void RBFSystem::save(tinyxml2::XMLNode *parent){
auto element = parent->GetDocument()->NewElement("RBFSystem");
auto centers = parent->GetDocument()->NewElement("centers");
auto trendFunc = parent->GetDocument()->NewElement("TrendFunction");
auto minPosition = parent->GetDocument()->NewElement("minPosition");
auto maxPosition = parent->GetDocument()->NewElement("maxPosition");
parent->InsertEndChild(element);
element->InsertEndChild(trendFunc);
element->InsertEndChild(minPosition);
element->InsertEndChild(maxPosition);
element->InsertEndChild(centers);
trendFunc->SetAttribute("c0",_trend._c[0]);
trendFunc->SetAttribute("c1",_trend._c[1]);
trendFunc->SetAttribute("c2",_trend._c[2]);
trendFunc->SetAttribute("c3",_trend._c[3]);
minPosition->SetAttribute("x",_min.x);
minPosition->SetAttribute("y",_min.y);
minPosition->SetAttribute("z",_min.z);
maxPosition->SetAttribute("x",_max.x);
maxPosition->SetAttribute("y",_max.y);
maxPosition->SetAttribute("z",_max.z);
for(auto k = _kernels.begin();k!=_kernels.end();++k){
(*k)->save(centers);
}
}
void storeResults(const RendererType& renderer, std::size_t index) {
FilePath baseName(toString3(index));
FilePath pngDir = m_ResultPath + "png";
FilePath exrDir = m_ResultPath + "exr";
FilePath statsDir = m_ResultPath + "stats";
storeFramebuffer(index, pngDir, exrDir, baseName, m_fGamma, renderer.getFramebuffer());
createDirectory(statsDir);
auto& stats = m_RenderStatistics[index];
storeArray(statsDir + baseName.addExt(".nrmseFloat"), stats.nrmse);
storeArray(statsDir + baseName.addExt(".rmseFloat"), stats.rmse);
storeArray(statsDir + baseName.addExt(".absErrorFloat"), stats.mae);
storeArray(statsDir + baseName.addExt(".processingTimes"), stats.renderTimes);
auto reportsPath = m_ResultPath + "reports";
createDirectory(reportsPath);
auto reportDocumentPath = reportsPath + (toString3(index) + ".report.bnz.xml");
tinyxml2::XMLDocument reportDocument;
auto pReport = reportDocument.NewElement("Result");
auto pRendererStats = reportDocument.NewElement("RendererStats");
auto pRendererSettings = reportDocument.NewElement("Renderer");
renderer.storeSettings(*pRendererSettings);
renderer.storeStatistics(*pRendererStats);
reportDocument.InsertEndChild(pReport);
setAttribute(*pReport, "Index", index);
setChildAttribute(*pReport, "Gamma", m_fGamma);
setChildAttribute(*pReport, "RenderTime", stats.renderTimes.back());
setChildAttribute(*pReport, "NRMSE", stats.nrmse.back());
setChildAttribute(*pReport, "RMSE", stats.rmse.back());
setChildAttribute(*pReport, "MAE", stats.mae.back());
setChildAttribute(*pReport, "IterationCount", stats.getIterationCount());
pReport->InsertEndChild(pRendererStats);
pReport->InsertEndChild(pRendererSettings);
reportDocument.SaveFile(reportDocumentPath.c_str());
}
XmlNode * XmlNode::AddNode( const char * tagName )
{
TiXmlElement element( tagName );
XmlNode * node = reinterpret_cast<XmlNode*>( InsertEndChild( element ) );
IE_ASSERT( node );
return node;
}
XMLNode* XMLNode::InsertAfterChild(XMLNode* afterThis, XMLNode* addThis)
{
if (addThis->_document != _document)
return 0;
TIXMLASSERT(afterThis->_parent == this);
if (afterThis->_parent != this)
{
return 0;
}
if (afterThis->_next == 0)
{
// The last node or the only node.
return InsertEndChild(addThis);
}
if (addThis->_parent)
addThis->_parent->Unlink(addThis);
else
addThis->_memPool->SetTracked();
addThis->_prev = afterThis;
addThis->_next = afterThis->_next;
afterThis->_next->_prev = addThis;
afterThis->_next = addThis;
addThis->_parent = this;
return addThis;
}
void
CityMap::WriteXML(tinyxml2::XMLElement *parent)
{
auto cityElement = parent->GetDocument()->NewElement("city");
parent->InsertEndChild(cityElement);
cityElement->SetAttribute("name", this->name.c_str());
cityElement->SetAttribute("sizeX", this->sizeX);
cityElement->SetAttribute("sizeY", this->sizeY);
cityElement->SetAttribute("sizeZ", this->sizeZ);
for (int x = 0; x < sizeX ;x++)
{
for (int y = 0; y < sizeY; y++)
{
for (int z = 0; z < sizeZ; z++)
{
int tileID = tiles[x][y][z];
if (tileID == 0)
continue;
auto tileElement = parent->GetDocument()->NewElement("tile");
cityElement->InsertEndChild(tileElement);
std::stringstream ss;
ss << "city/citymap:" << tileID;
tileElement->SetAttribute("x", x);
tileElement->SetAttribute("y", y);
tileElement->SetAttribute("z", z);
tileElement->SetText(ss.str().c_str());
}
}
}
}
void XmlNode::SetText( const char * srcText, TextType textType )
{
std::string text = srcText;
if ( textType == STRING || text.length() == 0)
{
text = '"' + text;
text += '"';
}
TiXmlText textNode( text.c_str() );
if ( InsertEndChild( textNode ) == NULL )
{
IE_ASSERT( false );
}
}
tinyxml2::XMLNode* Map::getXML(tinyxml2::XMLDocument& doc,
Logger& l) const {
auto e = doc.NewElement("Map");
auto blocksE = doc.NewElement("Blocks");
e->InsertEndChild(blocksE);
for (auto b : blocks) {
if(b->whatIsIt() == WorldBlock::TRACK)
blocksE->InsertEndChild(b->getTrack().getXML(doc, l));
if(b->whatIsIt() == WorldBlock::STATION)
blocksE->InsertEndChild(b->getStation().getXML(doc, l));
if(b->whatIsIt() == WorldBlock::JUNCT)
blocksE->InsertEndChild(b->getJunction().getXML(doc, l));
}
auto trainsE = doc.NewElement("TrainList");
e->InsertEndChild(trainsE);
for (auto t : trains)
trainsE->InsertEndChild(t->getXML(doc, l));
return e;
}
void onBtnClicked()
{
for(mQLabel* mQL : dragwidgetptr->labelsInside)
if(mQL->noName()){
QMessageBox m;
m.setText("Proszę nadać nazwy wszystkim obiektom!");
m.exec();
return;
}
for(mQLabel* mQL : dragwidgetptr->tracksInside)
if(mQL->noName()){
QMessageBox m;
m.setText("Proszę nadać nazwy wszystkim obiektom!");
m.exec();
return;
}
std::string path;
//załaduj ścieżkę do pliku
QString text = QInputDialog::getText(nullptr, "Ścieżka do zapisania pliku",
"Ścieżka:", QLineEdit::Normal);
if (text.isEmpty())
return;
path = text.toStdString();
path = checkXMLextension(path);
tinyxml2::XMLDocument doc;
doc.SetBOM(true);
//doc.SetHeader(true);
auto map = doc.NewElement("Map");
doc.InsertEndChild(map);
auto blocksE = doc.NewElement("Blocks");
map->InsertEndChild(blocksE);
for (mQLabel* mQL : dragwidgetptr->labelsInside){
if (mQL->type == mQLabel::STATION){
auto e = doc.NewElement("WorldBlock");
e->SetAttribute("id", mQL->ID.toStdString().c_str());
e->SetAttribute("type", "Station");
e->SetAttribute("x", mQL->pos().x());
e->SetAttribute("y", mQL->pos().y());
e->SetAttribute("noOfRails", mQL->noOfRails);
blocksE->InsertEndChild(e);
}
else {
auto e = doc.NewElement("WorldBlock");
e->SetAttribute("id", mQL->ID.toStdString().c_str());
e->SetAttribute("type", "Junction");
e->SetAttribute("x", mQL->pos().x());
e->SetAttribute("y", mQL->pos().y());
blocksE->InsertEndChild(e);
}
}
for (mQLabel* mQL : dragwidgetptr->tracksInside){
auto e = doc.NewElement("WorldBlock");
e->SetAttribute("id", mQL->ID.toStdString().c_str());
e->SetAttribute("type", "Track");
e->SetAttribute("length", mQL->length);
e->SetAttribute("conn1", mQL->conn1->getName().toStdString().c_str());
e->SetAttribute("conn2", mQL->conn2->getName().toStdString().c_str());
e->SetAttribute("noOfRails", mQL->noOfRails);
e->SetAttribute("speedLimit", mQL->speedLimit);
blocksE->InsertEndChild(e);
}
auto trainsE = doc.NewElement("TrainList");
map->InsertEndChild(trainsE);
do{
TrainEditor* te = new TrainEditor;
te->exec();
if (te->ok == false) {
delete te;
break;
}
// w tym miejscu zapisywanie do xml
auto e = doc.NewElement("Train");
e->SetAttribute("id", te->trainName.toStdString().c_str());
e->SetAttribute("maxSpeed", te->maxSpeed);
e->SetAttribute("acceleration", te->acc);
e->SetAttribute("breakAcc", te->bAcc);
trainsE->InsertEndChild(e);
QTime currDelay = te->beginSec;
QString today("2014-01-01 ");
auto r = doc.NewElement("Route");
e->InsertEndChild(r);
for(std::pair<QString, QTime> p : te->route){
auto s = doc.NewElement("Section");
s->SetAttribute("id", p.first.toStdString().c_str());
s->SetAttribute("begin", (today + currDelay.toString()).toStdString().c_str());
currDelay = currDelay.addSecs(p.second.second() + 60*p.second.minute() + 3600*p.second.hour());
s->SetAttribute("end", (today + currDelay.toString()).toStdString().c_str());
r->InsertEndChild(s);
}
delete te;
} while (1);
auto result = doc.SaveFile(path.c_str());
if(result != tinyxml2::XML_NO_ERROR){
QMessageBox m;
m.setText("Nie udało się zapisać pliku");
m.exec();
}
}
void UIAnimation::Save(tinyxml2::XMLElement& elem)
{
if (mGlobalAnim){
elem.SetAttribute("globalName", mName.c_str());
}
else {
elem.SetAttribute("id", mID);
elem.SetAttribute("name", mName.c_str());
elem.SetAttribute("length", mLength);
elem.SetAttribute("loop", mLoop);
if (!mKeyTextColor.empty()){
auto textColorElem = elem.GetDocument()->NewElement("TextColor");
elem.InsertEndChild(textColorElem);
for (auto& it : mKeyTextColor)
{
auto keyelem = textColorElem->GetDocument()->NewElement("key");
textColorElem->InsertEndChild(keyelem);
keyelem->SetAttribute("time", it.first);
keyelem->SetAttribute("color", StringMathConverter::ToString(it.second).c_str());
}
}
if (!mKeyBackColor.empty()){
auto backColorElem = elem.GetDocument()->NewElement("BackColor");
elem.InsertEndChild(backColorElem);
for (auto& it : mKeyBackColor)
{
auto keyelem = backColorElem->GetDocument()->NewElement("key");
backColorElem->InsertEndChild(keyelem);
keyelem->SetAttribute("time", it.first);
keyelem->SetAttribute("color", StringMathConverter::ToString(it.second).c_str());
}
}
if (!mKeyMaterialColor.empty()){
auto materialColorElem = elem.GetDocument()->NewElement("MaterialColor");
elem.InsertEndChild(materialColorElem);
for (auto& it : mKeyMaterialColor)
{
auto keyelem = materialColorElem->GetDocument()->NewElement("key");
materialColorElem->InsertEndChild(keyelem);
keyelem->SetAttribute("time", it.first);
keyelem->SetAttribute("color", StringMathConverter::ToString(it.second).c_str());
}
}
if (!mKeyPos.empty()){
auto posElem = elem.GetDocument()->NewElement("Pos");
elem.InsertEndChild(posElem);
for (auto& it : mKeyPos)
{
auto keyelem = posElem->GetDocument()->NewElement("key");
posElem->InsertEndChild(keyelem);
keyelem->SetAttribute("time", it.first);
keyelem->SetAttribute("pos", StringMathConverter::ToString(it.second).c_str());
}
}
if (!mKeyScale.empty()){
auto scaleElem = elem.GetDocument()->NewElement("Scale");
elem.InsertEndChild(scaleElem);
for (auto& it : mKeyScale)
{
auto keyelem = scaleElem->GetDocument()->NewElement("key");
scaleElem->InsertEndChild(keyelem);
keyelem->SetAttribute("time", it.first);
keyelem->SetAttribute("scale", StringMathConverter::ToString(it.second).c_str());
}
}
if (!mKeyAlpha.empty()){
auto alphaElem = elem.GetDocument()->NewElement("Alpha");
elem.InsertEndChild(alphaElem);
for (auto& it : mKeyAlpha)
{
auto keyelem = alphaElem->GetDocument()->NewElement("key");
alphaElem->InsertEndChild(keyelem);
keyelem->SetAttribute("time", it.first);
keyelem->SetAttribute("alpha", StringConverter::ToString(it.second).c_str());
}
}
}
}
