  internal_mrpt | |
   MatOrVecResizer | |
| MatOrVecResizer< R, 1 > | |
| MatOrVecResizer< 1, C > | |
 MatOrVecResizer< 1, 1 > | |
| mrpt | This is the global namespace for all Mobile Robot Programming Toolkit (MRPT) libraries |
| bayes | The namespace for Bayesian filtering algorithm: different particle filters and Kalman filter algorithms |
| detail | Auxiliary functions, for internal usage of MRPT classes |
| CRunOneKalmanIteration_addNewLandmarks | |
| CParticleFilter | This class acts as a common interface to the different interfaces (see CParticleFilter::TParticleFilterAlgorithm) any bayes::CParticleFilterCapable class can implement: it is the invoker of particle filter algorithms |
| TParticleFilterOptions | The configuration of a particle filter |
| TParticleFilterStats | Statistics for being returned from the "execute" method |
| CParticleFilterCapable | This virtual class defines the interface that any particles based PDF class must implement in order to be executed by a mrpt::bayes::CParticleFilter |
| TFastDrawAuxVars | Auxiliary vectors, see CParticleFilterCapable::prepareFastDrawSample for more information |
| CParticleFilterData | This template class declares the array of particles and its internal data, managing some memory-related issues and providing an easy implementation of virtual methods required for implementing a CParticleFilterCapable |
| CProbabilityParticle | A template class for holding a the data and the weight of a particle |
| TKF_options | Generic options for the Kalman Filter algorithm in itself |
| CKalmanFilterCapable | Virtual base for Kalman Filter (EKF,IEKF,UKF) implementations |
| CRejectionSamplingCapable | A base class for implementing rejection sampling in a generic state space |
| compress | Data compression/decompression algorithms |
| zip | Compression using the "zip" algorithm and from/to gzip (gz) files |
| detectors | |
| CCascadeClassifierDetection | |
| TOptions | |
| CDetectableObjectPtr | |
| CDetectableObject | Base class that contains common atributes and functions of detectable objects |
| CDetectable2DPtr | |
| CDetectable2D | |
| CDetectable3DPtr | |
| CDetectable3D | |
| CFaceDetection | Specific class for face detection |
| TMeasurement | |
| TOptions | |
| TTestsOptions | |
| CObjectDetection | |
| global_settings | Global variables to change the run-time behaviour of some MRPT classes within mrpt-core |
| graphs | Abstract graph and tree data structures, plus generic graph algorithms |
| detail | Internal functions for MRPT |
| edge_annotations_empty | An empty structure |
| node_annotations_empty | An empty structure |
| TPosePDFHelper | |
| TPosePDFHelper< CPose2D > | |
| TPosePDFHelper< CPose3D > | |
| graph_ops | Helper struct with static template functions |
| CAStarAlgorithm | This class is intended to efficiently solve graph-search problems using heuristics to determine the best path |
| CDirectedGraph | A directed graph with the argument of the template specifying the type of the annotations in the edges |
| edge_t | The type of each global pose in nodes: an extension of the TYPE_EDGES pose with any optional user-defined data |
| CDirectedTree | A special kind of graph in the form of a tree with directed edges and optional edge annotations of templatized type "TYPE_EDGES" |
| TEdgeInfo | |
| Visitor | Virtual base class for user-defined visitors |
| CGraphPartitioner | Algorithms for finding the min-normalized-cut of a weighted undirected graph |
| CNetworkOfPoses | A directed graph of pose constraints, with edges being the relative pose between pairs of nodes indentified by their numeric IDs (of type TNodeID) |
| global_pose_t | The type of each global pose in nodes: an extension of the constraint_no_pdf_t pose with any optional user-defined data |
| CNetworkOfPoses2DPtr | |
| CNetworkOfPoses3DPtr | |
| CNetworkOfPoses2DCovPtr | |
| CNetworkOfPoses3DCovPtr | |
| CNetworkOfPoses2DInfPtr | |
| CNetworkOfPoses3DInfPtr | |
| CNetworkOfPoses2D | The specialization of CNetworkOfPoses for poses of type CPose2D (not a PDF!), also implementing serialization |
| CNetworkOfPoses3D | The specialization of CNetworkOfPoses for poses of type CPose3D (not a PDF!), also implementing serialization |
| CNetworkOfPoses2DCov | The specialization of CNetworkOfPoses for poses of type CPosePDFGaussian, also implementing serialization |
| CNetworkOfPoses3DCov | The specialization of CNetworkOfPoses for poses of type CPose3DPDFGaussian, also implementing serialization |
| CNetworkOfPoses2DInf | The specialization of CNetworkOfPoses for poses of type CPosePDFGaussianInf, also implementing serialization |
| CNetworkOfPoses3DInf | The specialization of CNetworkOfPoses for poses of type CPose3DPDFGaussianInf, also implementing serialization |
 CDijkstra | The Dijkstra algorithm for finding the shortest path between a given source node in a (weighted) directed graph and all other nodes in the form of a tree |
 TDistance | Auxiliary struct for topological distances from root node |
