Grasper.cc

Go to the documentation of this file.

#include "Shared/RobotInfo.h"
#if (defined(TGT_HAS_ARMS) || !defined(STRICT_TGT_MODEL)) && !defined(TGT_IS_AIBO)

#include <Crew/Grasper.h>
#include <DualCoding/VRmixin.h>
#include <DualCoding/ShapeCylinder.h>
#include <Motion/IKSolver.h>

#include <fstream>

using namespace DualCoding;

//**** These constants are for the Chiara chess gripper.
float openLeftGripperVal = -0.10f;
float closedLeftGripperVal = -0.25f;
float openRightGripperVal = 0.07f;
float closedRightGripperVal = 0.25f;

MotionManager::MC_ID motionNodesWalkMC = MotionManager::invalid_MC_ID;

GrasperRequest* Grasper::curReq = NULL;
Grasper::GrasperVerbosity_t Grasper::verbosity = -1U;

void Grasper::ForwardRequestType::doStart() {
  curReq->moveConstrainedPath.clear();
  curReq->moveFreePath.clear();
  curReq->disengagePath.clear();
  postStateSignal<GrasperRequest::GrasperRequestType_t>(curReq->requestType);
}

void Grasper::PathPlanUnconstrained::doStart() {
  std::vector<NodeValue_t> endStates;
  
  fmat::Column<3> offset = fmat::pack(0.0f, 0.0f, 0.0f);
  
  Point toPt = curReq->object->getCentroid();
  VRmixin::grasper->computeGoalStates(toPt, curReq->gripperAngleRangesX, curReq->gripperAngleRangesY, curReq->gripperAngleRangesZ, curReq->angleResolution, endStates, offset);
  if (endStates.empty()) {
    std::cout << "PLAN - pickUpUnreachable" << std::endl;
    postStateSignal<GraspError>(GrasperRequest::pickUpUnreachable);
    return;
  }
  
  NodeValue_t startSt;
  Grasper::getCurrentState(startSt);
  
  VRmixin::grasper->appendObjectToObstacles();
  
  GET_SHAPE(worldBounds, PolygonData, VRmixin::worldShS);
  Grasper::Planner planner(VRmixin::worldShS, worldBounds, curReq->rrtInflation, curReq->effectorOffset);
  
  std::vector<NodeType_t> *treeStartResult = curReq->displayTree ? new std::vector<NodeType_t> : NULL;
  std::vector<NodeType_t> *treeEndResult = curReq->displayTree ? new std::vector<NodeType_t> : NULL;
  fmat::Transform t;
  DualCoding::Point c = VRmixin::theAgent->getCentroid();
  t.translation()[0] = c.coordX();
  t.translation()[1] = c.coordY();
  t.rotation() = fmat::Matrix<3,3>(fmat::rotation2D(VRmixin::theAgent->getOrientation()));
  Grasper::Planner::PlannerResult result =
  planner.planPath(startSt, endStates.front(), curReq->rrtInterpolationStep,
                   t, curReq->rrtMaxIterations,
                   &(curReq->moveFreePath), treeStartResult, treeEndResult);
  VRmixin::grasper->removeTargetFromObstacles();
  
  switch ( result.code ) {
    case GenericRRTBase::SUCCESS:
      std::cout << "Plan Unconstrained succeeded" << std::endl;
      break;
    case GenericRRTBase::START_COLLIDES:
      std::cout << "Navigation path planning failed: start state is in collision.\n";
      break;
    case GenericRRTBase::END_COLLIDES:
      std::cout << "Navigation path planning failed: end state is in collision.\n";
      break;
    case GenericRRTBase::MAX_ITER:
      std::cout << "Navigation path planning failed: too many iterations.\n";
      break;
  }
  
  if (result.code == GenericRRTBase::START_COLLIDES || result.code == GenericRRTBase::END_COLLIDES) {
    std::cout << "Obstacle: " << std::endl << "=================" << std::endl << result.movingObstacle->toString() << std::endl;
    std::cout << "collided with: " <<std::endl << "=================" << std::endl << result.collidingObstacle->toString() << std::endl;
    std::cout << "=================" << std::endl;
  }
  
  // Display the tree if requested
  if ( curReq->displayTree && result.code != GenericRRTBase::START_COLLIDES && GenericRRTBase::END_COLLIDES ) {
    NEW_SHAPE(plannerTrees, GraphicsData, new GraphicsData(VRmixin::worldShS));
    planner.plotTree(*treeStartResult, plannerTrees, rgb(0,0,0));
    planner.plotTree(*treeEndResult, plannerTrees, rgb(0,192,0));
    delete treeStartResult;
    delete treeEndResult;
  }
  
  // Display the path if requested
  if ( curReq->displayPath && result.code == GenericRRTBase::SUCCESS ) {
    NEW_SHAPE(plannedPath, GraphicsData, new GraphicsData(VRmixin::worldShS));
    planner.plotPath(curReq->moveFreePath, plannedPath, rgb(0,0,255));
  } 
  
  if (result.code == GenericRRTBase::SUCCESS)
    postStateCompletion();
  else {
    std::cout << "PLANNER FAILURE - UNCONSTRAINED" << std::endl;
    postStateSignal<GraspError>(GrasperRequest::noGraspPath);
  }
}

