701 lines
27 KiB
C++
Executable File
701 lines
27 KiB
C++
Executable File
/**
|
|
* @RDE_HEADER@
|
|
* Parse building xml file and create MainStructureElementCreateRequest for the data
|
|
* $Id$
|
|
* $HeadURL$
|
|
* $Author$
|
|
* Created by Christian Ehrlicher, SLSE, 2017-02-02
|
|
*/
|
|
|
|
#include "parse_building_xml.h"
|
|
#include <QDomDocument>
|
|
#include <QFile>
|
|
#include <QPointF>
|
|
|
|
#include <QJsonArray>
|
|
#include <QJsonObject>
|
|
#include <QJsonDocument>
|
|
|
|
#include <LtsUtilsCore/dds_vector.h>
|
|
|
|
//-------------------------------------------------------------------------------------------------------------
|
|
namespace InfrastructureManagement
|
|
{
|
|
class XmlImportException : public std::exception
|
|
{
|
|
public:
|
|
explicit XmlImportException(const QString &msg) noexcept
|
|
: m_msg(msg.toUtf8().data())
|
|
{}
|
|
~XmlImportException() = default;
|
|
|
|
virtual const char *what() const noexcept
|
|
{
|
|
return m_msg.c_str();
|
|
}
|
|
private:
|
|
const std::string m_msg;
|
|
};
|
|
|
|
//-------------------------------------------------------------------------------------------------------------
|
|
template <typename T>
|
|
static inline T positionFromElement(const QDomElement &elem)
|
|
{
|
|
return T(elem.attribute(QStringLiteral("X")).toDouble(),
|
|
elem.attribute(QStringLiteral("Y")).toDouble(),
|
|
elem.attribute(QStringLiteral("Z")).toDouble());
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------------------------------------
|
|
ParseBuildingXml::ParseBuildingXml(const QString &xmlFilename,
|
|
const QString &vulnerabilityFilename,
|
|
const QString &egcuToRoomFilename,
|
|
const QString &soundAreaFilename,
|
|
const Core::GeoPosition &geoPosition,
|
|
double rotationAngleDegree)
|
|
: m_xmlFilename(xmlFilename)
|
|
, m_vulnerabilityFilename(vulnerabilityFilename)
|
|
, m_egcuToRoomFilename(egcuToRoomFilename)
|
|
, m_soundAreaFilename(soundAreaFilename)
|
|
, m_geoPosition(geoPosition)
|
|
, m_rotationAngleDegree(rotationAngleDegree)
|
|
, m_logger(getLogger("ParseBuildingXml"))
|
|
{
|
|
DEBUG_LOG(m_logger) << "m_soundAreaFilename=" << m_soundAreaFilename;
|
|
}
|
|
|
|
QJsonObject ParseBuildingXml::egcusToJson() const
|
|
{
|
|
DEBUG_LOG(m_logger) << "egcusToJson";
|
|
if (m_egcus.isEmpty())
|
|
return QJsonObject();
|
|
|
|
QJsonObject egcusToRooms;
|
|
QJsonArray egcus;
|
|
QJsonArray rooms;
|
|
for (const auto &egcu : m_egcus)
|
|
{
|
|
rooms = {};
|
|
for (const int room : egcu.rooms)
|
|
rooms += room;
|
|
|
|
QJsonObject json;
|
|
json[QStringLiteral("mountpointEgcu")] = egcu.mountpointEgcu;
|
|
json[QStringLiteral("rooms")] = rooms;
|
|
egcus += json;
|
|
}
|
|
|
|
egcusToRooms[QStringLiteral("egcusToRooms")] = egcus;
|
|
return egcusToRooms;
|
|
}
|
|
|
|
QJsonObject ParseBuildingXml::soundAreaToJson() const
|
|
{
|
|
DEBUG_LOG(m_logger) << "soundAreaToJson";
|
|
QJsonObject soundArea;
|
|
QJsonObject json;
|
|
QJsonObject jsonEgcu;
|
|
QJsonArray arrayGeometry;
|
|
for (const auto &point : m_soundArea.geometry)
|
|
{
|
|
json[QStringLiteral("lat")] = point.lat();
|
|
json[QStringLiteral("lon")] = point.lon();
|
|
arrayGeometry.append(json);
|
|
}
|
|
QJsonArray arrayEgcus;
|
|
for (const auto &id : m_soundArea.egcuMountpoints)
|
|
{
|
|
jsonEgcu[QStringLiteral("id")] = id;
|
|
arrayEgcus.append(jsonEgcu);
|
|
}
|
|
soundArea[QStringLiteral("id")] = m_soundArea.id;
|
|
soundArea[QStringLiteral("geometry")] = arrayGeometry;
|
|
soundArea[QStringLiteral("mainEgcuMountpoint")] = m_soundArea.mainEgcuMountpoint;
|
|
soundArea[QStringLiteral("egcuMountpoints")] = arrayEgcus;
|
|
return soundArea;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------------------------------------
|
|
bool ParseBuildingXml::parseXml()
|
|
{
|
|
DEBUG_LOG(m_logger) << "parseXml";
|
|
m_request = MainStructureElementModifyRequest();
|
|
m_request.properties("{}");
|
|
m_lastError.clear();
|
|
bool bRet = true;
|
|
|
|
parseXmlInternal();
|
|
|
|
// try
|
|
// {
|
|
// parseXmlInternal();
|
|
// if (!m_vulnerabilityFilename.isEmpty())
|
|
// {
|
|
// QDomDocument doc = openXml(m_vulnerabilityFilename);
|
|
// if (!doc.isNull())
|
|
// {
|
|
// const QByteArray compressed = qCompress(doc.toByteArray(), 9);
|
|
// m_request.vulnerabilityData(LtsUtils::convert<std::vector<uint8_t>>(compressed));
|
|
// }
|
|
// }
|
|
// }
|
|
// catch (const std::exception &ex)
|
|
// {
|
|
// m_lastError = QString::fromUtf8(ex.what());
|
|
// WARNING_LOG(m_logger) << "Error importing building: " << ex.what();
|
|
// m_request = MainStructureElementModifyRequest();
|
|
// return false;
|
|
// }
|
|
|
|
QJsonObject properties;
|
|
|
|
parseXmlEgcus();
|
|
QJsonObject egcus = egcusToJson();
|
|
properties[QStringLiteral("egcusToRooms")] = egcus[QStringLiteral("egcusToRooms")];
|
|
DEBUG_LOG(m_logger) << "parseXml vor isEmpty";
|
|
if (!m_soundAreaFilename.isEmpty())
|
|
{
|
|
DEBUG_LOG(m_logger) << "parseXml vor parseXmlSoundArea";
|
|
parseXmlSoundArea();
|
|
properties[QStringLiteral("soundArea")] = soundAreaToJson();
|
|
}
|
|
|
|
m_request.properties(QJsonDocument(properties).toJson(QJsonDocument::Compact).toStdString());
|
|
|
|
DEBUG_LOG(m_logger) << "Finished import for file " << m_xmlFilename;
|
|
return bRet;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------------------------------------
|
|
ParseBuildingXml::Egcu ParseBuildingXml::parseEgcu(const QDomElement &domEgcu)
|
|
{
|
|
ParseBuildingXml::Egcu ret;
|
|
|
|
INFO_LOG(m_logger) << "parseEgcu Egcu: = " << domEgcu.tagName();
|
|
QDomElement mountpoint = domEgcu.firstChildElement(QStringLiteral("Mountpoint"));
|
|
INFO_LOG(m_logger) << "Mountpoint=" << mountpoint.tagName();
|
|
QDomElement mountpointSubId = mountpoint.firstChildElement(QStringLiteral("SubId"));
|
|
INFO_LOG(m_logger) << "Mountpoint=" << mountpointSubId.tagName()
|
|
<< " SubId = " << mountpointSubId.attribute(QStringLiteral("SubId"))
|
|
<< " text= " << mountpointSubId.text();
|
|
ret.mountpointEgcu = mountpointSubId.text().toInt();
|
|
|
|
QDomElement rooms = domEgcu.firstChildElement(QStringLiteral("Rooms"));
|
|
INFO_LOG(m_logger) << "Rooms=" << rooms.tagName()
|
|
<< " SubId = " << rooms.attribute(QStringLiteral("SubId"))
|
|
<< " text = " << rooms.text();
|
|
|
|
QDomElement room = rooms.firstChildElement(QStringLiteral("SubId"));
|
|
for (; !room.isNull(); room = room.nextSiblingElement(room.tagName()))
|
|
{
|
|
INFO_LOG(m_logger) << "Room=" << room.tagName()
|
|
<< " SubId = " << room.attribute(QStringLiteral("SubId"))
|
|
<< " text = " << room.text();
|
|
ret.rooms.append(room.text().toInt());
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
bool ParseBuildingXml::parseXmlEgcus()
|
|
{
|
|
m_lastError.clear();
|
|
bool bRet = true;
|
|
try
|
|
{
|
|
//parseXmlInternal();
|
|
INFO_LOG(m_logger) << "parseXmlEgcus " << m_egcuToRoomFilename;
|
|
if (!m_egcuToRoomFilename.isEmpty())
|
|
{
|
|
INFO_LOG(m_logger) << "openXml";
|
|
QDomDocument doc = openXml(m_egcuToRoomFilename);
|
|
if (!doc.isNull())
|
|
{
|
|
// Evaluate xml file and modify properties in m_request
|
|
QDomElement root = doc.documentElement();
|
|
INFO_LOG(m_logger) << "root.tagName()=" << root.tagName();
|
|
if (root.tagName() != QStringLiteral("EgcusToRooms"))
|
|
{
|
|
WARNING_LOG(m_logger) << "The file is not EgcusToRooms";
|
|
return false;
|
|
}
|
|
QDomElement domEgcu = root.firstChildElement(QStringLiteral("Egcu"));
|
|
if (domEgcu.isNull())
|
|
INFO_LOG(m_logger) << "Keine EGCU's";
|
|
for (; !domEgcu.isNull(); domEgcu = domEgcu.nextSiblingElement(domEgcu.tagName()))
|
|
{
|
|
INFO_LOG(m_logger) << "parseEgcus=" << domEgcu.tagName()
|
|
<< " text=" << domEgcu.text()
|
|
<< " Name=" << domEgcu.attribute(QStringLiteral("Name"));
|
|
const Egcu egcu = parseEgcu(domEgcu);
|
|
m_egcus.append(egcu);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
catch (const std::exception &ex)
|
|
{
|
|
m_lastError = QString::fromUtf8(ex.what());
|
|
WARNING_LOG(m_logger) << "Error importing building: wrong XML-File EgcuToRooms: " << ex.what();
|
|
bRet = false;
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------------------------------------
|
|
|
|
bool ParseBuildingXml::parseXmlSoundArea()
|
|
{
|
|
Core::GeoPosition geoPosition;
|
|
m_lastError.clear();
|
|
bool bRet = true;
|
|
try
|
|
{
|
|
//parseXmlInternal();
|
|
INFO_LOG(m_logger) << "parseXmlSoundArea " << m_soundAreaFilename;
|
|
if (!m_soundAreaFilename.isEmpty())
|
|
{
|
|
INFO_LOG(m_logger) << "openXml";
|
|
QDomDocument doc = openXml(m_soundAreaFilename);
|
|
if (!doc.isNull())
|
|
{
|
|
// Evaluate xml file and modify properties in m_request
|
|
QDomElement root = doc.documentElement();
|
|
INFO_LOG(m_logger) << "root.tagName()=" << root.tagName();
|
|
if (root.tagName() != QStringLiteral("SoundArea"))
|
|
{
|
|
WARNING_LOG(m_logger) << "The file is not SoundArea";
|
|
return false;
|
|
}
|
|
|
|
INFO_LOG(m_logger) << "parseSoundArea SoundArea: = " << root.tagName();
|
|
|
|
// Id
|
|
m_soundArea.id = root.firstChildElement(QStringLiteral("Id")).text().toInt();
|
|
INFO_LOG(m_logger) << "Id=" << m_soundArea.id;
|
|
|
|
// Geometry
|
|
QDomElement geometry = root.firstChildElement(QStringLiteral("Geometry"));
|
|
QDomElement point = geometry.firstChildElement(QStringLiteral("Point"));
|
|
for (; !point.isNull(); point = point.nextSiblingElement(point.tagName()))
|
|
{
|
|
INFO_LOG(m_logger) << "Point=" << point.tagName()
|
|
<< " lat = " << point.firstChildElement(QStringLiteral("lat")).text().toDouble()
|
|
<< " lon = " << point.firstChildElement(QStringLiteral("lon")).text().toDouble();
|
|
geoPosition.lat(point.firstChildElement(QStringLiteral("lat")).text().toDouble());
|
|
geoPosition.lon(point.firstChildElement(QStringLiteral("lon")).text().toDouble());
|
|
m_soundArea.geometry.push_back(geoPosition);
|
|
}
|
|
|
|
// MainEgcuMountpoint
|
|
m_soundArea.mainEgcuMountpoint = root.firstChildElement(QStringLiteral("MainEgcuMountpoint")).text().toInt();
|
|
DEBUG_LOG(m_logger) << "MainEgcuMountpoint Id=" << m_soundArea.mainEgcuMountpoint;
|
|
|
|
// MountpointsEgcu
|
|
QDomElement egcuMountpoints = root.firstChildElement(QStringLiteral("EgcuMountpoints"));
|
|
QDomElement id = egcuMountpoints.firstChildElement(QStringLiteral("Id"));
|
|
for (; !id.isNull(); id = id.nextSiblingElement(id.tagName()))
|
|
{
|
|
int mountpointEgcu = id.text().toInt();
|
|
DEBUG_LOG(m_logger) << "mountpointEgcu=" << mountpointEgcu;
|
|
m_soundArea.egcuMountpoints.push_back(mountpointEgcu);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
catch (const std::exception &ex)
|
|
{
|
|
m_lastError = QString::fromUtf8(ex.what());
|
|
WARNING_LOG(m_logger) << "Error importing building: wrong XML-File EgcuToRooms: " << ex.what();
|
|
bRet = false;
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------------------------------------
|
|
QDomDocument ParseBuildingXml::openXml(const QString &fileName) const
|
|
{
|
|
// check filename is empty
|
|
if (fileName.isEmpty())
|
|
throw XmlImportException(tr("Empty filename!"));
|
|
|
|
// check if metaFileName is a valid xml file
|
|
QFile f(fileName);
|
|
if (f.size() == 0)
|
|
return QDomDocument();
|
|
if (!f.open(QIODevice::ReadOnly))
|
|
throw XmlImportException(tr("Error opening file %1: %2").arg(fileName, f.errorString()));
|
|
|
|
// read Xml file
|
|
QDomDocument metaDoc;
|
|
int errLine = 0, errColumn = 0;
|
|
QString err;
|
|
if (!metaDoc.setContent(&f, &err, &errLine, &errColumn))
|
|
throw XmlImportException(tr("Error parsing file content: %1 at %2.%3").arg(err).arg(errLine).arg(errColumn));
|
|
|
|
// close metaFile
|
|
f.close();
|
|
|
|
return metaDoc;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------------------------------------
|
|
QVector<ParseBuildingXml::BuildingMetaInfo> ParseBuildingXml::parseMetaXml(const QString &metaXml) const
|
|
{
|
|
QVector<ParseBuildingXml::BuildingMetaInfo> ret;
|
|
const QDomDocument metaDoc = openXml(metaXml);
|
|
|
|
if (metaDoc.isNull())
|
|
return ret;
|
|
|
|
// parse metaDoc for building elements MetaData/Tag/Group/Feature+Orientation+Position+File
|
|
const QDomElement metaElem = getChildElement(metaDoc, QStringLiteral("MetaData"));
|
|
const QDomElement tagElem = getChildElement(metaElem, QStringLiteral("Tag"));
|
|
const QDomElement groupElem = getChildElement(tagElem, QStringLiteral("Group"));
|
|
QDomElement modelElem = getChildElement(groupElem, QStringLiteral("Model"));
|
|
for (; !modelElem.isNull(); modelElem = modelElem.nextSiblingElement(modelElem.tagName()))
|
|
{
|
|
const QDomElement orientationElem = getChildElement(modelElem, QStringLiteral("Orientation"));
|
|
const QDomElement posElem = getChildElement(modelElem, QStringLiteral("Position"));
|
|
const QDomElement streifElem = getChildElement(modelElem, QStringLiteral("STREIF"));
|
|
|
|
// read building file name, name, angle, position
|
|
ParseBuildingXml::BuildingMetaInfo info;
|
|
info.filename = streifElem.attribute(QLatin1String("Name"));
|
|
if (info.filename.isEmpty())
|
|
{
|
|
WARNING_LOG(m_logger) << "Empty filename (building)!";
|
|
continue;
|
|
}
|
|
|
|
info.rotationAngleDegree = orientationElem.attribute(QLatin1String("Angle")).toDouble(); // correct rotation?
|
|
INFO_LOG(m_logger) << "Found Building angle: " << info.rotationAngleDegree;
|
|
|
|
info.geoPosition = positionFromElement<Core::GeoPosition>(posElem);
|
|
|
|
INFO_LOG(m_logger) << "Found Building position: (" << info.geoPosition.lon() << ", ("
|
|
<< info.geoPosition.lat() << ", ("
|
|
<< info.geoPosition.z() << ")";
|
|
|
|
ret += info;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------------------------------------
|
|
void ParseBuildingXml::parseXmlInternal()
|
|
{
|
|
const QDomDocument objDoc = openXml(m_xmlFilename);
|
|
if (objDoc.isNull())
|
|
throw XmlImportException(tr("xml file %1 is empty").arg(m_xmlFilename));
|
|
const QDomElement rootElem = objDoc.documentElement(); // STREIF
|
|
|
|
const QDomElement headerElem = getChildElement(rootElem, QStringLiteral("Header"));
|
|
const QDomElement baseGroupElem = getChildElement(headerElem, QStringLiteral("Group"));
|
|
|
|
DEBUG_LOG(m_logger) << "Start import for file " << m_xmlFilename;
|
|
|
|
m_request.angle(m_rotationAngleDegree);
|
|
m_request.geoPosition(m_geoPosition);
|
|
m_request.modelId(getInteger(getChildElement(baseGroupElem, QStringLiteral("ModelId")), QStringLiteral("Id")));
|
|
m_request.name(getChildElement(baseGroupElem, QStringLiteral("Name")).text().toStdString());
|
|
m_request.description(m_request.name());
|
|
INFO_LOG(m_logger) << "Importing building with name: " << m_request.name();
|
|
|
|
InfrastructureManagement::StructureElement seBuilding;
|
|
seBuilding.name(m_request.name());
|
|
seBuilding.displayName(m_request.name());
|
|
seBuilding.structureElementTypeId(InfrastructureManagement::StructureElementType::Building);
|
|
seBuilding.mountingPointTypeId(InfrastructureManagement::MountingPointType::Unknown);
|
|
seBuilding.properties("{}");
|
|
addElementToRequest(seBuilding, -1);
|
|
|
|
InfrastructureManagement::StructureElement seMPBuilding;
|
|
seMPBuilding.name(m_request.name());
|
|
seMPBuilding.displayName(m_request.name());
|
|
m_buildingName = QString::fromStdString(seBuilding.displayName());
|
|
seMPBuilding.structureElementTypeId(InfrastructureManagement::StructureElementType::MountingPoint);
|
|
seMPBuilding.mountingPointTypeId(InfrastructureManagement::MountingPointType::BuildingControlUnit);
|
|
seMPBuilding.properties("{}");
|
|
addElementToRequest(seMPBuilding, 0);
|
|
|
|
//SWPA 2/22 - GUEZE-1459 - IO 2022.11.10 - do not import GV for new Guez Buildings
|
|
#ifndef GUEZ_MODE
|
|
InfrastructureManagement::StructureElement seGVBuilding;
|
|
seGVBuilding.name(m_request.name()+std::string("_gv"));
|
|
seGVBuilding.displayName(m_request.name()+std::string("_gv"));
|
|
seGVBuilding.structureElementTypeId(InfrastructureManagement::StructureElementType::MountingPoint);
|
|
seGVBuilding.mountingPointTypeId(InfrastructureManagement::MountingPointType::BuildingNetworkSwitch);
|
|
seGVBuilding.properties("{}");
|
|
addElementToRequest(seGVBuilding, 0);
|
|
#endif
|
|
|
|
// all below building, not below building bcu mounting point
|
|
const int parentIdx = 0;
|
|
importFootprint(baseGroupElem);
|
|
importExternalReferences(baseGroupElem, parentIdx);
|
|
importFloors(baseGroupElem, parentIdx);
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------------------------------------
|
|
void ParseBuildingXml::importFootprint(const QDomElement &parent)
|
|
{
|
|
QDomElement groupElem = parent.firstChildElement(QStringLiteral("Group"));
|
|
std::vector<InfrastructureManagement::FootprintElement> fp;
|
|
for (; !groupElem.isNull(); groupElem = groupElem.nextSiblingElement(groupElem.tagName()))
|
|
{
|
|
const QDomElement nameElement = getChildElement(groupElem, QStringLiteral("Name"), false);
|
|
if (!nameElement.text().startsWith(QLatin1String("FOOTPRINT"), Qt::CaseInsensitive))
|
|
continue;
|
|
|
|
const QDomElement polygonElem = getChildElement(groupElem, QStringLiteral("Polygon"), false);
|
|
if (polygonElem.isNull())
|
|
continue;
|
|
QDomElement vertexElem = polygonElem.firstChildElement(QStringLiteral("Vertex"));
|
|
for (; !vertexElem.isNull(); vertexElem = vertexElem.nextSiblingElement(vertexElem.tagName()))
|
|
{
|
|
// TODO: xml hat keine Reihenfolge! Man kann es anhand der Namen sortieren
|
|
const QDomElement coordElem = vertexElem.firstChildElement(QStringLiteral("Coord"));
|
|
if (coordElem.isNull())
|
|
continue;
|
|
FootprintElement fpElem;
|
|
fpElem.relPosition() = positionFromElement<Core::RelativePosition>(coordElem);
|
|
fp.resize(fp.size() + 1, fpElem);
|
|
}
|
|
break;
|
|
}
|
|
if (fp.size() > 0)
|
|
m_request.footprint(std::move(fp));
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------------------------------------
|
|
void ParseBuildingXml::importExternalReferences(const QDomElement &parent,
|
|
int parentIdx)
|
|
{
|
|
QDomElement extRefElem = parent.firstChildElement(QStringLiteral("External_Reference"));
|
|
for (; !extRefElem.isNull(); extRefElem = extRefElem.nextSiblingElement(extRefElem.tagName()))
|
|
{
|
|
const StructureElement se = getStructureElement(extRefElem);
|
|
// we don't care about BCU Mounting positions inside xml file - we create our own
|
|
if (se.mountingPointTypeId() == MountingPointType::BuildingControlUnit)
|
|
{
|
|
INFO_LOG(m_logger) << "Ignoring xml-internal BuildingControl mounting point - not needed";
|
|
continue;
|
|
}
|
|
if (se.mountingPointTypeId() == MountingPointType::Unknown)
|
|
{
|
|
INFO_LOG(m_logger) << "Ignoring unknown mounting point type with subId " << se.mountingPointId();
|
|
continue;
|
|
}
|
|
INFO_LOG(m_logger) << "importExternalReferences: " << se.displayName() << ", parentIdx = " << parentIdx;
|
|
addElementToRequest(se, parentIdx);
|
|
}
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------------------------------------
|
|
void ParseBuildingXml::importFloors(const QDomElement &parent,
|
|
int parentIdx)
|
|
{
|
|
QDomElement floorElem = parent.firstChildElement(QStringLiteral("Group"));
|
|
for (; !floorElem.isNull(); floorElem = floorElem.nextSiblingElement(floorElem.tagName()))
|
|
{
|
|
const QDomElement nameElement = getChildElement(floorElem, QStringLiteral("Name"), false);
|
|
if (!nameElement.text().startsWith(QLatin1String("floor_"), Qt::CaseInsensitive))
|
|
continue;
|
|
|
|
INFO_LOG(m_logger) << "importFloors: " << nameElement.text() << ", parentIdx = " << parentIdx;
|
|
|
|
StructureElement se;
|
|
se.name(nameElement.text().simplified().toStdString());
|
|
se.displayName(se.name());
|
|
se.structureElementTypeId(InfrastructureManagement::StructureElementType::Floor);
|
|
se.mountingPointTypeId(InfrastructureManagement::MountingPointType::Unknown);
|
|
se.properties("{}");
|
|
|
|
// read base height from xml comment
|
|
const QDomElement commentElement = getChildElement(floorElem, QStringLiteral("Comment"), false);
|
|
DEBUG_LOG(m_logger) << "Comment = " << commentElement.text();
|
|
const QStringList comm = commentElement.text().split(QLatin1Char('='));
|
|
double baseHeight = 0.00;
|
|
if (comm.at(0) == QStringLiteral("base_height"))
|
|
baseHeight = comm.at(1).toDouble();
|
|
DEBUG_LOG(m_logger) << "base_height = " << baseHeight;
|
|
se.relPosition().offsetZ(baseHeight);
|
|
|
|
addElementToRequest(se, parentIdx);
|
|
|
|
const int curIdx = m_request.elements().size() - 1;
|
|
importRooms(floorElem, curIdx);
|
|
}
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------------------------------------
|
|
void ParseBuildingXml::importRooms(const QDomElement &parent,
|
|
int parentIdx)
|
|
{
|
|
QDomElement roomElem = parent.firstChildElement(QStringLiteral("Switch"));
|
|
for (; !roomElem.isNull(); roomElem = roomElem.nextSiblingElement(roomElem.tagName()))
|
|
{
|
|
const QDomElement nameElement = getChildElement(roomElem, QStringLiteral("Name"), false);
|
|
if (!nameElement.text().startsWith(QLatin1String("SW_room_"), Qt::CaseInsensitive))
|
|
continue;
|
|
const int subId = getInteger(getChildElement(roomElem, QStringLiteral("SubId")), QStringLiteral("ID"));
|
|
|
|
StructureElement se;
|
|
se.name(nameElement.text().simplified().toStdString());
|
|
|
|
QString roomName = QString::fromStdString(se.name());
|
|
// displayed room names are too long
|
|
roomName.replace(QStringLiteral("SW_room"), QStringLiteral("R"));
|
|
|
|
INFO_LOG(m_logger) << "importRooms: " << roomName << ", parentIdx = " << parentIdx;
|
|
|
|
se.displayName(roomName.toStdString());
|
|
se.mountingPointId(subId);
|
|
se.structureElementTypeId(InfrastructureManagement::StructureElementType::Room);
|
|
se.mountingPointTypeId(InfrastructureManagement::MountingPointType::Unknown);
|
|
se.properties("{}");
|
|
|
|
QDomElement subRoomElem = roomElem.firstChildElement(QStringLiteral("Group"));
|
|
if (!subRoomElem.isNull())
|
|
{
|
|
tryGetRoomBoundingBox(subRoomElem, se);
|
|
addElementToRequest(se, parentIdx);
|
|
const int curIdx = m_request.elements().size() - 1;
|
|
importExternalReferences(subRoomElem, curIdx);
|
|
DEBUG_LOG(m_logger) << "Room=" << se.name()
|
|
<< " Id=" << se.id()
|
|
<< " mountingPointId=" << se.mountingPointId();
|
|
}
|
|
else
|
|
{
|
|
addElementToRequest(se, parentIdx);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------------------------------------
|
|
void ParseBuildingXml::tryGetRoomBoundingBox(const QDomElement &subRoomElem, StructureElement &se)
|
|
{
|
|
const QDomElement min = getChildElement(subRoomElem, QStringLiteral("BBox_Min"));
|
|
const QDomElement max = getChildElement(subRoomElem, QStringLiteral("BBox_Max"));
|
|
if (min.isNull() || max.isNull())
|
|
return;
|
|
const auto minPos(positionFromElement<Core::RelativePosition>(min));
|
|
const auto maxPos(positionFromElement<Core::RelativePosition>(min));
|
|
se.relPosition(Core::RelativePosition((minPos.offsetX() + maxPos.offsetX()) / 2,
|
|
(minPos.offsetY() + maxPos.offsetY()) / 2,
|
|
(minPos.offsetZ() + maxPos.offsetZ()) / 2));
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------------------------------------
|
|
void ParseBuildingXml::addElementToRequest(const StructureElement &se,
|
|
int parentIdx)
|
|
{
|
|
const size_t size = m_request.elements().size();
|
|
m_request.elements().resize(size + 1, se);
|
|
m_request.childParentRelations().resize(size + 1, parentIdx);
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------------------------------------
|
|
InfrastructureManagement::MountingPointType ParseBuildingXml::mptFromSubId(int subId)
|
|
{
|
|
enum ExternalReference
|
|
{
|
|
NONE = 0,
|
|
REF_MOD = 11000,
|
|
ZEG = 12000,
|
|
CAMERA_OUT = 13000,
|
|
CAMERA_IN = 14000,
|
|
IPS_OUT = 15000,
|
|
IPS_IN = 16000,
|
|
Unknown1 = 17000,
|
|
ANNOUNCEMENT_Unit = 26000,
|
|
EGCU = 27000,
|
|
Unknown2 = 28000
|
|
};
|
|
|
|
if (subId > Unknown2)
|
|
return MountingPointType::Unknown;
|
|
|
|
if (subId > EGCU)
|
|
return MountingPointType::EffectGenerationControlUnit;
|
|
|
|
if (subId > ANNOUNCEMENT_Unit)
|
|
return MountingPointType::AnnouncementUnit;
|
|
|
|
if (subId > Unknown1)
|
|
return MountingPointType::Unknown;
|
|
|
|
if (subId > IPS_IN)
|
|
return MountingPointType::IndoorIPS;
|
|
|
|
if (subId > IPS_OUT)
|
|
return MountingPointType::OutdoorIPS;
|
|
|
|
if (subId > CAMERA_IN)
|
|
return MountingPointType::IndoorCamera;
|
|
|
|
if (subId > CAMERA_OUT)
|
|
return MountingPointType::OutdoorCamera;
|
|
|
|
if (subId > ZEG)
|
|
return MountingPointType::BuildingControlUnit;
|
|
|
|
if (subId > REF_MOD)
|
|
return MountingPointType::BuildingSensorModule;
|
|
|
|
return MountingPointType::Unknown;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------------------------------------
|
|
StructureElement ParseBuildingXml::getStructureElement(const QDomElement &element) const
|
|
{
|
|
const int subId = getInteger(getChildElement(element, QStringLiteral("SubId")), QStringLiteral("ID"));
|
|
|
|
StructureElement se;
|
|
se.relPosition(positionFromElement<Core::RelativePosition>(getChildElement(element, QStringLiteral("Coord"))));
|
|
se.orientation(positionFromElement<Core::Orientation>(getChildElement(element, QStringLiteral("Dir")))); // xyz=hpr?
|
|
se.mountingPointTypeId(mptFromSubId(subId));
|
|
se.structureElementTypeId(InfrastructureManagement::StructureElementType::MountingPoint);
|
|
se.name(element.firstChildElement(QStringLiteral("Name")).text().simplified().toStdString());
|
|
|
|
QString displayName = m_buildingName;
|
|
displayName.append(QLatin1String(" - "));
|
|
displayName.append(QString::fromStdString(se.name()));
|
|
se.displayName(displayName.toStdString());
|
|
se.mountingPointId(subId);
|
|
se.properties("{}");
|
|
return se;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------------------------------------
|
|
template <typename T>
|
|
QDomElement ParseBuildingXml::getChildElement(const T &parent, const QString &childTag, bool bThrow) const
|
|
{
|
|
const QDomElement ret = parent.firstChildElement(childTag);
|
|
if (ret.isNull() && bThrow)
|
|
throw XmlImportException(tr("Invalid XML Structure - no '%1' tag (line %2:%3)")
|
|
.arg(childTag).arg(parent.lineNumber()).arg(parent.columnNumber()));
|
|
return ret;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------------------------------------
|
|
int ParseBuildingXml::getInteger(const QDomElement &element, const QString &attribute) const
|
|
{
|
|
bool bOk = true;
|
|
const int ret = element.attribute(attribute).toInt(&bOk);
|
|
if (!bOk)
|
|
throw XmlImportException(tr("Can not find attribute %1 in xml element %2 (line %3:%4)")
|
|
.arg(attribute, element.tagName()).arg(element.lineNumber()).arg(element.columnNumber()));
|
|
return ret;
|
|
}
|
|
|
|
} // namespace InfrastructureManagement
|