| TPrevious | Auxiliary struct for backward paths |
| graphslam | SLAM methods related to graphs of pose constraints |
| detail | Internal auxiliary classes |
| AuxErrorEval< CPose2D, gst > | |
| AuxErrorEval< CPose3D, gst > | |
| AuxErrorEval< CPosePDFGaussianInf, gst > | |
| AuxErrorEval< CPose3DPDFGaussianInf, gst > | |
| graphslam_traits | Auxiliary traits template for use among graph-slam problems to make life easier with these complicated, long data type names |
| observation_info_t | Auxiliary struct used in graph-slam implementation: It holds the relevant information for each of the constraints being taking into account |
| TResultInfoSpaLevMarq | Output information for mrpt::graphslam::optimize_graph_spa_levmarq() |
| gui | Classes for creating GUI windows for 2D and 3D visualization |
| CBaseGUIWindowPtr | |
| CBaseGUIWindow | The base class for GUI window classes |
| mrptEventWindowChar | An event sent by a window upon a char pressed by the user |
| mrptEventWindowResize | An event sent by a window upon resize |
| mrptEventMouseDown | An event sent by a window upon a mouse click, giving the (x,y) pixel coordinates |
| mrptEventWindowClosed | An event sent by a window upon when it's about to be closed, either manually by the user or programatically |
| CDisplayWindowPtr | |
| CDisplayWindow | This class creates a window as a graphical user interface (GUI) for displaying images to the user |
| CDisplayWindow3DPtr | |
| CDisplayWindow3D | A graphical user interface (GUI) for efficiently rendering 3D scenes in real-time |
| mrptEvent3DWindowGrabImageFile | An event sent by a CDisplayWindow3D window when an image is saved after enabling this feature with CDisplayWindow3D::grabImagesStart() |
| CDisplayWindowPlotsPtr | |
| CDisplayWindowPlots | Create a GUI window and display plots with MATLAB-like interfaces and commands |
| WxSubsystem | This class implements the GUI thread required for the wxWidgets-based GUI |
| hmtslam | Classes related to the implementation of Hybrid Metric Topological (HMT) SLAM |
| CHierarchicalMapMHPartition | Represents a set of nodes and arcs, posibly only a part of the whole hierarchical, multi-hypothesis map |
| CHierarchicalMHMapPtr | |
| CHierarchicalMHMap | The most high level class for storing hybrid, multi-hypothesis maps in a graph-based model |
| CHMHMapArc | A class for representing an arc between two nodes in a hierarchical, multi-hypothesis map |
| CHMHMapNodePtr | |
| CHMHMapNode | A class for representing a node in a hierarchical, multi-hypothesis map |
| CHMTSLAMPtr | |
| CHMTSLAM | An implementation of Hybrid Metric Topological SLAM (HMT-SLAM) |
| TMessageLSLAMfromAA | Message definition: |
| TMessageLSLAMfromTBI | Message definition: |
| TBI_info | |
| TMessageLSLAMtoTBI | Message definition: |
| TOptions | A variety of options and configuration params (private, use loadOptions) |
| CLSLAMAlgorithmBase | Virtual base for local SLAM methods, used in mrpt::slam::CHMTSLAM |
| CLSLAM_RBPF_2DLASER | Implements a 2D local SLAM method based on a RBPF over an occupancy grid map |
| TPathBin | Auxiliary structure |
| CLSLAMParticleDataPtr | |
| CLocalMetricHypothesisPtr | |
| CLSLAMParticleData | Auxiliary class used in mrpt::slam::CLocalMetricHypothesis for HMT-SLAM; this class keeps the data relative to each local metric particle ("a robot metric path hypothesis" and its associated metric map) |
| CLocalMetricHypothesis | This class is used in HMT-SLAM to represent each of the Local Metric Hypotheses (LMHs) |
| TRobotPosesPartitioning | Used by AA thread |
| TPoseInfo | Information kept for each robot pose used in CRobotPosesGraph |
| CRobotPosesGraphPtr | |
| CRobotPosesGraph | Auxiliary class used in mrpt::slam::CLocalMetricHypothesis for HMT-SLAM; this class stores a set of robot poses and its sensory frames and pose PDF, for being stored in a HMT-map as a serializable object in annotation NODE_ANNOTATION_POSES_GRAPH |
| CTopLCDetector_FabMap | |
| TOptions | Options for a TLC-detector of type FabMap, used from CHMTSLAM |
| CTopLCDetector_GridMatching | |
| TOptions | Options for a TLC-detector of type gridmap-matching, used from CHMTSLAM |
| CTopLCDetectorBase | The virtual base class for Topological Loop-closure Detectors; used in HMT-SLAM |
| CHMHMapArcPtr | |
| THypothesisIDSetPtr | |
| THypothesisIDSet | A set of hypothesis IDs, used for arcs and nodes in multi-hypothesis hybrid maps |
| TArcList | A class for storing a sequence of arcs (a path) |
| hwdrivers | Contains classes for various device interfaces |
| C2DRangeFinderAbstract | This is the base, abstract class for "software drivers" interfaces to 2D scanners (laser range finders) |
| CActivMediaRobotBase | This software driver implements the communications (and some rudimentary control) for ActivMedia robotic bases (Pioneer DX/AT, PeopleBot, etc) |
| TRobotDescription | A structure describing the robot |
| CBoardDLMS | An interface to a custom board which interfaces two SICK laser scanners |
| CBoardENoses | A class for interfacing an e-Noses via a FTDI USB link |
| CBoardIR | A parser of NMEA commands, for connecting to a GPS by a serial port |
| CBoardSonars | This "software driver" implements the communication protocol for interfacing a Ultrasonic range finder SRF10 through a custom USB board |
| CCameraSensor | The central class for camera grabbers in MRPT, implementing the "generic sensor" interface |
| CFFMPEG_InputStream | A generic class which process a video file or other kind of input stream (http, rtsp) and allows the extraction of images frame by frame |
| TSensorClassId | A structure for runtime ID class type information in the context of hwdrivers::CGenericSensor |
| CGenericSensor | A generic interface for a wide-variety of sensors designed to be used in the application RawLogGrabber |
| CLASSINIT_GENERIC_SENSOR | Auxiliary structure used for CSerializable runtime class ID support |
| CGPSInterface | A parser of NMEA commands, for connecting to a GPS by a serial port |
| CGyroKVHDSP3000 | A class for interfacing KVH DSP 3000 gyroscope with an assynchronous serial communication (product SN : 02-1222-01) |
| CHokuyoURG | This software driver implements the protocol SCIP-2.0 for interfacing HOKUYO URG, UTM and UXM laser scanners |
| TSensorInfo | Used in CHokuyoURG::displayVersionInfo |
| CIbeoLuxETH | This "software driver" implements the communication protocol for interfacing a Ibeo Lux laser scanners through an ethernet controller |
| TCaptureOptions_dc1394 | Options used when creating an dc1394 capture object All but the frame size, framerate, and color_coding can be changed dynamically by CImageGrabber_dc1394::changeCaptureOptions |
| CImageGrabber_dc1394 | A class for grabing images from a IEEE1394 (Firewire) camera using the libdc1394-2 library |
| TCameraInfo | Used in enumerateCameras |
| TCaptureCVOptions | Options used when creating an OpenCV capture object Some options apply to IEEE1394 cameras only |
| CImageGrabber_OpenCV | A class for grabing images from a "OpenCV"-compatible camera, or from an AVI video file |
| CImpinjRFID | This class implements an interface to an Impinj RFID reader |
| CIMUXSens | A class for interfacing Inertial Measuring Units (IMUs) of the type "XSens MTi" It uses a serial port connection to the device |
| TFTDIDevice | A list of FTDI devices and their descriptors |
| CInterfaceFTDI | A definition of a CStream actually representing a USB connection to a FTDI chip |
| CJoystick | Access to joysticks and gamepads (read buttons and position), and request number of joysticks in the system |
| CKinect | A class for grabing "range images", intensity images (either RGB or IR) and other information from an Xbox Kinect sensor |
| CLMS100Eth | This "software driver" implements the communication protocol for interfacing a SICK LMS100 laser scanners through an ethernet controller |
| CNTRIPClient | A client for NTRIP (HTTP) sources of differential GPS corrections from internet servers, or Global navigation satellite system (GNSS) internet radio |
| NTRIPArgs | The arguments for connecting to a NTRIP stream, used in CNTRIPClient::open |
| TMountPoint | A descriptor of one stream in an NTRIP Caster - See CNTRIPClient::retrieveListOfMountpoints |
| CNTRIPEmitter | This "virtual driver" encapsulates a NTRIP client (see CNTRIPClient) but adds the functionality of dumping the received datastream to a given serial port |
| CPhidgetInterfaceKitProximitySensors | : An interface for the phidget Interface kit board (1018) |
| CPtuBase | This class implements initialization and comunication methods to control a generic Pan and Tilt Unit, working in radians |
| CPtuDPerception | This class implements initialization and comunication methods to control a Pan and Tilt Unit model PTU-46-17.5, working in radians |
| ThreadParams | |
| CPtuHokuyo | |
| my_pos | |
| CRaePID | This class implements a driver for the RAE Systems gas PhotoIonization Detector (PID) (Tested on a MiniRAE Lite) The sensor is accessed via a standard (or USB) serial port |
| CRoboticHeadInterface | This "software driver" implements the communication protocol for interfacing a Robotic Head Board through a custom USB RS-422 interface board |
| CRovio | A class to interface a Rovio robot (manufactured by WowWee) |
| TEncoders | |
| TOptions | |
| TRovioState | |
| CSerialPort | A communications serial port built as an implementation of a utils::CStream |
| CServoeNeck | A USB-interface for a custom "robotic neck" designed at MAPIR lab |
| CSickLaserSerial | This "software driver" implements the communication protocol for interfacing a SICK LMS 2XX laser scanners through a standard RS232 serial port (or a USB2SERIAL converter) |
| CSickLaserUSB | This "software driver" implements the communication protocol for interfacing a SICK LMS2XX laser scanners through a custom USB RS-422 interface board |
| TCaptureOptions_bumblebee | Options used when creating a bumblebee camera capture object |
| CStereoGrabber_Bumblebee | A class for grabing stereo images from a "Bumblebee" or "Bumblebee2" camera NOTE: |
| TCaptureOptions_SVS | Options used when creating a STOC Videre Design camera capture object |
| CStereoGrabber_SVS | A class for grabing stereo images from a STOC camera of Videre Design NOTE: |
| CSwissRanger3DCamera | A class for grabing "range images" from a MESA imaging SwissRanger 3D cameras (SR-2, SR-3000, SR-4k) |
| CTuMicos | This class implements initialization and comunication methods to control a Tilt Unit model DT-80, working in radians |
| CWirelessPower | This class implements a wireless power probe |
| math | This base provides a set of functions for maths stuff |
| detail | |
| VicinityTraits< CMatrixFixedNumeric< T, D, D > > | Vicinity traits class specialization for fixed size matrices |
| VicinityTraits< CMatrixTemplateNumeric< T > > | Vicinity traits class specialization for fixed size matrices |
| TAuxResizer | Internal resize which compiles to nothing on fixed-size matrices |
| TAuxResizer< MAT,-1 > | |
| MatrixWrapper< U, true > | |
| MatrixWrapper< U, false > | |
| AccessorIterator | Template class for matrix accessor's iterators |
| ReverseAccessorIterator | Template class for matrix accessor's iterators |
| jacobians | A collection of functions to compute jacobians of diverse transformations, etc (some functions are redirections to existing methods elsewhere, so this namespace is actually used with grouping purposes) |
| CArray | A STL container (as wrapper) for arrays of constant size defined at compile time - Users will most likely prefer to use CArrayPOD and its derived classes instead |
| CArray< T, 0 > | |
| CArrayNumeric | CArrayNumeric is an array for numeric types supporting several mathematical operations (actually, just a wrapper on Eigen::Matrix<T,N,1>) |
| CArrayFloat | A partial specialization of CArrayNumeric for float numbers |
| CArrayDouble | A partial specialization of CArrayNumeric for double numbers |
| CArrayInt | A partial specialization of CArrayNumeric for int numbers |
| CArrayUInt | A partial specialization of CArrayNumeric for unsigned int numbers |
| CMatrixTemplateSize | Auxiliary class used in CMatrixTemplate:size(), CMatrixTemplate::resize(), CMatrixFixedNumeric::size(), CMatrixFixedNumeric::resize(), to mimic the behavior of STL-containers |
| CBinaryRelation | This class models a binary relation through the elements of any given set |
| CHistogram | This class provides an easy way of computing histograms for unidimensional real valued variables |
| CLevenbergMarquardtTempl | An implementation of the Levenberg-Marquardt algorithm for least-square minimization |
| TResultInfo | |
| CMatrixPtr | |
| CMatrix | This class is a "CSerializable" wrapper for "CMatrixFloat" |
| CMatrixBPtr | |
| CMatrixB | This class is a "CSerializable" wrapper for "CMatrixBool" |
| CMatrixDPtr | |
| CMatrixD | This class is a "CSerializable" wrapper for "CMatrixTemplateNumeric<double>" |
| CMatrixFixedNumeric | A numeric matrix of compile-time fixed size |
| CMatrixTemplate | This template class provides the basic functionality for a general 2D any-size, resizable container of numerical or non-numerical elements |
| CMatrixTemplateNumeric | A matrix of dynamic size |
| CMatrixTemplateObjects | This template class extends the class "CMatrixTemplate" for storing "objects" at each matrix entry |
| CMonteCarlo | Montecarlo simulation for experiments in 1D |
| CStatisticalAnalyzer | |
| CPolygonPtr | |
| CPolygon | A wrapper of a TPolygon2D class, implementing CSerializable |
| CQuaternion | A quaternion, which can represent a 3D rotation as pair  , with a real part "r" and a 3D vector  , or alternatively, q = r + ix + jy + kz |
| CExceptionNotDefPos | Used in mrpt::math::CSparseMatrix |
| CSparseMatrix | A sparse matrix structure, wrapping T |
| CholeskyDecomp | Auxiliary class to hold the results of a Cholesky factorization of a sparse matrix |
| CSparseMatrixTemplate | A sparse matrix container (with cells of any type), with iterators |
| CSparseSymmetricalMatrix | A sparse matrix container for square symmetrical content around the main diagonal |
| CSplineInterpolator1DPtr | |
| CSplineInterpolator1D | A (persistent) sequence of (x,y) coordinates, allowing queries of intermediate points through spline interpolation, where possible |
| TPolygonWithPlane | Slightly heavyweight type to speed-up calculations with polygons in 3D |
| KDTreeCapable | A generic adaptor class for providing Approximate Nearest Neighbors (ANN) (via the nanoflann library) to MRPT classses |
| TKDTreeDataHolder | Internal structure with the KD-tree representation (mainly used to avoid copying pointers with the = operator) |
| TKDTreeSearchParams | |
| TPoint2D | Lightweight 2D point |
| TPose2D | Lightweight 2D pose |
| TPoint3Df | Lightweight 3D point (float version) |
| TPoint3D | Lightweight 3D point |
| TPose3D | Lightweight 3D pose (three spatial coordinates, plus three angular coordinates) |
| TPose3DQuat | Lightweight 3D pose (three spatial coordinates, plus a quaternion ) |
| TSegment2D | 2D segment, consisting of two points |
| TSegment3D | 3D segment, consisting of two points |
| TLine2D | 2D line without bounds, represented by its equation  |
| TLine3D | 3D line, represented by a base point and a director vector |
| TPlane | 3D Plane, represented by its equation  |
| TPolygon2D | 2D polygon, inheriting from std::vector<TPoint2D> |
| TPolygon3D | 3D polygon, inheriting from std::vector<TPoint3D> |
| TObject2D | Standard type for storing any lightweight 2D type |
| TObject3D | Standard object for storing any 3D lightweight object |
| CMatrixRowAccessor | A vector-like wrapper for a Matrix for accessing the elements of a given row with a [] operator |
| CMatrixRowAccessorExtended | A vector-like wrapper for a Matrix for accessing the elements of a given row with a [] operator, with offset and custom spacing |
| CConstMatrixRowAccessor | A vector-like wrapper for a const Matrix for accessing the elements of a given row with a [] operator |
| CConstMatrixRowAccessorExtended | A vector-like wrapper for a const Matrix for accessing the elements of a given row with a [] operator, with offset and custom spacing |
| CMatrixColumnAccessor | A vector-like wrapper for a Matrix for accessing the elements of a given column with a [] operator |
| CMatrixColumnAccessorExtended | A vector-like wrapper for a Matrix for accessing the elements of a given column with a [] operator, with offset and custom spacing |
| CConstMatrixColumnAccessor | A vector-like wrapper for a const Matrix for accessing the elements of a given column with a [] operator |
| CConstMatrixColumnAccessorExtended | A vector-like wrapper for a const Matrix for accessing the elements of a given column with a [] operator, with offset and custom spacing |
| ModelSearch | Model search implementations: RANSAC and genetic algorithm |
| TSpecies | |
| RANSAC_Template | A generic RANSAC implementation with models as matrices |
| mrpt | This is the global namespace for all Mobile Robot Programming Toolkit (MRPT) libraries |
| math | |
| detail | |
| TAuxResizer | Internal resize which compiles to nothing on fixed-size matrices |
| TAuxResizer< MAT,-1 > | |
| poses | |
| synch | |
| CAtomicCounter | This class acts exactly as an int (or long) variable, but with atomic increment and decrement operators |
| system | This namespace provides a OS-independent interface to many useful functions: filenames manipulation, time and date, string parsing, file I/O, threading, memory allocation, etc |
| os | This namespace provides a OS-independent interface to low-level functions |
| utils | |
| detail | |
| PointCloudAdapterHelperNoRGB | A helper base class for those PointCloudAdapter<> which do not handle RGB data; it declares needed interface methods which fall back to XYZ-only methods |
| CProfilerProxy | |
| dynamicsize_vector | The base class of MRPT vectors, actually, Eigen column matrices of dynamic size with specialized constructors that resemble std::vector |
| aligned_containers | Helper types for STL containers with Eigen memory allocators |
| opengl | The namespace for 3D scene representation and rendering |
| detail | |
| gl_utils | A set of auxiliary functions that can be called to render OpenGL primitives from MRPT or user code |
| TRenderInfo | Information about the rendering process being issued |
| graph_tools | Tool functions for graphs of pose constraints |
| stock_objects | A collection of pre-built 3D objects for quick insertion in opengl::COpenGLScene objects |
| CAngularObservationMeshPtr | |
| CAngularObservationMesh | A mesh built from a set of 2D laser scan observations |
| FTrace1D | Internal functor class to trace a ray |
| FTrace2D | Internal functor class to trace a set of rays |
| TDoubleRange | Range specification type, with several uses |
| rd | Union type with the actual data |
| CPlanarLaserScanPtr | |
| CPlanarLaserScan | This object renders a 2D laser scan by means of three elements: the points, the line along end-points and the 2D scanned surface |
| C3DSScenePtr | |
| C3DSScene | This element keeps a set of objects imported from a 3DStudio file (.3ds) |
| TImpl3DS | A container for automatic deletion of lib3ds's scene when the last reference of the smart_ptr's is destroyed |
| CArrowPtr | |
| CArrow | A 3D arrow |
| CAxisPtr | |
| CAxis | Draw a 3D world axis, with coordinate marks at some regular interval |
| CBoxPtr | |
| CBox | A solid or wireframe box in 3D, defined by 6 rectangular faces parallel to the planes X, Y and Z (note that the object can be translated and rotated afterwards as any other CRenderizable object using the "object pose" in the base class) |
| CCameraPtr | |
| CCamera | A camera: if added to a scene, the viewpoint defined by this camera will be used instead of the camera parameters set in COpenGLViewport::m_camera |
| CCylinderPtr | |
| CCylinder | A cylinder or cone whose base lies in the XY plane |
| CDiskPtr | |
| CDisk | A planar disk in the XY plane |
| CEllipsoidPtr | |
| CEllipsoid | A 2D ellipse or 3D ellipsoid, depending on the size of the m_cov matrix (2x2 or 3x3) |
| CEllipsoidInverseDepth2DPtr | |
| CEllipsoidInverseDepth2D | An especial "ellipsoid" in 3D computed as the uncertainty iso-surfaces of a (inv_range,yaw) variable |
| CEllipsoidInverseDepth3DPtr | |
| CEllipsoidInverseDepth3D | An especial "ellipsoid" in 3D computed as the uncertainty iso-surfaces of a (inv_range,yaw,pitch) variable |
| CEllipsoidRangeBearing2DPtr | |
| CEllipsoidRangeBearing2D | An especial "ellipsoid" in 2D computed as the uncertainty iso-surfaces of a (range,bearing) variable |
| CFBORender | A class for rendering 3D scenes off-screen directly into an image using OpenGL extensions (glext) |
| CFrustumPtr | |
| CFrustum | A solid or wireframe frustum in 3D (a rectangular truncated pyramid), with arbitrary (possibly assymetric) field-of-view angles |
| CGeneralizedCylinderPtr | |
| CGeneralizedCylinder | This object represents any figure obtained by extruding any profile along a given axis |
| TQuadrilateral | Auxiliary struct holding any quadrilateral, represented by foour points |
| CGeneralizedEllipsoidTemplate | A class that generalizes the concept of an ellipsoid to arbitrary parameterizations of uncertainty shapes in either 2D or 3D |
| CGridPlaneXYPtr | |
| CGridPlaneXY | A grid of lines over the XY plane |
| CGridPlaneXZPtr | |
| CGridPlaneXZ | A grid of lines over the XZ plane |
| CMeshPtr | |
| CMesh | A planar (XY) grid where each cell has an associated height and, optionally, a texture map |
| COctreePointRenderer | Template class that implements the data structure and algorithms for Octree-based efficient rendering |
| TNode | The structure for each octree spatial node |
| TRenderQueueElement | |
| COpenGLScenePtr | |
| COpenGLScene | This class allows the user to create, load, save, and render 3D scenes using OpenGL primitives |
| COpenGLStandardObjectPtr | |
| COpenGLStandardObject | Objects of this class represent a generic openGL object without specific geometric properties |
| COpenGLViewportPtr | |
| COpenGLViewport | A viewport within a COpenGLScene, containing a set of OpenGL objects to render |
| TLastProjectiveMatrixInfo | |
| mrptEventGLPreRender | An event sent by an mrpt::opengl::COpenGLViewport just after clearing the viewport and setting the GL_PROJECTION matrix, and before calling the scene OpenGL drawing primitives |
| mrptEventGLPostRender | An event sent by an mrpt::opengl::COpenGLViewport after calling the scene OpenGL drawing primitives and before doing a glSwapBuffers |
| CPointCloudPtr | |
| CPointCloud | A cloud of points, all with the same color or each depending on its value along a particular coordinate axis |
| CPointCloudColouredPtr | |
| CPointCloudColoured | A cloud of points, each one with an individual colour (R,G,B) |
| TPointColour | |
| CPolyhedronPtr | |
| CPolyhedron | This class represents arbitrary polyhedra |
| TPolyhedronEdge | Struct used to store a polyhedron edge |
| TPolyhedronFace | Struct used to store a polyhedron face |
| CRenderizablePtr | |
| CRenderizable | The base class of 3D objects that can be directly rendered through OpenGL |
| CRenderizableDisplayListPtr | |
| CRenderizableDisplayList | A renderizable object suitable for rendering with OpenGL's display lists |
| CSetOfLinesPtr | |
| CSetOfLines | A set of independent lines (or segments), one line with its own start and end positions (X,Y,Z) |
| CSetOfObjectsPtr | |
| CSetOfObjects | A set of object, which are referenced to the coordinates framework established in this object |
| CSetOfTexturedTrianglesPtr | |
| CSetOfTexturedTriangles | A set of textured triangles |
| TTriangle | Triangle |
| TVertex | Triangle vertex |
| CSetOfTrianglesPtr | |
| CSetOfTriangles | A set of colored triangles |
| TTriangle | Triangle definition |
| CSimpleLinePtr | |
| CSimpleLine | A line segment |
| CSpherePtr | |
| CSphere | A solid or wire-frame sphere |
| CTextPtr | |
| CText | A 2D text (bitmap rendering): it always "faces the observer" despite it's at some 3D location |
| CText3DPtr | |
| CText3D | A 3D text (rendered with OpenGL primitives), with selectable font face and drawing style |
| CTextMessageCapable | Keeps a list of text messages which can be rendered to OpenGL contexts by graphic classes |
| CTexturedObjectPtr | |
| CTexturedObject | A base class for all OpenGL objects with loadable textures |
| CTexturedPlanePtr | |
| CTexturedPlane | A 2D plane in the XY plane with a texture image |
| TFontParams | A description of a bitmapped or vectorized text font |
| T2DTextData | An auxiliary struct for holding a list of text messages in some mrpt::opengl & mrpt::gui classes The font can be either a bitmapped or a vectorized font |
| poses | Classes for 2D/3D geometry representation, both of single values and probability density distributions (PDFs) in many forms |
| detail | Internal, auxiliary templates for MRPT classes |
| T3DTypeHelper< CPoint2D > | |
| T3DTypeHelper< CPoint3D > | |
| T3DTypeHelper< CPose2D > | |
| T3DTypeHelper< CPose3D > | |
| T3DTypeHelper< CPose3DQuat > | |
| T3DTypeHelper< CPose3DRotVec > | |
| pose_point_impl< DERIVEDCLASS, 1 > | |
| pose_point_impl< DERIVEDCLASS, 0 > | |
| CPoint | A base class for representing a point in 2D or 3D |
| CPoint2DPtr | |
| CPoint2D | A class used to store a 2D point |
| CPoint2DPDFPtr | |
| CPoint2DPDF | Declares a class that represents a Probability Distribution function (PDF) of a 2D point (x,y) |
| CPoint2DPDFGaussianPtr | |
| CPoint2DPDFGaussian | A gaussian distribution for 2D points |
| CPoint3DPtr | |
| CPoint3D | A class used to store a 3D point |
| CPointPDFPtr | |
| CPointPDF | Declares a class that represents a Probability Distribution function (PDF) of a 3D point (x,y,z) |
| CPointPDFGaussianPtr | |
| CPointPDFGaussian | A gaussian distribution for 3D points |
| TSimple3DPointPtr | |
| TSimple3DPoint | Data within each particle |
| CPointPDFParticlesPtr | |
| CPointPDFParticles | A probability distribution of a 2D/3D point, represented as a set of random samples (particles) |
| CPointPDFSOGPtr | |
| CPointPDFSOG | Declares a class that represents a Probability Density function (PDF) of a 3D point ![$ p(\mathbf{x}) = [x ~ y ~ z ]^t $](form_55.png) |
| TGaussianMode | The struct for each mode: |
| CPose | A base class for representing a pose in 2D or 3D |
| CPose2DPtr | |
| CPose2D | A class used to store a 2D pose |
| CPose2DGridTemplate | This is a template class for storing a 3D (2D+heading) grid containing any kind of data |
| CPose3DPtr | |
| CPose3D | A class used to store a 3D pose (a 3D translation + a rotation in 3D) |
| CPose3DInterpolatorPtr | |
| CPose3DInterpolator | A trajectory in time and in 6D (CPose3D) that interpolates using splines the intervals between a set of given time-referenced poses |
| CPose3DPDFPtr | |
| CPose3DPDF | Declares a class that represents a Probability Density Function (PDF) of a 3D pose (6D actually) |
| CPose3DPDFGaussianPtr | |
| CPose3DPDFGaussian | Declares a class that represents a Probability Density function (PDF) of a 3D pose ![$ p(\mathbf{x}) = [x ~ y ~ z ~ yaw ~ pitch ~ roll]^t $](form_67.png) |
| CPose3DPDFGaussianInfPtr | |
| CPose3DPDFGaussianInf | Declares a class that represents a Probability Density function (PDF) of a 3D pose as a Gaussian described by its mean and its inverse covariance matrix |
| CPose3DPDFParticlesPtr | |
| CPose3DPDFParticles | Declares a class that represents a Probability Density function (PDF) of a 3D pose |
| CPose3DPDFSOGPtr | |
| CPose3DPDFSOG | Declares a class that represents a Probability Density function (PDF) of a 3D(6D) pose |
| TGaussianMode | The struct for each mode: |
| CPose3DQuatPtr | |
| CPose3DQuat | A class used to store a 3D pose as a translation (x,y,z) and a quaternion (qr,qx,qy,qz) |
| const_iterator | |
| iterator | |
| CPose3DQuatPDFPtr | |
| CPose3DQuatPDF | Declares a class that represents a Probability Density Function (PDF) of a 3D pose (6D actually), by means of a 7-vector with a translation [x y z] and a quaternion [qr qx qy qz] |
| CPose3DQuatPDFGaussianPtr | |
| CPose3DQuatPDFGaussian | Declares a class that represents a Probability Density function (PDF) of a 3D pose using a quaternion ![$ p(\mathbf{x}) = [x ~ y ~ z ~ qr ~ qx ~ qy ~ qz]^\top $](form_73.png) |
| CPose3DQuatPDFGaussianInfPtr | |
| CPose3DQuatPDFGaussianInf | Declares a class that represents a Probability Density function (PDF) of a 3D pose using a quaternion |
| CPose3DRotVecPtr | |
| CPose3DRotVec | A 3D pose (a 3D translation + a rotation in 3D) |
| CPoseOrPoint | The base template class for 2D & 3D points and poses |
| CPosePDFPtr | |
| CPosePDF | Declares a class that represents a probability density function (pdf) of a 2D pose (x,y,phi) |
| CPosePDFGaussianPtr | |
| CPosePDFGaussian | Declares a class that represents a Probability Density function (PDF) of a 2D pose ![$ p(\mathbf{x}) = [x ~ y ~ \phi ]^t $](form_77.png) |
| CPosePDFGaussianInfPtr | |
| CPosePDFGaussianInf | A Probability Density function (PDF) of a 2D pose as a Gaussian with a mean and the inverse of the covariance |
| CPosePDFGridPtr | |
| CPosePDFGrid | Declares a class that represents a Probability Distribution function (PDF) of a 2D pose (x,y,phi) |
| CPosePDFParticlesPtr | |
| CPosePDFParticles | Declares a class that represents a Probability Density Function (PDF) over a 2D pose (x,y,phi), using a set of weighted samples |
| CPosePDFSOGPtr | |
| CPosePDFSOG | Declares a class that represents a Probability Density function (PDF) of a 2D pose |
| TGaussianMode | The struct for each mode: |
| CPoseRandomSampler | An efficient generator of random samples drawn from a given 2D (CPosePDF) or 3D (CPose3DPDF) pose probability density function (pdf) |
| CPoses2DSequencePtr | |
| CPoses2DSequence | This class stores a sequence of relative, incremental 2D poses |
| CPoses3DSequencePtr | |
| CPoses3DSequence | This class stores a sequence of relative, incremental 3D poses |
| CRobot2DPoseEstimator | A simple filter to estimate and extrapolate the robot 2D (x,y,phi) pose from asynchronous odometry and localization data |
| TOptions | |
| SE_traits< 3 > | Specialization of SE for 3D poses |
| SE_traits< 2 > | Specialization of SE for 2D poses |
| random | A namespace of pseudo-random numbers genrators of diferent distributions |
| CRandomGenerator | A thred-safe pseudo random number generator, based on an internal MT19937 randomness generator |
| TMT19937_data | Data used internally by the MT19937 PRNG algorithm |
| reactivenav | This namespace contains classes for building a TP-Space Reactive Navigation System |
| CAbstractHolonomicReactiveMethod | A base class for holonomic reactive navigation methods |
| CReactiveInterfaceImplementation | The pure virtual class that a user of CAbstractReactiveNavigationSystem-derived classes must implement in order to allow the navigator sense the world and send motion commands to the robot |
| CAbstractReactiveNavigationSystem | This is the base class for any reactive navigation system |
| TNavigationParams | The struct for configuring the navigation request |
| CHolonomicLogFileRecordPtr | |
| CHolonomicLogFileRecord | A base class for log records for different holonomic navigation methods |
| CLogFileRecord_NDPtr | |
| CHolonomicND | An implementation of the holonomic reactive navigation method "Nearness-Diagram" |
| TGap | The structure used to store a detected gap in obstacles |
| CLogFileRecord_ND | A class for storing extra information about the execution of CHolonomicND navigation |
| CLogFileRecord_VFFPtr | |
| CLogFileRecord_VFF | A class for storing extra information about the execution of CHolonomicVFF navigation |
| CHolonomicVFF | A holonomic reactive navigation method, based on Virtual Force Fields (VFF) |
| CLogFileRecordPtr | |
| CLogFileRecord | A class for storing, saving and loading a reactive navigation log record for the CReactiveNavigationSystem class |
| TInfoPerPTG | The structure used to store all relevant information about each transformation into TP-Space |
| CParameterizedTrajectoryGenerator | This is the base class for any user defined PTG |
| CColisionGrid | An internal class for storing the collision grid |
| TCellForLambdaFunction | Specifies the min/max values for "k" and "n", respectively |
| TCPoint | The trajectories in the C-Space: |
| CPRRTNavigator | This class is a multi-threaded mobile robot navigator, implementing an (anytime) PTG-based Rapidly-exploring Random Tree (PRRT) search algorithm |
| TOptions | |
| TPathTrackingOpts | |
| TPlannerOpts | |
| TPathData | Each data point in m_planned_path |
| CPTG1 | A PTG for circular paths |
| CPTG2 | The alpha-PTG |
| CPTG3 | A PTG for optimal paths of type "C|C,S" |
| CPTG4 | A PTG for optimal paths of type "C|C" |
| CPTG5 | A PTG for optimal paths of type "C|C,S" |
| CPTG6 | A PTG for circular paths |
| CPTG7 | A PTG for circular paths |
| CReactiveNavigationSystem | Implements a reactive navigation system based on TP-Space, with an arbitrary holonomic reactive method running on it, and any desired number of PTG for transforming the navigation space |
| THolonomicMovement | The structure used for storing a movement generated by a holonomic-method |
| scanmatching | A set of scan matching-related static functions |
| slam | This namespace contains algorithms for SLAM, localization, map building, representation of robot's actions and observations, and representation of many kinds of metric maps |
| detail | |
| logoddscell_traits< int8_t > | |
| logoddscell_traits< int16_t > | |
| TPoseBin2D | Auxiliary structure used in KLD-sampling in particle filters |
| lt_operator | Less-than ordering of bins for usage in STL containers |
| TPathBin2D | Auxiliary structure |
| lt_operator | Less-than ordering of bins for usage in STL containers |
| TPoseBin3D | Auxiliary structure used in KLD-sampling in particle filters |
| lt_operator | Less-than ordering of bins for usage in STL containers |
| CBeaconPtr | |
| CBeacon | The class for storing individual "beacon landmarks" under a variety of 3D position PDF distributions |
| CBeaconMapPtr | |
| CBeaconMap | A class for storing a map of 3D probabilistic beacons, using a Montecarlo, Gaussian, or Sum of Gaussians (SOG) representation (for range-only SLAM) |
| TInsertionOptions | This struct contains data for choosing the method by which new beacons are inserted in the map |
| TLikelihoodOptions | With this struct options are provided to the likelihood computations |
| CColouredPointsMapPtr | |
| CColouredPointsMap | A map of 2D/3D points with individual colours (RGB) |
| TColourOptions | The definition of parameters for generating colors from laser scans |
| CGasConcentrationGridMap2DPtr | |
| CGasConcentrationGridMap2D | CGasConcentrationGridMap2D represents a PDF of gas concentrations over a 2D area |
| TInsertionOptions | Parameters related with inserting observations into the map: |
| CHeightGridMap2DPtr | |
| THeightGridmapCell | The contents of each cell in a CHeightGridMap2D map |
| CHeightGridMap2D | A mesh representation of a surface which keeps the estimated height for each (x,y) location |
| TInsertionOptions | Parameters related with inserting observations into the map |
| CLogOddsGridMap2D | A generic provider of log-odds grid-map maintainance functions |
| CLogOddsGridMapLUT | One static instance of this struct should exist in any class implementing CLogOddsGridMap2D to hold the Look-up-tables (LUTs) for log-odss Bayesian update |
| COccupancyGridMap2DPtr | |
| COccupancyGridMap2D | A class for storing an occupancy grid map |
| TCriticalPointsList | The structure used to store the set of Voronoi diagram critical points |
| TEntropyInfo | Used for returning entropy related information |
| TInsertionOptions | With this struct options are provided to the observation insertion process |
| TLikelihoodOptions | With this struct options are provided to the observation likelihood computation process |
| TLikelihoodOutput | Some members of this struct will contain intermediate or output data after calling "computeObservationLikelihood" for some likelihood functions |
| TUpdateCellsInfoChangeOnly | An internal structure for storing data related to counting the new information apported by some observation |
| CPointsMapPtr | |
| CPointsMap | A cloud of points in 2D or 3D, which can be built from a sequence of laser scans or other sensors |
| TInsertionOptions | With this struct options are provided to the observation insertion process |
| TLaserRange2DInsertContext | Helper struct used for internal_loadFromRangeScan2D_prepareOneRange() |
| TLaserRange3DInsertContext | Helper struct used for internal_loadFromRangeScan3D_prepareOneRange() |
| TLikelihoodOptions | Options used when evaluating "computeObservationLikelihood" in the derived classes |
| CRandomFieldGridMap2DPtr | |
| TRandomFieldCell | The contents of each cell in a CRandomFieldGridMap2D map |
| CRandomFieldGridMap2D | CRandomFieldGridMap2D represents a 2D grid map where each cell is associated one real-valued property which is estimated by this map, either as a simple value or as a probility distribution (for each cell) |
| TInsertionOptionsCommon | Parameters common to any derived class |
| CReflectivityGridMap2DPtr | |
| CReflectivityGridMap2D | A 2D grid map representing the reflectivity of the environment (for example, measured with an IR proximity sensor) |
| TInsertionOptions | Parameters related with inserting observations into the map |
| CSimplePointsMapPtr | |
| CSimplePointsMap | A cloud of points in 2D or 3D, which can be built from a sequence of laser scans |
| CWeightedPointsMapPtr | |
| CWeightedPointsMap | A cloud of points in 2D or 3D, which can be built from a sequence of laser scans |
| CWirelessPowerGridMap2DPtr | |
| CWirelessPowerGridMap2D | CWirelessPowerGridMap2D represents a PDF of wifi concentrations over a 2D area |
| TInsertionOptions | Parameters related with inserting observations into the map: |
| CActionPtr | |
| CAction | Declares a class for storing a robot action |
| CActionCollectionPtr | |
| CActionCollection | Declares a class for storing a collection of robot actions |
| CActionRobotMovement2DPtr | |
| CActionRobotMovement2D | Represents a probabilistic 2D movement of the robot mobile base |
| TMotionModelOptions | The parameter to be passed to "computeFromOdometry" |
| TOptions_GaussianModel | Options for the gaussian model, which generates a CPosePDFGaussian object in poseChange |
| TOptions_ThrunModel | Options for the Thrun's model, which generates a CPosePDFParticles object in poseChange |
| CActionRobotMovement3DPtr | |
| CActionRobotMovement3D | Represents a probabilistic 3D (6D) movement |
| CMetricMapPtr | |
| CMetricMap | Declares a virtual base class for all metric maps storage classes |
| mrptEventMetricMapClear | Event emitted by a metric up upon call of clear() |
| mrptEventMetricMapInsert | Event emitted by a metric up upon a succesful call to insertObservation() |
| CObservationPtr | |
| CObservation | Declares a class that represents any robot's observation |
| T2DScanProperties | Auxiliary struct that holds all the relevant geometry information about a 2D scan |
| CObservation2DRangeScanPtr | |
| CObservation2DRangeScan | A "CObservation"-derived class that represents a 2D range scan measurement (typically from a laser scanner) |
| CObservation3DRangeScanPtr | |
| CObservation3DRangeScan | Declares a class derived from "CObservation" that encapsules a 3D range scan measurement (e.g |
| TCached3DProjTables | Look-up-table struct for project3DPointsFromDepthImageInto() |
| CObservationBatteryStatePtr | |
| CObservationBatteryState | This represents a measurement of the batteries on the robot |
| CObservationBeaconRangesPtr | |
| CObservationBeaconRanges | Declares a class derived from "CObservation" that represents one (or more) range measurements to labeled beacons |
| TMeasurement | Each one of the measurements: |
| CObservationBearingRangePtr | |
| CObservationBearingRange | This observation represents a number of range-bearing value pairs, each one for a detected landmark, which optionally can have identification IDs |
| TMeasurement | Each one of the measurements: |
| CObservationCommentPtr | |
| CObservationComment | This "observation" is actually a placeholder for a text block with comments or additional parameters attached to a given rawlog file |
| CObservationGasSensorsPtr | |
| CObservationGasSensors | Declares a class derived from "CObservation" that represents a set of readings from gas sensors |
| CMOSmodel | Declares a class within "CObservationGasSensors" that represents a set of gas concentration readings from the modelation of a MOS gas sensor readings |
| TdataMap | The content of each m_lastObservations in the estimation when using the option : MOS_MODEl (useMOSmodel =1) |
| TObservationENose | The structure for each e-nose |
| CObservationGPSPtr | |
| CObservationGPS | Declares a class derived from "CObservation" that represents a Global Positioning System (GPS) reading |
| TGPSDatum_GGA | The GPS datum for GGA commands |
| TGPSDatum_PZS | The GPS datum for TopCon's mmGPS devices |
| TGPSDatum_RMC | The GPS datum for RMC commands |
| TGPSDatum_SATS | A generic structure for statistics about tracked satelites and their positions |
| TUTCTime | A UTC time-stamp structure for GPS messages |
| CObservationImagePtr | |
| CObservationImage | Declares a class derived from "CObservation" that encapsules an image from a camera, whose relative pose to robot is also stored |
| CObservationIMUPtr | |
| CObservationIMU | This class stores measurements from an Inertial Measurement Unit (IMU), and/or its attitude estimation (integration of raw measurements) |
| CObservationOdometryPtr | |
| CObservationOdometry | An observation of the current (cumulative) odometry for a wheeled robot |
| CObservationRangePtr | |
| CObservationRange | Declares a class derived from "CObservation" that encapsules a single range measurement, and associated parameters |
| TMeasurement | |
| CObservationReflectivityPtr | |
| CObservationReflectivity | Declares a class derived from "CObservation" that encapsules a single short-range reflectivity measurement |
| CObservationRFIDPtr | |
| CObservationRFID | This represents one or more RFID tags observed by a receiver |
| TTagReading | Each of the individual readings of a RFID tag |
| CObservationStereoImagesPtr | |
| CObservationStereoImages | Observation class for either a pair of left+right or left+disparity images from a stereo camera |
| TStereoImageFeatures | |
| CObservationStereoImagesFeaturesPtr | |
| CObservationStereoImagesFeatures | Declares a class derived from "CObservation" that encapsules a pair of cameras and a set of matched image features extracted from them |
| CObservationWirelessPowerPtr | |
| CObservationWirelessPower | This represents a measurement of the wireless strength perceived by the robot |
| CRawlogPtr | |
| CRawlog | This class stores a rawlog (robotic datasets) in one of two possible formats: |
| const_iterator | A normal iterator, plus the extra method "getType" to determine the type of each entry in the sequence |
| iterator | A normal iterator, plus the extra method "getType" to determine the type of each entry in the sequence |
| CSensoryFramePtr | |
| CSensoryFrame | Declares a class for storing a "sensory frame", a set of "observations" taken by the robot approximately at the same time as one "snapshot" of the environment |
| CSimpleMapPtr | |
| CSimpleMap | This class stores a sequence of <Probabilistic Pose,SensoryFrame> pairs, thus a "metric map" can be totally determined with this information |
| CSinCosLookUpTableFor2DScans | A smart look-up-table (LUT) of sin/cos values for 2D laser scans |
| TSinCosValues | A pair of vectors with the cos and sin values |
| CDetectorDoorCrossing | |
| TDoorCrossingOutParams | A structure used as output in this method |
| TOptions | In this structure parameters can be changed to customize the behaviour of this algorithm |
| CGridMapAligner | A class for aligning two multi-metric maps (with an occupancy grid maps and a points map, at least) based on features extraction and matching |
| TConfigParams | The ICP algorithm configuration data |
| TReturnInfo | The ICP algorithm return information |
| TPairPlusDistance | |
| CICP | Several implementations of ICP (Iterative closest point) algorithms for aligning two point maps or a point map wrt a grid map |
| TConfigParams | The ICP algorithm configuration data |
| TReturnInfo | The ICP algorithm return information |
| CIncrementalMapPartitionerPtr | |
| CIncrementalMapPartitioner | This class can be used to make partitions on a map/graph build from observations taken at some poses/nodes |
| TOptions | Configuration of the algorithm: |
| CMetricMapBuilder | This virtual class is the base for SLAM implementations |
| TOptions | Options for the algorithm |
| CMetricMapBuilderICP | A class for very simple 2D SLAM based on ICP |
| TConfigParams | Algorithm configuration params |
| TDist | Traveled distances from last map update / ICP-based localization |
| CMetricMapBuilderRBPF | This class implements a Rao-Blackwelized Particle Filter (RBPF) approach to map building (SLAM) |
| TConstructionOptions | Options for building a CMetricMapBuilderRBPF object, passed to the constructor |
| TStats | This structure will hold stats after each execution of processActionObservation |
| CMetricMapsAlignmentAlgorithm | A base class for any algorithm able of maps alignment |
| CMonteCarloLocalization2D | Declares a class that represents a Probability Density Function (PDF) over a 2D pose (x,y,phi), using a set of weighted samples |
| CMonteCarloLocalization3D | Declares a class that represents a Probability Density Function (PDF) over a 3D pose (x,y,phi,yaw,pitch,roll), using a set of weighted samples |
| CMultiMetricMapPtr | |
| CMultiMetricMap | This class stores any customizable set of metric maps |
| TOptions | Some options for this class: |
| TMetricMapInitializer | Each structure of this kind will determine the kind (and initial configuration) of one map to be build into a CMultiMetricMap object |
| CBeaconMapOptions | Specific options for landmarks maps (mrpt::slam::CBeaconMap) |
| CColouredPointsMapOptions | Specific options for coloured point maps (mrpt::slam::CPointsMap) |
| CGasConcentrationGridMap2DOptions | Specific options for gas grid maps (mrpt::slam::CGasConcentrationGridMap2D) |
| CHeightGridMap2DOptions | Specific options for height grid maps (mrpt::slam::CHeightGridMap2D) |
| CLandmarksMapOptions | Specific options for landmarks maps (mrpt::slam::CLandmarksMap) |
| CPointsMapOptions | Specific options for point maps (mrpt::slam::CPointsMap) |
| CReflectivityGridMap2DOptions | Specific options for height grid maps (mrpt::slam::CReflectivityGridMap2D) |
| CWeightedPointsMapOptions | Specific options for coloured point maps (mrpt::slam::CPointsMap) |
| CWirelessPowerGridMap2DOptions | Specific options for wifi grid maps (mrpt::slam::CWirelessPowerGridMap2D) |
| TOccGridMap2DOptions | Specific options for grid maps (mrpt::slam::COccupancyGridMap2D) |
| TSetOfMetricMapInitializers | A set of TMetricMapInitializer structures, passed to the constructor CMultiMetricMap::CMultiMetricMap See the comments for TSetOfMetricMapInitializers::loadFromConfigFile, and "CMultiMetricMap::setListOfMaps" for effectively creating the list of desired maps |
| CRBPFParticleDataPtr | |
| CRBPFParticleData | Auxiliary class used in mrpt::slam::CMultiMetricMapPDF |
| CMultiMetricMapPDFPtr | |
| CMultiMetricMapPDF | Declares a class that represents a Rao-Blackwellized set of particles for solving the SLAM problem (This class is the base of RBPF-SLAM applications) |
| TPredictionParams | The struct for passing extra simulation parameters to the prediction/update stage when running a particle filter |
| COccupancyGridMapFeatureExtractor | A class for detecting features from occupancy grid maps |
| CPathPlanningCircularRobot | An implementation of CPathPlanningMethod |
| CPathPlanningMethod | A virtual base class for computing the optimal path for a robot from a origin location to a target point |
| CRangeBearingKFSLAM | An implementation of EKF-based SLAM with range-bearing sensors, odometry, a full 6D robot pose, and 3D landmarks |
| TDataAssocInfo | Information for data-association: |
| TOptions | The options for the algorithm |
| CRangeBearingKFSLAM2D | An implementation of EKF-based SLAM with range-bearing sensors, odometry, and a 2D (+heading) robot pose, and 2D landmarks |
| TDataAssocInfo | Information for data-association: |
| TOptions | The options for the algorithm |
| CRejectionSamplingRangeOnlyLocalization | An implementation of rejection sampling for generating 2D robot pose from range-only measurements within a landmarks (beacons) map |
| TDataPerBeacon | Data for each beacon observation with a correspondence with the map |
| TDataAssociationResults | The results from mrpt::slam::data_association |
| PF_implementation | A set of common data shared by PF implementations for both SLAM and localization |
| TKLDParams | Option set for KLD algorithm |
| TMonteCarloLocalizationParams | The struct for passing extra simulation parameters to the prediction stage when running a particle filter |
| CLandmarkPtr | |
| CLandmark | The class for storing "landmarks" (visual or laser-scan-extracted features,...) |
| CLandmarksMapPtr | |
| CLandmarksMap | A class for storing a map of 3D probabilistic landmarks |
| TCustomSequenceLandmarks | The list of landmarks: the wrapper class is just for maintaining the KD-Tree representation |
| TFuseOptions | With this struct options are provided to the fusion process |
| TInsertionOptions | With this struct options are provided to the observation insertion process |
| TInsertionResults | This struct stores extra results from invoking insertObservation |
| TLikelihoodOptions | With this struct options are provided to the likelihood computations |
| TGPSOrigin | This struct store de GPS longitude, latitude (in degrees ) and altitude (in meters) for the first GPS observation compose with de sensor position on the robot |
| CObservationVisualLandmarksPtr | |
| CObservationVisualLandmarks | Declares a class derived from "CObservation" that stores a Landmarks Map as seen from a stereo camera at a given instant of time |
| stlplus | |
| null_dereference | |
| end_dereference | |
| wrong_object | |
| illegal_copy | |
| smart_ptr_base | |
| constructor_copy | |
| clone_copy | |
| no_copy | |
| smart_ptr | |
| smart_ptr_clone | |
| smart_ptr_nocopy | |
| synch | This namespace provides multitask, synchronization utilities |
| CAtomicCounter | This class acts exactly as an int (or long) variable, but with atomic increment and decrement operators |
| CCriticalSection | This class provides simple critical sections functionality |
| CCriticalSectionLocker | A class acquiring a CCriticalSection at its constructor, and releasing it at destructor |
| CEvent | This class provides a simple way of waiting for and signaling events (NOT IMPLEMENTED YET!) |
| CSemaphore | A semaphore for inter-thread synchronization |
| CThreadSafeVariable | A template for created thread-safe variables with an internal critical section controlled each read or write |
| MT_buffer | This class is a bulk sequence of bytes with MultiThread (MT)-safe read and write operations |
| system | This namespace provides a OS-independent interface to many useful functions: filenames manipulation, time and date, string parsing, file I/O, threading, memory allocation, etc |
| detail | Auxiliary classes used internally to MRPT |
| ThreadCreateFunctor | |
| ThreadCreateFunctor< void * > | |
| ThreadCreateFunctorNoParams | |
| ThreadCreateObjectFunctor | |
| ThreadCreateObjectFunctorNoParams | |
| os | This namespace provides a OS-independent interface to low-level functions |
| CDirectoryExplorer | This class allows the enumeration of the files/directories that exist into a given path |
| TFileInfo | This represents the information about each file |
| CFileSystemWatcher | This class subscribes to notifications of file system changes, thus it can be used to efficiently stay informed about changes in a directory tree |
| TFileSystemChange | Each of the changes detected by utils::CFileSystemWatcher |
| CGenericMemoryPool | A generic system for versatile memory pooling |
| TTimeParts | The parts of a date/time (it's like the standard 'tm' but with fractions of seconds) |
| BlockedRange | |
| Split | |
| TThreadHandle | This structure contains the information needed to interface the threads API on each platform: |
| topography | This namespace provides topography helper functions, coordinate transformations |
| TCoords | A coordinate that is stored as a simple "decimal" angle in degrees, but can be retrieved/set in the form of DEGREES + arc-MINUTES + arc-SECONDS |
| TEllipsoid | |
| TGeodeticCoords | A set of geodetic coordinates: latitude, longitude and height, defined over a given geoid (typically, WGS84) |
| TDatum7Params | Parameters for a topographic transfomation |
| TDatum7Params_TOPCON | |
| TDatum10Params | Parameters for a topographic transfomation |
| TDatumHelmert2D | Parameters for a topographic transfomation |
| TDatumHelmert2D_TOPCON | |
| TDatumHelmert3D | Parameters for a topographic transfomation |
| TDatumHelmert3D_TOPCON | Parameters for a topographic transfomation |
| TDatum1DTransf | Parameters for a topographic transfomation |
| TDatumTransfInterpolation | Parameters for a topographic transfomation |
| TPathFromRTKInfo | Used to return optional information from mrpt::topography::path_from_rtk_gps |
| utils | Classes for serialization, sockets, ini-file manipulation, streams, list of properties-values, timewatch, extensions to STL |
| detail | |
| PointCloudAdapterHelperNoRGB | A helper base class for those PointCloudAdapter<> which do not handle RGB data; it declares needed interface methods which fall back to XYZ-only methods |
| metaprogramming | A set of utility objects for metaprogramming with STL algorithms |
| ObjectDelete | An object for deleting pointers (intended for STL algorithms) |
| ObjectClear | An object for clearing an object (invokes its method "->clear()") given a pointer or smart-pointer, intended for being used in STL algorithms |
| ObjectClear2 | An object for clearing an object (invokes its method ".clear()") given a pointer or smart-pointer, intended for being used in STL algorithms |
| ObjectClearSecond | An object for clearing an object->second (invokes its method "clear()") given a pointer or smart-pointer, intended for being used in STL algorithms |
| ObjectConvert | An object for transforming between types/classes, intended for being used in STL algorithms |
| ObjectMakeUnique | An object for making smart pointers unique (ie, making copies if necessary), intended for being used in STL algorithms |
| ObjectPairMakeUnique | An object for making smart pointers unique (ie, making copies if necessary), intended for being used in STL algorithms |
| ObjectClearUnique | An object for making smart pointers unique (ie, making copies if necessary), intended for being used in STL algorithms |
| ObjectReadFromStream | An object for reading objects from a stream, intended for being used in STL algorithms |
| ObjectWriteToStream | An object for writing objects to a stream, intended for being used in STL algorithms |
| MemoryBypasserIterator | This class bypasses pointer access in iterators to pointers, thus allowing the use of algorithms that expect an object of class T with containers of T* |
| BinaryMemberFunctionWrapper | This template encapsulates a binary member function and a single object into a function expecting the two parameters of the member function |
| UnaryMemberFunctionWrapper | This template encapsulates an unary member function and a single object into a function expecting the parameter of the member function |
| MemberFunctionWrapper | This template encapsulates a member function without arguments and a single object into a function |
| NonConstBind1st | Equivalent of std::bind1st for functions with non-const arguments |
| NonConstBind2nd | Equivalent of std::bind2nd for functions with non-const arguments |
| net | A set of useful routines for networking |
| TTypeName< mrpt::math::CArrayNumeric< T, N > > | |
| TTypeName< mrpt::math::CArrayDouble< N > > | |
| TTypeName< mrpt::math::CArrayFloat< N > > | |
| TTypeName< mrpt::math::CMatrixFixedNumeric< T, N, M > > | |
| TTypeName< mrpt::math::CMatrixTemplateNumeric< T > > | |
| TEnumTypeFiller< poses::CPose3DInterpolator::TInterpolatorMethod > | |
| bimap | A bidirectional version of std::map, declared as bimap<KEY,VALUE> and which actually contains two std::map's, one for keys and another for values |
| CProfilerProxy | |
| CCanvas | This virtual class defines the interface of any object accepting drawing primitives on it |
| CClientTCPSocket | A TCP socket that can be connected to a TCP server, implementing MRPT's CStream interface for passing objects as well as generic read/write methods |
| CConfigFile | This class allows loading and storing values and vectors of different types from ".ini" files easily |
| CConfigFileBase | This class allows loading and storing values and vectors of different types from a configuration text, which can be implemented as a ".ini" file, a memory-stored string, etc.. |
| CConfigFileMemory | This class implements a config file-like interface over a memory-stored string list |
| CConsoleRedirector | By creating an object of this class, all the output to std::cout (and std::cerr) will be redirected to a text file, and optionally also shown on the console |
| CDebugOutputCapable | This base class provides a common printf-like method to send debug information to std::cout, with the purpose of allowing its redirection to other streams if desired |
| CDynamicGrid | A 2D grid of dynamic size which stores any kind of data at each cell |
| CEnhancedMetaFile | This class represents a Windows Enhanced Meta File (EMF) for generating and saving graphics |
| CFileGZInputStream | Transparently opens a compressed "gz" file and reads uncompressed data from it |
| CFileInputStream | This CStream derived class allow using a file as a read-only, binary stream |
| CFileOutputStream | This CStream derived class allow using a file as a write-only, binary stream |
| CFileStream | This CStream derived class allow using a file as a read/write binary stream, creating it if the file didn't exist |
| CImagePtr | |
| CImage | A class for storing images as grayscale or RGB bitmaps |
| circular_buffer | A circular buffer of fixed size (defined at construction-time), implemented with a std::vector as the underlying storage |
| CListOfClasses | A list (actually based on a std::set) of MRPT classes, capable of keeping any class registered by the mechanism of CSerializable classes |
| CLoadableOptions | This is a virtual base class for sets of options than can be loaded from and/or saved to configuration plain-text files |
| CLog | A decorator of CStringList special for keeping logs |
| CMappedImage | This class encapsulates a MRPT Image and allows the sampling of individual pixels with sub-pixel accuracy and with a change of coordinates (eg, meters) |
| CMemoryChunkPtr | |
| CMemoryChunk | A memory buffer (implements CStream) which can be itself serialized |
| CMemoryStream | This CStream derived class allow using a memory buffer as a CStream |
| CMessage | A class that contain generic messages, that can be sent and received from a "CClientTCPSocket" object |
| CMHPropertiesValuesListPtr | |
| TPropertyValueIDTriplet | Internal triplet for each property in utils::CMHPropertiesValuesList |
| CMHPropertiesValuesList | An arbitrary list of "annotations", or named attributes, each being an instance of any CSerializable object (Multi-hypotheses version) |
| CObjectPtr | A smart pointer to a CObject object |
| TRuntimeClassId | A structure that holds runtime class type information |
| CLASSINIT | Auxiliary structure used for CObject-based RTTI |
| CObject | The virtual base class of all MRPT classes with a unified RTTI system |
| CObservable | Inherit from this class for those objects capable of being observed by a CObserver class |
| CObserver | Inherit from this class to get notified about events from any CObservable object after subscribing to it |
| CProbabilityDensityFunction | A generic template for probability density distributions (PDFs) |
| CPropertiesValuesListPtr | |
| CPropertiesValuesList | An arbitrary list of "annotations", or named attributes, each being an instance of any CSerializable object |
| TPropertyValuePair | |
| CReferencedMemBlock | Represents a memory block (via "void*") that can be shared between several objects through copy operator (=) |
| CRobotSimulator | This class can be used to simulate the kinematics and dynamics of a differential driven planar mobile robot, including odometry errors and dynamics limitations |
| CSerializablePtr | |
| CSerializable | The virtual base class which provides a unified interface for all persistent objects in MRPT |
| TTypeName | A template to obtain the type of its argument as a string at compile time |
| TTypeName< std::pair< T1, T2 > > | |
| CServerTCPSocket | A TCP socket that can be wait for client connections to enter |
| CSimpleDatabasePtr | |
| CSimpleDatabaseTablePtr | |
| CSimpleDatabaseTable | This class implements the tables of databases |
| CSimpleDatabase | This class impements a very simple database system |
| CStartUpClassesRegister | A helper class that automatically register at start up a custom function to register all the CObject-derived classes in a given MRPT library or user application |
| CStdOutStream | This CStdOutStream derived class allow printing to standard out, normally the console text output |
| CStream | This base class is used to provide a unified interface to files,memory buffers,..Please see the derived classes |
| CStringListPtr | |
| CStringList | A class for storing a list of text lines |
| CTextFileLinesParser | A class for parsing text files, returning each non-empty and non-comment line, along its line number |
| CThreadSafeQueue | A thread-safe template queue for object passing between threads; for a template argument of T, the objects being passed in the queue are "T*" |
| CTicTac | This class implements a high-performance stopwatch |
| CTimeLogger | A versatile "profiler" that logs the time spent within each pair of calls to enter(X)-leave(X), among other stats |
| TCallData | Data of all the calls: |
| CTypeSelectorPtr | |
| CTypeSelector | This class represents a std::string derived class which is also CSerializable |
| CUncopiable | The base class of classes that cannot be copied: compile-time errors will be issued on any copy operation |
| CMRPTException | The base for MRPT-especific exceptions |
| CExceptionExternalImageNotFound | Used in mrpt::utils::CImage |
| CExceptionEOF | Used in mrpt::utils::CStream |
| list_searchable | This class implements a STL container with features of both, a std::set and a std::list |
| map_as_vector | A STL-like container which looks and behaves (almost exactly) like a std::map<> but is implemented as a linear std::vector<> indexed by KEY |
| mrptEvent | The basic event type for the observer-observable pattern in MRPT |
| mrptEventOnDestroy | An event sent by any CObservable object (automatically) just before being destroyed and telling its observers to unsubscribe |
| PLY_Importer | A virtual base class that implements the capability of importing 3D point clouds and faces from a file in the Stanford PLY format |
| PLY_Exporter | A virtual base class that implements the capability of exporting 3D point clouds and faces to a file in the Stanford PLY format |
| safe_ptr_basic | A wrapper class for pointers that can be safely copied with "=" operator without problems |
| safe_ptr | A wrapper class for pointers that can be safely copied with "=" operator without problems |
| non_copiable_ptr_basic | A wrapper class for pointers that can NOT be copied with "=" operator, raising an exception at runtime if a copy is attempted |
| non_copiable_ptr | A wrapper class for pointers that can NOT be copied with "=" operator, raising an exception at runtime if a copy is attempted |
| copiable_NULL_ptr_basic | A wrapper class for pointers that, if copied with the "=" operator, should be set to NULL in the copy |
| copiable_NULL_ptr | A wrapper class for pointers that, if copied with the "=" operator, should be set to NULL in the new copy |
| ci_less | A case-insensitive comparator struct for usage within STL containers, eg: map<string,string,ci_less> |
| nocase_compare | |
| TCameraPtr | |
| TCamera | Structure to hold the parameters of a pinhole camera model |
| TColor | A RGB color - 8bit |
| TColorf | A RGB color - floats in the range [0,1] |
| TEnumTypeFiller | Only specializations of this class are defined for each enum type of interest |
| TEnumType | A helper class that can convert an enum value into its textual representation, and viceversa |
| TMatchingPair | A structure for holding correspondences between two sets of points or points-like entities in 2D or 3D |
| TMatchingPairList | A list of TMatchingPair |
| TParameters | For usage when passing a dynamic number of (numeric) arguments to a function, by name |
| TPixelCoordf | A pair (x,y) of pixel coordinates (subpixel resolution) |
| TPixelCoord | A pair (x,y) of pixel coordinates (integer resolution) |
| map_traits_stdmap | Traits for using a std::map<> (sparse representation) |
| map | |
| map_traits_map_as_vector | Traits for using a mrpt::utils::map_as_vector<> (dense, fastest representation) |
| map | |
| TStereoCameraPtr | |
| TStereoCamera | Structure to hold the parameters of a pinhole stereo camera model |
| TEnumTypeFiller< bayes::TKFMethod > | |
| TEnumTypeFiller< hwdrivers::CKinect::TVideoChannel > | |
| PointCloudAdapter< mrpt::slam::CColouredPointsMap > | Specialization mrpt::utils::PointCloudAdapter<mrpt::slam::CColouredPointsMap> |
| TEnumTypeFiller< slam::CHeightGridMap2D::TMapRepresentation > | |
| PointCloudAdapter< mrpt::slam::CPointsMap > | Specialization mrpt::utils::PointCloudAdapter<mrpt::slam::CPointsMap> |
| TEnumTypeFiller< slam::CRandomFieldGridMap2D::TMapRepresentation > | |
| PointCloudAdapter< mrpt::slam::CSimplePointsMap > | Specialization mrpt::utils::PointCloudAdapter<mrpt::slam::CSimplePointsMap> |
| PointCloudAdapter< mrpt::slam::CWeightedPointsMap > | Specialization mrpt::utils::PointCloudAdapter<mrpt::slam::CWeightedPointsMap> |
| PointCloudAdapter< pcl::PointCloud< pcl::PointXYZ > > | Specialization mrpt::utils::PointCloudAdapter<pcl::PointCloud<pcl::PointXYZ> > for an XYZ point cloud (without RGB) |
| PointCloudAdapter< pcl::PointCloud< pcl::PointXYZRGB > > | Specialization mrpt::utils::PointCloudAdapter<pcl::PointCloud<pcl::PointXYZRGB> > for an XYZ point cloud with RGB |
| PointCloudAdapter< pcl::PointCloud< pcl::PointXYZRGBA > > | Specialization mrpt::utils::PointCloudAdapter<pcl::PointCloud<pcl::PointXYZRGBA> > for an XYZ point cloud with RGB |
| TEnumTypeFiller< slam::CObservation3DRangeScan::TIntensityChannelID > | |
| PointCloudAdapter< CObservation3DRangeScan > | Specialization mrpt::utils::PointCloudAdapter<CObservation3DRangeScan> |
| PointCloudAdapter< mrpt::opengl::CPointCloud > | Specialization mrpt::utils::PointCloudAdapter<mrpt::opengl::CPointCloud> |
| PointCloudAdapter< mrpt::opengl::CPointCloudColoured > | Specialization mrpt::utils::PointCloudAdapter<mrpt::opengl::CPointCloudColoured> |
| TEnumTypeFiller< slam::CMultiMetricMap::TOptions::TMapSelectionForLikelihood > | |
| TEnumTypeFiller< slam::TDataAssociationMethod > | |
| TEnumTypeFiller< slam::TDataAssociationMetric > | |
| vision | Classes for computer vision, detectors, features, etc |
| detail | |
| TSIFTDesc2KDTree_Adaptor | |
| TSURFDesc2KDTree_Adaptor | |
| pinhole | Functions related to pinhole camera models, point projections, etc |
| CCamModel | This class represent a pinhole camera model for Monocular SLAM and implements some associated Jacobians |
| CameraTempVariables | |
| CFeaturePtr | |
| CFeature | A generic 2D feature from an image, extracted with CFeatureExtraction Each feature may have one or more descriptors (see descriptors), in addition to an image patch |
| TDescriptors | All the possible descriptors this feature may have |
| CFeatureList | A list of visual features, to be used as output by detectors, as input/output by trackers, etc |
| CMatchedFeatureList | A list of features |
| CFeatureExtraction | The central class from which images can be analyzed in search of different kinds of interest points and descriptors computed for them |
| TOptions | The set of parameters for all the detectors & descriptor algorithms |
| TBCDOptions | BCD Options |
| TFASTOptions | FAST and FASTER Options |
| THarrisOptions | Harris Options |
| TKLTOptions | KLT Options |
| TLogPolarImagesOptions | LogPolarImagesOptions Options |
| TPolarImagesOptions | PolarImagesOptions Options |
| TSIFTOptions | SIFT Options |
| TSpinImagesOptions | |
| TSURFOptions | |
| TImageCalibData | Data associated to each image in the calibration process mrpt::vision::checkerBoardCameraCalibration (All the information can be left empty and will be filled up in the calibration method) |
| TImageStereoCalibData | Data associated to each stereo image in the calibration process mrpt::vision::checkerBoardCameraCalibration (All the information can be left empty and will be filled up in the calibration method) |
| TImageStereoCallbackData | Params of the optional callback provided by the user |
| TStereoCalibParams | Input parameters for mrpt::vision::checkerBoardStereoCalibration |
| TStereoCalibResults | Output results for mrpt::vision::checkerBoardStereoCalibration |
| CImagePyramid | Holds and builds a pyramid of images: starting with an image at full resolution (octave=1), it builds a number of half-resolution images: octave=2 at 1/2 , octave=3 at 1/2^2, octave=N at 1/2^(N-1) |
| CStereoRectifyMap | Use this class to rectify stereo images if the same distortion maps are reused over and over again |
| CUndistortMap | Use this class to undistort monocular images if the same distortion map is used over and over again |
| CVideoFileWriter | An output stream which takes a sequence of images and writes a video file in any of a given of compatible formats |
| TSIFTDescriptorsKDTreeIndex | A kd-tree builder for sets of features with SIFT descriptors |
| TSURFDescriptorsKDTreeIndex | A kd-tree builder for sets of features with SURF descriptors |
| RobustKernel< static_cast< int >(rkLeastSquares), T > | No robust kernel, use standard least squares: rho(r)= 1/2 * r^2 |
| RobustKernel< static_cast< int >(rkPseudoHuber), T > | Pseudo-huber robust kernel: rho(r) = b^2 * (-1+sqrt(1+(r)^2)) |
| CGenericFeatureTracker | A virtual interface for all feature trackers, implementing the part of feature tracking that is common to any specific tracker implementation |
| TExtraOutputInfo | |
| CFeatureTracker_KL | Track a set of features from old_img -> new_img using sparse optimal flow (classic KL method) |
| CFeatureTracker_FAST | Track a set of features from old_img -> new_img by patch correlation over the closest FAST features, using a KD-tree for looking closest correspondences |
| CFeatureTracker_PatchMatch | Track a set of features from old_img -> new_img by patch matching over a fixed window centered at each feature's previous location |
| TSimpleFeature_templ | A simple structure for representing one image feature (without descriptor nor patch) - This is the template which allows you to select if pixels are represented as integers or floats |
| TSimpleFeatureTraits< TSimpleFeature > | |
| TSimpleFeatureTraits< TSimpleFeaturef > | |
| TSimpleFeatureList_templ | A list of image features using the structure TSimpleFeature for each feature - capable of KD-tree computations Users normally use directly the typedef's: TSimpleFeatureList & TSimpleFeaturefList |
| KeypointResponseSorter | A helper struct to sort keypoints by their response: It can be used with these types: |
| CFeatureListKDTree | Helper class: KD-tree search class for vector<KeyPoint>: Call mark_as_outdated() to force rebuilding the kd-tree after modifying the linked feature list |
| TFeatureObservation | One feature observation entry, used within sequences with TSequenceFeatureObservations |
| TRelativeFeaturePos | One relative feature observation entry, used with some relative bundle-adjustment functions |
| TSequenceFeatureObservations | A complete sequence of observations of features from different camera frames (poses) |
| TStereoSystemParams | Parameters associated to a stereo system |
| TROI | A structure for storing a 3D ROI |
| TImageROI | A structure for defining a ROI within an image |
| TMatchingOptions | A structure containing options for the matching |
| TMultiResMatchingOutput | Struct containing the output after matching multi-resolution SIFT-like descriptors |
| TMultiResDescMatchOptions | Struct containing the options when matching multi-resolution SIFT-like descriptors |
| TMultiResDescOptions | Struct containing the options when computing the multi-resolution SIFT-like descriptors |
| dynamicsize_vector | The base class of MRPT vectors, actually, Eigen column matrices of dynamic size with specialized constructors that resemble std::vector |
| aligned_containers | Helper types for STL containers with Eigen memory allocators |
| nanoflann | |
| KNNResultSet | |
| RadiusResultSet | A result-set class used when performing a radius based search |
| IndexDist_Sorter | Operator "<" for std::sort() |
| L1_Adaptor | Manhattan distance functor (generic version, optimized for high-dimensionality data sets) |
| L2_Adaptor | Squared Euclidean distance functor (generic version, optimized for high-dimensionality data sets) |
| L2_Simple_Adaptor | Squared Euclidean distance functor (suitable for low-dimensionality datasets, like 2D or 3D point clouds) Corresponding distance traits: nanoflann::metric_L2_Simple |
| metric_L1 | Metaprogramming helper traits class for the L1 (Manhattan) metric |
| traits | |
| metric_L2 | Metaprogramming helper traits class for the L2 (Euclidean) metric |
| traits | |
| metric_L2_Simple | Metaprogramming helper traits class for the L2_simple (Euclidean) metric |
| traits | |
| KDTreeSingleIndexAdaptorParams | Parameters (see http://code.google.com/p/nanoflann/ for help choosing the parameters) |
| SearchParams | Search options for KDTreeSingleIndexAdaptor::findNeighbors() |
| PooledAllocator | |
| KDTreeSingleIndexAdaptor | Kd-tree index |
| BranchStruct | This record represents a branch point when finding neighbors in the tree |
| Interval | |
| Node | |
| KDTreeEigenMatrixAdaptor | A simple KD-tree adaptor for working with data directly stored in an Eigen Matrix, without duplicating the data storage |
| stlplus | |
| null_dereference | |
| end_dereference | |
| wrong_object | |
| illegal_copy | |
| smart_ptr_base | |
| constructor_copy | |
| clone_copy | |
| no_copy | |
| smart_ptr | |
| smart_ptr_clone | |
| smart_ptr_nocopy | |
| smart_ptr_holder | |
| TCLAP | |
| MULTI_ARG_HELPER | |
| ValueExtractor | This class is used to extract a value from an argument |
| ValueExtractor< std::string > | Specialization for string |
| VALUE_ARG_HELPER | |
| ValueExtractor | This class is used to extract a value from an argument |
| ValueExtractor< std::string > | Specialization for string |
| Arg | A virtual base class that defines the essential data for all arguments |
| ArgException | A simple class that defines and argument exception |
| ArgParseException | Thrown from within the child Arg classes when it fails to properly parse the argument it has been passed |
| CmdLineParseException | Thrown from CmdLine when the arguments on the command line are not properly specified, e.g |
| SpecificationException | Thrown from Arg and CmdLine when an Arg is improperly specified, e.g |
| ActionDoneException | (Added by JLBC for MRPT): An exception that indicates to CmdLine::parse that help,version,.. |
| CmdLine | The base class that manages the command line definition and passes along the parsing to the appropriate Arg classes |
| CmdLineInterface | The base class that manages the command line definition and passes along the parsing to the appropriate Arg classes |
| CmdLineOutput | The interface that any output object must implement |
| Constraint | The interface that defines the interaction between the Arg and Constraint |
| DocBookOutput | A class that generates DocBook output for usage() method for the given CmdLine and its Args |
| HelpVisitor | A Visitor object that calls the usage method of the given CmdLineOutput object for the specified CmdLine object |
| IgnoreRestVisitor | A Vistor that tells the CmdLine to begin ignoring arguments after this one is parsed |
| MultiArg | An argument that allows multiple values of type T to be specified |
| MultiSwitchArg | A multiple switch argument |
| OptionalUnlabeledTracker | |
| StdOutput | A class that isolates any output from the CmdLine object so that it may be easily modified |
| SwitchArg | A simple switch argument |
| UnlabeledMultiArg | Just like a MultiArg, except that the arguments are unlabeled |
| UnlabeledValueArg | The basic unlabeled argument that parses a value |
| ValueArg | The basic labeled argument that parses a value |
| ValuesConstraint | A Constraint that constrains the Arg to only those values specified in the constraint |
| VersionVisitor | A Vistor that will call the version method of the given CmdLineOutput for the specified CmdLine object and then exit |
| Visitor | A base class that defines the interface for visitors |
| XorHandler | This class handles lists of Arg's that are to be XOR'd on the command line |
| AuxErrorEval | |
| CKalmanFilterCapable | |
| CMatrixTemplate | |
| CMatrixTemplate | |
| CMatrixTemplateObjects | |
| CMatrixTemplateObjects | |
| CPoseOrPoint | |
| getVicinity | This huge template encapsulates a function to get the vicinity of an element, with maximum genericity |
| getVicinity | This huge template encapsulates a function to get the vicinity of an element, with maximum genericity |
| getVicinity | This huge template encapsulates a function to get the vicinity of an element, with maximum genericity |
| graph_ops | |
| imaxdiv_t | |
| loadFromRangeImpl | |
| logoddscell_traits | |
| MatrixWrapper | This template is a trick to switch the type of a variable using a boolean variable in the template |
| mpBitmapLayer | This virtual class represents objects that can be moved to an arbitrary 2D location+rotation |
| mpCovarianceEllipse | A 2D ellipse, described by a 2x2 covariance matrix |
| mpFX | Abstract base class providing plot and labeling functionality for functions F:X->Y |
| mpFXY | Abstract base class providing plot and labeling functionality for a locus plot F:N->X,Y |
| mpFXYVector | A class providing graphs functionality for a 2D plot (either continuous or a set of points), from vectors of data |
| mpFY | Abstract base class providing plot and labeling functionality for functions F:Y->X |
| mpInfoCoords | Implements an overlay box which shows the mouse coordinates in plot units |
| mpInfoLayer | Base class to create small rectangular info boxes mpInfoLayer is the base class to create a small rectangular info box in transparent overlay over plot layers |
| mpInfoLegend | Implements the legend to be added to the plot This layer allows you to add a legend to describe the plots in the window |
| mpLayer | Plot layer, abstract base class |
| mpMovableObject | This virtual class represents objects that can be moved to an arbitrary 2D location+rotation |
| mpPolygon | An arbitrary polygon, descendant of mpMovableObject |
| mpPrintout | Printout class used by mpWindow to draw in the objects to be printed |
| mpProfile | Abstract base class providing plot and labeling functionality for functions F:Y->X |
| mpScaleX | Plot layer implementing a x-scale ruler |
| mpScaleY | Plot layer implementing a y-scale ruler |
| mpText | Plot layer implementing a text string |
| mpWindow | Canvas for plotting mpLayer implementations |
| MultiArg | |
| PointCloudAdapter | An adapter to different kinds of point cloud object |
| PointCloudAdapter | An adapter to different kinds of point cloud object |
| pointmap_traits | |
| pose_point_impl | |
| RobustKernel | |
| smart_ptr_holder | |
| smart_ptr_holder | |
| T3DTypeHelper | |
| TSIFTDesc2KDTree_Adaptor | |
| TSimpleFeatureTraits | |
| TSURFDesc2KDTree_Adaptor | |
| ValueArg | |
| VicinityTraits | The purpose of this class is to model traits for containers, so that they can be used as return values for the function CMatrixTemplate::getVicinity |
| VicinityTraits | The purpose of this class is to model traits for containers, so that they can be used as return values for the function CMatrixTemplate::getVicinity |
| VicinityTraits | The purpose of this class is to model traits for containers, so that they can be used as return values for the function CMatrixTemplate::getVicinity |