void Grasper::PathPlanConstrained::doStart() {
  std::vector<NodeValue_t> endStates;
  
  fmat::Column<3> offset = fmat::pack(0.0f, 0.0f, 0.0f);
  
  if (!curReq->targetLocation.isValid()) {
    postStateSignal<GraspError>(GrasperRequest::someError);
    return;
  }
  
  Point toPt = curReq->object->getCentroid();
  VRmixin::grasper->computeGoalStates(toPt, curReq->gripperAngleRangesX, curReq->gripperAngleRangesY, curReq->gripperAngleRangesZ,
                                      curReq->angleResolution, endStates, offset);
  if (endStates.empty()) {
    std::cout << "PLAN - pickUpUnreachable" << std::endl;
    postStateSignal<GraspError>(GrasperRequest::pickUpUnreachable);
    return;
  }
  
  NodeValue_t startSt;
  if (curReq->moveFreePath.empty())
    Grasper::getCurrentState(startSt);
  else
    startSt = curReq->moveFreePath.back();
  
  if (curReq->verbosity)
    std::cout << "Planning on "<< curReq->plannerObstacles.size() << " obstacles" << std::endl;
  
  GET_SHAPE(worldBounds, PolygonData, VRmixin::worldShS);
  Planner planner(VRmixin::worldShS, worldBounds, curReq->rrtInflation,
                                             curReq->effectorOffset, curReq->predicate);
  
  std::vector<NodeType_t> *treeStartResult = NULL;
  std::vector<NodeType_t> *treeEndResult = NULL;
  fmat::Transform t;
  DualCoding::Point c = VRmixin::theAgent->getCentroid();
  t.translation()[0] = c.coordX();
  t.translation()[1] = c.coordY();
  t.rotation() = fmat::Matrix<3,3>(fmat::rotation2D(VRmixin::theAgent->getOrientation()));
  Planner::PlannerResult result =
  planner.planPath(startSt, endStates.front(), curReq->rrtInterpolationStep,
                   t, curReq->rrtMaxIterations,
                   &(curReq->moveConstrainedPath), treeStartResult, treeEndResult);
  
  switch ( result.code ) {
    case GenericRRTBase::SUCCESS:
      std::cout << "Plan Constrained succeeded" << std::endl;
      postStateCompletion();
      return;
    case GenericRRTBase::START_COLLIDES:
      std::cout << "Navigation path planning failed: start state is in collision.\n";
      break;
    case GenericRRTBase::END_COLLIDES:
      std::cout << "Navigation path planning failed: end state is in collision.\n";
      break;
    case GenericRRTBase::MAX_ITER:
      std::cout << "Navigation path planning failed: too many iterations.\n";
      break;
  }
  
  if (result.code == GenericRRTBase::START_COLLIDES || result.code == GenericRRTBase::END_COLLIDES) {
    std::cout << "Obstacle: " << std::endl << "=================" << std::endl << result.movingObstacle->toString() << std::endl;
    std::cout << "collided with: " <<std::endl << "=================" << std::endl << result.collidingObstacle->toString() << std::endl;
    std::cout << "=================" << std::endl;
  }
  
  // Display the tree if requested
  if ( curReq->displayTree && result.code != GenericRRTBase::START_COLLIDES && GenericRRTBase::END_COLLIDES ) {
    NEW_SHAPE(plannerTrees, GraphicsData, new GraphicsData(VRmixin::worldShS));
    planner.plotTree(*treeStartResult, plannerTrees, rgb(0,0,0));
    planner.plotTree(*treeEndResult, plannerTrees, rgb(0,192,0));
    delete treeStartResult;
    delete treeEndResult;
  }
  
  // Display the path if requested
  if ( curReq->displayPath && result.code == GenericRRTBase::SUCCESS ) {
    NEW_SHAPE(plannedPath, GraphicsData, new GraphicsData(VRmixin::worldShS));
    planner.plotPath(curReq->moveConstrainedPath, plannedPath, rgb(0,0,255));
  } 
  
  if (result.code == GenericRRTBase::SUCCESS)
    postStateCompletion();
  else {
    std::cout << "PLANNER FAILURE - CONSTRAINED" << std::endl;
    postStateSignal<GraspError>(GrasperRequest::noGraspPath);
  }
}

