cartesian_interpolator.h

Go to the documentation of this file.

/*********************************************************************
 * Software License Agreement (BSD License)
 *
 *  Copyright (c) 2013, Ioan A. Sucan
 *  Copyright (c) 2013, Willow Garage, Inc.
 *  Copyright (c) 2019, PickNik LLC.
 *  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, Inc. 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: Ioan Sucan, Mike Lautman */
 
#pragma once
 
#include <moveit/robot_state/robot_state.h>
 
#include <boost/assert.hpp>
 
namespace moveit
{
namespace core
{
struct CartesianPrecision
{
  double translational = 0.001;  //< max deviation in translation (meters)
  double rotational = 0.01;      //< max deviation in rotation (radians)
  double max_resolution = 1e-5;  //< max resolution for waypoints (fraction of total path)
};
 
struct JumpThreshold
{
  double factor;
  double revolute;   // Radians
  double prismatic;  // Meters
 
  explicit JumpThreshold() : factor(0.0), revolute(0.0), prismatic(0.0)
  {
  }
 
  explicit JumpThreshold(double jt_factor) : JumpThreshold()
  {
    factor = jt_factor;
  }
 
  explicit JumpThreshold(double jt_revolute, double jt_prismatic) : JumpThreshold()
  {
    revolute = jt_revolute;    // Radians
    prismatic = jt_prismatic;  // Meters
  }
};
 
struct MaxEEFStep
{
  MaxEEFStep(double translation, double rotation) : translation(translation), rotation(rotation)
  {
  }
 
  MaxEEFStep(double step_size) : translation(step_size), rotation(3.5 * step_size)  // 0.035 rad = 2 deg
  {
  }
 
  double translation;  // Meters
  double rotation;     // Radians
};
 
class CartesianInterpolator
{
  // TODO(mlautman): Eventually, this planner should be moved out of robot_state
 
public:
  static double
  computeCartesianPath(const RobotState* start_state, const JointModelGroup* group,
                       std::vector<std::shared_ptr<RobotState>>& traj, const LinkModel* link,
                       const Eigen::Vector3d& translation, bool global_reference_frame, const MaxEEFStep& max_step,
                       const CartesianPrecision& precision,
                       const GroupStateValidityCallbackFn& validCallback = GroupStateValidityCallbackFn(),
                       const kinematics::KinematicsQueryOptions& options = kinematics::KinematicsQueryOptions());
 
  static double
  computeCartesianPath(const RobotState* start_state, const JointModelGroup* group,
                       std::vector<std::shared_ptr<RobotState>>& traj, const LinkModel* link,
                       const Eigen::Vector3d& direction, bool global_reference_frame, double distance,
                       const MaxEEFStep& max_step, const CartesianPrecision& precision,
                       const GroupStateValidityCallbackFn& validCallback = GroupStateValidityCallbackFn(),
                       const kinematics::KinematicsQueryOptions& options = kinematics::KinematicsQueryOptions())
  {
    return computeCartesianPath(start_state, group, traj, link, distance * direction, global_reference_frame, max_step,
                                precision, validCallback, options);
  }
 
  static double computeCartesianPath(const RobotState* start_state, const JointModelGroup* group,
                                     std::vector<RobotStatePtr>& traj, const LinkModel* link,
                                     const Eigen::Isometry3d& target, bool global_reference_frame,
                                     const MaxEEFStep& max_step, const CartesianPrecision& precision,
                                     const GroupStateValidityCallbackFn& validCallback,
                                     const kinematics::KinematicsQueryOptions& options,
                                     const Eigen::Isometry3d& link_offset = Eigen::Isometry3d::Identity());
 
