588 lines
19 KiB
C++
588 lines
19 KiB
C++
|
|
|
|
#include "lts_elevation_manager.h"
|
|
|
|
#ifdef BUILD_RTI
|
|
#include <AssetManagement/asm_data_plugin_interface.h>
|
|
#include <ExerciseManagement/exm_data_plugin_interface.h>
|
|
#include <Viewer/SituationMap/ElevationMap/elevation_map_manager.h>
|
|
#include <Viewer/SituationMap/Common/resource_path.h>
|
|
|
|
#include <QDir>
|
|
#include <QHash>
|
|
#include <QSharedPointer>
|
|
#include <QUrl>
|
|
|
|
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");
|
|
#endif
|
|
|
|
namespace LtsElevation
|
|
{
|
|
class LtsElevationManager;
|
|
|
|
using LtsElevatioMgrMapTrainingAreaId = QMap<int, LTS_ELEVATION_MANAGER_TYPE>;
|
|
|
|
static LtsElevatioMgrMapTrainingAreaId& ltsElevatioMgrMapTrainingAreaId()
|
|
{
|
|
static LtsElevatioMgrMapTrainingAreaId s_ltsElevatioMgrMapTrainingAreaId;
|
|
return s_ltsElevatioMgrMapTrainingAreaId;
|
|
}
|
|
|
|
static void cleanupLtsElevatioMgrMapTrainingAreaId()
|
|
{
|
|
qDeleteAll(ltsElevatioMgrMapTrainingAreaId());
|
|
ltsElevatioMgrMapTrainingAreaId().clear();
|
|
}
|
|
|
|
LtsElevatioMgrMapTrainingAreaId& getLtsElevationMgrMapTrainingAreaId()
|
|
{
|
|
if (ltsElevatioMgrMapTrainingAreaId().isEmpty())
|
|
qAddPostRoutine(cleanupLtsElevatioMgrMapTrainingAreaId);
|
|
|
|
return ltsElevatioMgrMapTrainingAreaId();
|
|
}
|
|
|
|
static long s_counter{0};
|
|
|
|
class LtsElevationManager::Private
|
|
{
|
|
public:
|
|
Private() = default;
|
|
|
|
~Private()
|
|
{
|
|
#ifdef BUILD_RTI
|
|
delete m_elevationManager;
|
|
#endif
|
|
}
|
|
|
|
std::shared_ptr<ExerciseManagement::Interface::Dtc> m_exmDtc;
|
|
#ifdef BUILD_RTI
|
|
std::shared_ptr<AssetManagement::Interface::Dtc> m_asmDtc;
|
|
SituationMap::ElevationMapManager* m_elevationManager{nullptr};
|
|
#endif
|
|
|
|
QStringList m_filePaths_rough_to_fine;
|
|
};
|
|
|
|
LtsElevationManager::LtsElevationManager()
|
|
: QObject(nullptr)
|
|
, d(new Private)
|
|
, m_logger(getLogger("LtsElevationManager"))
|
|
{
|
|
++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;
|
|
}
|
|
|
|
LTS_ELEVATION_MANAGER_TYPE
|
|
LtsElevationManager::createInstance(int exerciseId, const std::shared_ptr<ExerciseManagement::Interface::Dtc>& exmDtc,
|
|
#ifdef BUILD_RTI
|
|
const std::shared_ptr<AssetManagement::Interface::Dtc>& asmDtc
|
|
#else
|
|
const std::shared_ptr<void>& asmDtc
|
|
#endif
|
|
)
|
|
{
|
|
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;
|
|
}
|
|
|
|
// Qt5 logic restored (the qt6 port had dropped the exerciseId->trainingAreaId
|
|
// caching and always returned nullptr here).
|
|
#ifdef BUILD_RTI
|
|
int trainingAreaId = -1;
|
|
|
|
// remember for future calls
|
|
// (so createInstance should work WITHOUT dtcs)
|
|
// Idea: MainHandler: createInstance with exerciseId and valid dtcs
|
|
// Plugin or simular: createInstance with exerciseId and no dtcs
|
|
static QHash<int, int> s_exIdToTaIdStore;
|
|
|
|
const auto exTaIt = s_exIdToTaIdStore.find(exerciseId);
|
|
if (exTaIt != s_exIdToTaIdStore.end())
|
|
{
|
|
// CASE 1:
|
|
// already created:
|
|
trainingAreaId = *exTaIt;
|
|
}
|
|
else
|
|
{
|
|
// CASE 2:
|
|
// ... or create on demand:
|
|
if (!exmDtc || !asmDtc)
|
|
{
|
|
ERROR_LOG(logger) << Q_FUNC_INFO << " no dtcs for exerciseId=" << exerciseId
|
|
<< ", asmDtc=" << asmDtc
|
|
<< ", exmDtc=" << exmDtc;
|
|
return nullptr;
|
|
}
|
|
|
|
// exId to taId
|
|
trainingAreaId = exerciseIdToTrainingAreaId(exerciseId, exmDtc);
|
|
if (trainingAreaId <= 0)
|
|
{
|
|
ERROR_LOG(logger) << Q_FUNC_INFO << " Error getting trainingAreaId"
|
|
<< ", exerciseId=" << exerciseId
|
|
<< ", trainingAreaId=" << trainingAreaId;
|
|
return nullptr;
|
|
}
|
|
|
|
// store and remember:
|
|
s_exIdToTaIdStore[exerciseId] = trainingAreaId;
|
|
}
|
|
|
|
// CASE 1: Following should work even with invalid 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;
|
|
}
|
|
|
|
// add exmDtc
|
|
temp->initDDS(exmDtc, asmDtc);
|
|
|
|
TRACE_LOG(logger) << Q_FUNC_INFO << " END, exerciseId=" << exerciseId;
|
|
return temp;
|
|
#else
|
|
Q_UNUSED(exmDtc);
|
|
Q_UNUSED(asmDtc);
|
|
ERROR_LOG(logger) << Q_FUNC_INFO << " BUILD_RTI=OFF, cannot create instance";
|
|
return nullptr;
|
|
#endif
|
|
}
|
|
|
|
LTS_ELEVATION_MANAGER_TYPE LtsElevationManager::getInstance(int exerciseId)
|
|
{
|
|
return LtsElevationManager::createInstance(exerciseId);
|
|
}
|
|
|
|
#ifdef BUILD_RTI
|
|
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;
|
|
|
|
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);
|
|
|
|
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;
|
|
}
|
|
|
|
LTS_ELEVATION_MANAGER_TYPE temp = new LtsElevationManager();
|
|
|
|
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;
|
|
}
|
|
|
|
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);
|
|
|
|
DEBUG_LOG(logger) << " LtsElevationMgrMap contains instances now: " << map.size();
|
|
|
|
TRACE_LOG(logger) << Q_FUNC_INFO << " END, trainingAreaId=" << trainingAreaId;
|
|
return map[trainingAreaId];
|
|
}
|
|
#endif
|
|
|
|
LTS_ELEVATION_MANAGER_TYPE LtsElevationManager::createInstanceUnitTest(int id,
|
|
const QStringList& filePaths_rough_to_fine)
|
|
{
|
|
LOGGER_T logger = getLogger("LtsElevationManager");
|
|
|
|
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();
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
map.insert(id, temp);
|
|
|
|
DEBUG_LOG(logger) << " LtsElevationMgrMap contains instances now: " << map.size();
|
|
|
|
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";
|
|
}
|
|
|
|
#ifdef BUILD_RTI
|
|
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";
|
|
|
|
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);
|
|
|
|
TRACE_LOG(m_logger) << Q_FUNC_INFO << " END";
|
|
}
|
|
#else
|
|
void LtsElevationManager::initDDS(const std::shared_ptr<ExerciseManagement::Interface::Dtc>& exmDtc,
|
|
const std::shared_ptr<void>& asmDtc)
|
|
{
|
|
Q_UNUSED(exmDtc);
|
|
Q_UNUSED(asmDtc);
|
|
TRACE_LOG(m_logger) << Q_FUNC_INFO << " START (BUILD_RTI=OFF, no DDS init)";
|
|
|
|
// BUILD_RTI=OFF: No DDS initialization
|
|
TRACE_LOG(m_logger) << Q_FUNC_INFO << " END";
|
|
}
|
|
#endif
|
|
|
|
#ifdef BUILD_RTI
|
|
QStringList LtsElevationManager::getFilenamesForExercise(int exerciseId)
|
|
{
|
|
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 {};
|
|
}
|
|
|
|
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);
|
|
|
|
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";
|
|
|
|
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)
|
|
{
|
|
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());
|
|
|
|
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;
|
|
}
|
|
#else
|
|
QStringList LtsElevationManager::getFilenamesForExercise(int /*exerciseId*/)
|
|
{
|
|
ERROR_LOG(m_logger) << Q_FUNC_INFO << " BUILD_RTI=OFF, getFilenamesForExercise not available";
|
|
return {};
|
|
}
|
|
|
|
QStringList LtsElevationManager::getFilenamesForTrainingArea(int /*trainingAreaId*/)
|
|
{
|
|
ERROR_LOG(m_logger) << Q_FUNC_INFO << " BUILD_RTI=OFF, getFilenamesForTrainingArea not available";
|
|
return {};
|
|
}
|
|
#endif
|
|
|
|
bool LtsElevationManager::init(const QStringList& filePaths_rough_to_fine)
|
|
{
|
|
#ifdef BUILD_RTI
|
|
delete d->m_elevationManager;
|
|
|
|
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 !!!";
|
|
return false;
|
|
}
|
|
return true;
|
|
#else
|
|
Q_UNUSED(filePaths_rough_to_fine);
|
|
ERROR_LOG(m_logger) << Q_FUNC_INFO << " BUILD_RTI=OFF, init not available";
|
|
return false;
|
|
#endif
|
|
}
|
|
|
|
#ifdef BUILD_RTI
|
|
int LtsElevationManager::exerciseIdToTrainingAreaId(int exerciseId,
|
|
const std::shared_ptr<ExerciseManagement::Interface::Dtc>& exmDtc)
|
|
{
|
|
LOGGER_T logger = getLogger("LtsElevationManager");
|
|
|
|
if (!exmDtc)
|
|
{
|
|
ERROR_LOG(logger) << Q_FUNC_INFO << " no dtcs"
|
|
<< ", exerciseId=" << exerciseId;
|
|
return -1;
|
|
}
|
|
|
|
int trainingAreaId = -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 -1;
|
|
}
|
|
trainingAreaId = exm.trainingAreaId;
|
|
|
|
if (trainingAreaId <= 0)
|
|
{
|
|
ERROR_LOG(logger) << Q_FUNC_INFO << " Error getting trainingAreaId"
|
|
<< ", exerciseId=" << exerciseId << ", trainingAreaId=" << trainingAreaId;
|
|
return -1;
|
|
}
|
|
}
|
|
return trainingAreaId;
|
|
}
|
|
#else
|
|
int LtsElevationManager::exerciseIdToTrainingAreaId(int exerciseId,
|
|
const std::shared_ptr<ExerciseManagement::Interface::Dtc>& exmDtc)
|
|
{
|
|
Q_UNUSED(exerciseId);
|
|
Q_UNUSED(exmDtc);
|
|
LOGGER_T logger = getLogger("LtsElevationManager");
|
|
ERROR_LOG(logger) << Q_FUNC_INFO << " BUILD_RTI=OFF, cannot convert exerciseId to trainingAreaId";
|
|
return -1;
|
|
}
|
|
#endif
|
|
|
|
bool LtsElevationManager::waitForInitialization()
|
|
{
|
|
#ifdef BUILD_RTI
|
|
if (!d->m_elevationManager)
|
|
return false;
|
|
return d->m_elevationManager->waitForInitialization();
|
|
#else
|
|
ERROR_LOG(m_logger) << Q_FUNC_INFO << " BUILD_RTI=OFF, waitForInitialization not available";
|
|
return false;
|
|
#endif
|
|
}
|
|
|
|
bool LtsElevationManager::isValid() const
|
|
{
|
|
#ifdef BUILD_RTI
|
|
if (!d->m_elevationManager)
|
|
return false;
|
|
return d->m_elevationManager->isValid();
|
|
#else
|
|
ERROR_LOG(m_logger) << Q_FUNC_INFO << " BUILD_RTI=OFF, isValid not available";
|
|
return false;
|
|
#endif
|
|
}
|
|
|
|
double LtsElevationManager::elevation(double lon_rad, double lat_rad, double defaultValue, bool* bIsCovered) const
|
|
{
|
|
#ifdef BUILD_RTI
|
|
if (!d->m_elevationManager)
|
|
return defaultValue;
|
|
return d->m_elevationManager->elevation(lon_rad, lat_rad, defaultValue, bIsCovered);
|
|
#else
|
|
Q_UNUSED(lon_rad);
|
|
Q_UNUSED(lat_rad);
|
|
Q_UNUSED(bIsCovered);
|
|
ERROR_LOG(m_logger) << Q_FUNC_INFO << " BUILD_RTI=OFF, elevation not available";
|
|
return defaultValue;
|
|
#endif
|
|
}
|
|
|
|
LineOfSight LtsElevationManager::lineOfSightCalculation(const LtsUtils::QPoint3D& startPointGeo_absZ,
|
|
const LtsUtils::QPoint3D& endPointGeo_absZ)
|
|
{
|
|
#ifdef BUILD_RTI
|
|
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;
|
|
}
|
|
|
|
SituationMap::ElevationMapManager::LineOfSight eleMapMgrResult =
|
|
d->m_elevationManager->lineOfSightCalculation(startPointGeo_absZ, endPointGeo_absZ);
|
|
|
|
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;
|
|
#else
|
|
Q_UNUSED(startPointGeo_absZ);
|
|
Q_UNUSED(endPointGeo_absZ);
|
|
ERROR_LOG(m_logger) << Q_FUNC_INFO << " BUILD_RTI=OFF, lineOfSightCalculation not available";
|
|
return LineOfSight::LOS_ERROR;
|
|
#endif
|
|
}
|
|
|
|
LineOfSight LtsElevationManager::lineOfSightCalculation(const QPointF& startPointGeo, double startHat,
|
|
const QPointF& endPointGeo, double endHat)
|
|
{
|
|
#ifdef BUILD_RTI
|
|
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);
|
|
|
|
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;
|
|
#else
|
|
Q_UNUSED(startPointGeo);
|
|
Q_UNUSED(startHat);
|
|
Q_UNUSED(endPointGeo);
|
|
Q_UNUSED(endHat);
|
|
ERROR_LOG(m_logger) << Q_FUNC_INFO << " BUILD_RTI=OFF, lineOfSightCalculation not available";
|
|
return LineOfSight::LOS_ERROR;
|
|
#endif
|
|
}
|
|
|
|
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");
|
|
}
|
|
|
|
std::ostream& operator<<(std::ostream& stream, const LineOfSight value)
|
|
{
|
|
stream << toString(value).toStdString();
|
|
return stream;
|
|
}
|
|
|
|
} // namespace LtsElevation
|