pr2_arm_kinematics_utils.cpp

Go to the documentation of this file.

/*********************************************************************
 * Software License Agreement (BSD License)
 *
 *  Copyright (c) 2008, Willow Garage, Inc.
 *  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions
 *  are met:
 *
 *   * Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *   * Redistributions in binary form must reproduce the above
 *     copyright notice, this list of conditions and the following
 *     disclaimer in the documentation and/or other materials provided
 *     with the distribution.
 *   * Neither the name of Willow Garage nor the names of its
 *     contributors may be used to endorse or promote products derived
 *     from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 *  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 *  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 *  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 *  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
 *  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 *  POSSIBILITY OF SUCH DAMAGE.
 *********************************************************************/

/* Author: Sachin Chitta */

#include <pr2_arm_kinematics/pr2_arm_kinematics_utils.h>
#include <pr2_arm_kinematics/pr2_arm_kinematics_constants.h>

namespace pr2_arm_kinematics
{
static const double IK_DEFAULT_TIMEOUT = 10.0;
bool loadRobotModel(ros::NodeHandle node_handle, urdf::Model &robot_model, std::string &xml_string)
{
  std::string urdf_xml,full_urdf_xml;
  node_handle.param("urdf_xml",urdf_xml,std::string("robot_description"));
  node_handle.searchParam(urdf_xml,full_urdf_xml);
  TiXmlDocument xml;
  ROS_DEBUG("Reading xml file from parameter server\n");
  std::string result;
  if (node_handle.getParam(full_urdf_xml, result))
    xml.Parse(result.c_str());
  else
  {
    ROS_FATAL("Could not load the xml from parameter server: %s\n", urdf_xml.c_str());
    return false;
  }
  xml_string = result;
  TiXmlElement *root_element = xml.RootElement();
  TiXmlElement *root = xml.FirstChildElement("robot");
  if (!root || !root_element)
  {
    ROS_FATAL("Could not parse the xml from %s\n", urdf_xml.c_str());
    exit(1);
  }
  robot_model.initXml(root);
  return true;
}

bool getKDLChain(const std::string &xml_string, const std::string &root_name, const std::string &tip_name, KDL::Chain &kdl_chain)
{
  // create robot chain from root to tip
  KDL::Tree tree;
  if (!kdl_parser::treeFromString(xml_string, tree))
  {
    ROS_ERROR("Could not initialize tree object");
    return false;
  }
  if (!tree.getChain(root_name, tip_name, kdl_chain))
  {
    ROS_ERROR_STREAM("Could not initialize chain object for base " << root_name << " tip " << tip_name);
    return false;
  }
  return true;
}

bool getKDLTree(const std::string &xml_string, const std::string &root_name, const std::string &tip_name, KDL::Tree &kdl_tree)
{
  // create robot chain from root to tip
  if (!kdl_parser::treeFromString(xml_string, kdl_tree))
  {
    ROS_ERROR("Could not initialize tree object");
    return false;
  }
  return true;
}


Eigen::Matrix4f KDLToEigenMatrix(const KDL::Frame &p)
{
  Eigen::Matrix4f b = Eigen::Matrix4f::Identity();
  for(int i=0; i < 3; i++)
  {
    for(int j=0; j<3; j++)
    {
      b(i,j) = p.M(i,j);
    }
    b(i,3) = p.p(i);
  }
  return b;
}

double computeEuclideanDistance(const std::vector<double> &array_1, const KDL::JntArray &array_2)
{
  double distance = 0.0;
  for(int i=0; i< (int) array_1.size(); i++)
  {
    distance += (array_1[i] - array_2(i))*(array_1[i] - array_2(i));
  }
  return sqrt(distance);
}


double distance(const urdf::Pose &transform)
{
  return sqrt(transform.position.x*transform.position.x+transform.position.y*transform.position.y+transform.position.z*transform.position.z);
}


bool solveQuadratic(const double &a, const double &b, const double &c, double *x1, double *x2)
{
  double discriminant = b*b-4*a*c;
  if(fabs(a) < IK_EPS)
  {
    *x1 = -c/b;
    *x2 = *x1;
    return true;
  }
  //ROS_DEBUG("Discriminant: %f\n",discriminant);
  if (discriminant >= 0)
  {
    *x1 = (-b + sqrt(discriminant))/(2*a);
    *x2 = (-b - sqrt(discriminant))/(2*a);
    return true;
  }
  else if(fabs(discriminant) < IK_EPS)
  {
    *x1 = -b/(2*a);
    *x2 = -b/(2*a);
    return true;
  }
  else
  {
    *x1 = -b/(2*a);
    *x2 = -b/(2*a);
    return false;
  }
}

Eigen::Matrix4f matrixInverse(const Eigen::Matrix4f &g)
{
  Eigen::Matrix4f result = g;
  Eigen::Matrix3f Rt = Eigen::Matrix3f::Identity();

  Eigen::Vector3f p = Eigen::Vector3f::Zero(3);
  Eigen::Vector3f pinv = Eigen::Vector3f::Zero(3);

  Rt(0,0) = g(0,0);
  Rt(1,1) = g(1,1);
  Rt(2,2) = g(2,2);

  Rt(0,1) = g(1,0);
  Rt(1,0) = g(0,1);

  Rt(0,2) = g(2,0);
  Rt(2,0) = g(0,2);

  Rt(1,2) = g(2,1);
  Rt(2,1) = g(1,2);

  p(0) = g(0,3);
  p(1) = g(1,3);
  p(2) = g(2,3);

  pinv = -Rt*p;

  result(0,0) = g(0,0);
  result(1,1) = g(1,1);
  result(2,2) = g(2,2);

  result(0,1) = g(1,0);
  result(1,0) = g(0,1);

  result(0,2) = g(2,0);
  result(2,0) = g(0,2);

  result(1,2) = g(2,1);
  result(2,1) = g(1,2);

  result(0,3) = pinv(0);
  result(1,3) = pinv(1);
  result(2,3) = pinv(2);

  return result;
}


bool solveCosineEqn(const double &a, const double &b, const double &c, double &soln1, double &soln2)
{
  double theta1 = atan2(b,a);
  double denom  = sqrt(a*a+b*b);

  if(fabs(denom) < IK_EPS) // should never happen, wouldn't make sense but make sure it is checked nonetheless
  {
#ifdef DEBUG
    std::cout << "denom: " << denom << std::endl;
#endif
    return false;
  }
  double rhs_ratio = c/denom;
  if(rhs_ratio < -1 || rhs_ratio > 1)
  {
#ifdef DEBUG
    std::cout << "rhs_ratio: " << rhs_ratio << std::endl;
#endif
    return false;
  }
  double acos_term = acos(rhs_ratio);
  soln1 = theta1 + acos_term;
  soln2 = theta1 - acos_term;

  return true;
}


bool checkJointNames(const std::vector<std::string> &joint_names,
                     const moveit_msgs::KinematicSolverInfo &chain_info)
{
  for(unsigned int i=0; i < chain_info.joint_names.size(); i++)
  {
    int index = -1;
    for(unsigned int j=0; j < joint_names.size(); j++)
    {
      if(chain_info.joint_names[i] == joint_names[j])
      {
        index = j;
        break;
      }
    }
    if(index < 0)
    {
      ROS_ERROR("Joint state does not contain joint state for %s.",chain_info.joint_names[i].c_str());
      return false;
    }
  }
  return true;
}

bool checkLinkNames(const std::vector<std::string> &link_names,
                    const moveit_msgs::KinematicSolverInfo &chain_info)
{
  if(link_names.empty())
    return false;
  for(unsigned int i=0; i < link_names.size(); i++)
  {
    if(!checkLinkName(link_names[i],chain_info))
      return false;
  }
  return true;
}

bool checkLinkName(const std::string &link_name,
                   const moveit_msgs::KinematicSolverInfo &chain_info)
{
  for(unsigned int i=0; i < chain_info.link_names.size(); i++)
  {
    if(link_name == chain_info.link_names[i])
      return true;
  }
  return false;
}

bool checkRobotState(moveit_msgs::RobotState &robot_state,
                     const moveit_msgs::KinematicSolverInfo &chain_info)
{
  if((int) robot_state.joint_state.position.size() != (int) robot_state.joint_state.name.size())
  {
    ROS_ERROR("Number of joints in robot_state.joint_state does not match number of positions in robot_state.joint_state");
    return false;
  }
  if(!checkJointNames(robot_state.joint_state.name,chain_info))
  {
    ROS_ERROR("Robot state must contain joint state for every joint in the kinematic chain");
    return false;
  }
  return true;
}

bool checkFKService(moveit_msgs::GetPositionFK::Request &request,
                    moveit_msgs::GetPositionFK::Response &response,
                    const moveit_msgs::KinematicSolverInfo &chain_info)
{
  if(!checkLinkNames(request.fk_link_names,chain_info))
  {
    ROS_ERROR("Link name in service request does not match links that kinematics can provide solutions for.");
    response.error_code.val = response.error_code.INVALID_LINK_NAME;
    return false;
  }
  if(!checkRobotState(request.robot_state,chain_info))
  {
    response.error_code.val = response.error_code.INVALID_ROBOT_STATE;
    return false;
  }
  return true;
}

bool checkIKService(moveit_msgs::GetPositionIK::Request &request,
                    moveit_msgs::GetPositionIK::Response &response,
                    const moveit_msgs::KinematicSolverInfo &chain_info)
{
  if(!checkLinkName(request.ik_request.ik_link_name,chain_info))
  {
    ROS_ERROR("Link name in service request does not match links that kinematics can provide solutions for.");
    response.error_code.val = response.error_code.INVALID_LINK_NAME;
    return false;
  }
  if(!checkRobotState(request.ik_request.robot_state,chain_info))
  {
    response.error_code.val = response.error_code.INVALID_ROBOT_STATE;
    return false;
  }
  if(request.ik_request.timeout <= ros::Duration(0.0))
  {
    response.error_code.val = response.error_code.TIMED_OUT;
    return false;
  }
  return true;
}

bool convertPoseToRootFrame(const geometry_msgs::PoseStamped &pose_msg,
                            KDL::Frame &pose_kdl,
                            const std::string &root_frame,
                            tf::TransformListener& tf)
{
  geometry_msgs::PoseStamped pose_stamped;
  if(!convertPoseToRootFrame(pose_msg, pose_stamped, root_frame,tf))
    return false;
  tf::poseMsgToKDL(pose_stamped.pose, pose_kdl);
  return true;
}


bool convertPoseToRootFrame(const geometry_msgs::PoseStamped &pose_msg,
                            geometry_msgs::PoseStamped &pose_msg_out,
                            const std::string &root_frame,
                            tf::TransformListener& tf)
{
  geometry_msgs::PoseStamped pose_msg_in = pose_msg;
  ROS_DEBUG("Request:\nframe_id: %s\nPosition: %f %f %f\n:Orientation: %f %f %f %f\n",
            pose_msg_in.header.frame_id.c_str(),
            pose_msg_in.pose.position.x,
            pose_msg_in.pose.position.y,
            pose_msg_in.pose.position.z,
            pose_msg_in.pose.orientation.x,
            pose_msg_in.pose.orientation.y,
            pose_msg_in.pose.orientation.z,
            pose_msg_in.pose.orientation.w);
  pose_msg_out = pose_msg;
  tf::Stamped<tf::Pose> pose_stamped;
  poseStampedMsgToTF(pose_msg_in, pose_stamped);

  if (!tf.canTransform(root_frame, pose_stamped.frame_id_, pose_stamped.stamp_))
  {
    std::string err;
    if (tf.getLatestCommonTime(pose_stamped.frame_id_, root_frame, pose_stamped.stamp_, &err) != tf::NO_ERROR)
    {
      ROS_ERROR("pr2_arm_ik:: Cannot transform from '%s' to '%s'. TF said: %s",pose_stamped.frame_id_.c_str(),root_frame.c_str(), err.c_str());
      return false;
    }
  }
  try
  {
    tf.transformPose(root_frame, pose_stamped, pose_stamped);
  }
  catch(...)
  {
    ROS_ERROR("pr2_arm_ik:: Cannot transform from '%s' to '%s'",pose_stamped.frame_id_.c_str(),root_frame.c_str());
    return false;
  }
  tf::poseStampedTFToMsg(pose_stamped,pose_msg_out);
  return true;
}



int getJointIndex(const std::string &name,
                  const moveit_msgs::KinematicSolverInfo &chain_info)
{
  for(unsigned int i=0; i < chain_info.joint_names.size(); i++)
  {
    if(chain_info.joint_names[i] == name)
    {
      return i;
    }
  }
  return -1;
}

void getKDLChainInfo(const KDL::Chain &chain,
                     moveit_msgs::KinematicSolverInfo &chain_info)
{
  int i=0; // segment number
  while(i < (int)chain.getNrOfSegments())
  {
    chain_info.link_names.push_back(chain.getSegment(i).getName());
    i++;
  }
}

int getKDLSegmentIndex(const KDL::Chain &chain,
                       const std::string &name)
{
  int i=0; // segment number
  while(i < (int)chain.getNrOfSegments())
  {
    if(chain.getSegment(i).getName() == name)
    {
      return i+1;
    }
    i++;
  }
  return -1;
}


}