Apply clang-format to Lts/Common and DTC/enum headers

- Formatted all CodeGen module files (9 files)
- Formatted LtsAppDescriptor module files
- Formatted LtsAppManager/AppChooser files
- Applied clang-format to all DTC and enum headers across modules
- Removed coordTransTests from CommonUnitTestsPlaceholder (moved to tests/)

Cosmetic changes only, no functional modifications.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
This commit is contained in:
torstenandCopilot committed 2026-08-19 14:46:29 +02:00
1 parent 1881d68aef
commit d6b6ffce7c
848 files changed
+89305 -100020

No files matched your search

@@ -1,230 +1,198 @@
#include "elevation_unit_test.h"
#include <ElevationMap/elevation_map_manager.h>
#include <LtsCoordTrans/lts_coord_trans.h>
#include <nglapplication/nglcoreapplication.h>
#include <NGLLogger/NGLLoggerBootstrap.h>
#include <QtTest/QTest>
#include <nglapplication/nglcoreapplication.h>
Q_DECLARE_METATYPE(LtsUtils::QPoint3D);
Q_DECLARE_METATYPE(LtsElevation::LineOfSight);
#include <iostream>
static const int s_id{4711};
static LtsElevation::LtsElevationManager *s_eleMgr{nullptr};
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);
}
using BaseClass = LtsElevation::LtsElevationManager;
public:
static LtsElevationManager* createInstanceUnitTest(int id, const QStringList& filePaths_rough_to_fine)
{
return BaseClass::createInstanceUnitTest(id, filePaths_rough_to_fine);
}
};
UnitTestElevation::UnitTestElevation()
: m_logger(NGL::NGLLoggerBootstrap::getNGLRootLogger().getNGLLogger("UnitTestElevation"))
{}
: m_logger(NGL::NGLLoggerBootstrap::getNGLRootLogger().getNGLLogger("UnitTestElevation"))
{
}
void UnitTestElevation::initTestCase()
{
QString filePath(QStringLiteral("/usr/share/arcgis/resources/elevation/Altmark_dt1.tif"));
QString filePath(QStringLiteral("/usr/share/arcgis/resources/elevation/Altmark_dt1.tif"));
s_eleMgr = MyLtsElevationManagerBootstrap::createInstanceUnitTest(s_id, {filePath});
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;
}
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;
}
}
void UnitTestElevation::init()
{
QVERIFY2(s_eleMgr , "static LtsElevationManager does not exist");
QVERIFY2(s_eleMgr, "static LtsElevationManager does not exist");
}
void UnitTestElevation::test_elevation_data()
{
QTest::addColumn<QPointF>("lonLat");
QTest::addColumn<double>("elevationRef");
QTest::addColumn<QPointF>("lonLat");
QTest::addColumn<double>("elevationRef");
QTest::newRow("elevation 1 ") << LtsCoordTrans::UtmCoordinate::fromMgrs(QStringLiteral("32U PD 70000 10000")).geographic() << 75.0;
QTest::newRow("elevation 2 ") << LtsCoordTrans::UtmCoordinate::fromMgrs(QStringLiteral("32U PD 72000 13000")).geographic() << 80.0;
QTest::newRow("elevation 1 ")
<< LtsCoordTrans::UtmCoordinate::fromMgrs(QStringLiteral("32U PD 70000 10000")).geographic() << 75.0;
QTest::newRow("elevation 2 ")
<< LtsCoordTrans::UtmCoordinate::fromMgrs(QStringLiteral("32U PD 72000 13000")).geographic() << 80.0;
QTest::newRow("elevation 3 ") << LtsCoordTrans::UtmCoordinate::fromMgrs(QStringLiteral("32U PD 76925 18625")).geographic() << 92.0;
QTest::newRow("elevation 3 ")
<< LtsCoordTrans::UtmCoordinate::fromMgrs(QStringLiteral("32U PD 76925 18625")).geographic() << 92.0;
}
void UnitTestElevation::test_elevation()
{
QFETCH(QPointF, lonLat);
QFETCH(double, elevationRef);
QFETCH(QPointF, lonLat);
QFETCH(double, elevationRef);
double elevation = s_eleMgr->elevation(lonLat.x(), lonLat.y());
double elevation = s_eleMgr->elevation(lonLat.x(), lonLat.y());
QVERIFY2(qFuzzyCompare(elevationRef, elevation), " got wrong elevation result");
QVERIFY2(qFuzzyCompare(elevationRef, elevation), " got wrong elevation result");
}
void UnitTestElevation::test_elevation_isCovered()
{
const QPointF &lonLat1 = LtsCoordTrans::UtmCoordinate::fromMgrs(QStringLiteral("32U PD 70000 10000")).geographic();
const QPointF &lonLat2 = LtsCoordTrans::UtmCoordinate::fromMgrs(QStringLiteral("32U MD 60000 10000")).geographic();
const QPointF& lonLat1 = LtsCoordTrans::UtmCoordinate::fromMgrs(QStringLiteral("32U PD 70000 10000")).geographic();
const QPointF& lonLat2 = LtsCoordTrans::UtmCoordinate::fromMgrs(QStringLiteral("32U MD 60000 10000")).geographic();
const double defaultElevationValue = -123;
{
bool bIsCovered = false;
s_eleMgr->elevation(lonLat1.x(), lonLat1.y(), defaultElevationValue, &bIsCovered);
QVERIFY2(bIsCovered, " error on bIsCovered");
}
{
bool bIsCovered = true;
s_eleMgr->elevation(lonLat2.x(), lonLat2.y(), defaultElevationValue, &bIsCovered);
QVERIFY2(!bIsCovered, " error on bIsCovered");
}
const double defaultElevationValue = -123;
{
bool bIsCovered = false;
s_eleMgr->elevation(lonLat1.x(), lonLat1.y(), defaultElevationValue, &bIsCovered);
QVERIFY2(bIsCovered, " error on bIsCovered");
}
{
bool bIsCovered = true;
s_eleMgr->elevation(lonLat2.x(), lonLat2.y(), defaultElevationValue, &bIsCovered);
QVERIFY2(!bIsCovered, " error on bIsCovered");
}
}
void UnitTestElevation::test_elevation_defaultValue()
{
const QPointF &lonLat = LtsCoordTrans::UtmCoordinate::fromMgrs(QStringLiteral("32U PD 60000 10000")).geographic();
const QPointF& lonLat = LtsCoordTrans::UtmCoordinate::fromMgrs(QStringLiteral("32U PD 60000 10000")).geographic();
double elevation = s_eleMgr->elevation(lonLat.x(), lonLat.y());
QVERIFY2(qFuzzyCompare(elevation, std::numeric_limits<double>::min()), " error on defaultValue");
double elevation = s_eleMgr->elevation(lonLat.x(), lonLat.y());
QVERIFY2(qFuzzyCompare(elevation, std::numeric_limits<double>::min()), " error on defaultValue");
{
const double defaultValue = 100;
elevation = s_eleMgr->elevation(lonLat.x(), lonLat.y(), defaultValue);
QVERIFY2(qFuzzyCompare(elevation, defaultValue), " error on defaultValue");
}
{
const double defaultValue = 100;
elevation = s_eleMgr->elevation(lonLat.x(), lonLat.y(), defaultValue);
QVERIFY2(qFuzzyCompare(elevation, defaultValue), " error on defaultValue");
}
{
const double defaultValue = std::numeric_limits<double>::max();
elevation = s_eleMgr->elevation(lonLat.x(), lonLat.y(), defaultValue);
QVERIFY2(qFuzzyCompare(elevation, defaultValue), " error on defaultValue");
}
{
const double defaultValue = std::numeric_limits<double>::max();
elevation = s_eleMgr->elevation(lonLat.x(), lonLat.y(), defaultValue);
QVERIFY2(qFuzzyCompare(elevation, defaultValue), " error on defaultValue");
}
}
void UnitTestElevation::test_lineOfSightCalculation_data()
{
QTest::addColumn<QPointF>("startGeo2D");
QTest::addColumn<double>("startObjH");
QTest::addColumn<QPointF>("endGeo2D");
QTest::addColumn<double>("endObjH");
QTest::addColumn<LtsElevation::LineOfSight>("expectedResult");
QTest::addColumn<QPointF>("startGeo2D");
QTest::addColumn<double>("startObjH");
QTest::addColumn<QPointF>("endGeo2D");
QTest::addColumn<double>("endObjH");
QTest::addColumn<LtsElevation::LineOfSight>("expectedResult");
QTest::newRow("losDataset 1 ")
<< LtsCoordTrans::UtmCoordinate::fromMgrs(QStringLiteral("32U PD 60000 10000")).geographic() << 1.0
<< LtsCoordTrans::UtmCoordinate::fromMgrs(QStringLiteral("32U PD 60000 60000")).geographic() << 1.0
<< LtsElevation::LineOfSight::LOS_ERROR;
QTest::newRow("losDataset 1 ") << LtsCoordTrans::UtmCoordinate::fromMgrs(QStringLiteral("32U PD 60000 10000")).geographic() << 1.0
<< LtsCoordTrans::UtmCoordinate::fromMgrs(QStringLiteral("32U PD 60000 60000")).geographic() << 1.0
<< LtsElevation::LineOfSight::LOS_ERROR;
QTest::newRow("losDataset 2 ")
<< LtsCoordTrans::UtmCoordinate::fromMgrs(QStringLiteral("32U PD 77200 17600")).geographic() << 1.0
<< LtsCoordTrans::UtmCoordinate::fromMgrs(QStringLiteral("32U PD 77600 17600")).geographic() << 1.0
<< LtsElevation::LineOfSight::LOS_INVISIBLE;
QTest::newRow("losDataset 2 ") << LtsCoordTrans::UtmCoordinate::fromMgrs(QStringLiteral("32U PD 77200 17600")).geographic() << 1.0
<< LtsCoordTrans::UtmCoordinate::fromMgrs(QStringLiteral("32U PD 77600 17600")).geographic() << 1.0
<< LtsElevation::LineOfSight::LOS_INVISIBLE;
QTest::newRow("losDataset 3 ") << LtsCoordTrans::UtmCoordinate::fromMgrs(QStringLiteral("32U PD 77200 17600")).geographic() << 20.0
<< LtsCoordTrans::UtmCoordinate::fromMgrs(QStringLiteral("32U PD 77600 17600")).geographic() << 20.0
<< LtsElevation::LineOfSight::LOS_VISIBLE;
QTest::newRow("losDataset 4 ") << LtsCoordTrans::UtmCoordinate::fromMgrs(QStringLiteral("32U PD 77200 17600")).geographic() << -1.0
<< LtsCoordTrans::UtmCoordinate::fromMgrs(QStringLiteral("32U PD 77600 17600")).geographic() << 1.0
<< LtsElevation::LineOfSight::LOS_ERROR;
QTest::newRow("losDataset 5 ") << LtsCoordTrans::UtmCoordinate::fromMgrs(QStringLiteral("32U PD 77200 17600")).geographic() << 1.0
<< LtsCoordTrans::UtmCoordinate::fromMgrs(QStringLiteral("32U PD 77600 17600")).geographic() << -1.0
<< LtsElevation::LineOfSight::LOS_ERROR;
QTest::newRow("losDataset 6 ") << LtsCoordTrans::UtmCoordinate::fromMgrs(QStringLiteral("32U PD 77200 17600")).geographic() << 0.0
<< LtsCoordTrans::UtmCoordinate::fromMgrs(QStringLiteral("32U PD 77600 17600")).geographic() << 0.0
<< LtsElevation::LineOfSight::LOS_INVISIBLE;
QTest::newRow("losDataset 3 ")
<< LtsCoordTrans::UtmCoordinate::fromMgrs(QStringLiteral("32U PD 77200 17600")).geographic() << 20.0
<< LtsCoordTrans::UtmCoordinate::fromMgrs(QStringLiteral("32U PD 77600 17600")).geographic() << 20.0
<< LtsElevation::LineOfSight::LOS_VISIBLE;
QTest::newRow("losDataset 4 ")
<< LtsCoordTrans::UtmCoordinate::fromMgrs(QStringLiteral("32U PD 77200 17600")).geographic() << -1.0
<< LtsCoordTrans::UtmCoordinate::fromMgrs(QStringLiteral("32U PD 77600 17600")).geographic() << 1.0
<< LtsElevation::LineOfSight::LOS_ERROR;
QTest::newRow("losDataset 5 ")
<< LtsCoordTrans::UtmCoordinate::fromMgrs(QStringLiteral("32U PD 77200 17600")).geographic() << 1.0
<< LtsCoordTrans::UtmCoordinate::fromMgrs(QStringLiteral("32U PD 77600 17600")).geographic() << -1.0
<< LtsElevation::LineOfSight::LOS_ERROR;
QTest::newRow("losDataset 6 ")
<< LtsCoordTrans::UtmCoordinate::fromMgrs(QStringLiteral("32U PD 77200 17600")).geographic() << 0.0
<< LtsCoordTrans::UtmCoordinate::fromMgrs(QStringLiteral("32U PD 77600 17600")).geographic() << 0.0
<< LtsElevation::LineOfSight::LOS_INVISIBLE;
}
void UnitTestElevation::test_lineOfSightCalculation()
{
QFETCH(QPointF, startGeo2D);
QFETCH(double, startObjH);
QFETCH(QPointF, endGeo2D);
QFETCH(double, endObjH);
QFETCH(LtsElevation::LineOfSight, expectedResult);
QFETCH(QPointF, startGeo2D);
QFETCH(double, startObjH);
QFETCH(QPointF, endGeo2D);
QFETCH(double, endObjH);
QFETCH(LtsElevation::LineOfSight, expectedResult);
LtsUtils::QPoint3D start3D = LtsUtils::QPoint3D::fromQPointF(startGeo2D);
start3D.rz() = startObjH;
start3D.rz() += s_eleMgr->elevation(start3D.x(), start3D.y());
LtsUtils::QPoint3D start3D = LtsUtils::QPoint3D::fromQPointF(startGeo2D);
start3D.rz() = startObjH;
start3D.rz() += s_eleMgr->elevation(start3D.x(), start3D.y());
LtsUtils::QPoint3D end3D = LtsUtils::QPoint3D::fromQPointF(endGeo2D);
end3D.rz() = endObjH;
end3D.rz() += s_eleMgr->elevation(end3D.x(), end3D.y());
LtsUtils::QPoint3D end3D = LtsUtils::QPoint3D::fromQPointF(endGeo2D);
end3D.rz() = endObjH;
end3D.rz() += s_eleMgr->elevation(end3D.x(), end3D.y());
LtsElevation::LineOfSight los = s_eleMgr->lineOfSightCalculation(start3D, end3D);
NOTICE_LOG(m_logger) << "los = " << los;
LtsElevation::LineOfSight los = s_eleMgr->lineOfSightCalculation(start3D, end3D);
NOTICE_LOG(m_logger) << "los = " << los;
{
LtsElevation::LineOfSight los2 = s_eleMgr->lineOfSightCalculation(startGeo2D, startObjH,
endGeo2D, endObjH);
QVERIFY2(los == los2, " got different lineOfSightCalculation result");
}
{
LtsElevation::LineOfSight los2 = s_eleMgr->lineOfSightCalculation(startGeo2D, startObjH, endGeo2D, endObjH);
QVERIFY2(los == los2, " got different lineOfSightCalculation result");
}
QVERIFY2(los == expectedResult, " got lineOfSightCalculation result");
QVERIFY2(los == expectedResult, " got lineOfSightCalculation result");
}
int main(int argc, char *argv[])
int main(int argc, char* argv[])
{
NGLCoreApplication app(argc, argv);
app.createLogger("UnitTestElevation", "log4cxxElevationUnitTest.props");
NGLCoreApplication app(argc, argv);
app.createLogger("UnitTestElevation", "log4cxxElevationUnitTest.props");
UnitTestElevation tc;
UnitTestElevation tc;
int ret = QTest::qExec(&tc, argc, argv);
int ret = QTest::qExec(&tc, argc, argv);
if (s_eleMgr)
{
s_eleMgr->cleanupAll();
}
if (s_eleMgr)
{
s_eleMgr->cleanupAll();
}
return ret;
return ret;
}
@@ -1,61 +1,38 @@
#pragma once
#include <QObject>
#include <LtsElevation/lts_elevation_manager.h>
#include <ElevationMap/elevation_map_manager.h>
#include <QCoreApplication>
#include <QtTest/QTest>
#include <LtsElevation/lts_elevation_manager.h>
#include <NGLLogger/INGLLogger.h>
#include <QCoreApplication>
#include <QObject>
#include <QtTest/QTest>
using LOGGER_T = NGL::INGLLogger&;
class UnitTestElevation : public QObject
{
Q_OBJECT
Q_OBJECT
public:
UnitTestElevation();
public:
UnitTestElevation();
private Q_SLOTS:
private Q_SLOTS:
void initTestCase();
void init();
void test_elevation_data();
void test_elevation();
void initTestCase();
void test_elevation_isCovered();
void test_elevation_defaultValue();
void init();
void test_lineOfSightCalculation_data();
void test_lineOfSightCalculation();
void test_elevation_data();
void test_elevation();
void test_elevation_isCovered();
void test_elevation_defaultValue();
void test_lineOfSightCalculation_data();
void test_lineOfSightCalculation();
private:
NGL::INGLLogger &m_logger;
private:
NGL::INGLLogger& m_logger;
};
+17 -19
View File
@@ -1,6 +1,5 @@
#include "logger.h"
#include <NGLLogger/NGLLoggerBootstrap.h>
@@ -8,25 +7,24 @@
namespace LtsElevation
{
LOGGER_T getLogger(const char *name)
LOGGER_T getLogger(const char* name)
{
static const char ns[] = "Lts.Elevation.";
std::string loggerName;
const size_t len = strlen(name);
loggerName.reserve(sizeof(ns) + len);
loggerName.append(ns, sizeof(ns) - 1);
loggerName.append(name, len);
static const char ns[] = "Lts.Elevation.";
std::string loggerName;
const size_t len = strlen(name);
loggerName.reserve(sizeof(ns) + len);
loggerName.append(ns, sizeof(ns) - 1);
loggerName.append(name, len);
try
{
return NGL::NGLLoggerBootstrap::getNGLRootLogger().
getNGLLogger(loggerName);
}
catch (const std::exception &ex)
{
fprintf(stderr, "Error retrieving logger: %s", ex.what());
abort();
}
try
{
return NGL::NGLLoggerBootstrap::getNGLRootLogger().getNGLLogger(loggerName);
}
catch (const std::exception& ex)
{
fprintf(stderr, "Error retrieving logger: %s", ex.what());
abort();
}
}
}
} // namespace LtsElevation
+6 -7
View File
@@ -1,18 +1,17 @@
#pragma once
#include <NGLLogger/INGLLogger.h>
namespace LtsElevation
{
typedef NGL::INGLLogger &LOGGER_T;
typedef NGL::INGLLogger& LOGGER_T;
LOGGER_T getLogger(const char *name);
inline LOGGER_T getLogger(const QString &loggerName)
LOGGER_T getLogger(const char* name);
inline LOGGER_T getLogger(const QString& loggerName)
{
return getLogger(loggerName.toUtf8().constData());
return getLogger(loggerName.toUtf8().constData());
}
}
} // namespace LtsElevation
+321 -359
View File
@@ -1,510 +1,472 @@
#include "lts_elevation_manager.h"
#include <utility>
#include <Plugins/ExerciseManagement/exm_data_plugin_interface.h>
#include <Plugins/AssetManagement/asm_data_plugin_interface.h>
#include <Viewer/SituationMap/ElevationMap/elevation_map_manager.h>
#include <Viewer/SituationMap/Common/resource_path.h>
#include <QSharedPointer>
#include <Plugins/ExerciseManagement/exm_data_plugin_interface.h>
#include <QDir>
#include <QUrl>
#include <QHash>
#include <QSharedPointer>
#include <QUrl>
#include <Viewer/SituationMap/Common/resource_path.h>
#include <Viewer/SituationMap/ElevationMap/elevation_map_manager.h>
#include <utility>
static_assert((int)SituationMap::ElevationMapManager::LineOfSight::LOS_UNDEFINED == (int)LtsElevation::LineOfSight::LOS_UNDEFINED, "LineOfSight mismatch");
static_assert((int)SituationMap::ElevationMapManager::LineOfSight::LOS_ERROR == (int)LtsElevation::LineOfSight::LOS_ERROR, "LineOfSight mismatch");
static_assert((int)SituationMap::ElevationMapManager::LineOfSight::LOS_VISIBLE == (int)LtsElevation::LineOfSight::LOS_VISIBLE, "LineOfSight mismatch");
static_assert((int)SituationMap::ElevationMapManager::LineOfSight::LOS_INVISIBLE == (int)LtsElevation::LineOfSight::LOS_INVISIBLE, "LineOfSight mismatch");
static_assert((int)SituationMap::ElevationMapManager::LineOfSight::LOS_UNDEFINED ==
(int)LtsElevation::LineOfSight::LOS_UNDEFINED,
"LineOfSight mismatch");
static_assert((int)SituationMap::ElevationMapManager::LineOfSight::LOS_ERROR ==
(int)LtsElevation::LineOfSight::LOS_ERROR,
"LineOfSight mismatch");
static_assert((int)SituationMap::ElevationMapManager::LineOfSight::LOS_VISIBLE ==
(int)LtsElevation::LineOfSight::LOS_VISIBLE,
"LineOfSight mismatch");
static_assert((int)SituationMap::ElevationMapManager::LineOfSight::LOS_INVISIBLE ==
(int)LtsElevation::LineOfSight::LOS_INVISIBLE,
"LineOfSight mismatch");
namespace LtsElevation
{
class LtsElevationManager;
using LtsElevatioMgrMapTrainingAreaId = QMap<int, LTS_ELEVATION_MANAGER_TYPE>;
using LtsElevatioMgrMapTrainingAreaId = QMap<int, LTS_ELEVATION_MANAGER_TYPE>;
static LtsElevatioMgrMapTrainingAreaId &ltsElevatioMgrMapTrainingAreaId()
static LtsElevatioMgrMapTrainingAreaId& ltsElevatioMgrMapTrainingAreaId()
{
static LtsElevatioMgrMapTrainingAreaId s_ltsElevatioMgrMapTrainingAreaId;
return s_ltsElevatioMgrMapTrainingAreaId;
static LtsElevatioMgrMapTrainingAreaId s_ltsElevatioMgrMapTrainingAreaId;
return s_ltsElevatioMgrMapTrainingAreaId;
}
static void cleanupLtsElevatioMgrMapTrainingAreaId()
{
qDeleteAll(ltsElevatioMgrMapTrainingAreaId());
ltsElevatioMgrMapTrainingAreaId().clear();
qDeleteAll(ltsElevatioMgrMapTrainingAreaId());
ltsElevatioMgrMapTrainingAreaId().clear();
}
LtsElevatioMgrMapTrainingAreaId &getLtsElevationMgrMapTrainingAreaId()
LtsElevatioMgrMapTrainingAreaId& getLtsElevationMgrMapTrainingAreaId()
{
if (ltsElevatioMgrMapTrainingAreaId().isEmpty())
qAddPostRoutine(cleanupLtsElevatioMgrMapTrainingAreaId);
if (ltsElevatioMgrMapTrainingAreaId().isEmpty())
qAddPostRoutine(cleanupLtsElevatioMgrMapTrainingAreaId);
return ltsElevatioMgrMapTrainingAreaId();
return ltsElevatioMgrMapTrainingAreaId();
}
static long s_counter{0};
class LtsElevationManager::Private
{
public:
Private() = default;
~Private()
{
delete m_elevationManager;
}
std::shared_ptr<ExerciseManagement::Interface::Dtc> m_exmDtc;
std::shared_ptr<AssetManagement::Interface::Dtc> m_asmDtc;
public:
Private() = default;
QStringList m_filePaths_rough_to_fine;
SituationMap::ElevationMapManager *m_elevationManager{nullptr};
~Private()
{
delete m_elevationManager;
}
std::shared_ptr<ExerciseManagement::Interface::Dtc> m_exmDtc;
std::shared_ptr<AssetManagement::Interface::Dtc> m_asmDtc;
QStringList m_filePaths_rough_to_fine;
SituationMap::ElevationMapManager* m_elevationManager{nullptr};
};
LtsElevationManager::LtsElevationManager()
: QObject(nullptr)
, d(new Private)
LtsElevationManager::LtsElevationManager() : QObject(nullptr), d(new Private)
{
++s_counter;
TRACE_LOG(m_logger) << Q_FUNC_INFO << " START, s_counter=" << s_counter << " this=" << this;
TRACE_LOG(m_logger) << Q_FUNC_INFO << " END, s_counter=" << s_counter << " this=" << this;
++s_counter;
TRACE_LOG(m_logger) << Q_FUNC_INFO << " START, s_counter=" << s_counter << " this=" << this;
TRACE_LOG(m_logger) << Q_FUNC_INFO << " END, s_counter=" << s_counter << " this=" << this;
}
LtsElevationManager::~LtsElevationManager()
{
--s_counter;
TRACE_LOG(m_logger) << Q_FUNC_INFO << " START, s_counter=" << s_counter << " this=" << this;
delete d;
TRACE_LOG(m_logger) << Q_FUNC_INFO << " END, s_counter=" << s_counter << " this=" << this;
--s_counter;
TRACE_LOG(m_logger) << Q_FUNC_INFO << " START, s_counter=" << s_counter << " this=" << this;
delete d;
TRACE_LOG(m_logger) << Q_FUNC_INFO << " END, s_counter=" << s_counter << " this=" << this;
}
LTS_ELEVATION_MANAGER_TYPE LtsElevationManager::createInstance(int exerciseId,
const std::shared_ptr<ExerciseManagement::Interface::Dtc> &exmDtc,
const std::shared_ptr<AssetManagement::Interface::Dtc> &asmDtc)
LTS_ELEVATION_MANAGER_TYPE
LtsElevationManager::createInstance(int exerciseId, const std::shared_ptr<ExerciseManagement::Interface::Dtc>& exmDtc,
const std::shared_ptr<AssetManagement::Interface::Dtc>& asmDtc)
{
LOGGER_T logger = getLogger("LtsElevationManager");
TRACE_LOG(logger) << Q_FUNC_INFO << " START, exerciseId=" << exerciseId;
LOGGER_T logger = getLogger("LtsElevationManager");
TRACE_LOG(logger) << Q_FUNC_INFO << " START, exerciseId=" << exerciseId;
if (exerciseId < 0)
{
ERROR_LOG(logger) << Q_FUNC_INFO << " exerciseId invalid, exerciseId=" << exerciseId;
return nullptr;
}
int trainingAreaId = -1;
static QHash<int,int> s_exIdToTaIdStore;
const auto exTaIt = s_exIdToTaIdStore.find(exerciseId);
if (exTaIt != s_exIdToTaIdStore.end())
{
trainingAreaId = *exTaIt;
} else {
if (!exmDtc || !asmDtc)
if (exerciseId < 0)
{
ERROR_LOG(logger) << Q_FUNC_INFO << " no dtcs for exerciseId=" << exerciseId
<< ", asmDtc=" << asmDtc
<< ", exmDtc=" << exmDtc;
return nullptr;
ERROR_LOG(logger) << Q_FUNC_INFO << " exerciseId invalid, exerciseId=" << exerciseId;
return nullptr;
}
trainingAreaId = exerciseIdToTrainingAreaId(exerciseId, exmDtc);
if (trainingAreaId <= 0)
int trainingAreaId = -1;
static QHash<int, int> s_exIdToTaIdStore;
const auto exTaIt = s_exIdToTaIdStore.find(exerciseId);
if (exTaIt != s_exIdToTaIdStore.end())
{
ERROR_LOG(logger) << Q_FUNC_INFO << " Error getting trainingAreaId"
<< ", exerciseId=" << exerciseId
<< ", trainingAreaId=" << trainingAreaId;
return nullptr;
trainingAreaId = *exTaIt;
}
else
{
if (!exmDtc || !asmDtc)
{
ERROR_LOG(logger) << Q_FUNC_INFO << " no dtcs for exerciseId=" << exerciseId << ", asmDtc=" << asmDtc
<< ", exmDtc=" << exmDtc;
return nullptr;
}
trainingAreaId = exerciseIdToTrainingAreaId(exerciseId, exmDtc);
if (trainingAreaId <= 0)
{
ERROR_LOG(logger) << Q_FUNC_INFO << " Error getting trainingAreaId"
<< ", exerciseId=" << exerciseId << ", trainingAreaId=" << trainingAreaId;
return nullptr;
}
s_exIdToTaIdStore[exerciseId] = trainingAreaId;
}
s_exIdToTaIdStore[exerciseId] = trainingAreaId;
LTS_ELEVATION_MANAGER_TYPE temp = createInstanceForTrainingAreaId(trainingAreaId, asmDtc);
if (!temp)
{
ERROR_LOG(logger) << Q_FUNC_INFO << " Error on createInstanceForTrainingAreaId"
<< ", exerciseId=" << exerciseId << ", trainingAreaId=" << trainingAreaId;
return nullptr;
}
}
temp->initDDS(exmDtc, asmDtc);
LTS_ELEVATION_MANAGER_TYPE temp = createInstanceForTrainingAreaId(trainingAreaId, asmDtc);
if (!temp)
{
ERROR_LOG(logger) << Q_FUNC_INFO << " Error on createInstanceForTrainingAreaId"
<< ", exerciseId=" << exerciseId
<< ", trainingAreaId=" << trainingAreaId;
return nullptr;
}
temp->initDDS(exmDtc, asmDtc);
TRACE_LOG(logger) << Q_FUNC_INFO << " END, exerciseId=" << exerciseId;
return temp;
TRACE_LOG(logger) << Q_FUNC_INFO << " END, exerciseId=" << exerciseId;
return temp;
}
LTS_ELEVATION_MANAGER_TYPE LtsElevationManager::getInstance(int exerciseId)
{
return LtsElevationManager::createInstance(exerciseId);
return LtsElevationManager::createInstance(exerciseId);
}
LTS_ELEVATION_MANAGER_TYPE LtsElevationManager::createInstanceForTrainingAreaId(int trainingAreaId,
const std::shared_ptr<AssetManagement::Interface::Dtc> &asmDtc)
LTS_ELEVATION_MANAGER_TYPE
LtsElevationManager::createInstanceForTrainingAreaId(int trainingAreaId,
const std::shared_ptr<AssetManagement::Interface::Dtc>& asmDtc)
{
LOGGER_T logger = getLogger("LtsElevationManager");
TRACE_LOG(logger) << Q_FUNC_INFO << " START, trainingAreaId=" << trainingAreaId;
LOGGER_T logger = getLogger("LtsElevationManager");
TRACE_LOG(logger) << Q_FUNC_INFO << " START, trainingAreaId=" << trainingAreaId;
if (trainingAreaId < 0)
{
ERROR_LOG(logger) << Q_FUNC_INFO << " trainingAreaId invalid, trainingAreaId=" << trainingAreaId;
return nullptr;
}
if (trainingAreaId < 0)
{
ERROR_LOG(logger) << Q_FUNC_INFO << " trainingAreaId invalid, trainingAreaId=" << trainingAreaId;
return nullptr;
}
LtsElevatioMgrMapTrainingAreaId& map = getLtsElevationMgrMapTrainingAreaId();
QMap<int, LTS_ELEVATION_MANAGER_TYPE>::iterator it = map.find(trainingAreaId);
LtsElevatioMgrMapTrainingAreaId &map = getLtsElevationMgrMapTrainingAreaId();
QMap<int, LTS_ELEVATION_MANAGER_TYPE>::iterator it = map.find(trainingAreaId);
if (it != map.end())
{
DEBUG_LOG(logger) << " LtsElevationMgrMap contains instances: " << map.size();
return it.value();
}
if (it != map.end())
{
DEBUG_LOG(logger) << " LtsElevationMgrMap contains instances: " << map.size();
return it.value();
}
if (!asmDtc)
{
ERROR_LOG(logger) << Q_FUNC_INFO << " no dtcs for trainingAreaId=" << trainingAreaId << ", asmDtc=" << asmDtc;
return nullptr;
}
if (!asmDtc)
{
ERROR_LOG(logger) << Q_FUNC_INFO << " no dtcs for trainingAreaId=" << trainingAreaId
<< ", asmDtc=" << asmDtc;
return nullptr;
}
LTS_ELEVATION_MANAGER_TYPE temp = new LtsElevationManager();
LTS_ELEVATION_MANAGER_TYPE temp = new LtsElevationManager();
temp->initDDS(nullptr, asmDtc);
temp->initDDS(nullptr, asmDtc);
const QStringList& filenames = temp->getFilenamesForTrainingArea(trainingAreaId);
if (filenames.isEmpty())
{
ERROR_LOG(logger) << Q_FUNC_INFO << " no filenames for trainingAreaId=" << trainingAreaId;
delete temp;
return nullptr;
}
const QStringList &filenames = temp->getFilenamesForTrainingArea(trainingAreaId);
if (filenames.isEmpty())
{
ERROR_LOG(logger) << Q_FUNC_INFO << " no filenames for trainingAreaId=" << trainingAreaId;
delete temp;
return nullptr;
}
bool bInitFilenames = temp->init(filenames);
if (!bInitFilenames)
{
ERROR_LOG(logger) << Q_FUNC_INFO << " bInitFilenames failed for trainingAreaId=" << trainingAreaId;
delete temp;
return nullptr;
}
bool bInitFilenames = temp->init(filenames);
if (!bInitFilenames)
{
ERROR_LOG(logger) << Q_FUNC_INFO << " bInitFilenames failed for trainingAreaId=" << trainingAreaId;
delete temp;
return nullptr;
}
map.insert(trainingAreaId, temp);
map.insert(trainingAreaId, temp);
DEBUG_LOG(logger) << " LtsElevationMgrMap contains instances now: " << map.size();
DEBUG_LOG(logger) << " LtsElevationMgrMap contains instances now: " << map.size();
TRACE_LOG(logger) << Q_FUNC_INFO << " END, trainingAreaId=" << trainingAreaId;
return map[trainingAreaId];
TRACE_LOG(logger) << Q_FUNC_INFO << " END, trainingAreaId=" << trainingAreaId;
return map[trainingAreaId];
}
LTS_ELEVATION_MANAGER_TYPE LtsElevationManager::createInstanceUnitTest(int id, const QStringList &filePaths_rough_to_fine)
LTS_ELEVATION_MANAGER_TYPE LtsElevationManager::createInstanceUnitTest(int id,
const QStringList& filePaths_rough_to_fine)
{
LOGGER_T logger = getLogger("LtsElevationManager");
LOGGER_T logger = getLogger("LtsElevationManager");
LtsElevatioMgrMapTrainingAreaId &map = getLtsElevationMgrMapTrainingAreaId();
QMap<int, LTS_ELEVATION_MANAGER_TYPE>::iterator it = map.find(id);
LtsElevatioMgrMapTrainingAreaId& map = getLtsElevationMgrMapTrainingAreaId();
QMap<int, LTS_ELEVATION_MANAGER_TYPE>::iterator it = map.find(id);
if (it != map.end())
{
DEBUG_LOG(logger) << " LtsElevationMgrMap contains instances: " << map.size();
return it.value();
}
if (it != map.end())
{
DEBUG_LOG(logger) << " LtsElevationMgrMap contains instances: " << map.size();
return it.value();
}
LTS_ELEVATION_MANAGER_TYPE temp = new LtsElevationManager();
LTS_ELEVATION_MANAGER_TYPE temp = new LtsElevationManager();
bool bInitFilenames = temp->init(filePaths_rough_to_fine);
if (!bInitFilenames)
{
ERROR_LOG(logger) << Q_FUNC_INFO << " bInitFilenames failed for id=" << id;
delete temp;
return nullptr;
}
bool bInitFilenames = temp->init(filePaths_rough_to_fine);
if (!bInitFilenames)
{
ERROR_LOG(logger) << Q_FUNC_INFO << " bInitFilenames failed for id=" << id;
delete temp;
return nullptr;
}
map.insert(id, temp);
map.insert(id, temp);
DEBUG_LOG(logger) << " LtsElevationMgrMap contains instances now: " << map.size();
DEBUG_LOG(logger) << " LtsElevationMgrMap contains instances now: " << map.size();
TRACE_LOG(logger) << Q_FUNC_INFO << " END, trainingAreaId=" << id;
return map[id];
TRACE_LOG(logger) << Q_FUNC_INFO << " END, trainingAreaId=" << id;
return map[id];
}
void LtsElevationManager::cleanupAll()
{
LOGGER_T logger = getLogger("LtsElevationManager");
TRACE_LOG(logger) << Q_FUNC_INFO << " START";
cleanupLtsElevatioMgrMapTrainingAreaId();
TRACE_LOG(logger) << Q_FUNC_INFO << " END";
LOGGER_T logger = getLogger("LtsElevationManager");
TRACE_LOG(logger) << Q_FUNC_INFO << " START";
cleanupLtsElevatioMgrMapTrainingAreaId();
TRACE_LOG(logger) << Q_FUNC_INFO << " END";
}
void LtsElevationManager::initDDS(const std::shared_ptr<ExerciseManagement::Interface::Dtc> &exmDtc, const std::shared_ptr<AssetManagement::Interface::Dtc> &asmDtc)
void LtsElevationManager::initDDS(const std::shared_ptr<ExerciseManagement::Interface::Dtc>& exmDtc,
const std::shared_ptr<AssetManagement::Interface::Dtc>& asmDtc)
{
TRACE_LOG(m_logger) << Q_FUNC_INFO << " START";
TRACE_LOG(m_logger) << Q_FUNC_INFO << " START";
d->m_exmDtc = exmDtc;
if (d->m_exmDtc)
d->m_exmDtc->waitForHistoricalDataExercise(1000);
d->m_exmDtc = exmDtc;
if (d->m_exmDtc)
d->m_exmDtc->waitForHistoricalDataExercise(1000);
d->m_asmDtc = asmDtc;
if (d->m_asmDtc)
d->m_asmDtc->waitForHistoricalDataTrainingArea(1000);
d->m_asmDtc = asmDtc;
if (d->m_asmDtc)
d->m_asmDtc->waitForHistoricalDataTrainingArea(1000);
TRACE_LOG(m_logger) << Q_FUNC_INFO << " END";
TRACE_LOG(m_logger) << Q_FUNC_INFO << " END";
}
QStringList LtsElevationManager::getFilenamesForExercise(int exerciseId)
{
TRACE_LOG(m_logger) << Q_FUNC_INFO << " START";
TRACE_LOG(m_logger) << Q_FUNC_INFO << " START";
if (!d->m_exmDtc || !d->m_asmDtc)
{
ERROR_LOG(m_logger) << Q_FUNC_INFO << " no dtcs"
<< ", exerciseId=" << exerciseId;
return {};
}
if (!d->m_exmDtc || !d->m_asmDtc)
{
ERROR_LOG(m_logger) << Q_FUNC_INFO << " no dtcs"
<< ", exerciseId=" << exerciseId;
return {};
}
int trainingAreaId = exerciseIdToTrainingAreaId(exerciseId, d->m_exmDtc);
if (trainingAreaId <= 0)
{
ERROR_LOG(m_logger) << Q_FUNC_INFO << " Error getting trainingAreaId"
<< ", exerciseId=" << exerciseId
<< ", trainingAreaId=" << trainingAreaId;
return {};
}
int trainingAreaId = exerciseIdToTrainingAreaId(exerciseId, d->m_exmDtc);
if (trainingAreaId <= 0)
{
ERROR_LOG(m_logger) << Q_FUNC_INFO << " Error getting trainingAreaId"
<< ", exerciseId=" << exerciseId << ", trainingAreaId=" << trainingAreaId;
return {};
}
QStringList filePaths_rough_to_fine = getFilenamesForTrainingArea(trainingAreaId);
QStringList filePaths_rough_to_fine = getFilenamesForTrainingArea(trainingAreaId);
TRACE_LOG(m_logger) << Q_FUNC_INFO << " END, filePaths_rough_to_fine=" << filePaths_rough_to_fine.join(QStringLiteral(";"));
return filePaths_rough_to_fine;
TRACE_LOG(m_logger) << Q_FUNC_INFO
<< " END, filePaths_rough_to_fine=" << filePaths_rough_to_fine.join(QStringLiteral(";"));
return filePaths_rough_to_fine;
}
QStringList LtsElevationManager::getFilenamesForTrainingArea(int trainingAreaId)
{
TRACE_LOG(m_logger) << Q_FUNC_INFO << " START";
TRACE_LOG(m_logger) << Q_FUNC_INFO << " START";
if (!d->m_asmDtc)
{
ERROR_LOG(m_logger) << Q_FUNC_INFO << " no dtcs"
<< ", trainingAreaId=" << trainingAreaId;
return {};
}
QStringList filePaths_rough_to_fine;
{
d->m_asmDtc->waitForHistoricalDataTrainingArea(1000);
const AssetManagement::TrainingArea &ta = d->m_asmDtc->trainingArea(trainingAreaId);
if (ta.id() != trainingAreaId)
if (!d->m_asmDtc)
{
ERROR_LOG(m_logger) << Q_FUNC_INFO << " Error on s_asmDtc->trainingArea"
<< ", trainingAreaId=" << trainingAreaId;
return {};
ERROR_LOG(m_logger) << Q_FUNC_INFO << " no dtcs"
<< ", trainingAreaId=" << trainingAreaId;
return {};
}
const std::vector<AssetManagement::MapDescription> &mdVec = ta.elevation();
filePaths_rough_to_fine.reserve(mdVec.size());
for (const AssetManagement::MapDescription &md : std::as_const(mdVec))
QStringList filePaths_rough_to_fine;
{
QUrl url(QString::fromStdString(md.url()));
QString filePathAbs = url.toLocalFile();
if (QDir::isRelativePath(filePathAbs))
filePathAbs = SituationMap::getResourcePath() + QStringLiteral("/elevation/") + filePathAbs;
d->m_asmDtc->waitForHistoricalDataTrainingArea(1000);
const AssetManagement::TrainingArea& ta = d->m_asmDtc->trainingArea(trainingAreaId);
if (ta.id() != trainingAreaId)
{
ERROR_LOG(m_logger) << Q_FUNC_INFO << " Error on s_asmDtc->trainingArea"
<< ", trainingAreaId=" << trainingAreaId;
return {};
}
const std::vector<AssetManagement::MapDescription>& mdVec = ta.elevation();
filePaths_rough_to_fine.reserve(mdVec.size());
filePaths_rough_to_fine.append(filePathAbs);
for (const AssetManagement::MapDescription& md : std::as_const(mdVec))
{
QUrl url(QString::fromStdString(md.url()));
QString filePathAbs = url.toLocalFile();
if (QDir::isRelativePath(filePathAbs))
filePathAbs = SituationMap::getResourcePath() + QStringLiteral("/elevation/") + filePathAbs;
filePaths_rough_to_fine.append(filePathAbs);
}
}
}
TRACE_LOG(m_logger) << Q_FUNC_INFO << " END, filePaths_rough_to_fine=" << filePaths_rough_to_fine.join(QStringLiteral(";"));
return filePaths_rough_to_fine;
TRACE_LOG(m_logger) << Q_FUNC_INFO
<< " END, filePaths_rough_to_fine=" << filePaths_rough_to_fine.join(QStringLiteral(";"));
return filePaths_rough_to_fine;
}
bool LtsElevationManager::init(const QStringList &filePaths_rough_to_fine)
bool LtsElevationManager::init(const QStringList& filePaths_rough_to_fine)
{
delete d->m_elevationManager;
delete d->m_elevationManager;
d->m_elevationManager = new SituationMap::ElevationMapManager();
int cnt = d->m_elevationManager->init(filePaths_rough_to_fine);
d->m_elevationManager = new SituationMap::ElevationMapManager();
int cnt = d->m_elevationManager->init(filePaths_rough_to_fine);
if (cnt != filePaths_rough_to_fine.size())
{
FATAL_LOG(m_logger) << Q_FUNC_INFO << " ERROR, not all files could be loaded !!!";
FATAL_LOG(m_logger) << Q_FUNC_INFO << " ERROR, not all files could be loaded !!!";
FATAL_LOG(m_logger) << Q_FUNC_INFO << " ERROR, not all files could be loaded !!!";
FATAL_LOG(m_logger) << Q_FUNC_INFO << " ERROR, not all files could be loaded !!!";
FATAL_LOG(m_logger) << Q_FUNC_INFO << " ERROR, not all files could be loaded !!!";
FATAL_LOG(m_logger) << Q_FUNC_INFO << " ERROR, not all files could be loaded !!!";
FATAL_LOG(m_logger) << Q_FUNC_INFO << " ERROR, not all files could be loaded !!!";
return false;
}
return true;
if (cnt != filePaths_rough_to_fine.size())
{
FATAL_LOG(m_logger) << Q_FUNC_INFO << " ERROR, not all files could be loaded !!!";
FATAL_LOG(m_logger) << Q_FUNC_INFO << " ERROR, not all files could be loaded !!!";
FATAL_LOG(m_logger) << Q_FUNC_INFO << " ERROR, not all files could be loaded !!!";
FATAL_LOG(m_logger) << Q_FUNC_INFO << " ERROR, not all files could be loaded !!!";
FATAL_LOG(m_logger) << Q_FUNC_INFO << " ERROR, not all files could be loaded !!!";
FATAL_LOG(m_logger) << Q_FUNC_INFO << " ERROR, not all files could be loaded !!!";
FATAL_LOG(m_logger) << Q_FUNC_INFO << " ERROR, not all files could be loaded !!!";
return false;
}
return true;
}
int LtsElevationManager::exerciseIdToTrainingAreaId(int exerciseId, const std::shared_ptr<ExerciseManagement::Interface::Dtc> &exmDtc)
int LtsElevationManager::exerciseIdToTrainingAreaId(int exerciseId,
const std::shared_ptr<ExerciseManagement::Interface::Dtc>& exmDtc)
{
LOGGER_T logger = getLogger("LtsElevationManager");
LOGGER_T logger = getLogger("LtsElevationManager");
if (!exmDtc)
{
ERROR_LOG(logger) << Q_FUNC_INFO << " no dtcs"
<< ", exerciseId=" << exerciseId;
return {};
}
int trainingAreaId = -1;
{
exmDtc->waitForHistoricalDataExercise(1000);
const ExerciseManagement::Exercise &exm = exmDtc->exercise(exerciseId);
if (exm.id() != exerciseId)
if (!exmDtc)
{
ERROR_LOG(logger) << Q_FUNC_INFO << " Error on m_exmDtc->exercise"
<< ", exerciseId=" << exerciseId;
return {};
ERROR_LOG(logger) << Q_FUNC_INFO << " no dtcs"
<< ", exerciseId=" << exerciseId;
return {};
}
trainingAreaId = exm.trainingAreaId();
if (trainingAreaId <= 0)
int trainingAreaId = -1;
{
ERROR_LOG(logger) << Q_FUNC_INFO << " Error getting trainingAreaId"
<< ", exerciseId=" << exerciseId
<< ", trainingAreaId=" << trainingAreaId;
return -1;
exmDtc->waitForHistoricalDataExercise(1000);
const ExerciseManagement::Exercise& exm = exmDtc->exercise(exerciseId);
if (exm.id() != exerciseId)
{
ERROR_LOG(logger) << Q_FUNC_INFO << " Error on m_exmDtc->exercise"
<< ", exerciseId=" << exerciseId;
return {};
}
trainingAreaId = exm.trainingAreaId();
if (trainingAreaId <= 0)
{
ERROR_LOG(logger) << Q_FUNC_INFO << " Error getting trainingAreaId"
<< ", exerciseId=" << exerciseId << ", trainingAreaId=" << trainingAreaId;
return -1;
}
}
}
return trainingAreaId;
return trainingAreaId;
}
bool LtsElevationManager::waitForInitialization()
{
if (!d->m_elevationManager)
return false;
return d->m_elevationManager->waitForInitialization();
if (!d->m_elevationManager)
return false;
return d->m_elevationManager->waitForInitialization();
}
bool LtsElevationManager::isValid() const
{
if (!d->m_elevationManager)
return false;
return d->m_elevationManager->isValid();
if (!d->m_elevationManager)
return false;
return d->m_elevationManager->isValid();
}
double LtsElevationManager::elevation(double lon_rad, double lat_rad, double defaultValue, bool *bIsCovered) const
double LtsElevationManager::elevation(double lon_rad, double lat_rad, double defaultValue, bool* bIsCovered) const
{
if (!d->m_elevationManager)
return defaultValue;
return d->m_elevationManager->elevation(lon_rad, lat_rad, defaultValue, bIsCovered);
if (!d->m_elevationManager)
return defaultValue;
return d->m_elevationManager->elevation(lon_rad, lat_rad, defaultValue, bIsCovered);
}
LineOfSight LtsElevationManager::lineOfSightCalculation(const LtsUtils::QPoint3D &startPointGeo_absZ,
const LtsUtils::QPoint3D &endPointGeo_absZ)
LineOfSight LtsElevationManager::lineOfSightCalculation(const LtsUtils::QPoint3D& startPointGeo_absZ,
const LtsUtils::QPoint3D& endPointGeo_absZ)
{
TRACE_LOG(m_logger) << Q_FUNC_INFO << " START" << ", startPointGeo_absZ = " << startPointGeo_absZ << ", endPointGeo_absZ = " << endPointGeo_absZ;
TRACE_LOG(m_logger) << Q_FUNC_INFO << " START"
<< ", startPointGeo_absZ = " << startPointGeo_absZ
<< ", endPointGeo_absZ = " << endPointGeo_absZ;
if (!isValid())
{
ERROR_LOG(m_logger) << Q_FUNC_INFO << " Error, LtsElevationManager not valid";
return LineOfSight::LOS_ERROR;
}
if (!isValid())
{
ERROR_LOG(m_logger) << Q_FUNC_INFO << " Error, LtsElevationManager not valid";
return LineOfSight::LOS_ERROR;
}
SituationMap::ElevationMapManager::LineOfSight eleMapMgrResult = d->m_elevationManager->lineOfSightCalculation(startPointGeo_absZ,endPointGeo_absZ);
SituationMap::ElevationMapManager::LineOfSight eleMapMgrResult =
d->m_elevationManager->lineOfSightCalculation(startPointGeo_absZ, endPointGeo_absZ);
LtsElevation::LineOfSight result = static_cast<LtsElevation::LineOfSight>(eleMapMgrResult);
LtsElevation::LineOfSight result = static_cast<LtsElevation::LineOfSight>(eleMapMgrResult);
TRACE_LOG(m_logger) << Q_FUNC_INFO << " END" << ", startPointGeo = " << startPointGeo_absZ << ", endPointGeo = " << endPointGeo_absZ
<< " -> LineOfSight " << result;
return result;
TRACE_LOG(m_logger) << Q_FUNC_INFO << " END"
<< ", startPointGeo = " << startPointGeo_absZ << ", endPointGeo = " << endPointGeo_absZ
<< " -> LineOfSight " << result;
return result;
}
LineOfSight LtsElevationManager::lineOfSightCalculation(const QPointF &startPointGeo, double startHat, const QPointF &endPointGeo, double endHat)
LineOfSight LtsElevationManager::lineOfSightCalculation(const QPointF& startPointGeo, double startHat,
const QPointF& endPointGeo, double endHat)
{
TRACE_LOG(m_logger) << Q_FUNC_INFO << " START"
<< ", startPointGeo = " << startPointGeo << ", startHat = " << startHat
<< ", endPointGeo = " << endPointGeo << ", endHat = " << endHat;
TRACE_LOG(m_logger) << Q_FUNC_INFO << " START"
<< ", startPointGeo = " << startPointGeo << ", startHat = " << startHat
<< ", endPointGeo = " << endPointGeo << ", endHat = " << endHat;
SituationMap::ElevationMapManager::LineOfSight eleMapMgrResult = d->m_elevationManager->lineOfSightCalculation(startPointGeo, startHat,
endPointGeo, endHat);
SituationMap::ElevationMapManager::LineOfSight eleMapMgrResult =
d->m_elevationManager->lineOfSightCalculation(startPointGeo, startHat, endPointGeo, endHat);
LtsElevation::LineOfSight result = static_cast<LtsElevation::LineOfSight>(eleMapMgrResult);
LtsElevation::LineOfSight result = static_cast<LtsElevation::LineOfSight>(eleMapMgrResult);
TRACE_LOG(m_logger) << Q_FUNC_INFO << " END"
<< ", startPointGeo = " << startPointGeo << ", startHat = " << startHat
<< ", endPointGeo = " << endPointGeo << ", endHat = " << endHat
<< " -> LineOfSight " << static_cast<int>(eleMapMgrResult);
return result;
TRACE_LOG(m_logger) << Q_FUNC_INFO << " END"
<< ", startPointGeo = " << startPointGeo << ", startHat = " << startHat
<< ", endPointGeo = " << endPointGeo << ", endHat = " << endHat << " -> LineOfSight "
<< static_cast<int>(eleMapMgrResult);
return result;
}
const QString toString(const LineOfSight &value)
const QString toString(const LineOfSight& value)
{
switch (value)
{
case LineOfSight::LOS_UNDEFINED:
return QStringLiteral("LOS_UNDEFINED");
case LineOfSight::LOS_ERROR:
return QStringLiteral("LOS_ERROR");
case LineOfSight::LOS_VISIBLE:
return QStringLiteral("LOS_VISIBLE");
case LineOfSight::LOS_INVISIBLE:
return QStringLiteral("LOS_INVISIBLE");
}
Q_ASSERT(false);
return QStringLiteral("LineOfSightERROR");
switch (value)
{
case LineOfSight::LOS_UNDEFINED:
return QStringLiteral("LOS_UNDEFINED");
case LineOfSight::LOS_ERROR:
return QStringLiteral("LOS_ERROR");
case LineOfSight::LOS_VISIBLE:
return QStringLiteral("LOS_VISIBLE");
case LineOfSight::LOS_INVISIBLE:
return QStringLiteral("LOS_INVISIBLE");
}
Q_ASSERT(false);
return QStringLiteral("LineOfSightERROR");
}
std::ostream &operator<<(std::ostream &stream, const LineOfSight value)
std::ostream& operator<<(std::ostream& stream, const LineOfSight value)
{
stream << toString(value).toStdString();
return stream;
stream << toString(value).toStdString();
return stream;
}
}
} // namespace LtsElevation
+42 -73
View File
@@ -1,28 +1,22 @@
#pragma once
#include "logger.h"
#include "ltselevation_export.h"
#include <LtsUtilsCore/qpoint3d.h>
#include <QCoreApplication>
#include <QObject>
#include <QPointer>
#include <QStringList>
#include <QCoreApplication>
#include <memory>
#include <iosfwd>
#include <memory>
namespace LtsSession
{
class LtsSessionDataDds;
}
}
namespace ExerciseManagement
{
@@ -30,7 +24,7 @@ namespace Interface
{
class Dtc;
}
}
} // namespace ExerciseManagement
namespace AssetManagement
{
@@ -38,92 +32,67 @@ namespace Interface
{
class Dtc;
}
}
} // namespace AssetManagement
namespace LtsElevation
{
enum class LineOfSight { LOS_UNDEFINED,
LOS_ERROR,
LOS_VISIBLE,
LOS_INVISIBLE };
enum class LineOfSight { LOS_UNDEFINED, LOS_ERROR, LOS_VISIBLE, LOS_INVISIBLE };
class LtsElevationManager;
using LTS_ELEVATION_MANAGER_TYPE = QPointer<LtsElevationManager>;
class LTSELEVATION_EXPORT LtsElevationManager : public QObject
{
public:
public:
static LTS_ELEVATION_MANAGER_TYPE
createInstance(int exerciseId, const std::shared_ptr<ExerciseManagement::Interface::Dtc>& exmDtc = {},
const std::shared_ptr<AssetManagement::Interface::Dtc>& asmDtc = {});
static LTS_ELEVATION_MANAGER_TYPE getInstance(int exerciseId);
static LTS_ELEVATION_MANAGER_TYPE
createInstanceForTrainingAreaId(int trainingAreaId,
const std::shared_ptr<AssetManagement::Interface::Dtc>& asmDtc = nullptr);
static LTS_ELEVATION_MANAGER_TYPE createInstance(int exerciseId,
const std::shared_ptr<ExerciseManagement::Interface::Dtc> &exmDtc = {},
const std::shared_ptr<AssetManagement::Interface::Dtc> &asmDtc = {});
static void cleanupAll();
virtual ~LtsElevationManager();
static LTS_ELEVATION_MANAGER_TYPE getInstance(int exerciseId);
bool waitForInitialization();
bool isValid() const;
double elevation(double lon_rad, double lat_rad, double defaultValue = std::numeric_limits<double>::min(),
bool* bIsCovered = nullptr) const;
static LTS_ELEVATION_MANAGER_TYPE createInstanceForTrainingAreaId(int trainingAreaId,
const std::shared_ptr<AssetManagement::Interface::Dtc> &asmDtc = nullptr);
LineOfSight lineOfSightCalculation(const LtsUtils::QPoint3D& startPointGeo_absZ,
const LtsUtils::QPoint3D& endPointGeo_absZ);
LineOfSight lineOfSightCalculation(const QPointF& startPointGeo, double startHat, const QPointF& endPointGeo,
double endHat);
protected:
explicit LtsElevationManager();
void initDDS(const std::shared_ptr<ExerciseManagement::Interface::Dtc>& exmDtc,
const std::shared_ptr<AssetManagement::Interface::Dtc>& asmDtc);
bool init(const QStringList& filePaths_rough_to_fine);
static int exerciseIdToTrainingAreaId(int exerciseId,
const std::shared_ptr<ExerciseManagement::Interface::Dtc>& exmDtc);
static void cleanupAll();
virtual ~LtsElevationManager();
QStringList getFilenamesForExercise(int exerciseId);
QStringList getFilenamesForTrainingArea(int trainingAreaId);
static LTS_ELEVATION_MANAGER_TYPE createInstanceUnitTest(int id, const QStringList& filePaths_rough_to_fine);
bool waitForInitialization();
bool isValid() const;
private:
class Private;
double elevation(double lon_rad, double lat_rad, double defaultValue = std::numeric_limits<double>::min(), bool *bIsCovered = nullptr) const;
LineOfSight lineOfSightCalculation(const LtsUtils::QPoint3D &startPointGeo_absZ,
const LtsUtils::QPoint3D &endPointGeo_absZ);
LineOfSight lineOfSightCalculation(const QPointF &startPointGeo, double startHat,
const QPointF &endPointGeo, double endHat);
protected:
explicit LtsElevationManager();
void initDDS(const std::shared_ptr<ExerciseManagement::Interface::Dtc> &exmDtc,
const std::shared_ptr<AssetManagement::Interface::Dtc> &asmDtc);
bool init(const QStringList &filePaths_rough_to_fine);
static int exerciseIdToTrainingAreaId(int exerciseId, const std::shared_ptr<ExerciseManagement::Interface::Dtc> &exmDtc);
QStringList getFilenamesForExercise(int exerciseId);
QStringList getFilenamesForTrainingArea(int trainingAreaId);
static LTS_ELEVATION_MANAGER_TYPE createInstanceUnitTest(int id, const QStringList &filePaths_rough_to_fine);
private:
class Private;
Private *d;
LOGGER_T m_logger;
Private* d;
LOGGER_T m_logger;
};
LTSELEVATION_EXPORT const QString toString(const LtsElevation::LineOfSight &value);
LTSELEVATION_EXPORT const QString toString(const LtsElevation::LineOfSight& value);
LTSELEVATION_EXPORT std::ostream &operator<< (std::ostream &stream,
const LtsElevation::LineOfSight value);
LTSELEVATION_EXPORT std::ostream& operator<<(std::ostream& stream, const LtsElevation::LineOfSight value);
}
} // namespace LtsElevation