342 lines
13 KiB
C++
Executable File
342 lines
13 KiB
C++
Executable File
/**
|
|
* Handler for player data
|
|
* $Id$
|
|
* $HeadURL$
|
|
* $Author$
|
|
* Created by hjl, SLSE, 2017-02-20
|
|
*/
|
|
|
|
#include "handler_building_data.h"
|
|
#include "settings.h"
|
|
#include "handler_participant.h"
|
|
#include <LtsUtilsCore/dds_bitarray.h>
|
|
#include <LtsCoordTrans/lts_coord_trans.h>
|
|
#include <QHash>
|
|
#include <QHashIterator>
|
|
|
|
|
|
namespace CentralEffectSimulation
|
|
{
|
|
|
|
HandlerBuildingData::HandlerBuildingData(const std::shared_ptr<CentralEffectSimulation::DdsHandler> &ddsHandler, QObject *parent)
|
|
: QObject(parent)
|
|
, m_ddsHandler(ddsHandler)
|
|
, m_logger(CentralEffectSimulation::getLogger("HandlerBuildingData"))
|
|
{
|
|
INFO_LOG(m_logger) << "HandlerBuildingData::HandlerBuildingData()";
|
|
} // end of ctor()
|
|
//-----------------------------------------------------------------------------
|
|
|
|
HandlerBuildingData::~HandlerBuildingData()
|
|
{
|
|
} // end of dtor()
|
|
//-----------------------------------------------------------------------------
|
|
bool HandlerBuildingData::init()
|
|
{
|
|
INFO_LOG(m_logger) << "HandlerBuildingData::init()";
|
|
auto dtcIsm = m_ddsHandler->dtcIsm();
|
|
|
|
dtcIsm->waitForHistoricalDataMainStructureElement(1000);
|
|
connect(dtcIsm.get(), &InfrastructureManagement::Interface::Dtc::mainStructureElementChanged,
|
|
this, &HandlerBuildingData::onMainStructureElementChanged);
|
|
|
|
dtcIsm->enableMountingPointAsset();
|
|
connect(dtcIsm.get(), &InfrastructureManagement::Interface::Dtc::mountingPointAssetChanged,
|
|
this, &HandlerBuildingData::onMountingPointAssetChanged);
|
|
|
|
dtcIsm->enableInstrumentationAsset();
|
|
connect(dtcIsm.get(), &InfrastructureManagement::Interface::Dtc::instrumentationAssetChanged,
|
|
this, &HandlerBuildingData::onInstrumentationAssetChanged);
|
|
|
|
// Get 'static' data for all MainStructureElements
|
|
{
|
|
auto cb = [this](const InfrastructureManagement::MainStructureElement & mse)
|
|
{
|
|
onMainStructureElementChanged(mse, DataModification::eAdded);
|
|
};
|
|
if (!dtcIsm->mainStructureElements(cb))
|
|
return false;
|
|
}
|
|
return true;
|
|
} // end of init()
|
|
//-----------------------------------------------------------------------------
|
|
|
|
// ///////////////////////////////////
|
|
// I S M (InfrastructureManagement)
|
|
// ///////////////////////////////////
|
|
void HandlerBuildingData::onMainStructureElementChanged(const InfrastructureManagement::MainStructureElement &data, DataModification modType)
|
|
{
|
|
INFO_LOG(m_logger) << "HandlerBuildingData::onMainStructureElementChanged() id=" << data.id();
|
|
if (modType == DataModification::eRemoved
|
|
|| !m_ddsHandler->dtcIsm()->isElementAssignedToExercise(data, m_ddsHandler->getExerciseId()))
|
|
{
|
|
INFO_LOG(m_logger) << "HandlerBuildingData::onMainStructureElementChanged() id=" << data.id() << " remove";
|
|
m_mainStructureElements.remove(data.id());
|
|
m_footprints.remove(data.id());
|
|
return;
|
|
}
|
|
|
|
m_mainStructureElements.insert(data.id(), data);
|
|
DEBUG_LOG(m_logger) << "Got MainStructureElement: " << data;
|
|
for (const InfrastructureManagement::StructureElement &ele : qAsConst(data.elements()))
|
|
{
|
|
if (ele.structureElementTypeId() == InfrastructureManagement::StructureElementType_def::Room)
|
|
{
|
|
const std::vector<int32_t> &path = ele.path();
|
|
if (path.size() < 3)
|
|
continue;
|
|
const int structureElementId = path.at(0);
|
|
const int floorId = path.at(1);
|
|
const int roomId = path.at(2);
|
|
DEBUG_LOG(m_logger) << "ele.id=" << ele.id() << " name =" << ele.name()
|
|
<< " ele.StructureElementType=" << ele.structureElementTypeId()
|
|
<< " buildingId = " << structureElementId
|
|
<< " floorId =" << floorId
|
|
<< " roomId = " << roomId;
|
|
m_floorRoom.insert(roomId, floorId);
|
|
m_structureElementToFloor.insert(floorId, structureElementId);
|
|
m_buildingFloor.insert(floorId, data.id());
|
|
}
|
|
// get assetPositions
|
|
{
|
|
if (ele.mountingPointTypeId() == InfrastructureManagement::MountingPointType::EffectGenerationControlUnit)
|
|
{
|
|
DEBUG_LOG(m_logger) << "EGCU id=" << ele.id()
|
|
<< " displayName=" << ele.displayName()
|
|
<< " name=" << ele.name()
|
|
<< " type=" << ele.mountingPointTypeId();
|
|
AssetPosition assetPosition;
|
|
assetPosition.structureElementId = ele.id();
|
|
assetPosition.mountingPointType = ele.mountingPointTypeId();
|
|
assetPosition.relPosition = ele.relPosition();
|
|
assetPosition.geoPosition = ele.geoPosition();
|
|
const QPointF &posUtm = CentralEffectSimulation::geographic2Utm(assetPosition.geoPosition, m_zone);
|
|
qreal x = posUtm.x() + assetPosition.relPosition.offsetX();
|
|
qreal y = posUtm.y() + assetPosition.relPosition.offsetY();
|
|
const QPointF posAssetUtm(x, y);
|
|
assetPosition.positionUtm = posAssetUtm;
|
|
assetPosition.zone = m_zone;
|
|
|
|
//QString hostname = QString::fromStdString(ele.hostname());
|
|
//assetPosition.hostname = hostname;
|
|
m_assetPositions.insert(assetPosition.structureElementId, assetPosition);
|
|
DEBUG_LOG(m_logger) << "assetPosition.insert StructureElementId= " << assetPosition.structureElementId
|
|
<< " geoPosition=" << assetPosition.geoPosition
|
|
<< " relPosition=" << assetPosition.relPosition
|
|
<< " hostname=" << assetPosition.hostname
|
|
<< " Type=" << assetPosition.mountingPointType
|
|
<< " positionUtm=" << assetPosition.positionUtm.x()
|
|
<< "/" << assetPosition.positionUtm.y()
|
|
<< " zone=" << assetPosition.zone
|
|
<< " posUtm=" << posUtm.x() << "/" << posUtm.y();
|
|
}
|
|
}
|
|
}
|
|
getFootprintsByExercise();
|
|
}
|
|
|
|
void HandlerBuildingData::onMountingPointAssetChanged(const InfrastructureManagement::MountingPointAsset &data, DataModification modType)
|
|
{
|
|
if (modType == DataModification::eRemoved)
|
|
return;
|
|
|
|
DEBUG_LOG(m_logger) << "onMountingPointAssetChanged id=" << data.id()
|
|
<< " assetId=" << data.assetId()
|
|
<< " structureElementId=" << data.structureElementId();
|
|
m_mountingPointAsset.insert(data.structureElementId(), m_assetMountingPoint.value(data.assetId()));
|
|
m_assetMountingPoint.insert(data.assetId(), data.structureElementId());
|
|
}
|
|
|
|
void HandlerBuildingData::onInstrumentationAssetChanged(const InfrastructureManagement::InstrumentationAsset &data, DataModification modType)
|
|
{
|
|
if (modType == DataModification::eRemoved)
|
|
return;
|
|
|
|
if (data.mountingPointTypeId() == InfrastructureManagement::MountingPointType::EffectGenerationControlUnit)
|
|
{
|
|
DEBUG_LOG(m_logger) << "onInstrumentationAssetChanged id=" << data.id()
|
|
<< " hostname=" << data.hostname();
|
|
QString hostname = QString::fromStdString(data.hostname());
|
|
m_instrumentationAssets.insert(data.id(), hostname);
|
|
if (m_assetMountingPoint.contains(data.id()))
|
|
{
|
|
int assetId = data.id();
|
|
int mountpointId = m_assetMountingPoint.value(assetId);
|
|
DEBUG_LOG(m_logger) << "m_instrumentationAsset.contains(" << assetId << ")"
|
|
<< " assetId=" << assetId
|
|
<< " mountpointId=" << mountpointId;
|
|
if (m_assetPositions.contains(mountpointId))
|
|
{
|
|
AssetPosition assetPosition = m_assetPositions.value(mountpointId);
|
|
assetPosition.hostname = hostname;
|
|
assetPosition.mountingPointType = data.mountingPointTypeId();
|
|
m_assetPositions.insert(assetPosition.structureElementId, assetPosition);
|
|
DEBUG_LOG(m_logger) << "m_assetPositions.insert assetPosition structureElementId= " << assetPosition.structureElementId
|
|
<< " type=" << assetPosition.mountingPointType
|
|
<< " geoPosition=" << assetPosition.geoPosition
|
|
<< " relPosition=" << assetPosition.relPosition
|
|
<< " hostname=" << assetPosition.hostname
|
|
<< " positionUtm=" << assetPosition.positionUtm.x()
|
|
<< "/" << assetPosition.positionUtm.y();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
QVector<int> HandlerBuildingData::getFloorsFromStructureElementId(int structureElementId) const
|
|
{
|
|
DEBUG_LOG(m_logger) << "getFloorsFromStructureElementId structureElementId=" << structureElementId;
|
|
QVector<int> result;
|
|
result.reserve(m_structureElementToFloor.size());
|
|
for (auto i = m_structureElementToFloor.begin(); i != m_structureElementToFloor.end(); ++i)
|
|
{
|
|
if (i.value() == structureElementId)
|
|
result.append(i.key());
|
|
}
|
|
DEBUG_LOG(m_logger) << "result.size()" << result.size();
|
|
return result;
|
|
}
|
|
|
|
QVector<int> HandlerBuildingData::getFloorsFromBuilding(int buildingId) const
|
|
{
|
|
DEBUG_LOG(m_logger) << "getFloorsFromBuilding buildingId=" << buildingId;
|
|
QVector<int> result;
|
|
result.reserve(m_buildingFloor.size());
|
|
for (auto i = m_buildingFloor.begin(); i != m_buildingFloor.end(); ++i)
|
|
{
|
|
if (i.value() == buildingId)
|
|
result.append(i.key());
|
|
}
|
|
DEBUG_LOG(m_logger) << "result.size()" << result.size();
|
|
return result;
|
|
}
|
|
|
|
void HandlerBuildingData::printAssetPositions()
|
|
{
|
|
DEBUG_LOG(m_logger) << "printAssetPositions: ";
|
|
QHashIterator<int, AssetPosition> i(m_assetPositions);
|
|
while (i.hasNext())
|
|
{
|
|
i.next();
|
|
DEBUG_LOG(m_logger) << "printAssetPositions: "
|
|
<< i.key() << ": " << i.value().structureElementId
|
|
<< " type = " << i.value().mountingPointType
|
|
<< " hostname =" << i.value().hostname
|
|
<< " pos=" << i.value().geoPosition
|
|
<< " posUtm=" << i.value().positionUtm.x()
|
|
<< "/" << i.value().positionUtm.y() ;
|
|
}
|
|
}
|
|
|
|
int HandlerBuildingData::getBuildingIdFromRoomId(const int roomId)
|
|
{
|
|
int buildingId = 0;
|
|
int floorId = getFloorIdFromRoomId(roomId);
|
|
if (floorId < 0)
|
|
buildingId = -1;
|
|
else
|
|
buildingId = getBuildingIdFromFloorId(floorId);
|
|
DEBUG_LOG(m_logger) << "getBuildingIdFromRoomId roomId=" << roomId
|
|
<< " buildingId=" << buildingId;
|
|
return buildingId;
|
|
}
|
|
|
|
QVector<int> HandlerBuildingData::polygonEncloseBuildings(const QPolygonF &polygon)
|
|
{
|
|
DEBUG_LOG(m_logger) << "polygonEncloseBuildings";
|
|
int exerciseId = m_ddsHandler->getExerciseId();
|
|
bool completeEnclosed = true;
|
|
|
|
DEBUG_LOG(m_logger) << "Vor getBuildingByPolygon";
|
|
bool isGroundLevel = false;
|
|
QVector<int> buildingsInside = m_ddsHandler->dtcIsm()->getBuildingByPolygon(exerciseId, polygon, completeEnclosed, isGroundLevel);
|
|
DEBUG_LOG(m_logger) << "Nach getBuildingByPolygon";
|
|
|
|
//int buildingId = m_ddsHandler->dtcIsm()->getSurroundingBuildingByPolygon(exerciseId, polygon);
|
|
//DEBUG_LOG(m_logger) << "getSurroundingBuildingByPolygon buildingId= " << buildingId;
|
|
return buildingsInside;
|
|
}
|
|
|
|
void HandlerBuildingData::getFootprintsByExercise()
|
|
{
|
|
auto dtcIsm = m_ddsHandler->dtcIsm();
|
|
int exerciseId = m_ddsHandler->getExerciseId();
|
|
bool isGroundLevel = false;
|
|
QMap<int, QPolygonF> footprintsUtm = dtcIsm->getUtmFootprintsByExerciseId(exerciseId, m_zone, isGroundLevel);
|
|
|
|
QMapIterator<int, QPolygonF> i(footprintsUtm);
|
|
while (i.hasNext())
|
|
{
|
|
i.next();
|
|
DEBUG_LOG(m_logger) << "Key=" << i.key() << ": " << i.value().size();
|
|
Footprint footprint;
|
|
footprint.mseId = i.key();
|
|
footprint.polyUtm = i.value();
|
|
footprint.zone = m_zone;
|
|
footprint.boundingBoxPolyUtm = footprint.polyUtm.boundingRect();
|
|
|
|
// for concealment calculation (Verdeckung)
|
|
if (!footprint.boundingBoxPolyUtm.isValid())
|
|
{
|
|
WARNING_LOG(m_logger) << "mseId=" << footprint.mseId
|
|
<< " boundingBoxPolyUtm not valid";
|
|
continue;
|
|
}
|
|
footprint.centroid = footprint.boundingBoxPolyUtm.center(); //compute2DPolygonCentroid_deprecated(footprint.polyUtm);
|
|
|
|
m_footprints.insert(i.key(), footprint);
|
|
}
|
|
}
|
|
|
|
QPointF compute2DPolygonCentroid_deprecated(const QPolygonF &metricVertices)
|
|
{
|
|
// taken from https://stackoverflow.com/questions/2792443/finding-the-centroid-of-a-polygon
|
|
// https://en.wikipedia.org/wiki/Centroid#Of_a_polygon
|
|
|
|
const int vertexCount = metricVertices.size();
|
|
if (metricVertices.size() < 3)
|
|
return {};
|
|
|
|
QPointF centroid;
|
|
double signedArea = 0.0;
|
|
|
|
double x0 = 0.0; // Current vertex X
|
|
double y0 = 0.0; // Current vertex Y
|
|
double x1 = 0.0; // Next vertex X
|
|
double y1 = 0.0; // Next vertex Y
|
|
double a = 0.0; // Partial signed area
|
|
|
|
// For all vertices except last
|
|
int i=0;
|
|
for (i=0; i<vertexCount-1; ++i)
|
|
{
|
|
x0 = metricVertices[i].x();
|
|
y0 = metricVertices[i].y();
|
|
x1 = metricVertices[i+1].x();
|
|
y1 = metricVertices[i+1].y();
|
|
a = x0*y1 - x1*y0;
|
|
signedArea += a;
|
|
centroid.rx() += (x0 + x1)*a;
|
|
centroid.ry() += (y0 + y1)*a;
|
|
} // for
|
|
|
|
// Do last vertex separately to avoid performing an expensive
|
|
// modulus operation in each iteration.
|
|
x0 = metricVertices[i].x();
|
|
y0 = metricVertices[i].y();
|
|
x1 = metricVertices[0].x();
|
|
y1 = metricVertices[0].y();
|
|
a = x0*y1 - x1*y0;
|
|
signedArea += a;
|
|
centroid.rx() += (x0 + x1)*a;
|
|
centroid.ry() += (y0 + y1)*a;
|
|
|
|
signedArea *= 0.5;
|
|
centroid.rx() /= (6.0*signedArea);
|
|
centroid.ry() /= (6.0*signedArea);
|
|
|
|
return centroid;
|
|
}
|
|
|
|
} // namespace CentralEffectSimulation2D
|