783 lines
33 KiB
C++
Executable File
783 lines
33 KiB
C++
Executable File
/**
|
||
* Handler for building models.
|
||
* $Id$
|
||
* $HeadURL$
|
||
* $Author$
|
||
* Created by biedziak_f, SLTE, 2021-03-23
|
||
*/
|
||
|
||
#include "handler_building_model.h"
|
||
|
||
#include <CentralEffectSimulation/logger.h>
|
||
|
||
#include <float.h>
|
||
|
||
#include <QJsonDocument>
|
||
#include <QJsonObject>
|
||
#include <QVector3D>
|
||
|
||
// operator<<
|
||
std::ostream &operator<< (std::ostream &stream, const QVector3D &value)
|
||
{
|
||
stream << "QPointF("
|
||
<< QString::number(value.x(), 'f', 6) << "#"
|
||
<< QString::number(value.y(), 'f', 6) << "#"
|
||
<< QString::number(value.z(), 'f', 6) << "#lenght="
|
||
<< QString::number(value.length(), 'f', 6)
|
||
<< ")";
|
||
return stream;
|
||
}
|
||
|
||
|
||
namespace CesBuildings
|
||
{
|
||
|
||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
// HandlerBuildingModel
|
||
//
|
||
|
||
/*************************************************************************************************
|
||
* Ctor, dtor and init *
|
||
*************************************************************************************************/
|
||
|
||
HandlerBuildingModel::HandlerBuildingModel(
|
||
const std::shared_ptr<CentralEffectSimulation::DdsHandler> &ddsHandler, const std::shared_ptr<HandlerAesData> &aesDataHandler, QObject *parent
|
||
)
|
||
: QObject(parent)
|
||
, CentralEffectSimulation::Interface::Fts::GetLineBuildingIntersectionRequestHandler(ddsHandler->ftsCes())
|
||
, CentralEffectSimulation::Interface::Fts::GetLineBuildingIntersectsRequestHandler(ddsHandler->ftsCes())
|
||
, CentralEffectSimulation::Interface::Fts::DetonationLocationRequestHandler(ddsHandler->ftsCes())
|
||
, m_ddsHandler(ddsHandler)
|
||
, m_aesDataHandler(aesDataHandler)
|
||
, m_logger(CentralEffectSimulation::getLogger("Plugin.Buildings.HandlerBuildingModel"))
|
||
{
|
||
TRACE_LOG(m_logger) << LOGFUNCTION << " START";
|
||
TRACE_LOG(m_logger) << LOGFUNCTION << " END";
|
||
}
|
||
|
||
HandlerBuildingModel::~HandlerBuildingModel()
|
||
{
|
||
TRACE_LOG(m_logger) << LOGFUNCTION << " START";
|
||
TRACE_LOG(m_logger) << LOGFUNCTION << " END";
|
||
}
|
||
|
||
bool HandlerBuildingModel::init()
|
||
{
|
||
TRACE_LOG(m_logger) << LOGFUNCTION << " START";
|
||
std::shared_ptr<InfrastructureManagement::Interface::Dtc> dtcIsm = m_ddsHandler->dtcIsm();
|
||
|
||
dtcIsm->waitForHistoricalDataMainStructureElement(1000);
|
||
connect(dtcIsm.get(), &InfrastructureManagement::Interface::Dtc::mainStructureElementChanged,
|
||
this, &HandlerBuildingModel::onMainStructureElementChanged);
|
||
|
||
// get:
|
||
dtcIsm->mainStructureElements([this](const InfrastructureManagement::MainStructureElement & data)
|
||
{
|
||
onMainStructureElementChanged(data, DataModification::eAdded);
|
||
});
|
||
|
||
INFO_LOG(m_logger) << "HandlerBuildingModel is running."
|
||
<< ", m_buildingModels.size() = " << m_buildingModels.size();
|
||
TRACE_LOG(m_logger) << LOGFUNCTION << " END";
|
||
return true;
|
||
}
|
||
|
||
HandlerBuildingModelInterface::LineBuildingIntersectionResult HandlerBuildingModel::getLineBuildingIntersection(
|
||
const std::vector<Core::GeoPosition> &line, const std::string &requestIdOpt)
|
||
{
|
||
TRACE_LOG(m_logger) << LOGFUNCTION << " START";
|
||
|
||
CentralEffectSimulation::GetLineBuildingIntersectionRequest newRequest;
|
||
newRequest.line(line);
|
||
newRequest.requestId(requestIdOpt);
|
||
|
||
const bool justForLineOfSight = false;
|
||
const CentralEffectSimulation::GetLineBuildingIntersectionReply &reply =
|
||
getLineBuildingIntersectionInternal(newRequest, justForLineOfSight);
|
||
|
||
// convert reply to result:
|
||
// compare HandlerBuildingModel::getLineBuildingIntersection()
|
||
|
||
LineBuildingIntersectionResult result;
|
||
result.requestId = requestIdOpt;
|
||
result.errorString = reply.errorString();
|
||
result.errorParams = reply.errorParams();
|
||
result.intersection = reply.intersection();
|
||
|
||
TRACE_LOG(m_logger) << LOGFUNCTION << " END";
|
||
return result;
|
||
}
|
||
|
||
HandlerBuildingModelInterface::LineBuildingIntersectsResult HandlerBuildingModel::getLineBuildingIntersects(const std::vector<Core::GeoPosition> &line, const std::string &requestIdOpt)
|
||
{
|
||
TRACE_LOG(m_logger) << LOGFUNCTION << " START";
|
||
|
||
CentralEffectSimulation::GetLineBuildingIntersectionRequest newRequest;
|
||
newRequest.line(line);
|
||
newRequest.requestId(requestIdOpt);
|
||
|
||
const bool justForLineOfSight = true;
|
||
const CentralEffectSimulation::GetLineBuildingIntersectionReply &reply =
|
||
getLineBuildingIntersectionInternal(newRequest, justForLineOfSight);
|
||
|
||
// convert reply to result:
|
||
// compare HandlerBuildingModel::onGetLineBuildingIntersectsRequest()
|
||
|
||
LineBuildingIntersectsResult result;
|
||
result.requestId = requestIdOpt;
|
||
result.errorString = reply.errorString();
|
||
result.errorParams = reply.errorParams();
|
||
result.intersects = ! std::isnan(reply.intersection().lat()); // ! std::isnan
|
||
|
||
TRACE_LOG(m_logger) << LOGFUNCTION << " END";
|
||
return result;
|
||
}
|
||
|
||
void HandlerBuildingModel::onMainStructureElementChanged(const InfrastructureManagement::MainStructureElement &data, DataModification modType)
|
||
{
|
||
const int mseBldgId = data.id();
|
||
|
||
TRACE_LOG(m_logger) << "MainStructureElement === " << data;
|
||
|
||
// Always delete m_buildingModels-entry
|
||
BuildingModel *buildingModelPtr = m_buildingModels.value((mseBldgId));
|
||
delete buildingModelPtr;
|
||
m_buildingModels.remove(mseBldgId);
|
||
|
||
if (modType == DataModification::eRemoved)
|
||
{
|
||
DEBUG_LOG(m_logger) << "Building not added or modified id=" << mseBldgId;
|
||
return;
|
||
}
|
||
|
||
// skip "Outdoor Cameras / Announcement Units"
|
||
if (data.structureElementTypeId() != InfrastructureManagement::StructureElementType_def::Building)
|
||
return;
|
||
|
||
// Vor allem in der GUEZ-DB sind ca 23 Gebäude per Hand eingefügt. (Sakralbau, Bahnhof, Wasserwerk etc.)
|
||
// Diese tragen die Description "Import von Hand".
|
||
// Für diese steht natürlich kein Verwundungsmodell zur Verfügung.
|
||
// Wie können wir diese erkennen und hier überspringen?
|
||
// Ich habe keine bessere Möglichkeit gefunden als diese:
|
||
const Core::GeoPosition &geoPos = data.geoPosition();
|
||
if (qFuzzyIsNull(geoPos.z()))
|
||
{
|
||
INFO_LOG(m_logger) << "BuildingId " << mseBldgId
|
||
<< " kann übersprungen werden, da von Hand importiert."
|
||
<< ", name: '" << data.name() << "'"
|
||
<< ", name: '" << data.description() << "'";
|
||
return;
|
||
}
|
||
|
||
|
||
|
||
const int exerciseId = m_ddsHandler->getExerciseId();
|
||
if (m_ddsHandler->dtcIsm()->isElementAssignedToExercise(data, exerciseId))
|
||
{
|
||
DEBUG_LOG(m_logger) << "BuildingId " << mseBldgId
|
||
<< ", in Exercise";
|
||
}
|
||
else
|
||
{
|
||
DEBUG_LOG(m_logger) << "BuildingId " << mseBldgId
|
||
<< ", not in Exercise";
|
||
return;
|
||
}
|
||
|
||
DEBUG_LOG(m_logger) << "HandlerBuildingData::onMainStructureElementChanged() id=" << mseBldgId
|
||
<< " properties=" << data.properties();
|
||
|
||
|
||
// const QVector<int> buildingIds = m_ddsHandler->dtcIsm()->getBuildingIdsByExercise(exerciseId);
|
||
// const QMap<int, InfrastructureManagement::VulnerabilityModelData> vulnerabilityModelData = m_ddsHandler->dtcIsm()->vulnerabilityModelDatas();
|
||
// QMap<int, InfrastructureManagement::VulnerabilityModelData> vulnerabilityModelData;
|
||
|
||
// InfrastructureManagement::VulnerabilityModelData vulnerabilityModelDataEle;
|
||
QByteArray vulnerabilityModelData = m_ddsHandler->dtcIsm()->getVulnerabilityModelData(data.id());
|
||
TRACE_LOG(m_logger) << "vulnerabilityModelData=" << vulnerabilityModelData
|
||
<< " id=" << data.id();
|
||
|
||
|
||
// int id = -1;
|
||
// for (auto vmdIt = vulnerabilityModelData.constBegin(); vmdIt != vulnerabilityModelData.constEnd(); ++vmdIt)
|
||
// {
|
||
// if (vmdIt.value().mainStructureElementId() == mseBldgId)
|
||
// {
|
||
// id = vmdIt.key();
|
||
// vulnerabilityModelDataEle = m_ddsHandler->dtcIsm()->vulnerabilityModelDatas().value(id);
|
||
// break;
|
||
// } // if
|
||
// } // for
|
||
// if (id == -1)
|
||
// {
|
||
// WARNING_LOG(m_logger) << "Missing VulnerabilityModelData for building " << mseBldgId << ". Skip building.";
|
||
// return;
|
||
// } // if
|
||
|
||
const InfrastructureManagement::MainFootprint &mainFootprint = m_ddsHandler->dtcIsm()->getFootprintsByExerciseId(exerciseId).value(mseBldgId);
|
||
|
||
DEBUG_LOG(m_logger) << "BuildingId " << mseBldgId;
|
||
|
||
BuildingModel *buildingModel = new BuildingModel(this);
|
||
const InfrastructureManagement::MainStructureElement &mse = data;
|
||
if (!buildingModel->init(mainFootprint, mse, vulnerabilityModelData, mseBldgId))
|
||
{
|
||
WARNING_LOG(m_logger) << "Initializing BuildingModel failed for building " << mseBldgId << ". Skipping building.";
|
||
return;
|
||
}
|
||
// if
|
||
|
||
INFO_LOG(m_logger) << "Inserting BuildingModel for building " << mseBldgId;
|
||
m_buildingModels.insert(mseBldgId, buildingModel);
|
||
|
||
INFO_LOG(m_logger) << "onMainStructureElementChanged: "
|
||
<< ", m_buildingModels.size() = " << m_buildingModels.size();
|
||
}
|
||
|
||
|
||
|
||
//--------------------------------------------------------------------------------------------------
|
||
// Intersection handling *
|
||
//--------------------------------------------------------------------------------------------------
|
||
|
||
void HandlerBuildingModel::onGetLineBuildingIntersectionRequest(const rti::core::SampleIdentity &cookie,
|
||
const CentralEffectSimulation::GetLineBuildingIntersectionRequest &request)
|
||
{
|
||
const int exerciseId = m_ddsHandler->getExerciseId();
|
||
DEBUG_LOG(m_logger) << "START onGetLineBuildingIntersectionRequest" << ", exerciseId = " << exerciseId << ", request '" << request.requestId() << "'";
|
||
|
||
const bool justForLineOfSight = false;
|
||
const CentralEffectSimulation::GetLineBuildingIntersectionReply &reply = getLineBuildingIntersectionInternal(request, justForLineOfSight);
|
||
|
||
// sendReply
|
||
m_ddsHandler->ftsCes()->getLineBuildingIntersectionReply(cookie, reply);
|
||
|
||
DEBUG_LOG(m_logger) << "END onGetLineBuildingIntersectionRequest, request '" << request.requestId() << "'";
|
||
}
|
||
|
||
void HandlerBuildingModel::onGetLineBuildingIntersectsRequest(const rti::core::SampleIdentity &cookie,
|
||
const CentralEffectSimulation::GetLineBuildingIntersectsRequest &request)
|
||
{
|
||
const int exerciseId = m_ddsHandler->getExerciseId();
|
||
DEBUG_LOG(m_logger) << "START onGetLineBuildingIntersectsRequest" << ", exerciseId = " << exerciseId << ", request '" << request.requestId() << "'";
|
||
|
||
|
||
CentralEffectSimulation::GetLineBuildingIntersectionRequest newRequest;
|
||
newRequest.line(request.line());
|
||
newRequest.requestId(request.requestId());
|
||
|
||
const bool justForLineOfSight = true;
|
||
const CentralEffectSimulation::GetLineBuildingIntersectionReply &reply = getLineBuildingIntersectionInternal(newRequest, justForLineOfSight);
|
||
|
||
// sendReply
|
||
CentralEffectSimulation::GetLineBuildingIntersectsReply newReply;
|
||
newReply.id(reply.id());
|
||
newReply.errorString(reply.errorString());
|
||
newReply.errorParams(reply.errorParams());
|
||
newReply.requestId(reply.requestId());
|
||
newReply.intersects(! std::isnan(reply.intersection().lat())); // ! std::isnan
|
||
|
||
m_ddsHandler->ftsCes()->getLineBuildingIntersectsReply(cookie, newReply);
|
||
|
||
DEBUG_LOG(m_logger) << "END onGetLineBuildingIntersectsRequest, request '" << request.requestId() << "'";
|
||
}
|
||
|
||
|
||
//LtsUtils::QPoint3D set_zValueToIfNegative(const LtsUtils::QPoint3D &pnt, double newZValue = 0.1)
|
||
//{
|
||
// return LtsUtils::QPoint3D(pnt.x(),
|
||
// pnt.y(),
|
||
// (pnt.z() > 0) ? pnt.z() : newZValue);
|
||
//}
|
||
|
||
|
||
CentralEffectSimulation::GetLineBuildingIntersectionReply HandlerBuildingModel::getLineBuildingIntersectionInternal(const CentralEffectSimulation::GetLineBuildingIntersectionRequest &request,
|
||
bool justForLineOfSight,
|
||
int *buildingIdOut,
|
||
int *segmentIdxOfIntersectionPtrOut) const
|
||
{
|
||
static Core::GeoPosition s_invalidPos(std::nan(""), std::nan(""), std::nan(""));
|
||
|
||
const int exerciseId = m_ddsHandler->getExerciseId();
|
||
|
||
DEBUG_LOG(m_logger) << "START getLineBuildingIntersectionInternal" << ", exerciseId = " << exerciseId << ", request '" << request.requestId() << "'"
|
||
<< ", request.line().size() = " << request.line().size();
|
||
|
||
CentralEffectSimulation::GetLineBuildingIntersectionReply reply;
|
||
reply.requestId(request.requestId());
|
||
// prepare invalid 'answer'
|
||
reply.intersection(s_invalidPos);
|
||
|
||
// empty (poly-)line
|
||
// (think of a trajectory)
|
||
const std::vector<Core::GeoPosition> &polylineRef = request.line();
|
||
if (polylineRef.size() < 2)
|
||
{
|
||
reply.errorString("insufficiant number of points");
|
||
WARNING_LOG(m_logger) << "getLineBuildingIntersectionInternal" << ", exerciseId = " << exerciseId << ", request '" << request.requestId() << "'"
|
||
<< ", error: '" << reply.errorString() << "'";
|
||
return reply;
|
||
}
|
||
|
||
QPolygonF polygon2D;
|
||
polygon2D.reserve(polylineRef.size());
|
||
for (const Core::GeoPosition &geoPos : qAsConst(polylineRef))
|
||
polygon2D << QPointF(geoPos.lon(), geoPos.lat());
|
||
|
||
// Only the buildings where the line/trajectory flies over the building footprint are taken into account.
|
||
bool completeEnclosed = false;
|
||
bool isGroundLevel = false;
|
||
const QVector<int> &relevantBuildings = m_ddsHandler->dtcIsm()->getBuildingByPolygon(exerciseId, polygon2D, completeEnclosed, isGroundLevel);
|
||
|
||
if (m_logger.isDebugEnabled())
|
||
{
|
||
DEBUG_LOG(m_logger) << "relevantBuildings.size=" << relevantBuildings.size();
|
||
for (const int bldgId : qAsConst(relevantBuildings))
|
||
DEBUG_LOG(m_logger) << "relevantBuilding: bldgId = " << bldgId;
|
||
}
|
||
|
||
|
||
double distance = DBL_MAX;
|
||
uint lineSegmentIdx = 0;
|
||
|
||
//---------------------
|
||
// We need to iterate over all items.
|
||
// But we need access to current and also successor item!
|
||
// If we like to avoid index operator, we can use following approach:
|
||
//
|
||
// iterate over all items, !!! BUT ONE !!!
|
||
// for (lineIt = polylineRef.begin(); lineIt != polylineRef.end()-1; )
|
||
// {
|
||
// // Copy...
|
||
// const Core::GeoPosition segStart = *lineIt;
|
||
// // ...increment and ref
|
||
// const Core::GeoPosition &segEnd = *(++lineIt);
|
||
// ...
|
||
//---------------------
|
||
// but we prefer index operator here, because in total is better:
|
||
// less copying of GeoPosition, iterator etc.
|
||
//---------------------
|
||
|
||
for (lineSegmentIdx = 0; lineSegmentIdx < polylineRef.size() - 1; ++lineSegmentIdx)
|
||
{
|
||
const Core::GeoPosition &segStart = polylineRef[lineSegmentIdx];
|
||
const Core::GeoPosition &segEnd = polylineRef[lineSegmentIdx + 1];
|
||
|
||
DEBUG_LOG(m_logger) << " lineSegmentIdx=" << lineSegmentIdx
|
||
<< ", start=" << segStart
|
||
<< " , end=" << segEnd;
|
||
|
||
int buildingId = -1; // for debugging purposes
|
||
//for (BuildingModel *buildingModel : qAsConst(m_buildingModels))
|
||
for (const int bldgId : qAsConst(relevantBuildings))
|
||
{
|
||
BuildingModel *buildingModel = m_buildingModels.value(bldgId, nullptr);
|
||
if (!buildingModel)
|
||
{
|
||
WARNING_LOG(m_logger) << " buildingModel not found, bldgId=" << bldgId;
|
||
continue;
|
||
}
|
||
|
||
DEBUG_LOG(m_logger) << " buildingModel->buildingId=" << buildingModel->buildingId()
|
||
<< " , HEIGHT = " << buildingModel-> height();
|
||
|
||
|
||
// skip buildingModel, if damaged (>80%)
|
||
auto dtcBld = m_ddsHandler->dtcBld();
|
||
dtcBld->enableBuildingState();
|
||
|
||
const Buildings::BuildingState &buildingState = dtcBld->buildingState(bldgId);
|
||
// if buildingState is not found, assume intact:
|
||
if (/*(buildingState.id() == bldgId) && */(buildingState.damagePercent() >= 80))
|
||
{
|
||
WARNING_LOG(m_logger) << " buildingModel->buildingId=" << buildingModel->buildingId()
|
||
<< ", lineSegmentIdx=" << lineSegmentIdx
|
||
<< ", damagePercent > 80% (" << buildingState.damagePercent() << ")";
|
||
continue;
|
||
}
|
||
|
||
|
||
// Do NOT
|
||
// Do NOT
|
||
// Do NOT
|
||
|
||
// Note:
|
||
// Imagine following situation:
|
||
// ______
|
||
// | |
|
||
// | Bldg |
|
||
// | |
|
||
// ----------
|
||
// * ---/ ------ o
|
||
// ---/ --------- Surface / BaseSurface / Soil
|
||
|
||
// * = Impact / Detonation
|
||
// o = Player
|
||
|
||
// In that case, no intersection will re recognized :-(
|
||
// To avoid this, lift zValue on building level by using set_zValueToIfNegative
|
||
|
||
// positions in the building's coordinate system in [m] (distance from reference position)
|
||
// const LtsUtils::QPoint3D &relStart = set_zValueToIfNegative(buildingModel->fromGeographic(segStart), 0.1); // lift / lift_zValueToIfNegative
|
||
// const LtsUtils::QPoint3D &relEnd = set_zValueToIfNegative(buildingModel->fromGeographic(segEnd), 0.1); // lift / lift_zValueToIfNegative
|
||
|
||
|
||
// Do NOT
|
||
// GUEZE-3166:
|
||
// in case of U_BAHN, segStart and segEnd really have negative values.
|
||
// It will lead to false results, if set_zValueToIfNegative is executed.
|
||
// In the meantime, lineOfSightElevation is introduced.
|
||
// Aceept the situation drawn above and assume, that lineOfSightElevation will do it.
|
||
// Do NOT
|
||
// Do NOT
|
||
|
||
|
||
const LtsUtils::QPoint3D &relStart = buildingModel->fromGeographic(segStart); // lift / lift_zValueToIfNegative
|
||
const LtsUtils::QPoint3D &relEnd = buildingModel->fromGeographic(segEnd); // lift / lift_zValueToIfNegative
|
||
|
||
DEBUG_LOG(m_logger) << " buildingModel->buildingId=" << buildingModel->buildingId()
|
||
<< ", lineSegmentIdx=" << lineSegmentIdx;
|
||
|
||
DEBUG_LOG(m_logger) << " segStart=" << segStart << " relStart=" << relStart;
|
||
DEBUG_LOG(m_logger) << " segEnd =" << segEnd << " relEnd=" << relEnd;
|
||
|
||
if (!buildingModel->hasIntersectionSimplified(relStart, relEnd)) // check height and footprint
|
||
continue;
|
||
|
||
DEBUG_LOG(m_logger) << " buildingModel->buildingId=" << buildingModel->buildingId()
|
||
<< ", lineSegmentIdx=" << lineSegmentIdx
|
||
<< ", hasIntersectionSimplified was true";
|
||
|
||
const Core::GeoPosition &intersection = buildingModel->intersection(relStart, relEnd); // assume intersection and calculate
|
||
|
||
DEBUG_LOG(m_logger) << " buildingModel->buildingId=" << buildingModel->buildingId()
|
||
<< ", lineSegmentIdx=" << lineSegmentIdx
|
||
<< ", intersection = " << intersection;
|
||
|
||
if (!BuildingModel::isValid(intersection)) // no intersection
|
||
continue;
|
||
|
||
DEBUG_LOG(m_logger) << " buildingModel->buildingId=" << buildingModel->buildingId()
|
||
<< ", lineSegmentIdx=" << lineSegmentIdx
|
||
<< ", has valid intersection = " << intersection;
|
||
if (buildingIdOut)
|
||
*buildingIdOut = buildingModel->buildingId();
|
||
|
||
// justForLineOfSight :
|
||
if (justForLineOfSight)
|
||
{
|
||
reply.intersection(intersection);
|
||
DEBUG_LOG(m_logger) << "END getLineBuildingIntersectionInternal, return due to justForLineOfSight " << request.requestId() << "'";
|
||
return reply;
|
||
}
|
||
// : justForLineOfSight
|
||
|
||
const double dist = (relStart - buildingModel->fromGeographic(intersection)).length(); // distance to start of segment
|
||
if (dist < distance) // new intersection is closer than the last one
|
||
{
|
||
if (buildingId == -1) // first intersection found
|
||
DEBUG_LOG(m_logger) << "Building " << buildingModel->buildingId() << " was hit.";
|
||
else // this building "covers" the last one found
|
||
DEBUG_LOG(m_logger) << "Building " << buildingModel->buildingId() << " was hit prior to building " << buildingId << ".";
|
||
buildingId = buildingModel->buildingId();
|
||
distance = dist;
|
||
reply.intersection(intersection);
|
||
if (segmentIdxOfIntersectionPtrOut)
|
||
*segmentIdxOfIntersectionPtrOut = lineSegmentIdx;
|
||
|
||
} // if
|
||
|
||
} // for (const int bldgId : qAsConst(relevantBuildings))
|
||
} // for(lineIt = polylineRef.begin(); lineIt != polylineRef.end()-1; ++lineIt)
|
||
|
||
DEBUG_LOG(m_logger) << "END getLineBuildingIntersectionInternal, request '" << request.requestId() << "'"
|
||
<< " buildingIdOut=" << *buildingIdOut;
|
||
|
||
return reply;
|
||
}
|
||
|
||
|
||
//--------------------------------------------------------------------------------------------------
|
||
// DetonationLocationRequest handling *
|
||
//--------------------------------------------------------------------------------------------------
|
||
|
||
void HandlerBuildingModel::onDetonationLocationRequest(
|
||
const rti::core::SampleIdentity &cookie, const CentralEffectSimulation::DetonationLocationRequest &request
|
||
)
|
||
{
|
||
DEBUG_LOG(m_logger) << "Received DetonationLocationRequest for aesId: " << request.id();
|
||
const CentralEffectSimulation::DetonationLocationReply reply = handleDetonationLocationRequest(request);
|
||
if (!reply.errorString().empty())
|
||
WARNING_LOG(m_logger) << "DetonationLocationRequest for aesId " << request.id() << " failed: " << reply.errorString();
|
||
// if
|
||
m_ddsHandler->ftsCes()->detonationLocationReply(cookie, reply);
|
||
}
|
||
|
||
CentralEffectSimulation::DetonationLocationReply HandlerBuildingModel::handleDetonationLocationRequest(const CentralEffectSimulation::DetonationLocationRequest &request) const
|
||
{
|
||
const int exerciseId = m_ddsHandler->getExerciseId();
|
||
DEBUG_LOG(m_logger) << " handleDetonationLocationRequest request=" << request
|
||
<< ", m_buildingModels.size() = " << m_buildingModels.size();
|
||
// AES::
|
||
// ExplosionCluster most likely has serveral impacts and therefore several trajectories.
|
||
// To differentiate between them, 'explosionIndex' is used (starting with 0)
|
||
// CES:
|
||
// To differentiate between a) explosionIndex and b) trajectoryIdx (segmentIdx)
|
||
// const int explosionIndex = request.index();
|
||
|
||
// prepare reply and store some values from request:
|
||
CentralEffectSimulation::DetonationLocationReply reply;
|
||
reply.id(request.id()); // AES: aesItemId
|
||
reply.index(request.index()); // AES: explosionIndex
|
||
|
||
if ( m_buildingModels.size() <= 0)
|
||
return reply;
|
||
|
||
CentralEffectSimulation::GetLineBuildingIntersectionRequest lbRequest;
|
||
lbRequest.requestId("handleDetonationLocationRequest");
|
||
lbRequest.line(request.trajectory());
|
||
|
||
const std::vector<Core::GeoPosition>& reqTrajRef = request.trajectory();
|
||
|
||
if (reqTrajRef.size() < 2)
|
||
{
|
||
ERROR_LOG(m_logger) << " handleDetonationLocationRequest request.trajectory() invalid, size =" << reqTrajRef.size();
|
||
return reply;
|
||
}
|
||
|
||
// next step: determine detonationDistance according fuseType:
|
||
double detonationDistance = 0;
|
||
ProjectDataManagement::IgniterFunctionBase ignFuncBase = m_ddsHandler->getIgniterFunctionBaseFromChargeTypeId(request.chargeTypeId(),
|
||
request.igniterTypeId(),
|
||
request.igniterFunctionId());
|
||
switch (ignFuncBase.underlying())
|
||
{
|
||
case ProjectDataManagement::IgniterFunctionBase::IfbProximity: detonationDistance = -5; break;
|
||
case ProjectDataManagement::IgniterFunctionBase::IfbImpact: detonationDistance = 0; break;
|
||
case ProjectDataManagement::IgniterFunctionBase::IfbDelay: detonationDistance = 5; break;
|
||
default:
|
||
// empty
|
||
break;
|
||
} // switch
|
||
|
||
// next step: find bldgIntersection
|
||
const bool justForLineOfSight = false;
|
||
int validSizeOfOriginalTraj = -1;
|
||
int buildingId = -1;
|
||
const CentralEffectSimulation::GetLineBuildingIntersectionReply &lbiReply =
|
||
getLineBuildingIntersectionInternal(lbRequest, justForLineOfSight, &buildingId, &validSizeOfOriginalTraj);
|
||
|
||
const LtsCoordTrans::LtsCoordinate bldgIntersectionCoord(lbiReply.intersection());
|
||
const bool bHasBuildingIntersection = BuildingModel::isValid(bldgIntersectionCoord.geoPosition());
|
||
if (bHasBuildingIntersection)
|
||
{
|
||
DEBUG_LOG(m_logger) << "RESULT: Trajectory: hasBuildingIntersection YES, at: " << bldgIntersectionCoord.mgrs()
|
||
<< " buildingId=" << buildingId;
|
||
}
|
||
else
|
||
{
|
||
DEBUG_LOG(m_logger) << "RESULT: Trajectory: hasBuildingIntersection NO";
|
||
|
||
const bool bIsInTrainingOrCentralArea = true;
|
||
if (bIsInTrainingOrCentralArea)
|
||
{
|
||
DEBUG_LOG(m_logger) << "RESULT: integrate free area...";
|
||
|
||
// free area and FuseType_def::IfbDelay:
|
||
// We can´t move the detonation point _below_ the surface.
|
||
// That would be identical to a neagative 'startHat'
|
||
// In other words: lineOfSightElevation would deliver LineOfSight::LOS_ERROR
|
||
// so:
|
||
if (detonationDistance > 0) // detonationDistance > 0 === FuseType_def::IfbDelay
|
||
detonationDistance = 0;
|
||
}
|
||
} // if (bHasBuildingIntersection)
|
||
|
||
|
||
// next step: integrate detonationDistance into trajectory to find the final detonationLocation:
|
||
|
||
// !!! assume that the requested trajectory ends directly on the ground !!!
|
||
|
||
LtsCoordTrans::LtsCoordinate detonationLocation;
|
||
if (bHasBuildingIntersection)
|
||
detonationLocation = bldgIntersectionCoord;
|
||
else
|
||
detonationLocation = LtsCoordTrans::LtsCoordinate(reqTrajRef.back());
|
||
|
||
// do we really have to do any calculations?
|
||
if (qFuzzyIsNull(detonationDistance)) // depends on 'FuseType'
|
||
{
|
||
if (!bHasBuildingIntersection)
|
||
{
|
||
DEBUG_LOG(m_logger) << "detonationLocation on ground" << detonationLocation.geoPosition()
|
||
<< std::fixed << std::setprecision(3)
|
||
<< ", heightOverElevation = " << detonationLocation.heightOverElevation();
|
||
Q_ASSERT_X(std::fabs(detonationLocation.heightOverElevation()) < 1.0, "handleDetonationLocationRequest", "heightOverElevation is to high");
|
||
}
|
||
|
||
DEBUG_LOG(m_logger) << "Trajectory bAdjusted/bHasBuildingIntersection: " << bHasBuildingIntersection
|
||
<< ", igniterFunctionBase: " << ignFuncBase
|
||
<< ", detonationDistance: " << detonationDistance
|
||
<< ", reqTrajRef.size():" << reqTrajRef.size() << " back: " << reqTrajRef.back()
|
||
<< ", detonationLocation: " << detonationLocation.toString(true)
|
||
<< ", buildingId: " << buildingId;
|
||
|
||
reply.position(detonationLocation.geoPosition());
|
||
reply.buildingId(buildingId);
|
||
}
|
||
else
|
||
{
|
||
// DetonationLocation
|
||
// instead of backtrackTrajectory(), use simply resize and push_back(bldgIntersectionCoord)
|
||
std::vector<Core::GeoPosition> trajectoryCopy = reqTrajRef;
|
||
|
||
DEBUG_LOG(m_logger) << "validSizeOfOriginalTraj is below zero: " << validSizeOfOriginalTraj << ", exerciseId " << exerciseId << ", buildingId=" << buildingId;
|
||
|
||
// in case of hasBuildingIntersection
|
||
if (validSizeOfOriginalTraj > 0)
|
||
{
|
||
trajectoryCopy.resize(validSizeOfOriginalTraj);
|
||
trajectoryCopy.push_back(bldgIntersectionCoord.geoPosition());
|
||
}
|
||
|
||
// adjust detonationLocation by taking detonationDistance (!= 0) into account:
|
||
detonationLocation = LtsCoordTrans::LtsCoordinate(calculateDetonationLocation(trajectoryCopy, detonationDistance));
|
||
|
||
DEBUG_LOG(m_logger) << "Trajectory bAdjusted/bHasBuildingIntersection: " << bHasBuildingIntersection
|
||
<< ", igniterFunctionBase: " << ignFuncBase
|
||
<< ", detonationDistance: " << detonationDistance
|
||
<< ", trajectoryCopy.size()=" << trajectoryCopy.size() << " back: " << trajectoryCopy.back()
|
||
<< ", detonationLocation: " << detonationLocation.toString(true)
|
||
<< ", buildingId: " << buildingId;
|
||
reply.buildingId(buildingId);
|
||
reply.position(detonationLocation.geoPosition());
|
||
}
|
||
|
||
// otherwise let reply.position be untouched.
|
||
|
||
return reply;
|
||
}
|
||
|
||
Core::GeoPosition HandlerBuildingModel::calculateDetonationLocation(const std::vector<Core::GeoPosition> &trajectoryGeometry, double detonationDistance) const
|
||
{
|
||
DEBUG_LOG(m_logger) << LOGFUNCTION << " START";
|
||
|
||
const int geometrySize = trajectoryGeometry.size();
|
||
if (geometrySize < 3)
|
||
{
|
||
ERROR_LOG(m_logger) << LOGFUNCTION << ", trajectoryGeometry not sufficiant";
|
||
return {};
|
||
}
|
||
|
||
// Z-Werte - absolute
|
||
// geometrySize-3]; - see comment below
|
||
// ^^^
|
||
auto p1 = trajectoryGeometry[geometrySize - 3];
|
||
LtsCoordTrans::UtmCoordinate utm1 = LtsCoordTrans::UtmCoordinate::fromGeographic(p1.lon(), p1.lat()); // ToDo: Zone des Bldgs?
|
||
QVector3D segStart(utm1.x, utm1.y, p1.z());
|
||
|
||
auto p2 = trajectoryGeometry[geometrySize - 1];
|
||
LtsCoordTrans::UtmCoordinate utm2 = LtsCoordTrans::UtmCoordinate::fromGeographic(p2.lon(), p2.lat()); // ToDo: Zone des Bldgs?
|
||
QVector3D segEnd(utm2.x, utm2.y, p2.z());
|
||
|
||
QVector3D flightVec = segEnd - segStart;
|
||
|
||
INFO_LOG(m_logger) << "flightVec1 "
|
||
<< ", utm1 " << utm1 << " , z " << p1.z()
|
||
<< ", utm2 " << utm2 << " , z " << p2.z()
|
||
<< ", flightVec " << flightVec;
|
||
|
||
// 'auto p1 = trajectoryGeometry[geometrySize-3];'
|
||
// ^^^
|
||
// Sometime the flightVec has a very small component, so it becomes zero and scaling to 5m will fail:
|
||
// 2023-12-15 16:01:59.879 INFO CES::HandlerBuildingModel |#| Core::GeoPosition CesBuildings::HandlerBuildingModel::calculateDetonationLocation(const std::vector<Core::GeoPosition>&, double) const START (ation/Plugins/Buildings/handler_building_model.cpp:279)
|
||
// 2023-12-15 16:01:59.879 ERROR CES::HandlerBuildingModel |#|
|
||
// flightVec1 ,
|
||
// utm1 UtmCoordinate(676943.27#5818641.5 zone=32) , z 98.19423,
|
||
// utm2 UtmCoordinate(676943.29#5818641.7 zone=32) , z 98.072554,
|
||
// flightVec QPointF(0.062500#0.000000#-0.121674#lenght=0.136787) (ation/Plugins/Buildings/handler_building_model.cpp:299)
|
||
// ^^^^^^^^
|
||
// 2023-12-15 16:01:59.879 ERROR CES::HandlerBuildingModel |#| flightVec2 ,
|
||
// utm1 UtmCoordinate(676943.27#5818641.5 zone=32) , z 98.19423,
|
||
// utm2 UtmCoordinate(676943.29#5818641.7 zone=32) , z 98.072554,
|
||
// flightVec QPointF(2.284572#0.000000#-4.447553#lenght=5.000000), detonationLoc
|
||
// ^^^^^^^^
|
||
|
||
|
||
|
||
// scale:
|
||
const int distanceMeter = std::fabs(detonationDistance); // meter
|
||
flightVec *= distanceMeter / flightVec.length();
|
||
|
||
// now put on impactPositon;
|
||
QVector3D detonationLoc;
|
||
if (detonationDistance > 0) // Delay
|
||
detonationLoc = segEnd + flightVec; // 'extend'
|
||
else
|
||
detonationLoc = segEnd - flightVec; // 'reduce'
|
||
|
||
LtsCoordTrans::UtmCoordinate utmDeto(utm1.zone, detonationLoc.x(), detonationLoc.y());
|
||
const QPointF &pointDeto = utmDeto.geographic();
|
||
Core::GeoPosition geoPosDeto(pointDeto.x(), pointDeto.y(), detonationLoc.z());
|
||
|
||
DEBUG_LOG(m_logger) << "flightVec2 "
|
||
<< ", utm1 " << utm1 << " , z " << p1.z()
|
||
<< ", utm2 " << utm2 << " , z " << p2.z()
|
||
<< ", flightVec " << flightVec
|
||
<< ", detonationLoc " << detonationLoc
|
||
<< ", utmDeto " << utmDeto;
|
||
|
||
return geoPosDeto;
|
||
}
|
||
|
||
/*
|
||
Core::GeoPosition HandlerBuildingModel::backtrackTrajectory(const std::vector<Core::GeoPosition> &trajectory,
|
||
const Core::GeoPosition &position,
|
||
double distancePerSegment) const
|
||
{
|
||
Core::GeoPosition startGeo = position;
|
||
LtsCoordTrans::UtmCoordinate startUtm = LtsCoordTrans::UtmCoordinate::fromGeographic(position.lon(), position.lat());
|
||
LtsUtils::QPoint3D start(startUtm.x, startUtm.y, position.z());
|
||
|
||
double res = distancePerSegment;
|
||
for (int i = trajectory.size() - 1; i > 0; --i)
|
||
{
|
||
const Core::GeoPosition &segmentStartGeo = trajectory[i];
|
||
const Core::GeoPosition &segmentEndGeo = trajectory[i - 1];
|
||
|
||
const LtsCoordTrans::UtmCoordinate segmentStartUtm = LtsCoordTrans::UtmCoordinate::fromGeographic(segmentStartGeo.lon(), segmentStartGeo.lat());
|
||
const LtsCoordTrans::UtmCoordinate segmentEndUtm = LtsCoordTrans::UtmCoordinate::fromGeographic(segmentEndGeo.lon(), segmentEndGeo.lat());
|
||
|
||
const LtsUtils::QPoint3D segmentStart(segmentStartUtm.x, segmentStartUtm.y, segmentStartGeo.z());
|
||
const LtsUtils::QPoint3D segmentEnd(segmentEndUtm.x, segmentEndUtm.y, segmentEndGeo.z());
|
||
|
||
const LtsUtils::QPoint3D direction = (segmentEnd - segmentStart).normalized();
|
||
if (LtsUtils::QPoint3D::dotProduct(start - segmentEnd, direction) > (segmentEnd - segmentStart).length()) // start is in a different trajectory segment
|
||
continue;
|
||
|
||
const double length = (start - segmentEnd).length();
|
||
if (length < res) // continue to next segment
|
||
{
|
||
res -= length;
|
||
start = segmentEnd;
|
||
continue;
|
||
} // if
|
||
|
||
start += res * direction;
|
||
startUtm.x = start.x();
|
||
startUtm.y = start.y();
|
||
const QPointF lonLat = startUtm.geographic();
|
||
startGeo.lon(lonLat.x());
|
||
startGeo.lat(lonLat.y());
|
||
startGeo.z(start.z());
|
||
return startGeo;
|
||
} // for
|
||
|
||
WARNING_LOG(m_logger) << "Backtracing trajectory for proximity fuse type failed.";
|
||
return startGeo;
|
||
}
|
||
*/
|
||
|
||
|
||
} // namespace CesBuildings
|