| Eigen::internal::abs2_impl | |
| Eigen::internal::abs2_impl< std::complex< RealScalar > > | |
| Eigen::internal::abs2_retval | |
| Eigen::internal::abs_impl | |
| Eigen::internal::abs_retval | |
| mrpt::math::detail::AccessorIterator | Template class for matrix accessor's iterators |
| Eigen::internal::accessors_level | |
| TCLAP::ActionDoneException | (Added by JLBC for MRPT): An exception that indicates to CmdLine::parse that help,version,.. |
| Eigen::internal::add_const | |
| Eigen::internal::add_const< T & > | |
| Eigen::internal::add_const_on_value_type | |
| Eigen::internal::add_const_on_value_type< T & > | |
| Eigen::internal::add_const_on_value_type< T * > | |
| Eigen::internal::add_const_on_value_type< T *const > | |
| Eigen::internal::add_const_on_value_type< T const *const > | |
| Eigen::internal::add_const_on_value_type_if_arithmetic | |
| Eigen::aligned_allocator | STL compatible allocator to use with with 16 byte aligned types |
| mrpt::aligned_containers | Helper types for STL containers with Eigen memory allocators |
| Eigen::internal::aligned_stack_memory_handler | |
| Eigen::AlignedBox | |
| Eigen::internal::all_unroller | |
| Eigen::internal::all_unroller< Derived, 1 > | |
| Eigen::internal::all_unroller< Derived, Dynamic > | |
| std::allocator | STL class |
| Eigen::internal::always_void | |
| Eigen::AmbiVector | |
| Eigen::AngleAxis | |
| Eigen::internal::any_unroller | |
| Eigen::internal::any_unroller< Derived, 1 > | |
| Eigen::internal::any_unroller< Derived, Dynamic > | |
| TCLAP::Arg | A virtual base class that defines the essential data for all arguments |
| TCLAP::ArgException | A simple class that defines and argument exception |
| TCLAP::ArgParseException | Thrown from within the child Arg classes when it fails to properly parse the argument it has been passed |
| Eigen::Array | General-purpose arrays with easy API for coefficient-wise operations |
| Eigen::ArrayBase | Base class for all 1D and 2D array, and related expressions |
| Eigen::ArrayWrapper | Expression of a mathematical vector or matrix as an array object |
| Eigen::ArrayXpr | The type used to identify an array expression |
| Eigen::internal::atan2_default_impl | |
| Eigen::internal::atan2_default_impl< Scalar, true > | |
| Eigen::internal::atan2_impl | |
| Eigen::internal::atan2_retval | |
| std::auto_ptr | STL class |
| mrpt::graphslam::detail::AuxErrorEval< CPose2D, gst > | |
| mrpt::graphslam::detail::AuxErrorEval< CPose3D, gst > | |
| mrpt::graphslam::detail::AuxErrorEval< CPose3DPDFGaussianInf, gst > | |
| mrpt::graphslam::detail::AuxErrorEval< CPosePDFGaussianInf, gst > | |
| std::bad_alloc | STL class |
| std::bad_cast | STL class |
| std::bad_exception | STL class |
| std::bad_typeid | STL class |
| Eigen::internal::BandMatrix | Represents a rectangular matrix with a banded storage |
| Eigen::internal::BandMatrixBase | |
| Eigen::internal::BandMatrixWrapper | |
| std::basic_fstream | STL class |
| std::basic_ifstream | STL class |
| std::basic_ios | STL class |
| std::basic_iostream | STL class |
| std::basic_istream | STL class |
| std::basic_istringstream | STL class |
| std::basic_ofstream | STL class |
| std::basic_ostream | STL class |
| std::basic_ostringstream | STL class |
| std::basic_string | STL class |
| std::basic_stringstream | STL class |
| mrpt::utils::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 |
| Eigen::internal::binary_result_of_select | |
| Eigen::internal::binary_result_of_select< Func, ArgType0, ArgType1, sizeof(has_std_result_type)> | |
| Eigen::internal::binary_result_of_select< Func, ArgType0, ArgType1, sizeof(has_tr1_result)> | |
| mrpt::utils::metaprogramming::BinaryMemberFunctionWrapper | This template encapsulates a binary member function and a single object into a function expecting the two parameters of the member function |
| std::bitset | STL class |
| Eigen::internal::blas_data_mapper | |
| Eigen::internal::blas_traits | |
| Eigen::internal::blas_traits< const T > | |
| Eigen::internal::blas_traits< CwiseUnaryOp< scalar_conjugate_op< Scalar >, NestedXpr > > | |
| Eigen::internal::blas_traits< CwiseUnaryOp< scalar_multiple_op< Scalar >, NestedXpr > > | |
| Eigen::internal::blas_traits< CwiseUnaryOp< scalar_opposite_op< Scalar >, NestedXpr > > | |
| Eigen::internal::blas_traits< SelfCwiseBinaryOp< BinOp, NestedXpr, Rhs > > | |
| Eigen::internal::blas_traits< Transpose< NestedXpr > > | |
| Eigen::Block | Expression of a fixed-size or dynamic-size block |
| Eigen::Block< XprType, BlockRows, BlockCols, InnerPanel, true > | |
| mrpt::system::BlockedRange | |
| nanoflann::KDTreeSingleIndexAdaptor::BranchStruct | This record represents a branch point when finding neighbors in the tree |
| mrpt::hwdrivers::C2DRangeFinderAbstract | This is the base, abstract class for "software drivers" interfaces to 2D scanners (laser range finders) |
| mrpt::opengl::C3DSScene | This element keeps a set of objects imported from a 3DStudio file (.3ds) |
| mrpt::opengl::C3DSScenePtr | |
| mrpt::reactivenav::CAbstractHolonomicReactiveMethod | A base class for holonomic reactive navigation methods |
| mrpt::reactivenav::CAbstractReactiveNavigationSystem | This is the base class for any reactive navigation system |
| mrpt::slam::CAction | Declares a class for storing a robot action |
| mrpt::slam::CActionCollection | Declares a class for storing a collection of robot actions |
| mrpt::slam::CActionCollectionPtr | |
| mrpt::slam::CActionPtr | |
| mrpt::slam::CActionRobotMovement2D | Represents a probabilistic 2D movement of the robot mobile base |
| mrpt::slam::CActionRobotMovement2DPtr | |
| mrpt::slam::CActionRobotMovement3D | Represents a probabilistic 3D (6D) movement |
| mrpt::slam::CActionRobotMovement3DPtr | |
| mrpt::hwdrivers::CActivMediaRobotBase | This software driver implements the communications (and some rudimentary control) for ActivMedia robotic bases (Pioneer DX/AT, PeopleBot, etc) |
| mrpt::vision::CCamModel::CameraTempVariables | |
| mrpt::opengl::CAngularObservationMesh | A mesh built from a set of 2D laser scan observations |
| mrpt::opengl::CAngularObservationMeshPtr | |
| mrpt::math::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 |
| mrpt::math::CArray< T, 0 > | |
| mrpt::math::CArrayDouble | A partial specialization of CArrayNumeric for double numbers |
| mrpt::math::CArrayFloat | A partial specialization of CArrayNumeric for float numbers |
| mrpt::math::CArrayInt | A partial specialization of CArrayNumeric for int numbers |
| mrpt::math::CArrayNumeric | CArrayNumeric is an array for numeric types supporting several mathematical operations (actually, just a wrapper on Eigen::Matrix<T,N,1>) |
| mrpt::math::CArrayUInt | A partial specialization of CArrayNumeric for unsigned int numbers |
| mrpt::opengl::CArrow | A 3D arrow |
| mrpt::opengl::CArrowPtr | |
| Eigen::internal::cast_impl | |
| Eigen::internal::cast_return_type | |
| mrpt::graphs::CAStarAlgorithm | This class is intended to efficiently solve graph-search problems using heuristics to determine the best path |
| mrpt::synch::CAtomicCounter | This class acts exactly as an int (or long) variable, but with atomic increment and decrement operators |
| mrpt::opengl::CAxis | Draw a 3D world axis, with coordinate marks at some regular interval |
| mrpt::opengl::CAxisPtr | |
| mrpt::gui::CBaseGUIWindow | The base class for GUI window classes |
| mrpt::gui::CBaseGUIWindowPtr | |
| mrpt::slam::CBeacon | The class for storing individual "beacon landmarks" under a variety of 3D position PDF distributions |
| mrpt::slam::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) |
| mrpt::slam::TMetricMapInitializer::CBeaconMapOptions | Specific options for landmarks maps (mrpt::slam::CBeaconMap) |
| mrpt::slam::CBeaconMapPtr | |
| mrpt::slam::CBeaconPtr | |
| mrpt::math::CBinaryRelation | This class models a binary relation through the elements of any given set |
| mrpt::hwdrivers::CBoardDLMS | An interface to a custom board which interfaces two SICK laser scanners |
| mrpt::hwdrivers::CBoardENoses | A class for interfacing an e-Noses via a FTDI USB link |
| mrpt::hwdrivers::CBoardIR | A parser of NMEA commands, for connecting to a GPS by a serial port |
| mrpt::hwdrivers::CBoardSonars | This "software driver" implements the communication protocol for interfacing a Ultrasonic range finder SRF10 through a custom USB board |
| mrpt::opengl::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) |
| mrpt::opengl::CBoxPtr | |
| mrpt::opengl::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 |
| mrpt::opengl::CCameraPtr | |
| mrpt::hwdrivers::CCameraSensor | The central class for camera grabbers in MRPT, implementing the "generic sensor" interface |
| mrpt::vision::CCamModel | This class represent a pinhole camera model for Monocular SLAM and implements some associated Jacobians |
| mrpt::utils::CCanvas | This virtual class defines the interface of any object accepting drawing primitives on it |
| mrpt::detectors::CCascadeClassifierDetection | |
| mrpt::utils::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 |
| mrpt::reactivenav::CParameterizedTrajectoryGenerator::CColisionGrid | An internal class for storing the collision grid |
| mrpt::slam::CColouredPointsMap | A map of 2D/3D points with individual colours (RGB) |
| mrpt::slam::TMetricMapInitializer::CColouredPointsMapOptions | Specific options for coloured point maps (mrpt::slam::CPointsMap) |
| mrpt::slam::CColouredPointsMapPtr | |
| mrpt::utils::CConfigFile | This class allows loading and storing values and vectors of different types from ".ini" files easily |
| mrpt::utils::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.. |
| mrpt::utils::CConfigFileMemory | This class implements a config file-like interface over a memory-stored string list |
| mrpt::slam::CConsistentObservationAlignment | An algorithm for globally, consistent alignment of a sequence of observations |
| mrpt::utils::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 |
| mrpt::math::CConstMatrixColumnAccessor | A vector-like wrapper for a const Matrix for accessing the elements of a given column with a [] operator |
| mrpt::math::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 |
| mrpt::math::CConstMatrixRowAccessor | A vector-like wrapper for a const Matrix for accessing the elements of a given row with a [] operator |
| mrpt::math::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 |
| mrpt::synch::CCriticalSection | This class provides simple critical sections functionality |
| mrpt::synch::CCriticalSectionLocker | A class acquiring a CCriticalSection at its constructor, and releasing it at destructor |
| mrpt::opengl::CCylinder | A cylinder or cone whose base lies in the XY plane |
| mrpt::opengl::CCylinderPtr | |
| mrpt::utils::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 |
| mrpt::detectors::CDetectable2D | |
| mrpt::detectors::CDetectable2DPtr | |
| mrpt::detectors::CDetectable3D | |
| mrpt::detectors::CDetectable3DPtr | |
| mrpt::detectors::CDetectableObject | Base class that contains common atributes and functions of detectable objects |
| mrpt::detectors::CDetectableObjectPtr | |
| mrpt::slam::CDetectorDoorCrossing | |
| mrpt::graphs::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 |
| mrpt::graphs::CDirectedGraph | A directed graph with the argument of the template specifying the type of the annotations in the edges |
| mrpt::graphs::CDirectedTree | A special kind of graph in the form of a tree with directed edges and optional edge annotations of templatized type "TYPE_EDGES" |
| mrpt::system::CDirectoryExplorer | This class allows the enumeration of the files/directories that exist into a given path |
| mrpt::opengl::CDisk | A planar disk in the XY plane |
| mrpt::opengl::CDiskPtr | |
| mrpt::gui::CDisplayWindow | This class creates a window as a graphical user interface (GUI) for displaying images to the user |
| mrpt::gui::CDisplayWindow3D | A graphical user interface (GUI) for efficiently rendering 3D scenes in real-time |
| mrpt::gui::CDisplayWindow3DPtr | |
| mrpt::gui::CDisplayWindowPlots | Create a GUI window and display plots with MATLAB-like interfaces and commands |
| mrpt::gui::CDisplayWindowPlotsPtr | |
| mrpt::gui::CDisplayWindowPtr | |
| mrpt::utils::CDynamicGrid | A 2D grid of dynamic size which stores any kind of data at each cell |
| mrpt::opengl::CEllipsoid | A 2D ellipse or 3D ellipsoid, depending on the size of the m_cov matrix (2x2 or 3x3) |
| mrpt::opengl::CEllipsoidPtr | |
| mrpt::utils::CEnhancedMetaFile | This class represents a Windows Enhanced Meta File (EMF) for generating and saving graphics |
| mrpt::synch::CEvent | This class provides a simple way of waiting for and signaling events (NOT IMPLEMENTED YET!) |
| mrpt::utils::CExceptionEOF | Used in mrpt::utils::CStream |
| mrpt::utils::CExceptionExternalImageNotFound | Used in mrpt::utils::CImage |
| mrpt::math::CExceptionNotDefPos | Used in mrpt::math::CSparseMatrix |
| mrpt::detectors::CFaceDetection | Specific class for face detection |
| mrpt::opengl::CFBORender | A class for rendering 3D scenes off-screen directly into an image using OpenGL extensions (glext) |
| mrpt::vision::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 |
| mrpt::vision::CFeatureExtraction | The central class from which images can be analyzed in search of different kinds of interest points and descriptors computed for them |
| mrpt::vision::CFeatureList | A list of visual features, to be used as output by detectors, as input/output by trackers, etc |
| mrpt::vision::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 |
| mrpt::vision::CFeaturePtr | |
| mrpt::vision::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 |
| mrpt::vision::CFeatureTracker_KL | Track a set of features from old_img -> new_img using sparse optimal flow (classic KL method) |
| mrpt::vision::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 |
| mrpt::hwdrivers::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 |
| mrpt::utils::CFileGZInputStream | Transparently opens a compressed "gz" file and reads uncompressed data from it |
| mrpt::utils::CFileInputStream | This CStream derived class allow using a file as a read-only, binary stream |
| mrpt::utils::CFileOutputStream | This CStream derived class allow using a file as a write-only, binary stream |
| mrpt::utils::CFileStream | This CStream derived class allow using a file as a read/write binary stream, creating it if the file didn't exist |
| mrpt::system::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 |
| mrpt::slam::CGasConcentrationGridMap2D | CGasConcentrationGridMap2D represents a PDF of gas concentrations over a 2D area |
| mrpt::slam::TMetricMapInitializer::CGasConcentrationGridMap2DOptions | Specific options for gas grid maps (mrpt::slam::CGasConcentrationGridMap2D) |
| mrpt::slam::CGasConcentrationGridMap2DPtr | |
| mrpt::opengl::CGeneralizedCylinder | This object represents any figure obtained by extruding any profile along a given axis |
| mrpt::opengl::CGeneralizedCylinderPtr | |
| mrpt::vision::CGenericFeatureTracker | A virtual interface for all feature trackers, implementing the part of feature tracking that is common to any specific tracker implementation |
| mrpt::system::CGenericMemoryPool | A generic system for versatile memory pooling |
| mrpt::hwdrivers::CGenericSensor | A generic interface for a wide-variety of sensors designed to be used in the application RawLogGrabber |
| mrpt::hwdrivers::CGPSInterface | A parser of NMEA commands, for connecting to a GPS by a serial port |
| mrpt::graphs::CGraphPartitioner | Algorithms for finding the min-normalized-cut of a weighted undirected graph |
| mrpt::slam::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 |
| mrpt::opengl::CGridPlaneXY | A grid of lines over the XY plane |
| mrpt::opengl::CGridPlaneXYPtr | |
| mrpt::opengl::CGridPlaneXZ | A grid of lines over the XZ plane |
| mrpt::opengl::CGridPlaneXZPtr | |
| mrpt::hwdrivers::CGyroKVHDSP3000 | A class for interfacing KVH DSP 3000 gyroscope with an assynchronous serial communication (product SN : 02-1222-01) |
| Eigen::internal::check_transpose_aliasing_compile_time_selector | |
| Eigen::internal::check_transpose_aliasing_compile_time_selector< DestIsTransposed, CwiseBinaryOp< BinOp, DerivedA, DerivedB > > | |
| Eigen::internal::check_transpose_aliasing_run_time_selector | |
| Eigen::internal::check_transpose_aliasing_run_time_selector< Scalar, DestIsTransposed, CwiseBinaryOp< BinOp, DerivedA, DerivedB > > | |
| Eigen::internal::checkTransposeAliasing_impl | |
| Eigen::internal::checkTransposeAliasing_impl< Derived, OtherDerived, false > | |
| mrpt::slam::CHeightGridMap2D | A mesh representation of a surface which keeps the estimated height for each (x,y) location |
| mrpt::slam::TMetricMapInitializer::CHeightGridMap2DOptions | Specific options for height grid maps (mrpt::slam::CHeightGridMap2D) |
| mrpt::slam::CHeightGridMap2DPtr | |
| mrpt::hmtslam::CHierarchicalMapMHPartition | Represents a set of nodes and arcs, posibly only a part of the whole hierarchical, multi-hypothesis map |
| mrpt::hmtslam::CHierarchicalMHMap | The most high level class for storing hybrid, multi-hypothesis maps in a graph-based model |
| mrpt::hmtslam::CHierarchicalMHMapPtr | |
| mrpt::math::CHistogram | This class provides an easy way of computing histograms for unidimensional real valued variables |
| mrpt::hmtslam::CHMHMapArc | A class for representing an arc between two nodes in a hierarchical, multi-hypothesis map |
| mrpt::hmtslam::CHMHMapArcPtr | |
| mrpt::hmtslam::CHMHMapNode | A class for representing a node in a hierarchical, multi-hypothesis map |
| mrpt::hmtslam::CHMHMapNodePtr | |
| mrpt::hmtslam::CHMTSLAM | An implementation of Hybrid Metric Topological SLAM (HMT-SLAM) |
| mrpt::hmtslam::CHMTSLAMPtr | |
| mrpt::hwdrivers::CHokuyoURG | This software driver implements the protocol SCIP-2.0 for interfacing HOKUYO URG, UTM and UXM laser scanners |
| mrpt::math::CSparseMatrix::CholeskyDecomp | Auxiliary class to hold the results of a Cholesky factorization of a sparse matrix |
| mrpt::reactivenav::CHolonomicLogFileRecord | A base class for log records for different holonomic navigation methods |
| mrpt::reactivenav::CHolonomicLogFileRecordPtr | |
| mrpt::reactivenav::CHolonomicND | An implementation of the holonomic reactive navigation method "Nearness-Diagram" |
| mrpt::reactivenav::CHolonomicVFF | A holonomic reactive navigation method, based on Virtual Force Fields (VFF) |
| mrpt::utils::ci_less | A case-insensitive comparator struct for usage within STL containers, eg: map<string,string,ci_less> |
| mrpt::hwdrivers::CIbeoLuxETH | This "software driver" implements the communication protocol for interfacing a Ibeo Lux laser scanners through an ethernet controller |
| mrpt::slam::CICP | Several implementations of ICP (Iterative closest point) algorithms for aligning two point maps or a point map wrt a grid map |
| mrpt::utils::CImage | A class for storing images as grayscale or RGB bitmaps |
| mrpt::hwdrivers::CImageGrabber_dc1394 | A class for grabing images from a IEEE1394 (Firewire) camera using the libdc1394-2 library |
| mrpt::hwdrivers::CImageGrabber_OpenCV | A class for grabing images from a "OpenCV"-compatible camera, or from an AVI video file |
| mrpt::utils::CImagePtr | |
| mrpt::vision::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) |
| mrpt::hwdrivers::CIMUXSens | A class for interfacing Inertial Measuring Units (IMUs) of the type "XSens MTi" It uses a serial port connection to the device |
| mrpt::slam::CIncrementalMapPartitioner | This class can be used to make partitions on a map/graph build from observations taken at some poses/nodes |
| mrpt::slam::CIncrementalMapPartitionerPtr | |
| mrpt::hwdrivers::CInterfaceFTDI | A definition of a CStream actually representing a USB connection to a FTDI chip |
| mrpt::utils::circular_buffer | A circular buffer of fixed size (defined at construction-time), implemented with a std::vector as the underlying storage |
| mrpt::hwdrivers::CJoystick | Access to joysticks and gamepads (read buttons and position), and request number of joysticks in the system |
| mrpt::bayes::CKalmanFilterCapable | Virtual base for Kalman Filter (EKF,IEKF,UKF) implementations |
| mrpt::hwdrivers::CKinect | A class for grabing "range images", intensity images (either RGB or IR) and other information from an Xbox Kinect sensor |
| mrpt::slam::CLandmark | The class for storing "landmarks" (visual or laser-scan-extracted features,...) |
| mrpt::slam::CLandmarkPtr | |
| mrpt::slam::CLandmarksMap | A class for storing a map of 3D probabilistic landmarks |
| mrpt::slam::TMetricMapInitializer::CLandmarksMapOptions | Specific options for landmarks maps (mrpt::slam::CLandmarksMap) |
| mrpt::slam::CLandmarksMapPtr | |
| mrpt::utils::CLASSINIT | Auxiliary structure used for CObject-based RTTI |
| mrpt::hwdrivers::CGenericSensor::CLASSINIT_GENERIC_SENSOR | Auxiliary structure used for CSerializable runtime class ID support |
| mrpt::math::CLevenbergMarquardtTempl | An implementation of the Levenberg-Marquardt algorithm for least-square minimization |
| mrpt::utils::CListOfClasses | A list (actually based on a std::set) of MRPT classes, capable of keeping any class registered by the mechanism of CSerializable classes |
| mrpt::hwdrivers::CLMS100Eth | This "software driver" implements the communication protocol for interfacing a SICK LMS100 laser scanners through an ethernet controller |
| mrpt::utils::CLoadableOptions | This is a virtual base class for sets of options than can be loaded from and/or saved to configuration plain-text files |
| mrpt::hmtslam::CLocalMetricHypothesis | This class is used in HMT-SLAM to represent each of the Local Metric Hypotheses (LMHs) |
| mrpt::hmtslam::CLocalMetricHypothesisPtr | |
| mrpt::utils::CLog | A decorator of CStringList special for keeping logs |
| mrpt::reactivenav::CLogFileRecord | A class for storing, saving and loading a reactive navigation log record for the CReactiveNavigationSystem class |
| mrpt::reactivenav::CLogFileRecord_ND | A class for storing extra information about the execution of CHolonomicND navigation |
| mrpt::reactivenav::CLogFileRecord_NDPtr | |
| mrpt::reactivenav::CLogFileRecord_VFF | A class for storing extra information about the execution of CHolonomicVFF navigation |
| mrpt::reactivenav::CLogFileRecord_VFFPtr | |
| mrpt::reactivenav::CLogFileRecordPtr | |
| mrpt::slam::CLogOddsGridMap2D | A generic provider of log-odds grid-map maintainance functions |
| mrpt::slam::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 |
| stlplus::clone_copy | |
| mrpt::hmtslam::CLSLAM_RBPF_2DLASER | Implements a 2D local SLAM method based on a RBPF over an occupancy grid map |
| mrpt::hmtslam::CLSLAMAlgorithmBase | Virtual base for local SLAM methods, used in mrpt::slam::CHMTSLAM |
| mrpt::hmtslam::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) |
| mrpt::hmtslam::CLSLAMParticleDataPtr | |
| mrpt::utils::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) |
| mrpt::vision::CMatchedFeatureList | A list of features |
| mrpt::math::CMatrix | This class is a "CSerializable" wrapper for "CMatrixFloat" |
| mrpt::math::CMatrixB | This class is a "CSerializable" wrapper for "CMatrixBool" |
| mrpt::math::CMatrixBPtr | |
| mrpt::math::CMatrixColumnAccessor | A vector-like wrapper for a Matrix for accessing the elements of a given column with a [] operator |
| mrpt::math::CMatrixColumnAccessorExtended | A vector-like wrapper for a Matrix for accessing the elements of a given column with a [] operator, with offset and custom spacing |
| mrpt::math::CMatrixD | This class is a "CSerializable" wrapper for "CMatrixTemplateNumeric<double>" |
| mrpt::math::CMatrixDPtr | |
| mrpt::math::CMatrixFixedNumeric | A numeric matrix of compile-time fixed size |
| mrpt::math::CMatrixPtr | |
| mrpt::math::CMatrixRowAccessor | A vector-like wrapper for a Matrix for accessing the elements of a given row with a [] operator |
| mrpt::math::CMatrixRowAccessorExtended | A vector-like wrapper for a Matrix for accessing the elements of a given row with a [] operator, with offset and custom spacing |
| mrpt::math::CMatrixTemplate | This template class provides the basic functionality for a general 2D any-size, resizable container of numerical or non-numerical elements |
| mrpt::math::CMatrixTemplateNumeric | A matrix of dynamic size |
| mrpt::math::CMatrixTemplateObjects | This template class extends the class "CMatrixTemplate" for storing "objects" at each matrix entry |
| mrpt::math::CMatrixTemplateSize | Auxiliary class used in CMatrixTemplate:size(), CMatrixTemplate::resize(), CMatrixFixedNumeric::size(), CMatrixFixedNumeric::resize(), to mimic the behavior of STL-containers |
| TCLAP::CmdLine | The base class that manages the command line definition and passes along the parsing to the appropriate Arg classes |
| TCLAP::CmdLineInterface | The base class that manages the command line definition and passes along the parsing to the appropriate Arg classes |
| TCLAP::CmdLineOutput | The interface that any output object must implement |
| TCLAP::CmdLineParseException | Thrown from CmdLine when the arguments on the command line are not properly specified, e.g |
| mrpt::utils::CMemoryChunk | A memory buffer (implements CStream) which can be itself serialized |
| mrpt::utils::CMemoryChunkPtr | |
| mrpt::utils::CMemoryStream | This CStream derived class allow using a memory buffer as a CStream |
| mrpt::opengl::CMesh | A planar (XY) grid where each cell has an associated height and, optionally, a texture map |
| mrpt::opengl::CMeshPtr | |
| mrpt::utils::CMessage | A class that contain generic messages, that can be sent and received from a "CClientTCPSocket" object |
| mrpt::slam::CMetricMap | Declares a virtual base class for all metric maps storage classes |
| mrpt::slam::CMetricMapBuilder | This virtual class is the base for SLAM implementations |
| mrpt::slam::CMetricMapBuilderICP | A class for very simple 2D SLAM based on ICP |
| mrpt::slam::CMetricMapBuilderRBPF | This class implements a Rao-Blackwelized Particle Filter (RBPF) approach to map building (SLAM) |
| mrpt::slam::CMetricMapPtr | |
| mrpt::slam::CMetricMapsAlignmentAlgorithm | A base class for any algorithm able of maps alignment |
| mrpt::utils::CMHPropertiesValuesList | An arbitrary list of "annotations", or named attributes, each being an instance of any CSerializable object (Multi-hypotheses version) |
| mrpt::utils::CMHPropertiesValuesListPtr | |
| mrpt::math::CMonteCarlo | Montecarlo simulation for experiments in 1D |
| mrpt::slam::CMonteCarloLocalization2D | Declares a class that represents a Probability Density Function (PDF) over a 2D pose (x,y,phi), using a set of weighted samples |
| mrpt::slam::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 |
| mrpt::slam::CObservationGasSensors::CMOSmodel | Declares a class within "CObservationGasSensors" that represents a set of gas concentration readings from the modelation of a MOS gas sensor readings |
| mrpt::utils::CMRPTException | The base for MRPT-especific exceptions |
| mrpt::slam::CMultiMetricMap | This class stores any customizable set of metric maps |
| mrpt::slam::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) |
| mrpt::slam::CMultiMetricMapPDFPtr | |
| mrpt::slam::CMultiMetricMapPtr | |
| mrpt::graphs::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) |
| mrpt::graphs::CNetworkOfPoses2D | The specialization of CNetworkOfPoses for poses of type CPose2D (not a PDF!), also implementing serialization |
| mrpt::graphs::CNetworkOfPoses2DCov | The specialization of CNetworkOfPoses for poses of type CPosePDFGaussian, also implementing serialization |
| mrpt::graphs::CNetworkOfPoses2DCovPtr | |
| mrpt::graphs::CNetworkOfPoses2DInf | The specialization of CNetworkOfPoses for poses of type CPosePDFGaussianInf, also implementing serialization |
| mrpt::graphs::CNetworkOfPoses2DInfPtr | |
| mrpt::graphs::CNetworkOfPoses2DPtr | |
| mrpt::graphs::CNetworkOfPoses3D | The specialization of CNetworkOfPoses for poses of type CPose3D (not a PDF!), also implementing serialization |
| mrpt::graphs::CNetworkOfPoses3DCov | The specialization of CNetworkOfPoses for poses of type CPose3DPDFGaussian, also implementing serialization |
| mrpt::graphs::CNetworkOfPoses3DCovPtr | |
| mrpt::graphs::CNetworkOfPoses3DInf | The specialization of CNetworkOfPoses for poses of type CPose3DPDFGaussianInf, also implementing serialization |
| mrpt::graphs::CNetworkOfPoses3DInfPtr | |
| mrpt::graphs::CNetworkOfPoses3DPtr | |
| mrpt::hwdrivers::CNTRIPClient | A client for NTRIP (HTTP) sources of differential GPS corrections from internet servers, or Global navigation satellite system (GNSS) internet radio |
| mrpt::hwdrivers::CNTRIPEmitter | This "virtual driver" encapsulates a NTRIP client (see CNTRIPClient) but adds the functionality of dumping the received datastream to a given serial port |
| mrpt::utils::CObject | The virtual base class of all MRPT classes with a unified RTTI system |
| mrpt::detectors::CObjectDetection | |
| mrpt::utils::CObjectPtr | A smart pointer to a CObject object |
| mrpt::utils::CObservable | Inherit from this class for those objects capable of being observed by a CObserver class |
| mrpt::slam::CObservation | Declares a class that represents any robot's observation |
| mrpt::slam::CObservation2DRangeScan | A "CObservation"-derived class that represents a 2D range scan measurement (typically from a laser scanner) |
| mrpt::slam::CObservation2DRangeScanPtr | |
| mrpt::slam::CObservation3DRangeScan | Declares a class derived from "CObservation" that encapsules a 3D range scan measurement (e.g |
| mrpt::slam::CObservation3DRangeScanPtr | |
| mrpt::slam::CObservationBatteryState | This represents a measurement of the batteries on the robot |
| mrpt::slam::CObservationBatteryStatePtr | |
| mrpt::slam::CObservationBeaconRanges | Declares a class derived from "CObservation" that represents one (or more) range measurements to labeled beacons |
| mrpt::slam::CObservationBeaconRangesPtr | |
| mrpt::slam::CObservationBearingRange | This observation represents a number of range-bearing value pairs, each one for a detected landmark, which optionally can have identification IDs |
| mrpt::slam::CObservationBearingRangePtr | |
| mrpt::slam::CObservationComment | This "observation" is actually a placeholder for a text block with comments or additional parameters attached to a given rawlog file |
| mrpt::slam::CObservationCommentPtr | |
| mrpt::slam::CObservationGasSensors | Declares a class derived from "CObservation" that represents a set of readings from gas sensors |
| mrpt::slam::CObservationGasSensorsPtr | |
| mrpt::slam::CObservationGPS | Declares a class derived from "CObservation" that represents a Global Positioning System (GPS) reading |
| mrpt::slam::CObservationGPSPtr | |
| mrpt::slam::CObservationImage | Declares a class derived from "CObservation" that encapsules an image from a camera, whose relative pose to robot is also stored |
| mrpt::slam::CObservationImagePtr | |
| mrpt::slam::CObservationIMU | This class stores measurements from an Inertial Measurement Unit (IMU), and/or its attitude estimation (integration of raw measurements) |
| mrpt::slam::CObservationIMUPtr | |
| mrpt::slam::CObservationOdometry | An observation of the current (cumulative) odometry for a wheeled robot |
| mrpt::slam::CObservationOdometryPtr | |
| mrpt::slam::CObservationPtr | |
| mrpt::slam::CObservationRange | Declares a class derived from "CObservation" that encapsules a single range measurement, and associated parameters |
| mrpt::slam::CObservationRangePtr | |
| mrpt::slam::CObservationReflectivity | Declares a class derived from "CObservation" that encapsules a single short-range reflectivity measurement |
| mrpt::slam::CObservationReflectivityPtr | |
| mrpt::slam::CObservationStereoImages | Observation class for either a pair of left+right or left+disparity images from a stereo camera |
| mrpt::slam::CObservationStereoImagesFeatures | Declares a class derived from "CObservation" that encapsules a pair of cameras and a set of matched image features extracted from them |
| mrpt::slam::CObservationStereoImagesFeaturesPtr | |
| mrpt::slam::CObservationStereoImagesPtr | |
| mrpt::slam::CObservationVisualLandmarks | Declares a class derived from "CObservation" that stores a Landmarks Map as seen from a stereo camera at a given instant of time |
| mrpt::slam::CObservationVisualLandmarksPtr | |
| mrpt::slam::CObservationWirelessPower | This represents a measurement of the wireless strength perceived by the robot |
| mrpt::slam::CObservationWirelessPowerPtr | |
| mrpt::utils::CObserver | Inherit from this class to get notified about events from any CObservable object after subscribing to it |
| mrpt::slam::COccupancyGridMap2D | A class for storing an occupancy grid map |
| mrpt::slam::COccupancyGridMap2DPtr | |
| mrpt::slam::COccupancyGridMapFeatureExtractor | A class for detecting features from occupancy grid maps |
| mrpt::opengl::COctreePointRenderer | Template class that implements the data structure and algorithms for Octree-based efficient rendering |
| Eigen::internal::coeff_visitor | |
| Eigen::CoeffBasedProduct | |
| Eigen::ColPivHouseholderQR | Householder rank-revealing QR decomposition of a matrix with column-pivoting |
| Eigen::CommaInitializer | Helper class used by the comma initializer operator |
| std::complex | STL class |
| Eigen::internal::complex_schur_reduce_to_hessenberg< MatrixType, IsComplex > | |
| Eigen::internal::complex_schur_reduce_to_hessenberg< MatrixType, false > | |
| Eigen::ComplexEigenSolver | |
| Eigen::ComplexSchur< _MatrixType > | |
| Eigen::CompressedStorage | Stores a sparse set of values as a list of values and a list of indices |
| Eigen::internal::compute_inverse | |
| Eigen::internal::compute_inverse< MatrixType, ResultType, 1 > | |
| Eigen::internal::compute_inverse< MatrixType, ResultType, 2 > | |
| Eigen::internal::compute_inverse< MatrixType, ResultType, 3 > | |
| Eigen::internal::compute_inverse< MatrixType, ResultType, 4 > | |
| Eigen::internal::compute_inverse_and_det_with_check | |
| Eigen::internal::compute_inverse_and_det_with_check< MatrixType, ResultType, 1 > | |
| Eigen::internal::compute_inverse_and_det_with_check< MatrixType, ResultType, 2 > | |
| Eigen::internal::compute_inverse_and_det_with_check< MatrixType, ResultType, 3 > | |
| Eigen::internal::compute_inverse_and_det_with_check< MatrixType, ResultType, 4 > | |
| Eigen::internal::compute_inverse_size4 | |
| Eigen::internal::compute_matrix_flags | |
| Eigen::internal::conditional | |
| Eigen::internal::conditional< false, Then, Else > | |
| Eigen::internal::conj_expr_if | |
| Eigen::internal::conj_helper< RealScalar, std::complex< RealScalar >, false, Conj > | |
| Eigen::internal::conj_helper< Scalar, Scalar, false, false > | |
| Eigen::internal::conj_helper< std::complex< RealScalar >, RealScalar, Conj, false > | |
| Eigen::internal::conj_helper< std::complex< RealScalar >, std::complex< RealScalar >, false, true > | |
| Eigen::internal::conj_helper< std::complex< RealScalar >, std::complex< RealScalar >, true, false > | |
| Eigen::internal::conj_helper< std::complex< RealScalar >, std::complex< RealScalar >, true, true > | |
| Eigen::internal::conj_if< false > | |
| Eigen::internal::conj_if< true > | |
| Eigen::internal::conj_impl | |
| Eigen::internal::conj_impl< std::complex< RealScalar > > | |
| Eigen::internal::conj_retval | |
| Eigen::internal::conservative_resize_like_impl | |
| Eigen::internal::conservative_resize_like_impl< Derived, OtherDerived, true > | |
| Eigen::internal::const_blas_data_mapper | |
| mrpt::slam::CRawlog::const_iterator | A normal iterator, plus the extra method "getType" to determine the type of each entry in the sequence |
| mrpt::poses::CPose3DQuat::const_iterator | |
| std::basic_string::const_iterator | STL iterator class |
| std::string::const_iterator | STL iterator class |
| std::wstring::const_iterator | STL iterator class |
| std::deque::const_iterator | STL iterator class |
| std::list::const_iterator | STL iterator class |
| std::map::const_iterator | STL iterator class |
| std::multimap::const_iterator | STL iterator class |
| std::set::const_iterator | STL iterator class |
| std::multiset::const_iterator | STL iterator class |
| std::vector::const_iterator | STL iterator class |
| std::basic_string::const_reverse_iterator | STL iterator class |
| std::string::const_reverse_iterator | STL iterator class |
| std::wstring::const_reverse_iterator | STL iterator class |
| std::deque::const_reverse_iterator | STL iterator class |
| std::list::const_reverse_iterator | STL iterator class |
| std::map::const_reverse_iterator | STL iterator class |
| std::multimap::const_reverse_iterator | STL iterator class |
| std::set::const_reverse_iterator | STL iterator class |
| std::multiset::const_reverse_iterator | STL iterator class |
| std::vector::const_reverse_iterator | STL iterator class |
| Eigen::MatrixBase::ConstDiagonalIndexReturnType | |
| Eigen::DenseBase::ConstFixedSegmentReturnType | |
| TCLAP::Constraint | The interface that defines the interaction between the Arg and Constraint |
| stlplus::constructor_copy | |
| Eigen::internal::constructor_without_unaligned_array_assert | |
| Eigen::MatrixBase::ConstSelfAdjointViewReturnType | |
| Eigen::MatrixBase::ConstTriangularViewReturnType | |
| mrpt::opengl::COpenGLScene | This class allows the user to create, load, save, and render 3D scenes using OpenGL primitives |
| mrpt::opengl::COpenGLScenePtr | |
| mrpt::opengl::COpenGLStandardObject | Objects of this class represent a generic openGL object without specific geometric properties |
| mrpt::opengl::COpenGLStandardObjectPtr | |
| mrpt::opengl::COpenGLViewport | A viewport within a COpenGLScene, containing a set of OpenGL objects to render |
| mrpt::opengl::COpenGLViewportPtr | |
| mrpt::utils::copiable_NULL_ptr | A wrapper class for pointers that, if copied with the "=" operator, should be set to NULL in the new copy |
| mrpt::utils::copiable_NULL_ptr_basic | A wrapper class for pointers that, if copied with the "=" operator, should be set to NULL in the copy |
| Eigen::internal::member_redux::Cost | |
| mrpt::reactivenav::CParameterizedTrajectoryGenerator | This is the base class for any user defined PTG |
| mrpt::bayes::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 |
| mrpt::bayes::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 |
| mrpt::bayes::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 |
| mrpt::slam::CPathPlanningCircularRobot | An implementation of CPathPlanningMethod |
| mrpt::slam::CPathPlanningMethod | A virtual base class for computing the optimal path for a robot from a origin location to a target point |
| mrpt::hwdrivers::CPhidgetInterfaceKitProximitySensors | : An interface for the phidget Interface kit board (1018) |
| mrpt::opengl::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 |
| mrpt::opengl::CPlanarLaserScanPtr | |
| mrpt::poses::CPoint | A base class for representing a point in 2D or 3D |
| mrpt::poses::CPoint2D | A class used to store a 2D point |
| mrpt::poses::CPoint2DPDF | Declares a class that represents a Probability Distribution function (PDF) of a 2D point (x,y) |
| mrpt::poses::CPoint2DPDFGaussian | A gaussian distribution for 2D points |
| mrpt::poses::CPoint2DPDFGaussianPtr | |
| mrpt::poses::CPoint2DPDFPtr | |
| mrpt::poses::CPoint2DPtr | |
| mrpt::poses::CPoint3D | A class used to store a 3D point |
| mrpt::poses::CPoint3DPtr | |
| mrpt::opengl::CPointCloud | A cloud of points, all with the same color or each depending on its value along a particular coordinate axis |
| mrpt::opengl::CPointCloudColoured | A cloud of points, each one with an individual colour (R,G,B) |
| mrpt::opengl::CPointCloudColouredPtr | |
| mrpt::opengl::CPointCloudPtr | |
| mrpt::poses::CPointPDF | Declares a class that represents a Probability Distribution function (PDF) of a 3D point (x,y,z) |
| mrpt::poses::CPointPDFGaussian | A gaussian distribution for 3D points |
| mrpt::poses::CPointPDFGaussianPtr | |
| mrpt::poses::CPointPDFParticles | A probability distribution of a 2D/3D point, represented as a set of random samples (particles) |
| mrpt::poses::CPointPDFParticlesPtr | |
| mrpt::poses::CPointPDFPtr | |
| mrpt::poses::CPointPDFSOG | Declares a class that represents a Probability Density function (PDF) of a 3D point ![$ p(\mathbf{x}) = [x ~ y ~ z ]^t $](form_49.png) |
| mrpt::poses::CPointPDFSOGPtr | |
| mrpt::slam::CPointsMap | A cloud of points in 2D or 3D, which can be built from a sequence of laser scans or other sensors |
| mrpt::slam::TMetricMapInitializer::CPointsMapOptions | Specific options for point maps (mrpt::slam::CPointsMap) |
| mrpt::slam::CPointsMapPtr | |
| mrpt::math::CPolygon | A wrapper of a TPolygon2D class, implementing CSerializable |
| mrpt::math::CPolygonPtr | |
| mrpt::opengl::CPolyhedron | This class represents arbitrary polyhedra |
| mrpt::opengl::CPolyhedronPtr | |
| mrpt::poses::CPose | A base class for representing a pose in 2D or 3D |
| mrpt::poses::CPose2D | A class used to store a 2D pose |
| mrpt::poses::CPose2DGridTemplate | This is a template class for storing a 3D (2D+heading) grid containing any kind of data |
| mrpt::poses::CPose2DPtr | |
| mrpt::poses::CPose3D | A class used to store a 3D pose (a 3D translation + a rotation in 3D) |
| mrpt::poses::CPose3DInterpolator | A trajectory in time and in 6D (CPose3D) that interpolates using splines the intervals between a set of given time-referenced poses |
| mrpt::poses::CPose3DInterpolatorPtr | |
| mrpt::poses::CPose3DPDF | Declares a class that represents a Probability Density Function (PDF) of a 3D pose (6D actually) |
| mrpt::poses::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_61.png) |
| mrpt::poses::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 |
| mrpt::poses::CPose3DPDFGaussianInfPtr | |
| mrpt::poses::CPose3DPDFGaussianPtr | |
| mrpt::poses::CPose3DPDFParticles | Declares a class that represents a Probability Density function (PDF) of a 3D pose |
| mrpt::poses::CPose3DPDFParticlesPtr | |
| mrpt::poses::CPose3DPDFPtr | |
| mrpt::poses::CPose3DPDFSOG | Declares a class that represents a Probability Density function (PDF) of a 3D(6D) pose |
| mrpt::poses::CPose3DPDFSOGPtr | |
| mrpt::poses::CPose3DPtr | |
| mrpt::poses::CPose3DQuat | A class used to store a 3D pose as a translation (x,y,z) and a quaternion (qr,qx,qy,qz) |
| mrpt::poses::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] |
| mrpt::poses::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_67.png) |
| mrpt::poses::CPose3DQuatPDFGaussianPtr | |
| mrpt::poses::CPose3DQuatPDFPtr | |
| mrpt::poses::CPose3DQuatPtr | |
| mrpt::poses::CPoseOrPoint | The base template class for 2D & 3D points and poses |
| mrpt::poses::CPosePDF | Declares a class that represents a probability density function (pdf) of a 2D pose (x,y,phi) |
| mrpt::poses::CPosePDFGaussian | Declares a class that represents a Probability Density function (PDF) of a 2D pose ![$ p(\mathbf{x}) = [x ~ y ~ \phi ]^t $](form_71.png) |
| mrpt::poses::CPosePDFGaussianInf | A Probability Density function (PDF) of a 2D pose as a Gaussian with a mean and the inverse of the covariance |
| mrpt::poses::CPosePDFGaussianInfPtr | |
| mrpt::poses::CPosePDFGaussianPtr | |
| mrpt::poses::CPosePDFGrid | Declares a class that represents a Probability Distribution function (PDF) of a 2D pose (x,y,phi) |
| mrpt::poses::CPosePDFGridPtr | |
| mrpt::poses::CPosePDFParticles | Declares a class that represents a Probability Density Function (PDF) over a 2D pose (x,y,phi), using a set of weighted samples |
| mrpt::poses::CPosePDFParticlesPtr | |
| mrpt::poses::CPosePDFPtr | |
| mrpt::poses::CPosePDFSOG | Declares a class that represents a Probability Density function (PDF) of a 2D pose |
| mrpt::poses::CPosePDFSOGPtr | |
| mrpt::poses::CPoseRandomSampler | An efficient generator of random samples drawn from a given 2D (CPosePDF) or 3D (CPose3DPDF) pose probability density function (pdf) |
| mrpt::poses::CPoses2DSequence | This class stores a sequence of relative, incremental 2D poses |
| mrpt::poses::CPoses2DSequencePtr | |
| mrpt::poses::CPoses3DSequence | This class stores a sequence of relative, incremental 3D poses |
| mrpt::poses::CPoses3DSequencePtr | |
| mrpt::utils::CProbabilityDensityFunction | A generic template for probability density distributions (PDFs) |
| mrpt::bayes::CProbabilityParticle | A template class for holding a the data and the weight of a particle |
| mrpt::utils::CProfilerProxy | |
| mrpt::utils::CPropertiesValuesList | An arbitrary list of "annotations", or named attributes, each being an instance of any CSerializable object |
| mrpt::utils::CPropertiesValuesListPtr | |
| mrpt::reactivenav::CPRRTNavigator | This class is a multi-threaded mobile robot navigator, implementing an (anytime) PTG-based Rapidly-exploring Random Tree (PRRT) search algorithm |
| mrpt::reactivenav::CPTG1 | A PTG for circular paths |
| mrpt::reactivenav::CPTG2 | The alpha-PTG |
| mrpt::reactivenav::CPTG3 | A PTG for optimal paths of type "C|C,S" |
| mrpt::reactivenav::CPTG4 | A PTG for optimal paths of type "C|C" |
| mrpt::reactivenav::CPTG5 | A PTG for optimal paths of type "C|C,S" |
| mrpt::reactivenav::CPTG6 | A PTG for circular paths |
| mrpt::reactivenav::CPTG7 | A PTG for circular paths |
| mrpt::hwdrivers::CPtuBase | This class implements initialization and comunication methods to control a generic Pan and Tilt Unit, working in radians |
| mrpt::hwdrivers::CPtuDPerception | This class implements initialization and comunication methods to control a Pan and Tilt Unit model PTU-46-17.5, working in radians |
| mrpt::hwdrivers::CPtuHokuyo | |
| mrpt::math::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 |
| mrpt::slam::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) |
| mrpt::slam::CRandomFieldGridMap2DPtr | |
| mrpt::random::CRandomGenerator | A thred-safe pseudo random number generator, based on an internal MT19937 randomness generator |
| mrpt::slam::CRangeBearingKFSLAM | An implementation of EKF-based SLAM with range-bearing sensors, odometry, a full 6D robot pose, and 3D landmarks |
| mrpt::slam::CRangeBearingKFSLAM2D | An implementation of EKF-based SLAM with range-bearing sensors, odometry, and a 2D (+heading) robot pose, and 2D landmarks |
| mrpt::slam::CRawlog | This class stores a rawlog (robotic datasets) in one of two possible formats: |
| mrpt::slam::CRawlogPtr | |
| mrpt::slam::CRBPFParticleData | Auxiliary class used in mrpt::slam::CMultiMetricMapPDF |
| mrpt::slam::CRBPFParticleDataPtr | |
| mrpt::reactivenav::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 |
| mrpt::reactivenav::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 |
| mrpt::utils::CReferencedMemBlock | Represents a memory block (via "void*") that can be shared between several objects through copy operator (=) |
| mrpt::slam::CReflectivityGridMap2D | A 2D grid map representing the reflectivity of the environment (for example, measured with an IR proximity sensor) |
| mrpt::slam::TMetricMapInitializer::CReflectivityGridMap2DOptions | Specific options for height grid maps (mrpt::slam::CReflectivityGridMap2D) |
| mrpt::slam::CReflectivityGridMap2DPtr | |
| mrpt::bayes::CRejectionSamplingCapable | A base class for implementing rejection sampling in a generic state space |
| mrpt::slam::CRejectionSamplingRangeOnlyLocalization | An implementation of rejection sampling for generating 2D robot pose from range-only measurements within a landmarks (beacons) map |
| mrpt::opengl::CRenderizable | The base class of 3D objects that can be directly rendered through OpenGL |
| mrpt::opengl::CRenderizableDisplayList | A renderizable object suitable for rendering with OpenGL's display lists |
| mrpt::opengl::CRenderizableDisplayListPtr | |
| mrpt::opengl::CRenderizablePtr | |
| mrpt::poses::CRobot2DPoseEstimator | A simple filter to estimate and extrapolate the robot 2D (x,y,phi) pose from asynchronous odometry and localization data |
| mrpt::hwdrivers::CRoboticHeadInterface | This "software driver" implements the communication protocol for interfacing a Robotic Head Board through a custom USB RS-422 interface board |
| mrpt::hmtslam::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 |
| mrpt::hmtslam::CRobotPosesGraphPtr | |
| mrpt::utils::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 |
| Eigen::internal::cross3_impl | |
| mrpt::hwdrivers::CRovio | A class to interface a Rovio robot (manufactured by WowWee) |
| mrpt::bayes::detail::CRunOneKalmanIteration_addNewLandmarks | |
| cs_dmperm_results | |
| cs_numeric | |
| cs_sparse | |
| cs_symbolic | |
| mrpt::synch::CSemaphore | A semaphore for inter-thread synchronization |
| mrpt::slam::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 |
| mrpt::slam::CSensoryFramePtr | |
| mrpt::utils::CSerializable | The virtual base class which provides a unified interface for all persistent objects in MRPT |
| mrpt::utils::CSerializablePtr | |
| mrpt::hwdrivers::CSerialPort | A communications serial port built as an implementation of a utils::CStream |
| mrpt::utils::CServerTCPSocket | A TCP socket that can be wait for client connections to enter |
| mrpt::hwdrivers::CServoeNeck | A USB-interface for a custom "robotic neck" designed at MAPIR lab |
| mrpt::opengl::CSetOfLines | A set of independent lines (or segments), one line with its own start and end positions (X,Y,Z) |
| mrpt::opengl::CSetOfLinesPtr | |
| mrpt::opengl::CSetOfObjects | A set of object, which are referenced to the coordinates framework established in this object |
| mrpt::opengl::CSetOfObjectsPtr | |
| mrpt::opengl::CSetOfTexturedTriangles | A set of textured triangles |
| mrpt::opengl::CSetOfTexturedTrianglesPtr | |
| mrpt::opengl::CSetOfTriangles | A set of colored triangles |
| mrpt::opengl::CSetOfTrianglesPtr | |
| mrpt::hwdrivers::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) |
| mrpt::hwdrivers::CSickLaserUSB | This "software driver" implements the communication protocol for interfacing a SICK LMS2XX laser scanners through a custom USB RS-422 interface board |
| mrpt::utils::CSimpleDatabase | This class impements a very simple database system |
| mrpt::utils::CSimpleDatabasePtr | |
| mrpt::utils::CSimpleDatabaseTable | This class implements the tables of databases |
| mrpt::utils::CSimpleDatabaseTablePtr | |
| mrpt::opengl::CSimpleLine | A line segment |
| mrpt::opengl::CSimpleLinePtr | |
| mrpt::slam::CSimpleMap | This class stores a sequence of <Probabilistic Pose,SensoryFrame> pairs, thus a "metric map" can be totally determined with this information |
| mrpt::slam::CSimpleMapPtr | |
| mrpt::slam::CSimplePointsMap | A cloud of points in 2D or 3D, which can be built from a sequence of laser scans |
| mrpt::slam::CSimplePointsMapPtr | |
| mrpt::slam::CSinCosLookUpTableFor2DScans | A smart look-up-table (LUT) of sin/cos values for 2D laser scans |
| mrpt::math::CSparseMatrix | A sparse matrix capable of efficient math operations (a wrapper around the CSparse library) The type of cells is fixed to "double" |
| mrpt::math::CSparseMatrixTemplate | A sparse matrix container (with cells of any type), with iterators |
| mrpt::math::CSparseSymmetricalMatrix | A sparse matrix container for square symmetrical content around the main diagonal |
| mrpt::opengl::CSphere | A solid or wire-frame sphere |
| mrpt::opengl::CSpherePtr | |
| mrpt::math::CSplineInterpolator1D | A (persistent) sequence of (x,y) coordinates, allowing queries of intermediate points through spline interpolation, where possible |
| mrpt::math::CSplineInterpolator1DPtr | |
| mrpt::utils::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 |
| mrpt::math::CMonteCarlo::CStatisticalAnalyzer | |
| mrpt::utils::CStdOutStream | This CStdOutStream derived class allow printing to standard out, normally the console text output |
| mrpt::hwdrivers::CStereoGrabber_Bumblebee | A class for grabing stereo images from a "Bumblebee" or "Bumblebee2" camera NOTE: |
| mrpt::hwdrivers::CStereoGrabber_SVS | A class for grabing stereo images from a STOC camera of Videre Design NOTE: |
| mrpt::utils::CStream | This base class is used to provide a unified interface to files,memory buffers,..Please see the derived classes |
| mrpt::utils::CStringList | A class for storing a list of text lines |
| mrpt::utils::CStringListPtr | |
| mrpt::hwdrivers::CSwissRanger3DCamera | A class for grabing "range images" from a MESA imaging SwissRanger 3D cameras (SR-2, SR-3000, SR-4k) |
| mrpt::opengl::CText | A 2D text (bitmap rendering): it always "faces the observer" despite it's at some 3D location |
| mrpt::opengl::CText3D | A 3D text (rendered with OpenGL primitives), with selectable font face and drawing style |
| mrpt::opengl::CText3DPtr | |
| mrpt::utils::CTextFileLinesParser | A class for parsing text files, returning each non-empty and non-comment line, along its line number |
| mrpt::opengl::CTextMessageCapable | Keeps a list of text messages which can be rendered to OpenGL contexts by graphic classes |
| mrpt::opengl::CTextPtr | |
| mrpt::opengl::CTexturedObject | A base class for all OpenGL objects with loadable textures |
| mrpt::opengl::CTexturedObjectPtr | |
| mrpt::opengl::CTexturedPlane | A 2D plane in the XY plane with a texture image |
| mrpt::opengl::CTexturedPlanePtr | |
| mrpt::utils::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*" |
| mrpt::synch::CThreadSafeVariable | A template for created thread-safe variables with an internal critical section controlled each read or write |
| mrpt::utils::CTicTac | This class implements a high-performance stopwatch |
| mrpt::utils::CTimeLogger | A versatile "profiler" that logs the time spent within each pair of calls to enter(X)-leave(X), among other stats |
| mrpt::hmtslam::CTopLCDetector_FabMap | |
| mrpt::hmtslam::CTopLCDetector_GridMatching | |
| mrpt::hmtslam::CTopLCDetectorBase | The virtual base class for Topological Loop-closure Detectors; used in HMT-SLAM |
| mrpt::hwdrivers::CTuMicos | This class implements initialization and comunication methods to control a Tilt Unit model DT-80, working in radians |
| mrpt::utils::CTypeSelector | This class represents a std::string derived class which is also CSerializable |
| mrpt::utils::CTypeSelectorPtr | |
| mrpt::utils::CUncopiable | The base class of classes that cannot be copied: compile-time errors will be issued on any copy operation |
| mrpt::vision::CUndistortMap | Use this class to undistort images if the same distortion map is used over and over again |
| mrpt::vision::CVideoFileWriter | An output stream which takes a sequence of images and writes a video file in any of a given of compatible formats |
| mrpt::slam::CWeightedPointsMap | A cloud of points in 2D or 3D, which can be built from a sequence of laser scans |
| mrpt::slam::TMetricMapInitializer::CWeightedPointsMapOptions | Specific options for coloured point maps (mrpt::slam::CPointsMap) |
| mrpt::slam::CWeightedPointsMapPtr | |
| mrpt::hwdrivers::CWirelessPower | This class implements a wireless power probe |
| mrpt::slam::CWirelessPowerGridMap2D | CWirelessPowerGridMap2D represents a PDF of wifi concentrations over a 2D area |
| mrpt::slam::TMetricMapInitializer::CWirelessPowerGridMap2DOptions | Specific options for wifi grid maps (mrpt::slam::CWirelessPowerGridMap2D) |
| mrpt::slam::CWirelessPowerGridMap2DPtr | |
| Eigen::CwiseBinaryOp | Generic expression where a coefficient-wise binary operator is applied to two expressions |
| Eigen::CwiseBinaryOpImpl< BinaryOp, Lhs, Rhs, Dense > | |
| Eigen::CwiseBinaryOpImpl< BinaryOp, Lhs, Rhs, Sparse > | |
| Eigen::CwiseNullaryOp | Generic expression of a matrix where all coefficients are defined by a functor |
| Eigen::CwiseUnaryOp | Generic expression where a coefficient-wise unary operator is applied to an expression |
| Eigen::CwiseUnaryOpImpl< UnaryOp, MatrixType, Sparse > | |
| Eigen::CwiseUnaryOpImpl< UnaryOp, XprType, Dense > | |
| Eigen::CwiseUnaryView | Generic lvalue expression of a coefficient-wise unary operator of a matrix or a vector |
| Eigen::CwiseUnaryViewImpl< ViewOp, MatrixType, Dense > | |
| Eigen::CwiseUnaryViewImpl< ViewOp, MatrixType, Sparse > | |
| Eigen::internal::decrement_size | |
| Eigen::internal::default_packet_traits | |
| Eigen::SparseMatrix::default_prunning_func | |
| Eigen::Default_t | |
| Eigen::Dense | The type used to identify a dense storage |
| Eigen::internal::dense_xpr_base | |
| Eigen::internal::dense_xpr_base< Derived, ArrayXpr > | |
| Eigen::internal::dense_xpr_base< Derived, MatrixXpr > | |
| Eigen::DenseBase | Base class for all dense matrices, vectors, and arrays |
| Eigen::DenseCoeffsBase< Derived, DirectAccessors > | Base class providing direct read-only coefficient access to matrices and arrays |
| Eigen::DenseCoeffsBase< Derived, DirectWriteAccessors > | Base class providing direct read/write coefficient access to matrices and arrays |
| Eigen::DenseCoeffsBase< Derived, ReadOnlyAccessors > | Base class providing read-only coefficient access to matrices and arrays |
| Eigen::DenseCoeffsBase< Derived, WriteAccessors > | Base class providing read/write coefficient access to matrices and arrays |
| Eigen::DenseSparseProductReturnType | |
| Eigen::DenseSparseProductReturnType< Lhs, Rhs, 1 > | |
| Eigen::DenseStorage | |
| Eigen::DenseStorage< T, 0, _Rows, _Cols, _Options > | |
| Eigen::DenseStorage< T, 0, _Rows, Dynamic, _Options > | |
| Eigen::DenseStorage< T, 0, Dynamic, _Cols, _Options > | |
| Eigen::DenseStorage< T, 0, Dynamic, Dynamic, _Options > | |
| Eigen::DenseStorage< T, Dynamic, _Rows, Dynamic, _Options > | |
| Eigen::DenseStorage< T, Dynamic, Dynamic, _Cols, _Options > | |
| Eigen::DenseStorage< T, Dynamic, Dynamic, Dynamic, _Options > | |
| Eigen::DenseStorage< T, Size, _Rows, Dynamic, _Options > | |
| Eigen::DenseStorage< T, Size, Dynamic, _Cols, _Options > | |
| Eigen::DenseStorage< T, Size, Dynamic, Dynamic, _Options > | |
| Eigen::DenseTimeSparseProduct | |
| Eigen::DenseTimeSparseSelfAdjointProduct | |
| std::deque | STL class |
| Eigen::internal::determinant_impl | |
| Eigen::internal::determinant_impl< Derived, 1 > | |
| Eigen::internal::determinant_impl< Derived, 2 > | |
| Eigen::internal::determinant_impl< Derived, 3 > | |
| Eigen::internal::determinant_impl< Derived, 4 > | |
| Eigen::Diagonal | Expression of a diagonal/subdiagonal/superdiagonal in a matrix |
| Eigen::MatrixBase::DiagonalIndexReturnType | |
| Eigen::internal::BandMatrixBase::DiagonalIntReturnType | |
| Eigen::DiagonalMatrix | Represents a diagonal matrix with its storage |
| Eigen::DiagonalProduct | |
| Eigen::DiagonalWrapper | Expression of a diagonal matrix |
| TCLAP::DocBookOutput | A class that generates DocBook output for usage() method for the given CmdLine and its Args |
| std::domain_error | STL class |
| Eigen::internal::dot_nocheck | |
| Eigen::internal::dot_nocheck< T, U, true > | |
| Eigen::internal::gebp_traits< std::complex< RealScalar >, std::complex< RealScalar >, _ConjLhs, _ConjRhs >::DoublePacket | |
| mrpt::dynamicsize_vector | The base class of MRPT vectors, actually, Eigen column matrices of dynamic size with specialized constructors that resemble std::vector |
| Eigen::DynamicSparseMatrix | A sparse matrix class designed for matrix assembly purpose |
| mrpt::graphs::detail::edge_annotations_empty | An empty structure |
| mrpt::graphs::CDirectedGraph::edge_t | The type of each global pose in nodes: an extension of the TYPE_EDGES pose with any optional user-defined data |
| Eigen::EigenBase | Common base class for all classes T such that MatrixBase has an operator=(T) and a constructor MatrixBase(T) |
| Eigen::EigenSolver | |
| Eigen::internal::eigenvalues_selector | |
| Eigen::internal::eigenvalues_selector< Derived, false > | |
| Eigen::internal::enable_if< true, T > | |
| stlplus::end_dereference | |
| Eigen::internal::eval< Array< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols >, Dense > | |
| Eigen::internal::eval< Matrix< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols >, Dense > | |
| Eigen::internal::eval< T, Dense > | |
| Eigen::internal::eval< T, Sparse > | |
| std::exception | STL class |
| Eigen::VectorwiseOp::ExtendedType | |
| Eigen::internal::extract_data_selector | |
| Eigen::internal::extract_data_selector< T, false > | |
| std::ios_base::failure | STL class |
| Eigen::internal::false_type | |
| Eigen::internal::first_aligned_impl | |
| Eigen::internal::first_aligned_impl< Derived, false > | |
| Eigen::DenseBase::FixedSegmentReturnType | |
| Eigen::Flagged | Expression with modified flags |
| Eigen::internal::floor_log2 | |
| Eigen::internal::floor_log2< n, lower, upper, floor_log2_bogus > | |
| Eigen::internal::floor_log2< n, lower, upper, floor_log2_move_down > | |
| Eigen::internal::floor_log2< n, lower, upper, floor_log2_move_up > | |
| Eigen::internal::floor_log2< n, lower, upper, floor_log2_terminate > | |
| Eigen::internal::floor_log2_selector | |
| Eigen::ForceAlignedAccess | Enforce aligned packet loads and stores regardless of what is requested |
| std::fstream | STL class |
| mrpt::opengl::CAngularObservationMesh::FTrace1D | Internal functor class to trace a ray |
| mrpt::opengl::CAngularObservationMesh::FTrace2D | Internal functor class to trace a set of rays |
| Eigen::FullPivHouseholderQR | Householder rank-revealing QR decomposition of a matrix with full pivoting |
| Eigen::FullPivLU | LU decomposition of a matrix with complete pivoting, and related features |
| Eigen::internal::functor_allows_mixing_real_and_complex | |
| Eigen::internal::functor_allows_mixing_real_and_complex< scalar_conj_product_op< LhsScalar, RhsScalar > > | |
| Eigen::internal::functor_allows_mixing_real_and_complex< scalar_product_op< LhsScalar, RhsScalar > > | |
| Eigen::internal::functor_has_linear_access | |
| Eigen::internal::functor_has_linear_access< scalar_identity_op< Scalar > > | |
| Eigen::internal::functor_traits | |
| Eigen::internal::functor_traits< linspaced_op< Scalar, RandomAccess > > | |
| Eigen::internal::functor_traits< max_coeff_visitor< Scalar > > | |
| Eigen::internal::functor_traits< min_coeff_visitor< Scalar > > | |
| Eigen::internal::functor_traits< scalar_abs2_op< Scalar > > | |
| Eigen::internal::functor_traits< scalar_abs_op< Scalar > > | |
| Eigen::internal::functor_traits< scalar_acos_op< Scalar > > | |
| Eigen::internal::functor_traits< scalar_add_op< Scalar > > | |
| Eigen::internal::functor_traits< scalar_asin_op< Scalar > > | |
| Eigen::internal::functor_traits< scalar_boolean_and_op > | |
| Eigen::internal::functor_traits< scalar_boolean_or_op > | |
| Eigen::internal::functor_traits< scalar_cast_op< Scalar, NewType > > | |
| Eigen::internal::functor_traits< scalar_conj_product_op< LhsScalar, RhsScalar > > | |
| Eigen::internal::functor_traits< scalar_conjugate_op< Scalar > > | |
| Eigen::internal::functor_traits< scalar_constant_op< Scalar > > | |
| Eigen::internal::functor_traits< scalar_cos_op< Scalar > > | |
| Eigen::internal::functor_traits< scalar_cube_op< Scalar > > | |
| Eigen::internal::functor_traits< scalar_difference_op< Scalar > > | |
| Eigen::internal::functor_traits< scalar_exp_op< Scalar > > | |
| Eigen::internal::functor_traits< scalar_hypot_op< Scalar > > | |
| Eigen::internal::functor_traits< scalar_identity_op< Scalar > > | |
| Eigen::internal::functor_traits< scalar_imag_op< Scalar > > | |
| Eigen::internal::functor_traits< scalar_imag_ref_op< Scalar > > | |
| Eigen::internal::functor_traits< scalar_inverse_op< Scalar > > | |
| Eigen::internal::functor_traits< scalar_log_op< Scalar > > | |
| Eigen::internal::functor_traits< scalar_max_op< Scalar > > | |
| Eigen::internal::functor_traits< scalar_min_op< Scalar > > | |
| Eigen::internal::functor_traits< scalar_multiple2_op< Scalar1, Scalar2 > > | |
| Eigen::internal::functor_traits< scalar_multiple_op< Scalar > > | |
| Eigen::internal::functor_traits< scalar_opposite_op< Scalar > > | |
| Eigen::internal::functor_traits< scalar_pow_op< Scalar > > | |
| Eigen::internal::functor_traits< scalar_product_op< LhsScalar, RhsScalar > > | |
| Eigen::internal::functor_traits< scalar_quotient1_impl< Scalar, false > > | |
| Eigen::internal::functor_traits< scalar_quotient1_impl< Scalar, true > > | |
| Eigen::internal::functor_traits< scalar_quotient1_op< Scalar > > | |
| Eigen::internal::functor_traits< scalar_quotient_op< Scalar > > | |
| Eigen::internal::functor_traits< scalar_random_op< Scalar > > | |
| Eigen::internal::functor_traits< scalar_real_op< Scalar > > | |
| Eigen::internal::functor_traits< scalar_real_ref_op< Scalar > > | |
| Eigen::internal::functor_traits< scalar_sin_op< Scalar > > | |
| Eigen::internal::functor_traits< scalar_sqrt_op< Scalar > > | |
| Eigen::internal::functor_traits< scalar_square_op< Scalar > > | |
| Eigen::internal::functor_traits< scalar_sum_op< Scalar > > | |
| Eigen::internal::functor_traits< scalar_tan_op< Scalar > > | |
| Eigen::internal::functor_traits< std::binary_negate< T > > | |
| Eigen::internal::functor_traits< std::binder1st< T > > | |
| Eigen::internal::functor_traits< std::binder2nd< T > > | |
| Eigen::internal::functor_traits< std::divides< T > > | |
| Eigen::internal::functor_traits< std::equal_to< T > > | |
| Eigen::internal::functor_traits< std::greater< T > > | |
| Eigen::internal::functor_traits< std::greater_equal< T > > | |
| Eigen::internal::functor_traits< std::less< T > > | |
| Eigen::internal::functor_traits< std::less_equal< T > > | |
| Eigen::internal::functor_traits< std::logical_and< T > > | |
| Eigen::internal::functor_traits< std::logical_not< T > > | |
| Eigen::internal::functor_traits< std::logical_or< T > > | |
| Eigen::internal::functor_traits< std::minus< T > > | |
| Eigen::internal::functor_traits< std::multiplies< T > > | |
| Eigen::internal::functor_traits< std::negate< T > > | |
| Eigen::internal::functor_traits< std::not_equal_to< T > > | |
| Eigen::internal::functor_traits< std::plus< T > > | |
| Eigen::internal::functor_traits< std::unary_negate< T > > | |
| Eigen::internal::gebp_kernel | |
| Eigen::internal::gebp_madd_selector | |
| Eigen::internal::gebp_madd_selector< CJ, T, T, T, T > | |
| Eigen::internal::gebp_traits | |
| Eigen::internal::gebp_traits< RealScalar, std::complex< RealScalar >, false, _ConjRhs > | |
| Eigen::internal::gebp_traits< std::complex< RealScalar >, RealScalar, _ConjLhs, false > | |
| Eigen::internal::gebp_traits< std::complex< RealScalar >, std::complex< RealScalar >, _ConjLhs, _ConjRhs > | |
| Eigen::internal::gemm_blocking_space< StorageOrder, _LhsScalar, _RhsScalar, MaxRows, MaxCols, MaxDepth, false > | |
| Eigen::internal::gemm_blocking_space< StorageOrder, _LhsScalar, _RhsScalar, MaxRows, MaxCols, MaxDepth, true > | |
| Eigen::internal::gemm_functor | |
| Eigen::internal::gemm_pack_lhs | |
| Eigen::internal::gemm_pack_rhs< Scalar, Index, nr, ColMajor, Conjugate, PanelMode > | |
| Eigen::internal::gemm_pack_rhs< Scalar, Index, nr, RowMajor, Conjugate, PanelMode > | |
| Eigen::internal::GemmParallelInfo | |
| Eigen::internal::gemv_selector< OnTheLeft, StorageOrder, BlasCompatible > | |
| Eigen::internal::gemv_selector< OnTheRight, ColMajor, false > | |
| Eigen::internal::gemv_selector< OnTheRight, ColMajor, true > | |
| Eigen::internal::gemv_selector< OnTheRight, RowMajor, false > | |
| Eigen::internal::gemv_selector< OnTheRight, RowMajor, true > | |
| Eigen::internal::gemv_static_vector_if< Scalar, Size, Dynamic, true > | |
| Eigen::internal::gemv_static_vector_if< Scalar, Size, MaxSize, false > | |
| Eigen::internal::gemv_static_vector_if< Scalar, Size, MaxSize, true > | |
| Eigen::internal::general_matrix_matrix_product< Index, LhsScalar, LhsStorageOrder, ConjugateLhs, RhsScalar, RhsStorageOrder, ConjugateRhs, ColMajor > | |
| Eigen::internal::general_matrix_matrix_product< Index, LhsScalar, LhsStorageOrder, ConjugateLhs, RhsScalar, RhsStorageOrder, ConjugateRhs, RowMajor > | |
| Eigen::internal::general_matrix_matrix_triangular_product< Index, LhsScalar, LhsStorageOrder, ConjugateLhs, RhsScalar, RhsStorageOrder, ConjugateRhs, ColMajor, UpLo > | |
| Eigen::internal::general_matrix_matrix_triangular_product< Index, LhsScalar, LhsStorageOrder, ConjugateLhs, RhsScalar, RhsStorageOrder, ConjugateRhs, RowMajor, UpLo > | |
| Eigen::internal::general_matrix_vector_product< Index, LhsScalar, ColMajor, ConjugateLhs, RhsScalar, ConjugateRhs > | |
| Eigen::internal::general_matrix_vector_product< Index, LhsScalar, RowMajor, ConjugateLhs, RhsScalar, ConjugateRhs > | |
| Eigen::GeneralizedSelfAdjointEigenSolver | |
| GeneralProduct | Expression of the product of two general matrices or vectors |
| Eigen::GeneralProduct< Lhs, Rhs, GemmProduct > | |
| Eigen::GeneralProduct< Lhs, Rhs, GemvProduct > | |
| Eigen::GeneralProduct< Lhs, Rhs, InnerProduct > | |
| Eigen::GeneralProduct< Lhs, Rhs, OuterProduct > | |
| Eigen::GenericNumTraits | |
| Eigen::internal::get_factor | |
| Eigen::internal::get_factor< Scalar, typename NumTraits< Scalar >::Real > | |
| Eigen::internal::global_math_functions_filtering_base | |
| Eigen::internal::global_math_functions_filtering_base< T, typename always_void< typename T::Eigen_BaseClassForSpecializationOfGlobalMathFuncImpl >::type > | |
| mrpt::graphs::CNetworkOfPoses::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 |
| mrpt::graphs::detail::graph_ops | Helper struct with static template functions |
| mrpt::graphslam::graphslam_traits | Auxiliary traits template for use among graph-slam problems to make life easier with these complicated, long data type names |
| Eigen::internal::has_direct_access | |
| Eigen::internal::has_none | |
| Eigen::internal::has_std_result_type | |
| Eigen::internal::has_tr1_result | |
| TCLAP::HelpVisitor | A Visitor object that calls the usage method of the given CmdLineOutput object for the specified CmdLine object |
| Eigen::HessenbergDecomposition< _MatrixType > | |
| Eigen::internal::HessenbergDecompositionMatrixHReturnType< MatrixType > | |
| Eigen::Homogeneous | |
| Eigen::internal::homogeneous_left_product_impl< Homogeneous< MatrixType, Vertical >, Lhs > | |
| Eigen::internal::homogeneous_right_product_impl< Homogeneous< MatrixType, Horizontal >, Rhs > | |
| Eigen::HouseholderQR | Householder QR decomposition of a matrix |
| Eigen::HouseholderSequence | |
| Eigen::internal::hseq_side_dependent_impl | |
| Eigen::internal::hseq_side_dependent_impl< VectorsType, CoeffsType, OnTheRight > | |
| Eigen::Hyperplane | |
| Eigen::internal::hypot_impl | |
| Eigen::internal::hypot_retval | |
| std::ifstream | STL class |
| TCLAP::IgnoreRestVisitor | A Vistor that tells the CmdLine to begin ignoring arguments after this one is parsed |
| stlplus::illegal_copy | |
| Eigen::internal::imag_impl | |
| Eigen::internal::imag_impl< std::complex< RealScalar > > | |
| Eigen::internal::imag_ref_default_impl | |
| Eigen::internal::imag_ref_default_impl< Scalar, false > | |
| Eigen::internal::imag_ref_impl | |
| Eigen::internal::imag_ref_retval | |
| Eigen::internal::imag_retval | |
| Eigen::internal::image_retval< FullPivLU< _MatrixType > > | |
| Eigen::internal::image_retval_base | |
| imaxdiv_t | |
| nanoflann::IndexDist_Sorter | Operator "<" for std::sort() |
| Eigen::internal::inner_stride_at_compile_time | |
| Eigen::internal::inner_stride_at_compile_time< Derived, false > | |
| Eigen::SparseMatrix::InnerIterator | |
| Eigen::DynamicSparseMatrix::InnerIterator | |
| Eigen::MappedSparseMatrix::InnerIterator | |
| Eigen::SparseVector::InnerIterator | |
| Eigen::DenseBase::InnerIterator | |
| Eigen::SparseInnerVectorSet::InnerIterator | |
| Eigen::SparseInnerVectorSet< DynamicSparseMatrix< _Scalar, _Options, _Index >, Size >::InnerIterator | |
| Eigen::SparseInnerVectorSet< SparseMatrix< _Scalar, _Options, _Index >, Size >::InnerIterator | |
| Eigen::TransposeImpl< MatrixType, Sparse >::InnerIterator | |
| Eigen::CwiseUnaryOpImpl< UnaryOp, MatrixType, Sparse >::InnerIterator | |
| Eigen::CwiseUnaryViewImpl< ViewOp, MatrixType, Sparse >::InnerIterator | |
| Eigen::CwiseBinaryOpImpl< BinaryOp, Lhs, Rhs, Sparse >::InnerIterator | |
| Eigen::SparseDenseOuterProduct::InnerIterator | |
| Eigen::SparseTriangularView::InnerIterator | |
| Eigen::SparseView::InnerIterator | |
| InnerIterator | An InnerIterator allows to loop over the element of a sparse (or dense) matrix or expression |
| Eigen::InnerStride | Convenience specialization of Stride to specify only an inner stride See class Map for some examples |
| Eigen::internal::inplace_transpose_selector< MatrixType, false > | |
| Eigen::internal::inplace_transpose_selector< MatrixType, true > | |
| nanoflann::KDTreeSingleIndexAdaptor::Interval | |
| std::invalid_argument | STL class |
| Eigen::internal::inverse_impl | |
| Eigen::IOFormat | Stores a set of parameters controlling the way matrices are printed |
| std::ios | STL class |
| std::ios_base | STL class |
| Eigen::internal::is_arithmetic | |
| Eigen::internal::is_arithmetic< bool > | |
| Eigen::internal::is_arithmetic< char > | |
| Eigen::internal::is_arithmetic< double > | |
| Eigen::internal::is_arithmetic< float > | |
| Eigen::internal::is_arithmetic< long double > | |
| Eigen::internal::is_arithmetic< signed char > | |
| Eigen::internal::is_arithmetic< signed int > | |
| Eigen::internal::is_arithmetic< signed long > | |
| Eigen::internal::is_arithmetic< signed long long > | |
| Eigen::internal::is_arithmetic< signed short > | |
| Eigen::internal::is_arithmetic< unsigned char > | |
| Eigen::internal::is_arithmetic< unsigned int > | |
| Eigen::internal::is_arithmetic< unsigned long > | |
| Eigen::internal::is_arithmetic< unsigned long long > | |
| Eigen::internal::is_arithmetic< unsigned short > | |
| Eigen::internal::is_const | |
| Eigen::internal::is_const< T const > | |
| Eigen::internal::is_diagonal | |
| Eigen::internal::is_diagonal< DiagonalBase< T > > | |
| Eigen::internal::is_diagonal< DiagonalMatrix< T, S > > | |
| Eigen::internal::is_diagonal< DiagonalWrapper< T > > | |
| Eigen::internal::is_lvalue | |
| Eigen::internal::is_reference | |
| Eigen::internal::is_reference< T & > | |
| Eigen::internal::is_same | |
| Eigen::internal::is_same< T, T > | |
| Eigen::internal::isApprox_selector | |
| Eigen::internal::isApprox_selector< Derived, OtherDerived, true > | |
| Eigen::internal::isMuchSmallerThan_object_selector | |
| Eigen::internal::isMuchSmallerThan_object_selector< Derived, OtherDerived, true > | |
| Eigen::internal::isMuchSmallerThan_scalar_selector | |
| Eigen::internal::isMuchSmallerThan_scalar_selector< Derived, true > | |
| std::istream | STL class |
| std::istringstream | STL class |
| mrpt::slam::CRawlog::iterator | A normal iterator, plus the extra method "getType" to determine the type of each entry in the sequence |
| mrpt::poses::CPose3DQuat::iterator | |
| Eigen::AmbiVector::Iterator | Iterator over the nonzero coefficients |
| std::basic_string::iterator | STL iterator class |
| std::string::iterator | STL iterator class |
| std::wstring::iterator | STL iterator class |
| std::deque::iterator | STL iterator class |
| std::list::iterator | STL iterator class |
| std::map::iterator | STL iterator class |
| std::multimap::iterator | STL iterator class |
| std::set::iterator | STL iterator class |
| std::multiset::iterator | STL iterator class |
| std::vector::iterator | STL iterator class |
| Eigen::JacobiRotation | |
| Eigen::JacobiSVD | Two-sided Jacobi SVD decomposition of a rectangular matrix |
| mrpt::math::KDTreeCapable | A generic adaptor class for providing Approximate Nearest Neighbors (ANN) (via the nanoflann library) to MRPT classses |
| nanoflann::KDTreeEigenMatrixAdaptor | A simple KD-tree adaptor for working with data directly stored in an Eigen Matrix, without duplicating the data storage |
| nanoflann::KDTreeSingleIndexAdaptor | Kd-tree index |
| nanoflann::KDTreeSingleIndexAdaptorParams | Parameters |
| Eigen::internal::kernel_retval< FullPivLU< _MatrixType > > | |
| Eigen::internal::kernel_retval_base | |
| mrpt::vision::KeypointResponseSorter | A helper struct to sort keypoints by their response: It can be used with these types: |
| nanoflann::KNNResultSet | |
| nanoflann::L1_Adaptor | Manhattan distance functor (generic version, optimized for high-dimensionality data sets) |
| nanoflann::L2_Adaptor | Squared Euclidean distance functor (generic version, optimized for high-dimensionality data sets) |
| nanoflann::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 |
| Eigen::LazyProductReturnType | |
| Eigen::LDLT | Robust Cholesky decomposition of a matrix with pivoting |
| Eigen::internal::ldlt_inplace< Lower > | |
| Eigen::internal::ldlt_inplace< Upper > | |
| Eigen::internal::LDLT_Traits< MatrixType, Lower > | |
| Eigen::internal::LDLT_Traits< MatrixType, Upper > | |
| std::length_error | STL class |
| Eigen::internal::level3_blocking | |
| Eigen::internal::linspaced_op | |
| Eigen::internal::linspaced_op_impl< Scalar, false > | |
| Eigen::internal::linspaced_op_impl< Scalar, true > | |
| std::list | STL class |
| mrpt::utils::list_searchable | This class implements a STL container with features of both, a std::set and a std::list |
| Eigen::AmbiVector::ListEl | |
| Eigen::LLT | Standard Cholesky decomposition (LL^T) of a matrix and associated features |
| Eigen::internal::llt_inplace< Lower > | |
| Eigen::internal::llt_inplace< Upper > | |
| Eigen::internal::LLT_Traits< MatrixType, Lower > | |
| Eigen::internal::LLT_Traits< MatrixType, Upper > | |
| std::logic_error | STL class |
| mrpt::slam::detail::logoddscell_traits< int16_t > | |
| mrpt::slam::detail::logoddscell_traits< int8_t > | |
| Eigen::internal::lpNorm_selector | |
| Eigen::internal::lpNorm_selector< Derived, 1 > | |
| Eigen::internal::lpNorm_selector< Derived, 2 > | |
| Eigen::internal::lpNorm_selector< Derived, Infinity > | |
| mrpt::slam::detail::TPoseBin2D::lt_operator | Less-than ordering of bins for usage in STL containers |
| mrpt::slam::detail::TPathBin2D::lt_operator | Less-than ordering of bins for usage in STL containers |
| mrpt::slam::detail::TPoseBin3D::lt_operator | Less-than ordering of bins for usage in STL containers |
| Eigen::internal::make_proper_matrix_type | |
| Eigen::Map | A matrix or vector expression mapping an existing array of data |
| mrpt::utils::map_traits_stdmap::map | |
| mrpt::utils::map_traits_map_as_vector::map | |
| std::map | STL class |
| Eigen::Map< const Quaternion< _Scalar >, _Options > | Quaternion expression mapping a constant memory buffer |
| Eigen::Map< PermutationMatrix< SizeAtCompileTime, MaxSizeAtCompileTime, IndexType >, _PacketAccess > | |
| Eigen::Map< Quaternion< _Scalar >, _Options > | Expression of a quaternion from a memory buffer |
| Eigen::Map< Transpositions< SizeAtCompileTime, MaxSizeAtCompileTime, IndexType >, PacketAccess > | |
| mrpt::utils::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 |
| mrpt::utils::map_traits_map_as_vector | Traits for using a mrpt::utils::map_as_vector<> (dense, fastest representation) |
| mrpt::utils::map_traits_stdmap | Traits for using a std::map<> (sparse representation) |
| MapBase | Base class for Map and Block expression with direct access |
| Eigen::MapBase< Derived, ReadOnlyAccessors > | |
| Eigen::MapBase< Derived, WriteAccessors > | |
| Eigen::MappedSparseMatrix | Sparse matrix |
| internal_mrpt::MatOrVecResizer | |
| internal_mrpt::MatOrVecResizer< 1, 1 > | |
| internal_mrpt::MatOrVecResizer< 1, C > | |
| internal_mrpt::MatOrVecResizer< R, 1 > | |
| Eigen::Matrix | The matrix class, also used for vectors and row-vectors |
| Eigen::internal::matrix_swap_impl | |
| Eigen::internal::matrix_swap_impl< MatrixTypeA, MatrixTypeB, true > | |
| Eigen::internal::matrix_type_times_scalar_type | |
| Eigen::MatrixBase | Base class for all dense matrices, vectors, and expressions |
| Eigen::MatrixWrapper | Expression of an array as a mathematical vector or matrix |
| mrpt::math::detail::MatrixWrapper< U, false > | |
| mrpt::math::detail::MatrixWrapper< U, true > | |
| Eigen::MatrixXpr | The type used to identify a matrix expression |
| Eigen::internal::max_coeff_visitor | |
| Eigen::internal::member_redux | |
| mrpt::utils::metaprogramming::MemberFunctionWrapper | This template encapsulates a member function without arguments and a single object into a function |
| mrpt::utils::metaprogramming::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* |
| Eigen::internal::meta_sqrt | |
| Eigen::internal::meta_sqrt< Y, InfX, SupX, true > | |
| nanoflann::metric_L1 | Metaprogramming helper traits class for the L1 (Manhattan) metric |
| nanoflann::metric_L2 | Metaprogramming helper traits class for the L2 (Euclidean) metric |
| nanoflann::metric_L2_Simple | Metaprogramming helper traits class for the L2_simple (Euclidean) metric |
| Eigen::internal::min_coeff_visitor | |
| mrpt::math::ModelSearch | Model search implementations: RANSAC and genetic algorithm |
| 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 |
| mrpt::utils::mrptEvent | The basic event type for the observer-observable pattern in MRPT |
| mrpt::gui::mrptEvent3DWindowGrabImageFile | An event sent by a CDisplayWindow3D window when an image is saved after enabling this feature with CDisplayWindow3D::grabImagesStart() |
| mrpt::opengl::mrptEventGLPostRender | An event sent by an mrpt::opengl::COpenGLViewport after calling the scene OpenGL drawing primitives and before doing a glSwapBuffers |
| mrpt::opengl::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 |
| mrpt::slam::mrptEventMetricMapClear | Event emitted by a metric up upon call of clear() |
| mrpt::slam::mrptEventMetricMapInsert | Event emitted by a metric up upon a succesful call to insertObservation() |
| mrpt::gui::mrptEventMouseDown | An event sent by a window upon a mouse click, giving the (x,y) pixel coordinates |
| mrpt::utils::mrptEventOnDestroy | An event sent by any CObservable object (automatically) just before being destroyed and telling its observers to unsubscribe |
| mrpt::gui::mrptEventWindowChar | An event sent by a window upon a char pressed by the user |
| mrpt::gui::mrptEventWindowResize | An event sent by a window upon resize |
| mrpt::synch::MT_buffer | This class is a bulk sequence of bytes with MultiThread (MT)-safe read and write operations |
| TCLAP::MultiArg | An argument that allows multiple values of type T to be specified |
| std::multimap | STL class |
| std::multiset | STL class |
| TCLAP::MultiSwitchArg | A multiple switch argument |
| Eigen::internal::must_nest_by_value | |
| mrpt::hwdrivers::CPtuHokuyo::my_pos | |
| Eigen::NestByValue | Expression which must be nested by value |
| Eigen::internal::nested | |
| Eigen::internal::nested< CoeffBasedProduct< Lhs, Rhs, EvalBeforeNestingBit|EvalBeforeAssigningBit >, N, PlainObject > | |
| Eigen::internal::nested< GeneralProduct< Lhs, Rhs, Mode >, N, PlainObject > | |
| Eigen::internal::nested< ReturnByValue< Derived >, n, PlainObject > | |
| Eigen::internal::no_assignment_operator | |
| stlplus::no_copy | |
| Eigen::NoAlias | Pseudo expression providing an operator = assuming no aliasing |
| mrpt::utils::ci_less::nocase_compare | |
| Eigen::NoChange_t | |
| nanoflann::KDTreeSingleIndexAdaptor::Node | |
| mrpt::graphs::detail::node_annotations_empty | An empty structure |
| mrpt::utils::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 |
| mrpt::utils::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 |
| mrpt::utils::metaprogramming::NonConstBind1st | Equivalent of std::bind1st for functions with non-const arguments |
| mrpt::utils::metaprogramming::NonConstBind2nd | Equivalent of std::bind2nd for functions with non-const arguments |
| Eigen::internal::norm1_default_impl | |
| Eigen::internal::norm1_default_impl< Scalar, false > | |
| Eigen::internal::norm1_impl | |
| Eigen::internal::norm1_retval | |
| mrpt::hwdrivers::CNTRIPClient::NTRIPArgs | The arguments for connecting to a NTRIP stream, used in CNTRIPClient::open |
| stlplus::null_dereference | |
| Eigen::NumTraits | Holds information about the various numeric (i.e |
| Eigen::NumTraits< Array< Scalar, Rows, Cols, Options, MaxRows, MaxCols > > | |
| Eigen::NumTraits< double > | |
| Eigen::NumTraits< float > | |
| Eigen::NumTraits< long double > | |
| Eigen::NumTraits< std::complex< _Real > > | |
| mrpt::utils::metaprogramming::ObjectClear | An object for clearing an object (invokes its method "->clear()") given a pointer or smart-pointer, intended for being used in STL algorithms |
| mrpt::utils::metaprogramming::ObjectClear2 | An object for clearing an object (invokes its method ".clear()") given a pointer or smart-pointer, intended for being used in STL algorithms |
| mrpt::utils::metaprogramming::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 |
| mrpt::utils::metaprogramming::ObjectClearUnique | An object for making smart pointers unique (ie, making copies if necessary), intended for being used in STL algorithms |
| mrpt::utils::metaprogramming::ObjectConvert | An object for transforming between types/classes, intended for being used in STL algorithms |
| mrpt::utils::metaprogramming::ObjectDelete | An object for deleting pointers (intended for STL algorithms) |
| mrpt::utils::metaprogramming::ObjectMakeUnique | An object for making smart pointers unique (ie, making copies if necessary), intended for being used in STL algorithms |
| mrpt::utils::metaprogramming::ObjectPairMakeUnique | An object for making smart pointers unique (ie, making copies if necessary), intended for being used in STL algorithms |
| mrpt::utils::metaprogramming::ObjectReadFromStream | An object for reading objects from a stream, intended for being used in STL algorithms |
| mrpt::utils::metaprogramming::ObjectWriteToStream | An object for writing objects to a stream, intended for being used in STL algorithms |
| mrpt::graphslam::graphslam_traits::observation_info_t | Auxiliary struct used in graph-slam implementation: It holds the relevant information for each of the constraints being taking into account |
| std::ofstream | STL class |
| TCLAP::OptionalUnlabeledTracker | |
| std::ostream | STL class |
| std::ostringstream | STL class |
| std::out_of_range | STL class |
| Eigen::internal::outer_product_selector< ColMajor > | |
| Eigen::internal::outer_product_selector< RowMajor > | |
| Eigen::internal::outer_stride_at_compile_time | |
| Eigen::internal::outer_stride_at_compile_time< Derived, false > | |
| Eigen::OuterStride | Convenience specialization of Stride to specify only an outer stride See class Map for some examples |
| std::overflow_error | STL class |
| Eigen::internal::packet_traits | |
| Eigen::internal::palign_impl | |
| Eigen::ParametrizedLine | |
| Eigen::internal::partial_lu_impl | |
| Eigen::PartialPivLU | LU decomposition of a matrix with partial pivoting, and related features |
| Eigen::PartialReduxExpr | Generic expression of a partially reduxed matrix |
| Eigen::internal::permut_matrix_product_retval | |
| Eigen::PermutationBase | Base class for permutations |
| Eigen::PermutationMatrix | Permutation matrix |
| Eigen::PermutationStorage | |
| Eigen::PermutationWrapper | Class to view a vector of integers as a permutation matrix |
| mrpt::slam::PF_implementation | A set of common data shared by PF implementations for both SLAM and localization |
| Eigen::internal::plain_array | |
| Eigen::internal::plain_array< T, 0, MatrixOrArrayOptions, Alignment > | |
| Eigen::internal::plain_array< T, Size, MatrixOrArrayOptions, 16 > | |
| Eigen::internal::plain_col_type | |
| Eigen::internal::plain_diag_type | |
| Eigen::internal::plain_matrix_type< T, Dense > | |
| Eigen::internal::plain_matrix_type< T, Sparse > | |
| Eigen::internal::plain_matrix_type_column_major | |
| Eigen::internal::plain_matrix_type_dense< T, ArrayXpr > | |
| Eigen::internal::plain_matrix_type_dense< T, MatrixXpr > | |
| Eigen::internal::plain_matrix_type_row_major | |
| Eigen::internal::plain_row_type | |
| Eigen::PlainObjectBase | Dense storage base class for matrices and arrays |
| mrpt::utils::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 |
| mrpt::utils::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 |
| nanoflann::PooledAllocator | |
| mrpt::poses::detail::pose_point_impl< DERIVEDCLASS, 0 > | |
| mrpt::poses::detail::pose_point_impl< DERIVEDCLASS, 1 > | |
| Eigen::internal::pow_default_impl | |
| Eigen::internal::pow_default_impl< Scalar, true > | |
| Eigen::internal::pow_impl | |
| Eigen::internal::pow_retval | |
| std::priority_queue | STL class |
| Eigen::internal::product_coeff_impl< DefaultTraversal, 0, Lhs, Rhs, RetScalar > | |
| Eigen::internal::product_coeff_impl< DefaultTraversal, Dynamic, Lhs, Rhs, RetScalar > | |
| Eigen::internal::product_coeff_impl< DefaultTraversal, UnrollingIndex, Lhs, Rhs, RetScalar > | |
| Eigen::internal::product_coeff_impl< InnerVectorizedTraversal, Dynamic, Lhs, Rhs, RetScalar > | |
| Eigen::internal::product_coeff_impl< InnerVectorizedTraversal, UnrollingIndex, Lhs, Rhs, RetScalar > | |
| Eigen::internal::product_coeff_vectorized_dyn_selector | |
| Eigen::internal::product_coeff_vectorized_dyn_selector< Lhs, Rhs, 1, 1 > | |
| Eigen::internal::product_coeff_vectorized_dyn_selector< Lhs, Rhs, 1, RhsCols > | |
| Eigen::internal::product_coeff_vectorized_dyn_selector< Lhs, Rhs, LhsRows, 1 > | |
| Eigen::internal::product_coeff_vectorized_unroller | |
| Eigen::internal::product_coeff_vectorized_unroller< 0, Lhs, Rhs, Packet > | |
| Eigen::internal::product_packet_impl< ColMajor, 0, Lhs, Rhs, Packet, LoadMode > | |
| Eigen::internal::product_packet_impl< ColMajor, Dynamic, Lhs, Rhs, Packet, LoadMode > | |
| Eigen::internal::product_packet_impl< ColMajor, UnrollingIndex, Lhs, Rhs, Packet, LoadMode > | |
| Eigen::internal::product_packet_impl< RowMajor, 0, Lhs, Rhs, Packet, LoadMode > | |
| Eigen::internal::product_packet_impl< RowMajor, Dynamic, Lhs, Rhs, Packet, LoadMode > | |
| Eigen::internal::product_packet_impl< RowMajor, UnrollingIndex, Lhs, Rhs, Packet, LoadMode > | |
| Eigen::internal::product_selfadjoint_matrix< Scalar, Index, LhsStorageOrder, false, ConjugateLhs, RhsStorageOrder, true, ConjugateRhs, ColMajor > | |
| Eigen::internal::product_selfadjoint_matrix< Scalar, Index, LhsStorageOrder, LhsSelfAdjoint, ConjugateLhs, RhsStorageOrder, RhsSelfAdjoint, ConjugateRhs, RowMajor > | |
| Eigen::internal::product_selfadjoint_matrix< Scalar, Index, LhsStorageOrder, true, ConjugateLhs, RhsStorageOrder, false, ConjugateRhs, ColMajor > | |
| Eigen::internal::product_size_category | |
| Eigen::internal::product_triangular_matrix_matrix< Scalar, Index, Mode, false, LhsStorageOrder, ConjugateLhs, RhsStorageOrder, ConjugateRhs, ColMajor > | |
| Eigen::internal::product_triangular_matrix_matrix< Scalar, Index, Mode, LhsIsTriangular, LhsStorageOrder, ConjugateLhs, RhsStorageOrder, ConjugateRhs, RowMajor > | |
| Eigen::internal::product_triangular_matrix_matrix< Scalar, Index, Mode, true, LhsStorageOrder, ConjugateLhs, RhsStorageOrder, ConjugateRhs, ColMajor > | |
| Eigen::internal::product_triangular_matrix_vector< Index, Mode, LhsScalar, ConjLhs, RhsScalar, ConjRhs, ColMajor > | |
| Eigen::internal::product_triangular_matrix_vector< Index, Mode, LhsScalar, ConjLhs, RhsScalar, ConjRhs, RowMajor > | |
| Eigen::internal::product_type | |
| Eigen::internal::product_type_selector< 1, 1, 1 > | |
| Eigen::internal::product_type_selector< 1, 1, Depth > | |
| Eigen::internal::product_type_selector< 1, Large, Large > | |
| Eigen::internal::product_type_selector< 1, Large, Small > | |
| Eigen::internal::product_type_selector< 1, Small, Large > | |
| Eigen::internal::product_type_selector< 1, Small, Small > | |
| Eigen::internal::product_type_selector< Large, 1, Large > | |
| Eigen::internal::product_type_selector< Large, 1, Small > | |
| Eigen::internal::product_type_selector< Large, Large, Large > | |
| Eigen::internal::product_type_selector< Large, Large, Small > | |
| Eigen::internal::product_type_selector< Large, Small, 1 > | |
| Eigen::internal::product_type_selector< Large, Small, Large > | |
| Eigen::internal::product_type_selector< Large, Small, Small > | |
| Eigen::internal::product_type_selector< M, N, 1 > | |
| Eigen::internal::product_type_selector< Small, 1, Large > | |
| Eigen::internal::product_type_selector< Small, 1, Small > | |
| Eigen::internal::product_type_selector< Small, Large, 1 > | |
| Eigen::internal::product_type_selector< Small, Large, Large > | |
| Eigen::internal::product_type_selector< Small, Large, Small > | |
| Eigen::internal::product_type_selector< Small, Small, 1 > | |
| Eigen::internal::product_type_selector< Small, Small, Large > | |
| Eigen::internal::product_type_selector< Small, Small, Small > | |
| Eigen::ProductBase | |
| Eigen::ProductReturnType | Helper class to get the correct and optimized returned type of operator* |
| Eigen::ProductReturnType< Lhs, Rhs, CoeffBasedProductMode > | |
| Eigen::ProductReturnType< Lhs, Rhs, LazyCoeffBasedProductMode > | |
| Eigen::internal::projective_transform_inverse | |
| Eigen::internal::projective_transform_inverse< TransformType, Projective > | |
| Eigen::internal::promote_index_type | |
| Eigen::internal::promote_storage_type< A, A > | |
| Eigen::internal::promote_storage_type< Dense, Sparse > | |
| Eigen::internal::promote_storage_type< Sparse, Dense > | |
| Eigen::internal::qr_preconditioner_impl | |
| Eigen::internal::qr_preconditioner_impl< MatrixType, ColPivHouseholderQRPreconditioner, PreconditionIfMoreColsThanRows, true > | |
| Eigen::internal::qr_preconditioner_impl< MatrixType, ColPivHouseholderQRPreconditioner, PreconditionIfMoreRowsThanCols, true > | |
| Eigen::internal::qr_preconditioner_impl< MatrixType, FullPivHouseholderQRPreconditioner, PreconditionIfMoreColsThanRows, true > | |
| Eigen::internal::qr_preconditioner_impl< MatrixType, FullPivHouseholderQRPreconditioner, PreconditionIfMoreRowsThanCols, true > | |
| Eigen::internal::qr_preconditioner_impl< MatrixType, HouseholderQRPreconditioner, PreconditionIfMoreColsThanRows, true > | |
| Eigen::internal::qr_preconditioner_impl< MatrixType, HouseholderQRPreconditioner, PreconditionIfMoreRowsThanCols, true > | |
| Eigen::internal::qr_preconditioner_impl< MatrixType, QRPreconditioner, Case, false > | |
| Eigen::internal::qr_preconditioner_should_do_anything | |
| Eigen::internal::quat_product | |
| Eigen::Quaternion | |
| Eigen::QuaternionBase | |
| Eigen::internal::quaternionbase_assign_impl< Other, 3, 3 > | |
| Eigen::internal::quaternionbase_assign_impl< Other, 4, 1 > | |
| std::queue | STL class |
| nanoflann::RadiusResultSet | A result-set class used when performing a radius based search |
| Eigen::internal::random_default_impl | |
| Eigen::internal::random_default_impl< Scalar, false, false > | |
| Eigen::internal::random_default_impl< Scalar, false, true > | |
| Eigen::internal::random_default_impl< Scalar, true, false > | |
| Eigen::internal::random_impl | |
| Eigen::internal::random_impl< bool > | |
| Eigen::internal::random_retval | |
| std::range_error | STL class |
| mrpt::math::RANSAC_Template | A generic RANSAC implementation with models as matrices |
| mrpt::opengl::CAngularObservationMesh::TDoubleRange::rd | Union type with the actual data |
| Eigen::internal::real_impl | |
| Eigen::internal::real_impl< std::complex< RealScalar > > | |
| Eigen::internal::real_ref_impl | |
| Eigen::internal::real_ref_retval | |
| Eigen::internal::real_retval | |
| Eigen::RealSchur< _MatrixType > | |
| Eigen::aligned_allocator::rebind | |
| Eigen::internal::redux_impl< Func, Derived, DefaultTraversal, CompleteUnrolling > | |
| Eigen::internal::redux_impl< Func, Derived, DefaultTraversal, NoUnrolling > | |
| Eigen::internal::redux_impl< Func, Derived, LinearVectorizedTraversal, CompleteUnrolling > | |
| Eigen::internal::redux_impl< Func, Derived, LinearVectorizedTraversal, NoUnrolling > | |
| Eigen::internal::redux_impl< Func, Derived, SliceVectorizedTraversal, NoUnrolling > | |
| Eigen::internal::redux_novec_unroller | |
| Eigen::internal::redux_novec_unroller< Func, Derived, Start, 0 > | |
| Eigen::internal::redux_novec_unroller< Func, Derived, Start, 1 > | |
| Eigen::internal::redux_traits | |
| Eigen::internal::redux_vec_unroller | |
| Eigen::internal::redux_vec_unroller< Func, Derived, Start, 1 > | |
| Eigen::VectorwiseOp::ReduxReturnType | |
| Eigen::internal::ref_selector | |
| Eigen::internal::remove_all | |
| Eigen::internal::remove_all< const T > | |
| Eigen::internal::remove_all< T & > | |
| Eigen::internal::remove_all< T * > | |
| Eigen::internal::remove_all< T const & > | |
| Eigen::internal::remove_all< T const * > | |
| Eigen::internal::remove_const | |
| Eigen::internal::remove_const< const T > | |
| Eigen::internal::remove_const< const T[]> | |
| Eigen::internal::remove_const< const T[Size]> | |
| Eigen::internal::remove_pointer | |
| Eigen::internal::remove_pointer< T * > | |
| Eigen::internal::remove_pointer< T *const > | |
| Eigen::internal::remove_reference | |
| Eigen::internal::remove_reference< T & > | |
| Eigen::Replicate | Expression of the multiple replication of a matrix or vector |
| Eigen::internal::result_of | |
| Eigen::internal::result_of< Func(ArgType)> | |
| Eigen::internal::result_of< Func(ArgType0, ArgType1)> | |
| Eigen::ReturnByValue | |
| Eigen::VectorwiseOp::ReturnType | |
| Eigen::Reverse | Expression of the reverse of a vector or matrix |
| std::wstring::reverse_iterator | STL iterator class |
| std::set::reverse_iterator | STL iterator class |
| std::multiset::reverse_iterator | STL iterator class |
| std::basic_string::reverse_iterator | STL iterator class |
| std::vector::reverse_iterator | STL iterator class |
| std::string::reverse_iterator | STL iterator class |
| std::list::reverse_iterator | STL iterator class |
| std::deque::reverse_iterator | STL iterator class |
| std::map::reverse_iterator | STL iterator class |
| std::multimap::reverse_iterator | STL iterator class |
| Eigen::internal::reverse_packet_cond | |
| Eigen::internal::reverse_packet_cond< PacketScalar, false > | |
| mrpt::math::detail::ReverseAccessorIterator | Template class for matrix accessor's iterators |
| Eigen::TransposeImpl< MatrixType, Sparse >::ReverseInnerIterator | |
| Eigen::Rotation2D | |
| Eigen::internal::rotation_base_generic_product_selector< RotationDerived, DiagonalMatrix< Scalar, Dim, MaxDim >, false > | |
| Eigen::internal::rotation_base_generic_product_selector< RotationDerived, MatrixType, false > | |
| Eigen::internal::rotation_base_generic_product_selector< RotationDerived, OtherVectorType, true > | |
| Eigen::RotationBase | Common base class for compact rotation representations |
| std::runtime_error | STL class |
| mrpt::utils::safe_ptr | A wrapper class for pointers that can be safely copied with "=" operator without problems |
| mrpt::utils::safe_ptr_basic | A wrapper class for pointers that can be safely copied with "=" operator without problems |
| Eigen::internal::scalar_abs2_op | |
| Eigen::internal::scalar_abs_op | |
| Eigen::internal::scalar_acos_op | |
| Eigen::internal::scalar_add_op | |
| Eigen::internal::scalar_asin_op | |
| Eigen::internal::scalar_boolean_and_op | |
| Eigen::internal::scalar_boolean_or_op | |
| Eigen::internal::scalar_cast_op | |
| Eigen::internal::scalar_conj_product_op | |
| Eigen::internal::scalar_conjugate_op | |
| Eigen::internal::scalar_constant_op | |
| Eigen::internal::scalar_cos_op | |
| Eigen::internal::scalar_cube_op | |
| Eigen::internal::scalar_difference_op | |
| Eigen::internal::scalar_exp_op | |
| Eigen::internal::scalar_fuzzy_default_impl | |
| Eigen::internal::scalar_fuzzy_default_impl< Scalar, false, false > | |
| Eigen::internal::scalar_fuzzy_default_impl< Scalar, false, true > | |
| Eigen::internal::scalar_fuzzy_default_impl< Scalar, true, false > | |
| Eigen::internal::scalar_fuzzy_impl | |
| Eigen::internal::scalar_fuzzy_impl< bool > | |
| Eigen::internal::scalar_hypot_op | |
| Eigen::internal::scalar_identity_op | |
| Eigen::internal::scalar_imag_op | |
| Eigen::internal::scalar_imag_ref_op | |
| Eigen::internal::scalar_inverse_op | |
| Eigen::internal::scalar_log_op | |
| Eigen::internal::scalar_max_op | |
| Eigen::internal::scalar_min_op | |
| Eigen::internal::scalar_multiple2_op | |
| Eigen::internal::scalar_multiple_op | |
| Eigen::internal::scalar_opposite_op | |
| Eigen::internal::scalar_pow_op | |
| Eigen::internal::scalar_product_op | |
| Eigen::internal::scalar_product_traits< std::complex< T >, T > | |
| Eigen::internal::scalar_product_traits< T, std::complex< T > > | |
| Eigen::internal::scalar_product_traits< T, T > | |
| Eigen::internal::scalar_quotient1_impl | |
| Eigen::internal::scalar_quotient1_impl< Scalar, true > | |
| Eigen::internal::scalar_quotient1_op | |
| Eigen::internal::scalar_quotient_op | |
| Eigen::internal::scalar_random_op | |
| Eigen::internal::scalar_real_op | |
| Eigen::internal::scalar_real_ref_op | |
| Eigen::internal::scalar_sin_op | |
| Eigen::internal::scalar_sqrt_op | |
| Eigen::internal::scalar_square_op | |
| Eigen::internal::scalar_sum_op | |
| Eigen::internal::scalar_tan_op | |
| Eigen::ScaledProduct | |
| Scaling | |
| mrpt::poses::SE_traits< 2 > | Specialization of SE for 2D poses |
| mrpt::poses::SE_traits< 3 > | Specialization of SE for 3D poses |
| nanoflann::SearchParams | Search options for KDTreeSingleIndexAdaptor::findNeighbors() |
| Eigen::Select | Expression of a coefficient wise version of the C++ ternary operator ?: |
| Eigen::selfadjoint_product_selector< MatrixType, OtherType, UpLo, false > | |
| Eigen::selfadjoint_product_selector< MatrixType, OtherType, UpLo, true > | |
| Eigen::selfadjoint_rank1_update< Scalar, Index, ColMajor, UpLo, ConjLhs, ConjRhs > | |
| Eigen::selfadjoint_rank1_update< Scalar, Index, RowMajor, UpLo, ConjLhs, ConjRhs > | |
| Eigen::internal::selfadjoint_rank2_update_selector< Scalar, Index, UType, VType, Lower > | |
| Eigen::internal::selfadjoint_rank2_update_selector< Scalar, Index, UType, VType, Upper > | |
| Eigen::SelfAdjointEigenSolver | |
| Eigen::SelfadjointProductMatrix< Lhs, 0, true, Rhs, RhsMode, false > | |
| Eigen::SelfadjointProductMatrix< Lhs, LhsMode, false, Rhs, 0, true > | |
| Eigen::SelfadjointProductMatrix< Lhs, LhsMode, false, Rhs, RhsMode, false > | |
| Eigen::SelfAdjointView | Expression of a selfadjoint matrix from a triangular part of a dense matrix |
| Eigen::MatrixBase::SelfAdjointViewReturnType | |
| Eigen::SelfCwiseBinaryOp | |
| Eigen::Sequential_t | |
| std::set | STL class |
| Eigen::internal::setIdentity_impl | |
| Eigen::internal::setIdentity_impl< Derived, true > | |
| Eigen::internal::significant_decimals_default_impl | |
| Eigen::internal::significant_decimals_default_impl< Scalar, true > | |
| Eigen::internal::significant_decimals_impl | |
| Eigen::internal::size_at_compile_time | |
| Eigen::internal::smart_copy_helper< T, false > | |
| Eigen::internal::smart_copy_helper< T, true > | |
| stlplus::smart_ptr | |
| stlplus::smart_ptr_base | |
| stlplus::smart_ptr_clone | |
| stlplus::smart_ptr_holder | |
| stlplus::smart_ptr_nocopy | |
| Eigen::internal::solve_retval< ColPivHouseholderQR< _MatrixType >, Rhs > | |
| Eigen::internal::solve_retval< FullPivHouseholderQR< _MatrixType >, Rhs > | |
| Eigen::internal::solve_retval< FullPivLU< _MatrixType >, Rhs > | |
| Eigen::internal::solve_retval< HouseholderQR< _MatrixType >, Rhs > | |
| Eigen::internal::solve_retval< JacobiSVD< _MatrixType, QRPreconditioner >, Rhs > | |
| Eigen::internal::solve_retval< LDLT< _MatrixType, _UpLo >, Rhs > | |
| Eigen::internal::solve_retval< LLT< _MatrixType, UpLo >, Rhs > | |
| Eigen::internal::solve_retval< PartialPivLU< _MatrixType >, Rhs > | |
| Eigen::internal::solve_retval_base< _DecompositionType, Rhs > | |
| Eigen::Sparse | The type used to identify a general sparse storage |
| Eigen::internal::sparse_cwise_binary_op_inner_iterator_selector< BinaryOp, Lhs, Rhs, Derived, Sparse, Sparse > | |
| Eigen::internal::sparse_cwise_binary_op_inner_iterator_selector< scalar_product_op< T >, Lhs, Rhs, Derived, Dense, Sparse > | |
| Eigen::internal::sparse_cwise_binary_op_inner_iterator_selector< scalar_product_op< T >, Lhs, Rhs, Derived, Sparse, Dense > | |
| Eigen::internal::sparse_cwise_binary_op_inner_iterator_selector< scalar_product_op< T >, Lhs, Rhs, Derived, Sparse, Sparse > | |
| Eigen::internal::sparse_diagonal_product_inner_iterator_selector< Lhs, Rhs, SparseDiagonalProductType, SDP_IsDiagonal, SDP_IsSparseColMajor > | |
| Eigen::internal::sparse_diagonal_product_inner_iterator_selector< Lhs, Rhs, SparseDiagonalProductType, SDP_IsDiagonal, SDP_IsSparseRowMajor > | |
| Eigen::internal::sparse_diagonal_product_inner_iterator_selector< Lhs, Rhs, SparseDiagonalProductType, SDP_IsSparseColMajor, SDP_IsDiagonal > | |
| Eigen::internal::sparse_diagonal_product_inner_iterator_selector< Lhs, Rhs, SparseDiagonalProductType, SDP_IsSparseRowMajor, SDP_IsDiagonal > | |
| Eigen::internal::sparse_product_selector2< Lhs, Rhs, ResultType, ColMajor, ColMajor, ColMajor > | |
| Eigen::internal::sparse_product_selector2< Lhs, Rhs, ResultType, ColMajor, ColMajor, RowMajor > | |
| Eigen::internal::sparse_product_selector2< Lhs, Rhs, ResultType, ColMajor, RowMajor, ColMajor > | |
| Eigen::internal::sparse_product_selector2< Lhs, Rhs, ResultType, ColMajor, RowMajor, RowMajor > | |
| Eigen::internal::sparse_product_selector2< Lhs, Rhs, ResultType, RowMajor, ColMajor, ColMajor > | |
| Eigen::internal::sparse_product_selector2< Lhs, Rhs, ResultType, RowMajor, ColMajor, RowMajor > | |
| Eigen::internal::sparse_product_selector2< Lhs, Rhs, ResultType, RowMajor, RowMajor, ColMajor > | |
| Eigen::internal::sparse_product_selector2< Lhs, Rhs, ResultType, RowMajor, RowMajor, RowMajor > | |
| Eigen::internal::sparse_product_selector< Lhs, Rhs, ResultType, ColMajor, ColMajor, ColMajor > | |
| Eigen::internal::sparse_product_selector< Lhs, Rhs, ResultType, ColMajor, ColMajor, RowMajor > | |
| Eigen::internal::sparse_product_selector< Lhs, Rhs, ResultType, RowMajor, RowMajor, ColMajor > | |
| Eigen::internal::sparse_product_selector< Lhs, Rhs, ResultType, RowMajor, RowMajor, RowMajor > | |
| Eigen::internal::sparse_solve_triangular_selector< Lhs, Rhs, Mode, Lower, ColMajor > | |
| Eigen::internal::sparse_solve_triangular_selector< Lhs, Rhs, Mode, Lower, RowMajor > | |
| Eigen::internal::sparse_solve_triangular_selector< Lhs, Rhs, Mode, Upper, ColMajor > | |
| Eigen::internal::sparse_solve_triangular_selector< Lhs, Rhs, Mode, Upper, RowMajor > | |
| Eigen::internal::sparse_solve_triangular_sparse_selector< Lhs, Rhs, Mode, UpLo, ColMajor > | |
| Eigen::SparseDenseOuterProduct | |
| Eigen::SparseDenseProductReturnType | |
| Eigen::SparseDenseProductReturnType< Lhs, Rhs, 1 > | |
| Eigen::SparseDiagonalProduct | |
| Eigen::SparseInnerVectorSet | |
| Eigen::SparseInnerVectorSet< DynamicSparseMatrix< _Scalar, _Options, _Index >, Size > | |
| Eigen::SparseInnerVectorSet< SparseMatrix< _Scalar, _Options, _Index >, Size > | |
| Eigen::SparseMatrix | The main sparse matrix class |
| Eigen::SparseMatrixBase | Base class of any sparse matrices or sparse expressions |
| Eigen::SparseSelfAdjointTimeDenseProduct | |
| Eigen::SparseSelfAdjointView | Pseudo expression to manipulate a triangular sparse matrix as a selfadjoint matrix |
| Eigen::SparseSparseProduct | |
| Eigen::SparseSparseProductReturnType | |
| Eigen::SparseSymmetricPermutationProduct | |
| Eigen::SparseTimeDenseProduct | |
| Eigen::SparseTriangularView | |
| Eigen::SparseVector | Sparse vector class |
| Eigen::SparseView | |
| Eigen::internal::special_scalar_op_base | |
| Eigen::internal::special_scalar_op_base< Derived, Scalar, OtherScalar, true > | |
| TCLAP::SpecificationException | Thrown from Arg and CmdLine when an Arg is improperly specified, e.g |
| mrpt::system::Split | |
| Eigen::internal::sqrt_default_impl | |
| Eigen::internal::sqrt_default_impl< Scalar, true > | |
| Eigen::internal::sqrt_impl | |
| Eigen::internal::sqrt_retval | |
| std::stack | STL class |
| Eigen::internal::static_assertion | |
| Eigen::internal::static_assertion< true > | |
| TCLAP::StdOutput | A class that isolates any output from the CmdLine object so that it may be easily modified |
| Eigen::internal::stem_function | |
| Eigen::Stride | Holds strides information for Map |
| Eigen::PlainObjectBase::StridedAlignedMapType | |
| Eigen::PlainObjectBase::StridedConstAlignedMapType | |
| Eigen::PlainObjectBase::StridedConstMapType | |
| Eigen::PlainObjectBase::StridedMapType | |
| std::string | STL class |
| std::stringstream | STL class |
| Eigen::internal::svd_precondition_2x2_block_to_be_real | |
| Eigen::internal::svd_precondition_2x2_block_to_be_real< MatrixType, QRPreconditioner, false > | |
| Eigen::internal::svd_precondition_2x2_block_to_be_real< MatrixType, QRPreconditioner, true > | |
| Eigen::SwapWrapper | |
| TCLAP::SwitchArg | A simple switch argument |
| Eigen::internal::symm_pack_lhs | |
| Eigen::internal::symm_pack_rhs | |
| mrpt::slam::T2DScanProperties | Auxiliary struct that holds all the relevant *geometry* information about a 2D scan |
| mrpt::opengl::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 |
| mrpt::poses::detail::T3DTypeHelper< CPoint2D > | |
| mrpt::poses::detail::T3DTypeHelper< CPoint3D > | |
| mrpt::poses::detail::T3DTypeHelper< CPose2D > | |
| mrpt::poses::detail::T3DTypeHelper< CPose3D > | |
| mrpt::poses::detail::T3DTypeHelper< CPose3DQuat > | |
| Eigen::internal::take_matrix_for_product | |
| Eigen::internal::take_matrix_for_product< Transform< Scalar, Dim, Mode, Options > > | |
| Eigen::internal::take_matrix_for_product< Transform< Scalar, Dim, Projective, Options > > | |
| mrpt::hmtslam::TArcList | A class for storing a sequence of arcs (a path) |
| mrpt::math::detail::TAuxResizer | Internal resize which compiles to nothing on fixed-size matrices |
| mrpt::math::detail::TAuxResizer< MAT,-1 > | |
| mrpt::vision::CFeatureExtraction::TOptions::TBCDOptions | BCD Options |
| mrpt::hmtslam::CHMTSLAM::TMessageLSLAMfromTBI::TBI_info | |
| mrpt::utils::CTimeLogger::TCallData | Data of all the calls: |
| mrpt::utils::TCamera | Structure to hold the parameters of a pinhole camera model |
| mrpt::hwdrivers::CImageGrabber_dc1394::TCameraInfo | Used in enumerateCameras |
| mrpt::utils::TCameraPtr | |
| mrpt::hwdrivers::TCaptureCVOptions | Options used when creating an OpenCV capture object Some options apply to IEEE1394 cameras only |
| mrpt::hwdrivers::TCaptureOptions_bumblebee | Options used when creating a bumblebee camera capture object |
| mrpt::hwdrivers::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 |
| mrpt::hwdrivers::TCaptureOptions_SVS | Options used when creating a STOC Videre Design camera capture object |
| mrpt::reactivenav::CParameterizedTrajectoryGenerator::TCellForLambdaFunction | Specifies the min/max values for "k" and "n", respectively |
| mrpt::utils::TColor | A RGB color - 8bit |
| mrpt::utils::TColorf | A RGB color - floats in the range [0,1] |
| mrpt::slam::CColouredPointsMap::TColourOptions | The definition of parameters for generating colors from laser scans |
| mrpt::slam::CGridMapAligner::TConfigParams | The ICP algorithm configuration data |
| mrpt::slam::CMetricMapBuilderICP::TConfigParams | Algorithm configuration params |
| mrpt::slam::CICP::TConfigParams | The ICP algorithm configuration data |
| mrpt::slam::CMetricMapBuilderRBPF::TConstructionOptions | Options for building a CMetricMapBuilderRBPF object, passed to the constructor |
| mrpt::topography::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 |
| mrpt::reactivenav::CParameterizedTrajectoryGenerator::TCPoint | The trajectories in the C-Space: |
| mrpt::slam::COccupancyGridMap2D::TCriticalPointsList | The structure used to store the set of Voronoi diagram critical points |
| mrpt::slam::CLandmarksMap::TCustomSequenceLandmarks | The list of landmarks: the wrapper class is just for maintaining the KD-Tree representation |
| mrpt::slam::TDataAssociationResults | The results from mrpt::slam::data_association |
| mrpt::slam::CRangeBearingKFSLAM2D::TDataAssocInfo | Information for data-association: |
| mrpt::slam::CRangeBearingKFSLAM::TDataAssocInfo | Information for data-association: |
| mrpt::slam::CObservationGasSensors::CMOSmodel::TdataMap | The content of each m_lastObservations in the estimation when using the option : MOS_MODEl (useMOSmodel =1) |
| mrpt::slam::CGasConcentrationGridMap2D::TdataMap | The content of each m_lastObservations in the estimation when using the option : MOS_MODEl (insertionOptions.useMOSmodel =1) |
| mrpt::slam::CRejectionSamplingRangeOnlyLocalization::TDataPerBeacon | Data for each beacon observation with a correspondence with the map |
| mrpt::topography::TDatum10Params | Parameters for a topographic transfomation |
| mrpt::topography::TDatum1DTransf | Parameters for a topographic transfomation |
| mrpt::topography::TDatum7Params | Parameters for a topographic transfomation |
| mrpt::topography::TDatum7Params_TOPCON | |
| mrpt::topography::TDatumHelmert2D | Parameters for a topographic transfomation |
| mrpt::topography::TDatumHelmert2D_TOPCON | |
| mrpt::topography::TDatumHelmert3D | Parameters for a topographic transfomation |
| mrpt::topography::TDatumHelmert3D_TOPCON | Parameters for a topographic transfomation |
| mrpt::topography::TDatumTransfInterpolation | Parameters for a topographic transfomation |
| mrpt::vision::CFeature::TDescriptors | All the possible descriptors this feature may have |
| mrpt::slam::CMetricMapBuilderICP::TDist | Traveled distances from last map update / ICP-based localization |
| mrpt::graphs::CDijkstra::TDistance | Auxiliary struct for topological distances from root node |
| mrpt::slam::CDetectorDoorCrossing::TDoorCrossingOutParams | A structure used as output in this method |
| mrpt::opengl::CAngularObservationMesh::TDoubleRange | Range specification type, with several uses |
| mrpt::graphs::CDirectedTree::TEdgeInfo | |
| mrpt::topography::TEllipsoid | |
| mrpt::hwdrivers::CRovio::TEncoders | |
| mrpt::slam::COccupancyGridMap2D::TEntropyInfo | Used for returning entropy related information |
| mrpt::utils::TEnumType | A helper class that can convert an enum value into its textual representation, and viceversa |
| mrpt::utils::TEnumTypeFiller | Only specializations of this class are defined for each enum type of interest |
| mrpt::utils::TEnumTypeFiller< bayes::TKFMethod > | |
| mrpt::utils::TEnumTypeFiller< hwdrivers::CKinect::TVideoChannel > | |
| mrpt::utils::TEnumTypeFiller< poses::CPose3DInterpolator::TInterpolatorMethod > | |
| mrpt::utils::TEnumTypeFiller< slam::CHeightGridMap2D::TMapRepresentation > | |
| mrpt::utils::TEnumTypeFiller< slam::CMultiMetricMap::TOptions::TMapSelectionForLikelihood > | |
| mrpt::utils::TEnumTypeFiller< slam::CRandomFieldGridMap2D::TMapRepresentation > | |
| mrpt::utils::TEnumTypeFiller< slam::TDataAssociationMethod > | |
| mrpt::utils::TEnumTypeFiller< slam::TDataAssociationMetric > | |
| mrpt::vision::CGenericFeatureTracker::TExtraOutputInfo | |
| mrpt::bayes::CParticleFilterCapable::TFastDrawAuxVars | Auxiliary vectors, see CParticleFilterCapable::prepareFastDrawSample for more information |
| mrpt::vision::CFeatureExtraction::TOptions::TFASTOptions | FAST and FASTER Options |
| mrpt::vision::TFeatureObservation | One feature observation entry, used within sequences with TSequenceFeatureObservations |
| mrpt::system::CDirectoryExplorer::TFileInfo | This represents the information about each file |
| mrpt::system::CFileSystemWatcher::TFileSystemChange | Each of the changes detected by utils::CFileSystemWatcher |
| mrpt::hwdrivers::TFTDIDevice | A list of FTDI devices and their descriptors |
| mrpt::slam::CLandmarksMap::TFuseOptions | With this struct options are provided to the fusion process |
| mrpt::reactivenav::CHolonomicND::TGap | The structure used to store a detected gap in obstacles |
| mrpt::poses::CPointPDFSOG::TGaussianMode | The struct for each mode: |
| mrpt::poses::CPose3DPDFSOG::TGaussianMode | The struct for each mode: |
| mrpt::poses::CPosePDFSOG::TGaussianMode | The struct for each mode: |
| mrpt::topography::TGeodeticCoords | A set of geodetic coordinates: latitude, longitude and height, defined over a given geoid (typically, WGS84) |
| mrpt::slam::CObservationGPS::TGPSDatum_GGA | The GPS datum for GGA commands |
| mrpt::slam::CObservationGPS::TGPSDatum_PZS | The GPS datum for TopCon's mmGPS devices |
| mrpt::slam::CObservationGPS::TGPSDatum_RMC | The GPS datum for RMC commands |
| mrpt::slam::CObservationGPS::TGPSDatum_SATS | A generic structure for statistics about tracked satelites and their positions |
| mrpt::slam::CLandmarksMap::TLikelihoodOptions::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 |
| mrpt::vision::CFeatureExtraction::TOptions::THarrisOptions | Harris Options |
| mrpt::slam::THeightGridmapCell | The contents of each cell in a CHeightGridMap2D map |
| mrpt::reactivenav::CReactiveNavigationSystem::THolonomicMovement | The structure used for storing a movement generated by a holonomic-method |
| mrpt::system::detail::ThreadCreateFunctor | |
| mrpt::system::detail::ThreadCreateFunctor< void * > | |
| mrpt::system::detail::ThreadCreateFunctorNoParams | |
| mrpt::system::detail::ThreadCreateObjectFunctor | |
| mrpt::system::detail::ThreadCreateObjectFunctorNoParams | |
| mrpt::hwdrivers::ThreadParams | |
| mrpt::hmtslam::THypothesisIDSet | A set of hypothesis IDs, used for arcs and nodes in multi-hypothesis hybrid maps |
| mrpt::hmtslam::THypothesisIDSetPtr | |
| mrpt::vision::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) |
| mrpt::vision::TImageROI | A structure for defining a ROI within an image |
| mrpt::opengl::C3DSScene::TImpl3DS | A container for automatic deletion of lib3ds's scene when the last reference of the smart_ptr's is destroyed |
| mrpt::reactivenav::CLogFileRecord::TInfoPerPTG | The structure used to store all relevant information about each transformation into TP-Space |
| mrpt::slam::COccupancyGridMap2D::TInsertionOptions | With this struct options are provided to the observation insertion process |
| mrpt::slam::CWirelessPowerGridMap2D::TInsertionOptions | Parameters related with inserting observations into the map: |
| mrpt::slam::CHeightGridMap2D::TInsertionOptions | Parameters related with inserting observations into the map |
| mrpt::slam::CReflectivityGridMap2D::TInsertionOptions | Parameters related with inserting observations into the map |
| mrpt::slam::CGasConcentrationGridMap2D::TInsertionOptions | Parameters related with inserting observations into the map: |
| mrpt::slam::CPointsMap::TInsertionOptions | With this struct options are provided to the observation insertion process |
| mrpt::slam::CLandmarksMap::TInsertionOptions | With this struct options are provided to the observation insertion process |
| mrpt::slam::CBeaconMap::TInsertionOptions | This struct contains data for choosing the method by which new beacons are inserted in the map |
| mrpt::slam::CRandomFieldGridMap2D::TInsertionOptionsCommon | Parameters common to any derived class |
| mrpt::slam::CLandmarksMap::TInsertionResults | This struct stores extra results from invoking insertObservation |
| mrpt::math::KDTreeCapable::TKDTreeDataHolder | Internal structure with the KD-tree representation (mainly used to avoid copying pointers with the = operator) |
| mrpt::math::KDTreeCapable::TKDTreeSearchParams | |
| mrpt::bayes::TKF_options | Generic options for the Kalman Filter algorithm in itself |
| mrpt::slam::TKLDParams | Option set for KLD algorithm |
| mrpt::vision::CFeatureExtraction::TOptions::TKLTOptions | KLT Options |
| mrpt::slam::CPointsMap::TLaserRange2DInsertContext | Helper struct used for internal_loadFromRangeScan2D_prepareOneRange() |
| mrpt::slam::CPointsMap::TLaserRange3DInsertContext | Helper struct used for internal_loadFromRangeScan3D_prepareOneRange() |
| mrpt::opengl::COpenGLViewport::TLastProjectiveMatrixInfo | |
| mrpt::slam::CBeaconMap::TLikelihoodOptions | With this struct options are provided to the likelihood computations |
| mrpt::slam::COccupancyGridMap2D::TLikelihoodOptions | With this struct options are provided to the observation likelihood computation process |
| mrpt::slam::CPointsMap::TLikelihoodOptions | Options used when evaluating "computeObservationLikelihood" in the derived classes |
| mrpt::slam::CLandmarksMap::TLikelihoodOptions | With this struct options are provided to the likelihood computations |
| mrpt::slam::COccupancyGridMap2D::TLikelihoodOutput | Some members of this struct will contain intermediate or output data after calling "computeObservationLikelihood" for some likelihood functions |
| mrpt::math::TLine2D | 2D line without bounds, represented by its equation  |
| mrpt::math::TLine3D | 3D line, represented by a base point and a director vector |
| mrpt::vision::CFeatureExtraction::TOptions::TLogPolarImagesOptions | LogPolarImagesOptions Options |
| mrpt::vision::TMatchingOptions | A structure containing options for the matching |
| mrpt::utils::TMatchingPair | A structure for holding correspondences between two sets of points or points-like entities in 2D or 3D |
| mrpt::utils::TMatchingPairList | A list of TMatchingPair |
| mrpt::detectors::CFaceDetection::TMeasurement | |
| mrpt::slam::CObservationRange::TMeasurement | |
| mrpt::slam::CObservationBearingRange::TMeasurement | Each one of the measurements: |
| mrpt::slam::CObservationBeaconRanges::TMeasurement | Each one of the measurements: |
| mrpt::hmtslam::CHMTSLAM::TMessageLSLAMfromAA | Message definition: |
| mrpt::hmtslam::CHMTSLAM::TMessageLSLAMfromTBI | Message definition: |
| mrpt::hmtslam::CHMTSLAM::TMessageLSLAMtoTBI | Message definition: |
| mrpt::slam::TMetricMapInitializer | Each structure of this kind will determine the kind (and initial configuration) of one map to be build into a CMultiMetricMap object |
| mrpt::slam::TMonteCarloLocalizationParams | The struct for passing extra simulation parameters to the prediction stage when running a particle filter |
| mrpt::slam::CActionRobotMovement2D::TMotionModelOptions | The parameter to be passed to "computeFromOdometry" |
| mrpt::hwdrivers::CNTRIPClient::TMountPoint | A descriptor of one stream in an NTRIP Caster - See CNTRIPClient::retrieveListOfMountpoints |
| mrpt::random::CRandomGenerator::TMT19937_data | Data used internally by the MT19937 PRNG algorithm |
| mrpt::vision::TMultiResDescMatchOptions | Struct containing the options when matching multi-resolution SIFT-like descriptors |
| mrpt::vision::TMultiResDescOptions | Struct containing the options when computing the multi-resolution SIFT-like descriptors |
| mrpt::vision::TMultiResMatchingOutput | Struct containing the output after matching multi-resolution SIFT-like descriptors |
| mrpt::reactivenav::CAbstractReactiveNavigationSystem::TNavigationParams | The struct for configuring the navigation request |
| mrpt::opengl::COctreePointRenderer::TNode | The structure for each octree spatial node |
| mrpt::math::TObject2D | Standard type for storing any lightweight 2D type |
| mrpt::math::TObject3D | Standard object for storing any 3D lightweight object |
| mrpt::slam::CObservationGasSensors::TObservationENose | The structure for each e-nose |
| mrpt::slam::TMetricMapInitializer::TOccGridMap2DOptions | Specific options for grid maps (mrpt::slam::COccupancyGridMap2D) |
| mrpt::hmtslam::CTopLCDetector_GridMatching::TOptions | Options for a TLC-detector of type gridmap-matching, used from CHMTSLAM |
| mrpt::detectors::CCascadeClassifierDetection::TOptions | |
| mrpt::hwdrivers::CRovio::TOptions | |
| mrpt::hmtslam::CHMTSLAM::TOptions | A variety of options and configuration params (private, use loadOptions) |
| mrpt::slam::CMetricMapBuilder::TOptions | Options for the algorithm |
| mrpt::slam::CRangeBearingKFSLAM2D::TOptions | The options for the algorithm |
| mrpt::slam::CDetectorDoorCrossing::TOptions | In this structure parameters can be changed to customize the behaviour of this algorithm |
| mrpt::detectors::CFaceDetection::TOptions | |
| mrpt::slam::CIncrementalMapPartitioner::TOptions | Configuration of the algorithm: |
| mrpt::hmtslam::CTopLCDetector_FabMap::TOptions | Options for a TLC-detector of type FabMap, used from CHMTSLAM |
| mrpt::slam::CRangeBearingKFSLAM::TOptions | The options for the algorithm |
| mrpt::slam::CMultiMetricMap::TOptions | Some options for this class: |
| mrpt::reactivenav::CPRRTNavigator::TOptions | |
| mrpt::slam::CConsistentObservationAlignment::TOptions | The options for the method |
| mrpt::vision::CFeatureExtraction::TOptions | The set of parameters for all the detectors & descriptor algorithms |
| mrpt::poses::CRobot2DPoseEstimator::TOptions | |
| mrpt::slam::CActionRobotMovement2D::TMotionModelOptions::TOptions_GaussianModel | Options for the gaussian model, which generates a CPosePDFGaussian object in poseChange |
| mrpt::slam::CActionRobotMovement2D::TMotionModelOptions::TOptions_ThrunModel | Options for the Thrun's model, which generates a CPosePDFParticles object in poseChange |
| mrpt::slam::CGridMapAligner::TReturnInfo::TPairPlusDistance | |
| mrpt::utils::TParameters | For usage when passing a dynamic number of (numeric) arguments to a function, by name |
| mrpt::bayes::CParticleFilter::TParticleFilterOptions | The configuration of a particle filter |
| mrpt::bayes::CParticleFilter::TParticleFilterStats | Statistics for being returned from the "execute" method |
| mrpt::hmtslam::CLSLAM_RBPF_2DLASER::TPathBin | Auxiliary structure |
| mrpt::slam::detail::TPathBin2D | Auxiliary structure |
| mrpt::reactivenav::CPRRTNavigator::TPathData | Each data point in m_planned_path |
| mrpt::topography::TPathFromRTKInfo | Used to return optional information from mrpt::topography::path_from_rtk_gps |
| mrpt::reactivenav::CPRRTNavigator::TOptions::TPathTrackingOpts | |
| mrpt::utils::TPixelCoord | A pair (x,y) of pixel coordinates (integer resolution) |
| mrpt::utils::TPixelCoordf | A pair (x,y) of pixel coordinates (subpixel resolution) |
| mrpt::math::TPlane | 3D Plane, represented by its equation  |
| mrpt::reactivenav::CPRRTNavigator::TOptions::TPlannerOpts | |
| mrpt::math::TPoint2D | Lightweight 2D point |
| mrpt::math::TPoint3D | Lightweight 3D point |
| mrpt::math::TPoint3Df | Lightweight 3D point (float version) |
| mrpt::opengl::CPointCloudColoured::TPointColour | |
| mrpt::vision::CFeatureExtraction::TOptions::TPolarImagesOptions | PolarImagesOptions Options |
| mrpt::math::TPolygon2D | 2D polygon, inheriting from std::vector<TPoint2D> |
| mrpt::math::TPolygon3D | 3D polygon, inheriting from std::vector<TPoint3D> |
| mrpt::math::TPolygonWithPlane | Slightly heavyweight type to speed-up calculations with polygons in 3D |
| mrpt::opengl::CPolyhedron::TPolyhedronEdge | Struct used to store a polyhedron edge |
| mrpt::opengl::CPolyhedron::TPolyhedronFace | Struct used to store a polyhedron face |
| mrpt::math::TPose2D | Lightweight 2D pose |
| mrpt::math::TPose3D | Lightweight 3D pose (three spatial coordinates, plus three angular coordinates) |
| mrpt::math::TPose3DQuat | Lightweight 3D pose (three spatial coordinates, plus a quaternion ) |
| mrpt::slam::detail::TPoseBin2D | Auxiliary structure used in KLD-sampling in particle filters |
| mrpt::slam::detail::TPoseBin3D | Auxiliary structure used in KLD-sampling in particle filters |
| mrpt::hmtslam::TPoseInfo | Information kept for each robot pose used in CRobotPosesGraph |
| mrpt::graphs::detail::TPosePDFHelper | |
| mrpt::graphs::detail::TPosePDFHelper< CPose2D > | |
| mrpt::graphs::detail::TPosePDFHelper< CPose3D > | |
| mrpt::slam::CMultiMetricMapPDF::TPredictionParams | The struct for passing extra simulation parameters to the prediction/update stage when running a particle filter |
| mrpt::graphs::CDijkstra::TPrevious | Auxiliary struct for backward paths |
| mrpt::utils::TPropertyValueIDTriplet | Internal triplet for each property in utils::CMHPropertiesValuesList |
| mrpt::utils::CPropertiesValuesList::TPropertyValuePair | |
| mrpt::opengl::CGeneralizedCylinder::TQuadrilateral | Auxiliary struct holding any quadrilateral, represented by foour points |
| nanoflann::metric_L1::traits | |
| nanoflann::metric_L2::traits | |
| nanoflann::metric_L2_Simple::traits | |
| Eigen::internal::traits< AngleAxis< _Scalar > > | |
| Eigen::internal::traits< Array< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols > > | |
| Eigen::internal::traits< ArrayWrapper< ExpressionType > > | |
| Eigen::internal::traits< BandMatrix< _Scalar, _Rows, _Cols, _Supers, _Subs, _Options > > | |
| Eigen::internal::traits< BandMatrixWrapper< _CoefficientsType, _Rows, _Cols, _Supers, _Subs, _Options > > | |
| Eigen::internal::traits< Block< XprType, BlockRows, BlockCols, InnerPanel, HasDirectAccess > > | |
| Eigen::internal::traits< CoeffBasedProduct< LhsNested, RhsNested, NestingFlags > > | |
| Eigen::internal::traits< const T > | |
| Eigen::internal::traits< CwiseBinaryOp< BinaryOp, Lhs, Rhs > > | |
| Eigen::internal::traits< CwiseNullaryOp< NullaryOp, PlainObjectType > > | |
| Eigen::internal::traits< CwiseUnaryOp< UnaryOp, XprType > > | |
| Eigen::internal::traits< CwiseUnaryView< ViewOp, MatrixType > > | |
| Eigen::internal::traits< DenseTimeSparseProduct< Lhs, Rhs > > | |
| Eigen::internal::traits< DenseTimeSparseSelfAdjointProduct< Lhs, Rhs, UpLo > > | |
| Eigen::internal::traits< Diagonal< MatrixType, DiagIndex > > | |
| Eigen::internal::traits< DiagonalMatrix< _Scalar, SizeAtCompileTime, MaxSizeAtCompileTime > > | |
| Eigen::internal::traits< DiagonalProduct< MatrixType, DiagonalType, ProductOrder > > | |
| Eigen::internal::traits< DiagonalWrapper< _DiagonalVectorType > > | |
| Eigen::internal::traits< DynamicSparseMatrix< _Scalar, _Options, _Index > > | |
| Eigen::internal::traits< Flagged< ExpressionType, Added, Removed > > | |
| Eigen::internal::traits< ForceAlignedAccess< ExpressionType > > | |
| Eigen::internal::traits< GeneralProduct< Lhs, Rhs, GemmProduct > > | |
| Eigen::internal::traits< GeneralProduct< Lhs, Rhs, GemvProduct > > | |
| Eigen::internal::traits< GeneralProduct< Lhs, Rhs, InnerProduct > > | |
| Eigen::internal::traits< GeneralProduct< Lhs, Rhs, OuterProduct > > | |
| Eigen::internal::traits< HessenbergDecompositionMatrixHReturnType< MatrixType > > | |
| Eigen::internal::traits< Homogeneous< MatrixType, Direction > > | |
| Eigen::internal::traits< homogeneous_left_product_impl< Homogeneous< MatrixType, Vertical >, Lhs > > | |
| Eigen::internal::traits< homogeneous_right_product_impl< Homogeneous< MatrixType, Horizontal >, Rhs > > | |
| Eigen::internal::traits< HouseholderSequence< VectorsType, CoeffsType, Side > > | |
| Eigen::internal::traits< image_retval_base< DecompositionType > > | |
| Eigen::internal::traits< inverse_impl< MatrixType > > | |
| Eigen::internal::traits< kernel_retval_base< DecompositionType > > | |
| Eigen::internal::traits< Map< const Quaternion< _Scalar >, _Options > > | |
| Eigen::internal::traits< Map< PermutationMatrix< SizeAtCompileTime, MaxSizeAtCompileTime, IndexType >, _PacketAccess > > | |
| Eigen::internal::traits< Map< PlainObjectType, MapOptions, StrideType > > | |
| Eigen::internal::traits< Map< Quaternion< _Scalar >, _Options > > | |
| Eigen::internal::traits< Map< Transpositions< SizeAtCompileTime, MaxSizeAtCompileTime, IndexType >, _PacketAccess > > | |
| Eigen::internal::traits< MappedSparseMatrix< _Scalar, _Flags, _Index > > | |
| Eigen::internal::traits< Matrix< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols > > | |
| Eigen::internal::traits< MatrixWrapper< ExpressionType > > | |
| Eigen::internal::traits< NestByValue< ExpressionType > > | |
| Eigen::internal::traits< PartialReduxExpr< MatrixType, MemberOp, Direction > > | |
| Eigen::internal::traits< permut_matrix_product_retval< PermutationType, MatrixType, Side, Transposed > > | |
| Eigen::internal::traits< PermutationMatrix< SizeAtCompileTime, MaxSizeAtCompileTime, IndexType > > | |
| Eigen::internal::traits< PermutationWrapper< _IndicesType > > | |
| Eigen::internal::traits< ProductBase< Derived, _Lhs, _Rhs > > | |
| Eigen::internal::traits< Quaternion< _Scalar, _Options > > | |
| Eigen::internal::traits< Replicate< MatrixType, RowFactor, ColFactor > > | |
| Eigen::internal::traits< ReturnByValue< Derived > > | |
| Eigen::internal::traits< Reverse< MatrixType, Direction > > | |
| Eigen::internal::traits< Rotation2D< _Scalar > > | |
| Eigen::internal::traits< ScaledProduct< NestedProduct > > | |
| Eigen::internal::traits< Select< ConditionMatrixType, ThenMatrixType, ElseMatrixType > > | |
| Eigen::internal::traits< SelfadjointProductMatrix< Lhs, 0, true, Rhs, RhsMode, false > > | |
| Eigen::internal::traits< SelfadjointProductMatrix< Lhs, LhsMode, false, Rhs, 0, true > > | |
| Eigen::internal::traits< SelfadjointProductMatrix< Lhs, LhsMode, false, Rhs, RhsMode, false > > | |
| Eigen::internal::traits< SelfAdjointView< MatrixType, UpLo > > | |
| Eigen::internal::traits< SelfCwiseBinaryOp< BinaryOp, Lhs, Rhs > > | |
| Eigen::internal::traits< solve_retval_base< DecompositionType, Rhs > > | |
| Eigen::internal::traits< SparseDenseOuterProduct< Lhs, Rhs, Tr > > | |
| Eigen::internal::traits< SparseDiagonalProduct< Lhs, Rhs > > | |
| Eigen::internal::traits< SparseInnerVectorSet< MatrixType, Size > > | |
| Eigen::internal::traits< SparseMatrix< _Scalar, _Options, _Index > > | |
| Eigen::internal::traits< SparseSelfAdjointTimeDenseProduct< Lhs, Rhs, UpLo > > | |
| Eigen::internal::traits< SparseSelfAdjointView< MatrixType, UpLo > > | |
| Eigen::internal::traits< SparseSparseProduct< LhsNested, RhsNested > > | |
| Eigen::internal::traits< SparseSymmetricPermutationProduct< MatrixType, UpLo > > | |
| Eigen::internal::traits< SparseTimeDenseProduct< Lhs, Rhs > > | |
| Eigen::internal::traits< SparseTriangularView< MatrixType, Mode > > | |
| Eigen::internal::traits< SparseVector< _Scalar, _Options, _Index > > | |
| Eigen::internal::traits< SparseView< MatrixType > > | |
| Eigen::internal::traits< SwapWrapper< ExpressionType > > | |
| Eigen::internal::traits< Transpose< MatrixType > > | |
| Eigen::internal::traits< Transpose< PermutationBase< Derived > > > | |
| Eigen::internal::traits< transposition_matrix_product_retval< TranspositionType, MatrixType, Side, Transposed > > | |
| Eigen::internal::traits< Transpositions< SizeAtCompileTime, MaxSizeAtCompileTime, IndexType > > | |
| Eigen::internal::traits< TranspositionsWrapper< _IndicesType > > | |
| Eigen::internal::traits< triangular_solve_retval< Side, TriangularType, Rhs > > | |
| Eigen::internal::traits< TriangularProduct< Mode, LhsIsTriangular, Lhs, false, Rhs, false > > | |
| Eigen::internal::traits< TriangularProduct< Mode, LhsIsTriangular, Lhs, false, Rhs, true > > | |
| Eigen::internal::traits< TriangularProduct< Mode, LhsIsTriangular, Lhs, true, Rhs, false > > | |
| Eigen::internal::traits< TriangularView< MatrixType, _Mode > > | |
| Eigen::internal::traits< TridiagonalizationMatrixTReturnType< MatrixType > > | |
| Eigen::internal::traits< VectorBlock< VectorType, Size > > | |
| mrpt::slam::TRandomFieldCell | The contents of each cell in a CRandomFieldGridMap2D map |
| Eigen::Transform | |
| Eigen::internal::transform_construct_from_matrix< Other, AffineCompact, Options, Dim, HDim, HDim, HDim > | |
| Eigen::internal::transform_construct_from_matrix< Other, Mode, Options, Dim, HDim, Dim, Dim > | |
| Eigen::internal::transform_construct_from_matrix< Other, Mode, Options, Dim, HDim, Dim, HDim > | |
| Eigen::internal::transform_construct_from_matrix< Other, Mode, Options, Dim, HDim, HDim, HDim > | |
| Eigen::internal::transform_left_product_impl< Other, AffineCompact, Options, Dim, HDim, Dim, HDim > | |
| Eigen::internal::transform_left_product_impl< Other, AffineCompact, Options, Dim, HDim, HDim, HDim > | |
| Eigen::internal::transform_left_product_impl< Other, Mode, Options, Dim, HDim, Dim, Dim > | |
| Eigen::internal::transform_left_product_impl< Other, Mode, Options, Dim, HDim, Dim, HDim > | |
| Eigen::internal::transform_left_product_impl< Other, Mode, Options, Dim, HDim, HDim, HDim > | |
| Eigen::internal::transform_product_result | |
| Eigen::internal::transform_right_product_impl< TransformType, MatrixType, 0 > | |
| Eigen::internal::transform_right_product_impl< TransformType, MatrixType, 1 > | |
| Eigen::internal::transform_right_product_impl< TransformType, MatrixType, 2 > | |
| Eigen::internal::transform_take_affine_part | |
| Eigen::internal::transform_take_affine_part< Transform< Scalar, Dim, AffineCompact, Options > > | |
| Eigen::internal::transform_traits | |
| Eigen::internal::transform_transform_product_impl< Transform< Scalar, Dim, LhsMode, LhsOptions >, Transform< Scalar, Dim, RhsMode, RhsOptions >, false > | |
| Eigen::internal::transform_transform_product_impl< Transform< Scalar, Dim, LhsMode, LhsOptions >, Transform< Scalar, Dim, RhsMode, RhsOptions >, true > | |
| Eigen::Translation | |
| Eigen::Transpose | Expression of the transpose of a matrix |
| Eigen::Transpose< PermutationBase< Derived > > | |
| Eigen::Transpose< TranspositionsBase< TranspositionsDerived > > | |
| Eigen::TransposeImpl< MatrixType, Dense > | |
| Eigen::TransposeImpl< MatrixType, Sparse > | |
| Eigen::internal::TransposeImpl_base | |
| Eigen::internal::TransposeImpl_base< MatrixType, false > | |
| Eigen::internal::transposition_matrix_product_retval | |
| Eigen::Transpositions | Represents a sequence of transpositions (row/column interchange) |
| Eigen::TranspositionsBase | |
| Eigen::TranspositionsWrapper | |
| mrpt::vision::TRelativeFeaturePos | One relative feature observation entry, used with some relative bundle-adjustment functions |
| mrpt::opengl::gl_utils::TRenderInfo | Information about the rendering process being issued |
| mrpt::opengl::COctreePointRenderer::TRenderQueueElement | |
| mrpt::math::CLevenbergMarquardtTempl::TResultInfo | |
| mrpt::graphslam::TResultInfoSpaLevMarq | Output information for mrpt::graphslam::optimize_graph_spa_levmarq() |
| mrpt::slam::CGridMapAligner::TReturnInfo | The ICP algorithm return information |
| mrpt::slam::CICP::TReturnInfo | The ICP algorithm return information |
| Eigen::internal::triangular_assignment_selector | |
| Eigen::internal::triangular_assignment_selector< Derived1, Derived2, Lower, Dynamic, ClearOpposite > | |
| Eigen::internal::triangular_assignment_selector< Derived1, Derived2, Mode, 0, ClearOpposite > | |
| Eigen::internal::triangular_assignment_selector< Derived1, Derived2, SelfAdjoint|Lower, 0, ClearOpposite > | |
| Eigen::internal::triangular_assignment_selector< Derived1, Derived2, SelfAdjoint|Lower, Dynamic, ClearOpposite > | |
| Eigen::internal::triangular_assignment_selector< Derived1, Derived2, SelfAdjoint|Upper, 0, ClearOpposite > | |
| Eigen::internal::triangular_assignment_selector< Derived1, Derived2, SelfAdjoint|Upper, Dynamic, ClearOpposite > | |
| Eigen::internal::triangular_assignment_selector< Derived1, Derived2, StrictlyLower, Dynamic, ClearOpposite > | |
| Eigen::internal::triangular_assignment_selector< Derived1, Derived2, StrictlyUpper, Dynamic, ClearOpposite > | |
| Eigen::internal::triangular_assignment_selector< Derived1, Derived2, UnitLower, Dynamic, ClearOpposite > | |
| Eigen::internal::triangular_assignment_selector< Derived1, Derived2, UnitUpper, Dynamic, ClearOpposite > | |
| Eigen::internal::triangular_assignment_selector< Derived1, Derived2, Upper, Dynamic, ClearOpposite > | |
| Eigen::internal::triangular_assignment_selector< Derived1, Derived2,(SelfAdjoint|Lower), UnrollCount, ClearOpposite > | |
| Eigen::internal::triangular_assignment_selector< Derived1, Derived2,(SelfAdjoint|Upper), UnrollCount, ClearOpposite > | |
| Eigen::internal::triangular_solve_matrix< Scalar, Index, OnTheLeft, Mode, Conjugate, TriStorageOrder, ColMajor > | |
| Eigen::internal::triangular_solve_matrix< Scalar, Index, OnTheRight, Mode, Conjugate, TriStorageOrder, ColMajor > | |
| Eigen::internal::triangular_solve_matrix< Scalar, Index, Side, Mode, Conjugate, TriStorageOrder, RowMajor > | |
| Eigen::internal::triangular_solve_retval | |
| Eigen::internal::triangular_solve_vector< LhsScalar, RhsScalar, Index, OnTheLeft, Mode, Conjugate, ColMajor > | |
| Eigen::internal::triangular_solve_vector< LhsScalar, RhsScalar, Index, OnTheLeft, Mode, Conjugate, RowMajor > | |
| Eigen::internal::triangular_solve_vector< LhsScalar, RhsScalar, Index, OnTheRight, Mode, Conjugate, StorageOrder > | |
| Eigen::internal::triangular_solver_selector< Lhs, Rhs, OnTheLeft, Mode, CompleteUnrolling, 1 > | |
| Eigen::internal::triangular_solver_selector< Lhs, Rhs, OnTheRight, Mode, CompleteUnrolling, 1 > | |
| Eigen::internal::triangular_solver_selector< Lhs, Rhs, Side, Mode, NoUnrolling, 1 > | |
| Eigen::internal::triangular_solver_selector< Lhs, Rhs, Side, Mode, NoUnrolling, Dynamic > | |
| Eigen::internal::triangular_solver_unroller< Lhs, Rhs, Mode, Index, Size, false > | |
| Eigen::internal::triangular_solver_unroller< Lhs, Rhs, Mode, Index, Size, true > | |
| Eigen::TriangularBase | |
| Eigen::TriangularProduct< Mode, false, Lhs, true, Rhs, false > | |
| Eigen::TriangularProduct< Mode, LhsIsTriangular, Lhs, false, Rhs, false > | |
| Eigen::TriangularProduct< Mode, true, Lhs, false, Rhs, true > | |
| Eigen::TriangularView | Base class for triangular part in a matrix |
| Eigen::MatrixBase::TriangularViewReturnType | |
| Eigen::internal::tribb_kernel | |
| Eigen::Tridiagonalization< _MatrixType > | |
| Eigen::internal::tridiagonalization_inplace_selector< MatrixType, Size, IsComplex > | |
| Eigen::internal::tridiagonalization_inplace_selector< MatrixType, 1, IsComplex > | |
| Eigen::internal::tridiagonalization_inplace_selector< MatrixType, 3, false > | |
| Eigen::internal::TridiagonalizationMatrixTReturnType< MatrixType > | |
| Eigen::internal::TridiagonalMatrix | Represents a tridiagonal matrix with a compact banded storage |
| Eigen::internal::trmv_selector< ColMajor > | |
| Eigen::internal::trmv_selector< RowMajor > | |
| mrpt::hwdrivers::CActivMediaRobotBase::TRobotDescription | A structure describing the robot |
| mrpt::hmtslam::CLocalMetricHypothesis::TRobotPosesPartitioning | Used by AA thread |
| mrpt::vision::TROI | A structure for storing a 3D ROI |
| mrpt::hwdrivers::CRovio::TRovioState | |
| Eigen::internal::trsolve_traits | |
| Eigen::internal::true_type | |
| mrpt::utils::TRuntimeClassId | A structure that holds runtime class type information |
| mrpt::math::TSegment2D | 2D segment, consisting of two points |
| mrpt::math::TSegment3D | 3D segment, consisting of two points |
| mrpt::hwdrivers::TSensorClassId | A structure for runtime ID class type information in the context of hwdrivers::CGenericSensor |
| mrpt::hwdrivers::CHokuyoURG::TSensorInfo | Used in CHokuyoURG::displayVersionInfo |
| mrpt::vision::TSequenceFeatureObservations | A complete sequence of observations of features from different camera frames (poses) |
| mrpt::slam::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 |
| mrpt::vision::CFeatureExtraction::TOptions::TSIFTOptions | |
| mrpt::poses::TSimple3DPoint | Data within each particle |
| mrpt::poses::TSimple3DPointPtr | |
| mrpt::vision::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 |
| mrpt::vision::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 |
| mrpt::vision::TSimpleFeatureTraits< TSimpleFeature > | |
| mrpt::vision::TSimpleFeatureTraits< TSimpleFeaturef > | |
| mrpt::slam::CSinCosLookUpTableFor2DScans::TSinCosValues | A pair of vectors with the cos and sin values |
| mrpt::math::ModelSearch::TSpecies | |
| mrpt::vision::CFeatureExtraction::TOptions::TSpinImagesOptions | |
| mrpt::slam::CMetricMapBuilderRBPF::TStats | This structure will hold stats after each execution of processActionObservation |
| mrpt::utils::TStereoCamera | Structure to hold the parameters of a pinhole stereo camera model |
| mrpt::utils::TStereoCameraPtr | |
| mrpt::slam::TStereoImageFeatures | |
| mrpt::vision::TStereoSystemParams | Parameters associated to a stereo system |
| mrpt::vision::CFeatureExtraction::TOptions::TSURFOptions | |
| mrpt::detectors::CFaceDetection::TTestsOptions | |
| mrpt::system::TThreadHandle | This structure contains the information needed to interface the threads API on each platform: |
| mrpt::system::TTimeParts | The parts of a date/time (it's like the standard 'tm' but with fractions of seconds) |
| mrpt::opengl::CSetOfTexturedTriangles::TTriangle | Triangle |
| mrpt::opengl::CSetOfTriangles::TTriangle | Triangle definition |
| mrpt::utils::TTypeName | A template to obtain the type of its argument as a string at compile time |
| mrpt::utils::TTypeName< mrpt::math::CArrayDouble< N > > | |
| mrpt::utils::TTypeName< mrpt::math::CArrayFloat< N > > | |
| mrpt::utils::TTypeName< mrpt::math::CArrayNumeric< T, N > > | |
| mrpt::utils::TTypeName< mrpt::math::CMatrixFixedNumeric< T, N, M > > | |
| mrpt::utils::TTypeName< mrpt::math::CMatrixTemplateNumeric< T > > | |
| mrpt::utils::TTypeName< std::pair< T1, T2 > > | |
| mrpt::slam::COccupancyGridMap2D::TUpdateCellsInfoChangeOnly | An internal structure for storing data related to counting the new information apported by some observation |
| mrpt::slam::CObservationGPS::TUTCTime | A UTC time-stamp structure for GPS messages |
| mrpt::opengl::CSetOfTexturedTriangles::TVertex | Triangle vertex |
| Eigen::internal::unary_result_of_select | |
| Eigen::internal::unary_result_of_select< Func, ArgType, sizeof(has_std_result_type)> | |
| Eigen::internal::unary_result_of_select< Func, ArgType, sizeof(has_tr1_result)> | |
| mrpt::utils::metaprogramming::UnaryMemberFunctionWrapper | This template encapsulates an unary member function and a single object into a function expecting the parameter of the member function |
| std::underflow_error | STL class |
| Eigen::UniformScaling | |
| Eigen::internal::unitOrthogonal_selector | |
| Eigen::internal::unitOrthogonal_selector< Derived, 2 > | |
| Eigen::internal::unitOrthogonal_selector< Derived, 3 > | |
| TCLAP::UnlabeledMultiArg | Just like a MultiArg, except that the arguments are unlabeled |
| TCLAP::UnlabeledValueArg | The basic unlabeled argument that parses a value |
| Eigen::internal::unpacket_traits | |
| Eigen::internal::UpperBidiagonalization | |
| std::valarray | STL class |
| TCLAP::ValueArg | The basic labeled argument that parses a value |
| TCLAP::MULTI_ARG_HELPER::ValueExtractor | This class is used to extract a value from an argument |
| TCLAP::VALUE_ARG_HELPER::ValueExtractor | This class is used to extract a value from an argument |
| TCLAP::MULTI_ARG_HELPER::ValueExtractor< std::string > | Specialization for string |
| TCLAP::VALUE_ARG_HELPER::ValueExtractor< std::string > | Specialization for string |
| TCLAP::ValuesConstraint | A Constraint that constrains the Arg to only those values specified in the constraint |
| Eigen::internal::variable_if_dynamic | |
| Eigen::internal::variable_if_dynamic< T, Dynamic > | |
| std::vector | STL class |
| Eigen::VectorBlock | Expression of a fixed-size or dynamic-size sub-vector |
| Eigen::VectorwiseOp | Pseudo expression providing partial reduction operations |
| TCLAP::VersionVisitor | A Vistor that will call the version method of the given CmdLineOutput for the specified CmdLine object and then exit |
| mrpt::math::detail::VicinityTraits< CMatrixFixedNumeric< T, D, D > > | Vicinity traits class specialization for fixed size matrices |
| mrpt::math::detail::VicinityTraits< CMatrixTemplateNumeric< T > > | Vicinity traits class specialization for fixed size matrices |
| mrpt::graphs::CDirectedTree::Visitor | Virtual base class for user-defined visitors |
| TCLAP::Visitor | A base class that defines the interface for visitors |
| Eigen::internal::visitor_impl | |
| Eigen::internal::visitor_impl< Visitor, Derived, 1 > | |
| Eigen::internal::visitor_impl< Visitor, Derived, Dynamic > | |
| std::wfstream | STL class |
| std::wifstream | STL class |
| std::wios | STL class |
| std::wistream | STL class |
| std::wistringstream | STL class |
| Eigen::WithFormat | Pseudo expression providing matrix output with given format |
| std::wofstream | STL class |
| std::wostream | STL class |
| std::wostringstream | STL class |
| stlplus::wrong_object | |
| std::wstring | STL class |
| std::wstringstream | STL class |
| mrpt::gui::WxSubsystem | This class implements the GUI thread required for the wxWidgets-based GUI |
| TCLAP::XorHandler | This class handles lists of Arg's that are to be XOR'd on the command line |
