Address review

Author: rhaschke

core/include/moveit/task_constructor/solvers/cartesian_path.h

@@ -59,14 +59,16 @@ class CartesianPath : public PlannerInterface
 
 	void setStepSize(double step_size) { setProperty("step_size", step_size); }
 	void setPrecision(const moveit::core::CartesianPrecision& precision) { setProperty("precision", precision); }
-	[[deprecated("Replace with setPrecision")]]  // clang-format off
-	void setJumpThreshold(double /*jump_threshold*/) {}
+	template <typename T = float>
+	void setJumpThreshold(double) {
+		static_assert(std::is_integral<T>::value, "setJumpThreshold() is deprecated. Replace with setPrecision.");
+	}
 	void setMinFraction(double min_fraction) { setProperty("min_fraction", min_fraction); }
 
 	[[deprecated("Replace with setMaxVelocityScalingFactor")]]  // clang-format off
-	void setMaxVelocityScaling(double factor) { setMaxVelocityScalingFactor(factor); }
+	void setMaxVelocityScaling(double factor) { setMaxVelocityScalingFactor(factor); }  // clang-format on
 	[[deprecated("Replace with setMaxAccelerationScalingFactor")]]  // clang-format off
-	void setMaxAccelerationScaling(double factor) { setMaxAccelerationScalingFactor(factor); }
+	void setMaxAccelerationScaling(double factor) { setMaxAccelerationScalingFactor(factor); }  // clang-format on
 
 	void init(const moveit::core::RobotModelConstPtr& robot_model) override;
 
@@ -75,8 +77,8 @@ class CartesianPath : public PlannerInterface
 	            const moveit_msgs::Constraints& path_constraints = moveit_msgs::Constraints()) override;
 
 	Result plan(const planning_scene::PlanningSceneConstPtr& from, const moveit::core::LinkModel& link,
-	            const Eigen::Isometry3d& offset, const Eigen::Isometry3d& target, const moveit::core::JointModelGroup* jmg,
-	            double timeout, robot_trajectory::RobotTrajectoryPtr& result,
+	            const Eigen::Isometry3d& offset, const Eigen::Isometry3d& target,
+	            const moveit::core::JointModelGroup* jmg, double timeout, robot_trajectory::RobotTrajectoryPtr& result,
 	            const moveit_msgs::Constraints& path_constraints = moveit_msgs::Constraints()) override;
 };
 }  // namespace solvers

core/python/bindings/src/solvers.cpp

@@ -100,11 +100,14 @@ void export_solvers(py::module& m) {
 	    .property<double>("max_step", "float: Limit any (single) joint change between two waypoints to this amount")
 	    .def(py::init<>());
 
+	const moveit::core::CartesianPrecision default_precision;
 	py::class_<moveit::core::CartesianPrecision>(m, "CartesianPrecision", "precision for Cartesian interpolation")
 	    .def(py::init([](double translational, double rotational, double max_resolution) {
 		         return new moveit::core::CartesianPrecision{ translational, rotational, max_resolution };
 	         }),
-	         py::arg("translational") = 0.001, py::arg("rotational") = 0.01, py::arg("max_resolution") = 1e-5)
+	         py::arg("translational") = default_precision.translational,
+	         py::arg("rotational") = default_precision.rotational,
+	         py::arg("max_resolution") = default_precision.max_resolution)
 	    .def_readwrite("translational", &moveit::core::CartesianPrecision::translational)
 	    .def_readwrite("rotational", &moveit::core::CartesianPrecision::rotational)
 	    .def_readwrite("max_resolution", &moveit::core::CartesianPrecision::max_resolution)

core/src/solvers/cartesian_path.cpp

@@ -54,7 +54,8 @@ CartesianPath::CartesianPath() {
 	auto& p = properties();
 	p.declare<geometry_msgs::PoseStamped>("ik_frame", "frame to move linearly (use for joint-space target)");
 	p.declare<double>("step_size", 0.01, "step size between consecutive waypoints");
-	p.declare<moveit::core::CartesianPrecision>("precision", { 1e-3, 1e-2, 1e-4 }, "precision of linear path");
+	p.declare<moveit::core::CartesianPrecision>("precision", moveit::core::CartesianPrecision(),
+	                                            "precision of linear path");
 	p.declare<double>("min_fraction", 1.0, "fraction of motion required for success");
 	p.declare<kinematics::KinematicsQueryOptions>("kinematics_options", kinematics::KinematicsQueryOptions(),
 	                                              "KinematicsQueryOptions to pass to CartesianInterpolator");