Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

[detail level 12345]

►Nbackup_tester
CBackupTest
►Nbehavior_server
CBehaviorServer	An server hosting a map of behavior plugins
►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
►Nloopback_simulator
CLoopbackSimulator
►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 motion model 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
CPathHandler	Manager of incoming reference paths for transformation and processing
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
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)> >
►Nnav2_amcl
►CAmclNode
Camcl_hyp_t
CPoint2D
Cangleutils
CDifferentialMotionModel
CMotionModel	An abstract motion model class
COmniMotionModel
CLaser
CLaserData
CBeamModel
CLikelihoodFieldModel
CLikelihoodFieldModelProb
►Nnav2_behavior_tree
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
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
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
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
CTruncatePath	A BT::ActionNodeBase to shorten path by some distance
CTruncatePathLocal	A BT::ActionNodeBase to shorten path to some distance around robot
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
CIsPathValidCondition	A BT::ConditionNode that returns SUCCESS when the IsPathValid service returns true and FAILURE otherwise
CIsStoppedCondition	A BT::ConditionNode that tracks robot odometry and returns SUCCESS if robot is considered stopped for long enough, RUNNING if stopped but not for long enough and FAILURE otherwise
CIsStuckCondition	A BT::ConditionNode that tracks robot odometry and returns SUCCESS if robot is stuck somewhere 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
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
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	2D point
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
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
CNavigatorMuxer	A class to control the state of the BT navigator by allowing only a single plugin to be processed at a time
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
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
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
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
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
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
CCellData	Storage for cell information used during obstacle inflation
CInflationLayer	Layer to convolve costmap by robot's radius or footprint to prevent collisions and largely simply collision checking
CLayer	Abstract class for layered costmap plugin implementations
CLayeredCostmap	Instantiates different layer plugins and aggregates them into one score
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
CPathHandler	Handles input paths to transform them to local frames required
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_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
►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
►Nnav2_planner
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
CCollisionChecker	Checks for collision based on a RPP control command
CParameters
CParameterHandler	Handles parameters and dynamic parameters for RPP
CPathHandler	Handles input paths to transform them to local frames required
CRegulatedPurePursuitController	Regulated pure pursuit controller plugin
►Nnav2_rotation_shim_controller
CRotationShimController	Rotate to rough path heading controller shim plugin
►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
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
►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
CGoalManager	Responsible for managing multiple variables storing information on the goal
►CNode2D	Node2D implementation for graph
CCoordinates	Node2D implementation of coordinate structure
CNodeBasic	NodeBasic implementation for priority queue insertion
CObstacleHeuristicComparator
CHybridMotionTable	A table of motion primitives and related functions
►CNodeHybrid	NodeHybrid implementation for graph, Hybrid-A*
CCoordinates	NodeHybrid implementation of coordinate structure
CLatticeMotionTable	A table of motion primitives and related functions
CNodeLattice	NodeLattice implementation for graph, Hybrid-A*
CSmacPlanner2D
CSmacPlannerHybrid
CSmacPlannerLattice
CPathSegment	A segment of a path in start/end indices
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
►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
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
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
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
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
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
►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 >
►Nsmoother_utils
CPathSegment
►Nspin_tester
CSpinTest
►Ntester
CGpsWaypointFollowerTest
CWaypointFollowerTest
►Ntester_node
CTestType
CFilterMask
CNavTester
CRouteTester
►Ntheta_star
CThetaStar
►Nunique_multi_tb3_simulation_launch
CRobotConfig
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
CPathSegment	A segment of a path in start/end indices
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