void Grasper::PathPlanToRest::doStart() {
  NodeValue_t startSt;
  NodeValue_t endSt;
  
  switch(curReq->restType) {
    case GrasperRequest::stationary:
      postStateCompletion();
      return;
    case GrasperRequest::settleArm:
    case GrasperRequest::settleBodyAndArm:
      for(unsigned i = 0; i < NumArmJoints; i++)
        endSt[i] = curReq->armRestState[i];
      break;
  }
  
  VRmixin::grasper->appendObjectToObstacles();
  
  if (!curReq->moveConstrainedPath.empty())
    startSt = curReq->moveConstrainedPath.back();
  else if (!curReq->moveFreePath.empty())
    startSt = curReq->moveFreePath.back();
  else
    Grasper::getCurrentState(startSt);
  
  if (curReq->verbosity)
    std::cout << "Planning on "<< curReq->plannerObstacles.size() << " obstacles" << std::endl;
  
  GET_SHAPE(worldBounds, PolygonData, VRmixin::worldShS);
  Planner planner(VRmixin::worldShS, worldBounds, curReq->rrtInflation, curReq->effectorOffset, NULL);
  
  std::vector<NodeType_t> *treeStartResult = NULL;
  std::vector<NodeType_t> *treeEndResult = NULL;
  fmat::Transform t;
  DualCoding::Point c = VRmixin::theAgent->getCentroid();
  t.translation()[0] = c.coordX();
  t.translation()[1] = c.coordY();
  t.rotation() = fmat::Matrix<3,3>(fmat::rotation2D(VRmixin::theAgent->getOrientation()));
  Planner::PlannerResult result =
  planner.planPath(startSt, endSt, curReq->rrtInterpolationStep,
                   t, curReq->rrtMaxIterations,
                   &(curReq->disengagePath), treeStartResult, treeEndResult);
  VRmixin::grasper->removeTargetFromObstacles();
  
  switch ( result.code ) {
    case GenericRRTBase::SUCCESS:
      std::cout << "Plan disengage succeeded" << std::endl;
      postStateCompletion();
      return;
    case GenericRRTBase::START_COLLIDES:
      std::cout << "Navigation path planning failed: start state is in collision.\n";
      break;
    case GenericRRTBase::END_COLLIDES:
      std::cout << "Navigation path planning failed: end state is in collision.\n";
      break;
    case GenericRRTBase::MAX_ITER:
      std::cout << "Navigation path planning failed: too many iterations.\n";
      break;
  }
  
  if (result.code == GenericRRTBase::START_COLLIDES || result.code == GenericRRTBase::END_COLLIDES) {
    std::cout << "Obstacle: " << std::endl << "=================" << std::endl << result.movingObstacle->toString() << std::endl;
    std::cout << "collided with: " <<std::endl << "=================" << std::endl << result.collidingObstacle->toString() << std::endl;
    std::cout << "=================" << std::endl;
  }
  
  // Display the tree if requested
  if ( curReq->displayTree && result.code != GenericRRTBase::START_COLLIDES && GenericRRTBase::END_COLLIDES ) {
    NEW_SHAPE(plannerTrees, GraphicsData, new GraphicsData(VRmixin::worldShS));
    planner.plotTree(*treeStartResult, plannerTrees, rgb(0,0,0));
    planner.plotTree(*treeEndResult, plannerTrees, rgb(0,192,0));
    delete treeStartResult;
    delete treeEndResult;
  }
  
  // Display the path if requested
  if ( curReq->displayPath && result.code == GenericRRTBase::SUCCESS ) {
    NEW_SHAPE(plannedPath, GraphicsData, new GraphicsData(VRmixin::worldShS));
    planner.plotPath(curReq->disengagePath, plannedPath, rgb(0,0,255));
  } 
  
  if (result.code == GenericRRTBase::SUCCESS)
    postStateCompletion();
  else {
    std::cout << "PLANNER FAILURE - ARM_REST" << std::endl;
    postStateSignal<GraspError>(GrasperRequest::noGraspPath);
  }
}

