C++ Element::element_end方法代码示例

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);
}

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);
}

// 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]);
    }
}

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);
}

/*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);
    }
}

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);
}

//_____________________________________________________________________________
// 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);
}

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.

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);
}

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);
}

/**
 * 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);
}

/*
 * 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);
}

/**
 * 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.");
    }
}   

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");
//.........这里部分代码省略.........

/** 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]];
//.........这里部分代码省略.........