Ejemplo n.º 1
0
void XMLDocument::addPhysicalOffsetFrame(SimTK::Xml::Element& element,
    const std::string& frameName,
    const std::string& parentFrameName, 
    const SimTK::Vec3& location, const SimTK::Vec3& orientation)
{
    SimTK::Xml::element_iterator  frames_node = element.element_begin("frames");
    //SimTK::String debug; //Only used for debugging
    
    if (frames_node == element.element_end()) {
        SimTK::Xml::Element framesElement("frames");
        element.insertNodeBefore(element.element_begin(), framesElement);
        frames_node = element.element_begin("frames");
    }
    // Here we're guaranteed frames node exists, add individual frame
    SimTK::Xml::Element newFrameElement("PhysicalOffsetFrame");
    newFrameElement.setAttributeValue("name", frameName);
    //newFrameElement.writeToString(debug);

    XMLDocument::addConnector(newFrameElement, "Connector_PhysicalFrame_", "parent", parentFrameName);

    std::ostringstream transValue;
    transValue << location[0] << " " << location[1] << " " << location[2];
    SimTK::Xml::Element translationElement("translation", transValue.str());
    newFrameElement.insertNodeAfter(newFrameElement.element_end(), translationElement);

    std::ostringstream orientValue; 
    orientValue << orientation[0] << " " << orientation[1] << " " << orientation[2];
    SimTK::Xml::Element orientationElement("orientation", orientValue.str());
    newFrameElement.insertNodeAfter(newFrameElement.element_end(), orientationElement);

    frames_node->insertNodeAfter(frames_node->element_end(), newFrameElement);
    //frames_node->writeToString(debug);
}
Ejemplo n.º 2
0
void Body::updateFromXMLNode(SimTK::Xml::Element& aNode, int versionNumber)
{
    if (versionNumber < XMLDocument::getLatestVersion()) {
        if (versionNumber < 30500) {
            SimTK::Vec6 newInertia(1.0, 1.0, 1.0, 0., 0., 0.);
            std::string inertiaComponents[] = { "inertia_xx", "inertia_yy", "inertia_zz", "inertia_xy", "inertia_xz", "inertia_yz" };
            for (int i = 0; i < 6; ++i) {
                SimTK::Xml::element_iterator iIter = aNode.element_begin(inertiaComponents[i]);
                if (iIter != aNode.element_end()) {
                    newInertia[i] = iIter->getValueAs<double>();
                    aNode.removeNode(iIter);
                }
            }
            std::ostringstream strs;
            for (int i = 0; i < 6; ++i) {
                strs << newInertia[i];
                if (i < 5) strs << " ";
            }
            std::string strInertia = strs.str();
            SimTK::Xml::Element inertiaNode("inertia", strInertia);
            aNode.insertNodeAfter(aNode.element_end(), inertiaNode);
        }
    }
    Super::updateFromXMLNode(aNode, versionNumber);
}
Ejemplo n.º 3
0
/*static*/ 
void  XMLDocument::renameChildNode(SimTK::Xml::Element& aNode, std::string oldElementName, std::string newElementName)
{
    Xml::element_iterator elmtIter(aNode.element_begin(oldElementName));
    if (elmtIter!=aNode.element_end()){
        elmtIter->setElementTag(newElementName);
    }
}
Ejemplo n.º 4
0
/*virtual*/
void Marker::updateFromXMLNode(SimTK::Xml::Element& aNode, int versionNumber)
{

    if (versionNumber < XMLDocument::getLatestVersion()){
        if (versionNumber < 30501) {
            // Parse name of Body under <body>node
            SimTK::Xml::element_iterator bIter = aNode.element_begin("body");
            SimTK::String bName = bIter->getValue();
            // Create nodes for new layout
            SimTK::Xml::Element connectorsElement("connectors");
            SimTK::Xml::Element frameElement("Connector_PhysicalFrame_");
            connectorsElement.insertNodeAfter(connectorsElement.node_end(), frameElement);
            frameElement.setAttributeValue("name", "parent_frame");
            SimTK::Xml::Element connecteeElement("connectee_name");
            // Markers in pre-4.0 models are necessarily 1 level deep
            // (model, markers), and Bodies were necessarily 1 level deep;
            // here we create the correct relative path (accounting for sets
            // being components).
            bName = XMLDocument::updateConnecteePath30517("bodyset", bName);
            connecteeElement.setValue(bName);
            frameElement.insertNodeAfter(frameElement.node_end(), connecteeElement);
            aNode.insertNodeAfter(bIter, connectorsElement);
            aNode.eraseNode(bIter);
        }
    }
    // Call base class now assuming _node has been corrected for current version
    Super::updateFromXMLNode(aNode, versionNumber);
}
void PointToPointSpring::updateFromXMLNode(SimTK::Xml::Element& aNode, int versionNumber)
{
    int documentVersion = versionNumber;
    if (documentVersion < XMLDocument::getLatestVersion()) {
        if (documentVersion<30500) {
            // replace old properties with latest use of Connectors
            SimTK::Xml::element_iterator body1Element = aNode.element_begin("body1");
            SimTK::Xml::element_iterator body2Element = aNode.element_begin("body2");
            std::string body1_name(""), body2_name("");
            // If default constructed then elements not serialized since they
            // are default values. Check that we have associated elements, then
            // extract their values.
            // Forces in pre-4.0 models are necessarily 1 level deep
            // Bodies are also necessarily 1 level deep.
            // Here we create the correct relative path (accounting for sets
            // being components).
            if (body1Element != aNode.element_end()) {
                body1Element->getValueAs<std::string>(body1_name);
                body1_name = XMLDocument::updateConnecteePath30517("bodyset",
                                                                   body1_name);
            }
            if (body2Element != aNode.element_end()) {
                body2Element->getValueAs<std::string>(body2_name);
                body2_name = XMLDocument::updateConnecteePath30517("bodyset",
                                                                   body2_name);
            }
            XMLDocument::addConnector(aNode, "Connector_PhysicalFrame_",
                "body1", body1_name);
            XMLDocument::addConnector(aNode, "Connector_PhysicalFrame_",
                "body2", body2_name);
        }
    }

    Super::updateFromXMLNode(aNode, versionNumber);
}
// Handle conversion from older format
void VisibleObject::updateFromXMLNode(SimTK::Xml::Element& aNode, int versionNumber)
{ 
    SimTK::Array_<SimTK::String> oldGeometryFiles;
	if ( versionNumber < XMLDocument::getLatestVersion()){
		if (versionNumber<20101){
			SimTK::Xml::element_iterator visPropIter = aNode.element_begin("VisibleProperties");
			// Get geometry files and Preferences if any and set them into 
			if (visPropIter!=aNode.element_end()){
				// Move display_prference, and show_axes nodes up to VisibleObject
				SimTK::Xml::element_iterator  prefIter = visPropIter->element_begin("display_preference");
				if (prefIter!= visPropIter->element_end()){
					SimTK::Xml::Node moveNode = visPropIter->removeNode(prefIter);
					aNode.insertNodeAfter(aNode.element_end(), moveNode);
				}
				SimTK::Xml::element_iterator  showAxesIter = visPropIter->element_begin("show_axes");
				if (showAxesIter!=aNode.element_end()){
					SimTK::Xml::Node moveNode = visPropIter->removeNode(showAxesIter);
					aNode.insertNodeAfter(aNode.element_end(), moveNode);
				}
			}
			SimTK::Xml::element_iterator geometryIter = aNode.element_begin("geometry_files");
			string propValue="";
			bool hasPieces=false;
			if (geometryIter!= aNode.element_end()){
				geometryIter->getValueAs(oldGeometryFiles);
			}
        }
    }
	Object::updateFromXMLNode(aNode, versionNumber);
    if (oldGeometryFiles.size()>0){
        for(unsigned i=0; i< oldGeometryFiles.size(); i++) 
            setGeometryFileName(i, oldGeometryFiles[i]);
    }
}
Ejemplo n.º 7
0
void ModelComponent::updateFromXMLNode(SimTK::Xml::Element& aNode,
        int versionNumber) {

    if (versionNumber < XMLDocument::getLatestVersion()) {
        if (versionNumber < 30506) {
            // geometry list property removed. Everything that was in this list
            // should be moved to the components list property.
            SimTK::Xml::element_iterator geometry = aNode.element_begin("geometry");
            if (geometry != aNode.element_end()) {
                // We found a list property of geometry.
                SimTK::Xml::Element componentsNode;
                SimTK::Xml::element_iterator componentsIt = aNode.element_begin("components");
                if (componentsIt == aNode.element_end()) {
                    // This component does not yet have a list property of
                    // components, so we'll create one.
                    componentsNode = SimTK::Xml::Element("components");
                    aNode.insertNodeBefore(aNode.element_begin(), componentsNode);
                } else {
                    componentsNode = *componentsIt;
                }
                // Copy each node under <geometry> into <components>.
                for (auto geomIt = geometry->element_begin();
                        geomIt != geometry->element_end(); ++geomIt) {
                    componentsNode.appendNode(geomIt->clone());
                }
                // Now that we moved over the geometry, we can delete the
                // <geometry> element.
                aNode.eraseNode(geometry);
            }
        }
    }
    Super::updateFromXMLNode(aNode, versionNumber);
}
Ejemplo n.º 8
0
void XMLDocument::writeDefaultObjects(SimTK::Xml::Element& elmt)
{
    if (_defaultObjects.getSize()==0) return;
    // Make node for "defaults"
    SimTK::Xml::Element defaultsElement("defaults");
    
    elmt.insertNodeAfter(elmt.node_end(), defaultsElement);
    for(int i=0; i < _defaultObjects.getSize(); i++){
        _defaultObjects.get(i)->updateXMLNode(defaultsElement);
    }
}
Ejemplo n.º 9
0
void ContactGeometry::updateFromXMLNode(SimTK::Xml::Element& node,
                                        int versionNumber) {
    if (versionNumber < XMLDocument::getLatestVersion()) {
        if (versionNumber < 30505) {
            SimTK::Xml::element_iterator bodyElement =
                node.element_begin("body_name");
            std::string body_name("");
            // Element may not exist if body_name property had default value.
            if (bodyElement != node.element_end()) {
                bodyElement->getValueAs<std::string>(body_name);
            }
            XMLDocument::addConnector(node, "Connector_PhysicalFrame_",
                    "frame", body_name);
        }
    }
    Super::updateFromXMLNode(node, versionNumber);
}
Ejemplo n.º 10
0
void PathPoint::updateFromXMLNode(SimTK::Xml::Element& aNode, int versionNumber)
{
    int documentVersion = versionNumber;
    if (documentVersion < XMLDocument::getLatestVersion()) {
        if (documentVersion < 30505) {
            // replace old properties with latest use of Connectors
            SimTK::Xml::element_iterator bodyElement = aNode.element_begin("body");
            std::string bodyName("");
            if (bodyElement != aNode.element_end()) {
                bodyElement->getValueAs<std::string>(bodyName);
                XMLDocument::addConnector(aNode, "Connector_PhysicalFrame_",
                    "parent_frame", bodyName);
            }
        }
    }

    Super::updateFromXMLNode(aNode, versionNumber);
}
Ejemplo n.º 11
0
/**
 * Override default implementation by object to intercept and fix the XML node
 * underneath the tool to match current version
 */