void Grasper::MoveArm::doStart() {
  switch(pa) {
    case GrasperRequest::moveFree:
      if ( curReq->verbosity & GVexecutePath )
        std::cout << "Grasper: moving along unconstrained path" << std::endl;
      executeMove(curReq->moveFreePath);
      break;
    case GrasperRequest::moveConstrained:
      if ( curReq->verbosity & GVexecutePath )
        std::cout << "Grasper: moving along constrained path" << std::endl;
      executeMove(curReq->moveConstrainedPath);
      break;
    case GrasperRequest::disengage:
      if ( curReq->verbosity & GVexecutePath )
        std::cout << "Grasper: moving along disengage path" << std::endl;
      executeMove(curReq->disengagePath);
      break;
    case GrasperRequest::noPath:
      break;
  }
}

void Grasper::MoveArm::executeMove(const std::vector<NodeValue_t>& path) {
  MMAccessor<DynamicMotionSequence> move_acc = getMC();
  move_acc->clear();
  move_acc->setTime(10);
  for(unsigned int p = 0; p < path.size(); p++) {
    unsigned int j = 0;
    for(unsigned int i = 0; j < NumArmJoints; i++) {
#ifdef TGT_HAS_ARMS
      if (kine->getKinematicJoint(ArmOffset+i)->isMobile() == false)
        continue;
      move_acc->setOutputCmd(ArmOffset+i, (float)path[p][j]);
#endif
      j++;
    }
    if (p < path.size()-1) {
      NodeValue_t confDif;
      for(unsigned i = 0; i < NumArmJoints; i++)
        confDif[i] = path[p][i] - path[p+1][i];
      move_acc->advanceTime( advTime(confDif) );
    }
  }
  
  move_acc->play();
}

void Grasper::convertObstacles() {
  // First delete any obstacles left around by the last planning operation
  for(unsigned i = 0; i < curReq->plannerObstacles.size(); i++)
    delete curReq->plannerObstacles[i];
  curReq->plannerObstacles.clear();
  
  for(std::vector<ShapeRoot>::iterator it = curReq->envObstacles.begin();
      it != curReq->envObstacles.end(); it++)
#ifdef TGT_CALLIOPE
    PlannerObstacle3D::convertShapeToPlannerObstacle(*it, 0, curReq->plannerObstacles);
#else
    PlannerObstacle2D::convertShapeToPlannerObstacle(*it, 0, curReq->plannerObstacles);
#endif
  
  // Prevent any self collisions
  /*
   TODO: body?
   Make this cleaner. Have hardcoded leg values in here
   */
  
#ifdef TGT_HAS_LEGS
  //Need to prevent the arm from running into any legs
  vector<string> legNames, sweepNames;
  legNames.push_back("RFrFootFrame"); sweepNames.push_back("RFr:sweep");
  //  legNames.push_back("LFrFootFrame"); sweepNames.push_back("LFr:sweep");
  //  legNames.push_back("RMdFootFrame"); sweepNames.push_back("RMd:sweep");
  //  legNames.push_back("LMdFootFrame"); sweepNames.push_back("LMd:sweep");
  //  legNames.push_back("RBkFootFrame"); sweepNames.push_back("RBk:sweep");
  //  legNames.push_back("LBkFootFrame"); sweepNames.push_back("LBk:sweep");
  
  std::cout << "Grasper HACK: Leg obstacles" << std::endl;
  
  for (unsigned i = 0; i < legNames.size(); i++) {
    unsigned int jInd = capabilities.findFrameOffset(legNames[i]);
    unsigned int sInd = capabilities.findFrameOffset(sweepNames[i]);
    if (jInd > NumReferenceFrames || sInd > NumReferenceFrames)
      continue;
    const KinematicJoint* k = kine->getKinematicJoint(jInd);
    const KinematicJoint* s = kine->getKinematicJoint(sInd);
    if (k == NULL || s == NULL)
      continue;
    fmat::Column<3> legPos = k->getWorldPosition(), sweepPos = s->getWorldPosition();
    legPos[2] = sweepPos[2] = 0;
    float radius = 10;
    bool notRest = !(curReq->requestType == GrasperRequest::rest);
    //    std::cout << "isStanding=" << isStanding << " notRest=" << notRest << std::endl;
    if (notRest) {
      fmat::Column<3> dif = legPos - sweepPos;
      dif /= dif.norm();
      dif *= 40;
      //      std::cout << "for "<< legNames[i] << " legPos=" << legPos << " dif=" << dif;
      legPos += dif;
      //      std::cout << " updated=" << legPos << std::endl;
      radius = 30;
    }
    Shape<CylinderData> leg(new CylinderData(VRmixin::localShS, Point(legPos),  300, radius));
    PlannerObstacle::convertShapeToPlannerObstacle(leg, 0, curReq->plannerObstacles);
  }
#endif
  
}

