42 #include <moveit/version.h>
43 #include <tf2_eigen/tf2_eigen.hpp>
49 #define BOOST_ALLOW_DEPRECATED_HEADERS
50 #include <boost/regex.hpp>
51 #include <boost/progress.hpp>
52 #undef BOOST_ALLOW_DEPRECATED_HEADERS
53 #include <boost/date_time/posix_time/posix_time.hpp>
75 template <
class Clock,
class Duration>
76 boost::posix_time::ptime
toBoost(
const std::chrono::time_point<Clock, Duration>& from)
78 typedef std::chrono::nanoseconds duration_t;
80 rep_t d = std::chrono::duration_cast<duration_t>(from.time_since_epoch()).count();
81 rep_t sec = d / 1000000000;
82 rep_t nsec = d % 1000000000;
83 namespace pt = boost::posix_time;
84 #ifdef BOOST_DATE_TIME_HAS_NANOSECONDS
85 return pt::from_time_t(sec) + pt::nanoseconds(nsec)
87 return pt::from_time_t(sec) + pt::microseconds(nsec / 1000);
93 robot_descriptionparam) }
94 , planning_scene_storage_{ nullptr }
95 , planning_scene_world_storage_{ nullptr }
96 , robot_state_storage_{ nullptr }
97 , constraints_storage_{ nullptr }
98 , trajectory_constraints_storage_{ nullptr }
114 for (
const std::string& planning_pipeline_name : planning_pipeline_names)
116 if (
moveit_cpp_->getPlanningPipelines().find(planning_pipeline_name) ==
moveit_cpp_->getPlanningPipelines().end())
118 RCLCPP_ERROR(
getLogger(),
"Cannot find pipeline '%s'", planning_pipeline_name.c_str());
122 const auto& pipeline =
moveit_cpp_->getPlanningPipelines().at(planning_pipeline_name);
126 RCLCPP_ERROR(
getLogger(),
"Failed to initialize planning pipeline '%s'", planning_pipeline_name.c_str());
134 RCLCPP_ERROR(
getLogger(),
"No planning pipelines have been loaded. Nothing to do for the benchmarking service.");
138 RCLCPP_INFO(
getLogger(),
"Available planning pipelines:");
139 for (
const std::pair<const std::string, planning_pipeline::PlanningPipelinePtr>& entry :
142 RCLCPP_INFO_STREAM(
getLogger(), entry.first);
214 RCLCPP_ERROR(
getLogger(),
"No planning pipelines configured. Did you call BenchmarkExecutor::initialize?");
218 std::vector<BenchmarkRequest> queries;
219 moveit_msgs::msg::PlanningScene scene_msg;
223 for (std::size_t i = 0; i < queries.size(); ++i)
226 if (scene_msg.robot_model_name !=
planning_scene_->getRobotModel()->getName())
246 RCLCPP_INFO(
getLogger(),
"Benchmarking query '%s' (%lu of %lu)", queries[i].
name.c_str(), i + 1, queries.size());
247 std::chrono::system_clock::time_point start_time = std::chrono::system_clock::now();
249 std::chrono::duration<double> dt = std::chrono::system_clock::now() - start_time;
250 double duration = dt.count();
266 moveit_msgs::msg::PlanningScene& scene_msg,
267 std::vector<BenchmarkRequest>& requests)
274 std::vector<StartState> start_states;
275 std::vector<PathConstraints> path_constraints;
276 std::vector<PathConstraints> goal_constraints;
277 std::vector<TrajectoryConstraints> traj_constraints;
278 std::vector<BenchmarkRequest> queries;
283 RCLCPP_ERROR(
getLogger(),
"Failed to load benchmark query data");
289 "Benchmark loaded %lu starts, %lu goals, %lu path constraints, %lu trajectory constraints, and %lu queries",
290 start_states.size(), goal_constraints.size(), path_constraints.size(), traj_constraints.size(), queries.size());
292 moveit_msgs::msg::WorkspaceParameters workspace_parameters =
options.workspace;
294 if (workspace_parameters.min_corner.x == workspace_parameters.max_corner.x &&
295 workspace_parameters.min_corner.x == 0.0 &&
296 workspace_parameters.min_corner.y == workspace_parameters.max_corner.y &&
297 workspace_parameters.min_corner.y == 0.0 &&
298 workspace_parameters.min_corner.z == workspace_parameters.max_corner.z &&
299 workspace_parameters.min_corner.z == 0.0)
301 workspace_parameters.min_corner.x = workspace_parameters.min_corner.y = workspace_parameters.min_corner.z = -5.0;
303 workspace_parameters.max_corner.x = workspace_parameters.max_corner.y = workspace_parameters.max_corner.z = 5.0;
314 benchmark_request.
name = goal_constraint.name;
315 benchmark_request.
request.workspace_parameters = workspace_parameters;
316 benchmark_request.
request.goal_constraints = goal_constraint.constraints;
318 benchmark_request.
request.allowed_planning_time =
options.timeout;
319 benchmark_request.
request.num_planning_attempts = 1;
321 if (benchmark_request.
request.goal_constraints.size() == 1 &&
322 benchmark_request.
request.goal_constraints.at(0).position_constraints.size() == 1 &&
323 benchmark_request.
request.goal_constraints.at(0).orientation_constraints.size() == 1 &&
324 benchmark_request.
request.goal_constraints.at(0).visibility_constraints.empty() &&
325 benchmark_request.
request.goal_constraints.at(0).joint_constraints.empty())
330 std::vector<BenchmarkRequest> request_combos;
332 requests.insert(requests.end(), request_combos.begin(), request_combos.end());
341 benchmark_request.
name = query.name;
342 benchmark_request.
request = query.request;
344 benchmark_request.
request.allowed_planning_time =
options.timeout;
345 benchmark_request.
request.num_planning_attempts = 1;
348 if (benchmark_request.
request.workspace_parameters.min_corner.x ==
349 benchmark_request.
request.workspace_parameters.max_corner.x &&
350 benchmark_request.
request.workspace_parameters.min_corner.x == 0.0 &&
351 benchmark_request.
request.workspace_parameters.min_corner.y ==
352 benchmark_request.
request.workspace_parameters.max_corner.y &&
353 benchmark_request.
request.workspace_parameters.min_corner.y == 0.0 &&
354 benchmark_request.
request.workspace_parameters.min_corner.z ==
355 benchmark_request.
request.workspace_parameters.max_corner.z &&
356 benchmark_request.
request.workspace_parameters.min_corner.z == 0.0)
359 benchmark_request.
request.workspace_parameters = workspace_parameters;
363 std::vector<BenchmarkRequest> request_combos;
365 requests.insert(requests.end(), request_combos.begin(), request_combos.end());
373 benchmark_request.
name = traj_constraint.name;
374 benchmark_request.
request.trajectory_constraints = traj_constraint.constraints;
376 benchmark_request.
request.allowed_planning_time =
options.timeout;
377 benchmark_request.
request.num_planning_attempts = 1;
379 if (benchmark_request.
request.trajectory_constraints.constraints.size() == 1 &&
380 benchmark_request.
request.trajectory_constraints.constraints.at(0).position_constraints.size() == 1 &&
381 benchmark_request.
request.trajectory_constraints.constraints.at(0).orientation_constraints.size() == 1 &&
382 benchmark_request.
request.trajectory_constraints.constraints.at(0).visibility_constraints.empty() &&
383 benchmark_request.
request.trajectory_constraints.constraints.at(0).joint_constraints.empty())
388 std::vector<BenchmarkRequest> request_combos;
389 std::vector<PathConstraints> no_path_constraints;
391 requests.insert(requests.end(), request_combos.begin(), request_combos.end());
397 const BenchmarkOptions&
options, moveit_msgs::msg::PlanningScene& scene_msg, std::vector<StartState>& start_states,
398 std::vector<PathConstraints>& path_constraints, std::vector<PathConstraints>& goal_constraints,
399 std::vector<TrajectoryConstraints>& traj_constraints, std::vector<BenchmarkRequest>& queries)
403 warehouse_ros::DatabaseConnection::Ptr warehouse_connection =
db_loader_.loadDatabase();
404 warehouse_connection->setParams(
options.hostname,
options.port, 20);
405 if (warehouse_connection->connect())
409 std::make_shared<moveit_warehouse::PlanningSceneWorldStorage>(warehouse_connection);
410 robot_state_storage_ = std::make_shared<moveit_warehouse::RobotStateStorage>(warehouse_connection);
411 constraints_storage_ = std::make_shared<moveit_warehouse::ConstraintsStorage>(warehouse_connection);
413 std::make_shared<moveit_warehouse::TrajectoryConstraintsStorage>(warehouse_connection);
414 RCLCPP_INFO(
getLogger(),
"Connected to DB");
418 RCLCPP_ERROR(
getLogger(),
"Failed to connect to DB");
422 catch (std::exception& e)
424 RCLCPP_ERROR(
getLogger(),
"Failed to initialize benchmark server: '%s'", e.what());
430 RCLCPP_ERROR(
getLogger(),
"Failed to load the planning scene");
435 RCLCPP_ERROR(
getLogger(),
"Failed to load the states");
440 RCLCPP_ERROR(
getLogger(),
"Failed to load the goal constraints");
444 RCLCPP_ERROR(
getLogger(),
"Failed to load the path constraints");
448 RCLCPP_ERROR(
getLogger(),
"Failed to load the trajectory constraints");
452 RCLCPP_ERROR(
getLogger(),
"Failed to get a query regex");
458 const std::vector<double>& offset)
460 Eigen::Isometry3d offset_tf(Eigen::AngleAxis<double>(offset.at(3), Eigen::Vector3d::UnitX()) *
461 Eigen::AngleAxis<double>(offset.at(4), Eigen::Vector3d::UnitY()) *
462 Eigen::AngleAxis<double>(offset.at(5), Eigen::Vector3d::UnitZ()));
463 offset_tf.translation() =
Eigen::Vector3d(offset.at(0), offset.at(1), offset.at(2));
465 geometry_msgs::msg::Pose constraint_pose_msg;
466 constraint_pose_msg.position =
467 constraints.position_constraints.at(0).constraint_region.primitive_poses.at(0).position;
468 constraint_pose_msg.orientation = constraints.orientation_constraints.at(0).orientation;
469 Eigen::Isometry3d constraint_pose;
470 tf2::fromMsg(constraint_pose_msg, constraint_pose);
472 Eigen::Isometry3d new_pose = constraint_pose * offset_tf;
473 geometry_msgs::msg::Pose new_pose_msg;
474 new_pose_msg = tf2::toMsg(new_pose);
476 constraints.position_constraints.at(0).constraint_region.primitive_poses.at(0).position = new_pose_msg.position;
477 constraints.orientation_constraints.at(0).orientation = new_pose_msg.orientation;
481 const std::vector<StartState>& start_states,
482 const std::vector<PathConstraints>& path_constraints,
483 std::vector<BenchmarkRequest>& requests)
486 if (start_states.empty())
492 new_benchmark_request.
request.path_constraints = path_constraint.constraints.at(0);
493 new_benchmark_request.
name = benchmark_request.
name +
"_" + path_constraint.name;
494 requests.push_back(new_benchmark_request);
497 if (path_constraints.empty())
499 requests.push_back(benchmark_request);
504 for (
const StartState& start_state : start_states)
507 if (start_state.name == benchmark_request.
name)
511 new_benchmark_request.
request.start_state = start_state.state;
516 new_benchmark_request.
request.path_constraints = path_constraint.constraints.at(0);
517 new_benchmark_request.
name = start_state.name +
"_" + new_benchmark_request.
name +
"_" + path_constraint.name;
518 requests.push_back(new_benchmark_request);
521 if (path_constraints.empty())
523 new_benchmark_request.
name = start_state.name +
"_" + benchmark_request.
name;
524 requests.push_back(new_benchmark_request);
533 for (
const std::pair<
const std::string, std::vector<std::string>>& pipeline_config_entry : pipeline_configurations)
535 bool pipeline_exists =
false;
536 for (
const std::pair<const std::string, planning_pipeline::PlanningPipelinePtr>& pipeline_entry :
539 pipeline_exists = pipeline_entry.first == pipeline_config_entry.first;
544 if (!pipeline_exists)
546 RCLCPP_ERROR(
getLogger(),
"Planning pipeline '%s' does NOT exist", pipeline_config_entry.first.c_str());
563 RCLCPP_ERROR(
getLogger(),
"Failed to load planning scene '%s'", scene_name.c_str());
566 scene_msg =
static_cast<moveit_msgs::msg::PlanningScene
>(*planning_scene_w_metadata);
573 RCLCPP_ERROR(
getLogger(),
"Failed to load planning scene world '%s'", scene_name.c_str());
576 scene_msg.world =
static_cast<moveit_msgs::msg::PlanningSceneWorld
>(*pswwm);
577 scene_msg.robot_model_name =
578 "NO ROBOT INFORMATION. ONLY WORLD GEOMETRY";
582 RCLCPP_ERROR(
getLogger(),
"Failed to find planning scene '%s'", scene_name.c_str());
586 catch (std::exception& ex)
588 RCLCPP_ERROR(
getLogger(),
"Error loading planning scene: %s", ex.what());
591 RCLCPP_INFO(
getLogger(),
"Loaded planning scene successfully");
596 std::vector<BenchmarkRequest>& queries)
600 RCLCPP_WARN(
getLogger(),
"No query regex provided, don't load any queries from the database");
604 std::vector<std::string> query_names;
609 catch (std::exception& ex)
611 RCLCPP_ERROR(
getLogger(),
"Error loading motion planning queries: %s", ex.what());
615 if (query_names.empty())
617 RCLCPP_ERROR(
getLogger(),
"Scene '%s' has no associated queries", scene_name.c_str());
621 for (
const std::string& query_name : query_names)
628 catch (std::exception& ex)
630 RCLCPP_ERROR(
getLogger(),
"Error loading motion planning query '%s': %s", query_name.c_str(), ex.what());
635 query.
name = query_name;
637 queries.push_back(query);
639 RCLCPP_INFO(
getLogger(),
"Loaded queries successfully");
647 std::regex start_regex(regex);
648 std::vector<std::string> state_names;
651 if (state_names.empty())
653 RCLCPP_WARN(
getLogger(),
"Database does not contain any named states");
656 for (
const std::string& state_name : state_names)
659 if (std::regex_match(state_name, match, start_regex))
667 start_state.
state = moveit_msgs::msg::RobotState(*robot_state);
668 start_state.
name = state_name;
669 start_states.push_back(start_state);
672 catch (std::exception& ex)
674 RCLCPP_ERROR(
getLogger(),
"Runtime error when loading state '%s': %s", state_name.c_str(), ex.what());
680 if (start_states.empty())
682 RCLCPP_WARN(
getLogger(),
"No stored states matched the provided start state regex: '%s'", regex.c_str());
685 RCLCPP_INFO(
getLogger(),
"Loaded states successfully");
693 std::vector<std::string> cnames;
696 for (
const std::string& cname : cnames)
705 constraint.
name = cname;
706 constraints.push_back(constraint);
709 catch (std::exception& ex)
711 RCLCPP_ERROR(
getLogger(),
"Runtime error when loading path constraint '%s': %s", cname.c_str(), ex.what());
716 if (constraints.empty())
718 RCLCPP_WARN(
getLogger(),
"No path constraints found that match regex: '%s'", regex.c_str());
722 RCLCPP_INFO(
getLogger(),
"Loaded path constraints successfully");
729 std::vector<TrajectoryConstraints>& constraints)
733 std::vector<std::string> cnames;
736 for (
const std::string& cname : cnames)
745 constraint.
name = cname;
746 constraints.push_back(constraint);
749 catch (std::exception& ex)
751 RCLCPP_ERROR(
getLogger(),
"Runtime error when loading trajectory constraint '%s': %s", cname.c_str(), ex.what());
756 if (constraints.empty())
758 RCLCPP_WARN(
getLogger(),
"No trajectory constraints found that match regex: '%s'", regex.c_str());
762 RCLCPP_INFO(
getLogger(),
"Loaded trajectory constraints successfully");
772 auto num_planners = 0;
773 for (
const std::pair<
const std::string, std::vector<std::string>>& pipeline_entry :
options.planning_pipelines)
775 num_planners += pipeline_entry.second.size();
777 num_planners +=
options.parallel_planning_pipelines.size();
779 boost::progress_display progress(num_planners *
options.runs, std::cout);
782 auto planning_pipelines =
moveit_cpp_->getPlanningPipelines();
783 for (
const std::pair<
const std::string, std::vector<std::string>>& pipeline_entry :
options.planning_pipelines)
786 for (
const std::string& planner_id : pipeline_entry.second)
791 std::vector<planning_interface::MotionPlanDetailedResponse> responses(
options.runs);
792 std::vector<bool> solved(
options.runs);
794 request.planner_id = planner_id;
799 planner_start_function(request, planner_data);
804 .planning_pipeline = pipeline_entry.first,
805 .planning_attempts = request.num_planning_attempts,
806 .planning_time = request.allowed_planning_time,
807 .max_velocity_scaling_factor = request.max_velocity_scaling_factor,
808 .max_acceleration_scaling_factor = request.max_acceleration_scaling_factor
812 for (
int j = 0; j <
options.runs; ++j)
816 pre_event_function(request);
819 auto planning_component = std::make_shared<moveit_cpp::PlanningComponent>(request.group_name,
moveit_cpp_);
823 planning_component->setStartState(start_state);
824 planning_component->setGoal(request.goal_constraints);
825 planning_component->setPathConstraints(request.path_constraints);
826 planning_component->setTrajectoryConstraints(request.trajectory_constraints);
829 std::chrono::system_clock::time_point start = std::chrono::system_clock::now();
832 const auto response = planning_component->plan(plan_req_params,
planning_scene_);
834 solved[j] = bool(response.error_code);
836 responses[j].error_code = response.error_code;
837 if (response.trajectory)
839 responses[j].description.push_back(
"plan");
840 responses[j].trajectory.push_back(response.trajectory);
841 responses[j].processing_time.push_back(response.planning_time);
844 std::chrono::duration<double> dt = std::chrono::system_clock::now() - start;
845 double total_time = dt.count();
848 start = std::chrono::system_clock::now();
853 post_event_fn(request, responses[j], planner_data[j]);
855 collectMetrics(planner_data[j], responses[j], solved[j], total_time);
856 dt = std::chrono::system_clock::now() - start;
857 double metriconstraints_storage_time = dt.count();
858 RCLCPP_DEBUG(
getLogger(),
"Spent %lf seconds collecting metrics", metriconstraints_storage_time);
868 planner_completion_fn(request, planner_data);
875 if (!
options.parallel_planning_pipelines.empty())
878 for (
const std::pair<
const std::string, std::vector<std::pair<std::string, std::string>>>& parallel_pipeline_entry :
879 options.parallel_planning_pipelines)
884 std::vector<planning_interface::MotionPlanDetailedResponse> responses(
options.runs);
885 std::vector<bool> solved(
options.runs);
890 planner_start_function(request, planner_data);
895 for (
const auto& pipeline_planner_id_pair : parallel_pipeline_entry.second)
898 .
planner_id = pipeline_planner_id_pair.second,
899 .planning_pipeline = pipeline_planner_id_pair.first,
900 .planning_attempts = request.num_planning_attempts,
901 .planning_time = request.allowed_planning_time,
902 .max_velocity_scaling_factor = request.max_velocity_scaling_factor,
903 .max_acceleration_scaling_factor = request.max_acceleration_scaling_factor
909 for (
int j = 0; j <
options.runs; ++j)
914 pre_event_function(request);
918 auto planning_component = std::make_shared<moveit_cpp::PlanningComponent>(request.group_name,
moveit_cpp_);
922 planning_component->setStartState(start_state);
923 planning_component->setGoal(request.goal_constraints);
924 planning_component->setPathConstraints(request.path_constraints);
925 planning_component->setTrajectoryConstraints(request.trajectory_constraints);
928 std::chrono::system_clock::time_point start = std::chrono::system_clock::now();
930 const auto t1 = std::chrono::system_clock::now();
931 const auto response = planning_component->plan(multi_pipeline_plan_request,
934 const auto t2 = std::chrono::system_clock::now();
936 solved[j] = bool(response.error_code);
938 responses[j].error_code = response.error_code;
939 if (response.trajectory)
941 responses[j].description.push_back(
"plan");
942 responses[j].trajectory.push_back(response.trajectory);
943 responses[j].processing_time.push_back(std::chrono::duration_cast<std::chrono::milliseconds>(t2 - t1).count());
946 std::chrono::duration<double> dt = std::chrono::system_clock::now() - start;
947 double total_time = dt.count();
950 start = std::chrono::system_clock::now();
954 post_event_fn(request, responses[j], planner_data[j]);
957 collectMetrics(planner_data[j], responses[j], solved[j], total_time);
958 dt = std::chrono::system_clock::now() - start;
959 double metriconstraints_storage_time = dt.count();
960 RCLCPP_DEBUG(
getLogger(),
"Spent %lf seconds collecting metrics", metriconstraints_storage_time);
970 planner_completion_fn(request, planner_data);
980 bool solved,
double total_time)
983 metrics[
"solved BOOLEAN"] = solved ?
"true" :
"false";
988 double traj_len = 0.0;
989 double clearance = 0.0;
992 double process_time = total_time;
993 for (std::size_t j = 0; j < motion_plan_response.
trajectory.size(); ++j)
1022 return s.has_value() ? s.value() : 0.0;
1025 metrics[
"path_" + motion_plan_response.
description[j] +
"_correct BOOLEAN"] = correct ?
"true" :
"false";
1029 metrics[
"path_" + motion_plan_response.
description[j] +
"_time REAL"] =
1032 if (j == motion_plan_response.
trajectory.size() - 1)
1034 metrics[
"final_path_correct BOOLEAN"] = correct ?
"true" :
"false";
1042 if (process_time <= 0.0)
1049 PlannerBenchmarkData& planner_data,
const std::vector<planning_interface::MotionPlanDetailedResponse>& responses,
1050 const std::vector<bool>& solved)
1052 RCLCPP_INFO(
getLogger(),
"Computing result path similarity");
1053 const size_t result_count = planner_data.size();
1054 size_t unsolved = std::count_if(solved.begin(), solved.end(), [](
bool s) { return !s; });
1055 std::vector<double> average_distances(responses.size());
1056 for (
size_t first_traj_i = 0; first_traj_i < result_count; ++first_traj_i)
1059 if (!solved[first_traj_i])
1061 average_distances[first_traj_i] = std::numeric_limits<double>::max();
1065 for (
size_t second_traj_i = first_traj_i + 1; second_traj_i < result_count; ++second_traj_i)
1068 if (!solved[second_traj_i])
1076 double trajectory_distance;
1081 average_distances[first_traj_i] += trajectory_distance;
1082 average_distances[second_traj_i] += trajectory_distance;
1085 average_distances[first_traj_i] /= result_count - unsolved - 1;
1089 for (
size_t i = 0; i < result_count; ++i)
1095 double& result_distance)
1098 if (traj_first.
empty() || traj_second.
empty())
1102 size_t pos_first = 0;
1103 size_t pos_second = 0;
1113 double total_distance = 0;
1119 total_distance += current_distance;
1121 if (pos_first == max_pos_first && pos_second == max_pos_second)
1125 bool can_up_first = pos_first < max_pos_first;
1126 bool can_up_second = pos_second < max_pos_second;
1127 bool can_up_both = can_up_first && can_up_second;
1130 double up_both = std::numeric_limits<double>::max();
1131 double up_first = std::numeric_limits<double>::max();
1132 double up_second = std::numeric_limits<double>::max();
1141 if (can_up_both && up_both < up_first && up_both < up_second)
1145 current_distance = up_both;
1147 else if ((can_up_first && up_first < up_second) || !can_up_second)
1150 current_distance = up_first;
1152 else if (can_up_second)
1155 current_distance = up_second;
1159 result_distance = total_distance /
static_cast<double>(steps);
1167 size_t num_planners = 0;
1168 for (
const std::pair<
const std::string, std::vector<std::string>>& pipeline :
options.planning_pipelines)
1170 num_planners += pipeline.second.size();
1172 num_planners +=
options.parallel_planning_pipelines.size();
1174 std::string hostname = [&]() {
1175 static const int BUF_SIZE = 1024;
1176 char buffer[BUF_SIZE];
1177 int err = gethostname(buffer,
sizeof(buffer));
1180 return std::string();
1184 buffer[BUF_SIZE - 1] =
'\0';
1185 return std::string(buffer);
1188 if (hostname.empty())
1190 hostname =
"UNKNOWN";
1194 std::string filename =
options.output_directory;
1195 if (!filename.empty() && filename[filename.size() - 1] !=
'/')
1197 filename.append(
"/");
1201 std::filesystem::create_directories(filename);
1204 filename += (
options.benchmark_name.empty() ?
"" :
options.benchmark_name +
"_") + benchmark_request.
name +
"_" +
1205 hostname +
"_" + start_time +
".log";
1208 std::ofstream out(filename.c_str());
1211 RCLCPP_ERROR(
getLogger(),
"Failed to open '%s' for benchmark output", filename.c_str());
1216 out <<
"MoveIt version " << MOVEIT_VERSION_STR <<
'\n';
1217 out <<
"Experiment " << benchmark_request.
name <<
'\n';
1218 out <<
"Running on " << hostname <<
'\n';
1219 out <<
"Starting at " << start_time <<
'\n';
1222 moveit_msgs::msg::PlanningScene scene_msg;
1224 out <<
"<<<|" <<
'\n';
1225 out <<
"Motion plan request:" <<
'\n'
1226 <<
" planner_id: " << benchmark_request.
request.planner_id <<
'\n'
1227 <<
" group_name: " << benchmark_request.
request.group_name <<
'\n'
1228 <<
" num_planning_attempts: " << benchmark_request.
request.num_planning_attempts <<
'\n'
1229 <<
" allowed_planning_time: " << benchmark_request.
request.allowed_planning_time <<
'\n';
1230 out <<
"Planning scene:" <<
'\n'
1231 <<
" scene_name: " << scene_msg.name <<
'\n'
1232 <<
" robot_model_name: " << scene_msg.robot_model_name <<
'\n'
1236 out <<
"0 is the random seed" <<
'\n';
1237 out << benchmark_request.
request.allowed_planning_time <<
" seconds per run" <<
'\n';
1239 out <<
"-1 MB per run" <<
'\n';
1240 out <<
options.runs <<
" runs per planner" <<
'\n';
1241 out << benchmark_duration <<
" seconds spent to collect the data" <<
'\n';
1244 out <<
"0 enum types" <<
'\n';
1246 out << num_planners <<
" planners" <<
'\n';
1252 for (
const std::pair<
const std::string, std::vector<std::string>>& pipeline :
options.planning_pipelines)
1254 for (std::size_t i = 0; i < pipeline.second.size(); ++i, ++run_id)
1257 out << pipeline.second[i] <<
" (" << pipeline.first <<
')' <<
'\n';
1261 out <<
"0 common properties" <<
'\n';
1264 std::set<std::string> properties_set;
1267 for (PlannerRunData::const_iterator pit = planner_run_data.begin(); pit != planner_run_data.end();
1269 properties_set.insert(pit->first);
1273 out << properties_set.size() <<
" properties for each run" <<
'\n';
1274 for (
const std::string& property : properties_set)
1275 out <<
property <<
'\n';
1284 for (
const std::string& property : properties_set)
1287 PlannerRunData::const_iterator runit = planner_run_data.find(property);
1288 if (runit != planner_run_data.end())
1289 out << runit->second;
1299 for (
const std::pair<
const std::string, std::vector<std::pair<std::string, std::string>>>& parallel_pipeline :
1300 options.parallel_planning_pipelines)
1303 out << parallel_pipeline.first <<
" (" << parallel_pipeline.first <<
")" <<
'\n';
1307 out <<
"0 common properties" <<
'\n';
1310 std::set<std::string> properties_set;
1314 for (PlannerRunData::const_iterator pit = planner_run_data.begin(); pit != planner_run_data.end(); ++pit)
1316 properties_set.insert(pit->first);
1321 out << properties_set.size() <<
" properties for each run" <<
'\n';
1322 for (
const std::string& property : properties_set)
1323 out <<
property <<
'\n';
1332 for (
const std::string& property : properties_set)
1335 PlannerRunData::const_iterator runit = planner_run_data.find(property);
1336 if (runit != planner_run_data.end())
1337 out << runit->second;
1349 RCLCPP_INFO(
getLogger(),
"Benchmark results saved to '%s'", filename.c_str());
boost::posix_time::ptime toBoost(const std::chrono::time_point< Clock, Duration > &from)
Representation of a robot's state. This includes position, velocity, acceleration and effort.
double distance(const RobotState &other) const
Return the sum of joint distances to "other" state. An L1 norm. Only considers active joints.
bool satisfiesBounds(double margin=0.0) const
bool loadPlanningScene(const std::string &scene_name, moveit_msgs::msg::PlanningScene &scene_msg)
Load the planning scene with the given name from the warehouse.
void computeAveragePathSimilarities(PlannerBenchmarkData &planner_data, const std::vector< planning_interface::MotionPlanDetailedResponse > &responses, const std::vector< bool > &solved)
bool loadQueries(const std::string ®ex, const std::string &scene_name, std::vector< BenchmarkRequest > &queries)
Load all motion plan requests matching the given regular expression from the warehouse.
void createRequestCombinations(const BenchmarkRequest &benchmark_request, const std::vector< StartState > &start_states, const std::vector< PathConstraints > &path_constraints, std::vector< BenchmarkRequest > &combos)
Duplicate the given benchmark request for all combinations of start states and path constraints.
std::vector< PlannerRunData > PlannerBenchmarkData
Structure to hold information for a single planner's benchmark data.
rclcpp::Node::SharedPtr node_
planning_scene::PlanningScenePtr planning_scene_
std::vector< PlannerStartEventFunction > planner_start_functions_
warehouse_ros::DatabaseLoader db_loader_
bool computeTrajectoryDistance(const robot_trajectory::RobotTrajectory &traj_first, const robot_trajectory::RobotTrajectory &traj_second, double &result_distance)
void addQueryStartEvent(const QueryStartEventFunction &func)
std::shared_ptr< moveit_warehouse::ConstraintsStorage > constraints_storage_
std::shared_ptr< moveit_warehouse::PlanningSceneStorage > planning_scene_storage_
std::function< void(const moveit_msgs::msg::MotionPlanRequest &request, PlannerBenchmarkData &benchmark_data)> PlannerCompletionEventFunction
std::vector< QueryCompletionEventFunction > query_end_functions_
std::shared_ptr< moveit_warehouse::TrajectoryConstraintsStorage > trajectory_constraints_storage_
std::function< void(const moveit_msgs::msg::MotionPlanRequest &request, planning_scene::PlanningScenePtr)> QueryCompletionEventFunction
Definition of a query-end benchmark event function. Invoked after a query has finished benchmarking.
std::shared_ptr< moveit_cpp::MoveItCpp > moveit_cpp_
virtual void collectMetrics(PlannerRunData &metrics, const planning_interface::MotionPlanDetailedResponse &motion_plan_response, bool solved, double total_time)
std::vector< QueryStartEventFunction > query_start_functions_
bool loadPathConstraints(const std::string ®ex, std::vector< PathConstraints > &constraints)
Load all constraints matching the given regular expression from the warehouse.
std::vector< PreRunEventFunction > pre_event_functions_
void runBenchmark(moveit_msgs::msg::MotionPlanRequest request, const BenchmarkOptions &options)
Execute the given motion plan request on the set of planners for the set number of runs.
void addPreRunEvent(const PreRunEventFunction &func)
BenchmarkExecutor(const rclcpp::Node::SharedPtr &node, const std::string &robot_description_param="robot_description")
virtual bool runBenchmarks(const BenchmarkOptions &options)
std::vector< PlannerBenchmarkData > benchmark_data_
virtual bool loadBenchmarkQueryData(const BenchmarkOptions &options, moveit_msgs::msg::PlanningScene &scene_msg, std::vector< StartState > &start_states, std::vector< PathConstraints > &path_constraints, std::vector< PathConstraints > &goal_constraints, std::vector< TrajectoryConstraints > &traj_constraints, std::vector< BenchmarkRequest > &queries)
Initialize benchmark query data from start states and constraints.
std::vector< PostRunEventFunction > post_event_functions_
virtual bool initializeBenchmarks(const BenchmarkOptions &options, moveit_msgs::msg::PlanningScene &scene_msg, std::vector< BenchmarkRequest > &queries)
void addPlannerCompletionEvent(const PlannerCompletionEventFunction &func)
std::shared_ptr< planning_scene_monitor::PlanningSceneMonitor > planning_scene_monitor_
void addPlannerStartEvent(const PlannerStartEventFunction &func)
void addQueryCompletionEvent(const QueryCompletionEventFunction &func)
bool loadStates(const std::string ®ex, std::vector< StartState > &start_states)
Load all states matching the given regular expression from the warehouse.
bool pipelinesExist(const std::map< std::string, std::vector< std::string >> &planners)
Check that the desired planning pipelines exist.
std::function< void(const moveit_msgs::msg::MotionPlanRequest &request, const planning_interface::MotionPlanDetailedResponse &response, PlannerRunData &run_data)> PostRunEventFunction
Definition of a post-run benchmark event function. Invoked immediately after each planner calls solve...
std::function< void(moveit_msgs::msg::MotionPlanRequest &request)> PreRunEventFunction
Definition of a pre-run benchmark event function. Invoked immediately before each planner calls solve...
std::vector< PlannerCompletionEventFunction > planner_completion_functions_
std::shared_ptr< moveit_warehouse::RobotStateStorage > robot_state_storage_
virtual ~BenchmarkExecutor()
std::function< void(const moveit_msgs::msg::MotionPlanRequest &request, planning_scene::PlanningScenePtr)> QueryStartEventFunction
Definition of a query-start benchmark event function. Invoked before a new query is benchmarked.
virtual void writeOutput(const BenchmarkRequest &benchmark_request, const std::string &start_time, double benchmark_duration, const BenchmarkOptions &options)
bool initialize(const std::vector< std::string > &plugin_classes)
std::shared_ptr< moveit_warehouse::PlanningSceneWorldStorage > planning_scene_world_storage_
std::function< void(const moveit_msgs::msg::MotionPlanRequest &request, PlannerBenchmarkData &benchmark_data)> PlannerStartEventFunction
bool loadTrajectoryConstraints(const std::string ®ex, std::vector< TrajectoryConstraints > &constraints)
Load all trajectory constraints from the warehouse that match the given regular expression.
void addPostRunEvent(const PostRunEventFunction &func)
void shiftConstraintsByOffset(moveit_msgs::msg::Constraints &constraints, const std::vector< double > &offset)
std::map< std::string, std::string > PlannerRunData
Structure to hold information for a single run of a planner.
Maintain a sequence of waypoints and the time durations between these waypoints.
std::size_t getWayPointCount() const
const moveit::core::RobotState & getWayPoint(std::size_t index) const
locale-agnostic conversion functions from floating point numbers to strings
rclcpp::Logger getLogger()
Vec3fX< details::Vec3Data< double > > Vector3d
std::string toString(double d)
Convert a double to std::string using the classic C locale.
bool robotStateMsgToRobotState(const Transforms &tf, const moveit_msgs::msg::RobotState &robot_state, RobotState &state, bool copy_attached_bodies=true)
Convert a robot state msg (with accompanying extra transforms) to a MoveIt robot state.
::planning_interface::MotionPlanResponse getShortestSolution(const std::vector<::planning_interface::MotionPlanResponse > &solutions)
Function that returns the shortest solution out of a vector of solutions based on robot_trajectory::p...
warehouse_ros::MessageWithMetadata< moveit_msgs::msg::RobotState >::ConstPtr RobotStateWithMetadata
warehouse_ros::MessageWithMetadata< moveit_msgs::msg::PlanningScene >::ConstPtr PlanningSceneWithMetadata
warehouse_ros::MessageWithMetadata< moveit_msgs::msg::TrajectoryConstraints >::ConstPtr TrajectoryConstraintsWithMetadata
warehouse_ros::MessageWithMetadata< moveit_msgs::msg::PlanningSceneWorld >::ConstPtr PlanningSceneWorldWithMetadata
warehouse_ros::MessageWithMetadata< moveit_msgs::msg::MotionPlanRequest >::ConstPtr MotionPlanRequestWithMetadata
warehouse_ros::MessageWithMetadata< moveit_msgs::msg::Constraints >::ConstPtr ConstraintsWithMetadata
rclcpp::Logger getLogger(const std::string &name)
Creates a namespaced logger.
moveit_msgs::msg::MotionPlanRequest MotionPlanRequest
std::optional< double > smoothness(const RobotTrajectory &trajectory)
Calculate the smoothness of a given trajectory.
double pathLength(const RobotTrajectory &trajectory)
Calculate the path length of a given trajectory based on the accumulated robot state distances....
Representation of a collision checking request.
Representation of a collision checking result.
bool collision
True if collision was found, false otherwise.
Planner parameters provided with the MotionPlanRequest.
std::vector< PlanRequestParameters > plan_request_parameter_vector
Planner parameters provided with the MotionPlanRequest.
moveit_msgs::msg::MotionPlanRequest request
std::vector< moveit_msgs::msg::Constraints > constraints
moveit_msgs::msg::RobotState state
moveit_msgs::msg::TrajectoryConstraints constraints
Options to configure a benchmark experiment. The configuration is provided via ROS2 parameters.
std::vector< std::string > description
std::vector< double > processing_time
std::vector< robot_trajectory::RobotTrajectoryPtr > trajectory