/*virtual*/ void ForwardTool::updateFromXMLNode(SimTK::Xml::Element& aNode, int versionNumber)
{
    int documentVersion = versionNumber;
    bool neededSprings=false;
    std::string savedCwd;
    if(getDocument()) {
        savedCwd = IO::getCwd();
        IO::chDir(IO::getParentDirectory(getDocument()->getFileName()));
    }   
    if ( documentVersion < XMLDocument::getLatestVersion()){
            // Now check if we need to create a correction controller to replace springs
        if (documentVersion<10904){
            std::string propNames[]={
                "body1_linear_corrective_spring_active",
                "body1_torsional_corrective_spring_active",
                "body2_linear_corrective_spring_active",
                "body2_torsional_corrective_spring_active"
            };
            int i=0;
            while (!neededSprings && i<4){
                neededSprings = (aNode.element_begin(propNames[i++])!=aNode.element_end());
            }
            AbstractTool::updateFromXMLNode(aNode, versionNumber);
            if (neededSprings){
                CorrectionController* cc = new CorrectionController();
                cc->setKp(16.0);
                cc->setKv(8.0);
                _controllerSet.adoptAndAppend(cc);
                _parsingLog+= "This setup file contains corrective springs.\n";
                _parsingLog+= "Corrective springs are deprecated in OpenSim 2.0\n";
                _parsingLog+= "Instead, a Corrective Controller has been created.\n";

            }
        }
        else
            AbstractTool::updateFromXMLNode(aNode, versionNumber);
    }
    else
        AbstractTool::updateFromXMLNode(aNode, versionNumber);
    if(getDocument()) IO::chDir(savedCwd);
    //Object::updateFromXMLNode(aNode, versionNumber);
}
Ejemplo n.º 12
0
/*
 * Helper function to add connector to the xmlElement passed in
 */
