1206 lines
35 KiB
C++
Executable File
1206 lines
35 KiB
C++
Executable File
/**
|
|
* @RDE_HEADER@
|
|
* Interface-Implementation of AbstractMapObject
|
|
* $Id$
|
|
* $HeadURL$
|
|
* $Author$
|
|
*/
|
|
|
|
// Own
|
|
#include "abstract_map_object_impl.h"
|
|
#include "map_impl.h"
|
|
#include "object_container_impl.h"
|
|
|
|
#include <Map/party_id_to_color_functor.h>
|
|
|
|
#include <MathUtils/geometry_engine.h>
|
|
|
|
#include <GraphicalObjects/abstract_graphical_object.h>
|
|
#include <GraphicalObjects/graphical_object_text.h>
|
|
#include <GraphicalObjects/graphical_object_cube.h>
|
|
#include <GraphicalObjects/graphical_object_path.h>
|
|
#include <GraphicalObjects/tactical_appearance.h>
|
|
#include <Map/bounding_box.h>
|
|
|
|
|
|
// ESRI
|
|
#include <arcgis/Graphic.h>
|
|
#include <arcgis/GraphicsOverlay.h>
|
|
#include <arcgis/LayerSceneProperties.h>
|
|
|
|
|
|
// Qt
|
|
|
|
|
|
namespace SituationMap
|
|
{
|
|
|
|
struct ExtraData
|
|
{
|
|
QVector<QByteArray> propertyNames;
|
|
QVector<QVariant> propertyValues;
|
|
};
|
|
|
|
|
|
|
|
AbstractMapObjectImpl::AbstractMapObjectImpl(const QString &debugInfo)
|
|
: AbstractMapObject()
|
|
, m_uniqueMapId(SituationMap::INVALID_MAP_ID)
|
|
, m_logger(getLogger("AbstractMapObjectImpl"))
|
|
{
|
|
TRACE_LOG(m_logger) << LOGFUNCTION << " START" << " debugInfo='" << debugInfo << "'";
|
|
m_debugInfo = debugInfo;
|
|
TRACE_LOG(m_logger) << LOGFUNCTION << " END" << " debugInfo='" << debugInfo << "'";
|
|
} // AbstractMapObjectImpl::AbstractMapObjectImpl
|
|
|
|
|
|
AbstractMapObjectImpl::~AbstractMapObjectImpl()
|
|
{
|
|
TRACE_LOG(m_logger) << LOGFUNCTION << " START"
|
|
<< " debugInfo=" << m_debugInfo
|
|
<< " uniqueMapId=" << m_uniqueMapId;
|
|
delete m_mapConnector;
|
|
m_mapConnector = nullptr;
|
|
|
|
resetPin();
|
|
|
|
delete m_tacticalAppearance;
|
|
m_tacticalAppearance = nullptr;
|
|
|
|
delete m_mainGraphicalObjectText;
|
|
m_mainGraphicalObjectText = nullptr;
|
|
|
|
resetGraphicalObjectExtrusion();
|
|
|
|
delete m_mainGraphicalObject;
|
|
m_mainGraphicalObject = nullptr;
|
|
|
|
delete m_extraData;
|
|
m_extraData = nullptr;
|
|
|
|
TRACE_LOG(m_logger) << LOGFUNCTION << " END"
|
|
<< " debugInfo=" << m_debugInfo
|
|
<< " uniqueMapId=" << m_uniqueMapId;
|
|
|
|
} // AbstractMapObjectImpl::~AbstractMapObjectImpl
|
|
|
|
|
|
void AbstractMapObjectImpl::removeMySelf()
|
|
{
|
|
TRACE_LOG(m_logger) << LOGFUNCTION << " START"
|
|
<< " debugInfo=" << m_debugInfo;
|
|
|
|
// To avoid accessing already deleted variables make some local copies 2016/01/08 JT
|
|
QString debugInfo = m_debugInfo;
|
|
UniqueMapId uid = m_uniqueMapId;
|
|
SituationMap::LOGGER_T logger(m_logger);
|
|
|
|
if (m_mapImpl)
|
|
{
|
|
TRACE_LOG(m_logger) << "removeObject, uniqueMapId = " << m_uniqueMapId;
|
|
m_uniqueMapId = SituationMap::INVALID_MAP_ID;
|
|
m_mapImpl->objectContainer().removeObject(uid);
|
|
|
|
}
|
|
else
|
|
ERROR_LOG(m_logger) << LOGFUNCTION << " m_mapImpl does not exist.";
|
|
|
|
// Attention CRASH here if AbstractMapObject is not been referenced by a RefPointer. In this case the this-object has been deleted immediately 2016/01/08 JT
|
|
TRACE_LOG(logger) << LOGFUNCTION << " END"
|
|
<< " debugInfo=" << debugInfo;
|
|
}
|
|
|
|
bool AbstractMapObjectImpl::setProperty(const char *name, const QVariant &value)
|
|
{
|
|
// following setProperty/property approach is take from qt4.8.5:
|
|
|
|
if (!m_extraData)
|
|
m_extraData = new ExtraData;
|
|
|
|
const int idx = m_extraData->propertyNames.indexOf(name);
|
|
|
|
if (!value.isValid())
|
|
{
|
|
if (idx == -1)
|
|
return false;
|
|
m_extraData->propertyNames.removeAt(idx);
|
|
m_extraData->propertyValues.removeAt(idx);
|
|
}
|
|
else
|
|
{
|
|
if (idx == -1)
|
|
{
|
|
m_extraData->propertyNames.append(name);
|
|
m_extraData->propertyValues.append(value);
|
|
}
|
|
else
|
|
m_extraData->propertyValues[idx] = value;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
QVariant AbstractMapObjectImpl::property(const char *name) const
|
|
{
|
|
if (!m_extraData)
|
|
return QVariant();
|
|
const int i = m_extraData->propertyNames.indexOf(name);
|
|
return m_extraData->propertyValues.value(i);
|
|
}
|
|
|
|
|
|
UniqueMapId AbstractMapObjectImpl::uniqueMapId() const
|
|
{
|
|
return m_uniqueMapId;
|
|
}
|
|
|
|
|
|
QString AbstractMapObjectImpl::debugInfo() const
|
|
{
|
|
return m_debugInfo;
|
|
}
|
|
|
|
void AbstractMapObjectImpl::setDebugInfo(const QString &debugInfo)
|
|
{
|
|
m_debugInfo = debugInfo;
|
|
|
|
if (m_mainGraphicalObject)
|
|
m_mainGraphicalObject->setDebugInfo(m_debugInfo + QLatin1String("#mainGO"));
|
|
else
|
|
ERROR_LOG(m_logger) << LOGFUNCTION << " no object";
|
|
|
|
if (m_mainGraphicalObjectText)
|
|
m_mainGraphicalObjectText->setDebugInfo(m_debugInfo + QLatin1String("#Text"));
|
|
|
|
if (m_tacticalAppearance)
|
|
m_tacticalAppearance->setDebugInfo(m_debugInfo + QLatin1String("#TactApp"));
|
|
|
|
}
|
|
|
|
QString AbstractMapObjectImpl::toString() const
|
|
{
|
|
QString str;
|
|
|
|
if (!m_debugInfo.isEmpty())
|
|
str.append(QStringLiteral("debugInfo='%1'").arg(m_debugInfo));
|
|
|
|
str.append(QStringLiteral("uniqueMapId='%1'").arg(m_uniqueMapId));
|
|
|
|
if ((m_mainGraphicalObjectText) &&
|
|
(! m_mainGraphicalObjectText->text().isEmpty())
|
|
)
|
|
str.append(QStringLiteral(" identifier='%1'").arg(m_mainGraphicalObjectText->text()));
|
|
|
|
if (!m_logicalLayerName.isEmpty())
|
|
str.append(QStringLiteral(" logicalLayerName='%1'").arg(m_logicalLayerName));
|
|
|
|
str.append(QStringLiteral(" partyId=%1").arg(m_party.partyId.value()));
|
|
|
|
str.append(QStringLiteral(" aesState=%1").arg(SituationMap::toString(m_aesState.value())));
|
|
|
|
if (m_mainGraphicalObject)
|
|
str.append(QStringLiteral(" scale='%1'").arg(m_mainGraphicalObject->scale()));
|
|
|
|
str.append(QStringLiteral(" visibility='%1'").arg(m_visibility));
|
|
str.append(QStringLiteral(" visibilityTech='%1'").arg(m_visibilityTechnical));
|
|
str.append(QStringLiteral(" visibilityTact='%1'").arg(m_visibilityTactical));
|
|
str.append(QStringLiteral(" visibilityTechGeo='%1'").arg(m_visibilityTechnicalGeometry));
|
|
str.append(QStringLiteral(" identiferVisible=%1").arg(m_identiferVisible.value()));
|
|
str.append(QStringLiteral(" selected='%1'").arg(m_selected));
|
|
str.append(QStringLiteral(" pickable='%1'").arg(m_pickable));
|
|
|
|
str.append(QStringLiteral(" majorColor='%1'").arg(this->majorColor().name(QColor::HexArgb)));
|
|
|
|
return str;
|
|
}
|
|
|
|
void AbstractMapObjectImpl::boundingBox(SituationMap::BoundingBox &) const
|
|
{
|
|
// leave it empty and invalid. Method has to be overloaded if required.
|
|
}
|
|
|
|
|
|
void AbstractMapObjectImpl::setForceMajorColor(const QColor &majorColor)
|
|
{
|
|
m_forcedMajorColor = majorColor;
|
|
}
|
|
QColor AbstractMapObjectImpl::majorColor() const
|
|
{
|
|
if (m_forcedMajorColor.isValid())
|
|
return m_forcedMajorColor;
|
|
|
|
if (m_mainGraphicalObject)
|
|
return m_mainGraphicalObject->lineStyle().lineColor();
|
|
|
|
return QColor();
|
|
}
|
|
|
|
double AbstractMapObjectImpl::extrusionHeight() const
|
|
{
|
|
return m_extrusionHeight;
|
|
}
|
|
void AbstractMapObjectImpl::setExtrusionHeight(double extrusionHeight)
|
|
{
|
|
if (m_mapImpl->mode() != Mode::Mode_3D)
|
|
return;
|
|
|
|
m_extrusionHeight = extrusionHeight;
|
|
|
|
if (extrusionHeightValid())
|
|
createGraphicalObjectExtrusion();
|
|
else
|
|
resetGraphicalObjectExtrusion();
|
|
}
|
|
bool AbstractMapObjectImpl::extrusionHeightValid() const
|
|
{
|
|
return !std::isnan(m_extrusionHeight);
|
|
}
|
|
|
|
const QString AbstractMapObjectImpl::extrusionColorName() const
|
|
{
|
|
return m_extrusionColorName;
|
|
}
|
|
void AbstractMapObjectImpl::setExtrusionColorName(const QString &extrusionColorName)
|
|
{
|
|
m_extrusionColorName = extrusionColorName;
|
|
}
|
|
|
|
|
|
QString AbstractMapObjectImpl::identifier() const
|
|
{
|
|
if (m_mainGraphicalObjectText)
|
|
return m_mainGraphicalObjectText->text();
|
|
|
|
// else
|
|
// ERROR_LOG(m_logger) << LOGFUNCTION
|
|
// << " debugInfo=" << m_debugInfo
|
|
// << " no object"
|
|
// ;
|
|
|
|
return QString();
|
|
}
|
|
|
|
void AbstractMapObjectImpl::createGraphicalObjectText()
|
|
{
|
|
TRACE_LOG(m_logger) << LOGFUNCTION << " START"
|
|
<< " debugInfo=" << m_debugInfo;
|
|
|
|
if (!m_mainGraphicalObjectText)
|
|
{
|
|
m_mainGraphicalObjectText = new GraphicalObjectText(m_mapImpl->getEsriGeoView()
|
|
, m_graphicsLayer
|
|
, m_debugInfo + QLatin1String("#Text")
|
|
, uniqueMapId());
|
|
// Set default text style for all MapObjects:
|
|
m_mainGraphicalObjectText->setTextStyle(defaultTextStyle());
|
|
m_mainGraphicalObjectText->setXOffset(10); // use as initial default
|
|
}
|
|
|
|
TRACE_LOG(m_logger) << LOGFUNCTION << " END"
|
|
<< " debugInfo=" << m_debugInfo;
|
|
}
|
|
|
|
void AbstractMapObjectImpl::createTacticalAppearance()
|
|
{
|
|
TRACE_LOG(m_logger) << LOGFUNCTION << " START"
|
|
<< " debugInfo=" << m_debugInfo;
|
|
if (!m_tacticalAppearance)
|
|
{
|
|
m_tacticalAppearance = new TacticalAppearance(m_mapImpl,
|
|
m_logicalLayerName,
|
|
m_debugInfo + QStringLiteral("#TactApp"),
|
|
m_uniqueMapId
|
|
);
|
|
}
|
|
|
|
TRACE_LOG(m_logger) << LOGFUNCTION << " END"
|
|
<< " debugInfo=" << m_debugInfo;
|
|
}
|
|
|
|
void AbstractMapObjectImpl::resetTacticalAppearanceDrawOrderOffset()
|
|
{
|
|
m_tacticalAppearanceDrawOrderOffset = 0;
|
|
}
|
|
|
|
void AbstractMapObjectImpl::createPin()
|
|
{
|
|
TRACE_LOG(m_logger) << LOGFUNCTION << " START"
|
|
<< " debugInfo=" << m_debugInfo;
|
|
if (!m_graphicalObjectPin)
|
|
{
|
|
m_graphicalObjectPin = new GraphicalObjectPath(SituationMap::GraphicalObjectPathType::Polyline,
|
|
m_mapImpl->getEsriGeoView(),
|
|
m_graphicsLayer,
|
|
m_debugInfo + QStringLiteral("#Pin"),
|
|
m_uniqueMapId
|
|
);
|
|
}
|
|
|
|
TRACE_LOG(m_logger) << LOGFUNCTION << " END"
|
|
<< " debugInfo=" << m_debugInfo;
|
|
}
|
|
|
|
void AbstractMapObjectImpl::resetPin()
|
|
{
|
|
delete m_graphicalObjectPin;
|
|
m_graphicalObjectPin = nullptr;
|
|
}
|
|
|
|
void AbstractMapObjectImpl::setIdentifier(const QString &identifier)
|
|
{
|
|
if (identifier.isEmpty())
|
|
{
|
|
delete m_mainGraphicalObjectText;
|
|
m_mainGraphicalObjectText = nullptr;
|
|
}
|
|
else
|
|
{
|
|
createGraphicalObjectText();
|
|
if (m_mainGraphicalObjectText)
|
|
m_mainGraphicalObjectText->setText(identifier);
|
|
}
|
|
}
|
|
|
|
bool AbstractMapObjectImpl::identifierVisible() const
|
|
{
|
|
return m_identiferVisible.value();
|
|
}
|
|
|
|
void AbstractMapObjectImpl::setIdentifierVisible(bool identifierVisible)
|
|
{
|
|
m_identiferVisible = identifierVisible;
|
|
}
|
|
|
|
int AbstractMapObjectImpl::partyId() const
|
|
{
|
|
return m_party.partyId.value();
|
|
}
|
|
|
|
bool AbstractMapObjectImpl::isPartyIdValid() const
|
|
{
|
|
return m_party.partyId.value() >= 0;
|
|
}
|
|
|
|
void AbstractMapObjectImpl::setPartyId(int partyId)
|
|
{
|
|
m_party.partyId = partyId;
|
|
}
|
|
|
|
bool AbstractMapObjectImpl::setPartyIdChanged(int partyId)
|
|
{
|
|
if ((partyId < 0) || (m_party.partyId.value() == partyId))
|
|
{
|
|
m_party.partyId.setChanged();
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
const QColor &AbstractMapObjectImpl::partyColor() const
|
|
{
|
|
if (m_party.forcedPartyColor.value().isValid())
|
|
return m_party.forcedPartyColor.value();
|
|
|
|
if (m_party.partyId.changed() || m_party.useLightColor.changed() || !m_party.partyColor.isValid())
|
|
{
|
|
m_party.partyColor =
|
|
m_mapImpl->partyIdToColorFunctor().partyIdToColor(m_party.partyId.value(),
|
|
m_party.useLightColor.value());
|
|
}
|
|
return m_party.partyColor;
|
|
}
|
|
|
|
QColor AbstractMapObjectImpl::partyColor(int partyId, bool useLightColor) const
|
|
{
|
|
return m_mapImpl->partyIdToColorFunctor().partyIdToColor(partyId, useLightColor);
|
|
}
|
|
|
|
void AbstractMapObjectImpl::forcePartyColor(const QColor &partyColorToForce)
|
|
{
|
|
m_party.forcedPartyColor = partyColorToForce;
|
|
}
|
|
|
|
bool AbstractMapObjectImpl::useLightColor() const
|
|
{
|
|
return m_party.useLightColor.value();
|
|
}
|
|
void AbstractMapObjectImpl::setUseLightColor(bool useLightColor)
|
|
{
|
|
m_party.useLightColor = useLightColor;
|
|
}
|
|
|
|
AdvancedSymbology::Role AbstractMapObjectImpl::partyRole(bool roleIdentityAssumed) const
|
|
{
|
|
return m_mapImpl->partyIdToColorFunctor().partyIdToRole(m_party.partyId.value(), roleIdentityAssumed);
|
|
}
|
|
|
|
|
|
AesEffectState AbstractMapObjectImpl::aesState() const
|
|
{
|
|
return m_aesState.value();
|
|
}
|
|
void AbstractMapObjectImpl::setAesState(AesEffectState aesState)
|
|
{
|
|
m_aesState = aesState;
|
|
}
|
|
|
|
|
|
TextStyle AbstractMapObjectImpl::textStyle() const
|
|
{
|
|
if (m_mainGraphicalObjectText)
|
|
return m_mainGraphicalObjectText->textStyle();
|
|
else
|
|
return TextStyle();
|
|
}
|
|
|
|
TextStyle &AbstractMapObjectImpl::rTextStyle()
|
|
{
|
|
createGraphicalObjectText();
|
|
return m_mainGraphicalObjectText->rTextStyle();
|
|
}
|
|
|
|
void AbstractMapObjectImpl::setTextStyle(const TextStyle &textStyle)
|
|
{
|
|
createGraphicalObjectText();
|
|
m_mainGraphicalObjectText->setTextStyle(textStyle);
|
|
}
|
|
|
|
|
|
LineStyle AbstractMapObjectImpl::lineStyle() const
|
|
{
|
|
return (m_mainGraphicalObject) ? m_mainGraphicalObject->lineStyle() : LineStyle();
|
|
}
|
|
|
|
LineStyle &AbstractMapObjectImpl::rLineStyle()
|
|
{
|
|
static LineStyle dummy;
|
|
return (m_mainGraphicalObject) ? m_mainGraphicalObject->rLineStyle() : dummy;
|
|
}
|
|
|
|
void AbstractMapObjectImpl::setLineStyle(const LineStyle &lineStyle)
|
|
{
|
|
if (m_mainGraphicalObject) m_mainGraphicalObject->setLineStyle(lineStyle);
|
|
}
|
|
|
|
FillStyle AbstractMapObjectImpl::fillStyle() const
|
|
{
|
|
return (m_mainGraphicalObject) ? m_mainGraphicalObject->fillStyle() : FillStyle();
|
|
}
|
|
|
|
FillStyle &AbstractMapObjectImpl::rFillStyle()
|
|
{
|
|
static FillStyle dummy;
|
|
return (m_mainGraphicalObject) ? m_mainGraphicalObject->rFillStyle() : dummy;
|
|
}
|
|
|
|
void AbstractMapObjectImpl::setFillStyle(const FillStyle &fillStyle)
|
|
{
|
|
if (m_mainGraphicalObject) m_mainGraphicalObject->setFillStyle(fillStyle);
|
|
}
|
|
|
|
|
|
QString AbstractMapObjectImpl::layer() const
|
|
{
|
|
return logicalLayerName();
|
|
}
|
|
|
|
void AbstractMapObjectImpl::setDrawOrder(int drawOrder)
|
|
{
|
|
m_drawOrder = drawOrder;
|
|
m_internalDrawOrder = m_drawOrder * 10;
|
|
}
|
|
int AbstractMapObjectImpl::drawOrder() const
|
|
{
|
|
return m_drawOrder;
|
|
}
|
|
|
|
|
|
bool AbstractMapObjectImpl::visibility() const
|
|
{
|
|
return m_visibility;
|
|
}
|
|
void AbstractMapObjectImpl::setVisibility(bool visibility)
|
|
{
|
|
TRACE_LOG(m_logger) << LOGFUNCTION << " START"
|
|
<< " debugInfo=" << m_debugInfo
|
|
<< " visi old=" << m_visibility;
|
|
m_visibility = visibility;
|
|
TRACE_LOG(m_logger) << LOGFUNCTION << " END"
|
|
<< " debugInfo=" << m_debugInfo
|
|
<< " visi new=" << m_visibility;
|
|
}
|
|
|
|
bool AbstractMapObjectImpl::visibility(ObjectAppearance appearance) const
|
|
{
|
|
bool visi = true;
|
|
switch (appearance)
|
|
{
|
|
case SituationMap::ObjectAppearance::Technical:
|
|
visi = m_visibilityTechnical;
|
|
break;
|
|
case SituationMap::ObjectAppearance::Tactical:
|
|
visi = m_visibilityTactical;
|
|
break;
|
|
}
|
|
return visi;
|
|
}
|
|
|
|
void AbstractMapObjectImpl::setVisibility(ObjectAppearance appearance, bool visibility)
|
|
{
|
|
switch (appearance)
|
|
{
|
|
case SituationMap::ObjectAppearance::Technical:
|
|
m_visibilityTechnical = visibility;
|
|
break;
|
|
case SituationMap::ObjectAppearance::Tactical:
|
|
m_visibilityTactical = visibility;
|
|
break;
|
|
default:
|
|
ERROR_LOG(m_logger) << LOGFUNCTION << " ObjectAppearance not found";
|
|
break;
|
|
}
|
|
TRACE_LOG(m_logger) << LOGFUNCTION
|
|
<< " debugInfo=" << m_debugInfo
|
|
<< " m_visibilityTechnical=" << m_visibilityTechnical
|
|
<< " m_visibilityTactical=" << m_visibilityTactical;
|
|
}
|
|
|
|
bool AbstractMapObjectImpl::visibilityOfGeometry() const
|
|
{
|
|
return m_visibilityTechnicalGeometry;
|
|
}
|
|
|
|
void AbstractMapObjectImpl::setVisibilityOfGeometry(bool visiGeometry)
|
|
{
|
|
m_visibilityTechnicalGeometry = visiGeometry;
|
|
}
|
|
|
|
bool AbstractMapObjectImpl::selected() const
|
|
{
|
|
return m_selected;
|
|
}
|
|
void AbstractMapObjectImpl::setSelected(bool selected)
|
|
{
|
|
m_selected = selected;
|
|
}
|
|
|
|
bool AbstractMapObjectImpl::pickable() const
|
|
{
|
|
return m_pickable;
|
|
}
|
|
|
|
void AbstractMapObjectImpl::setPickable(bool pickable)
|
|
{
|
|
m_pickable = pickable;
|
|
}
|
|
|
|
|
|
float AbstractMapObjectImpl::scale() const
|
|
{
|
|
return (m_mainGraphicalObject) ? m_mainGraphicalObject->scale() : 0.0f;
|
|
}
|
|
|
|
void AbstractMapObjectImpl::setScale(float scale)
|
|
{
|
|
if (!m_enableScale)
|
|
return;
|
|
|
|
// typically the mainGraphicalObject does NOT need any scale values,
|
|
// but keep it similar to identifier, textStyle, fillStyle etc.
|
|
// mainGraphicalObjectText will receive the value within ::updateView()
|
|
if (m_mainGraphicalObject) m_mainGraphicalObject->setScale(scale);
|
|
}
|
|
|
|
bool AbstractMapObjectImpl::isScaleEnabled() const
|
|
{
|
|
return m_enableScale;
|
|
}
|
|
|
|
void AbstractMapObjectImpl::setScaleEnable(bool enabled)
|
|
{
|
|
m_enableScale = enabled;
|
|
}
|
|
|
|
|
|
SymbolData AbstractMapObjectImpl::symbol() const
|
|
{
|
|
return m_symbol.value();
|
|
}
|
|
void AbstractMapObjectImpl::setSymbol(const SymbolData &symbol)
|
|
{
|
|
m_symbol = symbol;
|
|
}
|
|
|
|
void AbstractMapObjectImpl::reRenderSymbol()
|
|
{
|
|
m_symbol.setChanged();
|
|
}
|
|
|
|
SymbolDataToRender AbstractMapObjectImpl::symbolDataToRender() const
|
|
{
|
|
return m_symbol.value().getDefaultRenderData();
|
|
}
|
|
|
|
SymbolImage AbstractMapObjectImpl::symbolImage() const
|
|
{
|
|
TRACE_LOG(m_logger) << LOGFUNCTION << " START";
|
|
TRACE_LOG(m_logger) << LOGFUNCTION << " END";
|
|
return m_symbolImage;
|
|
}
|
|
|
|
QImage AbstractMapObjectImpl::previewImage() const
|
|
{
|
|
return previewImageTypical();
|
|
}
|
|
|
|
QImage AbstractMapObjectImpl::previewImageTypical() const
|
|
{
|
|
return m_symbolImage.image();
|
|
}
|
|
|
|
QImage AbstractMapObjectImpl::previewImageSpecific() const
|
|
{
|
|
return m_symbolImage.image();
|
|
}
|
|
|
|
TextStyle AbstractMapObjectImpl::defaultTextStyle()
|
|
{
|
|
TextStyle ts; // Define default text style for all MapObjects
|
|
ts.setTextOutlineColor(Qt::white); // Define default text style for all MapObjects
|
|
ts.setTextOutlineWidth(0.5); // Define default text style for all MapObjects
|
|
return ts;
|
|
}
|
|
|
|
bool AbstractMapObjectImpl::updateTacticalAppearance()
|
|
{
|
|
bool successTactAppearance = true;
|
|
|
|
if (m_tacticalAppearance)
|
|
{
|
|
m_tacticalAppearance->setUniqueDesignation(identifier());
|
|
|
|
m_tacticalAppearance->setDrawOrder(m_internalDrawOrder + m_tacticalAppearanceDrawOrderOffset); // m_tacticalAppearanceDrawOrderOffset == 2
|
|
m_tacticalAppearance->setVisibility(m_visibility && m_visibilityTactical);
|
|
m_tacticalAppearance->setSelected(m_selected);
|
|
m_tacticalAppearance->setPickable(m_pickable);
|
|
|
|
if (m_symbol.changed())
|
|
m_tacticalAppearance->setSymbol(m_symbol.value());
|
|
|
|
if (m_mainGraphicalObject)
|
|
m_tacticalAppearance->setScale(m_mainGraphicalObject->scale());
|
|
else
|
|
ERROR_LOG(m_logger) << LOGFUNCTION << " m_mainGraphicalObject missing!!!";
|
|
|
|
successTactAppearance = m_tacticalAppearance->updateView();
|
|
}
|
|
return successTactAppearance;
|
|
}
|
|
|
|
void AbstractMapObjectImpl::createGraphicalObjectExtrusion()
|
|
{
|
|
TRACE_LOG(m_logger) << LOGFUNCTION << " START"
|
|
<< " debugInfo=" << m_debugInfo;
|
|
|
|
if (m_mapImpl->mode() != Mode::Mode_3D)
|
|
return;
|
|
|
|
if (!m_graphicalObjectExtrusion)
|
|
{
|
|
Esri::ArcGISRuntime::GraphicsOverlay *graphicsLayer = m_mapImpl->getGraphicsLayer3DExtrusion(m_logicalLayerName);
|
|
|
|
if (!graphicsLayer)
|
|
{
|
|
ERROR_LOG(m_logger) << LOGFUNCTION << " debugInfo='" << m_debugInfo << "'"
|
|
<< " getGraphicsLayer3DExtrusion failed";
|
|
return;
|
|
}
|
|
|
|
m_graphicalObjectExtrusion = new GraphicalObjectCube(m_mapImpl->getEsriGeoView(),
|
|
graphicsLayer, // ESRI-Layer, not logical
|
|
m_debugInfo + QStringLiteral("#GO3D"),
|
|
m_uniqueMapId
|
|
);
|
|
}
|
|
|
|
TRACE_LOG(m_logger) << LOGFUNCTION << " END"
|
|
<< " debugInfo=" << m_debugInfo;
|
|
}
|
|
|
|
void AbstractMapObjectImpl::resetGraphicalObjectExtrusion()
|
|
{
|
|
delete m_graphicalObjectExtrusion;
|
|
m_graphicalObjectExtrusion = nullptr;
|
|
}
|
|
|
|
bool AbstractMapObjectImpl::updateGraphicalObjectExtrusion()
|
|
{
|
|
bool successGo3D = true;
|
|
|
|
if (m_graphicalObjectExtrusion)
|
|
{
|
|
m_graphicalObjectExtrusion->setUniqueMapId(m_uniqueMapId);
|
|
|
|
// geometry:
|
|
if (m_mainGraphicalObject)
|
|
m_graphicalObjectExtrusion->setPositions(m_mainGraphicalObject->positions()); // translated / maybe they are densified?
|
|
|
|
m_graphicalObjectExtrusion->setDrawOrder(m_internalDrawOrder);
|
|
m_graphicalObjectExtrusion->setVisibility(m_visibility && m_visibilityTechnical);
|
|
m_graphicalObjectExtrusion->setSelected(m_selected);
|
|
m_graphicalObjectExtrusion->setPickable(m_pickable);
|
|
|
|
if (m_extrusionColorName.isEmpty())
|
|
{
|
|
// Fallback
|
|
const QColor &partyColor = m_mapImpl->partyIdToColorFunctor().partyIdToColor(m_party.partyId.value());
|
|
m_graphicalObjectExtrusion->setExtrusionColorName(partyColor.name());
|
|
} else {
|
|
m_graphicalObjectExtrusion->setExtrusionColorName(m_extrusionColorName);
|
|
}
|
|
m_graphicalObjectExtrusion->setHeight(m_extrusionHeight);
|
|
|
|
// scale....??
|
|
|
|
successGo3D = m_graphicalObjectExtrusion->updateView();
|
|
}
|
|
|
|
return successGo3D;
|
|
}
|
|
|
|
bool AbstractMapObjectImpl::updatePin()
|
|
{
|
|
TRACE_LOG(m_logger) << LOGFUNCTION << " START, m_debugInfo=" << m_debugInfo;
|
|
|
|
if (m_graphicalObjectPin)
|
|
{
|
|
m_graphicalObjectPin->setDrawOrder(m_internalDrawOrder + 5); // m_tacticalAppearanceDrawOrderOffset == 2
|
|
m_graphicalObjectPin->setVisibility(m_visibility);
|
|
m_graphicalObjectPin->setSelected(m_selected);
|
|
m_graphicalObjectPin->setPickable(m_pickable);
|
|
|
|
if (m_mainGraphicalObject)
|
|
{
|
|
m_graphicalObjectPin->setLineStyle(LineStyle(Qt::black, 3, LinePattern::DashDotDot));
|
|
m_graphicalObjectPin->setScale(m_mainGraphicalObject->scale());
|
|
}
|
|
else
|
|
ERROR_LOG(m_logger) << LOGFUNCTION << " m_mainGraphicalObject missing!!!";
|
|
|
|
//
|
|
// m_graphicalObjectPin->setPositions and updateView is called at GeoImageImpl::onMapExtentChanged()
|
|
//
|
|
}
|
|
|
|
TRACE_LOG(m_logger) << LOGFUNCTION << " END, m_debugInfo=" << m_debugInfo;
|
|
return true;
|
|
}
|
|
|
|
void AbstractMapObjectImpl::updateIdentifierPosition()
|
|
{
|
|
m_identifierPositionCandidateTranslated = m_mainGraphicalObject->origin();
|
|
}
|
|
|
|
bool AbstractMapObjectImpl::updateViewImplPre()
|
|
{
|
|
//
|
|
// createTacticalAppearance onDemand
|
|
//
|
|
if (!m_symbol.value().sidc.isEmpty())
|
|
createTacticalAppearance();
|
|
|
|
//
|
|
// partyId (and its resulting color) has priority to lineColor, fillColor:
|
|
//
|
|
if (isPartyIdValid() && partyChanged())
|
|
{
|
|
const QColor &partyCol = partyColor();
|
|
|
|
if (m_mainGraphicalObject)
|
|
{
|
|
if (m_lineColorFromParty)
|
|
m_mainGraphicalObject->rLineStyle().setLineColor(partyCol);
|
|
QColor fillColor(partyCol);
|
|
fillColor.setAlpha(m_fillColorAlpha);
|
|
m_mainGraphicalObject->rFillStyle().setFillColor(fillColor);
|
|
}
|
|
|
|
if (m_mainGraphicalObjectText)
|
|
m_mainGraphicalObjectText->rTextStyle().setTextColor(partyCol);
|
|
|
|
// maybe continued for TacticalAppearance
|
|
|
|
}
|
|
|
|
//
|
|
// if state!=Unknown -> its resulting pattern has priority to fillPattern:
|
|
//
|
|
if ((m_aesState.value() != AesEffectState::Unknown) && m_aesState.changed())
|
|
{
|
|
if (m_mainGraphicalObject)
|
|
{
|
|
FillPattern pattern = m_mapImpl->partyIdToColorFunctor().aesStateToPattern(m_aesState.value());
|
|
m_mainGraphicalObject->rFillStyle().setFillPattern(pattern);
|
|
}
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
inline bool isSurfacePlacementRelevant(Esri::ArcGISRuntime::GraphicsOverlay *graphicsLayer)
|
|
{
|
|
if (!graphicsLayer)
|
|
return false;
|
|
|
|
// maybe also SurfacePlacement::RelativeToScene ???
|
|
return (graphicsLayer->sceneProperties().surfacePlacement() == Esri::ArcGISRuntime::SurfacePlacement::Relative);
|
|
}
|
|
|
|
|
|
bool AbstractMapObjectImpl::updateViewImpl()
|
|
{
|
|
bool success = true;
|
|
bool successTactAppearance = true;
|
|
|
|
TRACE_LOG(m_logger) << LOGFUNCTION << " START"
|
|
<< " debugInfo =" << m_debugInfo
|
|
<< " uniqueMapId =" << m_uniqueMapId
|
|
<< " m_pickable=" << m_pickable;
|
|
|
|
// drawOrder :
|
|
|
|
// The LayerOrder could be added if required like...
|
|
// finalDrawOrder = m_mapImpl->layerFactory()-> indexOf(m_logicalLayerName);
|
|
|
|
if (m_mainGraphicalObjectText)
|
|
{
|
|
m_mainGraphicalObjectText->setDrawOrder(m_internalDrawOrder + 2); // +2 to provide space for indicationCont (e.g. mines of MineField)
|
|
m_mainGraphicalObjectText->setScale(m_mainGraphicalObject->scale());
|
|
}
|
|
|
|
// : drawOrder
|
|
|
|
if (m_mainGraphicalObject)
|
|
{
|
|
m_mainGraphicalObject->setDrawOrder(m_internalDrawOrder);
|
|
m_mainGraphicalObject->setVisibility(m_visibility && m_visibilityTechnical && m_visibilityTechnicalGeometry);
|
|
m_mainGraphicalObject->setSelected(m_selected);
|
|
m_mainGraphicalObject->setPickable(m_pickable);
|
|
|
|
success = m_mainGraphicalObject->updateView();
|
|
|
|
if (m_mainGraphicalObjectText)
|
|
{
|
|
this->updateIdentifierPosition();
|
|
|
|
m_mainGraphicalObjectText->setScale(m_mainGraphicalObject->scale());
|
|
// m_mainGraphicalObjectText->setSelected(m_selected); // Text should NEVER be selected
|
|
m_mainGraphicalObjectText->setPickable(m_pickable);
|
|
|
|
// mainGraphicalObjectText->updateView() will be called within following 'onMapExtentChanged()':
|
|
// successGoText = m_mainGraphicalObjectText->updateView();
|
|
}
|
|
}
|
|
|
|
successTactAppearance = updateTacticalAppearance();
|
|
|
|
bool successGoExtrusion = true;
|
|
if (m_graphicalObjectExtrusion && (m_mapImpl->mode() == Mode::Mode_3D))
|
|
{
|
|
successGoExtrusion = updateGraphicalObjectExtrusion();
|
|
if (!successGoExtrusion)
|
|
ERROR_LOG(m_logger) << LOGFUNCTION << " failure updateGraphicalObjectExtrusion " << " debugInfo =" << m_debugInfo << " uniqueMapId =" << m_uniqueMapId;
|
|
}
|
|
|
|
bool successUpdatePin = true;
|
|
if (m_graphicalObjectPin && (this->mapImpl()->mode() == Mode::Mode_3D) && isSurfacePlacementRelevant(m_graphicsLayer))
|
|
{
|
|
successUpdatePin = updatePin();
|
|
if (!successUpdatePin)
|
|
ERROR_LOG(m_logger) << LOGFUNCTION << " failure0 (updatePin) " << " debugInfo =" << m_debugInfo << " uniqueMapId =" << m_uniqueMapId;
|
|
}
|
|
|
|
bool successMapExtendChanged = this->onMapExtentChanged();
|
|
|
|
if (!success)
|
|
ERROR_LOG(m_logger) << LOGFUNCTION << " failure1 " << " debugInfo =" << m_debugInfo << " uniqueMapId =" << m_uniqueMapId;
|
|
if (!successTactAppearance)
|
|
ERROR_LOG(m_logger) << LOGFUNCTION << " failure2 " << " debugInfo =" << m_debugInfo << " uniqueMapId =" << m_uniqueMapId;
|
|
if (!successGoExtrusion)
|
|
ERROR_LOG(m_logger) << LOGFUNCTION << " failure3 " << " debugInfo =" << m_debugInfo << " uniqueMapId =" << m_uniqueMapId;
|
|
if (!successMapExtendChanged)
|
|
ERROR_LOG(m_logger) << LOGFUNCTION << " failure4 " << " debugInfo =" << m_debugInfo << " uniqueMapId =" << m_uniqueMapId;
|
|
|
|
TRACE_LOG(m_logger) << LOGFUNCTION << " START"
|
|
<< " debugInfo =" << m_debugInfo
|
|
<< " uniqueMapId =" << m_uniqueMapId;
|
|
return success && successTactAppearance && successGoExtrusion && successUpdatePin && successMapExtendChanged;
|
|
}
|
|
|
|
bool AbstractMapObjectImpl::updateViewImplPost()
|
|
{
|
|
partyReset();
|
|
m_aesState.reset();
|
|
m_symbol.reset();
|
|
m_identiferVisible.reset();
|
|
|
|
if (m_updateObjectIndicator)
|
|
{
|
|
for (auto *ptr : qAsConst(m_originPositionChangedCb))
|
|
ptr->onOriginPositionChanged();
|
|
}
|
|
m_updateObjectIndicator = false;
|
|
|
|
return true;
|
|
}
|
|
|
|
int AbstractMapObjectImpl::numberOfValuesChanged()
|
|
{
|
|
int count = 0;
|
|
if (m_party.changed()) { WARNING_LOG(m_logger) << LOGFUNCTION << " START "; ++count; }
|
|
if (m_aesState.changed()) { WARNING_LOG(m_logger) << LOGFUNCTION << " START "; ++count; }
|
|
|
|
if (m_symbol.changed()) { WARNING_LOG(m_logger) << LOGFUNCTION << " START "; ++count; }
|
|
|
|
if (m_identiferVisible.changed()) { WARNING_LOG(m_logger) << LOGFUNCTION << " START "; ++count; }
|
|
|
|
return count;
|
|
}
|
|
|
|
void AbstractMapObjectImpl::addChangedCallback(OriginPositionChangedCallback *cb)
|
|
{
|
|
m_originPositionChangedCb.push_back(cb);
|
|
}
|
|
void AbstractMapObjectImpl::removeChangedCallback(OriginPositionChangedCallback *cb)
|
|
{
|
|
m_originPositionChangedCb.removeAll(cb);
|
|
}
|
|
|
|
|
|
bool AbstractMapObjectImpl::init(MapImpl *mapImpl, const QString &logicalLayerName)
|
|
{
|
|
TRACE_LOG(m_logger) << LOGFUNCTION << " START"
|
|
<< " debugInfo=" << m_debugInfo;
|
|
bool success = true;
|
|
|
|
if (mapImpl)
|
|
m_mapImpl = mapImpl;
|
|
else
|
|
{
|
|
success = false;
|
|
ERROR_LOG(m_logger) << LOGFUNCTION
|
|
<< " debugInfo=" << m_debugInfo
|
|
<< " no mapImpl";
|
|
}
|
|
|
|
m_mapConnector = new SituationMap::MapConnector();
|
|
success = success && m_mapConnector->connectMapObject(m_mapImpl, this);
|
|
if (success)
|
|
{
|
|
success = this->setLogicalLayerName(logicalLayerName);
|
|
if (!success)
|
|
{
|
|
ERROR_LOG(m_logger) << LOGFUNCTION
|
|
<< " debugInfo=" << m_debugInfo
|
|
<< " setLogicalLayerName failed"
|
|
<< ", logicalLayerName='" << logicalLayerName << "'";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ERROR_LOG(m_logger) << LOGFUNCTION
|
|
<< " debugInfo=" << m_debugInfo
|
|
<< " MapConnector->connectObject failed";
|
|
}
|
|
|
|
// take static scaleHasVisibilityValue;
|
|
m_visibilityScaleRange.setInitial(s_scaleHasVisibilityValue); // static mamber of interface class.
|
|
|
|
|
|
TRACE_LOG(m_logger) << LOGFUNCTION << " END"
|
|
<< " debugInfo=" << m_debugInfo
|
|
<< " success=" << success;
|
|
return success;
|
|
}
|
|
|
|
void AbstractMapObjectImpl::setUniqueId(const UniqueMapId &uniqueId)
|
|
{
|
|
m_uniqueMapId = uniqueId;
|
|
|
|
if (m_mainGraphicalObject)
|
|
m_mainGraphicalObject->setUniqueMapId(m_uniqueMapId);
|
|
|
|
if (m_mainGraphicalObjectText)
|
|
m_mainGraphicalObjectText->setUniqueMapId(m_uniqueMapId);
|
|
|
|
if (m_tacticalAppearance)
|
|
m_tacticalAppearance->setUniqueMapId(m_uniqueMapId);
|
|
}
|
|
|
|
bool AbstractMapObjectImpl::onMapExtentChanged()
|
|
{
|
|
TRACE_LOG(m_logger) << LOGFUNCTION << " START" << " debugInfo=" << m_debugInfo;
|
|
|
|
bool success = true;
|
|
|
|
// Some MapObjects like ParticipantImpl do NOT use m_mainGraphicalObjectText:
|
|
if (m_mainGraphicalObjectText && m_mapImpl)
|
|
{
|
|
// hide identifier on zoom out???
|
|
|
|
// old approach:
|
|
// double meterPerPixel = -1.0;
|
|
// if (m_mapImpl)
|
|
// meterPerPixel = m_mapImpl->pixelSize();
|
|
// bool textVisi = meterPerPixel < 3000;
|
|
|
|
// new approach:
|
|
// double curScale = m_mapImpl->scale();
|
|
// bool textVisi = m_visibilityScaleRange.scaleHasVisibility(curScale);
|
|
// m_mainGraphicalObjectText->setVisibility(m_visibility && m_visibilityTechnical && textVisi);
|
|
|
|
// TRACE_LOG(m_logger) << LOGFUNCTION << " START"
|
|
// << " debugInfo=" << m_debugInfo << "'"
|
|
// << " meterPerPixel=" << m_mapImpl->pixelSize()
|
|
// << " newScale=" << m_mapImpl->scale()
|
|
// << " newExtent = " << SituationMap::toString(m_mapImpl->extent());
|
|
// m_mainGraphicalObjectText->setVisibility(m_visibility && m_visibilityTechnical && textVisi);
|
|
|
|
// do NOT hide identifier on zoom out:
|
|
m_mainGraphicalObjectText->setVisibility(m_visibility && m_visibilityTechnical && m_identiferVisible.value());
|
|
|
|
m_mainGraphicalObjectText->setOrigin(m_identifierPositionCandidateTranslated);
|
|
|
|
success = m_mainGraphicalObjectText->updateView();
|
|
}
|
|
|
|
TRACE_LOG(m_logger) << LOGFUNCTION << " END"
|
|
<< " debugInfo=" << m_debugInfo << "'"
|
|
<< " success=" << success;
|
|
return true;
|
|
}
|
|
|
|
|
|
QString AbstractMapObjectImpl::logicalLayerName() const
|
|
{
|
|
return m_logicalLayerName;
|
|
}
|
|
|
|
bool AbstractMapObjectImpl::setLogicalLayerName(const QString &logicalLayerName)
|
|
{
|
|
TRACE_LOG(m_logger) << LOGFUNCTION << " START"
|
|
<< " debugInfo='" << m_debugInfo << "'"
|
|
<< " logicalLayerName='" << logicalLayerName << "'";
|
|
|
|
m_logicalLayerName = logicalLayerName;
|
|
|
|
bool success = false;
|
|
|
|
m_graphicsLayer = m_mapImpl->getGraphicsLayer(logicalLayerName);
|
|
|
|
if (m_graphicsLayer)
|
|
success = true;
|
|
else
|
|
{
|
|
ERROR_LOG(m_logger) << LOGFUNCTION
|
|
<< " debugInfo=" << m_debugInfo << "'"
|
|
<< ", no layer found";
|
|
}
|
|
|
|
TRACE_LOG(m_logger) << LOGFUNCTION << " END"
|
|
<< " debugInfo='" << m_debugInfo << "'"
|
|
<< " logicalLayerName='" << logicalLayerName << "'"
|
|
<< " success=" << success;
|
|
return success;
|
|
}
|
|
|
|
|
|
bool AbstractMapObjectImpl::geometryIntersect(const MathUtils::GeometryEngine::Geometry &intersector_polyline) const
|
|
{
|
|
if (intersector_polyline.isEmpty())
|
|
return false;
|
|
|
|
if (m_mainGraphicalObject)
|
|
{
|
|
Esri::ArcGISRuntime::GraphicsOverlay *esriLayer = m_mainGraphicalObject->graphicsLayer();
|
|
if ((esriLayer) && (esriLayer->isVisible()))
|
|
{
|
|
// former: if (m_mainGraphicalObject->visibility())
|
|
// MineField stores the ountline/boundary in m_mainGraphicalObject to transfer this to m_tacticalAppearance
|
|
// That m_mainGraphicalObject is NOT visible, because of that fillPattern.
|
|
// to 'find' that MineField, anaylze just m_visibility && m_visibilityTechnical, and not m_visibilityTechnicalGeometry
|
|
if (m_visibility && m_visibilityTechnical)
|
|
{
|
|
if (MathUtils::GeometryEngine::intersect(m_mainGraphicalObject->getGraphicGeometry(), intersector_polyline))
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
// m_mainGraphicalObjectText
|
|
if (m_tacticalAppearance)
|
|
{
|
|
Esri::ArcGISRuntime::GraphicsOverlay *esriLayer = m_tacticalAppearance->graphicsLayer();
|
|
if ((esriLayer) && (esriLayer->isVisible()))
|
|
{
|
|
if (m_tacticalAppearance->visibility())
|
|
{
|
|
if (MathUtils::GeometryEngine::intersect(m_tacticalAppearance->getGraphicGeometry(), intersector_polyline))
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
} // bool AbstractMapObjectImpl::geometryIntersect( const MathUtils::GeometryEngine::Geometry & geom )
|
|
|
|
|
|
bool AbstractMapObjectImpl::geometryIsInHull(const MathUtils::GeometryEngine::Geometry &hull_polygon) const
|
|
{
|
|
if (hull_polygon.isEmpty())
|
|
return false;
|
|
|
|
if (m_mainGraphicalObject)
|
|
{
|
|
Esri::ArcGISRuntime::GraphicsOverlay *esriLayer = m_mainGraphicalObject->graphicsLayer();
|
|
if ((esriLayer) && (esriLayer->isVisible()))
|
|
{
|
|
// former: if (m_mainGraphicalObject->visibility())
|
|
// MineField stores the ountline/boundary in m_mainGraphicalObject to transfer this to m_tacticalAppearance
|
|
// That m_mainGraphicalObject is NOT visible, because of that fillPattern.
|
|
// to 'find' that MineField, anaylze just m_visibility && m_visibilityTechnical, and not m_visibilityTechnicalGeometry
|
|
if (m_visibility && m_visibilityTechnical)
|
|
{
|
|
if (MathUtils::GeometryEngine::contains(m_mainGraphicalObject->getGraphicGeometry(), hull_polygon))
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
// m_mainGraphicalObjectText
|
|
if (m_tacticalAppearance)
|
|
{
|
|
Esri::ArcGISRuntime::GraphicsOverlay *esriLayer = m_tacticalAppearance->graphicsLayer();
|
|
if ((esriLayer) && (esriLayer->isVisible()))
|
|
{
|
|
if (m_tacticalAppearance->visibility())
|
|
{
|
|
if (MathUtils::GeometryEngine::contains(m_tacticalAppearance->getGraphicGeometry(), hull_polygon))
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
Esri::ArcGISRuntime::Geometry AbstractMapObjectImpl::getEsriGeometry() const
|
|
{
|
|
if (!m_mainGraphicalObject)
|
|
return Esri::ArcGISRuntime::Geometry();
|
|
return m_mainGraphicalObject->getGraphicGeometry();
|
|
}
|
|
|
|
|
|
|
|
|
|
} // namespace SituationMap
|