752 lines
21 KiB
C++
Executable File
752 lines
21 KiB
C++
Executable File
/**
|
|
* @RDE_HEADER@
|
|
* Utilities for SituationMap
|
|
* $Id$
|
|
* $HeadURL$
|
|
* $Author$
|
|
*/
|
|
|
|
// Own
|
|
#include "situation_map_utils.h"
|
|
#include "abstract_effect_simulation.h"
|
|
|
|
|
|
// Esri
|
|
#include <arcgis/CoreTypes.h> // for LicenseStatus
|
|
#include <arcgis/MapTypes.h>
|
|
#include <arcgis/Viewpoint.h>
|
|
#include <arcgis/Camera.h>
|
|
|
|
|
|
#include <arcgis/arcgisversion.h> // This file is created by RME, not ESRI
|
|
|
|
#if ACRGIS_VERSION >= 0x640600 // 100.6.0 / Update 6
|
|
#define HAS_SURFACEPLACEMENT_RELATIVETOSCENE
|
|
#endif
|
|
|
|
|
|
// Qt
|
|
#include <QString>
|
|
#include <QPointF>
|
|
#include <QRect>
|
|
|
|
#include <sstream>
|
|
|
|
|
|
std::ostream &operator<< (std::ostream &stream,
|
|
const SituationMap::PositionCont &value)
|
|
{
|
|
stream << "PosCont(" << value.size() << "): ";
|
|
for (const SituationMap::Point3D &item : value)
|
|
stream << item << ";";
|
|
return stream;
|
|
}
|
|
|
|
|
|
//std::ostream& operator<< (std::ostream& stream,
|
|
// const QRect& value)
|
|
//{
|
|
// stream << "QRect(topLeft=" << value.topLeft()
|
|
// << " bottomRight=" << value.bottomRight()
|
|
// << " width=" << value.width()
|
|
// << " height=" << value.height()
|
|
// << " center=" << value.center()
|
|
// << " bottom=" << value.bottom()
|
|
// << " left=" << value.left()
|
|
// << ")";
|
|
// return stream;
|
|
//}
|
|
|
|
QString toString(const QRectF &value)
|
|
{
|
|
std::ostringstream stream;
|
|
stream << "QRect(topLeft=" << value.topLeft()
|
|
<< " bottomRight=" << value.bottomRight()
|
|
<< " width=" << value.width()
|
|
<< " height=" << value.height()
|
|
<< " center=" << value.center()
|
|
<< " bottom=" << value.bottom()
|
|
<< " left=" << value.left()
|
|
<< ")";
|
|
return QString::fromStdString(stream.str());
|
|
}
|
|
|
|
|
|
std::ostream &operator<<(std::ostream &stream, const QColor &value)
|
|
{
|
|
stream << "QColor("
|
|
<< value.name(QColor::HexArgb).toUtf8().data()
|
|
<< ")";
|
|
return stream;
|
|
}
|
|
|
|
QString toString(const QColor &value)
|
|
{
|
|
return value.name(QColor::HexArgb);
|
|
}
|
|
|
|
|
|
|
|
namespace SituationMap
|
|
{
|
|
QString toString(const AesEffectState value)
|
|
{
|
|
switch (value)
|
|
{
|
|
case AesEffectState::Removed:
|
|
return QStringLiteral("AesRemoved");
|
|
case AesEffectState::Expired:
|
|
return QStringLiteral("AesExpired");
|
|
case AesEffectState::Error:
|
|
return QStringLiteral("AesError");
|
|
case AesEffectState::Paused:
|
|
return QStringLiteral("AesPaused");
|
|
case AesEffectState::Prepared:
|
|
return QStringLiteral("AesExpired");
|
|
case AesEffectState::Created:
|
|
return QStringLiteral("AesCreated");
|
|
case AesEffectState::Activated:
|
|
return QStringLiteral("AesActivated");
|
|
case AesEffectState::Unknown:
|
|
return QStringLiteral("AesUnknown");
|
|
} // switch
|
|
Q_ASSERT(false);
|
|
return QStringLiteral("AesEffectStateERROR");
|
|
}
|
|
|
|
std::ostream &operator<< (std::ostream &stream,
|
|
const AesEffectState &value)
|
|
{
|
|
stream << toString(value).data();
|
|
return stream;
|
|
}
|
|
|
|
QString toString(DrawStatus value)
|
|
{
|
|
switch (value)
|
|
{
|
|
case SituationMap::DrawStatus::InProgress:
|
|
return QStringLiteral("DSInProgress");
|
|
case SituationMap::DrawStatus::Completed:
|
|
return QStringLiteral("DSCompleted");
|
|
} // switch
|
|
Q_ASSERT(false);
|
|
return QStringLiteral("DrawStatusERROR");
|
|
}
|
|
|
|
|
|
QString toString(GridType value)
|
|
{
|
|
switch (value)
|
|
{
|
|
case GridType::NoType:
|
|
return QStringLiteral("NoType");
|
|
case GridType::LatLon:
|
|
return QStringLiteral("LatLon");
|
|
case GridType::MGRS:
|
|
return QStringLiteral("MGRS");
|
|
case GridType::USGN:
|
|
return QStringLiteral("USGN");
|
|
case GridType::UTM:
|
|
return QStringLiteral("UTM");
|
|
} // switch
|
|
Q_ASSERT(false);
|
|
return QStringLiteral("GridTypeERROR");
|
|
}
|
|
|
|
QString toString(LayerType value)
|
|
{
|
|
switch (value)
|
|
{
|
|
case LayerType::Undefined:
|
|
return QStringLiteral("LTUndefined");
|
|
case LayerType::Basemap:
|
|
return QStringLiteral("LTBasemap");
|
|
case LayerType::JumpPoint:
|
|
return QStringLiteral("LTJumpPoint");
|
|
case LayerType::SnapshotOverlay:
|
|
return QStringLiteral("LTSnapshotOverlay");
|
|
case LayerType::Overlay:
|
|
return QStringLiteral("LTOverlay");
|
|
case LayerType::Operational:
|
|
return QStringLiteral("LTOperational");
|
|
case LayerType::Tools:
|
|
return QStringLiteral("LTTools");
|
|
case LayerType::Rubberband:
|
|
return QStringLiteral("LTRubberband");
|
|
case LayerType::EmergencyCall:
|
|
return QStringLiteral("LTEmergencyCall");
|
|
} // switch
|
|
Q_ASSERT(false);
|
|
return QStringLiteral("LayerTypeERROR");
|
|
}
|
|
|
|
QString toString(BasemapType value)
|
|
{
|
|
switch (value)
|
|
{
|
|
case BasemapType::Undefined:
|
|
return QStringLiteral("BMTUndefined");
|
|
case BasemapType::Aerial:
|
|
return QStringLiteral("BMTAerial");
|
|
case BasemapType::Topographic:
|
|
return QStringLiteral("BMTTopographic");
|
|
} // switch
|
|
Q_ASSERT(false);
|
|
return QStringLiteral("BasemapTypeERROR");
|
|
}
|
|
|
|
QString toString(SituationMap::RenderingMode value)
|
|
{
|
|
switch (value)
|
|
{
|
|
case RenderingMode::Dynamic:
|
|
return QStringLiteral("Dynamic");
|
|
case RenderingMode::Static:
|
|
return QStringLiteral("Static");
|
|
} // switch
|
|
Q_ASSERT(false);
|
|
return QStringLiteral("RenderingModeERROR");
|
|
}
|
|
bool fromString(RenderingMode &renderingMode, const QString &str)
|
|
{
|
|
if (str.compare(QStringLiteral("Dynamic")) == 0)
|
|
{
|
|
renderingMode = RenderingMode::Dynamic;
|
|
return true;
|
|
}
|
|
if (str.compare(QStringLiteral("Static")) == 0)
|
|
{
|
|
renderingMode = RenderingMode::Static;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
QString toString(SurfacePlacement value)
|
|
{
|
|
switch (value)
|
|
{
|
|
case SurfacePlacement::Draped:
|
|
return QStringLiteral("Draped");
|
|
case SurfacePlacement::Absolute:
|
|
return QStringLiteral("Absolute");
|
|
case SurfacePlacement::Relative:
|
|
return QStringLiteral("Relative");
|
|
} // switch
|
|
Q_ASSERT(false);
|
|
return QStringLiteral("SurfacePlacementERROR");
|
|
}
|
|
|
|
bool fromString(SituationMap::SurfacePlacement &surfacePlacement, const QString &str)
|
|
{
|
|
if (str.compare(QStringLiteral("Draped")) == 0)
|
|
{
|
|
surfacePlacement = SurfacePlacement::Draped;
|
|
return true;
|
|
}
|
|
if (str.compare(QStringLiteral("Absolute")) == 0)
|
|
{
|
|
surfacePlacement = SurfacePlacement::Absolute;
|
|
return true;
|
|
}
|
|
if (str.compare(QStringLiteral("Relative")) == 0)
|
|
{
|
|
surfacePlacement = SurfacePlacement::Relative;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
QString toDisplayString(BasemapType value)
|
|
{
|
|
switch (value)
|
|
{
|
|
case BasemapType::Undefined:
|
|
return QStringLiteral("TUndefined");
|
|
case BasemapType::Aerial:
|
|
return QStringLiteral("Aerial");
|
|
case BasemapType::Topographic:
|
|
return QStringLiteral("Topographic");
|
|
} // switch
|
|
Q_ASSERT(false);
|
|
return QStringLiteral("BasemapTypeERROR");
|
|
}
|
|
|
|
|
|
|
|
bool fromString(GridType &gridType, const QString &str)
|
|
{
|
|
if (str.compare(QStringLiteral("NoType")) == 0)
|
|
{
|
|
gridType = GridType::NoType;
|
|
return true;
|
|
}
|
|
if (str.compare(QStringLiteral("MGRS"), Qt::CaseInsensitive) == 0)
|
|
{
|
|
gridType = GridType::MGRS;
|
|
return true;
|
|
}
|
|
if (str.compare(QStringLiteral("UTM"), Qt::CaseInsensitive) == 0)
|
|
{
|
|
gridType = GridType::UTM;
|
|
return true;
|
|
}
|
|
if (str.compare(QStringLiteral("USGN"), Qt::CaseInsensitive) == 0)
|
|
{
|
|
gridType = GridType::USGN;
|
|
return true;
|
|
}
|
|
if (str.compare(QStringLiteral("LatLon"), Qt::CaseInsensitive) == 0)
|
|
{
|
|
gridType = GridType::LatLon;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
std::ostream &operator<< (std::ostream &stream,
|
|
const DrawStatus value)
|
|
{
|
|
stream << toString(value).data();
|
|
return stream;
|
|
}
|
|
|
|
std::ostream &operator<< (std::ostream &stream,
|
|
const GridType value)
|
|
{
|
|
stream << toString(value).data();
|
|
return stream;
|
|
}
|
|
|
|
std::ostream &operator<< (std::ostream &stream,
|
|
const SituationMap::LayerType value)
|
|
{
|
|
stream << toString(value).data();
|
|
return stream;
|
|
}
|
|
|
|
std::ostream &operator<< (std::ostream &stream,
|
|
const SituationMap::BasemapType value)
|
|
{
|
|
stream << toString(value).data();
|
|
return stream;
|
|
}
|
|
|
|
std::ostream &operator<< (std::ostream &stream,
|
|
const SituationMap::RenderingMode value)
|
|
{
|
|
stream << toString(value).data();
|
|
return stream;
|
|
}
|
|
|
|
std::ostream &operator<< (std::ostream &stream,
|
|
const SituationMap::SurfacePlacement value)
|
|
{
|
|
stream << toString(value).data();
|
|
return stream;
|
|
}
|
|
|
|
std::ostream &operator<< (std::ostream &stream,
|
|
const SituationMap::EsriNetworkCacheSettings value)
|
|
{
|
|
stream << "EsriNetworkCacheSettings: ";
|
|
stream << value.toString();
|
|
return stream;
|
|
}
|
|
|
|
} // namespace SituationMap
|
|
|
|
//------------------------------------------------------------------------------
|
|
// namespace Esri::ArcGISRuntime
|
|
namespace Esri
|
|
{
|
|
namespace ArcGISRuntime
|
|
{
|
|
|
|
std::ostream &operator<< (std::ostream &stream,
|
|
const Esri::ArcGISRuntime::Error &value)
|
|
{
|
|
stream << toString(value);
|
|
return stream;
|
|
}
|
|
|
|
QString toString(const Error &value)
|
|
{
|
|
std::ostringstream stream;
|
|
stream << "Esri::ArcGISRuntime::Error: "
|
|
<< " code=" << value.code()
|
|
<< ", domain=" << (int)value.domain()
|
|
<< ", extendedErrorType=" << (int)value.extendedErrorType()
|
|
<< ", message='" << value.message() << "'"
|
|
<< ", additionalMessage='" << value.additionalMessage() << "'";
|
|
return QString::fromStdString(stream.str());
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
std::ostream &operator<< (std::ostream &stream,
|
|
const Esri::ArcGISRuntime::LicenseStatus value)
|
|
{
|
|
stream << "EsriLicenseStatus(" << toString(value)
|
|
<< ")";
|
|
return stream;
|
|
}
|
|
|
|
QString toString(const Esri::ArcGISRuntime::LicenseStatus value)
|
|
{
|
|
switch (value)
|
|
{
|
|
case Esri::ArcGISRuntime::LicenseStatus::Invalid:
|
|
return QStringLiteral("Invalid");
|
|
case Esri::ArcGISRuntime::LicenseStatus::Expired:
|
|
return QStringLiteral("Expired");
|
|
case Esri::ArcGISRuntime::LicenseStatus::LoginRequired:
|
|
return QStringLiteral("LoginRequired");
|
|
case Esri::ArcGISRuntime::LicenseStatus::Valid:
|
|
return QStringLiteral("Valid");
|
|
} // switch
|
|
Q_ASSERT(false);
|
|
return QStringLiteral("Esri-LicenseStatusERROR");
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
#if ACRGIS_VERSION >= 0x640800 // 100.8.0 / Update 8
|
|
std::ostream &operator<< (std::ostream &stream,
|
|
const Esri::ArcGISRuntime::NetworkCachePolicy value)
|
|
{
|
|
stream << "EsriNCP(" << toString(value)
|
|
<< ")";
|
|
return stream;
|
|
}
|
|
QString toString(const NetworkCachePolicy value)
|
|
{
|
|
switch (value)
|
|
{
|
|
case Esri::ArcGISRuntime::NetworkCachePolicy::AlwaysCache:
|
|
return QStringLiteral("AlwaysCache");
|
|
case Esri::ArcGISRuntime::NetworkCachePolicy::AlwaysNetwork:
|
|
return QStringLiteral("AlwaysNetwork");
|
|
case Esri::ArcGISRuntime::NetworkCachePolicy::PreferCache:
|
|
return QStringLiteral("PreferCache");
|
|
case Esri::ArcGISRuntime::NetworkCachePolicy::PreferNetwork:
|
|
return QStringLiteral("PreferNetwork");
|
|
} // switch
|
|
Q_ASSERT(false);
|
|
return QStringLiteral("Esri-NetworkCachePolicyERROR");
|
|
}
|
|
#endif // ACRGIS_VERSION
|
|
|
|
//------------------------------------------------------------------------------
|
|
std::ostream &operator<< (std::ostream &stream,
|
|
const Esri::ArcGISRuntime::LoadStatus value)
|
|
{
|
|
stream << "EsriLS(" << toString(value)
|
|
<< ")";
|
|
return stream;
|
|
}
|
|
|
|
QString toString(const Esri::ArcGISRuntime::LoadStatus value)
|
|
{
|
|
switch (value)
|
|
{
|
|
case Esri::ArcGISRuntime::LoadStatus::Loaded:
|
|
return QStringLiteral("Loaded");
|
|
case Esri::ArcGISRuntime::LoadStatus::Loading:
|
|
return QStringLiteral("Loading");
|
|
case Esri::ArcGISRuntime::LoadStatus::FailedToLoad:
|
|
return QStringLiteral("FailedToLoad");
|
|
case Esri::ArcGISRuntime::LoadStatus::NotLoaded:
|
|
return QStringLiteral("NotLoaded");
|
|
case Esri::ArcGISRuntime::LoadStatus::Unknown:
|
|
return QStringLiteral("Unknown");
|
|
} // switch
|
|
Q_ASSERT(false);
|
|
return QStringLiteral("Esri-LoadStatusERROR");
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
std::ostream &operator<< (std::ostream &stream,
|
|
const Esri::ArcGISRuntime::LayerType value)
|
|
{
|
|
stream << "EsriLT(" << toString(value)
|
|
<< ")";
|
|
return stream;
|
|
}
|
|
|
|
QString toString(const Esri::ArcGISRuntime::LayerType value)
|
|
{
|
|
switch (value)
|
|
{
|
|
case Esri::ArcGISRuntime::LayerType::ImageTiledLayer:
|
|
return QStringLiteral("ImageTiledLayer");
|
|
case Esri::ArcGISRuntime::LayerType::ServiceImageTiledLayer:
|
|
return QStringLiteral("ServiceImageTiledLayer");
|
|
case Esri::ArcGISRuntime::LayerType::ArcGISMapImageLayer:
|
|
return QStringLiteral("ArcGISMapImageLayer");
|
|
case Esri::ArcGISRuntime::LayerType::ArcGISTiledLayer:
|
|
return QStringLiteral("ArcGISTiledLayer");
|
|
case Esri::ArcGISRuntime::LayerType::FeatureCollectionLayer:
|
|
return QStringLiteral("FeatureCollectionLayer");
|
|
case Esri::ArcGISRuntime::LayerType::FeatureLayer:
|
|
return QStringLiteral("FeatureLayer");
|
|
case Esri::ArcGISRuntime::LayerType::KMLLayer:
|
|
return QStringLiteral("KMLLayer");
|
|
case Esri::ArcGISRuntime::LayerType::BingMapLayer:
|
|
return QStringLiteral("BingMapLayer");
|
|
case Esri::ArcGISRuntime::LayerType::RasterLayer:
|
|
return QStringLiteral("RasterLayer");
|
|
case Esri::ArcGISRuntime::LayerType::UnsupportedLayer:
|
|
return QStringLiteral("UnsupportedLayer");
|
|
case Esri::ArcGISRuntime::LayerType::MobileBasemapLayer:
|
|
return QStringLiteral("MobileBasemapLayer");
|
|
case Esri::ArcGISRuntime::LayerType::ArcGISVectorTiledLayer:
|
|
return QStringLiteral("ArcGISVectorTiledLayer");
|
|
case Esri::ArcGISRuntime::LayerType::ArcGISSceneLayer:
|
|
return QStringLiteral("ArcGISSceneLayer");
|
|
case Esri::ArcGISRuntime::LayerType::WmtsLayer:
|
|
return QStringLiteral("WmtsLayer");
|
|
case Esri::ArcGISRuntime::LayerType::OpenStreetMapLayer:
|
|
return QStringLiteral("OpenStreetMapLayer");
|
|
case Esri::ArcGISRuntime::LayerType::BingMapsLayer:
|
|
return QStringLiteral("BingMapsLayer");
|
|
case Esri::ArcGISRuntime::LayerType::WebTiledLayer:
|
|
return QStringLiteral("WebTiledLayer");
|
|
case Esri::ArcGISRuntime::LayerType::EncLayer:
|
|
return QStringLiteral("EncLayer");
|
|
case Esri::ArcGISRuntime::LayerType::WmsLayer:
|
|
return QStringLiteral("WmsLayer");
|
|
|
|
#if ACRGIS_VERSION >= 0x640500 // 100.5.0 / Update 5
|
|
case Esri::ArcGISRuntime::LayerType::IntegratedMeshLayer:
|
|
return QStringLiteral("IntegratedMeshLayer");
|
|
case Esri::ArcGISRuntime::LayerType::PointCloudLayer:
|
|
return QStringLiteral("PointCloudLayer");
|
|
case Esri::ArcGISRuntime::LayerType::GroupLayer:
|
|
return QStringLiteral("GroupLayer");
|
|
case Esri::ArcGISRuntime::LayerType::AnnotationLayer:
|
|
return QStringLiteral("AnnotationLayer");
|
|
#endif // ACRGIS_VERSION
|
|
|
|
#if ACRGIS_VERSION >= 0x640700 // 100.7.0 / Update 7
|
|
case Esri::ArcGISRuntime::LayerType::SubtypeFeatureLayer:
|
|
return QStringLiteral("SubtypeFeatureLayer");
|
|
#endif // ACRGIS_VERSION
|
|
|
|
#if ACRGIS_VERSION >= 0x640D00 // 100.13.0
|
|
case Esri::ArcGISRuntime::LayerType::DimensionLayer:
|
|
return QStringLiteral("SubtypeFeatureLayer");
|
|
#endif // ACRGIS_VERSION
|
|
|
|
case Esri::ArcGISRuntime::LayerType::UnknownLayer:
|
|
return QStringLiteral("UnknownLayer");
|
|
|
|
} // switch
|
|
Q_ASSERT(false);
|
|
return QStringLiteral("Esri-LayerTypeERROR");
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
|
|
std::ostream &operator<< (std::ostream &stream,
|
|
const Esri::ArcGISRuntime::ElevationSourceType value)
|
|
{
|
|
stream << "EsriEST(" << toString(value)
|
|
<< ")";
|
|
return stream;
|
|
}
|
|
|
|
QString toString(const Esri::ArcGISRuntime::ElevationSourceType value)
|
|
{
|
|
switch (value)
|
|
{
|
|
case Esri::ArcGISRuntime::ElevationSourceType::Unknown:
|
|
return QStringLiteral("Unknown");
|
|
case Esri::ArcGISRuntime::ElevationSourceType::ArcGISTiledElevationSource:
|
|
return QStringLiteral("ArcGISTiledElevationSource");
|
|
case Esri::ArcGISRuntime::ElevationSourceType::RasterElevationSource:
|
|
return QStringLiteral("RasterElevationSource");
|
|
} // switch
|
|
Q_ASSERT(false);
|
|
return QStringLiteral("Esri-ElevationSourceTypeERROR");
|
|
}
|
|
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
std::ostream &operator<< (std::ostream &stream,
|
|
const Esri::ArcGISRuntime::GraphicsRenderingMode value)
|
|
{
|
|
stream << "EsriGRM(" << toString(value)
|
|
<< ")";
|
|
return stream;
|
|
}
|
|
|
|
QString toString(const Esri::ArcGISRuntime::GraphicsRenderingMode value)
|
|
{
|
|
switch (value)
|
|
{
|
|
case Esri::ArcGISRuntime::GraphicsRenderingMode::Dynamic:
|
|
return QStringLiteral("Dynamic");
|
|
case Esri::ArcGISRuntime::GraphicsRenderingMode::Static:
|
|
return QStringLiteral("Static");
|
|
} // switch
|
|
Q_ASSERT(false);
|
|
return QStringLiteral("Esri-GraphicsRenderingModeERROR");
|
|
}
|
|
|
|
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
std::ostream &operator<< (std::ostream &stream,
|
|
const Esri::ArcGISRuntime::GeometryType value)
|
|
{
|
|
stream << "EsriGT(" << toString(value) << ")";
|
|
return stream;
|
|
}
|
|
|
|
QString toString(const Esri::ArcGISRuntime::GeometryType value)
|
|
{
|
|
switch (value)
|
|
{
|
|
case Esri::ArcGISRuntime::GeometryType::Unknown:
|
|
return QStringLiteral("Unknown");
|
|
case Esri::ArcGISRuntime::GeometryType::Point:
|
|
return QStringLiteral("Point");
|
|
case Esri::ArcGISRuntime::GeometryType::Envelope:
|
|
return QStringLiteral("Envelope");
|
|
case Esri::ArcGISRuntime::GeometryType::Polyline:
|
|
return QStringLiteral("Polyline");
|
|
case Esri::ArcGISRuntime::GeometryType::Polygon:
|
|
return QStringLiteral("Polygon");
|
|
case Esri::ArcGISRuntime::GeometryType::Multipoint:
|
|
return QStringLiteral("Multipoint");
|
|
} // switch
|
|
Q_ASSERT(false);
|
|
return QStringLiteral("Esri-GeometryTypeERROR");
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
std::ostream &operator<< (std::ostream &stream,
|
|
const Esri::ArcGISRuntime::ViewpointType value)
|
|
{
|
|
stream << "EsriVPT(" << toString(value) << ")";
|
|
return stream;
|
|
}
|
|
|
|
QString toString(const Esri::ArcGISRuntime::ViewpointType value)
|
|
{
|
|
switch (value)
|
|
{
|
|
case Esri::ArcGISRuntime::ViewpointType::Unknown:
|
|
return QStringLiteral("Unknown");
|
|
case Esri::ArcGISRuntime::ViewpointType::CenterAndScale:
|
|
return QStringLiteral("CenterAndScale");
|
|
case Esri::ArcGISRuntime::ViewpointType::BoundingGeometry:
|
|
return QStringLiteral("BoundingGeometry");
|
|
}// switch
|
|
Q_ASSERT(false);
|
|
return QStringLiteral("Esri-ViewpointTypeERROR");
|
|
}
|
|
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
std::ostream &operator<< (std::ostream &stream,
|
|
const Esri::ArcGISRuntime::SceneLocationVisibility value)
|
|
{
|
|
stream << "EsriSLV(" << toString(value) << ")";
|
|
return stream;
|
|
}
|
|
|
|
QString toString(const Esri::ArcGISRuntime::SceneLocationVisibility value)
|
|
{
|
|
switch (value)
|
|
{
|
|
case Esri::ArcGISRuntime::SceneLocationVisibility::Visible:
|
|
return QStringLiteral("Visible");
|
|
case Esri::ArcGISRuntime::SceneLocationVisibility::HiddenByBaseSurface:
|
|
return QStringLiteral("HiddenByBaseSurface");
|
|
case Esri::ArcGISRuntime::SceneLocationVisibility::HiddenByEarth:
|
|
return QStringLiteral("HiddenByEarth");
|
|
case Esri::ArcGISRuntime::SceneLocationVisibility::HiddenByElevation:
|
|
return QStringLiteral("HiddenByElevation");
|
|
case Esri::ArcGISRuntime::SceneLocationVisibility::NotOnScreen:
|
|
return QStringLiteral("NotOnScreen");
|
|
}// switch
|
|
Q_ASSERT(false);
|
|
return QStringLiteral("Esri-SceneLocationVisibilityERROR");
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
std::ostream &operator<< (std::ostream &stream,
|
|
const Esri::ArcGISRuntime::SurfacePlacement value)
|
|
{
|
|
stream << "EsriSP(" << toString(value) << ")";
|
|
return stream;
|
|
}
|
|
|
|
QString toString(Esri::ArcGISRuntime::SurfacePlacement value)
|
|
{
|
|
switch (value)
|
|
{
|
|
case Esri::ArcGISRuntime::SurfacePlacement::Draped:
|
|
return QStringLiteral("Draped");
|
|
case Esri::ArcGISRuntime::SurfacePlacement::Absolute:
|
|
return QStringLiteral("Absolute");
|
|
case Esri::ArcGISRuntime::SurfacePlacement::Relative:
|
|
return QStringLiteral("Relative");
|
|
|
|
#ifdef HAS_SURFACEPLACEMENT_RELATIVETOSCENE
|
|
case Esri::ArcGISRuntime::SurfacePlacement::RelativeToScene:
|
|
return QStringLiteral("RelativeToScene");
|
|
#endif // HAS_SURFACEPLACEMENT_RELATIVETOSCENE
|
|
|
|
#if ACRGIS_VERSION >= 0x640700 // 100.7.0 / Update 7
|
|
case Esri::ArcGISRuntime::SurfacePlacement::DrapedFlat:
|
|
return QStringLiteral("DrapedFlat");
|
|
#endif // ACRGIS_VERSION
|
|
|
|
}// switch
|
|
Q_ASSERT(false);
|
|
return QStringLiteral("Esri-SurfacePlacementERROR");
|
|
}
|
|
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
std::ostream &operator<< (std::ostream &stream,
|
|
const Esri::ArcGISRuntime::Viewpoint &value)
|
|
{
|
|
stream << "EsriVP:"
|
|
<< " targetGeometryType=" << value.targetGeometry().geometryType();
|
|
if (value.targetGeometry().geometryType() == Esri::ArcGISRuntime::GeometryType::Point)
|
|
{
|
|
const Esri::ArcGISRuntime::Point center(value.targetGeometry());
|
|
stream << " center: x=" << center.x() << " - y=" << center.y() << " - z=" << center.z();
|
|
}
|
|
stream << " rotation=" << value.rotation()
|
|
<< " targetScale=" << value.targetScale();
|
|
return stream;
|
|
}
|
|
|
|
std::ostream &operator<< (std::ostream &stream,
|
|
const Esri::ArcGISRuntime::Camera &value)
|
|
{
|
|
const Esri::ArcGISRuntime::Point &location = value.location();
|
|
stream << "EsriCam:"
|
|
<< " location: xLon=" << location.x() << " - yLat=" << location.y() << " - z=" << location.z()
|
|
<< " ; h=" << value.heading() << " p=" << value.pitch() << " r=" << value.roll();
|
|
return stream;
|
|
}
|
|
|
|
|
|
}
|
|
} // namespace Esri::ArcGISRuntime
|