void Grasper::getCurrentState(NodeValue_t &current, KinematicJoint* endEffector) {
  KinematicJoint* joint = endEffector == NULL ? kine->getKinematicJoint(curReq->effectorOffset)->cloneBranch() : endEffector;
  for (unsigned int j = NumArmJoints; j > 0; j--) {
    while (joint->isMobile() == false) joint = joint->getParent();
    current[j-1] = joint->getQ();
    joint = joint->getParent();
  }
}

void Grasper::computeGoalStates(Point& toPt, std::vector<std::pair<float, float> >& rangesX,
                                std::vector<std::pair<float, float> >& rangesY, std::vector<std::pair<float, float> >& rangesZ,
                                float res, std::vector<NodeValue_t>& goals, fmat::Column<3> offset) {
  KinematicJoint* effector = kine->getKinematicJoint(curReq->effectorOffset)->cloneBranch();
  IKSolver& solver = effector->getIK();
  goals.clear();
  if (res == 0)
    res = 1;
  
  if (rangesX.empty()) {
    rangesX.push_back(pair<float, float>(0, 2*M_PI));
  }
  
  if (rangesY.empty()) {
    rangesY.push_back(pair<float, float>(0, 2*M_PI));
  }
  
  if (rangesZ.empty()) {
    rangesZ.push_back(pair<float, float>(0, 2*M_PI));
  }
  
  int factorX = 0;
  bool keepGoing = true;
  do {
    keepGoing = false;
    for(unsigned rX = 0; rX < rangesX.size(); rX++) {
      
      float thetaX = res * factorX;
      float midX = (rangesX[rX].first + rangesX[rX].second)/2;
      if (thetaX > rangesX[rX].second - midX)
        continue;
      int factorY = 0;
      
      for (unsigned rY = 0; rY < rangesY.size(); rY++) {
        
        float thetaY = res * factorY;
        float midY = (rangesY[rY].first + rangesY[rY].second)/2;
        if (thetaY > rangesY[rY].second - midY)
          continue;
        int factorZ = 0;
        
        for (unsigned rZ = 0; rZ < rangesZ.size(); rZ++) {
          
          float thetaZ = res * factorZ;
          float midZ = (rangesZ[rZ].first + rangesZ[rZ].second)/2;
          if (thetaZ > rangesZ[rZ].second - midZ)
            continue;
          
          keepGoing = true;
          fmat::Quaternion ori = fmat::Quaternion::fromMatrix(fmat::rotationZ(midZ + thetaZ) * fmat::rotationY(midY + thetaY) * fmat::rotationX(midX + thetaX));
          bool reached;
          reached = solver.solve(offset, IKSolver::Rotation(), *effector, IKSolver::Point(toPt.coords[0], toPt.coords[1], toPt.coords[2]), 1, IKSolver::Rotation(ori), 0);
          if (reached) {
            NodeValue_t endSt;
            KinematicJoint* joint = effector;
            for(unsigned int j = NumArmJoints; j > 0; j--) {
              while (joint->isMobile() == false) joint = joint->getParent();
              endSt[j-1] = joint->getQ();
              joint = joint->getParent();
            }
            goals.push_back(endSt);
          }
          
          ori = fmat::Quaternion::fromMatrix(fmat::rotationZ(midZ - thetaZ) * fmat::rotationY(midY - thetaY) * fmat::rotationX(midX - thetaX));
          reached = solver.solve(offset, IKSolver::Rotation(), *effector, IKSolver::Point(toPt.coords[0], toPt.coords[1], toPt.coords[2]), 1, IKSolver::Rotation(ori), 0);
          if (reached) {
            NodeValue_t endSt;
            KinematicJoint* joint = effector;
            while (joint->isMobile() == false) joint = joint->getParent();
            for(unsigned int j = NumArmJoints; j > 0; j--) {
              while (joint->isMobile() == false) joint = joint->getParent();
              endSt[j-1] = joint->getQ();
              joint = joint->getParent();
            }
            goals.push_back(endSt);
          }
          if ( curReq->maxNumberOfAngles <= (signed)goals.size() ) {
            keepGoing = false;
          }
          factorZ++;
        } // Z
        factorY++;
      } // Y
      factorX++;
    } // X
  } while (keepGoing);
  if ( curReq->verbosity & GVcomputeGoals )
    std::cout << "Grasper found " << goals.size() << " potential goal states." << std::endl;
}