void XMLDocument::addConnector(SimTK::Xml::Element& element, const std::string& connectorTag, const std::string& connectorName, const std::string& connectorValue)
{
    SimTK::Xml::element_iterator  connectors_node =  element.element_begin("connectors");
    SimTK::String debug;
    if (connectors_node == element.element_end()){
        SimTK::Xml::Element connectorsElement("connectors");
        element.insertNodeBefore(element.element_begin(), connectorsElement);
        connectors_node =  element.element_begin("connectors");
    }
    // Here we're guaranteed connectors node exist, add individual connector
    SimTK::Xml::Element newConnectorElement(connectorTag);
    newConnectorElement.setAttributeValue("name", connectorName);
    newConnectorElement.writeToString(debug);
    SimTK::Xml::Element connecteeElement("connectee_name");
    connecteeElement.insertNodeAfter(connecteeElement.element_end(), SimTK::Xml::Text(connectorValue));
    // Insert text under newConnectorElement
    newConnectorElement.insertNodeAfter(newConnectorElement.element_end(), connecteeElement);
    connectors_node->insertNodeAfter(connectors_node->element_end(), newConnectorElement);
    connectors_node->writeToString(debug);
}
void ConstantDistanceConstraint::updateFromXMLNode(SimTK::Xml::Element& aNode, int versionNumber)
{
    int documentVersion = versionNumber;
    if (documentVersion < XMLDocument::getLatestVersion()){
        if (documentVersion<30500){
            // replace old properties with latest use of Connectors
            SimTK::Xml::element_iterator body1Element = aNode.element_begin("body_1");
            SimTK::Xml::element_iterator body2Element = aNode.element_begin("body_2");
            std::string body1_name(""), body2_name("");
            // If default constructed then elements not serialized since they are default
            // values. Check that we have associated elements, then extract their values.
            if (body1Element != aNode.element_end())
                body1Element->getValueAs<std::string>(body1_name);
            if (body2Element != aNode.element_end())
                body2Element->getValueAs<std::string>(body2_name);
            XMLDocument::addConnector(aNode, "Connector_PhysicalFrame_", "body_1", body1_name);
            XMLDocument::addConnector(aNode, "Connector_PhysicalFrame_", "body_2", body2_name);
        }
    }

    Super::updateFromXMLNode(aNode, versionNumber);
}// Visual support ConstantDistanceConstraint drawing in SimTK visualizer.
Ejemplo n.º 14
0
void Controller::updateFromXMLNode(SimTK::Xml::Element& node,
                                   int versionNumber) {
    if(versionNumber < XMLDocument::getLatestVersion()) {
        if(versionNumber < 30509) {
            // Rename property 'isDisabled' to 'enabled' and
            // negate the contained value.
            std::string oldName{"isDisabled"};
            std::string newName{"enabled"};
            if(node.hasElement(oldName)) {
                auto elem = node.getRequiredElement(oldName);
                bool isDisabled = false;
                elem.getValue().tryConvertToBool(isDisabled);

                // now update tag name to 'enabled'
                elem.setElementTag(newName);
                // update its value to be the opposite of 'isDisabled'
                elem.setValue(SimTK::String(!isDisabled));
            }
        }
    }

    Super::updateFromXMLNode(node, versionNumber);
}
Ejemplo n.º 15
0
/*virtual*/
void Marker::updateFromXMLNode(SimTK::Xml::Element& aNode, int versionNumber)
{

    if (versionNumber < XMLDocument::getLatestVersion()){
        if (versionNumber < 30501) {
            // Parse name of Body under <body>node
            SimTK::Xml::element_iterator bIter = aNode.element_begin("body");
            SimTK::String bName = bIter->getValue();
            // Create nodes for new layout
            SimTK::Xml::Element connectorsElement("connectors");
            SimTK::Xml::Element frameElement("Connector_PhysicalFrame_");
            connectorsElement.insertNodeAfter(connectorsElement.node_end(), frameElement);
            frameElement.setAttributeValue("name", "reference_frame");
            SimTK::Xml::Element connecteeElement("connectee_name");
            connecteeElement.setValue(bName);
            frameElement.insertNodeAfter(frameElement.node_end(), connecteeElement);
            aNode.insertNodeAfter(bIter, connectorsElement);
            aNode.eraseNode(bIter);
        }
    }
    // Call base class now assuming _node has been corrected for current version
    Object::updateFromXMLNode(aNode, versionNumber);
}
/**
 * Update this object based on its XML node.
 */
