1130 lines
37 KiB
C++
Executable File
1130 lines
37 KiB
C++
Executable File
/**
|
||
* @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 <QCoreApplication>
|
||
#include <QJsonDocument>
|
||
#include <QJsonObject>
|
||
#include <QJsonArray>
|
||
#include <QNetworkProxy>
|
||
#include <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 ¢erPointMgrsIni = m_mapSettings.centerPointMgrs();
|
||
double scaleIni = m_mapSettings.scale();
|
||
|
||
if (m_viewPoint.isNull())
|
||
{
|
||
const QPointF ¢erPointGeo = 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 ¢erPointMgrsIni = m_mapSettings.centerPointMgrs();
|
||
double scaleIni = m_mapSettings.scale();
|
||
|
||
if (m_viewPoint.isNull())
|
||
{
|
||
const QPointF ¢erPointGeo = 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
|
||
|