unsigned int Grasper::executeRequest(const GrasperRequest& req, BehaviorBase* requestingBehavior) {
  GrasperRequest *newReq = new GrasperRequest(req);
  newReq->requestingBehavior = requestingBehavior;
  unsigned int reqID = ++idCounter;
  newReq->requestID = reqID;
  GraspError e = newReq->validateRequest();
  if ( e != GrasperRequest::noError ) {
    std::cout << "*** Grasper received invalid grasp request, id=" << reqID << std::endl;
    GrasperEvent myEvent(false, newReq->requestType, e, (size_t)newReq->requestingBehavior);
    erouter->postEvent(myEvent);
  }
  else {
    requests.push(newReq);
    executeRequest();
  }
  return reqID;
}

void Grasper::executeRequest() {
  if ( curReq != NULL )
    return;
  else if ( requests.empty() )
    return;
  curReq = requests.front();
  requests.pop();
  
  curReq->verbosity = (verbosity & ~curReq->clearVerbosity) | curReq->setVerbosity;
  if ( curReq->verbosity & GVexecuteRequest )
    std::cout << "Grasper now executing request " << curReq->requestID << std::endl;
  
  if (curReq->object.isValid() && curReq->object->getSpace().getRefFrameType() == VRmixin::worldShS.getRefFrameType())
    curReq->object = VRmixin::mapBuilder->importWorldToLocal(curReq->object);
  
  if (curReq->targetLocation.isValid() && curReq->targetLocation->getSpace().getRefFrameType() == VRmixin::worldShS.getRefFrameType())
    curReq->targetLocation = VRmixin::mapBuilder->importWorldToLocal(curReq->targetLocation);
  convertObstacles();
  dispatch();
}

void Grasper::dispatch() {
  switch( curReq->requestType ) {
    case GrasperRequest::reach:
      reachRoot->start();
      break;
    case GrasperRequest::computeReach:
      if ( curReq->populateEventPathWith == GrasperRequest::noPath )
        curReq->populateEventPathWith = GrasperRequest::moveFree;
      computeReachRoot->start();
      break;
    case GrasperRequest::grasp:
      graspRoot->start();
      break;
    case GrasperRequest::checkGraspable:
      checkRoot->start();
      break;
    case GrasperRequest::release:
      releaseRoot->start();
      break;
    case GrasperRequest::touch:
      touchRoot->start();
      break;
    case GrasperRequest::moveTo:
      moveRoot->start();
      break;
    case GrasperRequest::checkMovable:
      checkRoot->start();
      break;
    case GrasperRequest::rest:
      restRoot->start();
      break;
    case GrasperRequest::checkRestable:
      checkRoot->start();
      break;
    case GrasperRequest::sweep:
      std::cout << "Grasper functionality " << curReq->requestType << " not implemented"<< std::endl;
      break;
    default:
      std::cout << "Unidentified requestType" << std::endl;
      break;
  }
} 

#endif // TGT_HAS_ARMS