lifemaps/qt-migration-legatus
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
7a6be7474eedf82c0e250292f00a16a2bc8e49be
qt-migration-legatus/qt6-after/qt6-migrated-legatus/Lts/Viewer/SituationMap/Map/map_initializer.cpp
T
torstenandCopilot 7a6be7474e Qt6 migration: Fix BUILD_RTI=OFF build errors in TrainingAreaBase 
- training_area_telegrams.cpp: Fixed QJsonObject initializer syntax (Qt6 requires {{}} not ({}))
- training_area_telegrams.cpp: Fixed fromJson() methods to access m_* members directly
- training_area_telegrams.cpp: Fixed brace mismatches in multiple toJson() methods
- training_area_telegrams.h: Changed Header struct to public members for consistency
- tx_mixin.cpp: Fixed getEquipmentNumber() template for direct member access
- lts_coordinate.cpp: Added missing #include <iomanip>
- MIGRATION_STATUS.md: Added migration progress tracking document

C++17 constraint enforced due to RTI Connext DDS 7.7.0 incompatibility with C++20+

Build status: BUILD_RTI=OFF successful (0 errors, warnings only)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
2026-08-23 20:49:23 +02:00

1130 lines
37 KiB
C++
Executable File
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
/**
* @RDE_HEADER@
* MapInitializer
* $Id$
* $HeadURL$
* $Author$
*/
// Own
#include "map_initializer.h"
#include "grid.h"
#include <Map/viewshed.h>
#include <Map/situation_map_utils.h>
#include <Map/abstract_map_object.h>
#include <Rubberbands/rubberband_factory.h>
#include <Rubberbands/event_mouse_navigator.h>
#include <LtsCoordTrans/lts_coord_trans.h>
#include <arcgis/arcgisversion.h> // This file is created by RME, not ESRI
#include <QtCore/QCoreApplication>
#include <QtCore/QJsonDocument>
#include <QtCore/QJsonObject>
#include <QtCore/QJsonArray>
#include <QNetworkProxy>
#include <QtWidgets/QMessageBox>
//----------------------------------------------------------------------------
namespace SituationMap
{
//----------------------------------------------------------------------------
BaseUrl::BaseUrl(const QString &url, double minScale, double maxScale)
: m_url(url), m_minScale(minScale), m_maxScale(maxScale)
{}
BaseUrl BaseUrl::read(const QJsonObject &json)
{
BaseUrl baseUrl;
baseUrl.m_url = json[QStringLiteral("url")].toString();
baseUrl.m_minScale = json[QStringLiteral("minScale")].toDouble();
baseUrl.m_maxScale = json[QStringLiteral("maxScale")].toDouble();
if (json.contains(QStringLiteral("altitudeOffset")))
baseUrl.m_altitudeOffset = json[QStringLiteral("altitudeOffset")].toDouble();
else
baseUrl.m_altitudeOffset = 0.0;
// tbc !!!
return baseUrl;
}
QJsonObject BaseUrl::toJsonObject() const
{
QJsonObject json;
json[QStringLiteral("url")] = m_url;
json[QStringLiteral("minScale")] = m_minScale;
json[QStringLiteral("maxScale")] = m_maxScale;
if (!qFuzzyIsNull(m_altitudeOffset))
json[QStringLiteral("altitudeOffset")] = m_altitudeOffset;
// tbc !!!
return json;
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
// MapSettingsJson
static inline QJsonArray toJsonArray(const QVector<BaseUrl> &urls)
{
QJsonArray jArray;
for (const BaseUrl &baseUrl : urls)
jArray.append(baseUrl.toJsonObject());
return jArray;
}
static inline QVector<BaseUrl> fromJsonArray(const QJsonValue &val)
{
const QJsonArray &arr = val.toArray();
QVector<BaseUrl> urls;
urls.reserve(arr.size());
for (const auto &item : arr)
urls.append(BaseUrl::read(item.toObject()));
return urls;
}
QJsonObject MapSettingsJson::toJsonObject() const
{
QJsonObject obj;
obj[QLatin1String("mapUrls")] = toJsonArray(m_mapUrls);
obj[QLatin1String("sceneUrls")] = toJsonArray(m_sceneUrls);
obj[QLatin1String("sceneObjectUrls")] = toJsonArray(m_sceneObjectUrls);
obj[QLatin1String("elevationUrls")] = toJsonArray(m_elevationUrls);
return obj;
}
bool MapSettingsJson::fromJsonObject(const QJsonObject &json)
{
m_mapUrls = fromJsonArray(json[QLatin1String("mapUrls")]);
m_sceneUrls = fromJsonArray(json[QLatin1String("sceneUrls")]);
m_sceneObjectUrls = fromJsonArray(json[QLatin1String("sceneObjectUrls")]);
m_elevationUrls = fromJsonArray(json[QLatin1String("elevationUrls")]);
return true;
}
//----------------------------------------------------------------------------
MapInitializer::MapInitializer(Map &map,
MapSettings &mapSettings,
const QString &debugName,
QObject *parent)
: QObject(parent)
, m_map(map)
, m_mapSettings(mapSettings)
, m_debugName(debugName)
, m_logger(getLogger("MapInitializer"))
{
TRACE_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " START";
connect(&m_map, &SituationMap::Map::mapReady, this, &MapInitializer::onMapReady);
TRACE_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " END";
}
void MapInitializer::setMapSettingsJson(const MapSettingsJson &mapSettingJson)
{
m_mapSettingJson = mapSettingJson;
}
MapInitializer::~MapInitializer()
{
TRACE_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " START";
TRACE_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " END";
}
QString MapInitializer::filename() const { return m_mapSettings.filename(); }
bool MapInitializer::hasErrors() const { return m_mapSettings.hasErrors(); }
bool MapInitializer::exists() const { return m_mapSettings.exists(); }
bool MapInitializer::accessError() const { return m_mapSettings.accessError(); }
bool MapInitializer::formatError() const { return m_mapSettings.formatError(); }
bool MapInitializer::initMap(Mode mapMode)
{
TRACE_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " START"
<< " mapMode=" << mapMode;
m_mapMode = mapMode;
QString job;
bool success = true;
job = QLatin1String("applyLicense");
if (applyLicense())
INFO_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " successful: '" << job << "'";
else
{
FATAL_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " failure: '" << job << "'";
QMessageBox::critical(nullptr, tr("Apply License"), tr("ESRI License no valid"));
QCoreApplication::quit();
return false;
}
#if ACRGIS_VERSION >= 0x640700 // 100.7.0 / Update 7
job = QLatin1String("applyNetworkCache");
if (applyNetworkCache())
INFO_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " successful: '" << job << "'";
else
{
ERROR_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " failure: '" << job << "'";
success = false;
}
#endif // ACRGIS_VERSION
job = QLatin1String("setSymbologyType");
if (setSymbologyType())
DEBUG_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " successful: '" << job << "'";
else
{
ERROR_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " failure: '" << job << "'";
success = false;
}
job = QLatin1String("setBasemapLayernamePrefix");
if (setBasemapLayernamePrefix())
DEBUG_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " successful: '" << job << "'";
else
{
ERROR_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " failure: '" << job << "'";
success = false;
}
job = QLatin1String("setParticipantLayername");
if (setParticipantLayername())
DEBUG_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " successful: '" << job << "'";
else
{
ERROR_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " failure: '" << job << "'";
success = false;
}
job = QLatin1String("map.init");
if (! m_map.init(m_mapMode))
{
ERROR_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " failure: '" << job << "'";
success = false;
}
// DDS, LocalFile or ...
if (!initializeBasemaps(mapMode))
{
ERROR_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " failure: '" << job << "'";
success = false;
}
// DDS, LocalFile or ...
// elevation:
job = QLatin1String("initializeElevationSources");
if (initializeElevationSources())
DEBUG_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " successful: '" << job << "'";
else
{
ERROR_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " failure: '" << job << "'";
success = false;
}
if (m_mapMode == Mode::Mode_3D)
{
// Objects (like buildings):
// load from QSetting _OR_ from Dds/Json
if (m_mapSettingJson.getSceneObjectUrls().isEmpty())
{
success = initializeSceneObjectLayers();
} else {
success = initializeSceneObjectLayersJson();
}
} // if (m_mapMode == Mode::Mode_3D)
job = QLatin1String("initialzeInitialViewpoint");
if (initialzeInitialViewpoint())
DEBUG_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " successful: '" << job << "'";
else
{
ERROR_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " failure: '" << job << "'";
success = false;
}
// load to call 'setMap' and start Esri's cascading load dependecies...
INFO_LOG(m_logger) << LOGFUNCTION << " load";
m_map.load();
job = QLatin1String("initializeOperationalLayers");
if (initializeOperationalLayers())
DEBUG_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " successful: '" << job << "'";
else
{
ERROR_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " failure: '" << job << "'";
success = false;
}
if (m_mapMode == Mode::Mode_3D)
{
job = QLatin1String("initializeUniqueValueRendererForCubes");
if (initializeUniqueValueRendererForCubes())
DEBUG_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " successful: '" << job << "'";
else
{
ERROR_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " failure: '" << job << "'";
success = false;
}
}
job = QLatin1String("initializeExtraSymbolDirectory");
if (initializeExtraSymbolDirectory())
DEBUG_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " successful: '" << job << "'";
else
{
ERROR_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " failure: '" << job << "'";
success = false;
}
job = QLatin1String("initializeGrid");
if (initializeGrid())
DEBUG_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " successful: '" << job << "'";
else
{
ERROR_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " failure: '" << job << "'";
success = false;
}
job = QLatin1String("initializeAnimations");
if (initializeAnimations())
DEBUG_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " successful: '" << job << "'";
else
{
ERROR_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " failure: '" << job << "'";
success = false;
}
job = QLatin1String("initializeObjectFactory");
if (initializeObjectFactory())
DEBUG_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " successful: '" << job << "'";
else
{
ERROR_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " failure: '" << job << "'";
success = false;
}
job = QLatin1String("setObjectContainer");
if (setObjectContainer())
DEBUG_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " successful: '" << job << "'";
else
{
ERROR_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " failure: '" << job << "'";
success = false;
}
job = QLatin1String("initializeCoordTranslationFunctor");
if (initializeCoordTranslationFunctor())
DEBUG_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " successful: '" << job << "'";
else
{
ERROR_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " failure: '" << job << "'";
success = false;
}
job = QLatin1String("initializeRubberFactory");
if (initializeRubberFactory())
DEBUG_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " successful: '" << job << "'";
else
{
ERROR_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " failure: '" << job << "'";
success = false;
}
job = QLatin1String("initializeMapWidgets");
if (initializeMapWidgets())
DEBUG_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " successful: '" << job << "'";
else
{
ERROR_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " failure: '" << job << "'";
success = false;
}
job = QLatin1String("initializeSideBar");
if (initializeSideBar())
DEBUG_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " successful: '" << job << "'";
else
{
ERROR_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " failure: '" << job << "'";
success = false;
}
job = QLatin1String("setViewshedUrl");
if (setViewshedUrl())
DEBUG_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " successful: '" << job << "'";
else
{
ERROR_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " failure: '" << job << "'";
success = false;
}
TRACE_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " " << " END";
return success;
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
bool MapInitializer::applyLicense()
{
const QString &licStr = m_mapSettings.licenseStr();
const QStringList &licenseExtensions = m_mapSettings.licenseExtensions();
return SituationMap::Map::applyLicense(licStr, licenseExtensions);
}
//----------------------------------------------------------------------------
bool MapInitializer::applyNetworkCache()
{
SituationMap::EsriNetworkCacheSettings encs = m_mapSettings.networkCacheSettings();
SituationMap::Map::applyNetworkCacheSettings(encs);
// re-read:
const SituationMap::EsriNetworkCacheSettings &readEncs = SituationMap::Map::networkCacheSettings();
return readEncs.enabled == encs.enabled;
}
bool MapInitializer::setSymbologyType()
{
AdvancedSymbology::SymbologyType symbologyType = this->symbologyType();
return m_map.setSymbologyType(symbologyType);
}
bool MapInitializer::setBasemapLayernamePrefix()
{
const QString &basemapLayernamePrefix = m_mapSettings.basemapLayernamePrefix();
if (!basemapLayernamePrefix.isEmpty())
{
INFO_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")"
<< " set basemapLayernamePrefix to '" << basemapLayernamePrefix << "'";
m_map.layerFactory().setBasemapLayernamePrefix(basemapLayernamePrefix);
}
return true;
}
bool MapInitializer::setParticipantLayername()
{
// like 'Participants:Dynamic:Relative'
const QString &participantLayername = m_mapSettings.participantLayername();
if (participantLayername.isEmpty())
{
ERROR_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")"
<< ", participantLayername is empty";
return false;
}
const QStringList &sl = participantLayername.split(QLatin1Char(':'));
if (sl.size() != 3)
{
ERROR_LOG(m_logger) << LOGFUNCTION << " logicalLayerName configuration not correct."
<< ", participantLayername='" << participantLayername << "'";
return false;
}
// Layername
const QString &layername = sl.first();
// V100.0.0:
// Dynamic RenderMode has known issue related to military symbology at 3D.
// recommendation: use static:
RenderingMode renderingMode = RenderingMode::Dynamic; // ToDo V100: Dynamic vs. Static
SurfacePlacement surfacePlacement = SurfacePlacement::Draped;
// RenderingMode
const QString &rmName = sl[1];
if (!fromString(renderingMode, rmName))
{
ERROR_LOG(m_logger) << LOGFUNCTION << " parseError on renderMode: rmName='" << rmName << "'";
return false;
}
// SurfacePlacement
const QString &spName = sl[2];
if (!fromString(surfacePlacement, spName))
{
ERROR_LOG(m_logger) << LOGFUNCTION << " parseError on surfacePlacement: spName='" << rmName << "'";
return false;
}
INFO_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")"
<< " set participantLayername to '" << layername << "'"
<< " renderingMode=" << renderingMode
<< " surfacePlacement=" << surfacePlacement;
m_map.layerFactory().setParticipantLayer(layername, renderingMode, surfacePlacement);
return true;
}
AdvancedSymbology::SymbologyType MapInitializer::symbologyType() const
{
AdvancedSymbology::SymbologyType symbologyType = m_mapSettings.symbologyType();
return symbologyType;
}
bool MapInitializer::initalizeLocalMapFile()
{
const QString &localMapFile = m_mapSettings.localMapFile();
if (!localMapFile.isEmpty())
{
INFO_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")"
<< " localMapFile = '" << localMapFile << "'";
return m_map.layerFactory().initializeBasemapBuiltIn(localMapFile);
}
return true;
}
//----------------------------------------------------------------------------
bool MapInitializer::initializeBasemaps(Mode mapMode)
{
QVector<BaseUrl> baseUrls;
switch (mapMode)
{
case Mode::Undefined:
break;
case Mode::Mode_2D:
baseUrls = m_mapSettingJson.getMapUrls();
break;
case Mode::Mode_3D:
baseUrls = m_mapSettingJson.getSceneUrls();
break;
default:
break;
}
QString job;
bool success = true;
if (baseUrls.isEmpty())
{
// use QSettings
if (m_mapSettings.localMapFile().isEmpty())
{
job = QLatin1String("initializeBasemapsQSettings");
if (initializeBasemapsQSettings(mapMode))
DEBUG_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " successful: '" << job << "'";
else
{
ERROR_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " failure: '" << job << "'";
success = false;
}
} else {
job = QLatin1String("initalizeLocalMapFile");
if (initalizeLocalMapFile())
DEBUG_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " successful: '" << job << "'";
else
{
ERROR_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " failure: '" << job << "'";
success = false;
}
}
} else {
//
// Values are initially taken from DB -> MapDescription@TrainingArea@DDS
//
job = QLatin1String("initializeBasemapsJSON");
if (initializeBasemapsJson(baseUrls))
DEBUG_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " successful: '" << job << "'";
else
{
ERROR_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " failure: '" << job << "'";
success = false;
}
}
return success;
}
bool MapInitializer::initializeBasemapsQSettings(Mode mapMode)
{
QVector<QPair<QString, QString>> basemapUrls;
switch (mapMode)
{
case Mode::Undefined:
break;
case Mode::Mode_2D:
basemapUrls = m_mapSettings.mapUrlsWithNames();
break;
case Mode::Mode_3D:
basemapUrls = m_mapSettings.sceneUrlsWithNames();
break;
default:
break;
}
DEBUG_LOG(m_logger) << LOGFUNCTION
<< " UrlCount= " << basemapUrls.count();
// << " basemapUrls='" << basemapUrls.join(QLatin1String(";")) << "'";
// Process basemaps:
bool success = true;
int localLayerCount = 0;
// item => val, name
for (const QPair<QString, QString> &item : qAsConst(basemapUrls))
{
QString layername = QStringLiteral("%1%2").arg(m_map.layerFactory().basemapLayernamePrefix()).arg(localLayerCount);
QString urlVal = item.first;
QString displayName = item.second;
double minScale = -1;
double maxScale = -1;
QChar seperator(QLatin1Char('#'));
QStringList slUrlExt = urlVal.split(seperator);
QString finalMapUrl = slUrlExt.first();
if (slUrlExt.size() == 2)
{
finalMapUrl = slUrlExt[0];
const QString &mapUrlExtension = slUrlExt[1];
QChar innerSeperator(QLatin1Char(':'));
QStringList slMinMax = mapUrlExtension.split(innerSeperator);
if (slMinMax.size() == 2)
{
bool bOk = false;
QString temp = slMinMax[0];
minScale = temp.toDouble(&bOk);
if (!bOk)
{
minScale = -1;
ERROR_LOG(m_logger) << LOGFUNCTION << " String can´t be converted to double. str='" << temp << "'";
}
temp = slMinMax[1];
maxScale = temp.toDouble(&bOk);
if (!bOk)
{
maxScale = -1;
ERROR_LOG(m_logger) << LOGFUNCTION << " String can´t be converted to double. str='" << temp << "'";
}
}
}
DEBUG_LOG(m_logger) << " layername = '" << layername << "'"
<< " displayName = '" << displayName << "'"
<< " minScale = " << minScale << " maxScale = " << maxScale;
success = success && m_map.layerFactory().addBasemap(layername,
QUrl(finalMapUrl),
(localLayerCount == 0) ? BasemapType::Topographic : BasemapType::Aerial,
minScale,
maxScale,
displayName, // QStringLiteral("dispName_%1").arg(layername),
QStringLiteral("descrip_%1").arg(localLayerCount),
QImage());
++localLayerCount;
} // for
return success;
}
bool MapInitializer::initializeBasemapsJson(const QVector<BaseUrl> &baseUrls)
{
// Process basemaps:
bool success = true;
int localLayerCount = 0;
for (const BaseUrl &baseUrl : qAsConst(baseUrls))
{
const QString &layername = QStringLiteral("%1%2").arg(m_map.layerFactory().basemapLayernamePrefix()).arg(localLayerCount);
INFO_LOG(m_logger) << " ***** JSON: layername = '" << layername << "'"
<< " minScale = " << baseUrl.minScale() << " maxScale = " << baseUrl.maxScale()
<< " url = '" << baseUrl.url();
success = success && m_map.layerFactory().addBasemap(layername,
QUrl(baseUrl.url()),
// (localLayerCount == 0) ? BasemapType::Topographic : BasemapType::Aerial,
baseUrl.basemapType(),
baseUrl.minScale(),
baseUrl.maxScale(),
baseUrl.name(),
baseUrl.description(),
QImage());
++localLayerCount;
} // for
return success;
}
bool MapInitializer::initializeSceneObjectLayers()
{
const QStringList &sceneObjectUrls = m_mapSettings.sceneObjectUrls();
if (sceneObjectUrls.isEmpty())
return true; // handle as successful
bool success = true;
for (const QString &item : qAsConst(sceneObjectUrls))
{
QChar seperator(QLatin1Char('#'));
QStringList slUrlExt = item.split(seperator);
if (slUrlExt.size() < 1)
{
ERROR_LOG(m_logger) << " Error splitting item: '" << item << "'";
continue;
}
const QString realUrl = slUrlExt.first();
const QString altitudeOffsetStr = slUrlExt.value(1, QStringLiteral("0.0")); // default value is 0;
bool ok = false;
double altitudeOffset = altitudeOffsetStr.toDouble(&ok);
if (!ok)
altitudeOffset = 0.001;
INFO_LOG(m_logger) << " sceneObjectLayers "
<< " realUrl = '" << realUrl << "'"
<< " altitudeOffset = " << altitudeOffset;
int localLayerCount = 0;
const QString &layername = QStringLiteral("SceneObjectLayer_%1").arg(localLayerCount);
success = success && m_map.layerFactory().addSceneObjectLayer(layername,
QUrl(realUrl),
altitudeOffset,
QStringLiteral("dispName_%1").arg(layername),
QStringLiteral("descrip_%1").arg(localLayerCount),
QImage());
}
return success;
}
bool MapInitializer::initializeSceneObjectLayersJson()
{
const QVector<BaseUrl> &urls = m_mapSettingJson.getSceneObjectUrls();
if (urls.isEmpty())
return true; // handle as successful
bool success = true;
for (const BaseUrl &item : qAsConst(urls))
{
const QString &urlVal = item.url();
QChar seperator(QLatin1Char('#'));
QStringList slUrlExt = urlVal.split(seperator);
if (slUrlExt.size() < 1)
{
ERROR_LOG(m_logger) << " Error splitting item: '" << urlVal << "'";
continue;
}
const QString realUrl = slUrlExt.first();
const QString altitudeOffsetStr = slUrlExt.value(1, QStringLiteral("0.0")); // default value is 0;
bool ok = false;
double altitudeOffset = altitudeOffsetStr.toDouble(&ok);
if (!ok)
altitudeOffset = 0.001;
if (!qFuzzyIsNull(item.altitudeOffset()))
altitudeOffset = item.altitudeOffset();
NOTICE_LOG(m_logger) << " sceneObjectLayers "
<< " realUrl = '" << realUrl << "'"
<< " altitudeOffset = " << altitudeOffset;
int localLayerCount = 0;
const QString &layername = QStringLiteral("SceneObjectLayer_%1").arg(localLayerCount);
success = success && m_map.layerFactory().addSceneObjectLayer(layername,
QUrl(realUrl),
altitudeOffset,
QStringLiteral("dispName_%1").arg(layername),
QStringLiteral("descrip_%1").arg(localLayerCount),
QImage());
}
return success;
}
bool MapInitializer::initializeElevationSources()
{
bool success = false;
if (m_mapSettingJson.getElevationUrls().isEmpty())
{
success = initializeElevationSourcesQSettings();
} else {
success = initializeElevationSourcesJson();
}
return success;
}
bool MapInitializer::initializeElevationSourcesQSettings()
{
const QStringList &elevationUrls = m_mapSettings.elevationUrls();
if (elevationUrls.isEmpty())
return true; // handle as successful
INFO_LOG(m_logger) << LOGFUNCTION << " elevationUrlsQSettings = '" << elevationUrls.join(QLatin1Char(';')) << "'";
return m_map.layerFactory().initializeElevationSources(elevationUrls);
}
bool MapInitializer::initializeElevationSourcesJson()
{
const QVector<BaseUrl> &urls = m_mapSettingJson.getElevationUrls();
if (urls.isEmpty())
return true; // handle as successful
QStringList slUrls;
slUrls.reserve(urls.size());
for (const auto &item : urls)
slUrls.append(item.url());
INFO_LOG(m_logger) << LOGFUNCTION << " elevationUrlsJSON = '" << slUrls.join(QLatin1Char(';')) << "'";
return m_map.layerFactory().initializeElevationSources(slUrls);
}
bool MapInitializer::initialzeInitialViewpoint()
{
const QString &centerPointMgrsIni = m_mapSettings.centerPointMgrs();
double scaleIni = m_mapSettings.scale();
if (m_viewPoint.isNull())
{
const QPointF &centerPointGeo = LtsCoordTrans::geographicFromMgrs(centerPointMgrsIni);
m_viewPoint.setCenterGeo(centerPointGeo);
m_viewPoint.setScale(scaleIni);
}
DEBUG_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " centerPointMgrsIni=" << centerPointMgrsIni << " scaleIni=" << scaleIni << " m_viewPoint=" << m_viewPoint;
m_map.setInitialViewpoint(m_viewPoint); // QPointF(92750, 80525) -> Rennplatz - Bremen
return true;
}
//----------------------------------------------------------------------------
bool MapInitializer::initializeOperationalLayers()
{
const QStringList &operationLayers = m_mapSettings.operationalLayers();
if (operationLayers.isEmpty())
{
ERROR_LOG(m_logger) << LOGFUNCTION
<< " initializeOperationalLayers failed, "
<< " layerNames empty";
return false;
}
// Lookup for displaynames
QMap<QString, QString> displayNames;
displayNames[QStringLiteral("Buildings")] = tr("Buildings"); // dt. 3D Gebäude
displayNames[QStringLiteral("MountingPoints")] = tr("MountingPoints"); // dt. Anbringungspunkte
displayNames[QStringLiteral("IEDs")] = tr("IEDs"); // dt. IEDs
displayNames[QStringLiteral("BuildingOwnership")] = tr("BuildingOwnership"); // dt. Gebäudebesitz
displayNames[QStringLiteral("AES")] = tr("AES"); // dt. Wirksimulation
displayNames[QStringLiteral("AESCentral")] = tr("AesCentral"); // dt. Wirksimulation(Zentral)
displayNames[QStringLiteral("TechnicalAreas")] = tr("TechnicalAreas"); // dt. Technische Bereiche
displayNames[QStringLiteral("RubberbandLayer")] = tr("RubberbandLayer");
displayNames[QStringLiteral("Participants")] = tr("Participants"); // dt. Teilnehmer
displayNames[QStringLiteral("Participants_1")] = tr("Participant (Level 1)"); // dt. Teilnehmer (Ebene 1)
displayNames[QStringLiteral("Participants_2")] = tr("Participant (Level 2)"); // dt. Teilnehmer (Ebene 2)
displayNames[QStringLiteral("Participants_3")] = tr("Participant (Level 3)"); // dt. Teilnehmer (Ebene 3)
displayNames[QStringLiteral("Participants_4")] = tr("Participant (Level 4)"); // dt. Teilnehmer (Ebene 4)
displayNames[QStringLiteral("Participants_5")] = tr("Participant (Level 5)"); // dt. Teilnehmer (Ebene 5)
// V100.0.0:
// Dynamic RenderMode has known issue related to military symbology at 3D.
// recommendation: use static:
const RenderingMode defaultRenderingMode = RenderingMode::Dynamic; // ToDo V100: Dynamic vs. Static
const SurfacePlacement defaultSurfacePlacement = SurfacePlacement::Draped;
for (const QString &logicalLayerNameEncoded : operationLayers)
{
QString layerName;
RenderingMode renderMode = defaultRenderingMode;
SurfacePlacement surfacePlacement = defaultSurfacePlacement;
// RenderingMode configured in layername?
if (logicalLayerNameEncoded.contains(QLatin1Char(':')))
{
const QStringList &sl = logicalLayerNameEncoded.split(QLatin1Char(':'));
if (sl.size() != 3)
{
ERROR_LOG(m_logger) << LOGFUNCTION << " logicalLayerName configuration not correct."
<< ", logicalLayerName='" << logicalLayerNameEncoded << "'";
return false;
}
// Layername:
layerName = sl.first();
// RenderingMode
const QString &rmName = sl[1];
if (!fromString(renderMode, rmName))
{
ERROR_LOG(m_logger) << LOGFUNCTION << " parseError on renderMode: rmName='" << rmName << "'";
return false;
}
// SurfacePlacement
const QString &spName = sl[2];
if (!fromString(surfacePlacement, spName))
{
ERROR_LOG(m_logger) << LOGFUNCTION << " parseError on surfacePlacement: spName='" << rmName << "'";
return false;
}
} // if (logicalLayerName.contains(QLatin1Char(':')))
DEBUG_LOG(m_logger) << LOGFUNCTION << " logicalLayerName configuration"
<< ", logicalLayerNameEncoded='" << logicalLayerNameEncoded << "'"
<< ", layerName='" << layerName << "'"
<< " set to RM=" << renderMode
<< " set to SP=" << surfacePlacement;
QString displayName = layerName;
if (displayNames.contains(layerName))
displayName = displayNames[layerName];
if (! m_map.layerFactory().addOperationalLayer(layerName, displayName, renderMode, surfacePlacement))
{
ERROR_LOG(m_logger) << LOGFUNCTION
<< " addOperationalLayer failed, "
<< " layerName='" << layerName << "'";
return false;
}
} // foreach
return true;
}
bool MapInitializer::initializeUniqueValueRendererForCubes()
{
const QString &operationLayers4Cubes = m_mapSettings.operationalLayerForCubes();
if (operationLayers4Cubes.isEmpty())
{
ERROR_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")"
<< " operationalLayerForCubes missing";
return false;
}
m_map.layerFactory().setLayernameForCubes(operationLayers4Cubes);
return m_map.layerFactory().assignUniqueValueRendererForCubes();
}
bool MapInitializer::initializeExtraSymbolDirectory()
{
QString extraSymbolDir = m_mapSettings.extraSymbolDirectory();
if (extraSymbolDir.isEmpty())
return true;
// do it just once
// data is global and already store in SymbolDictionary
// see MapInitializer::initializeExtraSymbolDirectory and InterfaceImpl::reCreateSituationMapInit
static bool s_alreadyInitialized = false;
if (s_alreadyInitialized)
{
INFO_LOG(m_logger) << LOGFUNCTION << " EtsSymbols already initialized";
return true;
}
s_alreadyInitialized = true;
int addedFiles = m_map.symbolDictionary().addEtsSymbols(extraSymbolDir);
return addedFiles > 0;
}
bool MapInitializer::initializeAnimations()
{
// animationDuration
double animationDuration = m_mapSettings.animationDuration();
if (animationDuration > 0)
m_map.setAnimationDuration(animationDuration);
// animationDuration for 'rocket'
double rocketDuration = m_mapSettings.rocketDuration();
if (rocketDuration > 0)
m_map.setRocketDuration(rocketDuration);
return true;
}
//----------------------------------------------------------------------------
bool MapInitializer::initializeGrid()
{
GridType gridType = m_mapSettings.gridType();
switch (gridType)
{
case GridType::NoType:
//m_map.grid().setGridType(gridType);
m_map.grid().setVisible(false);
break;
case GridType::LatLon:
case GridType::MGRS:
case GridType::USGN:
case GridType::UTM:
m_map.grid().setGridType(gridType);
m_map.grid().setVisible(true);
break;
}
return true;
}
bool MapInitializer::initializeObjectFactory()
{
INFO_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " must be overloaded!!!";
return false;
}
//----------------------------------------------------------------------------
bool MapInitializer::setObjectContainer()
{
// use default
return true;
}
bool MapInitializer::initializeRubberFactory()
{
m_map.rubberbandFactory().setRubberbandDrawColor(m_mapSettings.rubberbandDrawColor());
m_map.rubberbandFactory().setRubberbandFillColor(m_mapSettings.rubberbandFillColor());
m_map.rubberbandFactory().setRubberbandHandleDrawColor(m_mapSettings.rubberbandHandleDrawColor());
m_map.rubberbandFactory().setRubberbandHandleFillColor(m_mapSettings.rubberbandHandleFillColor());
m_map.rubberbandFactory().setRubberbandSelectionColor(m_mapSettings.rubberbandSelectionColor());
m_map.rubberbandFactory().setRubberbandFrameColor(m_mapSettings.rubberbandFrameColor());
m_map.rubberbandFactory().setRubberbandFrameFillColor(m_mapSettings.rubberbandFrameFillColor());
m_map.rubberbandFactory().setRubberbandFrameHandleMargin(m_mapSettings.rubberbandFrameHandleMargin());
m_map.rubberbandFactory().setRubberbandPreviewOffset(m_mapSettings.rubberbandPreviewOffset());
m_map.rubberbandFactory().setRubberbandPreviewSize(m_mapSettings.rubberbandPreviewSize());
m_map.rubberbandFactory().setRubberbandPickingRatio(m_mapSettings.rubberbandPickingRatio());
m_map.rubberbandFactory().setRubberbandLineHandleWidth(m_mapSettings.rubberbandLineHandleWidth());
SituationMap::RB::EventMouseNavigator::setPickTolerance(m_mapSettings.rubberbandPickingRatio());
SituationMap::RB::EventMouseNavigator::setZoomFactorBase(m_mapSettings.zoomFactorBase());
return true;
} // MapInitializer::initializeRubberFactory()
//----------------------------------------------------------------------------
bool MapInitializer::initializeCoordTranslationFunctor()
{
m_map.initCoordTranslationFunctor();
return true;
}
bool MapInitializer::initializeMapWidgets()
{
if (m_mapSettings.addMapWidgets())
m_map.addMapWidget();
return true;
}
bool MapInitializer::initializeSideBar()
{
if (m_mapSettings.addSideBar())
m_map.addSideBar();
return true;
}
bool MapInitializer::setViewshedUrl()
{
QString viewshedUrl = m_mapSettings.viewshedUrl();
if (!viewshedUrl.isEmpty())
m_map.viewshed().setViewshedUrl(viewshedUrl);
return true;
}
void MapInitializer::onMapReady()
{
TRACE_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " START";
// center / scale :
if (m_map.initialViewpoint().isNull())
{
const QString &centerPointMgrsIni = m_mapSettings.centerPointMgrs();
double scaleIni = m_mapSettings.scale();
if (m_viewPoint.isNull())
{
const QPointF &centerPointGeo = LtsCoordTrans::geographicFromMgrs(centerPointMgrsIni);
m_viewPoint.setCenterGeo(centerPointGeo);
m_viewPoint.setScale(scaleIni);
}
INFO_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")"
<< " centerPointMgrsIni=" << centerPointMgrsIni
<< " scaleIni=" << scaleIni
<< " m_viewPoint=" << m_viewPoint;
// setViewpoint2D works for 2D and 3D
m_map.setViewpoint2D(m_viewPoint); // QPointF(92750, 80525) -> Rennplatz - Bremen
}
else
{
const Viewpoint2D &iVp = m_map.initialViewpoint();
INFO_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")"
<< " skip 'setViewpoint2D' due to setInitialViewpoint"
<< " (" << iVp << ")";
}
// : center / scale
// minMaxScale is optional:
double minScale = m_mapSettings.minScale();
double maxScale = m_mapSettings.maxScale();
INFO_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")"
<< " ini -> minScale=" << minScale
<< " maxScale=" << maxScale;
if (minScale > 1)
m_map.setMinScale(minScale); // big value (e.g. 10000000)
if (maxScale > 1)
m_map.setMaxScale(maxScale); // small value (e.g. 100)
// scaleHasVisibility:
double scaleHasVisibility = m_mapSettings.scaleHasVisibility();
// set static value (valid for all mapObjects):
AbstractMapObject::setScaleHasVisibility(scaleHasVisibility);
TRACE_LOG(m_logger) << LOGFUNCTION << "(" << m_debugName << ")" << " END";
}
//----------------------------------------------------------------------------
} // namespace SituationMap
Reference in new issue View Git Blame Copy Permalink