|
Nav2 Navigation Stack - lyrical
lyrical
ROS 2 Navigation Stack
|
| ►Nbackup_tester | |
| CBackupTest | |
| ►Nbehavior_server | |
| CBehaviorServer | An server hosting a map of behavior plugins |
| ►Nbt_nodes_validation | |
| ►Nvalidate_bt_xml_nodes | |
| CPortData | |
| ►Ncostmap_queue | |
| CCellData | Storage for cell information used during queue expansion |
| CCostmapQueue | |
| CLimitedCostmapQueue | Extension of Costmap Queue where distances are limited to a given distance from source cells |
| CMapBasedQueue | Templatized interface for a priority queue |
| ►Ndrive_tester | |
| CDriveTest | |
| ►Ndwb_core | |
| CDWBLocalPlanner | Plugin-based flexible controller |
| CIllegalTrajectoryException | Thrown when one of the critics encountered a fatal error |
| CIllegalTrajectoryTracker | |
| CNoLegalTrajectoriesException | Thrown when all the trajectories explored are illegal |
| CDWBPublisher | Consolidation of all the publishing logic for the DWB Local Planner |
| CTrajectoryCritic | Evaluates a Trajectory2D to produce a score |
| CTrajectoryGenerator | Interface for iterating through possible velocities and creating trajectories |
| ►Ndwb_critics | |
| CBaseObstacleCritic | Uses costmap 2d to assign negative costs if a circular robot would collide at any point of the trajectory |
| CGoalAlignCritic | Scores trajectories based on whether the robot ends up pointing toward the eventual goal |
| CGoalDistCritic | Scores trajectories based on how far along the global path they end up |
| CLineIterator | |
| ►CMapGridCritic | Breadth-first scoring of all the cells in the costmap |
| CMapGridQueue | Subclass of CostmapQueue that avoids Obstacles and Unknown Values |
| CObstacleFootprintCritic | Uses costmap 2d to assign negative costs if robot footprint is in obstacle on any point of the trajectory |
| COscillationCritic | Checks to see whether the sign of the commanded velocity flips frequently |
| CPathAlignCritic | Scores trajectories based on how far from the global path the front of the robot ends up |
| CPathDistCritic | Scores trajectories based on how far from the global path they end up |
| CPreferForwardCritic | Penalize trajectories with move backwards and/or turn too much |
| CRotateToGoalCritic | Forces the commanded trajectories to only be rotations if within a certain distance window |
| CTwirlingCritic | Penalize trajectories with rotational velocities |
| ►Ndwb_plugins | |
| CKinematicParameters | A struct containing one representation of the robot's kinematics |
| CKinematicsHandler | A class managing the representation of the robot's kinematics |
| CLimitedAccelGenerator | Limits the acceleration in the generated trajectories to a fraction of the simulated time |
| COneDVelocityIterator | An iterator for generating a number of samples in a range |
| CStandardTrajectoryGenerator | Standard DWA-like trajectory generator |
| CVelocityIterator | |
| CXYThetaIterator | |
| ►Nlattice_primitives | |
| ►Ngenerate_motion_primitives | |
| CHeaderDict | |
| ►Nlattice_generator | |
| CConfigDict | |
| ►CLatticeGenerator | |
| CFlip | |
| CMotionModel | |
| ►Ntrajectory | |
| CTrajectoryParameters | |
| CPath | |
| CTrajectory | |
| ►Ntrajectory_generator | |
| CTrajectoryGeneratorConfigDict | |
| CTrajectoryGenerator | |
| ►Nlaunch | |
| ►Nunique_multi_tb3_simulation_launch | |
| CRobotConfig | |
| ►Nmppi | |
| ►Ncritics | |
| CCollisionCost | Utility for storing cost information |
| CCriticFunction | Abstract critic objective function to score trajectories |
| CConstraintCritic | Critic objective function for enforcing feasible constraints |
| CCostCritic | Critic objective function for avoiding obstacles using costmap's inflated cost |
| CGoalAngleCritic | |
| CGoalCritic | |
| CObstaclesCritic | |
| CPathAlignCritic | |
| CPathAngleCritic | |
| CPathFollowCritic | |
| CPreferForwardCritic | |
| CTwirlingCritic | |
| CVelocityDeadbandCritic | Critic objective function for enforcing feasible constraints |
| ►Nmodels | |
| CControlConstraints | Constraints on control |
| CSamplingStd | Noise parameters for sampling trajectories |
| CControl | A set of controls |
| CControlSequence | A control sequence over time (e.g. trajectory) |
| COptimizerSettings | Settings for the optimizer to use |
| CPath | Path represented as a tensor |
| CState | State information: velocities, controls, poses, speed |
| CTrajectories | Candidate Trajectories |
| ►Nutils | |
| CPose2D | |
| CCriticData | Data to pass to critics for scoring, including state, trajectories, pruned path, global goal, costs, and important parameters to share |
| CCriticManager | Manager of objective function plugins for scoring trajectories |
| CMotionModel | Abstract pluginlib class for modeling a vehicle |
| CAckermannMotionModel | Ackermann motion model |
| CDiffDriveMotionModel | Differential drive motion model |
| COmniMotionModel | Omnidirectional motion model |
| COptimalTrajectoryValidator | Abstract base class for validating optimal trajectories from MPPI optimization |
| COptimizer | Main algorithm optimizer of the MPPI Controller |
| CNoiseGenerator | Generates noise trajectories from optimal trajectory |
| CParametersHandler | Handles getting parameters and dynamic parameter changes |
| CTrajectoryVisualizer | Visualizes trajectories for debugging |
| ►Nnav2 | |
| ►Nqos | |
| CStandardTopicQoS | A QoS profile for standard reliable topics with a history of 10 messages |
| CLatchedPublisherQoS | A QoS profile for latched, reliable topics with a history of 1 messages |
| CLatchedSubscriptionQoS | A QoS profile for latched, reliable topics with a history of 10 messages |
| CSensorDataQoS | A QoS profile for best-effort sensor data with a history of 10 messages |
| CLifecycleNode | A lifecycle node wrapper to enable common Nav2 needs such as manipulating parameters |
| CNodeThread | A background thread to process node/executor callbacks |
| CRate | A sim-time-aware rate for Nav2 loops |
| CServiceClient | A simple wrapper on ROS2 services client |
| CServiceServer | A simple wrapper on ROS2 services server |
| ►CSimpleActionServer | An action server wrapper to make applications simpler using Actions |
| Chas_error_code | |
| Chas_error_code< T, std::void_t< decltype(T::error_code)> > | |
| Chas_error_msg | SFINAE (Substitution Failure Is Not An Error) to check for existence of error_code and error_msg in ActionT::Result This allows for ActionT::Result messages that do not contain an error_code or error_msg such as test_msgs::action::Fibonacci |
| Chas_error_msg< T, std::void_t< decltype(T::error_msg)> > | |
| CTransformListener | Nav2 type wrapper for tf2_ros::TransformListener |
| CTransformBroadcaster | Nav2 type wrapper for tf2_ros::TransformBroadcaster |
| CStaticTransformBroadcaster | Nav2 type wrapper for tf2_ros::StaticTransformBroadcaster |
| CMessageFilter | Nav2 type wrapper for tf2_ros::MessageFilter |
| ►Nnav2_amcl | |
| ►CAmclNode | |
| Camcl_hyp_t | |
| CPoint2D | |
| Cangleutils | |
| CDifferentialMotionModel | |
| CMotionModel | An abstract motion model class |
| COmniMotionModel | |
| CLaser | |
| CLaserData | |
| CBeamModel | |
| CLikelihoodFieldModel | |
| CLikelihoodFieldModelProb | |
| ►Nnav2_behavior_tree | |
| CBTInfo | A struct to hold Behavior Tree ID information |
| CBehaviorTreeEngine | A class to create and handle behavior trees |
| CBtActionNode | Abstract class representing an action based BT node |
| CBtActionServer | An action server that uses behavior tree to execute an action |
| CBtCancelActionNode | Abstract class representing an action for cancelling BT node |
| CBtServiceNode | Abstract class representing a service based BT node |
| CAppendGoalPoseToGoals | |
| CAssistedTeleopAction | A nav2_behavior_tree::BtActionNode class that wraps nav2_msgs::action::AssistedTeleop |
| CAssistedTeleopCancel | A nav2_behavior_tree::BtActionNode class that wraps nav2_msgs::action::BackUp |
| CBackUpAction | A nav2_behavior_tree::BtActionNode class that wraps nav2_msgs::action::BackUp |
| CBackUpCancel | A nav2_behavior_tree::BtActionNode class that wraps nav2_msgs::action::BackUp |
| CCheckPoseOccupancy | A nav2_behavior_tree::BtServiceNode class that checks if a pose is occupied by calling the GetCosts service on the costmap |
| CCheckStopStatus | A nav2_behavior_tree::ActionNodeBase class that checks if the robot has been stopped for a specified duration |
| CClearEntireCostmapService | A nav2_behavior_tree::BtServiceNode class that wraps nav2_msgs::srv::ClearEntireCostmap |
| CClearCostmapExceptRegionService | A nav2_behavior_tree::BtServiceNode class that wraps nav2_msgs::srv::ClearCostmapExceptRegion |
| CClearCostmapAroundRobotService | A nav2_behavior_tree::BtServiceNode class that wraps nav2_msgs::srv::ClearCostmapAroundRobot |
| CClearCostmapAroundPoseService | A nav2_behavior_tree::BtServiceNode class that wraps nav2_msgs::srv::ClearCostmapAroundPose |
| CComputeAndTrackRouteAction | A nav2_behavior_tree::BtActionNode class that wraps nav2_msgs::action::ComputeAndTrackRoute |
| CComputeAndTrackRouteCancel | A nav2_behavior_tree::BtActionNode class that wraps nav2_msgs::action::ComputeAndTrackRoute cancellation |
| CComputePathThroughPosesAction | A nav2_behavior_tree::BtActionNode class that wraps nav2_msgs::action::ComputePathThroughPoses |
| CComputePathToPoseAction | A nav2_behavior_tree::BtActionNode class that wraps nav2_msgs::action::ComputePathToPose |
| CComputeRouteAction | A nav2_behavior_tree::BtActionNode class that wraps nav2_msgs::action::ComputeRoute |
| CConcatenatePaths | A BT::ActionNodeBase to shorten path by some distance |
| CControllerCancel | A nav2_behavior_tree::BtActionNode class that wraps nav2_msgs::action::FollowPath |
| CControllerSelector | The ControllerSelector behavior is used to switch the controller that will be used by the controller server. It subscribes to a topic "controller_selector" to get the decision about what controller must be used. It is usually used before of the FollowPath. The selected_controller output port is passed to controller_id input port of the FollowPath |
| CDriveOnHeadingAction | A nav2_behavior_tree::BtActionNode class that wraps nav2_msgs::action::DriveOnHeading |
| CDriveOnHeadingCancel | A nav2_behavior_tree::BtActionNode class that wraps nav2_msgs::action::DriveOnHeading |
| CExtractRouteNodesAsGoals | |
| CFollowObjectAction | Nav2_behavior_tree::BtActionNode class that wraps nav2_msgs/FollowObject |
| CFollowObjectCancel | A nav2_behavior_tree::BtActionNode class that wraps nav2_msgs::action::FollowObject |
| CFollowPathAction | A nav2_behavior_tree::BtActionNode class that wraps nav2_msgs::action::FollowPath |
| CGetCurrentPoseAction | A BT::ActionNodeBase to shorten path by some distance |
| CGetNextFewGoals | |
| CGetPoseFromPath | |
| CGoalCheckerSelector | The GoalCheckerSelector behavior is used to switch the goal checker of the controller server. It subscribes to a topic "goal_checker_selector" to get the decision about what goal_checker must be used. It is usually used before of the FollowPath. The selected_goal_checker output port is passed to goal_checker_id input port of the FollowPath |
| CNavigateThroughPosesAction | A nav2_behavior_tree::BtActionNode class that wraps nav2_msgs::action::NavigateThroughPoses |
| CNavigateToPoseAction | A nav2_behavior_tree::BtActionNode class that wraps nav2_msgs::action::NavigateToPose |
| CPathHandlerSelector | The PathHandlerSelector behavior is used to switch the path handler of the controller server. It subscribes to a topic "path_handler_selector" to get the decision about what path_handler must be used. It is usually used before the FollowPath. The selected_path_handler output port is passed to path_handler_id input port of the FollowPath |
| CPlannerSelector | The PlannerSelector behavior is used to switch the planner that will be used by the planner server. It subscribes to a topic "planner_selector" to get the decision about what planner must be used. It is usually used before of the ComputePathToPoseAction. The selected_planner output port is passed to planner_id input port of the ComputePathToPoseAction |
| CProgressCheckerSelector | The ProgressCheckerSelector behavior is used to switch the progress checker of the controller server. It subscribes to a topic "progress_checker_selector" to get the decision about what progress_checker must be used. It is usually used before of the FollowPath. The selected_progress_checker output port is passed to progress_checker_id input port of the FollowPath |
| CReinitializeGlobalLocalizationService | A nav2_behavior_tree::BtServiceNode class that wraps nav2_msgs::srv::Empty |
| CRemoveInCollisionGoals | A nav2_behavior_tree::BtServiceNode class that removes goals that are in collision in on the global costmap wraps nav2_msgs::srv::GetCosts |
| CRemovePassedGoals | A BT::ActionNodeBase that removes goals that the robot passed near to |
| CSmoothPathAction | A nav2_behavior_tree::BtActionNode class that wraps nav2_msgs::action::SmoothPath |
| CSmootherSelector | The SmootherSelector behavior is used to switch the smoother that will be used by the smoother server. It subscribes to a topic "smoother_selector" to get the decision about what smoother must be used. It is usually used before of the FollowPath. The selected_smoother output port is passed to smoother_id input port of the FollowPath |
| CSpinAction | A nav2_behavior_tree::BtActionNode class that wraps nav2_msgs::action::Spin |
| CSpinCancel | A nav2_behavior_tree::BtActionNode class that wraps nav2_msgs::action::Wait |
| CToggleCollisionMonitorService | A nav2_behavior_tree::BtServiceNode class that wraps nav2_msgs::srv::Toggle |
| CTruncatePath | A BT::ActionNodeBase to shorten path by some distance |
| CTruncatePathLocal | A BT::ActionNodeBase to shorten path to some distance around robot |
| CValidatePath | A nav2_behavior_tree::BtServiceNode class that validates a path by calling the IsPathValid service on the path provided in the input port |
| CWaitAction | A nav2_behavior_tree::BtActionNode class that wraps nav2_msgs::action::Wait |
| CWaitCancel | A nav2_behavior_tree::BtActionNode class that wraps nav2_msgs::action::Wait |
| CAreErrorCodesPresent | |
| CArePosesNearCondition | A BT::ConditionNode that returns SUCCESS when a specified goal is reached and FAILURE otherwise |
| CDistanceTraveledCondition | A BT::ConditionNode that returns SUCCESS every time the robot travels a specified distance and FAILURE otherwise |
| CGloballyUpdatedGoalCondition | A BT::ConditionNode that returns SUCCESS when goal is updated on the blackboard and FAILURE otherwise |
| CGoalReachedCondition | A BT::ConditionNode that returns SUCCESS when a specified goal is reached and FAILURE otherwise |
| CGoalUpdatedCondition | A BT::ConditionNode that returns SUCCESS when goal is updated on the blackboard and FAILURE otherwise |
| CInitialPoseReceived | A BT::ConditionNode that returns SUCCESS if initial pose has been received and FAILURE otherwise |
| CIsBatteryChargingCondition | A BT::ConditionNode that listens to a battery topic and returns SUCCESS when battery is charging and FAILURE otherwise |
| CIsBatteryLowCondition | A BT::ConditionNode that listens to a battery topic and returns SUCCESS when battery is low and FAILURE otherwise |
| CIsGoalNearbyCondition | A BT::ConditionNode that returns SUCCESS when remaining length of the current planned path is less than proximity_threshold and FAILURE otherwise |
| CIsStuckCondition | A BT::ConditionNode that tracks robot odometry and returns SUCCESS if robot is stuck somewhere and FAILURE otherwise |
| CIsWithinPathTrackingBoundsCondition | A BT::ConditionNode that returns SUCCESS when the current path tracking error is within specified bounds and FAILURE otherwise |
| CPathExpiringTimerCondition | A BT::ConditionNode that returns SUCCESS every time a specified time period passes and FAILURE otherwise |
| CTimeExpiredCondition | A BT::ConditionNode that returns SUCCESS every time a specified time period passes and FAILURE otherwise |
| CTransformAvailableCondition | A BT::ConditionNode that returns SUCCESS if there is a valid transform between two specified frames and FAILURE otherwise |
| CWouldAControllerRecoveryHelp | |
| CWouldAPlannerRecoveryHelp | |
| CWouldARouteRecoveryHelp | |
| CWouldASmootherRecoveryHelp | |
| CNonblockingSequence | Type of sequence node that keeps tickinng through all the children until all children return SUCCESS |
| CPauseResumeController | Controlled through service calls to pause and resume the execution of the tree It has one mandatory child for the RESUMED, and three optional for the PAUSED state, the ON_PAUSE event and the ON_RESUME event. It has two input ports: |
| CPersistentSequenceNode | The PersistentSequenceNode is similar to the SequenceNode, but it stores the index of the last running child in the blackboard (key: "current_child_idx"), and it does not reset the index when it got halted. It used to tick children in an ordered sequence. If any child returns RUNNING, previous children will NOT be ticked again |
| CPipelineSequence | Type of sequence node that re-ticks previous children when a child returns running |
| CRecoveryNode | The RecoveryNode has only two children and returns SUCCESS if and only if the first child returns SUCCESS |
| CRoundRobinNode | Type of sequence node that ticks children in a round-robin fashion |
| CDistanceController | A BT::DecoratorNode that ticks its child every time the robot travels a specified distance |
| CGoalUpdatedController | A BT::DecoratorNode that ticks its child if the goal was updated |
| CGoalUpdater | A BT::DecoratorNode that subscribes to a goal topic and updates the current goal on the blackboard |
| CPathLongerOnApproach | A BT::DecoratorNode that ticks its child every time when the length of the new path is smaller than the old one by the length given by the user |
| CRateController | A BT::DecoratorNode that ticks its child at a specified rate |
| CSingleTrigger | A BT::DecoratorNode that triggers its child only once and returns FAILURE for every succeeding tick (reset when halted) |
| CSpeedController | A BT::DecoratorNode that ticks its child every at a rate proportional to the speed of the robot. If the robot travels faster, this node will tick its child at a higher frequency and reduce the tick frequency if the robot slows down |
| CRosTopicLogger | A class to publish BT logs on BT status change |
| CLoopRate | |
| ►Nnav2_behaviors | |
| CAssistedTeleop | An action server behavior for assisted teleop |
| CBackUp | |
| CDriveOnHeading | An action server Behavior for spinning in |
| CSpin | An action server behavior for spinning in |
| CWait | An action server behavior for waiting a fixed duration |
| CResultStatus | |
| CTimedBehavior | |
| ►Nnav2_bt_navigator | |
| CBtNavigator | An action server that uses behavior tree for navigating a robot to its goal position |
| CNavigateThroughPosesNavigator | A navigator for navigating to a a bunch of intermediary poses |
| CNavigateToPoseNavigator | A navigator for navigating to a specified pose |
| ►Nnav2_collision_monitor | |
| CCircle | Circle shape implementation. For STOP/SLOWDOWN/LIMIT model it represents zone around the robot while for APPROACH model it represents robot footprint |
| CCollisionDetector | Collision Monitor ROS2 node |
| CCollisionMonitor | Collision Monitor ROS2 node |
| CCostmapSource | Reads nav2_msgs::msg::Costmap and produces obstacle points for Collision Monitor |
| CExclusionZone | Region that removes (masks out) source points falling inside it |
| CPointCloud | Implementation for pointcloud source |
| CPolygon | Basic polygon shape class. For STOP/SLOWDOWN/LIMIT model it represents zone around the robot while for APPROACH model it represents robot footprint |
| CPolygonSource | Implementation for polygon source |
| CRange | Implementation for IR/ultrasound range sensor source |
| CScan | Implementation for laser scanner source |
| CSource | Basic data source class |
| CVelocity | Velocity for 2D model of motion |
| CPoint | Point with 2D collision-check coordinates and optional z from the source |
| CPose | 2D Pose |
| CAction | Action for robot |
| ►CVelocityPolygon | Velocity polygon class. This class contains all the points of the polygon and the expected condition of the velocity based polygon |
| CSubPolygonParameter | Custom struct to store the parameters of the sub-polygon |
| ►Nnav2_common | |
| ►Nlaunch | |
| ►Nhas_node_params | |
| CHasNodeParams | |
| ►Nlaunch_config_as_bool | |
| CLaunchConfigAsBool | |
| ►Nreplace_string | |
| CReplaceString | |
| ►Nrewritten_yaml | |
| CDictItemReference | |
| CRewrittenYaml | |
| ►Nnav2_constrained_smoother | |
| CConstrainedSmoother | Regulated pure pursuit controller plugin |
| CSmootherParams | |
| COptimizerParams | |
| CSmoother | |
| CSmootherCostFunction | Cost function for path smoothing with multiple terms including curvature, smoothness, distance from original and obstacle avoidance |
| ►Nnav2_controller | |
| CControllerServer | This class hosts variety of plugins of different algorithms to complete control tasks from the exposed FollowPath action server |
| CParameters | |
| CParameterHandler | Handles parameters and dynamic parameters for Controller Server |
| CAdaptiveToleranceGoalChecker | Goal Checker plugin with two tolerance tiers: a tight desired tolerance and a looser coarse tolerance. The robot is considered to have reached the goal if: (1) it reaches within the desired (tight) tolerance, OR (2) it is within the coarse tolerance AND the robot's velocity is below a stopped threshold for a configurable number of consecutive cycles, indicating it is no longer making useful progress toward the goal |
| CAxisGoalChecker | Goal Checker plugin that checks progress along the axis defined by the last segment of the path to the goal |
| CFeasiblePathHandler | This plugin manages the global plan by clipping it to the local segment, typically bounded by the local costmap size and transforming the resulting path into the odom frame |
| CPoseProgressChecker | This plugin is used to check the position and the angle of the robot to make sure that it is actually progressing or rotating towards a goal |
| CPositionGoalChecker | Goal Checker plugin that only checks XY position, ignoring orientation |
| CSimpleGoalChecker | Goal Checker plugin that only checks the position difference |
| CSimpleProgressChecker | This plugin is used to check the position of the robot to make sure that it is actually progressing towards a goal |
| CStoppedGoalChecker | Goal Checker plugin that checks the position difference and velocity |
| ►Nnav2_core | |
| CBehavior | Abstract interface for behaviors to adhere to with pluginlib |
| CFeedbackUtils | Navigator feedback utilities required to get transforms and reference frames |
| CNavigatorBase | Navigator interface to allow navigators to be stored in a vector and accessed via pluginlib due to templates. These functions will be implemented by BehaviorTreeNavigator, not the user. The user should implement the virtual methods from BehaviorTreeNavigator to implement their navigator action |
| CNavigatorMuxer | A class to control the state of the BT navigator by allowing only a single plugin to be processed at a time |
| CBehaviorTreeNavigator | Navigator interface that acts as a base class for all BT-based Navigator action's plugins All methods from NavigatorBase are marked as final so they may not be overridden by derived methods - instead, users should use the appropriate APIs provided after BT Action handling |
| CController | Controller interface that acts as a virtual base class for all controller plugins |
| CControllerException | |
| CInvalidController | |
| CControllerTFError | |
| CFailedToMakeProgress | |
| CPatienceExceeded | |
| CInvalidPath | |
| CNoValidControl | |
| CControllerTimedOut | |
| CGlobalPlanner | Abstract interface for global planners to adhere to with pluginlib |
| CGoalChecker | Function-object for checking whether a goal has been reached |
| CPathHandler | Function-object for handling the path from Planner Server |
| CPlannerException | |
| CInvalidPlanner | |
| CStartOccupied | |
| CGoalOccupied | |
| CStartOutsideMapBounds | |
| CGoalOutsideMapBounds | |
| CNoValidPathCouldBeFound | |
| CPlannerTimedOut | |
| CPlannerTFError | |
| CNoViapointsGiven | |
| CPlannerCancelled | |
| CProgressChecker | This class defines the plugin interface used to check the position of the robot to make sure that it is actually progressing towards a goal |
| CRouteException | |
| COperationFailed | |
| CNoValidRouteCouldBeFound | |
| CTimedOut | |
| CRouteTFError | |
| CNoValidGraph | |
| CIndeterminantNodesOnGraph | |
| CInvalidEdgeScorerUse | |
| CSmoother | Smoother interface that acts as a virtual base class for all smoother plugins |
| CSmootherException | |
| CInvalidSmoother | |
| CSmootherTimedOut | |
| CSmoothedPathInCollision | |
| CFailedToSmoothPath | |
| CWaypointTaskExecutor | Base class for creating a plugin in order to perform a specific task at waypoint arrivals |
| ►Nnav2_costmap_2d | |
| ►Nimgproc_impl | |
| ►Nout_of_bounds_policy | |
| CDoNothing | Boundary case object stub. Used as parameter of class Window. Dereferences a pointer to a pixel without any checks |
| CReplaceToZero | Boundary case object. Used as parameter of class Window. Dereferences a pointer to a existing pixel. If the pixel is out of bounds, it returns a ref to 0 |
| CEquivalenceLabelTrees | Union-find data structure Implementation of union-find data structure, described in reference article. Store rooted trees, where each node of a tree is a provisional label and each edge represents an equivalence between two labels |
| CWindow | Forward scan mask sliding window Provides an interface for access to neighborhood of the current pixel (includes three neighbors of the top row, the pixel to the left and the current one). In the illustration below, the current pixel is e. |a|b|c| |d|e| | | | | | |
| CEquivalenceLabelTreesBase | |
| CLabelOverflow | |
| CProcessPixel | The specializations of this class provide the definition of the pixel label |
| CProcessPixel< ConnectivityType::Way8 > | Define the label of a pixel in an 8-linked image |
| CProcessPixel< ConnectivityType::Way4 > | Define the label of a pixel in an 4-linked image |
| CGroupsRemover | Object to eliminate grouped noise on the image Stores a label tree that is reused |
| CAsymmetricPathSegment | |
| CAsymmetricInflationLayer | Costmap layer that inflates obstacles asymmetrically relative to the global path, biasing the navigable corridor toward one side |
| CClearCostmapService | Exposes services to clear costmap objects in inclusive/exclusive regions or completely |
| CMapLocation | |
| ►CCostmap2D | A 2D costmap provides a mapping between points in the world and their associated "costs" |
| CMarkCell | |
| CPolygonOutlineCells | |
| CCostmap2DPublisher | A tool to periodically publish visualization data from a Costmap2D |
| CCostmap2DROS | A ROS wrapper for a 2D Costmap. Handles subscribing to topics that provide observations about obstacles in either the form of PointCloud or LaserScan messages |
| CBinaryFilter | Reads in a speed restriction mask and enables a robot to dynamically adjust speed based on pose in map to slow in dangerous areas. Done via absolute speed setting or percentage of maximum speed |
| CCostmapFilter | : CostmapFilter basic class. It is inherited from Layer in order to avoid hidden problems when the shared handling of costmap_ resource (PR #1936) |
| CKeepoutFilter | Reads in a keepout mask and marks keepout regions in the map to prevent planning or control in restricted areas |
| CSpeedFilter | Reads in a speed restriction mask and enables a robot to dynamically adjust speed based on pose in map to slow in dangerous areas. Done via absolute speed setting or percentage of maximum speed |
| ►CZoneParameterFilter | Costmap filter that applies a configured set of ROS parameters based on the mask value at the robot's pose |
| CStateParamEntry | |
| CCostmapLayer | A costmap layer base class for costmap plugin layers. Rather than just a layer, this object also contains an internal costmap object to populate and maintain state |
| CCostmapSubscriber | Subscribes to the costmap via a ros topic |
| CCostmapTopicCollisionChecker | Using a costmap via a ros topic, this object is used to find if robot poses are in collision with the costmap environment |
| CImage | Image with pixels of type T Сan own data, be a wrapper over some memory buffer, or refer to a fragment of another image Pixels of one row are stored continuity. But rows continuity is not guaranteed. The distance (number of elements of type T) from row(i) to row(i + 1) is equal to step() |
| CMemoryBuffer | A memory buffer that can grow to an upper-bounded capacity |
| CDenoiseLayer | Layer filters noise-induced standalone obstacles (white costmap pixels) or small obstacles groups |
| CDistanceTransform | Efficient Euclidean distance transform using the Felzenszwalb-Huttenlocher algorithm |
| CCollisionCheckerException | Exceptions thrown if collision checker determines a pose is in collision with the environment costmap |
| CIllegalPoseException | Thrown when CollisionChecker encounters a fatal error |
| CFootprintCollisionChecker | Checker for collision with a footprint on a costmap |
| CFootprintSubscriber | Subscriber to the footprint topic to get current robot footprint (if changing) for use in collision avoidance |
| CInflationLayer | Layer to convolve costmap by robot's radius or footprint using Eigen-based Felzenszwalb-Huttenlocher O(n) distance transform for improved performance |
| CInflationLayerInterface | Abstract interface for inflation layers, providing common methods needed by navigation components regardless of the inflation implementation |
| CLayer | Abstract class for layered costmap plugin implementations |
| CLayeredCostmap | Instantiates different layer plugins and aggregates them into one score |
| CCellData | Storage for cell information used during obstacle inflation |
| CLegacyInflationLayer | Layer to convolve costmap by robot's radius or footprint to prevent collisions and largely simply collision checking |
| CObservation | Stores an observation in terms of a point cloud and the origin of the source |
| CObservationBuffer | Takes in point clouds from sensors, transforms them to the desired frame, and stores them |
| CObstacleLayer | Takes in laser and pointcloud data to populate into 2D costmap |
| CPluginContainerLayer | Holds a list of plugins and applies them only to the specific layer |
| CRangeSensorLayer | Takes in IR/Sonar/similar point measurement sensors and populates in costmap |
| CStaticLayer | Takes in a map generated from SLAM to add costs to costmap |
| CVoxelLayer | Takes laser and pointcloud data to populate a 3D voxel representation of the environment |
| ►Nnav2_graceful_controller | |
| CEgocentricPolarCoordinates | Egocentric polar coordinates defined as the difference between the robot pose and the target pose relative to the robot position and orientation |
| CGracefulController | Graceful controller plugin |
| CParameters | |
| CParameterHandler | Handles parameters and dynamic parameters for GracefulMotionController |
| CSmoothControlLaw | Smooth control law for graceful motion based on "A smooth control law for graceful motion" (Jong Jin Park and Benjamin Kuipers) |
| ►Nnav2_lifecycle_manager | |
| CLifecycleManager | Implements service interface to transition the lifecycle nodes of Nav2 stack. It receives transition request and then uses lifecycle interface to change lifecycle node's state |
| CLifecycleManagerClient | |
| ►Nnav2_loopback_sim | |
| CClockPublisher | Publishes simulated clock to /clock using wall time. Uses wall timers so that it works correctly even when owned by a node with use_sim_time=true. Supports speed_factor to run sim time faster or slower than real time |
| CLoopbackSimulator | A loopback simulator that replaces a physics simulator to create a frictionless, inertialess, and collisionless simulation environment. It accepts cmd_vel messages and publishes odometry & TF messages based on the cumulative velocities received to mimic global localization and simulation. It also accepts initialpose messages to set the initial pose of the robot |
| ►Nnav2_map_server | |
| CCostmapFilterInfoServer | |
| CLoadParameters | |
| CSaveParameters | |
| CMapSaver | A class that provides map saving methods and services |
| CMapServer | Parses the map yaml file and creates a service and a publisher that provides occupancy grid |
| CVectorObjectServer | Vector Object server node |
| CShape | Basic class, other vector objects to be inherited from |
| CPolygon | Polygon shape class |
| CCircle | Circle shape class |
| CMapAction | Functor class used in raytraceLine algorithm |
| ►Nnav2_mppi_controller | |
| CMPPIController | |
| ►Nnav2_navfn_planner | |
| CNavFn | Navigation function class. Holds buffers for costmap, navfn map. Maps are pixel-based. Origin is upper left, x is right, y is down |
| CNavfnPlanner | |
| CParameters | |
| CParameterHandler | Handles parameters and dynamic parameters for Navfn |
| ►Nnav2_planner | |
| CIsPathValidService | Service to determine if a path is still valid given the current costmap state |
| CParameters | |
| CParameterHandler | Handles parameters and dynamic parameters for Planner Server |
| CPlannerServer | An action server implements the behavior tree's ComputePathToPose interface and hosts various plugins of different algorithms to compute plans |
| ►Nnav2_regulated_pure_pursuit_controller | |
| ►Ndynamic_window_pure_pursuit | |
| CDynamicWindowBounds | |
| CCollisionChecker | Checks for collision based on a RPP control command |
| CParameters | |
| CParameterHandler | Handles parameters and dynamic parameters for RPP |
| CRegulatedPurePursuitController | Regulated pure pursuit controller plugin |
| ►Nnav2_rotation_shim_controller | |
| CRotationShimController | Rotate to rough path heading controller shim plugin |
| CParameters | |
| CParameterHandler | Handles parameters and dynamic parameters for Rotation Shim |
| ►Nnav2_route | |
| ►NGoalIntentSearch | |
| CBreadthFirstSearch | |
| CLoSCollisionChecker | |
| CCornerArc | A class used to smooth corners defined by the edges and nodes of the route graph. Used with path converter to output a corner smoothed plan |
| CEdgeScorer | An class to encapsulate edge scoring logic for plugins and different user specified algorithms to influence graph search. It has access to the edge, which in turn has access to the parent and child node of the connection. It also contains action and arbitrary user-defined metadata to enable edge scoring logic based on arbitrary properties of the graph you select (e.g. some regions have a multiplier, some actions are discouraged with higher costs like having to go through a door, edges with reduced speed limits are proportionally less preferred for optimality relative to the distance the edge represents to optimize time to goal) |
| CGoalIntentExtractor | Extracts the start and goal nodes in the graph to use for the routing request from the action request. This may use additional information about the environment or simply find the corresponding nodes specified in the request |
| CGraphLoader | An action server to load graph files into the graph object for search and processing |
| CGraphSaver | An object to save graph objects to a file |
| CEdgeCostFunction | A plugin interface to score edges during graph search to modify the lowest cost path (e.g. by distance, maximum speed, regions prefer not to travel blocked by occupancy, or using arbitrarily defined user metadata stored in the edge and nodes of interest.) |
| CGraphFileLoader | A plugin interface to parse a file into the graph |
| CGraphFileSaver | A plugin interface to parse a file into the graph |
| COperationResult | Struct to hold return from an operation |
| CRouteOperation | A plugin interface to perform an operation while tracking the route such as triggered from the graph file when a particular node is achieved, edge is entered or exited. The API also supports triggering arbitrary operations when a status has changed (e.g. any node is achieved) or at a regular frequency on query set at a fixed rate of tracker_update_rate. Operations can request the system to reroute and avoid certain edges. Example operations may be to: reroute when blocked or at a required rate (though may want to use BTs instead), adjust speed limits, wait, call an external service or action to perform a task such as calling an elevator or opening an automatic door, etc. Operations may throw nav2_core::OperationFailed exceptions in failure cases |
| CGraphAdaptor | An adaptor for Nanoflann to operate on our graph object without copying |
| CNodeSpatialTree | An object to find kNNs of the graph to determining the start and end nodes to utilize for planning in a free-space-style request of start and goal poses. Since the graph does not change over time, we can precompute this quadtree and reuse it over many requests |
| COperationsManager | Manages operations plugins to call on route tracking |
| CPathConverter | An helper to convert the route into dense paths |
| CCostmapScorer | Scores edges by the average or maximum cost found while iterating over the edge's line segment in the global costmap |
| CDistanceScorer | Scores edges by the distance traversed, weighted by speed limit metadata to optimize for time to goal, when %-based speed limits are set |
| CDynamicEdgesScorer | Rejects edges that are in the closed set of edges for navigation to prevent routes from containing paths blocked or otherwise deemed not currently traversable |
| CGoalOrientationScorer | Scores an edge leading to the goal node by comparing the orientation of the route pose and the orientation of the edge by multiplying the deviation from the desired orientation with a user defined weight. An alternative method can be selected, with the use_orientation_threshold flag, which rejects the edge it is greater than some tolerance |
| CPenaltyScorer | Adjusts the score of an edge by an amount set as metadata in the graph |
| CSemanticScorer | Scores an edge based on arbitrary graph semantic data such as set priority/danger levels or regional attributes (e.g. living room, bathroom, work cell 2) |
| CStartPoseOrientationScorer | Scores initial edge by comparing the orientation of the robot's current pose and the orientation of the edge by multiplying the deviation from the desired orientation with a user defined weight. An alternative method can be selected, with the use_orientation_threshold flag, which rejects the edge it is greater than some tolerance |
| CTimeScorer | Scores edges by the time to traverse an edge. It uses previous times to navigate the edge primarily, then secondarily uses maximum speed and absolute speed limits to estimate with edge length |
| CGeoJsonGraphFileLoader | A GraphFileLoader plugin to load a geojson graph representation |
| CGeoJsonGraphFileSaver | A GraphFileSaver plugin to save a geojson graph representation |
| CRouteOperationClient | A route operation base class to trigger a service event at a node or edge. This is meant to be named accordingly to the event of query in the parameter file (e.g. OpenDoor, CallElevator). Thus, a single RouteOperationClient implementation can support many different operation instances calling different services. The template type may be overridden for any applications. It may be set up to either trigger a single service if the service_name is set in the parameter file at launch for all calls or trigger different services depending on the service_name set in the metadata of the node or edge operation given |
| CAdjustSpeedLimit | A route operation to process on state changes to evaluate if speed limits should be adjusted based on graph edge metadata |
| ►CCollisionMonitor | A route operation to process a costmap to determine if a route is blocked requiring immediate rerouting. If using the local costmap topic, then it will check in the local time horizon only. if using the global, it may check the full route for continued validity. It is however recommended to specify a maximum collision distance for evaluation to prevent necessarily long-term evaluation of collision information which may not be representative of the conditions in that area by the time the robot gets there |
| CLineSegment | |
| CReroutingService | A route operation to process requests from an external server for rerouting |
| CTimeMarker | A route operation to add accurate times to the graph's edges after navigation to use in later iterations for a more refined estimate of actual travel time |
| CTriggerEvent | A route operation to trigger an event at a node or edge. This operation is meant to be named accordingly to the event of query in the parameter file (e.g. OpenDoor, CallElevator). Thus, a single TriggerEvent plugin type can support many different operation instances calling different services. It may be set up to either trigger a single service if the service_name is set in the parameter file at launch or trigger different services depending on the service_name set in the metadata of the node or edge operation given for centralized or decentralized events by node or edge |
| CRoutePlanner | An optimal planner to compute a route from a start to a goal in an arbitrary graph |
| CRouteServer | An action server implements a Navigation Route-Graph planner to compliment free-space planning in the Planner Server |
| CRouteTracker | Takes a processing route request and tracks it for progress in accordance with executing behavioral operations |
| CMetadata | An object to store arbitrary metadata regarding nodes from the graph file |
| CNodeComparator | Node comparison for priority queue sorting |
| CEdgeCost | An object to store edge cost or cost metadata for scoring |
| COperation | An object to store operations to perform on events with types and metadata |
| COperationsResult | Result information from the operations manager |
| CDirectionalEdge | An object representing edges between nodes |
| CSearchState | An object to store state related to graph searching of nodes This is an internal class users should not modify |
| CCoordinates | An object to store Node coordinates in different frames |
| CNode | An object to store the nodes in the graph file |
| CRoute | An ordered set of nodes and edges corresponding to the planned route |
| CRouteRequest | An object to store salient features of the route request including its start and goal node ids, start and goal pose, and a flag to indicate if the start and goal poses are relevant |
| CRouteTrackingState | Current state management of route tracking class |
| CReroutingState | State shared to objects to communicate important rerouting data to avoid rerouting over blocked edges, ensure reroute from the current appropriate starting point along the route, and state of edges if pruned for seeding the Tracker's state. Admittedly, this is a bit complex, so more context is provided inline |
| ►Nnav2_rviz_plugins | |
| CCostmapCostTool | |
| CDockingPanel | Panel to interface to the docking server |
| CInitialDockThread | |
| CGoalPoseUpdater | Class to set and update goal pose by emitting signal |
| CGoalTool | |
| CNavThroughPoseTab | |
| CNav2Panel | Panel to interface to the nav2 stack |
| CInitialThread | |
| CFlatWeightedArrowsArray | |
| COgrePoseWithWeight | |
| CParticleCloudDisplay | Displays a nav2_msgs/ParticleCloud message as a bunch of line-drawn weighted arrows |
| CROSActionQEvent | Custom Event to track state of ROS Action |
| CROSActionQTransition | Custom Transition to check whether ROS Action state has changed |
| CRouteTool | |
| CSelector | |
| ►Nnav2_simple_commander | |
| ►Ncostmap_2d | |
| CPyCostmap2D | |
| ►Nfootprint_collision_checker | |
| CFootprintCollisionChecker | |
| ►Nline_iterator | |
| CLineIterator | |
| ►Noccupancy_grid | |
| CPyOccupancyGrid | |
| ►Nrobot_navigator | |
| CTaskResult | |
| CRunningTask | |
| CBasicNavigator | |
| ►Nnav2_smac_planner | |
| ►CAStarAlgorithm | An A* implementation for planning in a costmap. Templated based on the Node type |
| CNodeComparator | |
| ►CAnalyticExpansion | |
| CAnalyticExpansionNode | |
| CAnalyticExpansionNodes | Analytic expansion nodes and associated metadata |
| CGridCollisionChecker | A costmap grid collision checker |
| CCostmapDownsampler | A costmap downsampler for more efficient path planning |
| CDistanceHeuristic | Distance Heuristic implementation for graph, Hybrid-A* |
| CGoalManager | Responsible for managing multiple variables storing information on the goal |
| ►CNode2D | Node2D implementation for graph |
| CNodeContext | |
| CNodeBasic | NodeBasic implementation for priority queue insertion |
| CHybridMotionTable | A table of motion primitives and related functions |
| ►CNodeHybrid | NodeHybrid implementation for graph, Hybrid-A* |
| CNodeContext | |
| CLatticeMotionTable | A table of motion primitives and related functions |
| ►CNodeLattice | NodeLattice implementation for graph, Hybrid-A* |
| CNodeContext | |
| CObstacleHeuristicComparator | |
| CObstacleHeuristic | Obstacle Heuristic implementation for graph, Hybrid-A* |
| CSmacPlanner2DT | A templated 2D planner that allows custom node types |
| CSmacPlannerHybridT | A templated hybrid-A* planner that allows custom node types |
| CSmacPlannerLatticeT | A templated state lattice planner that allows custom node types |
| CBoundaryPoints | Set of boundary condition points from expansion |
| CBoundaryExpansion | Boundary expansion state |
| CSmoother | A Conjugate Gradient 2D path smoother implementation |
| CSearchInfo | Search properties and penalties |
| CSmootherParams | Parameters for the smoother cost function |
| CMotionPose | A struct for poses in motion primitives |
| CLatticeMetadata | A struct of all lattice metadata |
| CMotionPrimitive | A struct of all motion primitive data |
| CGoalState | A struct to store the goal state |
| CCoordinates2D | |
| CCoordinates | Implementation of coordinate2d structure |
| ►Nnav2_smoother | |
| CSmootherServer | This class hosts variety of plugins of different algorithms to smooth or refine a path from the exposed SmoothPath action server |
| CSavitzkyGolaySmoother | A path smoother implementation using Savitzky Golay filters |
| CSimpleSmoother | A path smoother implementation |
| ►Nnav2_system_tests | |
| CDummyActionServer | |
| CDummyService | |
| CDummyComputePathToPoseActionServer | |
| CDummyFollowPathActionServer | |
| CDummyClearEntireCostmapService | |
| CDummyClearCostmapAroundRobotService | |
| CDummyClearCostmapExceptRegionService | |
| CDummyClearCostmapAroundPoseService | |
| CServerHandler | |
| CAssistedTeleopBehaviorTester | |
| CWaitBehaviorTester | |
| CDummyController | |
| CDummyPlanner | |
| CUnknownErrorController | |
| CTFErrorController | |
| CFailedToMakeProgressErrorController | |
| CPatienceExceededErrorController | |
| CInvalidPathErrorController | |
| CNoValidControlErrorController | |
| CUnknownErrorPlanner | |
| CStartOccupiedErrorPlanner | |
| CGoalOccupiedErrorPlanner | |
| CStartOutsideMapErrorPlanner | |
| CGoalOutsideMapErrorPlanner | |
| CNoValidPathErrorPlanner | |
| CTimedOutErrorPlanner | |
| CTFErrorPlanner | |
| CNoViapointsGivenErrorPlanner | |
| CCancelledPlanner | |
| CUnknownErrorSmoother | |
| CTimeOutErrorSmoother | |
| CSmoothedPathInCollision | |
| CFailedToSmoothPath | |
| CInvalidPath | |
| CNavFnPlannerTester | |
| CPlannerTester | |
| ►Nnav2_theta_star_planner | |
| CParameters | |
| CParameterHandler | Handles parameters and dynamic parameters for Theta Star |
| CThetaStar | |
| CThetaStarPlanner | |
| ►Nnav2_util | |
| CCostmap | Class for a single layered costmap initialized from an occupancy grid representing the map |
| CExecutionTimer | Measures execution time of code between calls to start and end |
| CLifecycleServiceClient | Helper functions to interact with a lifecycle node |
| CLineIterator | An iterator implementing Bresenham Ray-Tracing |
| COdomSmoother | |
| CParameterHandler | |
| CPathSearchResult | Result of searching for the closest segment on a path |
| CPathSegment | A segment of a path in start/end indices |
| CTwistPublisher | A simple wrapper on a Twist publisher that provides either Twist or TwistStamped |
| CTwistSubscriber | A simple wrapper on a Twist subscriber that receives either geometry_msgs::msg::TwistStamped or geometry_msgs::msg::Twist |
| CBaseFootprintPublisherListener | A TF2 listener that overrides the subscription callback to inject base footprint publisher removing Z, Pitch, and Roll for 3D state estimation but desiring a 2D frame for navigation, visualization, or other reasons |
| CBaseFootprintPublisher | Republishes the base_link frame as base_footprint stripping away the Z, Roll, and Pitch of the full 3D state to provide a 2D projection for navigation when state estimation is full 3D |
| ►Nnav2_velocity_smoother | |
| CVelocitySmoother | This class that smooths cmd_vel velocities for robot bases |
| ►Nnav2_voxel_grid | |
| CVoxelGrid | |
| ►Nnav2_waypoint_follower | |
| CParameters | |
| CParameterHandler | Handles parameters and dynamic parameters for Planner Server |
| CInputAtWaypoint | Simple plugin based on WaypointTaskExecutor, let's robot to wait for a user input at waypoint arrival |
| CPhotoAtWaypoint | |
| CWaitAtWaypoint | Simple plugin based on WaypointTaskExecutor, let's robot to sleep for a specified amount of time at waypoint arrival. You can reference this class to define your own task and rewrite the body for it |
| CGoalStatus | |
| CWaypointFollower | An action server that uses behavior tree for navigating a robot to its goal position |
| ►Nnav_through_poses_tester_error_msg_node | |
| CNavTester | |
| ►Nnav_through_poses_tester_node | |
| CNavTester | |
| ►Nnav_to_pose_tester_node | |
| CNavTester | |
| ►Nopennav_docking | |
| CController | Default control law for approaching a dock target |
| CDockDatabase | An object to contain docks and docking plugins |
| CDockingServer | An action server which implements charger docking node for AMRs |
| CNavigator | An object the call navigation to obtain initial staging pose |
| CParameters | |
| CParameterHandler | Handles parameters and dynamic parameters for Controller Server |
| CPoseFilter | Filter for a sequence of pose measurements |
| CSimpleChargingDock | |
| CSimpleNonChargingDock | |
| ►Nopennav_docking_bt | |
| CDockRobotAction | Nav2_behavior_tree::BtActionNode class that wraps opnav2_msgsennav_docking_msgs/DockRobot |
| CUndockRobotAction | Nav2_behavior_tree::BtActionNode class that wraps nav2_msgs/UndockRobot |
| ►Nopennav_docking_core | |
| CChargingDock | Abstract interface for a charging dock for the docking framework |
| CDockingException | Abstract docking exception |
| CDockNotInDB | Dock was not found in the provided dock database |
| CDockNotValid | Dock plugin provided in the database or action was invalid |
| CFailedToStage | Failed to navigate to the staging pose |
| CFailedToDetectDock | Failed to detect the charging dock |
| CFailedToControl | Failed to control into or out of the dock |
| CFailedToCharge | Failed to start charging |
| CNonChargingDock | Abstract interface for a non-charging dock for the docking framework |
| ►Nopennav_following | |
| CFollowingServer | An action server which implements a dynamic following behavior |
| CParameters | |
| CParameterHandler | Handles parameters and dynamic parameters for Planner Server |
| ►Nrobin_hood | |
| ►Ndetail | |
| ►Nswappable | |
| Cnothrow | |
| CBulkPoolAllocator | |
| CNodeAllocator | |
| CNodeAllocator< T, MinSize, MaxSize, true > | |
| CNodeAllocator< T, MinSize, MaxSize, false > | |
| Cvoid_type | |
| Chas_is_transparent | |
| Chas_is_transparent< T, typename void_type< typename T::is_transparent >::type > | |
| CWrapHash | |
| CWrapKeyEqual | |
| CTable | |
| ►NROBIN_HOOD_STD | |
| ►Ndetail_ | |
| ►CIntSeqImpl | |
| CIntSeqCombiner | |
| CIntSeqCombiner< integer_sequence< TValue, Inds0... >, integer_sequence< TValue, Inds1... > > | |
| CIntSeqImpl< T, Begin, Begin, false > | |
| CIntSeqImpl< T, Begin, End, true > | |
| Calignment_of | |
| Cinteger_sequence | |
| Cis_transparent_tag | |
| Cpair | |
| Chash | |
| Chash< std::basic_string< CharT > > | |
| Chash< T * > | |
| Chash< std::unique_ptr< T > > | |
| Chash< std::shared_ptr< T > > | |
| Chash< Enum, typename std::enable_if< std::is_enum< Enum >::value >::type > | |
| ►Nspin_tester | |
| CSpinTest | |
| ►Ntester | |
| CGpsWaypointFollowerTest | |
| CWaypointFollowerTest | |
| ►Ntester_node | |
| CTestType | |
| CFilterMask | |
| CNavTester | |
| CRouteTester | |
| C_pf_sample_set_t | |
| C_pf_t | |
| CA | |
| CBehavior | An action server Behavior base class implementing the action server and basic factory |
| CCachedDistanceMap | |
| CCell | |
| CCellData | |
| Ccmd_struct | |
| Ccomp | |
| CcoordsM | |
| CcoordsW | |
| CCostmaQueue | A tool for finding the cells closest to some set of originating cells |
| CDock | |
| CFind | |
| CLifeCycleMangerClient | The LifecycleManagerClient sends requests to the LifecycleManager to control the lifecycle state of the navigation modules |
| Cmap_cell_t | |
| Cmap_t | |
| CMPPIController | Main plugin controller for MPPI Controller |
| CNodeComparator | Node comparison for priority queue sorting |
| COptimizerParams | Parameters for the ceres optimizer |
| CParameter | |
| Cpf_cluster_t | |
| Cpf_kdtree_node | |
| Cpf_kdtree_t | |
| Cpf_matrix_t | |
| Cpf_pdf_gaussian_t | |
| Cpf_sample_t | |
| Cpf_vector_t | |
| CRosLockGuard | |
| Ctree_node | |
| CTurnDirection | A struct with the motion primitive's direction embedded |
| CVoxelGrid | A 3D grid structure that stores points as an integer array. X and Y index the array and Z selects which bit of the integer is used giving a limit of 16 vertical cells |
1.9.1