  static double
  computeCartesianPath(const RobotState* start_state, const JointModelGroup* group,
                       std::vector<std::shared_ptr<RobotState>>& traj, const LinkModel* link,
                       const EigenSTL::vector_Isometry3d& waypoints, bool global_reference_frame,
                       const MaxEEFStep& max_step, const CartesianPrecision& precision,
                       const GroupStateValidityCallbackFn& validCallback = GroupStateValidityCallbackFn(),
                       const kinematics::KinematicsQueryOptions& options = kinematics::KinematicsQueryOptions(),
                       const Eigen::Isometry3d& link_offset = Eigen::Isometry3d::Identity());
 
  [[deprecated("Replace JumpThreshold with CartesianPrecision")]] static double
  computeCartesianPath(RobotState* start_state, const JointModelGroup* group,
                       std::vector<std::shared_ptr<RobotState>>& traj, const LinkModel* link,
                       const Eigen::Vector3d& translation, bool global_reference_frame, const MaxEEFStep& max_step,
                       const JumpThreshold& jump_threshold,
                       const GroupStateValidityCallbackFn& validCallback = GroupStateValidityCallbackFn(),
                       const kinematics::KinematicsQueryOptions& options = kinematics::KinematicsQueryOptions());
 
  [[deprecated("Replace JumpThreshold with CartesianPrecision")]] static double
  computeCartesianPath(RobotState* start_state, const JointModelGroup* group,
                       std::vector<std::shared_ptr<RobotState>>& traj, const LinkModel* link,
                       const Eigen::Vector3d& direction, bool global_reference_frame, double distance,
                       const MaxEEFStep& max_step, const JumpThreshold& jump_threshold,
                       const GroupStateValidityCallbackFn& validCallback = GroupStateValidityCallbackFn(),
                       const kinematics::KinematicsQueryOptions& options = kinematics::KinematicsQueryOptions())
  {
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
    return computeCartesianPath(start_state, group, traj, link, distance * direction, global_reference_frame, max_step,
                                jump_threshold, validCallback, options);
#pragma GCC diagnostic pop
  }
 
  [[deprecated("Replace JumpThreshold with CartesianPrecision")]] static double
  computeCartesianPath(RobotState* start_state, const JointModelGroup* group,
                       std::vector<std::shared_ptr<RobotState>>& traj, const LinkModel* link,
                       const Eigen::Isometry3d& target, bool global_reference_frame, const MaxEEFStep& max_step,
                       const JumpThreshold& jump_threshold,
                       const GroupStateValidityCallbackFn& validCallback = GroupStateValidityCallbackFn(),
                       const kinematics::KinematicsQueryOptions& options = kinematics::KinematicsQueryOptions(),
                       const Eigen::Isometry3d& link_offset = Eigen::Isometry3d::Identity());
 
  [[deprecated("Replace JumpThreshold with CartesianPrecision")]] static double
  computeCartesianPath(RobotState* start_state, const JointModelGroup* group,
                       std::vector<std::shared_ptr<RobotState>>& traj, const LinkModel* link,
                       const EigenSTL::vector_Isometry3d& waypoints, bool global_reference_frame,
                       const MaxEEFStep& max_step, const JumpThreshold& jump_threshold,
                       const GroupStateValidityCallbackFn& validCallback = GroupStateValidityCallbackFn(),
                       const kinematics::KinematicsQueryOptions& options = kinematics::KinematicsQueryOptions(),
                       const Eigen::Isometry3d& link_offset = Eigen::Isometry3d::Identity());
 
  static double checkJointSpaceJump(const JointModelGroup* group, std::vector<std::shared_ptr<RobotState>>& traj,
                                    const JumpThreshold& jump_threshold);
 
  static double checkRelativeJointSpaceJump(const JointModelGroup* group,
                                            std::vector<std::shared_ptr<RobotState>>& traj,
                                            double jump_threshold_factor);
 
  static double checkAbsoluteJointSpaceJump(const JointModelGroup* group,
                                            std::vector<std::shared_ptr<RobotState>>& traj,
                                            double revolute_jump_threshold, double prismatic_jump_threshold);
};
 
}  // end of namespace core
}  // end of namespace moveit