Remove modules not compiled by this branch's release build
Lts/Common: drop the 17 submodules excluded from the RELEASE_BUILD branch of Lts/Common/CMakeLists.txt (CodeGen, LtsAppManager, LtsBotan, LtsCoordinate, LtsElevation, LtsLogin, LtsMultiMonitor, LtsPluginManager, LtsPrinting, LtsProjectionWorkstation, LtsScriptTimeline, LtsSession, LtsTimeline, LtsTimelineClassic, LtsVirtualKeyboard, LtsWidgets, TopicEditorBase). Only the 13 subdirectories actually built remain. TrainingAreaBase: drop sources of targets excluded by IF(NOT RELEASE_BUILD) / IF(BUILD_RTI) (svcTabClient, svcTabServer, svcTrainingAreaBase exe, RecordReplayPlugin customization) and the 7 plugin directories not added in the release path (AdlerJson, ApacheHlaJson, DebugJsonDir, HlaJson, Nmea, UAS, WlsTetra). Only tabTelegrams, svcTabCommon and the TetraJson plugin are compiled. Cross-checked: no kept compiled source includes headers from the removed modules (GuiPluginInterface - the only LtsWidgets consumer - is itself NOT RELEASE_BUILD-guarded).
This commit is contained in:
1 parent
eb4d067365
commit
855b0a6101
765 files changed
-128732
No files matched your search
@@ -1,30 +0,0 @@
|
||||
#
|
||||
# $Id$
|
||||
# $HeadURL$
|
||||
# $Author$
|
||||
#
|
||||
|
||||
NGL_ADD_LIBRARY2(WS SV HLA LtsCoordinate SHARED
|
||||
lts_coordinate.h
|
||||
lts_coordinate.cpp
|
||||
lts_coord_vector.h
|
||||
lts_coord_vector.cpp
|
||||
)
|
||||
NGL_TARGET_INCLUDE_DIRECTORIES(LtsCoordinate
|
||||
INTERFACE
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/../
|
||||
)
|
||||
NGL_TARGET_INCLUDE_DIRECTORIES(LtsCoordinate
|
||||
PRIVATE
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/../LtsCoordTrans
|
||||
)
|
||||
NGL_TARGET_LINK_LIBRARIES(LtsCoordinate
|
||||
PRIVATE
|
||||
LtsCoordTrans
|
||||
PUBLIC
|
||||
$<IF:$<TARGET_EXISTS:ddscore>,ddscore,>
|
||||
LtsUtilsCoreHeaderOnly
|
||||
Qt6::Core
|
||||
)
|
||||
|
||||
ADD_SUBDIRECTORY(UnitTest_Coordinate)
|
||||
-38
@@ -1,38 +0,0 @@
|
||||
#
|
||||
# @RDE_HEADER@
|
||||
# $Id$
|
||||
# $HeadURL$
|
||||
# $Author$
|
||||
#
|
||||
|
||||
# Make ${Qt6_Gui} optional
|
||||
if(QT6_GUI_AVAILABLE AND TARGET Qt6::Gui)
|
||||
set(Qt6_Gui ${Qt6_Gui})
|
||||
else()
|
||||
set(Qt6_Gui "")
|
||||
endif()
|
||||
|
||||
|
||||
SET(UnitTestSources
|
||||
lts_coordinate_unit_test.cpp
|
||||
lts_coordinate_unit_test.h
|
||||
)
|
||||
|
||||
IF(BUILD_TESTING AND TARGET LtsElevation)
|
||||
ADD_EXECUTABLE(commonUnitTestCoordinate ${LinkedSources} ${UnitTestSources} )
|
||||
|
||||
TARGET_LINK_LIBRARIES(commonUnitTestCoordinate
|
||||
NGLLogger
|
||||
nglcoreapplication
|
||||
LtsCoordinate
|
||||
LtsElevation
|
||||
LtsCoordTrans
|
||||
situationMapCommon
|
||||
situationMapElevationMap
|
||||
Qt6::Core
|
||||
${Qt6_Gui}
|
||||
Qt6::Test)
|
||||
|
||||
ADD_TEST(NAME commonUnitTestCoordinate COMMAND $<TARGET_FILE:commonUnitTestCoordinate>)
|
||||
|
||||
ENDIF()
|
||||
-868
@@ -1,868 +0,0 @@
|
||||
|
||||
|
||||
#include "lts_coordinate_unit_test.h"
|
||||
|
||||
#include <ElevationMap/elevation_map_manager.h>
|
||||
#include <LtsCoordTrans/lts_coord_trans.h>
|
||||
#include <LtsCoordinate/lts_coord_vector.h>
|
||||
#include <LtsCoordinate/lts_coordinate.h>
|
||||
#include <NGLLogger/NGLLoggerBootstrap.h>
|
||||
#include <QtTest/QTest>
|
||||
#include <nglapplication/nglcoreapplication.h>
|
||||
|
||||
Q_DECLARE_METATYPE(LtsUtils::QPoint3D);
|
||||
|
||||
#include <iomanip>
|
||||
#include <iostream>
|
||||
|
||||
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;
|
||||
}
|
||||
-60
@@ -1,60 +0,0 @@
|
||||
|
||||
|
||||
#pragma once
|
||||
#include <ElevationMap/elevation_map_manager.h>
|
||||
#include <LtsElevation/lts_elevation_manager.h>
|
||||
#include <NGLLogger/INGLLogger.h>
|
||||
#include <QtCore/QCoreApplication>
|
||||
#include <QtCore/QObject>
|
||||
#include <QtTest/QTest>
|
||||
|
||||
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:
|
||||
NGL::INGLLogger& m_logger;
|
||||
};
|
||||
@@ -1,69 +0,0 @@
|
||||
|
||||
|
||||
#include "lts_coord_vector.h"
|
||||
|
||||
namespace LtsCoordTrans
|
||||
{
|
||||
|
||||
LtsCoordVector::LtsCoordVector(const std::vector<Core::GeoPosition>& geo_coordinates)
|
||||
: m_geo_coordinates(geo_coordinates)
|
||||
{
|
||||
}
|
||||
|
||||
const std::vector<UtmCoordinate>& LtsCoordVector::toStdUtmCoord(int zone) const
|
||||
{
|
||||
convertGeoToStdUtm(zone);
|
||||
return m_utmMapStd[zone];
|
||||
}
|
||||
|
||||
const QVector<UtmCoordinate>& LtsCoordVector::toQVectorUtmCoord(int zone) const
|
||||
{
|
||||
convertGeoToQVectorUtm(zone);
|
||||
return m_utmMapQVector[zone];
|
||||
}
|
||||
|
||||
const QVector<QPointF>& LtsCoordVector::toQVectorQPointF(int zone) const
|
||||
{
|
||||
convertGeoToQVectorQPointF(zone);
|
||||
return m_utmMapQVectorQPointF[zone];
|
||||
}
|
||||
|
||||
void LtsCoordVector::convertGeoToStdUtm(int zone) const
|
||||
{
|
||||
const auto it = m_utmMapStd.find(zone);
|
||||
if (it != m_utmMapStd.end())
|
||||
return;
|
||||
convertGeoToUtmInternal(zone, m_utmMapStd[zone]);
|
||||
}
|
||||
|
||||
void LtsCoordVector::convertGeoToQVectorUtm(int zone) const
|
||||
{
|
||||
const auto it = m_utmMapQVector.find(zone);
|
||||
if (it != m_utmMapQVector.end())
|
||||
return;
|
||||
|
||||
convertGeoToStdUtm(zone);
|
||||
QVector<LtsCoordTrans::UtmCoordinate>& utmVectorRef = m_utmMapQVector[zone];
|
||||
utmVectorRef.clear();
|
||||
utmVectorRef.reserve(m_geo_coordinates.size());
|
||||
|
||||
for (const auto& utmCoord : m_utmMapStd[zone])
|
||||
utmVectorRef.push_back(utmCoord);
|
||||
}
|
||||
|
||||
void LtsCoordVector::convertGeoToQVectorQPointF(int zone) const
|
||||
{
|
||||
const auto it = m_utmMapQVectorQPointF.find(zone);
|
||||
if (it != m_utmMapQVectorQPointF.end())
|
||||
return;
|
||||
|
||||
convertGeoToStdUtm(zone);
|
||||
QVector<QPointF>& QVectorQPointFRef = m_utmMapQVectorQPointF[zone];
|
||||
QVectorQPointFRef.clear();
|
||||
QVectorQPointFRef.reserve(m_geo_coordinates.size());
|
||||
|
||||
for (const auto& utmCoord : m_utmMapStd[zone])
|
||||
QVectorQPointFRef.push_back(QPointF(utmCoord.x, utmCoord.y));
|
||||
}
|
||||
|
||||
} // namespace LtsCoordTrans
|
||||
@@ -1,62 +0,0 @@
|
||||
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <LtsCoordinate/ltscoordinate_export.h>
|
||||
|
||||
#include <Core/core.hpp>
|
||||
#include <LtsCoordTrans/lts_coord_trans.h>
|
||||
#include <QtCore/QDebug>
|
||||
#include <QtCore/QPointF>
|
||||
#include <QtCore/QVector>
|
||||
#include <iosfwd>
|
||||
#include <unordered_map>
|
||||
#include <utility>
|
||||
#include <vector>
|
||||
|
||||
namespace LtsCoordTrans
|
||||
{
|
||||
|
||||
class LTSCOORDINATE_EXPORT LtsCoordVector
|
||||
{
|
||||
public:
|
||||
explicit LtsCoordVector(const std::vector<Core::GeoPosition>& geo_coordinates);
|
||||
|
||||
int size() const
|
||||
{
|
||||
return m_geo_coordinates.size();
|
||||
}
|
||||
|
||||
const std::vector<Core::GeoPosition>& geoPosition() const
|
||||
{
|
||||
return m_geo_coordinates;
|
||||
}
|
||||
|
||||
const std::vector<LtsCoordTrans::UtmCoordinate>& toStdUtmCoord(int zone) const;
|
||||
const QVector<LtsCoordTrans::UtmCoordinate>& toQVectorUtmCoord(int zone) const;
|
||||
const QVector<QPointF>& toQVectorQPointF(int zone) const;
|
||||
|
||||
protected:
|
||||
void convertGeoToStdUtm(int zone) const;
|
||||
void convertGeoToQVectorUtm(int zone) const;
|
||||
void convertGeoToQVectorQPointF(int zone) const;
|
||||
|
||||
template <typename T> void convertGeoToUtmInternal(int zone, T& utmVectorRef) const
|
||||
{
|
||||
|
||||
utmVectorRef.clear();
|
||||
utmVectorRef.reserve(m_geo_coordinates.size());
|
||||
|
||||
for (const auto& geoCoord : std::as_const(m_geo_coordinates))
|
||||
utmVectorRef.push_back(LtsCoordTrans::UtmCoordinate::fromGeographic(geoCoord.lon, geoCoord.lat, zone));
|
||||
}
|
||||
|
||||
protected:
|
||||
std::vector<Core::GeoPosition> m_geo_coordinates;
|
||||
|
||||
mutable std::unordered_map<int, std::vector<LtsCoordTrans::UtmCoordinate>> m_utmMapStd;
|
||||
mutable std::unordered_map<int, QVector<LtsCoordTrans::UtmCoordinate>> m_utmMapQVector;
|
||||
mutable std::unordered_map<int, QVector<QPointF>> m_utmMapQVectorQPointF;
|
||||
};
|
||||
|
||||
} // namespace LtsCoordTrans
|
||||
@@ -1,143 +0,0 @@
|
||||
|
||||
|
||||
#include "lts_coordinate.h"
|
||||
|
||||
#include <QtCore/QLineF>
|
||||
#include <iomanip>
|
||||
|
||||
namespace LtsCoordTrans
|
||||
{
|
||||
|
||||
static long s_conversion_counter = 0;
|
||||
|
||||
std::function<double(double, double, double, bool*)> LtsCoordinate::m_getElevationCB;
|
||||
|
||||
void LtsCoordinate::setElevationCallback(const elevationCbFunc& elevationCB)
|
||||
{
|
||||
m_getElevationCB = elevationCB;
|
||||
}
|
||||
|
||||
bool LtsCoordinate::hasElevationCallback()
|
||||
{
|
||||
return m_getElevationCB != nullptr;
|
||||
}
|
||||
|
||||
double LtsCoordinate::elevationAt(double defaultElevation, bool* bIsCovered) const
|
||||
{
|
||||
|
||||
if (!bIsCovered)
|
||||
if (!std::isnan(m_elevation))
|
||||
return m_elevation;
|
||||
if (m_getElevationCB)
|
||||
m_elevation = m_getElevationCB(m_geo.lon, m_geo.lat, defaultElevation, bIsCovered);
|
||||
return m_elevation;
|
||||
}
|
||||
|
||||
void LtsCoordinate::setZValueAccordingElevation(double defaultElevation)
|
||||
{
|
||||
m_geo.z = elevationAt(defaultElevation);
|
||||
}
|
||||
|
||||
double LtsCoordinate::elevationAt(const LtsCoordinate& coordinate, double defaultElevation, bool* bIsCovered)
|
||||
{
|
||||
return coordinate.elevationAt(defaultElevation, bIsCovered);
|
||||
}
|
||||
|
||||
void LtsCoordinate::replaceZValueByElevationIfValue(double zValueToBeReplaced, double defaultElevation)
|
||||
{
|
||||
|
||||
if ((std::isnan(zValueToBeReplaced) && std::isnan(m_geo.z)) || qFuzzyCompare(m_geo.z, zValueToBeReplaced))
|
||||
setZValueAccordingElevation(defaultElevation);
|
||||
}
|
||||
|
||||
double LtsCoordinate::angleDegreeUtm2D(const LtsCoordinate& coord1, const LtsCoordinate& coord2)
|
||||
{
|
||||
const LtsCoordTrans::UtmCoordinate& utm1 = coord1.utmCoordinate();
|
||||
const LtsCoordTrans::UtmCoordinate& utm2 = coord2.utmCoordinateDiffZone(utm1.zone);
|
||||
|
||||
const QPointF& offsetUtm = utm2.toPoint() - utm1.toPoint();
|
||||
QLineF poly(QPointF(), offsetUtm);
|
||||
const double angle = poly.angle();
|
||||
|
||||
return fmod(angle + 90.0, 360);
|
||||
}
|
||||
|
||||
const UtmCoordinate& LtsCoordinate::utmCoordinateInternal(int zone) const
|
||||
{
|
||||
if (zone == -1)
|
||||
{
|
||||
if (!hasUtm())
|
||||
convertGeoToUtm();
|
||||
return m_utm2D;
|
||||
}
|
||||
utmCoordinateDiffZone(zone);
|
||||
return m_utm2D_differentZone;
|
||||
}
|
||||
|
||||
void LtsCoordinate::convertGeoToUtm() const
|
||||
{
|
||||
|
||||
int zone = -1;
|
||||
|
||||
if (std::isnan(m_geo.lon) || std::isnan(m_geo.lat))
|
||||
{
|
||||
fprintf(stderr, "Error while fromGeographic, value is NaN\n");
|
||||
m_utm2D = LtsCoordTrans::UtmCoordinate();
|
||||
return;
|
||||
}
|
||||
|
||||
#ifdef LTS_DEBUG
|
||||
++s_conversion_counter;
|
||||
#endif
|
||||
|
||||
m_utm2D = LtsCoordTrans::UtmCoordinate::fromGeographic(m_geo.lon, m_geo.lat, zone);
|
||||
Q_ASSERT_X(m_utm2D.zone > 0, "LtsCoordinate", "zone has to be set");
|
||||
}
|
||||
|
||||
QString LtsCoordinate::mgrs(int prec, bool withSpaces) const
|
||||
{
|
||||
utmCoordinateInternal();
|
||||
QString tmp = m_utm2D.mgrs(prec, withSpaces);
|
||||
return tmp;
|
||||
}
|
||||
|
||||
QString LtsCoordinate::mgrsWithZ(int prec, bool withSpaces) const
|
||||
{
|
||||
double ele = elevationAt();
|
||||
QString tmp = mgrs(prec, withSpaces) + QStringLiteral(" z=") + QString::number(ele, 'f', 2);
|
||||
return tmp;
|
||||
}
|
||||
|
||||
QString LtsCoordinate::toString(bool fullAndExpensive) const
|
||||
{
|
||||
if (fullAndExpensive)
|
||||
{
|
||||
utmCoordinateInternal();
|
||||
elevationAt();
|
||||
}
|
||||
std::ostringstream stream;
|
||||
stream << "LtsCoordinate(m_geo=" << m_geo << ", m_utm2D.x " << m_utm2D.x << ", m_utm2D.y " << m_utm2D.y
|
||||
<< ", m_utm2D.zone " << m_utm2D.zone;
|
||||
if (!qFuzzyIsNull(m_utm2D.x) || !qFuzzyIsNull(m_utm2D.y))
|
||||
stream << ", m_utm2D.mgrs '" << m_utm2D.mgrs().toUtf8().constData() << "'";
|
||||
stream << ", elevation " << std::fixed << std::setprecision(3) << m_elevation << ")";
|
||||
return QString::fromStdString(stream.str());
|
||||
}
|
||||
|
||||
void LtsCoordinate::resetConversionCounter()
|
||||
{
|
||||
s_conversion_counter = 0;
|
||||
}
|
||||
|
||||
long LtsCoordinate::getConversionCounter()
|
||||
{
|
||||
return s_conversion_counter;
|
||||
}
|
||||
|
||||
std::ostream& operator<<(std::ostream& stream, const LtsCoordinate& value)
|
||||
{
|
||||
stream << value.toString().toStdString();
|
||||
return stream;
|
||||
}
|
||||
|
||||
} // namespace LtsCoordTrans
|
||||
@@ -1,297 +0,0 @@
|
||||
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <LtsCoordinate/ltscoordinate_export.h>
|
||||
|
||||
#include <Core/core.hpp>
|
||||
#include <LtsCoordTrans/lts_coord_trans.h>
|
||||
#include <LtsUtils/LtsUtilsCore/qpoint3d.h>
|
||||
#include <QtCore/QDebug>
|
||||
#include <QtCore/QPointF>
|
||||
#include <functional>
|
||||
#include <iosfwd>
|
||||
#include <type_traits>
|
||||
#include <utility>
|
||||
|
||||
namespace LtsCoordTrans
|
||||
{
|
||||
|
||||
using UtmCoordinate2D = LtsCoordTrans::UtmCoordinate;
|
||||
using QPoint3D = LtsUtils::QPoint3D;
|
||||
|
||||
class LTSCOORDINATE_EXPORT LtsCoordinate
|
||||
{
|
||||
public:
|
||||
explicit LtsCoordinate(double lon = 0, double lat = 0, double z = std::nan(""))
|
||||
: m_geo(Core::GeoPosition(lon, lat, z))
|
||||
{
|
||||
}
|
||||
|
||||
explicit LtsCoordinate(const QPointF& lonLat, double z = std::nan(""))
|
||||
: m_geo(Core::GeoPosition(lonLat.x(), lonLat.y(), z))
|
||||
{
|
||||
}
|
||||
|
||||
explicit LtsCoordinate(const Core::GeoPosition& geoPos) : m_geo(geoPos) {}
|
||||
|
||||
explicit LtsCoordinate(const Core::GeoPosition2D& geoPos2D) : m_geo(geoPos2D.lon, geoPos2D.lat, std::nan("")) {}
|
||||
|
||||
LtsCoordinate(const LtsCoordTrans::UtmCoordinate& utm2D, double zValue) = delete;
|
||||
|
||||
static LtsCoordinate fromGeoPosition(double lon, double lat, double z = std::nan(""))
|
||||
{
|
||||
return LtsCoordinate(lon, lat, z);
|
||||
}
|
||||
|
||||
static LtsCoordinate fromUtmCoordinate(const LtsCoordTrans::UtmCoordinate& utm2D, double zValue)
|
||||
{
|
||||
Q_ASSERT_X(utm2D.zone > 0, "LtsCoordinate", "zone has to be set");
|
||||
|
||||
const QPointF& geoPnt = utm2D.geographic();
|
||||
|
||||
return LtsCoordinate(geoPnt.x(), geoPnt.y(), zValue);
|
||||
}
|
||||
|
||||
static LtsCoordinate fromUtm(const QPointF& utm2d, int zone, double zValue)
|
||||
{
|
||||
const LtsCoordTrans::UtmCoordinate utmCoord(zone, utm2d.x(), utm2d.y());
|
||||
const QPointF& geoPnt = utmCoord.geographic();
|
||||
return LtsCoordinate(geoPnt.x(), geoPnt.y(), zValue);
|
||||
}
|
||||
|
||||
bool isValid() const
|
||||
{
|
||||
return hasGeo() || hasUtm();
|
||||
}
|
||||
|
||||
bool hasGeo() const
|
||||
{
|
||||
return !(valueIsNullOrNan(m_geo.lon) || valueIsNullOrNan(m_geo.lat));
|
||||
}
|
||||
|
||||
bool hasUtm() const
|
||||
{
|
||||
return m_utm2D.isValid();
|
||||
}
|
||||
|
||||
static bool valueIsNullOrNan(double value)
|
||||
{
|
||||
return qFuzzyIsNull(value) || std::isnan(value);
|
||||
}
|
||||
|
||||
QString mgrs(int prec = 5, bool withSpaces = true) const;
|
||||
QString mgrsWithZ(int prec = 5, bool withSpaces = true) const;
|
||||
|
||||
QString toString(bool fullAndExpensive = false) const;
|
||||
|
||||
static void resetConversionCounter();
|
||||
static long getConversionCounter();
|
||||
|
||||
const Core::GeoPosition& geoPosition() const
|
||||
{
|
||||
return m_geo;
|
||||
}
|
||||
|
||||
Core::GeoPosition2D geoPosition2D() const
|
||||
{
|
||||
return Core::GeoPosition2D(m_geo.lon, m_geo.lat);
|
||||
}
|
||||
|
||||
const LtsCoordTrans::UtmCoordinate& utmCoordinate() const
|
||||
{
|
||||
if (!hasUtm())
|
||||
convertGeoToUtm();
|
||||
return m_utm2D;
|
||||
}
|
||||
|
||||
double& rz()
|
||||
{
|
||||
return m_geo.z;
|
||||
}
|
||||
|
||||
double z() const
|
||||
{
|
||||
return m_geo.z;
|
||||
}
|
||||
|
||||
void setZ(double value)
|
||||
{
|
||||
m_geo.z = value;
|
||||
}
|
||||
|
||||
LtsCoordTrans::UtmCoordinate utmCoordinateDiffZone(int zone) const
|
||||
{
|
||||
|
||||
m_utm2D_differentZone = LtsCoordTrans::UtmCoordinate::fromGeographic(m_geo.lon, m_geo.lat, zone);
|
||||
return m_utm2D_differentZone;
|
||||
}
|
||||
|
||||
template <typename T> T toUtm(int zone = -1) const
|
||||
{
|
||||
T obj;
|
||||
helperToUtm(obj, zone);
|
||||
return obj;
|
||||
}
|
||||
|
||||
QPointF toUtmPointF() const
|
||||
{
|
||||
return toUtm<QPointF>();
|
||||
}
|
||||
|
||||
QPoint3D toUtmPoint3D() const
|
||||
{
|
||||
return toUtm<QPoint3D>();
|
||||
}
|
||||
|
||||
QPointF toGeoPointF() const
|
||||
{
|
||||
return QPointF(m_geo.lon, m_geo.lat);
|
||||
}
|
||||
|
||||
QPoint3D toGeoPoint3D() const
|
||||
{
|
||||
return QPoint3D(m_geo.lon, m_geo.lat, m_geo.z);
|
||||
}
|
||||
|
||||
UtmCoordinate3D toUtmCoordinate3D() const
|
||||
{
|
||||
return UtmCoordinate3D(utmCoordinate(), m_geo.z);
|
||||
}
|
||||
|
||||
using elevationCbFunc = std::function<double(double, double, double, bool*)>;
|
||||
|
||||
static void setElevationCallback(const elevationCbFunc& elevationCB);
|
||||
static bool hasElevationCallback();
|
||||
|
||||
double elevationAt(double defaultElevation = 0.0, bool* bIsCovered = nullptr) const;
|
||||
void setZValueAccordingElevation(double defaultElevation = 0.0);
|
||||
|
||||
static double elevationAt(const LtsCoordinate& coordinate, double defaultElevation = 0.0,
|
||||
bool* bIsCovered = nullptr);
|
||||
|
||||
void replaceZValueByElevationIfValue(double zValueToBeReplaced = std::nan(""), double defaultElevation = 0.0);
|
||||
|
||||
double heightOverElevation() const
|
||||
{
|
||||
return m_geo.z - elevationAt();
|
||||
}
|
||||
|
||||
double distanceUtm2D(const LtsCoordinate& other) const
|
||||
{
|
||||
|
||||
const LtsCoordTrans::UtmCoordinate& thisUtm2D = utmCoordinate();
|
||||
const LtsCoordTrans::UtmCoordinate& otherUtm2D = other.utmCoordinateDiffZone(m_utm2D.zone);
|
||||
return LtsCoordTrans::distance(thisUtm2D, otherUtm2D);
|
||||
}
|
||||
|
||||
double distanceUtm3D(const LtsCoordinate& other) const
|
||||
{
|
||||
|
||||
const QPoint3D& thisUtm3D = toUtm<QPoint3D>();
|
||||
const QPoint3D& otherUtm3D = other.toUtm<QPoint3D>(m_utm2D.zone);
|
||||
const double dist3D = (thisUtm3D - otherUtm3D).length();
|
||||
|
||||
Q_ASSERT_X(!std::isnan(dist3D), "LtsCoordinate", "ERROR, distance3D is NaN");
|
||||
|
||||
return dist3D;
|
||||
}
|
||||
|
||||
static double angleDegreeUtm2D(const LtsCoordinate& coord1, const LtsCoordinate& coord2);
|
||||
|
||||
protected:
|
||||
void clearGeo() const
|
||||
{
|
||||
clearGeoLonLat();
|
||||
m_geo.z = std::nan("");
|
||||
}
|
||||
|
||||
void clearGeoLonLat() const
|
||||
{
|
||||
m_geo.lon = 0;
|
||||
m_geo.lat = 0;
|
||||
}
|
||||
|
||||
void clearUtm() const
|
||||
{
|
||||
m_utm2D = m_utm2D_differentZone = UtmCoordinate2D();
|
||||
}
|
||||
|
||||
void clearElevation() const
|
||||
{
|
||||
m_elevation = std::nan("");
|
||||
}
|
||||
|
||||
void clear() const
|
||||
{
|
||||
clearGeo();
|
||||
clearUtm();
|
||||
clearElevation();
|
||||
}
|
||||
|
||||
const LtsCoordTrans::UtmCoordinate& utmCoordinateInternal(int zone = -1) const;
|
||||
void convertGeoToUtm() const;
|
||||
|
||||
protected:
|
||||
void helperToUtm(QPointF& pntRef, int zone = -1) const
|
||||
{
|
||||
const auto& utmTemp = utmCoordinateInternal(zone);
|
||||
pntRef.rx() = utmTemp.x;
|
||||
pntRef.ry() = utmTemp.y;
|
||||
}
|
||||
|
||||
void helperToUtm(QPoint3D& pntRef, int zone = -1) const
|
||||
{
|
||||
const auto& utmTemp = utmCoordinateInternal(zone);
|
||||
pntRef.rx() = utmTemp.x;
|
||||
pntRef.ry() = utmTemp.y;
|
||||
pntRef.rz() = m_geo.z;
|
||||
}
|
||||
|
||||
protected:
|
||||
mutable Core::GeoPosition m_geo;
|
||||
mutable UtmCoordinate2D m_utm2D;
|
||||
mutable UtmCoordinate2D m_utm2D_differentZone;
|
||||
mutable double m_elevation{std::nan("")};
|
||||
|
||||
static elevationCbFunc m_getElevationCB;
|
||||
};
|
||||
|
||||
class LTSCOORDINATE_EXPORT LtsCoordinateNoImplicitCopy : public LtsCoordinate
|
||||
{
|
||||
public:
|
||||
using BaseClass = LtsCoordinate;
|
||||
|
||||
LtsCoordinateNoImplicitCopy() = default;
|
||||
explicit LtsCoordinateNoImplicitCopy(const LtsCoordinateNoImplicitCopy&) = default;
|
||||
|
||||
~LtsCoordinateNoImplicitCopy() = default;
|
||||
|
||||
explicit LtsCoordinateNoImplicitCopy(const QPointF& lonLat, double z = std::nan(""))
|
||||
: BaseClass(Core::GeoPosition(lonLat.x(), lonLat.y(), z))
|
||||
{
|
||||
}
|
||||
|
||||
explicit LtsCoordinateNoImplicitCopy(const Core::GeoPosition& geoPos) : BaseClass(geoPos) {}
|
||||
|
||||
explicit LtsCoordinateNoImplicitCopy(const Core::GeoPosition2D& geoPos2D) : BaseClass(geoPos2D) {}
|
||||
|
||||
void updateGeoPosition(const Core::GeoPosition& geoPos) const
|
||||
{
|
||||
clear();
|
||||
m_geo = geoPos;
|
||||
}
|
||||
};
|
||||
|
||||
template <typename T_OUT, typename T_IN> T_OUT convert(const T_IN& contIn)
|
||||
{
|
||||
T_OUT out;
|
||||
out.reserve(contIn.size());
|
||||
for (const Core::GeoPosition& posGeo : std::as_const(contIn))
|
||||
out.push_back(LtsCoordinate(posGeo));
|
||||
return out;
|
||||
}
|
||||
|
||||
LTSCOORDINATE_EXPORT std::ostream& operator<<(std::ostream& stream, const LtsCoordinate& value);
|
||||
|
||||
} // namespace LtsCoordTrans
|
||||
Reference in new issue
Block a user