//-------------------------------------------------------------------------------------------------- /// Create a new PropertySet from the specified XML element /// /// The XML element passed as a parameter is assumed to be a PropertySet element //-------------------------------------------------------------------------------------------------- ref<PropertySet> PropertyXmlSerializer::createPropertySetFromXmlElement(const XmlElement& xmlPropertySetElement) { CVF_ASSERT(xmlPropertySetElement.name() == "PropertySet"); String propSetClassType = xmlPropertySetElement.getAttributeString("classType"); ref<PropertySet> ps = new PropertySet(propSetClassType); const XmlElement* xmlElem = xmlPropertySetElement.firstChildElement(); while (xmlElem) { Variant variant = variantFromXmlElement(*xmlElem); if (variant.isValid()) { String key = xmlElem->getAttributeString("key"); if (!key.isEmpty()) { ps->setValue(key, variant); } } xmlElem = xmlElem->nextSiblingElement(); } return ps; }
//-------------------------------------------------------------------------------------------------- /// Populate the PropertySet from the specified XML element /// /// The XML element passed as a parameter is assumed to be a PropertySet element //-------------------------------------------------------------------------------------------------- void PropertyXmlSerializer::toPropertySetCollection(const XmlElement& xmlPropertySetCollectionElement, PropertySetCollection* propertySetCollection) { CVF_ASSERT(xmlPropertySetCollectionElement.name() == "PropertySetCollection"); CVF_ASSERT(propertySetCollection); const XmlElement* xmlElem = xmlPropertySetCollectionElement.firstChildElement("PropertySet"); while (xmlElem) { ref<PropertySet> ps = createPropertySetFromXmlElement(*xmlElem); propertySetCollection->addPropertySet(ps.p()); xmlElem = xmlElem->nextSiblingElement("PropertySet"); } }
//-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- cvf::Variant PropertyXmlSerializer::arrayVariantFromXmlElement(const XmlElement& xmlArrayVariantElement) { CVF_ASSERT(xmlArrayVariantElement.name().toLower() == "array"); std::vector<Variant> arr; const XmlElement* xmlElem = xmlArrayVariantElement.firstChildElement(); while (xmlElem) { Variant variant = variantFromXmlElement(*xmlElem); if (variant.isValid()) { arr.push_back(variant); } xmlElem = xmlElem->nextSiblingElement(); } return Variant(arr); }
//-------------------------------------------------------------------------------------------------- /// Create variant from the specified XML element /// /// If the passed XML element is not recognized as a variant, an invalid variant will be returned //-------------------------------------------------------------------------------------------------- cvf::Variant PropertyXmlSerializer::variantFromXmlElement(const XmlElement& xmlVariantElement) { const String elementName = xmlVariantElement.name().toLower(); const String valueText = xmlVariantElement.valueText(); if (elementName == "int") { bool ok = false; int val = valueText.toInt(&ok); if (ok) { return Variant(val); } } else if (elementName == "uint") { bool ok = false; uint val = valueText.toUInt(&ok); if (ok) { return Variant(val); } } else if (elementName == "double") { bool ok = false; double val = valueText.toDouble(&ok); if (ok) { return Variant(val); } } else if (elementName == "float") { bool ok = false; float val = valueText.toFloat(&ok); if (ok) { return Variant(val); } } else if (elementName == "bool") { String valStr = valueText.toLower(); bool val = (valStr == "true") ? true : false; return Variant(val); } else if (elementName == "vec3d") { return variantFromVec3dValueText(valueText); } else if (elementName == "color3f") { return variantFromColor3fValueText(valueText); } else if (elementName == "string") { return Variant(valueText); } else if (elementName == "array") { return arrayVariantFromXmlElement(xmlVariantElement); } return Variant(); }
void FlowData::load() { if(!mReady) { Timer timer(true); XmlDocument * pointsDoc = new XmlDocument(dataSource); XmlElement rootNode = pointsDoc->rootNode(); if(rootNode.hasChildren()) { XmlElement tagNode = rootNode.findChild("tag"); XmlElement drawingNode = tagNode.findChild("drawing"); // Now get all the drawingNode's children.. and only worry about the stroke nodes. if(drawingNode.hasChildren()) { std::vector<XmlElement> strokeNodes = drawingNode.children(); // std::vector<XmlElement> strokeNodes = rootNode.xpath("//tag/drawing//stroke"); if(strokeNodes.size() > 0) { int totalPoints = 0; // Now declare some variables to reuse in our loop. FlowPoint lastPt(Vec2f::zero(), Vec2f::zero(), -1.f); for(std::vector<XmlElement>::iterator it = strokeNodes.begin(); it < strokeNodes.end(); it++) { XmlElement strokeNode = *it; if(strokeNode.name() == "stroke") { // Get all the point nodes. std::vector<XmlElement> pointNodes = strokeNode.children(); // Create a new stroke std::vector<FlowPoint> * stroke = new std::vector<FlowPoint>; for(std::vector<XmlElement>::iterator it2 = pointNodes.begin(); it2 < pointNodes.end(); it2++) { XmlElement ptNode = *it2; if(ptNode.name() == "pt") { std::string xVal = ptNode.findChild("x").value(); // float x = fromString( xVal ); float x = boost::lexical_cast<float>( xVal ); std::string yVal = ptNode.findChild("y").value(); // float y = fromString( yVal ); float y = boost::lexical_cast<float>( yVal ); std::string timeVal = ptNode.findChild("time").value(); // float time = fromString( timeVal ); float time = boost::lexical_cast<float>( timeVal ); x = mRemapMinX + (mRemapMaxX - mRemapMinX) * x; y = mRemapMinY + (mRemapMaxY - mRemapMinY) * y; Vec2f pos(x, y); Vec2f vel; if(lastPt.time > -1) { vel.x = pos.x - lastPt.getX(); vel.y = pos.y - lastPt.getY(); } FlowPoint pt(pos, vel, time); bool shouldAddPoint = false; if(ignoreRedundantPositions == true) { if(lastPt.time > -1) { if(pt.getX() != lastPt.getX() && pt.getY() != lastPt.getY()) { shouldAddPoint = true; } } else { shouldAddPoint = true; } } else { shouldAddPoint = true; } if(shouldAddPoint) { totalPoints++; stroke->push_back(pt); lastPt = FlowPoint(pt.pos, pt.vel, pt.time); } } } // Now see if our stroke is long enough. if(stroke->size() > minNumberOfPointsInStroke) { mStrokes.push_back(stroke); } } } // We're done. timer.stop(); std::cout << "FlowData :: GML file parsing complete. Elapsed seconds: " << toString( timer.getSeconds() ) << std::endl; std::cout << "FlowData :: Total number of points: " << totalPoints << std::endl; std::cout << "FlowData :: Number of strokes: " << mStrokes.size() << std::endl; if(mStrokes.size() > 0) mReady = true; } } } } }