void MapLoader::extractWalls() { TiXmlElement *textureElement = rootHandle.FirstChild("texture").ToElement(); string texturePath("none"); string surfaceType("none"); if (textureElement) { do { textureElement->QueryStringAttribute("source", &texturePath); textureElement->QueryStringAttribute("type", &surfaceType); TiXmlElement *wallBoxElement = textureElement->FirstChildElement("wall"); if (wallBoxElement) { do { scene->walls.emplace_back(); PhysicsEntity &wall = scene->walls.back(); XmlHelper::extractPosition(wallBoxElement, wall.position); XmlHelper::extractRotation(wallBoxElement, wall.rotation); XmlHelper::extractScale(wallBoxElement, wall.scale); wall.texture = TextureLoader::getTexture(texturePath); wall.texture.xTiling = 0.5f; wall.texture.yTiling = 0.5f; wall.mesh = MeshLoader::getPortalBox(wall); wall.physBody = BoxCollider::generateCage(wall); } while ((wallBoxElement = wallBoxElement->NextSiblingElement("wall")) != nullptr); } texturePath = "none"; } while ((textureElement = textureElement->NextSiblingElement("texture")) != nullptr); } }
OSMNode::OSMNode(TiXmlElement *element) : id(0), x(0), y(0), x_string(0), y_string(0) { if (element->Value() != std::string("node")) { std::cerr << "Unexpected '" << element->Value() << "' XML node, expected 'node'" << std::endl; throw std::runtime_error("wrong node"); } std::string id_string; element->QueryStringAttribute("id", &id_string); std::stringstream ss; ss << id_string; ss >> id; element->QueryDoubleAttribute("lat", &y); element->QueryDoubleAttribute("lon", &x); std::string lx_string, ly_string; element->QueryStringAttribute("lat", &ly_string); element->QueryStringAttribute("lon", &lx_string); element->QueryStringAttribute("timestamp", ×tamp); element->QueryStringAttribute("uid", &uid); element->QueryStringAttribute("user", &user); element->QueryStringAttribute("version", &version); element->QueryStringAttribute("changeset", &changeset); x_string = new std::string(lx_string); y_string = new std::string(ly_string); //std::cout << "id: " << id << " lat_precision: " << y_string.size()-1 << std::endl; //std::cout << "id: " << m_id << " x: " <<x << " y: " << y << std::endl; TiXmlHandle refH(element); TiXmlElement *ref = refH.FirstChild().Element(); for (; ref; ref=ref->NextSiblingElement()) { if (ref->Value() == std::string("tag")) { std::string key, value; ref->QueryStringAttribute("k", &key); ref->QueryStringAttribute("v", &value); if (!key.empty() && !value.empty()) { //std::cout << "Reading key: " << key << " value: " << value << std::endl; tags[key] = value; } } } }
void MapLoader::extractButtons() { TiXmlElement *textureElement = rootHandle.FirstChild("texture").ToElement(); string texturePath("none"); string surfaceType("none"); Vector2f position; Vector2f size; if (textureElement) { do { textureElement->QueryStringAttribute("source", &texturePath); textureElement->QueryStringAttribute("type", &surfaceType); TiXmlElement *buttonElement = textureElement->FirstChildElement("GUIbutton"); if (buttonElement) { do { scene->buttons.emplace_back(); GUIButton &button = scene->buttons.back(); buttonElement->QueryFloatAttribute("x", &position.x); buttonElement->QueryFloatAttribute("y", &position.y); buttonElement->QueryFloatAttribute("w", &size.x); buttonElement->QueryFloatAttribute("h", &size.y); button.texture = TextureLoader::getTexture(texturePath); button.texture.xTiling = 0.5f; button.texture.yTiling = 0.5f; } while ((buttonElement = buttonElement->NextSiblingElement("GUIbutton")) != nullptr); } texturePath = "none"; } while ((textureElement = textureElement->NextSiblingElement("texture")) != nullptr); } }
bool SVG::read( const char* data ) { TiXmlDocument doc; doc.Parse( data ); if (doc.Error()) { return false; } TiXmlElement* root = doc.FirstChild( "svg" )->ToElement(); recursive_parse( root ); // get bounds information from the svg file, ignoring non-pixel values string numberWithUnitString; regex numberWithUnitPattern( "^(-?\\d+)(px)?$" ); _handler->_minX = 0.0f; if ( root->QueryStringAttribute( "x", &numberWithUnitString ) == TIXML_SUCCESS ) { match_results<string::const_iterator> matches; if ( regex_search( numberWithUnitString, matches, numberWithUnitPattern ) ) { _handler->_minX = ::atof( matches[1].str().c_str() ); } } _handler->_minY = 0.0f; if ( root->QueryStringAttribute( "y", &numberWithUnitString ) == TIXML_SUCCESS ) { match_results<string::const_iterator> matches; if ( regex_search( numberWithUnitString, matches, numberWithUnitPattern ) ) { _handler->_minY = ::atof( matches[1].str().c_str() ); } } _handler->_width = 0.0f; if ( root->QueryStringAttribute( "width", &numberWithUnitString ) == TIXML_SUCCESS ) { match_results<string::const_iterator> matches; if ( regex_search( numberWithUnitString, matches, numberWithUnitPattern ) ) { _handler->_width = ::atof( matches[1].str().c_str() ); } } _handler->_height = 0.0f; if ( root->QueryStringAttribute( "height", &numberWithUnitString ) == TIXML_SUCCESS ) { match_results<string::const_iterator> matches; if ( regex_search( numberWithUnitString, matches, numberWithUnitPattern ) ) { _handler->_height = ::atof( matches[1].str().c_str() ); } } return true; }
void MapLoader::extractTriggers() { TiXmlElement *triggerElement = rootHandle.FirstChild("trigger").ToElement(); string triggerType("none"); if (triggerElement) { do { TiXmlElement *triggerTypeElement; scene->triggers.emplace_back(); Trigger &trigger = scene->triggers.back(); if (triggerElement) { triggerElement->QueryStringAttribute("type", &trigger.type); } if (triggerType == "none") { throw std::runtime_error("Trigger must define a type attribute."); } XmlHelper::extractPosition(triggerElement, trigger.position); XmlHelper::extractScale(triggerElement, trigger.scale); } while ((triggerElement = triggerElement->NextSiblingElement()) != nullptr); } }
void Graphe::importTemplate(QString & filename){ TiXmlDocument doc(filename.toStdString()); if(doc.LoadFile()){ //TiXmlHandle hDoc(&doc); TiXmlElement * pRoot; TiXmlElement * pChildren; std::string temps; TiXmlElement * pGraph; pGraph = doc.FirstChildElement("Graph"); if(pGraph){ pRoot = pGraph->FirstChildElement("Nodes"); int i, x, y; if(pRoot){ pChildren = pRoot->FirstChildElement("Node"); while(pChildren){ pChildren->QueryIntAttribute("id", &i); if(i<n){ pChildren->QueryIntAttribute("x", &x); pChildren->QueryIntAttribute("y", &y); noeuds[i]= Noeud(x,y); //qDebug()<<i; if(pChildren->QueryStringAttribute("Label", &temps) == TIXML_SUCCESS){ //qDebug()<<QString(temps.c_str()); labels[i]= QString(temps.c_str()); } } pChildren = pChildren->NextSiblingElement("Node"); } } } } }
std::string Loader::getAttribute(const TiXmlElement &element, const std::string &attribute) const { std::string value = ""; if (element.QueryStringAttribute(attribute.c_str(), &value) != TIXML_SUCCESS) { throw std::invalid_argument("attribute " + attribute + " not defined"); } return value; }
Vector ParticleComponentLoader::loadVector(const TiXmlElement& xmlElement, const char* pname) { Vector result; std::string value; if ( xmlElement.QueryStringAttribute(pname, &value) == TIXML_SUCCESS ) { result = parseVector(value); } return result; }
void MapLoader::extractModels() { Vector3f modelPos; string texture("none"); string mesh("none"); TiXmlElement *modelElement = rootHandle.FirstChild("model").ToElement(); if (modelElement){ do { modelElement->QueryStringAttribute("texture", &texture); modelElement->QueryStringAttribute("mesh", &mesh); XmlHelper::pushAttributeVertexToVector(modelElement, modelPos); scene->models.emplace_back(); VisualEntity &model = scene->models.back(); XmlHelper::extractPosition(modelElement, model.position); XmlHelper::extractRotation(modelElement, model.rotation); model.texture = TextureLoader::getTexture(texture); model.mesh = MeshLoader::getMesh(mesh); } while ((modelElement = modelElement->NextSiblingElement("model")) != nullptr); } }
std::unique_ptr<ISkill> DamageSkillLoader::mt_Load_Element(const TiXmlElement& element) { std::unique_ptr<ISkill> l_ret(nullptr); std::string l_skill_name, l_tmp; int l_skill_damages; DamageSkill::DamageSkillOperator l_skill_operator; /** name **/ element.QueryStringAttribute("name", &l_skill_name); /** damages **/ element.QueryIntAttribute("damages", &l_skill_damages); /** operator **/ element.QueryStringAttribute("operator", &l_tmp); l_skill_operator = DamageSkill::mt_String_To_Operator(l_tmp); /** new object **/ //if (l_fn_returned == TIXML_SUCCESS) l_ret = new DamageSkill(l_skill_name, l_skill_damages, l_skill_operator); return l_ret; }
void playlist::load(std::string filename) { music.clear(); if (access(filename.c_str(), F_OK)==-1) { printf("No playlist found(%s). No music will played.\n", filename.c_str()); return; } TiXmlDocument doc(filename.c_str()); doc.LoadFile(); TiXmlHandle hDoc(&doc); TiXmlElement* pElem; TiXmlHandle hRoot(0); pElem=hDoc.FirstChildElement().Element(); // should always have a valid root but handle gracefully if it doesn't if (!pElem) { printf("Error opening: %s. No music will played.\n", filename.c_str()); return; } // printf("name: %s\n", pElem->Value()); hRoot=TiXmlHandle(pElem); TiXmlElement * songs = hRoot.FirstChild().Element(); for (; songs!=NULL; songs=songs->NextSiblingElement()) { const char *pKey=songs->Value(); const char *pText=songs->GetText(); if (!pKey || !pText) continue; // printf("loop: %s %s\n", pKey, pText); std::string file = pText; std::string disp; // songs->QueryStringAttribute("display", &disp); if (songs->QueryStringAttribute("display", &disp)!= TIXML_SUCCESS) disp = file; // printf("%s: %s\n", disp.c_str(), file.c_str()); if (access(file.c_str(), F_OK)==-1) { //no file found } else { music.push_back(std::make_pair(disp, file)); } } }
RobotInterface::ParamList RobotInterface::XMLReader::Private::readParamListTag(TiXmlElement* paramListElem) { if (paramListElem->ValueStr().compare("paramlist") != 0) { SYNTAX_ERROR(paramListElem->Row()) << "Expected \"paramlist\". Found" << paramListElem->ValueStr(); } ParamList params; Param mainparam; if (paramListElem->QueryStringAttribute("name", &mainparam.name()) != TIXML_SUCCESS) { SYNTAX_ERROR(paramListElem->Row()) << "\"paramlist\" element should contain the \"name\" attribute"; } params.push_back(mainparam); // yDebug() << "Found paramlist [" << params.at(0).name() << "]"; for (TiXmlElement* childElem = paramListElem->FirstChildElement(); childElem != 0; childElem = childElem->NextSiblingElement()) { if (childElem->ValueStr().compare("elem") != 0) { SYNTAX_ERROR(childElem->Row()) << "Expected \"elem\". Found" << childElem->ValueStr(); } Param childParam; if (childElem->QueryStringAttribute("name", &childParam.name()) != TIXML_SUCCESS) { SYNTAX_ERROR(childElem->Row()) << "\"elem\" element should contain the \"name\" attribute"; } const char *valueText = childElem->GetText(); if (!valueText) { SYNTAX_ERROR(childElem->Row()) << "\"elem\" element should have a value [ \"name\" = " << childParam.name() << "]"; } childParam.value() = valueText; params.push_back(childParam); } if (params.empty()) { SYNTAX_ERROR(paramListElem->Row()) << "\"paramlist\" cannot be empty"; } // +1 skips the first element, that is the main param for (ParamList::iterator it = params.begin() + 1; it != params.end(); ++it) { Param ¶m = *it; params.at(0).value() += (params.at(0).value().empty() ? "(" : " ") + param.name(); } params.at(0).value() += ")"; // yDebug() << params; return params; }
void HierClassifier::loadCache(boost::filesystem::path file){ cout << "Loading cache from file " << file.string() << endl; TiXmlDocument doc(file.c_str()); if(!doc.LoadFile()){ cout << "Could not load cache file" << endl; throw "Could not load cache file"; } TiXmlElement* pWeakClassifiers = doc.FirstChildElement("weak_classifiers"); if(!pWeakClassifiers){ throw "Bad cache file - no weak_classifiers"; } int numClassifiers; pWeakClassifiers->QueryIntAttribute("num", &numClassifiers); pWeakClassifiers->QueryIntAttribute("num_labels", &numLabels); TiXmlElement* pClassifier = pWeakClassifiers->FirstChildElement("classifier"); while(pClassifier){ string cacheFile; double weight; WeakClassifierInfo info; string classifierType; pClassifier->QueryStringAttribute("type", &classifierType); pClassifier->QueryStringAttribute("cache_file", &cacheFile); pClassifier->QueryDoubleAttribute("weight", &weight); pClassifier->QueryIntAttribute("desc_beg", &(info.descBeg)); pClassifier->QueryIntAttribute("desc_end", &(info.descEnd)); weights.push_back(weight); classifiersInfo.push_back(info); if(classifierType == "SVM"){ classifiers.push_back(new ClassifierSVM()); } else if(classifierType == "RF"){ classifiers.push_back(new ClassifierRF()); } classifiers.back()->loadCache(pClassifier, cacheFile); pClassifier = pClassifier->NextSiblingElement("classifier"); } }
void StateLoader::LoadEnums(TiXmlHandle &hRoot, std::string functionName, IGlobalState *state) { std::string name = ""; std::string valueString = ""; TiXmlElement *pElem; TiXmlHandle handle(hRoot.FirstChild("enums").Element()); pElem = handle.FirstChild().Element(); for (; 0 != pElem; pElem = pElem->NextSiblingElement()) { int value, length = 1; pElem->QueryStringAttribute("name", &name); pElem->QueryStringAttribute("value", &valueString); if (pElem->QueryIntAttribute("length", &length) != TIXML_SUCCESS){ length = 1; } value = (int)strtol(valueString.c_str(), NULL, 0); state->addStateEnum(name, functionName, value, length); } }
bool SVG::read( const char* data ) { TiXmlDocument doc; doc.Parse( data ); if (doc.Error()) { return false; } TiXmlElement* root = doc.FirstChild( "svg" )->ToElement(); recursive_parse( root ); // get bounds information from the svg file, ignoring non-pixel values string numberWithUnitString; _handler->_minX = 0.0f; if ( root->QueryStringAttribute( "x", &numberWithUnitString ) == TIXML_SUCCESS ) { _handler->_minX = findNumberWithUnit( numberWithUnitString, _handler->_minX ); } _handler->_minY = 0.0f; if ( root->QueryStringAttribute( "y", &numberWithUnitString ) == TIXML_SUCCESS ) { _handler->_minY = findNumberWithUnit( numberWithUnitString, _handler->_minY ); } _handler->_width = 0.0f; if ( root->QueryStringAttribute( "width", &numberWithUnitString ) == TIXML_SUCCESS ) { _handler->_width = findNumberWithUnit( numberWithUnitString, _handler->_width ); } _handler->_height = 0.0f; if ( root->QueryStringAttribute( "height", &numberWithUnitString ) == TIXML_SUCCESS ) { _handler->_height = findNumberWithUnit( numberWithUnitString, _handler->_height ); } return true; }
void StateLoader::LoadFunctionEnums(TiXmlHandle &handle, IGlobalState *state) { TiXmlElement *pElem; std::string name; std::string data = ""; std::string functionName; pElem = handle.FirstChild().Element(); for (; 0 != pElem; pElem = pElem->NextSiblingElement()) { TiXmlHandle methodHandle(pElem); pElem->QueryStringAttribute("function", &functionName); LoadEnums(methodHandle, functionName, state); } }
void mitk::XMLSerializable::FromXMLFile(const std::string& file , const std::string& elemName) { endodebug( "Trying to read from " << file ) TiXmlDocument doc( file.c_str() ); bool loadOkay = doc.LoadFile(); if(!loadOkay) { std::ostringstream s; s << "File " << file << " could not be loaded!"; throw std::logic_error(s.str().c_str()); } m_XMLFileName = file; TiXmlElement* elem = doc.FirstChildElement(); endoAssertMsg( elem, "No root element found" ); // determine element to read from std::string elementName = elemName; if(elementName.empty()) elementName = this->GetNameOfClass(); // try again with the first element if(strcmp(elem->Value(), elementName.c_str()) != 0) elem = elem->FirstChildElement(elementName.c_str()); endoAssertMsg( elem, "No child element \"" << elementName << "\" found in " << file ); // if theres an attribute as file reference try to load the class // from that file std::string filename; if(elem->QueryStringAttribute(FILE_REFERENCE_ATTRIBUTE_NAME.c_str(), &filename) == TIXML_SUCCESS) { if( !itksys::SystemTools::FileIsFullPath(filename.c_str()) ) filename = itksys::SystemTools::GetFilenamePath(file) + "/" + filename; this->FromXMLFile(filename); return; // exit! } this->FromXML( elem ); }
Range ParticleComponentLoader::loadValueRange(const TiXmlElement& xmlElement, const char* pname) { Range result; std::string value; if ( xmlElement.QueryStringAttribute(pname, &value) == TIXML_SUCCESS ) { std::size_t index = value.find(':'); if ( index != value.npos ) { std::string leftstr = value.substr(0, index); std::string rightstr = value.substr(index+1, value.length() - index - 1); float left = (float) std::atof(leftstr.c_str()); float right = (float) std::atof(rightstr.c_str()); result.set(left, right - left); } } return result; }
TiXmlElement *CLibraryDirectory::LoadXML(const std::string &xmlFile) { if (!CFile::Exists(xmlFile)) return NULL; if (!m_doc.LoadFile(xmlFile)) return NULL; TiXmlElement *xml = m_doc.RootElement(); if (!xml || xml->ValueStr() != "node") return NULL; // check the condition std::string condition; xml->QueryStringAttribute("visible", &condition); if (condition.empty() || g_infoManager.EvaluateBool(condition)) return xml; return NULL; }
VectorRange ParticleComponentLoader::loadVectorRange(const TiXmlElement& xmlElement, const char* pname) { VectorRange result; std::string value; if ( xmlElement.QueryStringAttribute(pname, &value) == TIXML_SUCCESS ) { std::size_t index = value.find(':'); if ( index != value.npos ) { std::string leftrange = value.substr(0, index); std::string rightrange = value.substr(index+1, value.length() - index - 1); Vector left = parseVector(leftrange); Vector right = parseVector(rightrange); result.set(left, right); } } return result; }
bool AutoTimer::UpdateFrom(TiXmlElement* autoTimerNode, Channels &channels) { std::string strTmp; int iTmp; m_type = Timer::EPG_AUTO_SEARCH; //this is an auto timer so the state is always scheduled unless it's disabled m_state = PVR_TIMER_STATE_SCHEDULED; m_tags.clear(); if (XMLUtils::GetString(autoTimerNode, "e2tags", strTmp)) m_tags = strTmp; if (autoTimerNode->QueryStringAttribute("name", &strTmp) == TIXML_SUCCESS) m_title = strTmp; if (autoTimerNode->QueryStringAttribute("match", &strTmp) == TIXML_SUCCESS) m_searchPhrase = strTmp; if (autoTimerNode->QueryStringAttribute("enabled", &strTmp) == TIXML_SUCCESS) { if (strTmp == AUTOTIMER_ENABLED_NO) { m_state = PVR_TIMER_STATE_DISABLED; } } if (autoTimerNode->QueryIntAttribute("id", &iTmp) == TIXML_SUCCESS) m_backendId = iTmp; std::string from; std::string to; std::string avoidDuplicateDescription; std::string searchForDuplicateDescription; autoTimerNode->QueryStringAttribute("from", &from); autoTimerNode->QueryStringAttribute("to", &to); autoTimerNode->QueryStringAttribute("avoidDuplicateDescription", &avoidDuplicateDescription); autoTimerNode->QueryStringAttribute("searchForDuplicateDescription", &searchForDuplicateDescription); if (avoidDuplicateDescription != AUTOTIMER_AVOID_DUPLICATE_DISABLED) { if (searchForDuplicateDescription == AUTOTIMER_CHECK_SEARCH_FOR_DUP_IN_TITLE) m_deDup = AutoTimer::DeDup::CHECK_TITLE; else if (searchForDuplicateDescription == AUTOTIMER_CHECK_SEARCH_FOR_DUP_IN_TITLE_AND_SHORT_DESC) m_deDup = AutoTimer::DeDup::CHECK_TITLE_AND_SHORT_DESC; else if (searchForDuplicateDescription.empty() || searchForDuplicateDescription == AUTOTIMER_CHECK_SEARCH_FOR_DUP_IN_TITLE_AND_ALL_DESCS) //Even though this value should be 2 it is sent as ommitted for this attribute, we'll allow 2 anyway incase it changes in the future m_deDup = AutoTimer::DeDup::CHECK_TITLE_AND_ALL_DESCS; } if (autoTimerNode->QueryStringAttribute("encoding", &strTmp) == TIXML_SUCCESS) m_encoding = strTmp; if (autoTimerNode->QueryStringAttribute("searchType", &strTmp) == TIXML_SUCCESS) { m_searchType = strTmp; if (strTmp == AUTOTIMER_SEARCH_TYPE_DESCRIPTION) m_searchFulltext = true; } if (autoTimerNode->QueryStringAttribute("searchCase", &strTmp) == TIXML_SUCCESS) m_searchCase = strTmp; TiXmlElement* serviceNode = autoTimerNode->FirstChildElement("e2service"); if (serviceNode) { const TiXmlElement *nextServiceNode = serviceNode->NextSiblingElement("e2service"); if (!nextServiceNode) { //If we only have one channel if (XMLUtils::GetString(serviceNode, "e2servicereference", strTmp)) { m_channelId = channels.GetChannelUniqueId(Channel::NormaliseServiceReference(strTmp.c_str())); // For autotimers for channels we don't know about, such as when the addon only uses one bouquet or an old channel referene that doesn't exist // we'll default to any channel (as that is what kodi PVR does) and leave in ERROR state if (m_channelId == PVR_CHANNEL_INVALID_UID) { m_state = PVR_TIMER_STATE_ERROR; Logger::Log(LEVEL_DEBUG, "%s Overriding AutoTimer state as channel not found, state is: ERROR", __FUNCTION__); m_channelName = LocalizedString(30520); // Invalid Channel m_channelId = PVR_TIMER_ANY_CHANNEL; m_anyChannel = true; } else { m_channelName = channels.GetChannel(m_channelId)->GetChannelName(); } } } else //otherwise set to any channel { m_channelId = PVR_TIMER_ANY_CHANNEL; m_anyChannel = true; } } else //otherwise set to any channel { m_channelId = PVR_TIMER_ANY_CHANNEL; m_anyChannel = true; } m_weekdays = 0; TiXmlElement* includeNode = autoTimerNode->FirstChildElement("include"); if (includeNode) { for (; includeNode != nullptr; includeNode = includeNode->NextSiblingElement("include")) { std::string includeVal = includeNode->GetText(); std::string where; if (includeNode->QueryStringAttribute("where", &where) == TIXML_SUCCESS) { if (where == "dayofweek") { m_weekdays = m_weekdays |= (1 << atoi(includeVal.c_str())); } } } } if (m_weekdays != PVR_WEEKDAY_NONE) { std::time_t t = std::time(nullptr); std::tm timeinfo = *std::localtime(&t); timeinfo.tm_sec = 0; m_startTime = 0; if (!from.empty()) { ParseTime(from, timeinfo); m_startTime = std::mktime(&timeinfo); } timeinfo = *std::localtime(&t); timeinfo.tm_sec = 0; m_endTime = 0; if (!to.empty()) { ParseTime(to, timeinfo); m_endTime = std::mktime(&timeinfo); } } else { for (int i = 0; i < DAYS_IN_WEEK; i++) { m_weekdays = m_weekdays |= (1 << i); } m_startAnyTime = true; m_endAnyTime = true; } if (ContainsTag(TAG_FOR_GENRE_ID)) { int genreId = 0; if (std::sscanf(ReadTagValue(TAG_FOR_GENRE_ID).c_str(), "0x%02X", &genreId) == 1) { m_genreType = genreId & 0xF0; m_genreSubType = genreId & 0x0F; } else { m_genreType = 0; m_genreSubType = 0; } } return true; }
BaseProperty::Pointer mitk::TransferFunctionPropertySerializer::Deserialize(TiXmlElement* element) { if (!element) return nullptr; mitk::LocaleSwitch localeSwitch("C"); TransferFunction::Pointer tf = TransferFunction::New(); // deserialize scalar opacity function TiXmlElement* scalarOpacityPointlist = element->FirstChildElement("ScalarOpacity"); if (scalarOpacityPointlist == nullptr) { return nullptr; } tf->ClearScalarOpacityPoints(); try { for( TiXmlElement* pointElement = scalarOpacityPointlist->FirstChildElement("point"); pointElement != nullptr; pointElement = pointElement->NextSiblingElement("point")) { std::string x; std::string y; if (pointElement->QueryStringAttribute("x", &x) != TIXML_SUCCESS) return nullptr; if (pointElement->QueryStringAttribute("y", &y) != TIXML_SUCCESS) return nullptr; tf->AddScalarOpacityPoint(boost::lexical_cast<double>(x), boost::lexical_cast<double>(y)); } TiXmlElement* gradientOpacityPointlist = element->FirstChildElement("GradientOpacity"); if (gradientOpacityPointlist == nullptr) { return nullptr; } tf->ClearGradientOpacityPoints(); for( TiXmlElement* pointElement = gradientOpacityPointlist->FirstChildElement("point"); pointElement != nullptr; pointElement = pointElement->NextSiblingElement("point")) { std::string x; std::string y; if (pointElement->QueryStringAttribute("x", &x) != TIXML_SUCCESS) return nullptr; if (pointElement->QueryStringAttribute("y", &y) != TIXML_SUCCESS) return nullptr; tf->AddGradientOpacityPoint(boost::lexical_cast<double>(x), boost::lexical_cast<double>(y)); } TiXmlElement* rgbPointlist = element->FirstChildElement("Color"); if (rgbPointlist == nullptr) { return nullptr; } vtkColorTransferFunction* ctf = tf->GetColorTransferFunction(); if (ctf == nullptr) { return nullptr; } ctf->RemoveAllPoints(); for( TiXmlElement* pointElement = rgbPointlist->FirstChildElement("point"); pointElement != nullptr; pointElement = pointElement->NextSiblingElement("point")) { std::string x; std::string r,g,b, midpoint, sharpness; if (pointElement->QueryStringAttribute("x", &x) != TIXML_SUCCESS) return nullptr; if (pointElement->QueryStringAttribute("r", &r) != TIXML_SUCCESS) return nullptr; if (pointElement->QueryStringAttribute("g", &g) != TIXML_SUCCESS) return nullptr; if (pointElement->QueryStringAttribute("b", &b) != TIXML_SUCCESS) return nullptr; if (pointElement->QueryStringAttribute("midpoint", &midpoint) != TIXML_SUCCESS) return nullptr; if (pointElement->QueryStringAttribute("sharpness", &sharpness) != TIXML_SUCCESS) return nullptr; ctf->AddRGBPoint(boost::lexical_cast<double>(x), boost::lexical_cast<double>(r), boost::lexical_cast<double>(g), boost::lexical_cast<double>(b), boost::lexical_cast<double>(midpoint), boost::lexical_cast<double>(sharpness)); } } catch ( boost::bad_lexical_cast& e ) { MITK_ERROR << "Could not parse string as number: " << e.what(); return nullptr; } return TransferFunctionProperty::New(tf).GetPointer(); }
void EndoDebugFromXmlFile::Update() { endodebug( __FUNCTION__ ) std::string _FileName = *d->m_FileName; if( !itksys::SystemTools::FileExists( _FileName.c_str() ) ) { endodebug(_FileName << " does not exist"); return; } long int _FileModifiedTime = itksys::SystemTools::ModifiedTime( _FileName.c_str() ); // file has changed: we know an older version... if( d->m_FileModifiedTime >= _FileModifiedTime ) { endodebug("File not changed. No Update necessary."); return; } // reread endodebugvar( _FileName ) TiXmlDocument doc( _FileName ); doc.LoadFile(); TiXmlHandle docHandle( &doc ); TiXmlElement* elem = docHandle.FirstChildElement().FirstChildElement( "EndoDebug" ).ToElement(); if(elem == 0) { endodebug("EndoDebug element not found"); return; } int _DebugEnabled = d->m_EndoDebug->GetDebugEnabled(); if( elem->QueryIntAttribute("DebugEnabled",&_DebugEnabled) != TIXML_SUCCESS ) endodebug("DebugEnabled attribute not found"); int _ShowImagesInDebug = d->m_EndoDebug->GetShowImagesInDebug(); if( elem->QueryIntAttribute("ShowImagesInDebug",&_ShowImagesInDebug) != TIXML_SUCCESS ) endodebug("ShowImagesInDebug attribute not found"); int _ShowImagesTimeOut = d->m_EndoDebug->GetShowImagesTimeOut(); if( elem->QueryIntAttribute("ShowImagesTimeOut",&_ShowImagesTimeOut) != TIXML_SUCCESS ) endodebug("ShowImagesTimeOut attribute not found"); std::string _DebugImagesOutputDirectory = d->m_EndoDebug->GetDebugImagesOutputDirectory(); if( elem->QueryStringAttribute("DebugImagesOutputDirectory",&_DebugImagesOutputDirectory) != TIXML_SUCCESS ) endodebug("DebugImagesOutputDirectory attribute not found"); std::set<std::string> _FilesToDebug; std::string _FilesToDebugString; if( elem->QueryStringAttribute("FilesToDebug",&_FilesToDebugString) != TIXML_SUCCESS ) { endodebug("FilesToDebug attribute not found"); } else { StringExplode( _FilesToDebugString, ";", &_FilesToDebug ); } std::set<std::string> _SymbolsToDebug; std::string _SymbolsToDebugString; if( elem->QueryStringAttribute("SymbolsToDebug",&_SymbolsToDebugString) != TIXML_SUCCESS ) { endodebug("SymbolsToDebug attribute not found"); } else { StringExplode( _SymbolsToDebugString, ";", &_SymbolsToDebug ); } // save mitk::EndoDebug::GetInstance().SetDebugEnabled( _DebugEnabled == 1? true: false ); mitk::EndoDebug::GetInstance().SetShowImagesInDebug( _ShowImagesInDebug == 1? true: false ); mitk::EndoDebug::GetInstance().SetShowImagesTimeOut( _ShowImagesTimeOut ); mitk::EndoDebug::GetInstance().SetDebugImagesOutputDirectory( _DebugImagesOutputDirectory ); mitk::EndoDebug::GetInstance().SetFilesToDebug(_FilesToDebug); mitk::EndoDebug::GetInstance().SetSymbolsToDebug(_SymbolsToDebug); // save that modified time d->m_FileModifiedTime = _FileModifiedTime; }
bool Guldmannen::Level::Load(std::string _filename) { filename = "resources/levels/" + _filename; TiXmlDocument doc(filename.c_str()); doc.LoadFile(); TiXmlHandle root(&doc); TiXmlElement *tempElement; tempElement = root.FirstChild("level").Element(); if(tempElement) { std::cout << "Loading level with \"name\": " << tempElement->Attribute("name") << "\n"; tilesetfile = tempElement->Attribute("tileset"); tempElement->QueryIntAttribute("width",&width); tempElement->QueryIntAttribute("height",&height); std::cout << "height: " << height << ", width: " << width <<".\n"; //loading level relations and their offsets [4] tempElement = root.FirstChild("level").FirstChild("worldrelations").FirstChild("left").Element(); if(tempElement){ tempElement->QueryStringAttribute("level",&leadsTo[0]); tempElement->QueryIntAttribute("offset",&leadsTo_offset[0]); } tempElement = root.FirstChild("level").FirstChild("worldrelations").FirstChild("right").Element(); if(tempElement){ tempElement->QueryStringAttribute("level",&leadsTo[1]); tempElement->QueryIntAttribute("offset",&leadsTo_offset[1]); } tempElement = root.FirstChild("level").FirstChild("worldrelations").FirstChild("up").Element(); if(tempElement){ tempElement->QueryStringAttribute("level",&leadsTo[2]); tempElement->QueryIntAttribute("offset",&leadsTo_offset[2]); } tempElement = root.FirstChild("level").FirstChild("worldrelations").FirstChild("down").Element(); if(tempElement){ tempElement->QueryStringAttribute("level",&leadsTo[3]); tempElement->QueryIntAttribute("offset",&leadsTo_offset[3]); } } else { std::cout << "Failed to begin load level\n"; return false; } tempElement = root.FirstChild("level").FirstChild("tile").Element(); if(!tempElement) { std::cout << "Error, no tile nodes!\n"; return false; } int temptile[4] = {-1}; for(int i = 0 ; i<height*width ; tempElement = tempElement->NextSiblingElement("tile"), i++) { //if(tempElement->QueryIntAttribute("id",&temptile)) //{ tempElement->QueryIntAttribute("id",&temptile[0]); if(tempElement->QueryIntAttribute("id2",&temptile[1]) == 1) temptile[1] = -1; if(tempElement->QueryIntAttribute("id3",&temptile[2]) == 1) temptile[2] = -1; if(tempElement->QueryIntAttribute("id4",&temptile[3]) == 1) temptile[3] = -1; //if(i<100) Tiles.push_back(new Tile(temptile,1)); //else int temp_type = 0; if(tempElement->QueryIntAttribute("type",&temp_type) == 1) temp_type = 0; float temp_tps = 0; if(tempElement->QueryFloatAttribute("tps",&temp_tps) == 1) temp_tps = 0; int temp_frames = 0; tempElement->QueryIntAttribute("frames",&temp_frames); Tiles.push_back(new Tile(temptile,temp_type,temp_frames,temp_tps)); //} /*else { std::cout << "Failed to load level\n"; return false; }*/ TiXmlElement *twarp = tempElement->FirstChildElement("warp"); if(twarp != NULL) { std::cout << "hmm warp?\n"; std::string destination; int destX; int destY; if(twarp->QueryIntAttribute("dest_x",&destX) != 1) { if(twarp->QueryIntAttribute("dest_y",&destY) != 1) { if(twarp->QueryStringAttribute("dest_level",&destination) == 1) { destination = ""; } Warps.push_back(new Warp(i%width,(i-(i%width))/width,destX,destY,destination)); std::cout << "addade ett warp!! :D " << i%width << " " << (i-(i%width))/width << " " << destX << " " << destY << " " << destination << ".\n\n\n\n\n\n"; } } } TiXmlElement *entity = tempElement->FirstChildElement("entity"); if(entity != NULL) { std::cout << "adding an entity..\n"; entityHandler->AddEntity(entity, vec2d(i%width,(i-(i%width))/width)); } } tileSheet = Resources->GetTexture("resources/tilesets/" + tilesetfile); if(tileSheet == NULL) { std::cout << "tileSheet was never loaded!\n"; return false; } //else if(render) { RenderImage *gt_temp = NULL;//new RenderImage(tileSheet,true); int t = 0; for(int i=0;i<height;i++) { for(int j=0;j<width;j++) { for(int l=0;l<4;l++) { if(Tiles[t]->id[l] != -1) { gt_temp = new RenderImage(tileSheet,true); int W = tileSheet->Width/32; int H = tileSheet->Height/32; gt_temp->SetPosition(j*32,i*32); gt_temp->SetSize(32,32); gt_temp->SetTexClip(32,32,(Tiles[t]->id[l])%W*32, ((Tiles[t]->id[l]*32) - (Tiles[t]->id[l])%W*32) /W); if(l == 2) gt_temp->SetZ(0.5 + (0.0001*((i*32)+32))); else gt_temp->SetZ(0.4 + (0.1*l)); graphical_tiles.push_back(gt_temp); Tiles[t]->graphic_id[l] = (int)graphical_tiles.size()-1; } } t++; } } } return true; }
void ClassifierSVM::loadSettings(TiXmlElement* settings){ string tmp; cacheEnabled = true; TiXmlElement* pPtr = settings->FirstChildElement("cache"); if(!pPtr){ throw "Bad settings file - no cache setting for ClassifierSVM"; } pPtr->QueryBoolAttribute("enabled", &cacheEnabled); pPtr = settings->FirstChildElement("svm"); if(!pPtr){ throw "Bad settings file - no svm settings"; } int svmType; pPtr->QueryStringAttribute("type", &tmp); if(tmp == "C_SVC"){ svmType = C_SVC; } else if(tmp == "NU_SVC"){ svmType = NU_SVC; } else if(tmp == "ONE_CLASS"){ svmType = ONE_CLASS; } else{ throw "Bad settings file - wrong SVM type"; } int kernelType; TiXmlElement* svmPtr = pPtr->FirstChildElement("kernelType"); if(!svmPtr){ throw "Bad settings file - no kernel type"; } svmPtr->QueryStringAttribute("value", &tmp); if(tmp == "LINEAR"){ kernelType = LINEAR; } else if(tmp == "POLY"){ kernelType = POLY; } else if(tmp == "RBF"){ kernelType = RBF; } else if(tmp == "SIGMOID"){ kernelType = SIGMOID; } else{ throw "Bad settings file - wrong kernel type"; } double gamma = 0.5; svmPtr = pPtr->FirstChildElement("gamma"); if(!svmPtr){ throw "Bad settings file - no gamma value"; } svmPtr->QueryDoubleAttribute("value", &gamma); double degree = 2; svmPtr = pPtr->FirstChildElement("degree"); if(!svmPtr){ throw "Bad settings file - no degree value"; } svmPtr->QueryDoubleAttribute("value", °ree); double C = 1; svmPtr = pPtr->FirstChildElement("C"); if(!svmPtr){ throw "Bad settings file - no C value"; } svmPtr->QueryDoubleAttribute("value", &C); svmParams.svm_type = svmType; svmParams.kernel_type = kernelType; svmParams.gamma = gamma; svmParams.degree = degree; svmParams.C = C; }
BOOL CSpecialZipCache::ReadCache() { std::string strInfoXmlPath; strInfoXmlPath = ZTools::FormatString("%s%s_%s\\info.xml", GetSpacialCacheBasePath().c_str(), m_strThisFileMd5.c_str(), m_strThisFileSize.c_str()); if (!PathFileExists(strInfoXmlPath.c_str())) { return FALSE; } TiXmlBase::SetCondenseWhiteSpace(false); TiXmlDocument doc; #ifdef TIXML_USE_STL doc.LoadFile(strInfoXmlPath, TIXML_ENCODING_UTF8); #else doc.LoadFile(strInfoXmlPath.c_str(), TIXML_ENCODING_UTF8); #endif // std::string m_strFileIdListJson; // std::string m_strMainFileId; // std::string m_strThisFileId; // std::string m_strThisFileMd5; TiXmlElement* rootElement = doc.RootElement(); if (rootElement == NULL) { return FALSE; } #ifdef TIXML_USE_STL rootElement->QueryStringAttribute("fileIdListJson", &m_strFileIdListJson); rootElement->QueryStringAttribute("mainFileId", &m_strMainFileId); //rootElement->QueryStringAttribute("thisFileId", &m_strThisFileId); rootElement->QueryStringAttribute("thisFileMd5", &m_strThisFileMd5); rootElement->QueryStringAttribute("componentFileName", &m_strComponentFileName); rootElement->QueryStringAttribute("componentFileId", &m_strComponentFileId); rootElement->QueryStringAttribute("componentManifest", &m_strComponentManifest); rootElement->QueryStringAttribute("formFileName", &m_strFormFileName); rootElement->QueryStringAttribute("formFileId", &m_strFormFileId); rootElement->QueryStringAttribute("formManifest", &m_strFormManifest); #else const char* pStrFileIdListJson = rootElement->Attribute("fileIdListJson"); if (pStrFileIdListJson != NULL) { m_strFileIdListJson = std::string(pStrFileIdListJson); } const char* pStrMainFileId = rootElement->Attribute("mainFileId"); if (pStrMainFileId != NULL) { m_strMainFileId = std::string(pStrMainFileId); } // const char* pStrThisFileId = rootElement->Attribute("thisFileId"); // if (pStrThisFileId != NULL) // { // m_strThisFileId = std::string(pStrThisFileId); // } const char* pStrThisFileMd5 = rootElement->Attribute("thisFileMd5"); if (pStrThisFileMd5 != NULL) { m_strThisFileMd5 = std::string(pStrThisFileMd5); } const char* pStrComponentFileName = rootElement->Attribute("componentFileName"); if (pStrComponentFileName != NULL) { m_strComponentFileName = std::string(pStrComponentFileName); } const char* pStrComponentFileId = rootElement->Attribute("componentFileId"); if (pStrComponentFileId != NULL) { m_strComponentFileId = std::string(pStrComponentFileId); } const char* pStrComponentManifest = rootElement->Attribute("componentManifest"); if (pStrComponentManifest != NULL) { m_strComponentManifest = std::string(pStrComponentManifest); } const char* pStrFormFileName = rootElement->Attribute("formFileName"); if (pStrFormFileName != NULL) { m_strFormFileName = std::string(pStrFormFileName); } const char* pStrFormFileId = rootElement->Attribute("formFileId"); if (pStrFormFileId != NULL) { m_strFormFileId = std::string(pStrFormFileId); } const char* pStrFormManifest = rootElement->Attribute("formManifest"); if (pStrFormManifest != NULL) { m_strFormManifest = std::string(pStrFormManifest); } #endif ZTools::UTF8ToMB(m_strFileIdListJson); ZTools::UTF8ToMB(m_strMainFileId); ZTools::UTF8ToMB(m_strThisFileMd5); ZTools::UTF8ToMB(m_strComponentFileName); ZTools::UTF8ToMB(m_strComponentFileId); ZTools::UTF8ToMB(m_strComponentManifest); ZTools::UTF8ToMB(m_strFormFileName); ZTools::UTF8ToMB(m_strFormFileId); ZTools::UTF8ToMB(m_strFormManifest); return TRUE; }
bool XmlSceneLoader::loadScene(std::string file, interface::Scene& scene, vector<ObjectLoaded>& objects) { TiXmlDocument doc(file); if(!doc.LoadFile()) return false; TiXmlElement* root=doc.FirstChildElement(); TiXmlElement* elem = root; // first parse meshasset std::map<int, vector<XmlMeshAssetLoader::MeshElementModel>> meshAssets; std::map<int, std::string> meshAssetsName; int nbObject=0; while(elem) { if(elem->ValueStr() == std::string("MeshAsset")) { int index=-1; elem->QueryIntAttribute("index", &index); std::string name; meshAssets[index] = interface::XmlMeshAssetLoader::parseMeshAssetElement(elem, name); meshAssetsName[index] = name; } else if(elem->ValueStr() == std::string("Object")) { nbObject++; } else if(elem->ValueStr() == std::string("DirLight")) { int shadow=0; vec3 color = {1,1,1}; vec3 dir={0,0,-1}; elem->QueryIntAttribute("shadows", &shadow); std::string strColor = StringUtils::str(elem->Attribute("color")); std::string strDir = StringUtils::str(elem->Attribute("direction")); if(!strColor.empty()) color = toVec<3>(strColor); if(!strDir.empty()) dir = toVec<3>(strDir); scene.globalLight.dirLights.push_back({dir, vec4(color,1), shadow==1}); } elem=elem->NextSiblingElement(); } elem = root; vector<std::string> skybox; while(elem) { if(elem->ValueStr() == std::string("Object")) { std::string name; elem->QueryStringAttribute("name", &name); int index=-1; elem->QueryIntAttribute("model", &index); if(index < 0 || meshAssets.find(index)==meshAssets.end()) { elem=elem->NextSiblingElement(); continue; } bool isStatic = true, isPhysic = true, isVisible = true; elem->QueryBoolAttribute("isStatic", &isStatic); elem->QueryBoolAttribute("isPhysic", &isPhysic); elem->QueryBoolAttribute("isVisible", &isVisible); vec3 tr, sc; mat3 rot; ObjectLoaded obj; parseTransformation(elem, tr, sc, rot, &obj.collider); obj.name = name; obj.model = meshAssetsName[index]; obj.type = ObjectLoaded::MESH_INSTANCE; obj.asset = meshAssets[index]; obj.isPhysic = isPhysic; obj.isStatic = isStatic; obj.isVisible = isVisible; obj.scale = sc; obj.translation = tr; obj.rotation = rot; if(isVisible) obj.meshInstance = &scene.scene.add<MeshInstance>(XmlMeshAssetLoader::constructMesh(meshAssets[index], Texture::genParam(true,true,true, 0), false), mat4::constructTransformation(rot, tr, sc)); else obj.meshInstance = nullptr; objects.push_back(obj); } else if(elem->ValueStr() == std::string("Skybox")) { skybox = parseSkyboxXmlElement(elem); } elem=elem->NextSiblingElement(); } if(skybox.size() == 6) { scene.globalLight.skybox = renderer::IndirectLightRenderer::loadAndProcessSkybox(skybox, ShaderPool::instance().get("processSpecularCubeMap")); } return true; }
void HierClassifier::loadSettings(TiXmlElement* settings){ if(settings->QueryIntAttribute("debug", &debugLevel) != TIXML_SUCCESS){ throw "Bad settings file - wrong debug level"; } TiXmlElement* pPtr; /*pPtr = settings->FirstChildElement("cache"); if(!pPtr){ throw "Bad settings file - no cache setting for HierClassifier"; } pPtr->QueryBoolAttribute("enabled", &cacheEnabled);*/ pPtr = settings->FirstChildElement("segmentation"); if(!pPtr){ throw "Bad settings file - no segmentation setting for HierClassifier"; } pPtr->QueryFloatAttribute("k", &kSegment); pPtr->QueryIntAttribute("min_size", &minSizeSegment); pPtr = settings->FirstChildElement("descriptor"); if(!pPtr){ throw "Bad settings file - no descriptor setting for HierClassifier"; } std::vector<int> descLen; TiXmlElement* dPtr = pPtr->FirstChildElement(); while(dPtr){ if(dPtr->Value() == string("hist_HS")){ dPtr->QueryIntAttribute("len_H", &histHLen); dPtr->QueryIntAttribute("len_S", &histSLen); if(descLen.size() < 1){ descLen.resize(1); } descLen[0] = histHLen*histSLen; } else if(dPtr->Value() == string("hist_V")){ dPtr->QueryIntAttribute("len", &histVLen); if(descLen.size() < 2){ descLen.resize(2); } descLen[1] = histVLen; } else if(dPtr->Value() == string("mean_HSV")){ dPtr->QueryIntAttribute("len", &meanHSVLen); if(descLen.size() < 3){ descLen.resize(3); } descLen[2] = meanHSVLen; } else if(dPtr->Value() == string("covar_HSV")){ dPtr->QueryIntAttribute("len", &covarHSVLen); if(descLen.size() < 4){ descLen.resize(4); } descLen[3] = covarHSVLen; } else if(dPtr->Value() == string("hist_DI")){ dPtr->QueryIntAttribute("len_D", &histDLen); dPtr->QueryIntAttribute("len_I", &histILen); if(descLen.size() < 5){ descLen.resize(5); } descLen[4] = histDLen*histILen; } else if(dPtr->Value() == string("mean_laser")){ dPtr->QueryIntAttribute("len", &meanLaserLen); if(descLen.size() < 6){ descLen.resize(6); } descLen[5] = meanLaserLen; } else if(dPtr->Value() == string("covar_laser")){ dPtr->QueryIntAttribute("len", &covarLaserLen); if(descLen.size() < 7){ descLen.resize(7); } descLen[6] = covarLaserLen; } //else if(dPtr->Value() == string("kurt_laser")){ // dPtr->QueryIntAttribute("len", &kurtLaserLen); // if(descLen.size() < 7){ // descLen.resize(7); // } // descLen[6] = kurtLaserLen; //} else{ throw "Bad settings file - no such descriptor"; } dPtr = dPtr->NextSiblingElement(); } descBeg.assign(descLen.size(), 0); for(int d = 1; d < descLen.size(); d++){ descBeg[d] = descBeg[d - 1] + descLen[d - 1]; } descBeg.push_back(descBeg.back() + descLen.back()); for(int c = 0; c < weakClassifiersSet.size(); c++){ delete weakClassifiersSet[c]; } weakClassifiersSet.clear(); weakClassInfo.clear(); numWeakClassifiers = 0; TiXmlElement* cPtr = settings->FirstChildElement("Classifier"); while(cPtr){ string type; cPtr->QueryStringAttribute("type", &type); if(type == "SVM"){ weakClassifiersSet.push_back(new ClassifierSVM(cPtr)); TiXmlElement* iPtr = cPtr->FirstChildElement("info"); if(!iPtr){ throw "Bad settings file - no info setting for Classifier type = SVM"; } int dBeg, dEnd; iPtr->QueryIntAttribute("desc_beg", &dBeg); iPtr->QueryIntAttribute("desc_end", &dEnd); weakClassInfo.push_back(WeakClassifierInfo(descBeg[dBeg], descBeg[dEnd])); } else if(type == "RF"){ weakClassifiersSet.push_back(new ClassifierRF(cPtr)); TiXmlElement* iPtr = cPtr->FirstChildElement("info"); if(!iPtr){ throw "Bad settings file - no info setting for Classifier type = RF"; } int dBeg, dEnd; iPtr->QueryIntAttribute("desc_beg", &dBeg); iPtr->QueryIntAttribute("desc_end", &dEnd); weakClassInfo.push_back(WeakClassifierInfo(descBeg[dBeg], descBeg[dEnd])); } numWeakClassifiers++; cPtr = cPtr->NextSiblingElement("Classifier"); } numIterations = 1; }
Graphe::Graphe(QString &filename){ n=0; int i, j, x, y; TiXmlDocument doc(filename.toStdString()); if(doc.LoadFile()){ //TiXmlHandle hDoc(&doc); TiXmlElement * pGraph; pGraph = doc.FirstChildElement("Graph"); if(pGraph){ pGraph->QueryIntAttribute("n", &n); if(pGraph->Attribute("Title")) title = QString(pGraph->Attribute("Title")); if(pGraph->Attribute("Color")){ if(pGraph->Attribute("Color")[0] == 'r') color_r = 200; if(pGraph->Attribute("Color")[0] == 'b') color_b = 200; } noeuds = new Noeud[n]; labels = new QString[n]; //Init for(int i=0; i<n; i++) labels[i]=QString(); for(int i=0; i<n; i++){ noeuds[i] = Noeud(50 + 40*cos(2*3.14159/n*i), 50 + 40*sin(2*3.14159/n*i)); } adj = new float*[n]; for(int i=0; i<n; i++){ adj[i] = new float [n]; for(int j=0; j<n; j++){ adj[i][j]=0.; } } TiXmlElement * pRoot; TiXmlElement * pChildren; std::string temps; pRoot = pGraph->FirstChildElement("Nodes"); if(pRoot){ pChildren = pRoot->FirstChildElement("Node"); while(pChildren){ pChildren->QueryIntAttribute("id", &i); pChildren->QueryIntAttribute("x", &x); pChildren->QueryIntAttribute("y", &y); noeuds[i]= Noeud(x,y); if(pChildren->QueryStringAttribute("Label", &temps) == TIXML_SUCCESS) labels[i]= QString(temps.c_str()); pChildren = pChildren->NextSiblingElement("Node"); } } pRoot = pGraph->FirstChildElement("Arrows"); if(pRoot){ pChildren = pRoot->FirstChildElement("Arrow"); while(pChildren){ pChildren->QueryIntAttribute("From", &i); pChildren->QueryIntAttribute("To", &j); setlocale(LC_NUMERIC, "C"); if(pChildren) adj[i][j] = std::atof(pChildren->Attribute("Value")); //qDebug() << i << j << pChildren->Attribute("Value"); pChildren = pChildren->NextSiblingElement("Arrow"); } } this->findMaxadj(); pRoot = pGraph ->FirstChildElement("Config"); if(pRoot){ pChildren = pRoot; setlocale(LC_NUMERIC, "C"); if(pChildren->Attribute("ScaleMax")) maxadj=std::atof(pChildren->Attribute("ScaleMax")); } } } }
std::vector<itk::SmartPointer<BaseData> > ConnectomicsNetworkReader::Read() { std::vector<itk::SmartPointer<mitk::BaseData> > result; std::string location = GetInputLocation(); std::string ext = itksys::SystemTools::GetFilenameLastExtension(location); ext = itksys::SystemTools::LowerCase(ext); if ( location == "") { MITK_ERROR << "No file name specified."; } else if (ext == ".cnf") { try { mitk::ConnectomicsNetwork::Pointer outputNetwork = mitk::ConnectomicsNetwork::New(); TiXmlDocument doc( location ); bool loadOkay = doc.LoadFile(); if(!loadOkay) { mitkThrow() << "Could not open file " << location << " for reading."; } TiXmlHandle hDoc(&doc); TiXmlElement* pElem; TiXmlHandle hRoot(0); pElem = hDoc.FirstChildElement().Element(); // save this for later hRoot = TiXmlHandle(pElem); pElem = hRoot.FirstChildElement(mitk::ConnectomicsNetworkDefinitions::XML_GEOMETRY).Element(); // read geometry mitk::Geometry3D::Pointer geometry = mitk::Geometry3D::New(); // read origin mitk::Point3D origin; double temp = 0; pElem->Attribute(mitk::ConnectomicsNetworkDefinitions::XML_ORIGIN_X, &temp); origin[0] = temp; pElem->Attribute(mitk::ConnectomicsNetworkDefinitions::XML_ORIGIN_Y, &temp); origin[1] = temp; pElem->Attribute(mitk::ConnectomicsNetworkDefinitions::XML_ORIGIN_Z, &temp); origin[2] = temp; geometry->SetOrigin(origin); // read spacing ScalarType spacing[3]; pElem->Attribute(mitk::ConnectomicsNetworkDefinitions::XML_SPACING_X, &temp); spacing[0] = temp; pElem->Attribute(mitk::ConnectomicsNetworkDefinitions::XML_SPACING_Y, &temp); spacing[1] = temp; pElem->Attribute(mitk::ConnectomicsNetworkDefinitions::XML_SPACING_Z, &temp); spacing[2] = temp; geometry->SetSpacing(spacing); // read transform vtkMatrix4x4* m = vtkMatrix4x4::New(); pElem->Attribute(mitk::ConnectomicsNetworkDefinitions::XML_MATRIX_XX, &temp); m->SetElement(0,0,temp); pElem->Attribute(mitk::ConnectomicsNetworkDefinitions::XML_MATRIX_XY, &temp); m->SetElement(1,0,temp); pElem->Attribute(mitk::ConnectomicsNetworkDefinitions::XML_MATRIX_XZ, &temp); m->SetElement(2,0,temp); pElem->Attribute(mitk::ConnectomicsNetworkDefinitions::XML_MATRIX_YX, &temp); m->SetElement(0,1,temp); pElem->Attribute(mitk::ConnectomicsNetworkDefinitions::XML_MATRIX_YY, &temp); m->SetElement(1,1,temp); pElem->Attribute(mitk::ConnectomicsNetworkDefinitions::XML_MATRIX_YZ, &temp); m->SetElement(2,1,temp); pElem->Attribute(mitk::ConnectomicsNetworkDefinitions::XML_MATRIX_ZX, &temp); m->SetElement(0,2,temp); pElem->Attribute(mitk::ConnectomicsNetworkDefinitions::XML_MATRIX_ZY, &temp); m->SetElement(1,2,temp); pElem->Attribute(mitk::ConnectomicsNetworkDefinitions::XML_MATRIX_ZZ, &temp); m->SetElement(2,2,temp); m->SetElement(0,3,origin[0]); m->SetElement(1,3,origin[1]); m->SetElement(2,3,origin[2]); m->SetElement(3,3,1); geometry->SetIndexToWorldTransformByVtkMatrix(m); geometry->SetImageGeometry(true); outputNetwork->SetGeometry(geometry); // read network std::map< int, mitk::ConnectomicsNetwork::VertexDescriptorType > idToVertexMap; // read vertices pElem = hRoot.FirstChildElement(mitk::ConnectomicsNetworkDefinitions::XML_VERTICES).Element(); { // walk through the vertices TiXmlElement* vertexElement = pElem->FirstChildElement(); for( ; vertexElement; vertexElement=vertexElement->NextSiblingElement()) { std::vector< float > pos; std::string label; int vertexID(0); vertexElement->Attribute(mitk::ConnectomicsNetworkDefinitions::XML_VERTEX_X, &temp); pos.push_back(temp); vertexElement->Attribute(mitk::ConnectomicsNetworkDefinitions::XML_VERTEX_Y, &temp); pos.push_back(temp); vertexElement->Attribute(mitk::ConnectomicsNetworkDefinitions::XML_VERTEX_Z, &temp); pos.push_back(temp); vertexElement->Attribute(mitk::ConnectomicsNetworkDefinitions::XML_VERTEX_ID, &vertexID); vertexElement->QueryStringAttribute(mitk::ConnectomicsNetworkDefinitions::XML_VERTEX_LABEL, &label); mitk::ConnectomicsNetwork::VertexDescriptorType newVertex = outputNetwork->AddVertex( vertexID ); outputNetwork->SetLabel( newVertex, label ); outputNetwork->SetCoordinates( newVertex, pos ); if ( idToVertexMap.count( vertexID ) > 0 ) { MITK_ERROR << "Aborting network creation, duplicate vertex ID in file."; return result; } idToVertexMap.insert( std::pair< int, mitk::ConnectomicsNetwork::VertexDescriptorType >( vertexID, newVertex) ); } } // read edges pElem = hRoot.FirstChildElement(mitk::ConnectomicsNetworkDefinitions::XML_EDGES).Element(); { // walk through the edges TiXmlElement* edgeElement = pElem->FirstChildElement(); for( ; edgeElement; edgeElement=edgeElement->NextSiblingElement()) { int edgeID(0), edgeSourceID(0), edgeTargetID(0), edgeWeight(0); edgeElement->Attribute(mitk::ConnectomicsNetworkDefinitions::XML_EDGE_ID, &edgeID); edgeElement->Attribute(mitk::ConnectomicsNetworkDefinitions::XML_EDGE_SOURCE_ID, &edgeSourceID); edgeElement->Attribute(mitk::ConnectomicsNetworkDefinitions::XML_EDGE_TARGET_ID, &edgeTargetID); edgeElement->Attribute(mitk::ConnectomicsNetworkDefinitions::XML_EDGE_WEIGHT_ID, &edgeWeight); mitk::ConnectomicsNetwork::VertexDescriptorType source = idToVertexMap.find( edgeSourceID )->second; mitk::ConnectomicsNetwork::VertexDescriptorType target = idToVertexMap.find( edgeTargetID )->second; outputNetwork->AddEdge( source, target, edgeSourceID, edgeTargetID, edgeWeight); } } outputNetwork->UpdateBounds(); result.push_back(outputNetwork.GetPointer()); MITK_INFO << "Network read"; } catch (mitk::Exception e) { MITK_ERROR << e.GetDescription(); } catch(...) { MITK_ERROR << "Unknown error occured while trying to read file."; } } return result; }