void PrescribedForce::updateFromXMLNode(SimTK::Xml::Element& aNode, int versionNumber)
{
    // Base class
    // This test for veversion number needs to change when we have a new version number otherwise 
    // subsequent versions will continue to trigger the conversion below. -Ayman 4/16
    if (versionNumber != 30505) { 
        // Convert body property into a connector to PhysicalFrame with name "frame"
        SimTK::Xml::element_iterator bodyElement = aNode.element_begin("body");
        std::string frame_name("");
        if (bodyElement != aNode.element_end()) {
            bodyElement->getValueAs<std::string>(frame_name);
            XMLDocument::addConnector(aNode, "Connector_PhysicalFrame_", "frame", frame_name);
        }
    }
    Super::updateFromXMLNode(aNode, versionNumber);

    const FunctionSet& forceFunctions  = getForceFunctions();
    const FunctionSet& pointFunctions  = getPointFunctions();
    const FunctionSet& torqueFunctions = getTorqueFunctions();

    //Specify all or none of the components
    if(forceFunctions.getSize() != 3 && forceFunctions.getSize() != 0)
    {
        throw Exception("PrescribedForce:: three components of the force must be specified.");
    }

    if(pointFunctions.getSize() != 3 && pointFunctions.getSize() != 0)
    {
        throw Exception("PrescribedForce:: three components of the point must be specified.");
    }

    if(torqueFunctions.getSize() != 3 && torqueFunctions.getSize() != 0)
    {
        throw Exception("PrescribedForce:: three components of the torque must be specified.");
    }
}   
Ejemplo n.º 17
0
/** Override of the default implementation to account for versioning. */
void CustomJoint::
updateFromXMLNode(SimTK::Xml::Element& aNode, int versionNumber)
{
	int documentVersion = versionNumber;
	if ( documentVersion < XMLDocument::getLatestVersion()){
		if (Object::getDebugLevel()>=1)
			cout << "Updating CustomJoint to latest format..." << endl;
		// Version before refactoring spatialTransform
		if (documentVersion<10901){
			// replace TransformAxisSet with SpatialTransform
			/////renameChildNode("TransformAxisSet", "SpatialTransform");
			// Check how many TransformAxes are defined
			SimTK::Xml::element_iterator spatialTransformNode = 
                aNode.element_begin("TransformAxisSet");
			if (spatialTransformNode == aNode.element_end()) return;

			SimTK::Xml::element_iterator axesSetNode = 
                spatialTransformNode->element_begin("objects");
			/////if (axesSetNode != NULL)
			/////	spatialTransformNode->removeChild(axesSetNode);
			/////DOMElement*grpNode = XMLNode::GetFirstChildElementByTagName(spatialTransformNode,"groups");
			/////if (grpNode != NULL)
			/////	spatialTransformNode->removeChild(grpNode);
			// (0, 1, 2 rotations & 3, 4, 5 translations then remove the is_rotation node)
			SimTK::Array_<SimTK::Xml::Element> list = 
                axesSetNode->getAllElements();
			unsigned int listLength = list.size();
			int objectsFound = 0;
			Array<int> translationIndices(-1, 0);
			Array<int>  rotationIndices(-1, 0);
			int nextAxis = 0;
			std::vector<TransformAxis *> axes;
			// Add children for all six axes here
			//////_node->removeChild(SpatialTransformNode);
			
			// Create a blank Spatial Transform and use it to populate the 
            // XML structure
			for(int i=0; i<6; i++)
				updSpatialTransform()[i].setFunction(new OpenSim::Constant(0));
			
			Array<OpenSim::TransformAxis*> oldAxes;
			for(unsigned int j=0;j<listLength;j++) {
				// getChildNodes() returns all types of DOMNodes including 
                // comments, text, etc., but we only want
				// to process element nodes
				SimTK::Xml::Element objElmt = list[j];
				string objectType = objElmt.getElementTag();
                // (sherm) this is cleaning up old TransformAxis here but
                // that should really be done in TransformAxis instead.
				if (objectType == "TransformAxis"){
					OpenSim::TransformAxis* readAxis = 
                        new OpenSim::TransformAxis(objElmt);
					assert(nextAxis <=5);
					bool isRotation = false;
					SimTK::Xml::element_iterator rotationNode = 
                        objElmt.element_begin("is_rotation");
					if (rotationNode != objElmt.element_end()){
						SimTK::String sValue = 
                            rotationNode->getValueAs<SimTK::String>();
						bool value = (sValue.toLower() == "true");
								isRotation = value;
						objElmt.eraseNode(rotationNode);
							}
					SimTK::Xml::element_iterator coordinateNode = 
                        objElmt.element_begin("coordinate");
					SimTK::String coordinateName = 
                        coordinateNode->getValueAs<SimTK::String>();
					Array<std::string> names("");
					names.append(coordinateName);
					readAxis->setCoordinateNames(names);
					SimTK::Xml::element_iterator axisNode = 
                        objElmt.element_begin("axis");
					
					SimTK::Vec3 axisVec= axisNode->getValueAs<SimTK::Vec3>();
					readAxis->setAxis(axisVec);
					if (isRotation){
						rotationIndices.append(nextAxis);
					}
					else {
						translationIndices.append(nextAxis);
					}
					axes.push_back(readAxis);
					nextAxis++;
				}
			}
			assert(rotationIndices.getSize() <=3);
			assert(translationIndices.getSize() <=3);
			//XMLNode::RemoveChildren(SpatialTransformAxesNode);
			int nRotations = rotationIndices.getSize();
			int nTranslations = translationIndices.getSize();
			// Now copy coordinateName, Axis, Function into proper slot
			for (int i=0; i<nRotations; i++){
				updSpatialTransform()[i] = *axes[rotationIndices[i]];
			}
			updSpatialTransform().constructIndependentAxes(nRotations, 0);
			// Add Translations from old list then pad with default ones, 
            // make sure no singularity.
			for (int i=0; i<nTranslations; i++){
				updSpatialTransform()[i+3] = *axes[translationIndices[i]];
			}
			updSpatialTransform().constructIndependentAxes(nTranslations, 3);
		}
	}

    // Delegate to superclass now.
	Super::updateFromXMLNode(aNode, versionNumber);

	const CoordinateSet& coordinateSet = get_CoordinateSet();

	// Fix coordinate type post deserialization
	// Fix coordinate type post deserialization
	for (int i=0; i<coordinateSet.getSize(); i++){
		OpenSim::Coordinate& nextCoord = coordinateSet.get(i);
		// Find TransformAxis for the coordinate and use it to set Coordinate's motionType
		for(int axisIndex=0; axisIndex<6; axisIndex++){
			const TransformAxis& nextAxis = getSpatialTransform()[axisIndex];
			const Property<std::string>& coordNames = nextAxis.getCoordinateNames();
			if (coordNames.findIndex(nextCoord.getName())!=-1){
				coordinateSet.get(i).setMotionType((axisIndex>2)? 
						Coordinate::Translational : Coordinate::Rotational);
				break;
			}
		}
	}
	// Axes should be independent otherwise Simbody throws an exception in addToSystem
	double tol = 1e-5;
    // Verify that none of the rotation axes are colinear
	const std::vector<SimTK::Vec3> axes=getSpatialTransform().getAxes();
	for(int startIndex=0; startIndex<=3; startIndex+=3){
        if(((axes[startIndex+0]%axes[startIndex+1]).norm() < tol)||
			((axes[startIndex+0]%axes[startIndex+2]).norm() < tol)||
			((axes[startIndex+1]%axes[startIndex+2]).norm() < tol)){
				throw(Exception("CustomJoint " + getName() + 
                    " has colinear axes and so is not well-defined."
                    " Please fix and retry loading.."));
		}
	}
    updProperty_SpatialTransform().setValueIsDefault(false);
}
Ejemplo n.º 18
0
//-----------------------------------------------------------------------------
// UPDATE FROM OLDER VERSION
//-----------------------------------------------------------------------------
//_____________________________________________________________________________
void ExternalLoads::updateFromXMLNode(SimTK::Xml::Element& aNode, int versionNumber)
{
    int documentVersion = versionNumber;
    if ( documentVersion < 20301){
        if (Object::getDebugLevel()>=1)
            cout << "Updating ExternalLoad object to latest format..." << endl;
        _dataFileName="";
        SimTK::Xml::element_iterator dataFileElementIter =aNode.element_begin("datafile");
        if(dataFileElementIter!=aNode.element_end()) {
                    // Could still be empty or whiteSpace
            SimTK::String transcoded = dataFileElementIter->getValueAs<SimTK::String>();
                    if (transcoded.length()>0)
                _dataFileName =transcoded;
                }
        SimTK::Xml::element_iterator kinFileNode = aNode.element_begin("external_loads_model_kinematics_file");
        if (kinFileNode != aNode.element_end()){
            SimTK::String transcoded = kinFileNode->getValueAs<SimTK::String>();
                    if (transcoded.length()>0)
                _externalLoadsModelKinematicsFileName =transcoded;
                }
        SimTK::Xml::element_iterator kinFilterNode = aNode.element_begin("lowpass_cutoff_frequency_for_load_kinematics");
        if (kinFilterNode != aNode.element_end()){
            _lowpassCutoffFrequencyForLoadKinematics = kinFilterNode->getValueAs<double>();
            }
            bool changeWorkingDir = false;
            std::string savedCwd;
            // Change to directory of Document
            if(!ifstream(_dataFileName.c_str(), ios_base::in).good()) {
            string msg =
                    "Object: ERR- Could not open file " + _dataFileName+ "IO. It may not exist or you don't have permission to read it.";
                cout << msg;
                // Try switching to directory of setup file before aborting
                if(getDocument()) {
                    savedCwd = IO::getCwd();
                    IO::chDir(IO::getParentDirectory(getDocument()->getFileName()));
                    changeWorkingDir=true;
                }
                if(!ifstream(_dataFileName.c_str(), ios_base::in).good()) {
                    if(changeWorkingDir) IO::chDir(savedCwd);
            throw Exception(msg,__FILE__,__LINE__);
                }
            }
            Storage* dataSource = new Storage(_dataFileName, true);
            if (!dataSource->makeStorageLabelsUnique()){
                cout << "Making labels unique in storage file "<< _dataFileName << endl;
                dataSource = new Storage(_dataFileName);
                dataSource->makeStorageLabelsUnique();
                dataSource->print(_dataFileName);
            }
            if(changeWorkingDir) IO::chDir(savedCwd);
            
            const Array<string> &labels = dataSource->getColumnLabels();
            // Populate data file and other things that haven't changed
            // Create a ForceSet out of this XML node, this will create a set of PrescribedForces then we can reassign at a higher level to ExternalForces
            ModelComponentSet<PrescribedForce> oldForces(updModel(), getDocument()->getFileName(), true);
            for(int i=0; i< oldForces.getSize(); i++){
                PrescribedForce& oldPrescribedForce = oldForces.get(i);
                ExternalForce* newExternalForce = new ExternalForce();
                newExternalForce->setName(oldPrescribedForce.getName());
                newExternalForce->setAppliedToBodyName(oldPrescribedForce.getBodyName());
                newExternalForce->setPointExpressedInBodyName("ground");
                newExternalForce->setForceExpressedInBodyName("ground");
                // Reconstruct function names and use these to extract the identifier(s)
                OpenSim::Array<std::string> aFunctionNames;
                oldPrescribedForce.getForceFunctionNames(aFunctionNames);
                // Get names from force functions
                newExternalForce->setForceIdentifier(createIdentifier(aFunctionNames, labels));
                aFunctionNames.setSize(0);
                oldPrescribedForce.getPointFunctionNames(aFunctionNames);
                newExternalForce->setPointIdentifier(createIdentifier(aFunctionNames, labels));
                aFunctionNames.setSize(0);
                // Now the torques
                oldPrescribedForce.getTorqueFunctionNames(aFunctionNames);
                newExternalForce->setTorqueIdentifier(createIdentifier(aFunctionNames, labels));
                //newExternalForce->setDataSourceName("");
                adoptAndAppend(newExternalForce);
            }
            delete dataSource;
        }
    else 
        // Call base class now assuming _node has been corrected for current version
        ModelComponentSet<ExternalForce>::updateFromXMLNode(aNode, versionNumber);
}
Ejemplo n.º 19
0
bool XMLDocument::isElementEqual(SimTK::Xml::Element& elt1, SimTK::Xml::Element& elt2, double toleranceForDoubles)
{
    SimTK::String s1,s2;
    elt1.writeToString(s1);
    elt2.writeToString(s2);
    SimTK::Xml::attribute_iterator att1 = elt1.attribute_begin();
    SimTK::Xml::attribute_iterator att2 = elt2.attribute_begin();
    // Handle different # attributes
    if ( (att1 == elt1.attribute_end() && att2 != elt2.attribute_end()) ||
         (att1 != elt1.attribute_end() && att2 == elt2.attribute_end()) ){
            cout << "Number of attributes is different, element " << elt1.getElementTag() << endl;
            return false;
    }
    bool equal =true;
    // Same size attributes including none
    for(att1 = elt1.attribute_begin(); att1 != elt1.attribute_end() && equal; att1++, att2++){
        equal = (att1->getName() == att2->getName());
        equal = equal && (att1->getValue() == att2->getValue());
        if (!equal) {
            cout << "Attribute " << att1->getName() << " is different " << att1->getValue() << 
            "vs." << att2->getValue() << endl;
        }
    }
    if (!equal) return false;

    // Attributes match now children
    SimTK::Array_<SimTK::Xml::Element> elts1 = elt1.getAllElements();
    SimTK::Array_<SimTK::Xml::Element> elts2 = elt2.getAllElements();
    if (elts1.size() != elts2.size()){
        cout << "Different number of children for Element " << elt1.getElementTag() << endl;
        equal = false;
    }
    if (!equal) return false;
    // Recursively compare Elements unless Value Elements in that case do direct compare
    for(unsigned it = 0; it < elts1.size() && equal; it++){
        SimTK::String elt1Tag = elts1[it].getElementTag();
        cout << "Compare " << elt1Tag << endl;
        SimTK::Xml::element_iterator elt2_iter = elt2.element_begin(elt1Tag);
        if (elt2_iter==elt2.element_end()){
            cout << "Element " << elt1Tag << " was not found in reference document" << endl;
            equal = false;
            break;
        }
        bool value1 = elts1[it].isValueElement();
        bool value2 = elt2_iter->isValueElement();
        equal = (value1 == value2);
        if (!equal){ 
            cout << elts1[it].getElementTag() << " is different. One is Value Element the other isn't" << endl;  
            return false; 
        }
        if (value1){
            // We should check if this's a double or array of doubles in that case we can getValueAs<double> anbd
            try {
                SimTK::Array_<double> v1, v2;
                elts1[it].getValueAs(v1);
                elt2_iter->getValueAs(v2);
                for(unsigned ix=0; ix<v1.size() && equal; ix++)
                    equal = (std::fabs(v1[ix]-v2[ix]) < toleranceForDoubles);
            }
            catch(...){
                equal = (elts1[it].getValue() == elt2_iter->getValue());
            }
        }
        else    // recur
            equal = isElementEqual(elts1[it], elts2[it], toleranceForDoubles);
        if (!equal){ 
            cout << elts1[it].getElementTag() << " is different" << endl;  
            SimTK::String pad;
            elts1[it].writeToString(pad);
            cout << pad << endl;
            cout << "------------------- vs. ------" << endl;
            elts2[it].writeToString(pad);
            cout << pad << endl;
            return equal; 
        }
    }

    return equal;
}
Ejemplo n.º 20
0
void Joint::updateFromXMLNode(SimTK::Xml::Element& aNode, int versionNumber)
{
    int documentVersion = versionNumber;
    //bool converting = false;
    if (documentVersion < XMLDocument::getLatestVersion()){
        if (documentVersion<30500){
            XMLDocument::renameChildNode(aNode, "location", "location_in_child"); 
            XMLDocument::renameChildNode(aNode, "orientation", "orientation_in_child");
        }
        // Version 30501 converted Connector_Body_ to Connector_PhysicalFrame_
        if (documentVersion < 30501) {
            // Handle any models that have the Joint connecting to Bodies instead
            // of PhyscialFrames
            XMLDocument::renameChildNode(aNode, "Connector_Body_",
                                                "Connector_PhysicalFrame_");
        }
        // Version 30505 changed "parent_body" connector name to "parent_frame"
        // Convert location and orientation into PhysicalOffsetFrames owned by the Joint
        if (documentVersion < 30505) {
            // Elements for the parent and child names the joint connects
            SimTK::Xml::element_iterator parentNameElt;
            SimTK::Xml::element_iterator childNameElt;
            // The names of the two PhysicalFrames this joint connects
            std::string parentFrameName("");
            std::string childFrameName("");

            SimTK::Xml::element_iterator connectors_node = aNode.element_begin("connectors");

            SimTK::Xml::element_iterator connectorElement =
                connectors_node->element_begin("Connector_PhysicalFrame_");
            while (connectorElement != aNode.element_end()) {
                // If connector name is "parent_body" rename it to "parent_frame"
                if (connectorElement->getRequiredAttributeValue("name") == "parent_body") {
                    connectorElement->setAttributeValue("name", "parent_frame");
                }
                // If connector name is "parent_frame" get the name of the connectee
                if (connectorElement->getRequiredAttributeValue("name") == "parent_frame"){
                    parentNameElt = connectorElement->element_begin("connectee_name");
                    parentNameElt->getValueAs<std::string>(parentFrameName);

                    const auto slashLoc = parentFrameName.rfind('/');
                    if (slashLoc != std::string::npos)
                        parentFrameName = parentFrameName.substr(slashLoc + 1);
                }
                if (connectorElement->getRequiredAttributeValue("name") == "child_body") {
                    connectorElement->setAttributeValue("name", "child_frame");
                }
                if (connectorElement->getRequiredAttributeValue("name") == "child_frame") {
                    childNameElt =  connectorElement->element_begin("connectee_name");
                    childNameElt->getValueAs<std::string>(childFrameName);
                    const auto slashLoc = childFrameName.rfind('/');
                    if (slashLoc != std::string::npos)
                        childFrameName = childFrameName.substr(slashLoc + 1);
                }
                ++connectorElement;
            }

            SimTK::Xml::element_iterator locParentElt =
                aNode.element_begin("location_in_parent");
            SimTK::Xml::element_iterator orientParentElt =
                aNode.element_begin("orientation_in_parent");
            SimTK::Xml::element_iterator locChildElt =
                aNode.element_begin("location_in_child");
            SimTK::Xml::element_iterator orientChildElt =
                aNode.element_begin("orientation_in_child");

            Vec3 location_in_parent(0);
            Vec3 orientation_in_parent(0);
            Vec3 location_in_child(0);
            Vec3 orientation_in_child(0);

            if (locParentElt != aNode.element_end()){
                locParentElt->getValueAs<Vec3>(location_in_parent);
            }
            if (orientParentElt != aNode.element_end()){
                orientParentElt->getValueAs<Vec3>(orientation_in_parent);
            }
            if (locChildElt != aNode.element_end()){
                locChildElt->getValueAs<Vec3>(location_in_child);
            }
            if (orientChildElt != aNode.element_end()){
                orientChildElt->getValueAs<Vec3>(orientation_in_child);
            }

            // now append updated frames to the property list for
            // both parent and child
            XMLDocument::addPhysicalOffsetFrame30505_30517(aNode, parentFrameName+"_offset",
                parentFrameName, location_in_parent, orientation_in_parent);
            parentNameElt->setValue(parentFrameName + "_offset");

            XMLDocument::addPhysicalOffsetFrame30505_30517(aNode, childFrameName + "_offset",
                childFrameName, location_in_child, orientation_in_child);
            childNameElt->setValue(childFrameName + "_offset");
        }

        // Version 30507 replaced Joint's CoordinateSet with a "coordinates"
        // list property.
        if (documentVersion < 30507) {
            if (aNode.hasElement("CoordinateSet")) {
                auto coordSetIter = aNode.element_begin("CoordinateSet");
                if (coordSetIter->hasElement("objects")) {
                    auto coordIter = coordSetIter->getRequiredElement("objects")
                                                   .element_begin("Coordinate");
                    if (coordIter != aNode.element_end()) {
                        // A "CoordinateSet" element exists, it contains an
                        // "objects" element, and the "objects" element contains
                        // at least one "Coordinate" element.

                        // Create an element for the new layout.
                        Xml::Element coordinatesElement("coordinates");
                        // Copy all "Coordinate" elements from the old layout.
                        while (coordIter != aNode.element_end()) {
                            coordinatesElement.appendNode(coordIter->clone());
                            ++coordIter;
                        }
                        // Insert new "coordinates" element.
                        aNode.insertNodeAfter(coordSetIter, coordinatesElement);
                    }
                }

                // Remove old "CoordinateSet" element.
                aNode.eraseNode(coordSetIter);
            }
        }

        // Version 30514 removed the user-facing "reverse" property from Joint.
        // The parent and child frames are swapped if a "reverse" element is
        // found and its value is "true".
        if (documentVersion < 30514) {
            auto reverseElt = aNode.element_begin("reverse");

            if (reverseElt != aNode.element_end()) {
                bool swapFrames = false;
                reverseElt->getValue().tryConvertToBool(swapFrames);

                if (swapFrames) {
                    std::string oldParentFrameName = "";
                    std::string oldChildFrameName  = "";

                    // Find names of parent and child frames. If more than one
                    // "parent_frame" or "child_frame" element exists, keep the
                    // first one. The "parent_frame" and "child_frame" elements
                    // may be listed in either order.
                    SimTK::Xml::element_iterator connectorsNode =
                        aNode.element_begin("connectors");
                    SimTK::Xml::element_iterator connectorElt = connectorsNode->
                        element_begin("Connector_PhysicalFrame_");
                    SimTK::Xml::element_iterator connecteeNameElt;

                    while (connectorElt != connectorsNode->element_end())
                    {
                        if (connectorElt->getRequiredAttributeValue("name") ==
                            "parent_frame" && oldParentFrameName.empty())
                        {
                            connecteeNameElt = connectorElt->
                                               element_begin("connectee_name");
                            connecteeNameElt->getValueAs<std::string>(
                                oldParentFrameName);
                        }
                        else if (connectorElt->getRequiredAttributeValue("name")
                                 == "child_frame" && oldChildFrameName.empty())
                        {
                            connecteeNameElt = connectorElt->
                                               element_begin("connectee_name");
                            connecteeNameElt->getValueAs<std::string>(
                                oldChildFrameName);
                        }
                        ++connectorElt;
                    }

                    // Swap parent and child frame names. If more than one
                    // "parent_frame" or "child_frame" element exists, assign
                    // the same value to all such elements.
                    connectorsNode = aNode.element_begin("connectors");
                    connectorElt = connectorsNode->element_begin(
                                   "Connector_PhysicalFrame_");

                    while (connectorElt != connectorsNode->element_end())
                    {
                        if (connectorElt->getRequiredAttributeValue("name") ==
                            "parent_frame")
                        {
                            connecteeNameElt = connectorElt->
                                               element_begin("connectee_name");
                            connecteeNameElt->setValue(oldChildFrameName);
                        }
                        else if (connectorElt->getRequiredAttributeValue("name")
                                 == "child_frame")
                        {
                            connecteeNameElt = connectorElt->
                                               element_begin("connectee_name");
                            connecteeNameElt->setValue(oldParentFrameName);
                        }
                        ++connectorElt;
                    }
                }

                // Remove "reverse" element regardless of its value (it is no
                // longer a property of Joint).
                aNode.eraseNode(reverseElt);
            }
        }

    }

    Super::updateFromXMLNode(aNode, versionNumber);
}
Ejemplo n.º 21
0
//_____________________________________________________________________________
// Override default implementation by object to intercept and fix the XML node
// underneath the model to match current version.
void Muscle::updateFromXMLNode(SimTK::Xml::Element& aNode, int versionNumber)
{
    if ( versionNumber < XMLDocument::getLatestVersion()) {
        if (Object::getDebugLevel()>=1)
            cout << "Updating Muscle object to latest format..." << endl;
        
        if (versionNumber <= 20301){
            SimTK::Xml::element_iterator pathIter = 
                                            aNode.element_begin("GeometryPath");
            if (pathIter != aNode.element_end()) {
                XMLDocument::renameChildNode(*pathIter, "MusclePointSet", "PathPointSet");
                XMLDocument::renameChildNode(*pathIter, "MuscleWrapSet", "PathWrapSet");
            } else { // There was no GeometryPath, just MusclePointSet
                SimTK::Xml::element_iterator musclePointSetIter = aNode.element_begin("MusclePointSet");
                bool pathPointSetFound=false;
                if (musclePointSetIter != aNode.element_end()){
                    XMLDocument::renameChildNode(aNode, "MusclePointSet", "PathPointSet");
                    pathPointSetFound=true;
                }
                bool pathWrapSetFound=false;
                SimTK::Xml::element_iterator muscleWrapSetIter = aNode.element_begin("MuscleWrapSet");
                if (muscleWrapSetIter != aNode.element_end()){
                    XMLDocument::renameChildNode(aNode, "MuscleWrapSet", "PathWrapSet");
                    pathWrapSetFound=true;
                }
                // Now create a "GeometryPath" node and move MusclePointSet & MuscleWrapSet under it
                SimTK::Xml::Element myPathElement("GeometryPath");
                SimTK::Xml::Node moveNode;
                if (pathPointSetFound) {
                    SimTK::Xml::element_iterator  pathPointSetIter = aNode.element_begin("PathPointSet");
                    moveNode = aNode.removeNode(pathPointSetIter);
                    myPathElement.insertNodeAfter(myPathElement.element_end(),moveNode);
                }
                if (pathWrapSetFound) {
                    SimTK::Xml::element_iterator  pathWrapSetIter = aNode.element_begin("PathWrapSet");
                    moveNode = aNode.removeNode(pathWrapSetIter);
                    myPathElement.insertNodeAfter(myPathElement.element_end(),moveNode);
                }
                aNode.insertNodeAfter(aNode.element_end(), myPathElement);
            }
            XMLDocument::renameChildNode(aNode, "pennation_angle", "pennation_angle_at_optimal");
        }
    }
    // Call base class now assuming aNode has been corrected for current version
    Super::updateFromXMLNode(aNode, versionNumber);
}