Main MRPT website > C++ reference
MRPT logo

Class List

Here are the classes, structs, unions and interfaces with brief descriptions:
internal::abs2_impl< Scalar >
internal::abs2_impl< std::complex< RealScalar > >
internal::abs2_retval< Scalar >
internal::abs_impl< Scalar >
internal::abs_retval< Scalar >
mrpt::math::detail::AccessorIterator< A, T >Template class for matrix accessor's iterators
internal::accessors_level< Derived >
TCLAP::ActionDoneException(Added by JLBC for MRPT): An exception that indicates to CmdLine::parse that help,version,..
internal::add_const< T >
internal::add_const< T & >
internal::add_const_on_value_type< T >
internal::add_const_on_value_type< T & >
internal::add_const_on_value_type< T * >
internal::add_const_on_value_type< T *const >
internal::add_const_on_value_type< T const *const >
internal::add_const_on_value_type_if_arithmetic< T >
aligned_allocator< T >STL compatible allocator to use with with 16 byte aligned types
Eigen::aligned_allocator_indirection< T >
mrpt::aligned_containers< TYPE1, TYPE2 >Helper types for STL containers with Eigen memory allocators
AlignedBox< _Scalar, _AmbientDim >
internal::all_unroller< Derived, UnrollCount >
internal::all_unroller< Derived, 1 >
internal::all_unroller< Derived, Dynamic >
internal::always_void< T >
AmbiVector< _Scalar, _Index >
AngleAxis< _Scalar >
ANNbd_shrink
ANNbruteForce
ANNkd_leaf
ANNkd_node
ANNkd_split
ANNkd_tree
ANNkdStats
ANNmin_k
ANNorthHalfSpace
ANNorthRect
ANNpointSet
ANNpr_queue
ANNsampStat
internal::any_unroller< Derived, UnrollCount >
internal::any_unroller< Derived, 1 >
internal::any_unroller< Derived, Dynamic >
TCLAP::ArgA virtual base class that defines the essential data for all arguments
TCLAP::ArgExceptionA simple class that defines and argument exception
TCLAP::ArgParseExceptionThrown from within the child Arg classes when it fails to properly parse the argument it has been passed
Array< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols >General-purpose arrays with easy API for coefficient-wise operations
ArrayBase< Derived >Base class for all 1D and 2D array, and related expressions
ArrayWrapper< ExpressionType >Expression of a mathematical vector or matrix as an array object
ArrayXprThe type used to identify an array expression
internal::assign_DefaultTraversal_CompleteUnrolling< Derived1, Derived2, Index, Stop >
internal::assign_DefaultTraversal_CompleteUnrolling< Derived1, Derived2, Stop, Stop >
internal::assign_DefaultTraversal_InnerUnrolling< Derived1, Derived2, Index, Stop >
internal::assign_DefaultTraversal_InnerUnrolling< Derived1, Derived2, Stop, Stop >
internal::assign_impl< Derived1, Derived2, DefaultTraversal, CompleteUnrolling >
internal::assign_impl< Derived1, Derived2, DefaultTraversal, InnerUnrolling >
internal::assign_impl< Derived1, Derived2, DefaultTraversal, NoUnrolling >
internal::assign_impl< Derived1, Derived2, InnerVectorizedTraversal, CompleteUnrolling >
internal::assign_impl< Derived1, Derived2, InnerVectorizedTraversal, InnerUnrolling >
internal::assign_impl< Derived1, Derived2, InnerVectorizedTraversal, NoUnrolling >
internal::assign_impl< Derived1, Derived2, InvalidTraversal, Unrolling >
internal::assign_impl< Derived1, Derived2, LinearTraversal, CompleteUnrolling >
internal::assign_impl< Derived1, Derived2, LinearTraversal, NoUnrolling >
internal::assign_impl< Derived1, Derived2, LinearVectorizedTraversal, CompleteUnrolling >
internal::assign_impl< Derived1, Derived2, LinearVectorizedTraversal, NoUnrolling >
internal::assign_impl< Derived1, Derived2, SliceVectorizedTraversal, NoUnrolling >
internal::assign_innervec_CompleteUnrolling< Derived1, Derived2, Index, Stop >
internal::assign_innervec_CompleteUnrolling< Derived1, Derived2, Stop, Stop >
internal::assign_innervec_InnerUnrolling< Derived1, Derived2, Index, Stop >
internal::assign_innervec_InnerUnrolling< Derived1, Derived2, Stop, Stop >
internal::assign_LinearTraversal_CompleteUnrolling< Derived1, Derived2, Index, Stop >
internal::assign_LinearTraversal_CompleteUnrolling< Derived1, Derived2, Stop, Stop >
internal::assign_selector< Derived, OtherDerived, false, false >
internal::assign_selector< Derived, OtherDerived, false, true >
internal::assign_selector< Derived, OtherDerived, true, false >
internal::assign_selector< Derived, OtherDerived, true, true >
internal::assign_traits< Derived, OtherDerived >
internal::atan2_default_impl< Scalar, IsInteger >
internal::atan2_default_impl< Scalar, true >
internal::atan2_impl< Scalar >
internal::atan2_retval< Scalar >
internal::BandMatrix< _Scalar, Rows, Cols, Supers, Subs, Options >Represents a rectangular matrix with a banded storage
mrpt::utils::bimap< KEY, VALUE >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
internal::binary_result_of_select< Func, ArgType0, ArgType1, SizeOf >
internal::binary_result_of_select< Func, ArgType0, ArgType1, sizeof(has_std_result_type)>
internal::binary_result_of_select< Func, ArgType0, ArgType1, sizeof(has_tr1_result)>
mrpt::utils::metaprogramming::BinaryMemberFunctionWrapper< T, U1, U2, V >This template encapsulates a binary member function and a single object into a function expecting the two parameters of the member function
internal::blas_data_mapper< Scalar, Index, StorageOrder >
internal::blas_traits< XprType >
internal::blas_traits< const T >
internal::blas_traits< CwiseUnaryOp< scalar_conjugate_op< Scalar >, NestedXpr > >
internal::blas_traits< CwiseUnaryOp< scalar_multiple_op< Scalar >, NestedXpr > >
internal::blas_traits< CwiseUnaryOp< scalar_opposite_op< Scalar >, NestedXpr > >
internal::blas_traits< SelfCwiseBinaryOp< BinOp, NestedXpr, Rhs > >
internal::blas_traits< Transpose< NestedXpr > >
Block< XprType, BlockRows, BlockCols, InnerPanel, HasDirectAccess >Expression of a fixed-size or dynamic-size block
Block< XprType, BlockRows, BlockCols, InnerPanel, true >
mrpt::hwdrivers::C2DRangeFinderAbstractThis is the base, abstract class for "software drivers" interfaces to 2D scanners (laser range finders)
mrpt::opengl::C3DSSceneThis element keeps a set of objects imported from a 3DStudio file (.3ds)
mrpt::opengl::C3DSScenePtr
mrpt::reactivenav::CAbstractHolonomicReactiveMethodA base class for holonomic reactive navigation methods
mrpt::reactivenav::CAbstractReactiveNavigationSystemThis is the base class for any reactive navigation system
mrpt::slam::CActionDeclares a class for storing a robot action
mrpt::slam::CActionCollectionDeclares a class for storing a collection of robot actions
mrpt::slam::CActionCollectionPtr
mrpt::slam::CActionPtr
mrpt::slam::CActionRobotMovement2DRepresents a probabilistic 2D movement of the robot mobile base
mrpt::slam::CActionRobotMovement2DPtr
mrpt::slam::CActionRobotMovement3DRepresents a probabilistic 3D (6D) movement
mrpt::slam::CActionRobotMovement3DPtr
mrpt::hwdrivers::CActivMediaRobotBaseThis software driver implements the communications (and some rudimentary control) for ActivMedia robotic bases (Pioneer DX/AT, PeopleBot, etc)
mrpt::vision::CCamModel::CameraTempVariables< T >
mrpt::opengl::CAngularObservationMeshA mesh built from a set of 2D laser scan observations
mrpt::opengl::CAngularObservationMeshPtr
mrpt::math::CArray< T, N >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< N >A partial specialization of CArrayNumeric for double numbers
mrpt::math::CArrayFloat< N >A partial specialization of CArrayNumeric for float numbers
mrpt::math::CArrayInt< N >A partial specialization of CArrayNumeric for int numbers
mrpt::math::CArrayNumeric< T, N >CArrayNumeric is an array for numeric types supporting several mathematical operations (actually, just a wrapper on Eigen::Matrix<T,N,1>)
mrpt::math::CArrayUInt< N >A partial specialization of CArrayNumeric for unsigned int numbers
mrpt::opengl::CArrowA 3D arrow
mrpt::opengl::CArrowPtr
internal::cast_impl< OldType, NewType >
internal::cast_return_type< XprType, CastType >
mrpt::math::CAStarAlgorithm< T >This class is intended to efficiently solve graph-search problems using heuristics to determine the best path
mrpt::synch::CAtomicCounterThis class acts exactly as an int (or long) variable, but with atomic increment and decrement operators
mrpt::opengl::CAxisDraw a 3D world axis, with coordinate marks at some regular interval
mrpt::opengl::CAxisPtr
mrpt::gui::CBaseGUIWindowThe base class for GUI window classes
mrpt::gui::CBaseGUIWindowPtr
mrpt::slam::CBeaconThe class for storing individual "beacon landmarks" under a variety of 3D position PDF distributions
mrpt::slam::CBeaconMapA 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::CBeaconMapOptionsEspecific options for landmarks maps (mrpt::slam::CBeaconMap)
mrpt::slam::CBeaconMapPtr
mrpt::slam::CBeaconPtr
mrpt::math::CBinaryRelation< T, U, UIsObject >This class models a binary relation through the elements of any given set
mrpt::hwdrivers::CBoardDLMSAn interface to a custom board which interfaces two SICK laser scanners
mrpt::hwdrivers::CBoardENosesA class for interfacing an e-Noses via a FTDI USB link
mrpt::hwdrivers::CBoardIRA parser of NMEA commands, for connecting to a GPS by a serial port
mrpt::hwdrivers::CBoardSonarsThis "software driver" implements the communication protocol for interfacing a Ultrasonic range finder SRF10 through a custom USB board
mrpt::opengl::CBoxA 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::CCameraA 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::CCameraSensorThe central class for camera grabbers in MRPT, implementing the "generic sensor" interface
mrpt::vision::CCamModelThis class represent a pinhole camera model for Monocular SLAM and implements some associated Jacobians
mrpt::utils::CCanvasThis virtual class defines the interface of any object accepting drawing primitives on it
mrpt::detectors::CCascadeClassifierDetection
mrpt::utils::CClientTCPSocketA 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::CColisionGridAn internal class for storing the collision grid
mrpt::slam::CColouredPointsMapA map of 2D/3D points with individual colours (RGB)
mrpt::slam::TMetricMapInitializer::CColouredPointsMapOptionsEspecific options for coloured points maps (mrpt::slam::CPointsMap)
mrpt::slam::CColouredPointsMapPtr
mrpt::utils::CConfigFileThis class allows loading and storing values and vectors of different types from ".ini" files easily
mrpt::utils::CConfigFileBaseThis 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::CConfigFileMemoryThis class implements a config file-like interface over a memory-stored string list
mrpt::slam::CConsistentObservationAlignmentAn algorithm for globally, consistent alignment of a sequence of observations
mrpt::utils::CConsoleRedirectorBy 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< MAT >A vector-like wrapper for a const Matrix for accessing the elements of a given column with a [] operator
mrpt::math::CConstMatrixColumnAccessorExtended< MAT >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< MAT >A vector-like wrapper for a const Matrix for accessing the elements of a given row with a [] operator
mrpt::math::CConstMatrixRowAccessorExtended< MAT >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::CCriticalSectionThis class provides simple critical sections functionality
mrpt::synch::CCriticalSectionLockerA class acquiring a CCriticalSection at its constructor, and releasing it at destructor
mrpt::opengl::CCylinderA cylinder or cone whose base lies in the XY plane
mrpt::opengl::CCylinderPtr
mrpt::utils::CDebugOutputCapableThis 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::CDetectableObjectBase class that contains common atributes and functions of detectable objects
mrpt::detectors::CDetectableObjectPtr
mrpt::slam::CDetectorDoorCrossing
mrpt::math::CDijkstra< TYPE_EDGES, MAPS_IMPLEMENTATION >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::math::CDirectedGraph< TYPE_EDGES >A directed graph with the argument of the template specifying the type of the annotations in the edges
mrpt::math::CDirectedTree< TYPE_EDGES >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::CDirectoryExplorerThis class allows the enumeration of the files/directories that exist into a given path
mrpt::opengl::CDiskA planar disk in the XY plane
mrpt::opengl::CDiskPtr
mrpt::gui::CDisplayWindowThis class creates a window as a graphical user interface (GUI) for displaying images to the user
mrpt::gui::CDisplayWindow3DA graphical user interface (GUI) for efficiently rendering 3D scenes in real-time
mrpt::gui::CDisplayWindow3DPtr
mrpt::gui::CDisplayWindowPlotsCreate a GUI window and display plots with MATLAB-like interfaces and commands
mrpt::gui::CDisplayWindowPlotsPtr
mrpt::gui::CDisplayWindowPtr
mrpt::utils::CDynamicGrid< T >A 2D grid of dynamic size which stores any kind of data at each cell
mrpt::reactivenav::CReactiveNavigationSystem::CDynamicWindowFor taken the dynamics of the robot into account
mrpt::opengl::CEllipsoidA 2D ellipse or 3D ellipsoid, depending on the size of the m_cov matrix (2x2 or 3x3)
mrpt::opengl::CEllipsoidPtr
mrpt::utils::CEnhancedMetaFileThis class represents a Windows Enhanced Meta File (EMF) for generating and saving graphics
mrpt::synch::CEventThis class provides a simple way of waiting for and signaling events (NOT IMPLEMENTED YET!)
mrpt::utils::CExceptionEOFUsed in mrpt::utils::CStream
mrpt::utils::CExceptionExternalImageNotFoundUsed in mrpt::utils::CImage
mrpt::math::CExceptionNotDefPosUsed in mrpt::math::CSparseMatrix
mrpt::detectors::CFaceDetectionSpecific class for face detection
mrpt::opengl::CFBORenderA class for rendering 3D scenes off-screen directly into an image using OpenGL extensions (glext)
mrpt::vision::CFeatureA 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::CFeatureExtractionThe central class from which images can be analyzed in search of different kinds of interest points and descriptors computed for them
mrpt::vision::CFeatureListA list of visual features, to be used as output by detectors, as input/output by trackers, etc
mrpt::vision::CFeaturePtr
mrpt::vision::CFeatureTracker_FASTTrack 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_KLTrack a set of features from old_img -> new_img using sparse optimal flow (classic KL method)
mrpt::vision::CFeatureTracker_PatchMatchTrack 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_InputStreamA 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::CFileGZInputStreamTransparently opens a compressed "gz" file and reads uncompressed data from it
mrpt::utils::CFileInputStreamThis CStream derived class allow using a file as a read-only, binary stream
mrpt::utils::CFileOutputStreamThis CStream derived class allow using a file as a write-only, binary stream
mrpt::utils::CFileStreamThis CStream derived class allow using a file as a read/write binary stream, creating it if the file didn't exist
mrpt::system::CFileSystemWatcherThis 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::CGasConcentrationGridMap2DCGasConcentrationGridMap2D represents a PDF of gas concentrations over a 2D area
mrpt::slam::TMetricMapInitializer::CGasConcentrationGridMap2DOptionsEspecific options for gas grid maps (mrpt::slam::CGasConcentrationGridMap2D)
mrpt::slam::CGasConcentrationGridMap2DPtr
mrpt::opengl::CGeneralizedCylinderThis object represents any figure obtained by extruding any profile along a given axis
mrpt::opengl::CGeneralizedCylinderPtr
mrpt::vision::CGenericFeatureTrackerA virtual interface for all feature trackers, implementing the part of feature tracking that is common to any specific tracker implementation
mrpt::hwdrivers::CGenericSensorA generic interface for a wide-variety of sensors designed to be used in the application RawLogGrabber
mrpt::hwdrivers::CGPSInterfaceA parser of NMEA commands, for connecting to a GPS by a serial port
mrpt::math::CGraphPartitionerAlgorithms for finding the min-normalized-cut of a weighted undirected graph
mrpt::slam::CGridMapAlignerA 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::CGridPlaneXYA grid of lines over the XY plane
mrpt::opengl::CGridPlaneXYPtr
mrpt::opengl::CGridPlaneXZA grid of lines over the XZ plane
mrpt::opengl::CGridPlaneXZPtr
mrpt::hwdrivers::CGyroKVHDSP3000A class for interfacing KVH DSP 3000 gyroscope with an assynchronous serial communication (product SN : 02-1222-01)
internal::check_transpose_aliasing_compile_time_selector< DestIsTransposed, OtherDerived >
internal::check_transpose_aliasing_compile_time_selector< DestIsTransposed, CwiseBinaryOp< BinOp, DerivedA, DerivedB > >
internal::check_transpose_aliasing_run_time_selector< Scalar, DestIsTransposed, OtherDerived >
internal::check_transpose_aliasing_run_time_selector< Scalar, DestIsTransposed, CwiseBinaryOp< BinOp, DerivedA, DerivedB > >
internal::checkTransposeAliasing_impl< Derived, OtherDerived, MightHaveTransposeAliasing >
internal::checkTransposeAliasing_impl< Derived, OtherDerived, false >
mrpt::slam::CHeightGridMap2DA mesh representation of a surface which keeps the estimated height for each (x,y) location
mrpt::slam::TMetricMapInitializer::CHeightGridMap2DOptionsEspecific options for height grid maps (mrpt::slam::CHeightGridMap2D)
mrpt::slam::CHeightGridMap2DPtr
mrpt::hmtslam::CHierarchicalMapMHPartitionRepresents a set of nodes and arcs, posibly only a part of the whole hierarchical, multi-hypothesis map
mrpt::hmtslam::CHierarchicalMHMapThe most high level class for storing hybrid, multi-hypothesis maps in a graph-based model
mrpt::hmtslam::CHierarchicalMHMapPtr
mrpt::math::CHistogramThis class provides an easy way of computing histograms for unidimensional real valued variables
mrpt::hmtslam::CHMHMapArcA class for representing an arc between two nodes in a hierarchical, multi-hypothesis map
mrpt::hmtslam::CHMHMapArcPtr
mrpt::hmtslam::CHMHMapNodeA class for representing a node in a hierarchical, multi-hypothesis map
mrpt::hmtslam::CHMHMapNodePtr
mrpt::hmtslam::CHMTSLAMAn implementation of Hybrid Metric Topological SLAM (HMT-SLAM)
mrpt::hmtslam::CHMTSLAMPtr
mrpt::hwdrivers::CHokuyoURGThis software driver implements the protocol SCIP-2.0 for interfacing HOKUYO URG, UTM and UXM laser scanners
mrpt::math::CSparseMatrix::CholeskyDecompAuxiliary class to hold the results of a Cholesky factorization of a sparse matrix
mrpt::reactivenav::CHolonomicLogFileRecordA base class for log records for different holonomic navigation methods
mrpt::reactivenav::CHolonomicLogFileRecordPtr
mrpt::reactivenav::CHolonomicNDAn implementation of the holonomic reactive navigation method "Nearness-Diagram"
mrpt::reactivenav::CHolonomicVFFA holonomic reactive navigation method, based on Virtual Force Fields (VFF)
mrpt::utils::ci_lessA case-insensitive comparator struct for usage within STL containers, eg: map<string,string,ci_less>
mrpt::slam::CICPSeveral implementations of ICP (Iterative closest point) algorithms for aligning two point maps
mrpt::utils::CImageA class for storing images as grayscale or RGB bitmaps
mrpt::hwdrivers::CImageGrabber_dc1394A class for grabing images from a IEEE1394 (Firewire) camera using the libdc1394-2 library
mrpt::hwdrivers::CImageGrabber_OpenCVA class for grabing images from a "OpenCV"-compatible camera, or from an AVI video file
mrpt::utils::CImagePtr
mrpt::hwdrivers::CIMUXSensA class for interfacing Inertial Measuring Units (IMUs) of the type "XSens MTi" It uses a serial port connection to the device
mrpt::slam::CIncrementalMapPartitionerThis class can be used to make partitions on a map/graph build from observations taken at some poses/nodes
mrpt::slam::CIncrementalMapPartitionerPtr
mrpt::hwdrivers::CInterfaceFTDIA definition of a CStream actually representing a USB connection to a FTDI chip
mrpt::utils::circular_buffer< T >A circular buffer of fixed size (defined at construction-time), implemented with a std::vector as the underlying storage
mrpt::hwdrivers::CJoystickAccess to joysticks and gamepads (read buttons and position), and request number of joysticks in the system
mrpt::bayes::CKalmanFilterCapable< VEH_SIZE, OBS_SIZE, FEAT_SIZE, ACT_SIZE, KFTYPE >Virtual base for Kalman Filter (EKF,IEKF,UKF) implementations
mrpt::hwdrivers::CKinectA class for grabing "range images", intensity images and other information from an Xbox Kinect sensor
mrpt::slam::CLandmarkThe class for storing "landmarks" (visual or laser-scan-extracted features,...)
mrpt::slam::CLandmarkPtr
mrpt::slam::CLandmarksMapA class for storing a map of 3D probabilistic landmarks
mrpt::slam::TMetricMapInitializer::CLandmarksMapOptionsEspecific options for landmarks maps (mrpt::slam::CLandmarksMap)
mrpt::slam::CLandmarksMapPtr
mrpt::utils::CLASSINITAuxiliary structure used for CObject-based RTTI
mrpt::hwdrivers::CGenericSensor::CLASSINIT_GENERIC_SENSORAuxiliary structure used for CSerializable runtime class ID support
mrpt::math::CLevenbergMarquardtTempl< VECTORTYPE, USERPARAM >An implementation of the Levenberg-Marquardt algorithm for least-square minimization
mrpt::utils::CListOfClassesA list (actually based on a std::set) of MRPT classes, capable of keeping any class registered by the mechanism of CSerializable classes
mrpt::hwdrivers::CLMS100EthThis "software driver" implements the communication protocol for interfacing a SICK LMS100 laser scanners through an ethernet controller
mrpt::utils::CLoadableOptionsThis is a virtual base class for sets of options than can be loaded from and/or saved to configuration plain-text files
mrpt::hmtslam::CLocalMetricHypothesisThis class is used in HMT-SLAM to represent each of the Local Metric Hypotheses (LMHs)
mrpt::hmtslam::CLocalMetricHypothesisPtr
mrpt::utils::CLogA decorator of CStringList special for keeping logs
mrpt::reactivenav::CLogFileRecordA class for storing, saving and loading a reactive navigation log record for the CReactiveNavigationSystem class
mrpt::reactivenav::CLogFileRecord_NDA class for storing extra information about the execution of CHolonomicND navigation
mrpt::reactivenav::CLogFileRecord_NDPtr
mrpt::reactivenav::CLogFileRecord_VFFA class for storing extra information about the execution of CHolonomicVFF navigation
mrpt::reactivenav::CLogFileRecord_VFFPtr
mrpt::reactivenav::CLogFileRecordPtr
stlplus::clone_copy< T >
mrpt::hmtslam::CLSLAM_RBPF_2DLASERImplements a 2D local SLAM method based on a RBPF over an occupancy grid map
mrpt::hmtslam::CLSLAMAlgorithmBaseVirtual base for local SLAM methods, used in mrpt::slam::CHMTSLAM
mrpt::hmtslam::CLSLAMParticleDataAuxiliary 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::CMappedImageThis 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::CMatchedFeatureListA list of features
mrpt::math::CMatrixThis class is a "CSerializable" wrapper for "CMatrixFloat"
mrpt::math::CMatrixBThis class is a "CSerializable" wrapper for "CMatrixBool"
mrpt::math::CMatrixBPtr
mrpt::math::CMatrixColumnAccessor< MAT >A vector-like wrapper for a Matrix for accessing the elements of a given column with a [] operator
mrpt::math::CMatrixColumnAccessorExtended< MAT >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::CMatrixDThis class is a "CSerializable" wrapper for "CMatrixTemplateNumeric<double>"
mrpt::math::CMatrixDPtr
mrpt::math::CMatrixFixedNumeric< T, NROWS, NCOLS >A numeric matrix of compile-time fixed size
mrpt::math::CMatrixPtr
mrpt::math::CMatrixRowAccessor< MAT >A vector-like wrapper for a Matrix for accessing the elements of a given row with a [] operator
mrpt::math::CMatrixRowAccessorExtended< MAT >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< T >This template class provides the basic functionality for a general 2D any-size, resizable container of numerical or non-numerical elements
mrpt::math::CMatrixTemplateNumeric< T >A matrix of dynamic size
mrpt::math::CMatrixTemplateObjects< T >This template class extends the class "CMatrixTemplate" for storing "objects" at each matrix entry
mrpt::math::CMatrixTemplateSizeAuxiliary class used in CMatrixTemplate:size(), CMatrixTemplate::resize(), CMatrixFixedNumeric::size(), CMatrixFixedNumeric::resize(), to mimic the behavior of STL-containers
TCLAP::CmdLineThe base class that manages the command line definition and passes along the parsing to the appropriate Arg classes
TCLAP::CmdLineInterfaceThe base class that manages the command line definition and passes along the parsing to the appropriate Arg classes
TCLAP::CmdLineOutputThe interface that any output object must implement
TCLAP::CmdLineParseExceptionThrown from CmdLine when the arguments on the command line are not properly specified, e.g
mrpt::utils::CMemoryChunkA memory buffer (implements CStream) which can be itself serialized
mrpt::utils::CMemoryChunkPtr
mrpt::utils::CMemoryStreamThis CStream derived class allow using a memory buffer as a CStream
mrpt::opengl::CMeshA planar (XY) grid where each cell has an associated height and, optionally, a texture map
mrpt::opengl::CMeshPtr
mrpt::utils::CMessageA class that contain generic messages, that can be sent and received from a "CClientTCPSocket" object
mrpt::slam::CMetricMapDeclares a virtual base class for all metric maps storage classes
mrpt::slam::CMetricMapBuilderThis virtual class is the base for SLAM implementations
mrpt::slam::CMetricMapBuilderICPA class for very simple 2D SLAM based on ICP
mrpt::slam::CMetricMapBuilderRBPFThis class implements a Rao-Blackwelized Particle Filter (RBPF) approach to map building (SLAM)
mrpt::slam::CMetricMapPtr
mrpt::slam::CMetricMapsAlignmentAlgorithmA base class for any algorithm able of maps alignment
mrpt::utils::CMHPropertiesValuesListAn arbitrary list of "annotations", or named attributes, each being an instance of any CSerializable object (Multi-hypotheses version)
mrpt::utils::CMHPropertiesValuesListPtr
mrpt::math::CMonteCarlo< T, NUM, OTHER >Montecarlo simulation for experiments in 1D
mrpt::slam::CMonteCarloLocalization2DDeclares a class that represents a Probability Density Function (PDF) over a 2D pose (x,y,phi), using a set of weighted samples
mrpt::slam::CMonteCarloLocalization3DDeclares 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::CMOSmodelDeclares a class within "CObservationGasSensors" that represents a set of gas concentration readings from the modelation of a MOS gas sensor readings
mrpt::utils::CMRPTExceptionThe base for MRPT-especific exceptions
mrpt::slam::CMultiMetricMapThis class stores any customizable set of metric maps
mrpt::slam::CMultiMetricMapPDFDeclares 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::poses::CNetworkOfPoses< CPOSE, MAPS_IMPLEMENTATION >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::poses::CNetworkOfPoses2DThe specialization of CNetworkOfPoses for poses of type CPose2D (not a PDF!), also implementing serialization
mrpt::poses::CNetworkOfPoses2DCovThe specialization of CNetworkOfPoses for poses of type CPosePDFGaussian, also implementing serialization
mrpt::poses::CNetworkOfPoses2DCovPtr
mrpt::poses::CNetworkOfPoses2DInfThe specialization of CNetworkOfPoses for poses of type CPosePDFGaussianInf, also implementing serialization
mrpt::poses::CNetworkOfPoses2DInfPtr
mrpt::poses::CNetworkOfPoses2DPtr
mrpt::poses::CNetworkOfPoses3DThe specialization of CNetworkOfPoses for poses of type CPose3D (not a PDF!), also implementing serialization
mrpt::poses::CNetworkOfPoses3DCovThe specialization of CNetworkOfPoses for poses of type CPose3DPDFGaussian, also implementing serialization
mrpt::poses::CNetworkOfPoses3DCovPtr
mrpt::poses::CNetworkOfPoses3DInfThe specialization of CNetworkOfPoses for poses of type CPose3DPDFGaussianInf, also implementing serialization
mrpt::poses::CNetworkOfPoses3DInfPtr
mrpt::poses::CNetworkOfPoses3DPtr
mrpt::hwdrivers::CNTRIPClientA client for NTRIP (HTTP) sources of differential GPS corrections from internet servers, or Global navigation satellite system (GNSS) internet radio
mrpt::hwdrivers::CNTRIPEmitterThis "virtual driver" encapsulates a NTRIP client (see CNTRIPClient) but adds the functionality of dumping the received datastream to a given serial port
mrpt::utils::CObjectThe virtual base class of all MRPT classes with a unified RTTI system
mrpt::detectors::CObjectDetection
mrpt::utils::CObjectPtrA smart pointer to a CObject object
mrpt::utils::CObservableInherit from this class for those objects capable of being observed by a CObserver class
mrpt::slam::CObservationDeclares a class that represents any robot's observation
mrpt::slam::CObservation2DRangeScanA "CObservation"-derived class that represents a 2D range scan measurement (typically from a laser scanner)
mrpt::slam::CObservation2DRangeScanPtr
mrpt::slam::CObservation3DRangeScanDeclares a class derived from "CObservation" that encapsules a 3D range scan measurement (e.g
mrpt::slam::CObservation3DRangeScanPtr
mrpt::slam::CObservationBatteryStateThis represents a measurement of the batteries on the robot
mrpt::slam::CObservationBatteryStatePtr
mrpt::slam::CObservationBeaconRangesDeclares a class derived from "CObservation" that represents one (or more) range measurements to labeled beacons
mrpt::slam::CObservationBeaconRangesPtr
mrpt::slam::CObservationBearingRangeThis 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::CObservationCommentThis "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::CObservationGasSensorsDeclares a class derived from "CObservation" that represents a set of readings from gas sensors
mrpt::slam::CObservationGasSensorsPtr
mrpt::slam::CObservationGPSDeclares a class derived from "CObservation" that represents a Global Positioning System (GPS) reading
mrpt::slam::CObservationGPSPtr
mrpt::slam::CObservationImageDeclares 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::CObservationIMUThis class stores measurements from an Inertial Measurement Unit (IMU), and/or its attitude estimation (integration of raw measurements)
mrpt::slam::CObservationIMUPtr
mrpt::slam::CObservationOdometryAn observation of the current (cumulative) odometry for a wheeled robot
mrpt::slam::CObservationOdometryPtr
mrpt::slam::CObservationPtr
mrpt::slam::CObservationRangeDeclares a class derived from "CObservation" that encapsules a single range measurement, and associated parameters
mrpt::slam::CObservationRangePtr
mrpt::slam::CObservationStereoImagesObservation class for either a pair of left+right or left+disparity images from a stereo camera
mrpt::slam::CObservationStereoImagesFeaturesDeclares 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::CObservationVisualLandmarksDeclares 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::utils::CObserverInherit from this class to get notified about events from any CObservable object after subscribing to it
mrpt::slam::COccupancyGridMap2DA class for storing an occupancy grid map
mrpt::slam::COccupancyGridMap2DPtr
mrpt::slam::COccupancyGridMapFeatureExtractorA class for detecting features from occupancy grid maps
mrpt::opengl::COctreePointRenderer< Derived >Template class that implements the data structure and algorithms for Octree-based efficient rendering
internal::coeff_visitor< Derived >
CoeffBasedProduct< LhsNested, RhsNested, NestingFlags >
ColPivHouseholderQR< _MatrixType >Householder rank-revealing QR decomposition of a matrix with column-pivoting
Eigen::ColPivHouseholderQR< _MatrixType >Householder rank-revealing QR decomposition of a matrix with column-pivoting
CommaInitializer< XprType >Helper class used by the comma initializer operator
internal::complex_schur_reduce_to_hessenberg< MatrixType, IsComplex >
Eigen::internal::complex_schur_reduce_to_hessenberg< MatrixType, IsComplex >
internal::complex_schur_reduce_to_hessenberg< MatrixType, false >
Eigen::internal::complex_schur_reduce_to_hessenberg< MatrixType, false >
ComplexEigenSolver< _MatrixType >
Eigen::ComplexEigenSolver< _MatrixType >
ComplexSchur< _MatrixType >
Eigen::ComplexSchur< _MatrixType >
CompressedStorage< _Scalar, _Index >Stores a sparse set of values as a list of values and a list of indices
internal::compute_inverse< MatrixType, ResultType, Size >
internal::compute_inverse< MatrixType, ResultType, 1 >
internal::compute_inverse< MatrixType, ResultType, 2 >
internal::compute_inverse< MatrixType, ResultType, 3 >
internal::compute_inverse< MatrixType, ResultType, 4 >
internal::compute_inverse_and_det_with_check< MatrixType, ResultType, Size >
internal::compute_inverse_and_det_with_check< MatrixType, ResultType, 1 >
internal::compute_inverse_and_det_with_check< MatrixType, ResultType, 2 >
internal::compute_inverse_and_det_with_check< MatrixType, ResultType, 3 >
internal::compute_inverse_and_det_with_check< MatrixType, ResultType, 4 >
internal::compute_inverse_size4< Arch, Scalar, MatrixType, ResultType >
internal::compute_inverse_size4< Architecture::SSE, double, MatrixType, ResultType >
internal::compute_inverse_size4< Architecture::SSE, float, MatrixType, ResultType >
internal::compute_matrix_flags< Scalar, Rows, Cols, Options, MaxRows, MaxCols >
internal::conditional< Condition, Then, Else >
internal::conditional< false, Then, Else >
internal::conj_expr_if< Cond, T >
internal::conj_helper< Packet1cd, Packet1cd, false, true >
internal::conj_helper< Packet1cd, Packet1cd, true, false >
internal::conj_helper< Packet1cd, Packet1cd, true, true >
internal::conj_helper< Packet1cd, Packet2d, false, false >
internal::conj_helper< Packet2cf, Packet2cf, false, true >
internal::conj_helper< Packet2cf, Packet2cf, true, false >
internal::conj_helper< Packet2cf, Packet2cf, true, true >
internal::conj_helper< Packet2cf, Packet4f, false, false >
internal::conj_helper< Packet2d, Packet1cd, false, false >
internal::conj_helper< Packet4f, Packet2cf, false, false >
internal::conj_helper< RealScalar, std::complex< RealScalar >, false, Conj >
internal::conj_helper< Scalar, Scalar, false, false >
internal::conj_helper< std::complex< RealScalar >, RealScalar, Conj, false >
internal::conj_helper< std::complex< RealScalar >, std::complex< RealScalar >, false, true >
internal::conj_helper< std::complex< RealScalar >, std::complex< RealScalar >, true, false >
internal::conj_helper< std::complex< RealScalar >, std::complex< RealScalar >, true, true >
internal::conj_if< false >
internal::conj_if< true >
internal::conj_impl< Scalar >
internal::conj_impl< std::complex< RealScalar > >
internal::conj_retval< Scalar >
internal::conservative_resize_like_impl< Derived, OtherDerived, IsVector >
internal::conservative_resize_like_impl< Derived, OtherDerived, true >
internal::const_blas_data_mapper< Scalar, Index, StorageOrder >
mrpt::slam::CRawlog::const_iteratorA normal iterator, plus the extra method "getType" to determine the type of each entry in the sequence
mrpt::poses::CPose3DQuat::const_iterator
MatrixBase< Derived >::ConstDiagonalIndexReturnType< Index >
DenseBase< Derived >::ConstFixedSegmentReturnType< Size >
TCLAP::Constraint< T >The interface that defines the interaction between the Arg and Constraint
stlplus::constructor_copy< T >
internal::constructor_without_unaligned_array_assert
MatrixBase< Derived >::ConstSelfAdjointViewReturnType< UpLo >
MatrixBase< Derived >::ConstTriangularViewReturnType< Mode >
mrpt::opengl::COpenGLSceneThis class allows the user to create, load, save, and render 3D scenes using OpenGL primitives
mrpt::opengl::COpenGLScenePtr
mrpt::opengl::COpenGLStandardObjectObjects of this class represent a generic openGL object without specific geometric properties
mrpt::opengl::COpenGLStandardObjectPtr
mrpt::opengl::COpenGLViewportA viewport within a COpenGLScene, containing a set of OpenGL objects to render
mrpt::opengl::COpenGLViewportPtr
mrpt::utils::copiable_NULL_ptr< T >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< T >A wrapper class for pointers that, if copied with the "=" operator, should be set to NULL in the copy
internal::cos_default_impl< Scalar, IsInteger >
internal::cos_default_impl< Scalar, true >
internal::cos_impl< Scalar >
internal::cos_retval< Scalar >
internal::member_redux< BinaryOp, Scalar >::Cost< _Scalar, Size >
mrpt::reactivenav::CParameterizedTrajectoryGeneratorThis is the base class for any user defined PTG
mrpt::bayes::CParticleFilterThis 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::CParticleFilterCapableThis 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< T >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::CPathPlanningCircularRobotAn implementation of CPathPlanningMethod
mrpt::slam::CPathPlanningMethodA 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::CPlanarLaserScanThis 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< DERIVEDCLASS >A base class for representing a point in 2D or 3D
mrpt::poses::CPoint2DA class used to store a 2D point
mrpt::poses::CPoint2DPDFDeclares a class that represents a Probability Distribution function (PDF) of a 2D point (x,y)
mrpt::poses::CPoint2DPDFGaussianA gaussian distribution for 2D points
mrpt::poses::CPoint2DPDFGaussianPtr
mrpt::poses::CPoint2DPDFPtr
mrpt::poses::CPoint2DPtr
mrpt::poses::CPoint3DA class used to store a 3D point
mrpt::poses::CPoint3DPtr
mrpt::opengl::CPointCloudA cloud of points, all with the same color or each depending on its value along a particular coordinate axis
mrpt::opengl::CPointCloudColouredA cloud of points, each one with an individual colour (R,G,B)
mrpt::opengl::CPointCloudColouredPtr
mrpt::opengl::CPointCloudPtr
mrpt::poses::CPointPDFDeclares a class that represents a Probability Distribution function (PDF) of a 3D point (x,y,z)
mrpt::poses::CPointPDFGaussianA gaussian distribution for 3D points
mrpt::poses::CPointPDFGaussianPtr
mrpt::poses::CPointPDFParticlesA probability distribution of a 2D/3D point, represented as a set of random samples (particles)
mrpt::poses::CPointPDFParticlesPtr
mrpt::poses::CPointPDFPtr
mrpt::poses::CPointPDFSOGDeclares a class that represents a Probability Density function (PDF) of a 3D point $ p(\mathbf{x}) = [x ~ y ~ z ]^t $
mrpt::poses::CPointPDFSOGPtr
mrpt::slam::CPointsMapA cloud of points in 2D or 3D, which can be built from a sequence of laser scans or other sensors
mrpt::slam::TMetricMapInitializer::CPointsMapOptionsEspecific options for points maps (mrpt::slam::CPointsMap)
mrpt::slam::CPointsMapPtr
mrpt::math::CPolygonA wrapper of a TPolygon2D class, implementing CSerializable
mrpt::math::CPolygonPtr
mrpt::opengl::CPolyhedronThis class represents arbitrary polyhedra
mrpt::opengl::CPolyhedronPtr
mrpt::poses::CPose< DERIVEDCLASS >A base class for representing a pose in 2D or 3D
mrpt::poses::CPose2DA class used to store a 2D pose
mrpt::poses::CPose2DGridTemplate< T >This is a template class for storing a 3D (2D+heading) grid containing any kind of data
mrpt::poses::CPose2DPtr
mrpt::poses::CPose3DA class used to store a 3D pose (a 3D translation + a rotation in 3D)
mrpt::poses::CPose3DInterpolatorA 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::CPose3DPDFDeclares a class that represents a Probability Density Function (PDF) of a 3D pose (6D actually)
mrpt::poses::CPose3DPDFGaussianDeclares a class that represents a Probability Density function (PDF) of a 3D pose $ p(\mathbf{x}) = [x ~ y ~ z ~ yaw ~ pitch ~ roll]^t $
mrpt::poses::CPose3DPDFGaussianInfDeclares a class that represents a Probability Density function (PDF) of a 3D pose $ p(\mathbf{x}) = [x ~ y ~ z ~ yaw ~ pitch ~ roll]^t $ as a Gaussian described by its mean and its inverse covariance matrix
mrpt::poses::CPose3DPDFGaussianInfPtr
mrpt::poses::CPose3DPDFGaussianPtr
mrpt::poses::CPose3DPDFParticlesDeclares a class that represents a Probability Density function (PDF) of a 3D pose
mrpt::poses::CPose3DPDFParticlesPtr
mrpt::poses::CPose3DPDFPtr
mrpt::poses::CPose3DPDFSOGDeclares a class that represents a Probability Density function (PDF) of a 3D(6D) pose $ p(\mathbf{x}) = [x ~ y ~ z ~ yaw ~ pitch ~ roll]^t $
mrpt::poses::CPose3DPDFSOGPtr
mrpt::poses::CPose3DPtr
mrpt::poses::CPose3DQuatA class used to store a 3D pose as a translation (x,y,z) and a quaternion (qr,qx,qy,qz)
mrpt::poses::CPose3DQuatPDFDeclares 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::CPose3DQuatPDFGaussianDeclares 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 $
mrpt::poses::CPose3DQuatPDFGaussianPtr
mrpt::poses::CPose3DQuatPDFPtr
mrpt::poses::CPose3DQuatPtr
mrpt::poses::CPoseOrPoint< DERIVEDCLASS >The base template class for 2D & 3D points and poses
mrpt::poses::CPosePDFDeclares a class that represents a probability density function (pdf) of a 2D pose (x,y,phi)
mrpt::poses::CPosePDFGaussianDeclares a class that represents a Probability Density function (PDF) of a 2D pose $ p(\mathbf{x}) = [x ~ y ~ \phi ]^t $
mrpt::poses::CPosePDFGaussianInfA Probability Density function (PDF) of a 2D pose $ p(\mathbf{x}) = [x ~ y ~ \phi ]^t $ as a Gaussian with a mean and the inverse of the covariance
mrpt::poses::CPosePDFGaussianInfPtr
mrpt::poses::CPosePDFGaussianPtr
mrpt::poses::CPosePDFGridDeclares a class that represents a Probability Distribution function (PDF) of a 2D pose (x,y,phi)
mrpt::poses::CPosePDFGridPtr
mrpt::poses::CPosePDFParticlesDeclares 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::CPosePDFSOGDeclares a class that represents a Probability Density function (PDF) of a 2D pose $ p(\mathbf{x}) = [x ~ y ~ \phi ]^t $
mrpt::poses::CPosePDFSOGPtr
mrpt::poses::CPoseRandomSamplerAn efficient generator of random samples drawn from a given 2D (CPosePDF) or 3D (CPose3DPDF) pose probability density function (pdf)
mrpt::poses::CPoses2DSequenceThis class stores a sequence of relative, incremental 2D poses
mrpt::poses::CPoses2DSequencePtr
mrpt::poses::CPoses3DSequenceThis class stores a sequence of relative, incremental 3D poses
mrpt::poses::CPoses3DSequencePtr
mrpt::utils::CProbabilityDensityFunction< TDATA, STATE_LEN >A generic template for probability density distributions (PDFs)
mrpt::bayes::CProbabilityParticle< T >A template class for holding a the data and the weight of a particle
mrpt::utils::CProfilerProxy
mrpt::utils::CPropertiesValuesListAn arbitrary list of "annotations", or named attributes, each being an instance of any CSerializable object
mrpt::utils::CPropertiesValuesListPtr
mrpt::reactivenav::CPRRTNavigatorThis class is a multi-threaded mobile robot navigator, implementing an (anytime) PTG-based Rapidly-exploring Random Tree (PRRT) search algorithm
mrpt::reactivenav::CPTG1A PTG for circular paths
mrpt::reactivenav::CPTG2The alpha-PTG
mrpt::reactivenav::CPTG3A PTG for optimal paths of type "C|C,S"
mrpt::reactivenav::CPTG4A PTG for optimal paths of type "C|C"
mrpt::reactivenav::CPTG5A PTG for optimal paths of type "C|C,S"
mrpt::reactivenav::CPTG6A PTG for circular paths
mrpt::reactivenav::CPTG7A PTG for circular paths
mrpt::hwdrivers::CPtuBaseThis class implements initialization and comunication methods to control a generic Pan and Tilt Unit, working in radians
mrpt::hwdrivers::CPtuDPerceptionThis 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< T >A quaternion, which can represent a 3D rotation as pair $ (r,\mathbf{u}) $, with a real part "r" and a 3D vector $ \mathbf{u} = (x,y,z) $, or alternatively, q = r + ix + jy + kz
mrpt::random::CRandomGeneratorA thred-safe pseudo random number generator, based on an internal MT19937 randomness generator
mrpt::slam::CRangeBearingKFSLAMAn implementation of EKF-based SLAM with range-bearing sensors, odometry, a full 6D robot pose, and 3D landmarks
mrpt::slam::CRangeBearingKFSLAM2DAn implementation of EKF-based SLAM with range-bearing sensors, odometry, and a 2D (+heading) robot pose, and 2D landmarks
mrpt::slam::CRawlogThis class stores a rawlog (robotic datasets) in one of two possible formats:

  • Format #1: A sequence of actions and observations
mrpt::slam::CRawlogPtr
mrpt::slam::CRBPFParticleDataAuxiliary class used in mrpt::slam::CMultiMetricMapPDF
mrpt::slam::CRBPFParticleDataPtr
mrpt::reactivenav::CReactiveInterfaceImplementationThe 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::CReactiveNavigationSystemImplements 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::CReferencedMemBlockRepresents a memory block (via "void*") that can be shared between several objects through copy operator (=)
mrpt::bayes::CRejectionSamplingCapable< TStateSpace >A base class for implementing rejection sampling in a generic state space
mrpt::slam::CRejectionSamplingRangeOnlyLocalizationAn implementation of rejection sampling for generating 2D robot pose from range-only measurements within a landmarks (beacons) map
mrpt::opengl::CRenderizableThe base class of 3D objects that can be directly rendered through OpenGL
mrpt::opengl::CRenderizableDisplayListA renderizable object suitable for rendering with OpenGL's display lists
mrpt::opengl::CRenderizableDisplayListPtr
mrpt::opengl::CRenderizablePtr
mrpt::poses::CRobot2DPoseEstimatorA simple filter to estimate and extrapolate the robot 2D (x,y,phi) pose from asynchronous odometry and localization data
mrpt::hwdrivers::CRoboticHeadInterfaceThis "software driver" implements the communication protocol for interfacing a Robotic Head Board through a custom USB RS-422 interface board
mrpt::hmtslam::CRobotPosesGraphAuxiliary 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::CRobotSimulatorThis class can be used to simulate the kinematics and dynamics of a differential driven planar mobile robot, including odometry errors and dynamics limitations
internal::cross3_impl< Arch, VectorLhs, VectorRhs, Scalar, Vectorizable >
internal::cross3_impl< Architecture::SSE, VectorLhs, VectorRhs, float, true >
mrpt::hwdrivers::CRovioA 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::CSemaphoreA semaphore for inter-thread synchronization
mrpt::slam::CSensoryFrameDeclares 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::CSerializableThe virtual base class which provides a unified interface for all persistent objects in MRPT
mrpt::utils::CSerializablePtr
mrpt::hwdrivers::CSerialPortA communications serial port built as an implementation of a utils::CStream
mrpt::utils::CServerTCPSocketA TCP socket that can be wait for client connections to enter
mrpt::hwdrivers::CServoeNeck
mrpt::opengl::CSetOfLinesA set of independent lines (or segments), one line with its own start and end positions (X,Y,Z)
mrpt::opengl::CSetOfLinesPtr
mrpt::opengl::CSetOfObjectsA set of object, which are referenced to the coordinates framework established in this object
mrpt::opengl::CSetOfObjectsPtr
mrpt::opengl::CSetOfTexturedTrianglesA set of textured triangles
mrpt::opengl::CSetOfTexturedTrianglesPtr
mrpt::opengl::CSetOfTrianglesA set of colored triangles
mrpt::opengl::CSetOfTrianglesPtr
mrpt::hwdrivers::CSickLaserSerialThis "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::CSickLaserUSBThis "software driver" implements the communication protocol for interfacing a SICK LMS2XX laser scanners through a custom USB RS-422 interface board
mrpt::utils::CSimpleDatabaseThis class impements a very simple database system
mrpt::utils::CSimpleDatabasePtr
mrpt::utils::CSimpleDatabaseTableThis class implements the tables of databases
mrpt::utils::CSimpleDatabaseTablePtr
mrpt::opengl::CSimpleLineA line segment
mrpt::opengl::CSimpleLinePtr
mrpt::slam::CSimpleMapThis 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::CSimplePointsMapA cloud of points in 2D or 3D, which can be built from a sequence of laser scans
mrpt::slam::CSimplePointsMapPtr
mrpt::math::CSparseMatrixA sparse matrix capable of efficient math operations (a wrapper around the CSparse library) The type of cells is fixed to "double"
mrpt::math::CSparseMatrixTemplate< T >A sparse matrix container (with cells of any type), with iterators
mrpt::math::CSparseSymmetricalMatrix< T >A sparse matrix container for square symmetrical content around the main diagonal
mrpt::opengl::CSphereA solid or wire-frame sphere
mrpt::opengl::CSpherePtr
mrpt::math::CSplineInterpolator1DA (persistent) sequence of (x,y) coordinates, allowing queries of intermediate points through spline interpolation, where possible
mrpt::math::CSplineInterpolator1DPtr
mrpt::utils::CStartUpClassesRegisterA 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< T, NUM, OTHER >::CStatisticalAnalyzer
mrpt::utils::CStdOutStreamThis CStdOutStream derived class allow printing to standard out, normally the console text output
mrpt::hwdrivers::CStereoGrabber_BumblebeeA class for grabing stereo images from a "Bumblebee" or "Bumblebee2" camera NOTE:

  • Windows:
    • This class is only available when compiling MRPT with "MRPT_HAS_BUMBLEBEE"
mrpt::hwdrivers::CStereoGrabber_SVSA class for grabing stereo images from a STOC camera of Videre Design NOTE:

  • Windows:
    • This class is not available
mrpt::utils::CStreamThis base class is used to provide a unified interface to files,memory buffers,..Please see the derived classes
mrpt::utils::CStringListA class for storing a list of text lines
mrpt::utils::CStringListPtr
mrpt::hwdrivers::CSwissRanger3DCameraA class for grabing "range images" from a MESA imaging SwissRanger 3D cameras (SR-2, SR-3000, SR-4k)
mrpt::opengl::CTextA 2D text (bitmap rendering): it always "faces the observer" despite it's at some 3D location
mrpt::utils::CTextFileLinesParserA class for parsing text files, returning each non-empty and non-comment line, along its line number
mrpt::opengl::CTextPtr
mrpt::opengl::CTexturedObjectA base class for all OpenGL objects with loadable textures
mrpt::opengl::CTexturedObjectPtr
mrpt::opengl::CTexturedPlaneA 2D plane in the XY plane with a texture image
mrpt::opengl::CTexturedPlanePtr
mrpt::utils::CThreadSafeQueue< T >A thread-safe template queue for object passing between threads, with objects being passed being "T*"
mrpt::synch::CThreadSafeVariable< T >A template for created thread-safe variables with an internal critical section controlled each read or write
mrpt::utils::CTicTacThis class implements a high-performance stopwatch
mrpt::utils::CTimeLoggerA 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::CTopLCDetectorBaseThe virtual base class for Topological Loop-closure Detectors; used in HMT-SLAM
mrpt::hwdrivers::CTuMicosThis class implements initialization and comunication methods to control a Tilt Unit model DT-80, working in radians
mrpt::utils::CTypeSelectorThis class represents a std::string derived class which is also CSerializable
mrpt::utils::CTypeSelectorPtr
mrpt::utils::CUncopiableThe base class of classes that cannot be copied: compile-time errors will be issued on any copy operation
mrpt::vision::CUndistortMapUse this class to undistort images if the same distortion map is used over and over again
mrpt::vision::CVideoFileWriterAn output stream which takes a sequence of images and writes a video file in any of a given of compatible formats
Cwise< ExpressionType >Pseudo expression providing additional coefficient-wise operations
CwiseBinaryOp< BinaryOp, Lhs, Rhs >Generic expression where a coefficient-wise binary operator is applied to two expressions
CwiseBinaryOpImpl< BinaryOp, Lhs, Rhs, Dense >
CwiseBinaryOpImpl< BinaryOp, Lhs, Rhs, Sparse >
CwiseNullaryOp< NullaryOp, PlainObjectType >Generic expression of a matrix where all coefficients are defined by a functor
CwiseUnaryOp< UnaryOp, XprType >Generic expression where a coefficient-wise unary operator is applied to an expression
CwiseUnaryOpImpl< UnaryOp, MatrixType, Sparse >
CwiseUnaryOpImpl< UnaryOp, XprType, Dense >
CwiseUnaryView< ViewOp, MatrixType >Generic lvalue expression of a coefficient-wise unary operator of a matrix or a vector
CwiseUnaryViewImpl< ViewOp, MatrixType, Dense >
CwiseUnaryViewImpl< ViewOp, MatrixType, Sparse >
internal::decrement_size< n >
internal::default_packet_traits
SparseMatrix< _Scalar, _Options, _Index >::default_prunning_func
Default_t
DenseThe type used to identify a dense storage
internal::dense_xpr_base< Derived, XprKind >
internal::dense_xpr_base< Derived, ArrayXpr >
internal::dense_xpr_base< Derived, MatrixXpr >
DenseBase< Derived >Base class for all dense matrices, vectors, and arrays
DenseCoeffsBase
DenseCoeffsBase< Derived, DirectAccessors >Base class providing direct read-only coefficient access to matrices and arrays
DenseCoeffsBase< Derived, DirectWriteAccessors >Base class providing direct read/write coefficient access to matrices and arrays
DenseCoeffsBase< Derived, ReadOnlyAccessors >Base class providing read-only coefficient access to matrices and arrays
DenseCoeffsBase< Derived, WriteAccessors >Base class providing read/write coefficient access to matrices and arrays
DenseSparseProductReturnType< Lhs, Rhs, InnerSize >
DenseSparseProductReturnType< Lhs, Rhs, 1 >
DenseStorage< T, Size, _Rows, _Cols, _Options >
DenseStorage< T, 0, _Rows, _Cols, _Options >
DenseStorage< T, Dynamic, _Rows, Dynamic, _Options >
DenseStorage< T, Dynamic, Dynamic, _Cols, _Options >
DenseStorage< T, Dynamic, Dynamic, Dynamic, _Options >
DenseStorage< T, Size, _Rows, Dynamic, _Options >
DenseStorage< T, Size, Dynamic, _Cols, _Options >
DenseStorage< T, Size, Dynamic, Dynamic, _Options >
DenseTimeSparseProduct< Lhs, Rhs >
DenseTimeSparseSelfAdjointProduct< Lhs, Rhs, UpLo >
std::deque< T, EIGEN_ALIGNED_ALLOCATOR< T > >
internal::determinant_impl< Derived, DeterminantType >
internal::determinant_impl< Derived, 1 >
internal::determinant_impl< Derived, 2 >
internal::determinant_impl< Derived, 3 >
internal::determinant_impl< Derived, 4 >
Diagonal< MatrixType, DiagIndex >Expression of a diagonal/subdiagonal/superdiagonal in a matrix
MatrixBase< Derived >::DiagonalIndexReturnType< Index >
internal::BandMatrix< _Scalar, Rows, Cols, Supers, Subs, Options >::DiagonalIntReturnType< Index >
DiagonalMatrix< _Scalar, SizeAtCompileTime, MaxSizeAtCompileTime >Represents a diagonal matrix with its storage
DiagonalProduct< MatrixType, DiagonalType, ProductOrder >
DiagonalWrapper< _DiagonalVectorType >Expression of a diagonal matrix
TCLAP::DocBookOutputA class that generates DocBook output for usage() method for the given CmdLine and its Args
internal::dot_nocheck< T, U, NeedToTranspose >
internal::dot_nocheck< T, U, true >
internal::gebp_traits< std::complex< RealScalar >, std::complex< RealScalar >, _ConjLhs, _ConjRhs >::DoublePacket
mrpt::dynamicsize_vector< T >The base class of MRPT vectors, actually, Eigen column matrices of dynamic size with specialized constructors that resemble std::vector
DynamicSparseMatrix< _Scalar, _Options, _Index >A sparse matrix class designed for matrix assembly purpose
EigenBase< Derived >Common base class for all classes T such that MatrixBase has an operator=(T) and a constructor MatrixBase(T)
EigenSolver< _MatrixType >
Eigen::EigenSolver< _MatrixType >
internal::eigenvalues_selector< Derived, IsComplex >
Eigen::internal::eigenvalues_selector< Derived, IsComplex >
internal::eigenvalues_selector< Derived, false >
Eigen::internal::eigenvalues_selector< Derived, false >
internal::enable_if< true, T >
stlplus::end_dereference
internal::eval< Array< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols >, Dense >
internal::eval< Matrix< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols >, Dense >
internal::eval< T, Dense >
internal::eval< T, Sparse >
internal::exp_default_impl< Scalar, IsInteger >
internal::exp_default_impl< Scalar, true >
internal::exp_impl< Scalar >
internal::exp_retval< Scalar >
VectorwiseOp< ExpressionType, Direction >::ExtendedType< OtherDerived >
internal::extract_data_selector< T, HasUsableDirectAccess >
internal::extract_data_selector< T, false >
internal::false_type
internal::first_aligned_impl< Derived, JustReturnZero >
internal::first_aligned_impl< Derived, false >
DenseBase< Derived >::FixedSegmentReturnType< Size >
Flagged< ExpressionType, Added, Removed >Expression with modified flags
ForceAlignedAccess< ExpressionType >Enforce aligned packet loads and stores regardless of what is requested
mrpt::opengl::CAngularObservationMesh::FTrace1D< T >Internal functor class to trace a ray
mrpt::opengl::CAngularObservationMesh::FTrace2D< T >Internal functor class to trace a set of rays
FullPivHouseholderQR< _MatrixType >Householder rank-revealing QR decomposition of a matrix with full pivoting
Eigen::FullPivHouseholderQR< _MatrixType >Householder rank-revealing QR decomposition of a matrix with full pivoting
FullPivLU< _MatrixType >LU decomposition of a matrix with complete pivoting, and related features
internal::functor_allows_mixing_real_and_complex< Functor >
internal::functor_allows_mixing_real_and_complex< scalar_product_op< LhsScalar, RhsScalar > >
internal::functor_has_linear_access< Functor >
internal::functor_has_linear_access< scalar_identity_op< Scalar > >
internal::functor_traits< T >
internal::functor_traits< linspaced_op< Scalar, RandomAccess > >
internal::functor_traits< max_coeff_visitor< Scalar > >
internal::functor_traits< min_coeff_visitor< Scalar > >
internal::functor_traits< scalar_abs2_op< Scalar > >
internal::functor_traits< scalar_abs_op< Scalar > >
internal::functor_traits< scalar_add_op< Scalar > >
internal::functor_traits< scalar_cast_op< Scalar, NewType > >
internal::functor_traits< scalar_conj_product_op< Scalar > >
internal::functor_traits< scalar_conjugate_op< Scalar > >
internal::functor_traits< scalar_constant_op< Scalar > >
internal::functor_traits< scalar_cos_op< Scalar > >
internal::functor_traits< scalar_cube_op< Scalar > >
internal::functor_traits< scalar_difference_op< Scalar > >
internal::functor_traits< scalar_exp_op< Scalar > >
internal::functor_traits< scalar_hypot_op< Scalar > >
internal::functor_traits< scalar_identity_op< Scalar > >
internal::functor_traits< scalar_imag_op< Scalar > >
internal::functor_traits< scalar_imag_ref_op< Scalar > >
internal::functor_traits< scalar_inverse_op< Scalar > >
internal::functor_traits< scalar_log_op< Scalar > >
internal::functor_traits< scalar_max_op< Scalar > >
internal::functor_traits< scalar_min_op< Scalar > >
internal::functor_traits< scalar_multiple2_op< Scalar1, Scalar2 > >
internal::functor_traits< scalar_multiple_op< Scalar > >
internal::functor_traits< scalar_opposite_op< Scalar > >
internal::functor_traits< scalar_pow_op< Scalar > >
internal::functor_traits< scalar_product_op< LhsScalar, RhsScalar > >
internal::functor_traits< scalar_quotient1_impl< Scalar, false > >
internal::functor_traits< scalar_quotient1_impl< Scalar, true > >
internal::functor_traits< scalar_quotient1_op< Scalar > >
internal::functor_traits< scalar_quotient_op< Scalar > >
internal::functor_traits< scalar_random_op< Scalar > >
internal::functor_traits< scalar_real_op< Scalar > >
internal::functor_traits< scalar_real_ref_op< Scalar > >
internal::functor_traits< scalar_sin_op< Scalar > >
internal::functor_traits< scalar_sqrt_op< Scalar > >
internal::functor_traits< scalar_square_op< Scalar > >
internal::functor_traits< scalar_sum_op< Scalar > >
internal::functor_traits< std::binary_negate< T > >
internal::functor_traits< std::binder1st< T > >
internal::functor_traits< std::binder2nd< T > >
internal::functor_traits< std::divides< T > >
internal::functor_traits< std::equal_to< T > >
internal::functor_traits< std::greater< T > >
internal::functor_traits< std::greater_equal< T > >
internal::functor_traits< std::less< T > >
internal::functor_traits< std::less_equal< T > >
internal::functor_traits< std::logical_and< T > >
internal::functor_traits< std::logical_not< T > >
internal::functor_traits< std::logical_or< T > >
internal::functor_traits< std::minus< T > >
internal::functor_traits< std::multiplies< T > >
internal::functor_traits< std::negate< T > >
internal::functor_traits< std::not_equal_to< T > >
internal::functor_traits< std::plus< T > >
internal::functor_traits< std::unary_negate< T > >
internal::gebp_kernel< LhsScalar, RhsScalar, Index, mr, nr, ConjugateLhs, ConjugateRhs >
internal::gebp_madd_selector< CJ, A, B, C, T >
internal::gebp_madd_selector< CJ, T, T, T, T >
internal::gebp_traits< _LhsScalar, _RhsScalar, _ConjLhs, _ConjRhs >
internal::gebp_traits< RealScalar, std::complex< RealScalar >, false, _ConjRhs >
internal::gebp_traits< std::complex< RealScalar >, RealScalar, _ConjLhs, false >
internal::gebp_traits< std::complex< RealScalar >, std::complex< RealScalar >, _ConjLhs, _ConjRhs >
internal::gemm_blocking_space< StorageOrder, _LhsScalar, _RhsScalar, MaxRows, MaxCols, MaxDepth, false >
internal::gemm_blocking_space< StorageOrder, _LhsScalar, _RhsScalar, MaxRows, MaxCols, MaxDepth, true >
internal::gemm_functor< Scalar, Index, Gemm, Lhs, Rhs, Dest, BlockingType >
internal::gemm_pack_lhs< Scalar, Index, Pack1, Pack2, StorageOrder, Conjugate, PanelMode >
internal::gemm_pack_rhs< Scalar, Index, nr, ColMajor, Conjugate, PanelMode >
internal::gemm_pack_rhs< Scalar, Index, nr, RowMajor, Conjugate, PanelMode >
internal::GemmParallelInfo< Index >
internal::gemv_selector< OnTheLeft, StorageOrder, BlasCompatible >
internal::gemv_selector< OnTheRight, ColMajor, false >
internal::gemv_selector< OnTheRight, ColMajor, true >
internal::gemv_selector< OnTheRight, RowMajor, false >
internal::gemv_selector< OnTheRight, RowMajor, true >
internal::general_matrix_matrix_product< Index, LhsScalar, LhsStorageOrder, ConjugateLhs, RhsScalar, RhsStorageOrder, ConjugateRhs, ColMajor >
internal::general_matrix_matrix_product< Index, LhsScalar, LhsStorageOrder, ConjugateLhs, RhsScalar, RhsStorageOrder, ConjugateRhs, RowMajor >
internal::general_matrix_matrix_triangular_product< Index, LhsScalar, LhsStorageOrder, ConjugateLhs, RhsScalar, RhsStorageOrder, ConjugateRhs, ColMajor, UpLo >
internal::general_matrix_matrix_triangular_product< Index, LhsScalar, LhsStorageOrder, ConjugateLhs, RhsScalar, RhsStorageOrder, ConjugateRhs, RowMajor, UpLo >
internal::general_matrix_vector_product< Index, LhsScalar, ColMajor, ConjugateLhs, RhsScalar, ConjugateRhs >
internal::general_matrix_vector_product< Index, LhsScalar, RowMajor, ConjugateLhs, RhsScalar, ConjugateRhs >
GeneralizedSelfAdjointEigenSolver< _MatrixType >
Eigen::GeneralizedSelfAdjointEigenSolver< _MatrixType >
GeneralProductExpression of the product of two general matrices or vectors
GeneralProduct< Lhs, Rhs, GemmProduct >
GeneralProduct< Lhs, Rhs, GemvProduct >
GeneralProduct< Lhs, Rhs, InnerProduct >
GeneralProduct< Lhs, Rhs, OuterProduct >
GenericNumTraits< T >
internal::get_factor< From, To >
internal::get_factor< Scalar, typename NumTraits< Scalar >::Real >
internal::global_math_functions_filtering_base< T, dummy >
internal::global_math_functions_filtering_base< T, typename always_void< typename T::Eigen_BaseClassForSpecializationOfGlobalMathFuncImpl >::type >
mrpt::graphslam::graphslam_traits< EDGE_TYPE, MAPS_IMPLEMENTATION >Auxiliary traits template for use among graph-slam problems to make life easier with these complicated, long data type names
internal::has_direct_access< Derived >
internal::has_none
internal::has_std_result_type
internal::has_tr1_result
TCLAP::HelpVisitorA Visitor object that calls the usage method of the given CmdLineOutput object for the specified CmdLine object
HessenbergDecomposition< _MatrixType >
Eigen::HessenbergDecomposition< _MatrixType >
internal::HessenbergDecompositionMatrixHReturnType< MatrixType >
Eigen::internal::HessenbergDecompositionMatrixHReturnType< MatrixType >
Homogeneous< MatrixType, _Direction >
internal::homogeneous_left_product_impl< Homogeneous< MatrixType, Vertical >, Lhs >
internal::homogeneous_right_product_impl< Homogeneous< MatrixType, Horizontal >, Rhs >
HouseholderQR< _MatrixType >Householder QR decomposition of a matrix
Eigen::HouseholderQR< _MatrixType >Householder QR decomposition of a matrix
HouseholderSequence< VectorsType, CoeffsType, Side >
internal::hseq_side_dependent_impl< VectorsType, CoeffsType, Side >
internal::hseq_side_dependent_impl< VectorsType, CoeffsType, OnTheRight >
Hyperplane< _Scalar, _AmbientDim >
internal::hypot_impl< Scalar >
internal::hypot_retval< Scalar >
TCLAP::IgnoreRestVisitorA Vistor that tells the CmdLine to begin ignoring arguments after this one is parsed
stlplus::illegal_copy
internal::imag_impl< Scalar >
internal::imag_impl< std::complex< RealScalar > >
internal::imag_ref_default_impl< Scalar, IsComplex >
internal::imag_ref_default_impl< Scalar, false >
internal::imag_ref_impl< Scalar >
internal::imag_ref_retval< Scalar >
internal::imag_retval< Scalar >
internal::image_retval< FullPivLU< _MatrixType > >
internal::image_retval_base< _DecompositionType >
imaxdiv_t
internal::inner_stride_at_compile_time< Derived, HasDirectAccess >
internal::inner_stride_at_compile_time< Derived, false >
InnerIteratorAn InnerIterator allows to loop over the element of a sparse (or dense) matrix or expression
DenseBase< Derived >::InnerIterator
DynamicSparseMatrix< _Scalar, _Options, _Index >::InnerIterator
MappedSparseMatrix< _Scalar, _Flags, _Index >::InnerIterator
SparseInnerVectorSet< MatrixType, Size >::InnerIterator
SparseInnerVectorSet< SparseMatrix< _Scalar, _Options, _Index >, Size >::InnerIterator
SparseInnerVectorSet< DynamicSparseMatrix< _Scalar, _Options >, Size >::InnerIterator
CwiseBinaryOpImpl< BinaryOp, Lhs, Rhs, Sparse >::InnerIterator
CwiseUnaryOpImpl< UnaryOp, MatrixType, Sparse >::InnerIterator
CwiseUnaryViewImpl< ViewOp, MatrixType, Sparse >::InnerIterator
SparseDenseOuterProduct< Lhs, Rhs, Tr >::InnerIterator
SparseMatrix< _Scalar, _Options, _Index >::InnerIterator
TransposeImpl< MatrixType, Sparse >::InnerIterator
SparseTriangularView< MatrixType, Mode >::InnerIterator
SparseVector< _Scalar, _Options, _Index >::InnerIterator
SparseView< MatrixType >::InnerIterator
InnerStride< Value >Convenience specialization of Stride to specify only an inner stride See class Map for some examples
internal::inplace_transpose_selector< MatrixType, false >
internal::inplace_transpose_selector< MatrixType, true >
internal::inverse_impl< MatrixType >
IOFormatStores a set of parameters controlling the way matrices are printed
internal::is_arithmetic< T >
internal::is_arithmetic< __m128 >
internal::is_arithmetic< __m128d >
internal::is_arithmetic< __m128i >
internal::is_arithmetic< bool >
internal::is_arithmetic< char >
internal::is_arithmetic< double >
internal::is_arithmetic< float >
internal::is_arithmetic< long double >
internal::is_arithmetic< signed char >
internal::is_arithmetic< signed int >
internal::is_arithmetic< signed long >
internal::is_arithmetic< signed long long >
internal::is_arithmetic< signed short >
internal::is_arithmetic< unsigned char >
internal::is_arithmetic< unsigned int >
internal::is_arithmetic< unsigned long >
internal::is_arithmetic< unsigned long long >
internal::is_arithmetic< unsigned short >
internal::is_const< T >
internal::is_const< T const >
internal::is_diagonal< T >
internal::is_diagonal< DiagonalBase< T > >
internal::is_diagonal< DiagonalMatrix< T, S > >
internal::is_diagonal< DiagonalWrapper< T > >
internal::is_lvalue< ExpressionType >
internal::is_reference< T >
internal::is_reference< T & >
internal::is_same< T, U >
internal::is_same< T, T >
mrpt::slam::CRawlog::iteratorA normal iterator, plus the extra method "getType" to determine the type of each entry in the sequence
AmbiVector< _Scalar, _Index >::IteratorIterator over the nonzero coefficients
mrpt::poses::CPose3DQuat::iterator
JacobiRotation< Scalar >
JacobiSVD< _MatrixType, QRPreconditioner >Two-sided Jacobi SVD decomposition of a square matrix
mrpt::math::KDTreeCapableA base virtual class providing automatic, cached KD-tree-based look-up of points among data of arbitrary dimensionality
internal::kernel_retval< FullPivLU< _MatrixType > >
internal::kernel_retval_base< _DecompositionType >
LazyProductReturnType< Lhs, Rhs >
LDLT< _MatrixType, _UpLo >Robust Cholesky decomposition of a matrix with pivoting
Eigen::LDLT< _MatrixType, _UpLo >Robust Cholesky decomposition of a matrix with pivoting
Eigen::internal::ldlt_inplace< Lower >
internal::ldlt_inplace< Lower >
internal::ldlt_inplace< Upper >
Eigen::internal::ldlt_inplace< Upper >
internal::LDLT_Traits< MatrixType, Lower >
Eigen::internal::LDLT_Traits< MatrixType, Lower >
internal::LDLT_Traits< MatrixType, Upper >
Eigen::internal::LDLT_Traits< MatrixType, Upper >
internal::level3_blocking< _LhsScalar, _RhsScalar >
internal::linspaced_op< Scalar, RandomAccess >
internal::linspaced_op_impl< Scalar, false >
internal::linspaced_op_impl< Scalar, true >
std::list< T, EIGEN_ALIGNED_ALLOCATOR< T > >
mrpt::utils::list_searchable< T >This class implements a STL container with features of both, a std::set and a std::list
AmbiVector< _Scalar, _Index >::ListEl
LLT< _MatrixType, _UpLo >Standard Cholesky decomposition (LL^T) of a matrix and associated features
Eigen::LLT< _MatrixType, _UpLo >Standard Cholesky decomposition (LL^T) of a matrix and associated features
internal::llt_inplace< Lower >
Eigen::internal::llt_inplace< Lower >
internal::llt_inplace< Upper >
Eigen::internal::llt_inplace< Upper >
Eigen::internal::LLT_Traits< MatrixType, Lower >
internal::LLT_Traits< MatrixType, Lower >
internal::LLT_Traits< MatrixType, Upper >
Eigen::internal::LLT_Traits< MatrixType, Upper >
internal::log_default_impl< Scalar, IsInteger >
internal::log_default_impl< Scalar, true >
internal::log_impl< Scalar >
internal::log_retval< Scalar >
internal::lpNorm_selector< Derived, p >
internal::lpNorm_selector< Derived, 1 >
internal::lpNorm_selector< Derived, 2 >
internal::lpNorm_selector< Derived, Infinity >
mrpt::slam::detail::TPoseBin2D::lt_operatorLess-than ordering of bins for usage in STL containers
mrpt::slam::detail::TPathBin2D::lt_operatorLess-than ordering of bins for usage in STL containers
mrpt::slam::detail::TPoseBin3D::lt_operatorLess-than ordering of bins for usage in STL containers
internal::make_proper_matrix_type< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols >
Map< PlainObjectType, MapOptions, StrideType >A matrix or vector expression mapping an existing array of data
mrpt::utils::map_traits_stdmap::map< KEY, VALUE, _LessPred, _Alloc >
mrpt::utils::map_traits_map_as_vector::map< KEY, VALUE, _LessPred, _Alloc >
Map< const Quaternion< _Scalar >, PacketAccess >Quaternion expression mapping a constant memory buffer
Map< Quaternion< _Scalar >, PacketAccess >Expression of a quaternion from a memory buffer
mrpt::utils::map_as_vector< KEY, VALUE >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_vectorTraits for using a mrpt::utils::map_as_vector<> (dense, fastest representation)
mrpt::utils::map_traits_stdmapTraits for using a std::map<> (sparse representation)
MapBaseBase class for Map and Block expression with direct access
MapBase< Derived, ReadOnlyAccessors >
MapBase< Derived, WriteAccessors >
MappedSparseMatrix< _Scalar, _Flags, _Index >Sparse matrix
internal_mrpt::MatOrVecResizer< R, C >
internal_mrpt::MatOrVecResizer< 1, 1 >
internal_mrpt::MatOrVecResizer< 1, C >
internal_mrpt::MatOrVecResizer< R, 1 >
Matrix< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols >The matrix class, also used for vectors and row-vectors
Matrix
internal::matrix_swap_impl< MatrixTypeA, MatrixTypeB, SwapPointers >
internal::matrix_swap_impl< MatrixTypeA, MatrixTypeB, true >
internal::matrix_type_times_scalar_type< OtherScalarType, MatrixType >
MatrixBase< Derived >Base class for all dense matrices, vectors, and expressions
MatrixWrapper< ExpressionType >Expression of an array as a mathematical vector or matrix
mrpt::math::detail::MatrixWrapper< U, false >
mrpt::math::detail::MatrixWrapper< U, true >
MatrixXprThe type used to identify a matrix expression
internal::max_coeff_visitor< Derived >
internal::member_redux< BinaryOp, Scalar >
mrpt::utils::metaprogramming::MemberFunctionWrapper< T, V >This template encapsulates a member function without arguments and a single object into a function
mrpt::utils::metaprogramming::MemoryBypasserIterator< T, U >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*
internal::meta_sqrt< Y, InfX, SupX, Done >
internal::meta_sqrt< Y, InfX, SupX, true >
internal::min_coeff_visitor< Derived >
Minor< MatrixType >Expression of a minor
ANNmin_k::mk_node
mrpt::math::ModelSearchModel search implementations: RANSAC and genetic algorithm
mpBitmapLayerThis virtual class represents objects that can be moved to an arbitrary 2D location+rotation
mpCovarianceEllipseA 2D ellipse, described by a 2x2 covariance matrix
mpFXAbstract base class providing plot and labeling functionality for functions F:X->Y
mpFXYAbstract base class providing plot and labeling functionality for a locus plot F:N->X,Y
mpFXYVectorA class providing graphs functionality for a 2D plot (either continuous or a set of points), from vectors of data
mpFYAbstract base class providing plot and labeling functionality for functions F:Y->X
mpInfoCoordsImplements an overlay box which shows the mouse coordinates in plot units
mpInfoLayerBase 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
mpInfoLegendImplements the legend to be added to the plot This layer allows you to add a legend to describe the plots in the window
mpLayerPlot layer, abstract base class
mpMovableObjectThis virtual class represents objects that can be moved to an arbitrary 2D location+rotation
mpPolygonAn arbitrary polygon, descendant of mpMovableObject
mpPrintoutPrintout class used by mpWindow to draw in the objects to be printed
mpProfileAbstract base class providing plot and labeling functionality for functions F:Y->X
mpScaleXPlot layer implementing a x-scale ruler
mpScaleYPlot layer implementing a y-scale ruler
mpTextPlot layer implementing a text string
mpWindowCanvas for plotting mpLayer implementations
mrpt::utils::mrptEventThe basic event type for the observer-observable pattern in MRPT
mrpt::slam::mrptEventMetricMapClearEvent emitted by a metric up upon call of clear()
mrpt::slam::mrptEventMetricMapInsertEvent emitted by a metric up upon a succesful call to insertObservation()
mrpt::gui::mrptEventMouseDownAn event sent by a window upon a mouse click, giving the (x,y) pixel coordinates
mrpt::utils::mrptEventOnDestroyAn event sent by any CObservable object (automatically) just before being destroyed and telling its observers to unsubscribe
mrpt::gui::mrptEventWindowCharAn event sent by a window upon a char pressed by the user
mrpt::gui::mrptEventWindowResizeAn event sent by a window upon resize
mrpt::synch::MT_bufferThis class is a bulk sequence of bytes with MultiThread (MT)-safe read and write operations
TCLAP::MultiArg< T >An argument that allows multiple values of type T to be specified
TCLAP::MultiSwitchArgA multiple switch argument
internal::must_nest_by_value< T >
mrpt::hwdrivers::CPtuHokuyo::my_pos
NestByValue< ExpressionType >Expression which must be nested by value
internal::nested< T, n, PlainObject >
internal::nested< CoeffBasedProduct< Lhs, Rhs, EvalBeforeNestingBit|EvalBeforeAssigningBit >, N, PlainObject >
internal::nested< GeneralProduct< Lhs, Rhs, Mode >, N, PlainObject >
internal::nested< ReturnByValue< Derived >, n, PlainObject >
internal::no_assignment_operator
stlplus::no_copy< T >
NoAlias< ExpressionType, StorageBase >Pseudo expression providing an operator = assuming no aliasing
mrpt::utils::ci_less::nocase_compare
NoChange_t
mrpt::utils::non_copiable_ptr< T >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< T >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< Op >Equivalent of std::bind1st for functions with non-const arguments
mrpt::utils::metaprogramming::NonConstBind2nd< Op >Equivalent of std::bind2nd for functions with non-const arguments
internal::norm1_default_impl< Scalar, IsComplex >
internal::norm1_default_impl< Scalar, false >
internal::norm1_impl< Scalar >
internal::norm1_retval< Scalar >
mrpt::hwdrivers::CNTRIPClient::NTRIPArgsThe arguments for connecting to a NTRIP stream, used in CNTRIPClient::open
stlplus::null_dereference
NumTraits< T >Holds information about the various numeric (i.e
NumTraits< Array< Scalar, Rows, Cols, Options, MaxRows, MaxCols > >
NumTraits< double >
NumTraits< float >
NumTraits< long double >
NumTraits< std::complex< _Real > >
mrpt::utils::metaprogramming::ObjectClearAn 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::ObjectClear2An 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::ObjectClearSecondAn 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::ObjectClearUniqueAn object for making smart pointers unique (ie, making copies if necessary), intended for being used in STL algorithms
mrpt::utils::metaprogramming::ObjectConvert< TARGET_TYPE >An object for transforming between types/classes, intended for being used in STL algorithms
mrpt::utils::metaprogramming::ObjectDeleteAn object for deleting pointers (intended for STL algorithms)
mrpt::utils::metaprogramming::ObjectMakeUniqueAn object for making smart pointers unique (ie, making copies if necessary), intended for being used in STL algorithms
mrpt::utils::metaprogramming::ObjectPairMakeUniqueAn object for making smart pointers unique (ie, making copies if necessary), intended for being used in STL algorithms
mrpt::utils::metaprogramming::ObjectReadFromStreamAn object for reading objects from a stream, intended for being used in STL algorithms
mrpt::utils::metaprogramming::ObjectWriteToStreamAn object for writing objects to a stream, intended for being used in STL algorithms
mrpt::graphslam::graphslam_traits< EDGE_TYPE, MAPS_IMPLEMENTATION >::observation_info_tAuxiliary struct used in graph-slam implementation: It holds the relevant information for each of the constraints being taking into account
TCLAP::OptionalUnlabeledTracker
internal::outer_product_selector< ColMajor >
internal::outer_product_selector< RowMajor >
internal::outer_stride_at_compile_time< Derived, HasDirectAccess >
internal::outer_stride_at_compile_time< Derived, false >
OuterStride< Value >Convenience specialization of Stride to specify only an outer stride See class Map for some examples
internal::Packet1cd
internal::Packet2cf
internal::packet_traits< T >
internal::packet_traits< double >
internal::packet_traits< float >
internal::packet_traits< int >
internal::packet_traits< std::complex< double > >
internal::packet_traits< std::complex< float > >
internal::palign_impl< Offset, PacketType >
internal::palign_impl< Offset, Packet1cd >
internal::palign_impl< Offset, Packet2cf >
internal::palign_impl< Offset, Packet2d >
internal::palign_impl< Offset, Packet4f >
internal::palign_impl< Offset, Packet4i >
ParametrizedLine< _Scalar, _AmbientDim >
internal::partial_lu_impl< Scalar, StorageOrder >
PartialPivLU< _MatrixType >LU decomposition of a matrix with partial pivoting, and related features
PartialReduxExpr< MatrixType, MemberOp, Direction >Generic expression of a partially reduxed matrix
internal::permut_matrix_product_retval< PermutationType, MatrixType, Side, Transposed >
PermutationMatrix< SizeAtCompileTime, MaxSizeAtCompileTime >Permutation matrix
mrpt::slam::PF_implementation< PARTICLE_TYPE, MYSELF >A set of common data shared by PF implementations for both SLAM and localization
internal::plain_array< T, Size, MatrixOrArrayOptions, Alignment >
internal::plain_array< T, 0, MatrixOrArrayOptions, Alignment >
internal::plain_array< T, Size, MatrixOrArrayOptions, 16 >
internal::plain_col_type< ExpressionType, Scalar >
internal::plain_diag_type< ExpressionType, Scalar >
internal::plain_matrix_type< T, Dense >
internal::plain_matrix_type< T, Sparse >
internal::plain_matrix_type_column_major< T >
internal::plain_matrix_type_dense< T, ArrayXpr >
internal::plain_matrix_type_dense< T, MatrixXpr >
internal::plain_matrix_type_row_major< T >
internal::plain_row_type< ExpressionType, Scalar >
PlainObjectBase< Derived >Dense storage base class for matrices and arrays
pose_point_impl
mrpt::poses::detail::pose_point_impl< DERIVEDCLASS, 0 >
mrpt::poses::detail::pose_point_impl< DERIVEDCLASS, 1 >
internal::pow_default_impl
internal::pow_default_impl< Scalar, true >
internal::pow_impl< Scalar >
internal::pow_retval< Scalar >
ANNpr_queue::pq_node
internal::product_coeff_impl< DefaultTraversal, 0, Lhs, Rhs, RetScalar >
internal::product_coeff_impl< DefaultTraversal, Dynamic, Lhs, Rhs, RetScalar >
internal::product_coeff_impl< DefaultTraversal, UnrollingIndex, Lhs, Rhs, RetScalar >
internal::product_coeff_impl< InnerVectorizedTraversal, Dynamic, Lhs, Rhs, RetScalar >
internal::product_coeff_impl< InnerVectorizedTraversal, UnrollingIndex, Lhs, Rhs, RetScalar >
internal::product_coeff_vectorized_dyn_selector< Lhs, Rhs, LhsRows, RhsCols >
internal::product_coeff_vectorized_dyn_selector< Lhs, Rhs, 1, 1 >
internal::product_coeff_vectorized_dyn_selector< Lhs, Rhs, 1, RhsCols >
internal::product_coeff_vectorized_dyn_selector< Lhs, Rhs, LhsRows, 1 >
internal::product_coeff_vectorized_unroller< UnrollingIndex, Lhs, Rhs, Packet >
internal::product_coeff_vectorized_unroller< 0, Lhs, Rhs, Packet >
internal::product_packet_impl< ColMajor, 0, Lhs, Rhs, Packet, LoadMode >
internal::product_packet_impl< ColMajor, Dynamic, Lhs, Rhs, Packet, LoadMode >
internal::product_packet_impl< ColMajor, UnrollingIndex, Lhs, Rhs, Packet, LoadMode >
internal::product_packet_impl< RowMajor, 0, Lhs, Rhs, Packet, LoadMode >
internal::product_packet_impl< RowMajor, Dynamic, Lhs, Rhs, Packet, LoadMode >
internal::product_packet_impl< RowMajor, UnrollingIndex, Lhs, Rhs, Packet, LoadMode >
internal::product_selfadjoint_matrix< Scalar, Index, LhsStorageOrder, false, ConjugateLhs, RhsStorageOrder, true, ConjugateRhs, ColMajor >
internal::product_selfadjoint_matrix< Scalar, Index, LhsStorageOrder, LhsSelfAdjoint, ConjugateLhs, RhsStorageOrder, RhsSelfAdjoint, ConjugateRhs, RowMajor >
internal::product_selfadjoint_matrix< Scalar, Index, LhsStorageOrder, true, ConjugateLhs, RhsStorageOrder, false, ConjugateRhs, ColMajor >
internal::product_size_category< Size, MaxSize >
internal::product_triangular_matrix_matrix< Scalar, Index, Mode, false, LhsStorageOrder, ConjugateLhs, RhsStorageOrder, ConjugateRhs, ColMajor >
internal::product_triangular_matrix_matrix< Scalar, Index, Mode, LhsIsTriangular, LhsStorageOrder, ConjugateLhs, RhsStorageOrder, ConjugateRhs, RowMajor >
internal::product_triangular_matrix_matrix< Scalar, Index, Mode, true, LhsStorageOrder, ConjugateLhs, RhsStorageOrder, ConjugateRhs, ColMajor >
internal::product_triangular_matrix_vector< Index, Mode, LhsScalar, ConjLhs, RhsScalar, ConjRhs, ColMajor >
internal::product_triangular_matrix_vector< Index, Mode, LhsScalar, ConjLhs, RhsScalar, ConjRhs, RowMajor >
internal::product_type< Lhs, Rhs >
internal::product_type_selector< 1, 1, 1 >
internal::product_type_selector< 1, 1, Depth >
internal::product_type_selector< 1, Large, Large >
internal::product_type_selector< 1, Large, Small >
internal::product_type_selector< 1, Small, Large >
internal::product_type_selector< 1, Small, Small >
internal::product_type_selector< Large, 1, Large >
internal::product_type_selector< Large, 1, Small >
internal::product_type_selector< Large, Large, Large >
internal::product_type_selector< Large, Large, Small >
internal::product_type_selector< Large, Small, 1 >
internal::product_type_selector< Large, Small, Large >
internal::product_type_selector< Large, Small, Small >
internal::product_type_selector< M, N, 1 >
internal::product_type_selector< Small, 1, Large >
internal::product_type_selector< Small, 1, Small >
internal::product_type_selector< Small, Large, 1 >
internal::product_type_selector< Small, Large, Large >
internal::product_type_selector< Small, Large, Small >
internal::product_type_selector< Small, Small, 1 >
internal::product_type_selector< Small, Small, Large >
internal::product_type_selector< Small, Small, Small >
ProductBase< Derived, Lhs, Rhs >
ProductReturnType< Lhs, Rhs, ProductType >Helper class to get the correct and optimized returned type of operator*
ProductReturnType< Lhs, Rhs, CoeffBasedProductMode >
ProductReturnType< Lhs, Rhs, LazyCoeffBasedProductMode >
internal::projective_transform_inverse< TransformType, Mode >
internal::projective_transform_inverse< TransformType, Projective >
internal::promote_index_type< I1, I2 >
internal::promote_storage_type< A, A >
internal::promote_storage_type< Dense, Sparse >
internal::promote_storage_type< Sparse, Dense >
internal::qr_preconditioner_impl< MatrixType, QRPreconditioner, Case, DoAnything >
internal::qr_preconditioner_impl< MatrixType, ColPivHouseholderQRPreconditioner, PreconditionIfMoreColsThanRows, true >
internal::qr_preconditioner_impl< MatrixType, ColPivHouseholderQRPreconditioner, PreconditionIfMoreRowsThanCols, true >
internal::qr_preconditioner_impl< MatrixType, FullPivHouseholderQRPreconditioner, PreconditionIfMoreColsThanRows, true >
internal::qr_preconditioner_impl< MatrixType, FullPivHouseholderQRPreconditioner, PreconditionIfMoreRowsThanCols, true >
internal::qr_preconditioner_impl< MatrixType, HouseholderQRPreconditioner, PreconditionIfMoreColsThanRows, true >
internal::qr_preconditioner_impl< MatrixType, HouseholderQRPreconditioner, PreconditionIfMoreRowsThanCols, true >
internal::qr_preconditioner_impl< MatrixType, QRPreconditioner, Case, false >
internal::qr_preconditioner_should_do_anything< MatrixType, QRPreconditioner, Case >
internal::quat_product< Arch, Derived1, Derived2, Scalar, PacketAccess >
internal::quat_product< Architecture::SSE, Derived, OtherDerived, double, Aligned >
internal::quat_product< Architecture::SSE, Derived, OtherDerived, float, Aligned >
Quaternion< _Scalar >
QuaternionBase< Derived >
internal::quaternionbase_assign_impl< Other, 3, 3 >
internal::quaternionbase_assign_impl< Other, 4, 1 >
internal::random_default_impl
internal::random_default_impl< Scalar, false, false >
internal::random_default_impl< Scalar, false, true >
internal::random_default_impl< Scalar, true, false >
internal::random_impl< Scalar >
internal::random_impl< bool >
internal::random_retval< Scalar >
mrpt::math::RANSAC_Template< NUMTYPE >A generic RANSAC implementation with models as matrices
mrpt::opengl::CAngularObservationMesh::TDoubleRange::rdUnion type with the actual data
internal::real_impl< Scalar >
internal::real_impl< std::complex< RealScalar > >
internal::real_ref_impl< Scalar >
internal::real_ref_retval< Scalar >
internal::real_retval< Scalar >
RealSchur< _MatrixType >
Eigen::RealSchur< _MatrixType >
aligned_allocator< T >::rebind< U >
Eigen::aligned_allocator_indirection< T >::rebind< U >
internal::redux_impl< Func, Derived, DefaultTraversal, CompleteUnrolling >
internal::redux_impl< Func, Derived, DefaultTraversal, NoUnrolling >
internal::redux_impl< Func, Derived, LinearVectorizedTraversal, CompleteUnrolling >
internal::redux_impl< Func, Derived, LinearVectorizedTraversal, NoUnrolling >
internal::redux_impl< Func, Derived, SliceVectorizedTraversal, NoUnrolling >
internal::redux_novec_unroller< Func, Derived, Start, Length >
internal::redux_novec_unroller< Func, Derived, Start, 0 >
internal::redux_novec_unroller< Func, Derived, Start, 1 >
internal::redux_traits< Func, Derived >
internal::redux_vec_unroller< Func, Derived, Start, Length >
internal::redux_vec_unroller< Func, Derived, Start, 1 >
VectorwiseOp< ExpressionType, Direction >::ReduxReturnType< BinaryOp >
internal::ref_selector< T >
internal::remove_all< T >
internal::remove_all< const T >
internal::remove_all< T & >
internal::remove_all< T * >
internal::remove_all< T const & >
internal::remove_all< T const * >
internal::remove_const< T >
internal::remove_const< const T >
internal::remove_const< const T[]>
internal::remove_const< const T[Size]>
internal::remove_pointer< T >
internal::remove_pointer< T * >
internal::remove_pointer< T *const >
internal::remove_reference< T >
internal::remove_reference< T & >
Replicate< MatrixType, RowFactor, ColFactor >Expression of the multiple replication of a matrix or vector
internal::result_of< T >
internal::result_of< Func(ArgType)>
internal::result_of< Func(ArgType0, ArgType1)>
ReturnByValue< Derived >
VectorwiseOp< ExpressionType, Direction >::ReturnType< Functor, Scalar >
Reverse< MatrixType, Direction >Expression of the reverse of a vector or matrix
internal::reverse_packet_cond< PacketScalar, ReversePacket >
internal::reverse_packet_cond< PacketScalar, false >
mrpt::math::detail::ReverseAccessorIterator< A, T >Template class for matrix accessor's iterators
TransposeImpl< MatrixType, Sparse >::ReverseInnerIterator
Rotation2D< _Scalar >
internal::rotation_base_generic_product_selector< RotationDerived, DiagonalMatrix< Scalar, Dim, MaxDim >, false >
internal::rotation_base_generic_product_selector< RotationDerived, MatrixType, false >
internal::rotation_base_generic_product_selector< RotationDerived, OtherVectorType, true >
RotationBase< Derived, _Dim >Common base class for compact rotation representations
mrpt::utils::safe_ptr< T >A wrapper class for pointers that can be safely copied with "=" operator without problems
mrpt::utils::safe_ptr_basic< T >A wrapper class for pointers that can be safely copied with "=" operator without problems
internal::scalar_abs2_op< Scalar >
internal::scalar_abs_op< Scalar >
internal::scalar_add_op< Scalar >
internal::scalar_cast_op< Scalar, NewType >
internal::scalar_conj_product_op< Scalar >
internal::scalar_conjugate_op< Scalar >
internal::scalar_constant_op< Scalar >
internal::scalar_cos_op< Scalar >
internal::scalar_cube_op< Scalar >
internal::scalar_difference_op< Scalar >
internal::scalar_exp_op< Scalar >
internal::scalar_fuzzy_default_impl
internal::scalar_fuzzy_default_impl< Scalar, false, false >
internal::scalar_fuzzy_default_impl< Scalar, false, true >
internal::scalar_fuzzy_default_impl< Scalar, true, false >
internal::scalar_fuzzy_impl< Scalar >
internal::scalar_fuzzy_impl< bool >
internal::scalar_hypot_op< Scalar >
internal::scalar_identity_op< Scalar >
internal::scalar_imag_op< Scalar >
internal::scalar_imag_ref_op< Scalar >
internal::scalar_inverse_op< Scalar >
internal::scalar_log_op< Scalar >
internal::scalar_max_op< Scalar >
internal::scalar_min_op< Scalar >
internal::scalar_multiple2_op< Scalar1, Scalar2 >
internal::scalar_multiple_op< Scalar >
internal::scalar_opposite_op< Scalar >
internal::scalar_pow_op< Scalar >
internal::scalar_product_op< LhsScalar, RhsScalar >
internal::scalar_product_traits< std::complex< T >, T >
internal::scalar_product_traits< T, std::complex< T > >
internal::scalar_product_traits< T, T >
internal::scalar_quotient1_impl< Scalar, IsInteger >
internal::scalar_quotient1_impl< Scalar, true >
internal::scalar_quotient1_op< Scalar >
internal::scalar_quotient_op< Scalar >
internal::scalar_random_op< Scalar >
internal::scalar_real_op< Scalar >
internal::scalar_real_ref_op< Scalar >
internal::scalar_sin_op< Scalar >
internal::scalar_sqrt_op< Scalar >
internal::scalar_square_op< Scalar >
internal::scalar_sum_op< Scalar >
ScaledProduct< NestedProduct >
Scaling
mrpt::poses::SE_traits< 2 >Specialization of SE for 2D poses
mrpt::poses::SE_traits< 3 >Specialization of SE for 3D poses
Select< ConditionMatrixType, ThenMatrixType, ElseMatrixType >Expression of a coefficient wise version of the C++ ternary operator ?:
internal::selfadjoint_rank2_update_selector< Scalar, Index, UType, VType, Lower >
internal::selfadjoint_rank2_update_selector< Scalar, Index, UType, VType, Upper >
SelfAdjointEigenSolver< _MatrixType >
Eigen::SelfAdjointEigenSolver< _MatrixType >
SelfadjointProductMatrix< Lhs, 0, true, Rhs, RhsMode, false >
SelfadjointProductMatrix< Lhs, LhsMode, false, Rhs, 0, true >
SelfadjointProductMatrix< Lhs, LhsMode, false, Rhs, RhsMode, false >
SelfAdjointView< MatrixType, UpLo >Expression of a selfadjoint matrix from a triangular part of a dense matrix
MatrixBase< Derived >::SelfAdjointViewReturnType< UpLo >
SelfCwiseBinaryOp< BinaryOp, Lhs, Rhs >
Sequential_t
internal::setIdentity_impl< Derived, Big >
internal::setIdentity_impl< Derived, true >
internal::significant_decimals_default_impl< Scalar, IsInteger >
internal::significant_decimals_default_impl< Scalar, true >
internal::significant_decimals_impl< Scalar >
internal::sin_default_impl< Scalar, IsInteger >
internal::sin_default_impl< Scalar, true >
internal::sin_impl< Scalar >
internal::sin_retval< Scalar >
internal::size_at_compile_time< _Rows, _Cols >
stlplus::smart_ptr< T, COUNTER >
stlplus::smart_ptr_base< T, C, COUNTER >
stlplus::smart_ptr_clone< T, COUNTER >
stlplus::smart_ptr_holder< T, COUNTER >
stlplus::smart_ptr_nocopy< T, COUNTER >
Eigen::internal::solve_retval< ColPivHouseholderQR< _MatrixType >, Rhs >
internal::solve_retval< ColPivHouseholderQR< _MatrixType >, Rhs >
internal::solve_retval< FullPivHouseholderQR< _MatrixType >, Rhs >
Eigen::internal::solve_retval< FullPivHouseholderQR< _MatrixType >, Rhs >
internal::solve_retval< FullPivLU< _MatrixType >, Rhs >
internal::solve_retval< HouseholderQR< _MatrixType >, Rhs >
Eigen::internal::solve_retval< HouseholderQR< _MatrixType >, Rhs >
internal::solve_retval< JacobiSVD< _MatrixType, QRPreconditioner >, Rhs >
internal::solve_retval< LDLT< _MatrixType, _UpLo >, Rhs >
Eigen::internal::solve_retval< LDLT< _MatrixType, _UpLo >, Rhs >
Eigen::internal::solve_retval< LLT< _MatrixType, UpLo >, Rhs >
internal::solve_retval< LLT< _MatrixType, UpLo >, Rhs >
internal::solve_retval< PartialPivLU< _MatrixType >, Rhs >
internal::solve_retval_base< _DecompositionType, Rhs >
Eigen::internal::solve_retval_base< _DecompositionType, Rhs >
internal::sparse_cwise_binary_op_inner_iterator_selector< BinaryOp, Lhs, Rhs, Derived, Sparse, Sparse >
internal::sparse_cwise_binary_op_inner_iterator_selector< scalar_product_op< T >, Lhs, Rhs, Derived, Dense, Sparse >
internal::sparse_cwise_binary_op_inner_iterator_selector< scalar_product_op< T >, Lhs, Rhs, Derived, Sparse, Dense >
internal::sparse_cwise_binary_op_inner_iterator_selector< scalar_product_op< T >, Lhs, Rhs, Derived, Sparse, Sparse >
internal::sparse_diagonal_product_inner_iterator_selector< Lhs, Rhs, SparseDiagonalProductType, SDP_IsDiagonal, SDP_IsSparseColMajor >
internal::sparse_diagonal_product_inner_iterator_selector< Lhs, Rhs, SparseDiagonalProductType, SDP_IsDiagonal, SDP_IsSparseRowMajor >
internal::sparse_diagonal_product_inner_iterator_selector< Lhs, Rhs, SparseDiagonalProductType, SDP_IsSparseColMajor, SDP_IsDiagonal >
internal::sparse_diagonal_product_inner_iterator_selector< Lhs, Rhs, SparseDiagonalProductType, SDP_IsSparseRowMajor, SDP_IsDiagonal >
internal::sparse_product_selector2< Lhs, Rhs, ResultType, ColMajor, ColMajor, ColMajor >
internal::sparse_product_selector2< Lhs, Rhs, ResultType, ColMajor, ColMajor, RowMajor >
internal::sparse_product_selector2< Lhs, Rhs, ResultType, ColMajor, RowMajor, ColMajor >
internal::sparse_product_selector2< Lhs, Rhs, ResultType, ColMajor, RowMajor, RowMajor >
internal::sparse_product_selector2< Lhs, Rhs, ResultType, RowMajor, ColMajor, ColMajor >
internal::sparse_product_selector2< Lhs, Rhs, ResultType, RowMajor, ColMajor, RowMajor >
internal::sparse_product_selector2< Lhs, Rhs, ResultType, RowMajor, RowMajor, ColMajor >
internal::sparse_product_selector2< Lhs, Rhs, ResultType, RowMajor, RowMajor, RowMajor >
internal::sparse_product_selector< Lhs, Rhs, ResultType, ColMajor, ColMajor, ColMajor >
internal::sparse_product_selector< Lhs, Rhs, ResultType, ColMajor, ColMajor, RowMajor >
internal::sparse_product_selector< Lhs, Rhs, ResultType, RowMajor, RowMajor, ColMajor >
internal::sparse_product_selector< Lhs, Rhs, ResultType, RowMajor, RowMajor, RowMajor >
internal::sparse_solve_triangular_selector< Lhs, Rhs, Mode, Lower, ColMajor >
internal::sparse_solve_triangular_selector< Lhs, Rhs, Mode, Lower, RowMajor >
internal::sparse_solve_triangular_selector< Lhs, Rhs, Mode, Upper, ColMajor >
internal::sparse_solve_triangular_selector< Lhs, Rhs, Mode, Upper, RowMajor >
internal::sparse_solve_triangular_sparse_selector< Lhs, Rhs, Mode, UpLo, ColMajor >
SparseDenseOuterProduct< Lhs, Rhs, Tr >
SparseDenseProductReturnType< Lhs, Rhs, InnerSize >
SparseDenseProductReturnType< Lhs, Rhs, 1 >
SparseDiagonalProduct< Lhs, Rhs >
SparseInnerVectorSet< MatrixType, Size >
SparseInnerVectorSet< DynamicSparseMatrix< _Scalar, _Options >, Size >
SparseInnerVectorSet< SparseMatrix< _Scalar, _Options, _Index >, Size >
SparseMatrix< _Scalar, _Options, _Index >The main sparse matrix class
SparseMatrixBase< Derived >Base class of any sparse matrices or sparse expressions
SparseSelfAdjointTimeDenseProduct< Lhs, Rhs, UpLo >
SparseSelfAdjointView< MatrixType, UpLo >Pseudo expression to manipulate a triangular sparse matrix as a selfadjoint matrix
SparseSparseProduct< LhsNested, RhsNested >
SparseSparseProductReturnType< Lhs, Rhs >
SparseSymmetricPermutationProduct< MatrixType, UpLo >
SparseTimeDenseProduct< Lhs, Rhs >
SparseTriangularView< MatrixType, Mode >
SparseVector< _Scalar, _Options, _Index >Sparse vector class
SparseView< MatrixType >
internal::special_scalar_op_base< Derived, Scalar, OtherScalar, EnableIt >
internal::special_scalar_op_base< Derived, Scalar, OtherScalar, true >
TCLAP::SpecificationExceptionThrown from Arg and CmdLine when an Arg is improperly specified, e.g
internal::sqrt_default_impl< Scalar, IsInteger >
internal::sqrt_default_impl< Scalar, true >
internal::sqrt_impl< Scalar >
internal::sqrt_retval< Scalar >
internal::static_assertion< condition >
internal::static_assertion< true >
TCLAP::StdOutputA class that isolates any output from the CmdLine object so that it may be easily modified
internal::stem_function< Scalar >
Stride< _OuterStrideAtCompileTime, _InnerStrideAtCompileTime >Holds strides information for Map
internal::svd_precondition_2x2_block_to_be_real< MatrixType, QRPreconditioner, IsComplex >
internal::svd_precondition_2x2_block_to_be_real< MatrixType, QRPreconditioner, false >
internal::svd_precondition_2x2_block_to_be_real< MatrixType, QRPreconditioner, true >
SwapWrapper< ExpressionType >
TCLAP::SwitchArgA simple switch argument
internal::symm_pack_lhs< Scalar, Index, Pack1, Pack2, StorageOrder >
internal::symm_pack_rhs< Scalar, Index, nr, StorageOrder >
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 >
internal::take_matrix_for_product< MatrixOrTransformType >
internal::take_matrix_for_product< Transform< Scalar, Dim, Mode > >
internal::take_matrix_for_product< Transform< Scalar, Dim, Projective > >
mrpt::hmtslam::TArcListA class for storing a sequence of arcs (a path)
mrpt::math::detail::TAuxResizer< MAT, TypeSizeAtCompileTime >Internal resize which compiles to nothing on fixed-size matrices
mrpt::math::detail::TAuxResizer< MAT,-1 >
mrpt::vision::CFeatureExtraction::TOptions::TBCDOptions
mrpt::hmtslam::CHMTSLAM::TMessageLSLAMfromTBI::TBI_info
mrpt::utils::CTimeLogger::TCallDataData of all the calls:
mrpt::vision::TCamCalibBAResultsData returned by mrpt::vision::camera_calib_ba
mrpt::utils::TCameraStructure to hold the parameters of a pinhole camera model
mrpt::hwdrivers::CImageGrabber_dc1394::TCameraInfoUsed in enumerateCameras
mrpt::utils::TCameraPtr
mrpt::hwdrivers::TCaptureCVOptionsOptions used when creating an OpenCV capture object Some options apply to IEEE1394 cameras only
mrpt::hwdrivers::TCaptureOptions_bumblebeeOptions used when creating a bumblebee camera capture object
mrpt::hwdrivers::TCaptureOptions_dc1394Options 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_SVSOptions used when creating a STOC Videre Design camera capture object
mrpt::reactivenav::CParameterizedTrajectoryGenerator::TCellForLambdaFunctionSpecifies the min/max values for "k" and "n", respectively
mrpt::utils::TColorA RGB color - 8bit
mrpt::utils::TColorfA RGB color - floats in the range [0,1]
mrpt::slam::CColouredPointsMap::TColourOptionsThe definition of parameters for generating colors from laser scans
mrpt::slam::CGridMapAligner::TConfigParamsThe ICP algorithm configuration data
mrpt::slam::CICP::TConfigParamsThe ICP algorithm configuration data
mrpt::slam::CMetricMapBuilderICP::TConfigParamsAlgorithm configuration params
mrpt::slam::CMetricMapBuilderRBPF::TConstructionOptionsOptions for building a CMetricMapBuilderRBPF object, passed to the constructor
mrpt::topography::TCoordsA 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::TCPointThe trajectories in the C-Space:
mrpt::slam::COccupancyGridMap2D::TCriticalPointsListThe structure used to store the set of Voronoi diagram critical points
mrpt::slam::CLandmarksMap::TCustomSequenceLandmarksThe list of landmarks: the wrapper class is just for maintaining the KD-Tree representation
mrpt::slam::TDataAssociationResultsThe results from mrpt::slam::data_association
mrpt::slam::CRangeBearingKFSLAM::TDataAssocInfoInformation for data-association:
mrpt::slam::CRangeBearingKFSLAM2D::TDataAssocInfoInformation for data-association:
mrpt::slam::CObservationGasSensors::CMOSmodel::TdataMapThe content of each m_lastObservations in the estimation when using the option : MOS_MODEl (useMOSmodel =1)
mrpt::slam::CGasConcentrationGridMap2D::TdataMapThe content of each m_lastObservations in the estimation when using the option : MOS_MODEl (insertionOptions.useMOSmodel =1)
mrpt::slam::CRejectionSamplingRangeOnlyLocalization::TDataPerBeaconData for each beacon observation with a correspondence with the map
mrpt::topography::TDatum10ParamsParameters for a topographic transfomation
mrpt::topography::TDatum1DTransfParameters for a topographic transfomation
mrpt::topography::TDatum7ParamsParameters for a topographic transfomation
mrpt::topography::TDatum7Params_TOPCON
mrpt::topography::TDatumHelmert2DParameters for a topographic transfomation
mrpt::topography::TDatumHelmert2D_TOPCON
mrpt::topography::TDatumHelmert3DParameters for a topographic transfomation
mrpt::topography::TDatumHelmert3D_TOPCONParameters for a topographic transfomation
mrpt::topography::TDatumTransfInterpolationParameters for a topographic transfomation
mrpt::vision::CFeature::TDescriptorsAll the possible descriptors this feature may have
mrpt::slam::CMetricMapBuilderICP::TDistTraveled distances from last map update / ICP-based localization
mrpt::math::CDijkstra< TYPE_EDGES, MAPS_IMPLEMENTATION >::TDistanceAuxiliary struct for topological distances from root node
mrpt::slam::CDetectorDoorCrossing::TDoorCrossingOutParamsA structure used as output in this method
mrpt::opengl::CAngularObservationMesh::TDoubleRangeRange specification type, with several uses
mrpt::math::CDirectedTree< TYPE_EDGES >::TEdgeInfo
mrpt::topography::TEllipsoid
mrpt::hwdrivers::CRovio::TEncoders
mrpt::slam::COccupancyGridMap2D::TEntropyInfoUsed for returning entropy related information
mrpt::utils::TEnumType< ENUMTYPE >A helper class that can convert an enum value into its textual representation, and viceversa
mrpt::utils::TEnumTypeFiller< ENUMTYPE >Only specializations of this class are defined for each enum type of interest
mrpt::utils::TEnumTypeFiller< poses::CPose3DInterpolator::TInterpolatorMethod >
mrpt::utils::TEnumTypeFiller< slam::CGasConcentrationGridMap2D::TMapRepresentation >
mrpt::utils::TEnumTypeFiller< slam::CHeightGridMap2D::TMapRepresentation >
mrpt::vision::CFeatureTracker_FAST::TExtraOutputInfo
mrpt::bayes::CParticleFilterCapable::TFastDrawAuxVarsAuxiliary vectors, see CParticleFilterCapable::prepareFastDrawSample for more information
mrpt::vision::CFeatureExtraction::TOptions::TFASTOptions
mrpt::vision::TFeatureObservationOne feature observation entry, used within sequences with TSequenceFeatureObservations
mrpt::system::CDirectoryExplorer::TFileInfoThis represents the information about each file
mrpt::system::CFileSystemWatcher::TFileSystemChangeEach of the changes detected by utils::CFileSystemWatcher
mrpt::hwdrivers::TFTDIDeviceA list of FTDI devices and their descriptors
mrpt::slam::CLandmarksMap::TFuseOptionsWith this struct options are provided to the fusion process
mrpt::reactivenav::CHolonomicND::TGapThe structure used to store a detected gap in obstacles
mrpt::slam::TGasConcentrationCellThe contents of each cell in a CGasConcentrationGridMap2D map
mrpt::poses::CPosePDFSOG::TGaussianModeThe struct for each mode:
mrpt::poses::CPointPDFSOG::TGaussianModeThe struct for each mode:
mrpt::poses::CPose3DPDFSOG::TGaussianModeThe struct for each mode:
mrpt::topography::TGeodeticCoordsA set of geodetic coordinates: latitude, longitude and height, defined over a given geoid (typically, WGS84)
mrpt::slam::CObservationGPS::TGPSDatum_GGAThe GPS datum for GGA commands
mrpt::slam::CObservationGPS::TGPSDatum_PZSThe GPS datum for TopCon's mmGPS devices
mrpt::slam::CObservationGPS::TGPSDatum_RMCThe GPS datum for RMC commands
mrpt::slam::CObservationGPS::TGPSDatum_SATSA generic structure for statistics about tracked satelites and their positions
mrpt::slam::CLandmarksMap::TLikelihoodOptions::TGPSOriginThis 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
mrpt::slam::THeightGridmapCellThe contents of each cell in a CHeightGridMap2D map
mrpt::reactivenav::CReactiveNavigationSystem::THolonomicMovementThe structure used for storing a movement generated by a holonomic-method
mrpt::system::detail::ThreadCreateFunctor< T >
mrpt::system::detail::ThreadCreateFunctor< void * >
mrpt::system::detail::ThreadCreateFunctorNoParams
mrpt::system::detail::ThreadCreateObjectFunctor< CLASS, PARAM >
mrpt::system::detail::ThreadCreateObjectFunctorNoParams< CLASS >
mrpt::hwdrivers::ThreadParams
mrpt::hmtslam::THypothesisIDSetA set of hypothesis IDs, used for arcs and nodes in multi-hypothesis hybrid maps
mrpt::hmtslam::THypothesisIDSetPtr
mrpt::vision::TImageCalibDataData 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::TImageROIA structure for defining a ROI within an image
mrpt::opengl::C3DSScene::TImpl3DSA container for automatic deletion of lib3ds's scene when the last reference of the smart_ptr's is destroyed
mrpt::reactivenav::CLogFileRecord::TInfoPerPTGThe structure used to store all relevant information about each transformation into TP-Space
mrpt::slam::CPointsMap::TInsertionOptionsWith this struct options are provided to the observation insertion process
mrpt::slam::CGasConcentrationGridMap2D::TInsertionOptionsParameters related with inserting observations into the map:
mrpt::slam::COccupancyGridMap2D::TInsertionOptionsWith this struct options are provided to the observation insertion process
mrpt::slam::CLandmarksMap::TInsertionOptionsWith this struct options are provided to the observation insertion process
mrpt::slam::CHeightGridMap2D::TInsertionOptionsParameters related with inserting observations into the map
mrpt::slam::CBeaconMap::TInsertionOptionsThis struct contains data for choosing the method by which new beacons are inserted in the map
mrpt::slam::CLandmarksMap::TInsertionResultsThis struct stores extra results from invoking insertObservation
mrpt::math::KDTreeCapable::TKDTreeDataInternal structure with a KD-tree representation
mrpt::bayes::TKF_optionsGeneric options for the Kalman Filter algorithm in itself
mrpt::slam::TKLDParamsOption set for KLD algorithm
mrpt::vision::CFeatureExtraction::TOptions::TKLTOptions
mrpt::opengl::COpenGLViewport::TLastProjectiveMatrixInfo
mrpt::slam::CLandmarksMap::TLikelihoodOptionsWith this struct options are provided to the likelihood computations
mrpt::slam::CPointsMap::TLikelihoodOptionsOptions used when evaluating "computeObservationLikelihood" in the derived classes
mrpt::slam::COccupancyGridMap2D::TLikelihoodOptionsWith this struct options are provided to the observation likelihood computation process
mrpt::slam::CBeaconMap::TLikelihoodOptionsWith this struct options are provided to the likelihood computations
mrpt::slam::COccupancyGridMap2D::TLikelihoodOutputSome members of this struct will contain intermediate or output data after calling "computeObservationLikelihood" for some likelihood functions
mrpt::math::TLine2D2D line without bounds, represented by its equation $Ax+By+C=0$
mrpt::math::TLine3D3D line, represented by a base point and a director vector
mrpt::vision::CFeatureExtraction::TOptions::TLogPolarImagesOptionsLogPolarImagesOptions Options
mrpt::vision::TMatchingOptionsA structure containing options for the matching
mrpt::utils::TMatchingPairA structure for holding correspondences between two sets of points or points-like entities in 2D or 3D
mrpt::utils::TMatchingPairListA list of TMatchingPair
mrpt::slam::CObservationBeaconRanges::TMeasurementEach one of the measurements:
mrpt::slam::CObservationRange::TMeasurement
mrpt::slam::CObservationBearingRange::TMeasurementEach one of the measurements:
mrpt::detectors::CFaceDetection::TMeasurement
mrpt::hmtslam::CHMTSLAM::TMessageLSLAMfromAAMessage definition:

  • From: LSLAM
  • To: AA
  • Meaning: Reconsider the graph partition for the given LMH
mrpt::hmtslam::CHMTSLAM::TMessageLSLAMfromTBIMessage definition:

  • From: TBI
  • To: LSLAM
  • Meaning:
mrpt::hmtslam::CHMTSLAM::TMessageLSLAMtoTBIMessage definition:

  • From: LSLAM
  • To: TBI
  • Meaning: One or more areas are to be considered by the TBI engines
mrpt::slam::TMetricMapInitializerEach structure of this kind will determine the kind (and initial configuration) of one map to be build into a CMultiMetricMap object
mrpt::slam::TMonteCarloLocalizationParamsThe struct for passing extra simulation parameters to the prediction stage when running a particle filter
mrpt::slam::CActionRobotMovement2D::TMotionModelOptionsThe parameter to be passed to "computeFromOdometry"
mrpt::hwdrivers::CNTRIPClient::TMountPointA descriptor of one stream in an NTRIP Caster - See CNTRIPClient::retrieveListOfMountpoints
mrpt::random::CRandomGenerator::TMT19937_dataData used internally by the MT19937 PRNG algorithm
mrpt::vision::TMultiResDescMatchOptionsStruct containing the options when matching multi-resolution SIFT-like descriptors
mrpt::vision::TMultiResDescOptionsStruct containing the options when computing the multi-resolution SIFT-like descriptors
mrpt::vision::TMultiResMatchingOutputStruct containing the output after matching multi-resolution SIFT-like descriptors
mrpt::reactivenav::CAbstractReactiveNavigationSystem::TNavigationParamsThe struct for configuring the navigation request
mrpt::opengl::COctreePointRenderer< Derived >::TNodeThe structure for each octree spatial node
mrpt::math::TObject2DStandard type for storing any lightweight 2D type
mrpt::math::TObject3DStandard object for storing any 3D lightweight object
mrpt::slam::CObservationGasSensors::TObservationENoseThe structure for each e-nose
mrpt::slam::TMetricMapInitializer::TOccGridMap2DOptionsEspecific options for grid maps (mrpt::slam::COccupancyGridMap2D)
mrpt::slam::CIncrementalMapPartitioner::TOptionsConfiguration of the algorithm:
mrpt::slam::CDetectorDoorCrossing::TOptionsIn this structure parameters can be changed to customize the behaviour of this algorithm
mrpt::slam::CMultiMetricMap::TOptionsSome options for this class:
mrpt::detectors::CCascadeClassifierDetection::TOptions
mrpt::poses::CRobot2DPoseEstimator::TOptions
mrpt::slam::CConsistentObservationAlignment::TOptionsThe options for the method
mrpt::hmtslam::CTopLCDetector_GridMatching::TOptionsOptions for a TLC-detector of type gridmap-matching, used from CHMTSLAM
mrpt::reactivenav::CPRRTNavigator::TOptions
mrpt::vision::CFeatureExtraction::TOptionsThe set of parameters for all the detectors & descriptor algorithms
mrpt::slam::CRangeBearingKFSLAM::TOptionsThe options for the algorithm
mrpt::detectors::CFaceDetection::TOptions
mrpt::slam::CRangeBearingKFSLAM2D::TOptionsThe options for the algorithm
mrpt::slam::CMetricMapBuilder::TOptionsOptions for the algorithm
mrpt::hwdrivers::CRovio::TOptions
mrpt::hmtslam::CTopLCDetector_FabMap::TOptionsOptions for a TLC-detector of type FabMap, used from CHMTSLAM
mrpt::hmtslam::CHMTSLAM::TOptionsA variety of options and configuration params (private, use loadOptions)
mrpt::slam::CActionRobotMovement2D::TMotionModelOptions::TOptions_GaussianModelOptions for the gaussian model, which generates a CPosePDFGaussian object in poseChange
mrpt::slam::CActionRobotMovement2D::TMotionModelOptions::TOptions_ThrunModelOptions for the Thrun's model, which generates a CPosePDFParticles object in poseChange
mrpt::slam::CGridMapAligner::TReturnInfo::TPairPlusDistance
mrpt::utils::TParameters< T >For usage when passing a dynamic number of (numeric) arguments to a function, by name
mrpt::bayes::CParticleFilter::TParticleFilterOptionsThe configuration of a particle filter
mrpt::bayes::CParticleFilter::TParticleFilterStatsStatistics for being returned from the "execute" method
mrpt::hmtslam::CLSLAM_RBPF_2DLASER::TPathBinAuxiliary structure
mrpt::slam::detail::TPathBin2DAuxiliary structure
mrpt::reactivenav::CPRRTNavigator::TPathDataEach data point in m_planned_path
mrpt::topography::TPathFromRTKInfoUsed to return optional information from mrpt::topography::path_from_rtk_gps
mrpt::reactivenav::CPRRTNavigator::TOptions::TPathTrackingOpts
mrpt::utils::TPixelCoordA pair (x,y) of pixel coordinates (integer resolution)
mrpt::utils::TPixelCoordfA pair (x,y) of pixel coordinates (subpixel resolution)
mrpt::math::TPlane3D Plane, represented by its equation $Ax+By+Cz+D=0$
mrpt::reactivenav::CPRRTNavigator::TOptions::TPlannerOpts
mrpt::math::TPoint2DLightweight 2D point
mrpt::math::TPoint3DLightweight 3D point
mrpt::math::TPoint3DfLightweight 3D point (float version)
mrpt::opengl::CPointCloudColoured::TPointColour
mrpt::vision::CFeatureExtraction::TOptions::TPolarImagesOptionsPolarImagesOptions Options
mrpt::math::TPolygon2D2D polygon, inheriting from std::vector<TPoint2D>
mrpt::math::TPolygon3D3D polygon, inheriting from std::vector<TPoint3D>
mrpt::math::TPolygonWithPlaneSlightly heavyweight type to speed-up calculations with polygons in 3D
mrpt::opengl::CPolyhedron::TPolyhedronEdgeStruct used to store a polyhedron edge
mrpt::opengl::CPolyhedron::TPolyhedronFaceStruct used to store a polyhedron face
mrpt::math::TPose2DLightweight 2D pose
mrpt::math::TPose3DLightweight 3D pose (three spatial coordinates, plus three angular coordinates)
mrpt::math::TPose3DQuatLightweight 3D pose (three spatial coordinates, plus a quaternion )
mrpt::slam::detail::TPoseBin2DAuxiliary structure used in KLD-sampling in particle filters
mrpt::slam::detail::TPoseBin3DAuxiliary structure used in KLD-sampling in particle filters
mrpt::hmtslam::TPoseInfoInformation kept for each robot pose used in CRobotPosesGraph
mrpt::slam::CMultiMetricMapPDF::TPredictionParamsThe struct for passing extra simulation parameters to the prediction/update stage when running a particle filter
mrpt::math::CDijkstra< TYPE_EDGES, MAPS_IMPLEMENTATION >::TPreviousAuxiliary struct for backward paths
mrpt::utils::TPropertyValueIDTripletInternal triplet for each property in utils::CMHPropertiesValuesList
mrpt::utils::CPropertiesValuesList::TPropertyValuePair
mrpt::opengl::CGeneralizedCylinder::TQuadrilateralAuxiliary struct holding any quadrilateral, represented by foour points
internal::traits< AngleAxis< _Scalar > >
internal::traits< Array< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols > >
internal::traits< ArrayWrapper< ExpressionType > >
internal::traits< BandMatrix< _Scalar, Rows, Cols, Supers, Subs, Options > >
internal::traits< Block< XprType, BlockRows, BlockCols, InnerPanel, HasDirectAccess > >
internal::traits< CoeffBasedProduct< LhsNested, RhsNested, NestingFlags > >
internal::traits< const T >
internal::traits< CwiseBinaryOp< BinaryOp, Lhs, Rhs > >
internal::traits< CwiseNullaryOp< NullaryOp, PlainObjectType > >
internal::traits< CwiseUnaryOp< UnaryOp, XprType > >
internal::traits< CwiseUnaryView< ViewOp, MatrixType > >
internal::traits< DenseTimeSparseProduct< Lhs, Rhs > >
internal::traits< DenseTimeSparseSelfAdjointProduct< Lhs, Rhs, UpLo > >
internal::traits< Diagonal< MatrixType, DiagIndex > >
internal::traits< DiagonalMatrix< _Scalar, SizeAtCompileTime, MaxSizeAtCompileTime > >
internal::traits< DiagonalProduct< MatrixType, DiagonalType, ProductOrder > >
internal::traits< DiagonalWrapper< _DiagonalVectorType > >
internal::traits< DynamicSparseMatrix< _Scalar, _Options, _Index > >
internal::traits< Flagged< ExpressionType, Added, Removed > >
internal::traits< ForceAlignedAccess< ExpressionType > >
internal::traits< GeneralProduct< Lhs, Rhs, GemmProduct > >
internal::traits< GeneralProduct< Lhs, Rhs, GemvProduct > >
internal::traits< GeneralProduct< Lhs, Rhs, InnerProduct > >
internal::traits< GeneralProduct< Lhs, Rhs, OuterProduct > >
internal::traits< HessenbergDecompositionMatrixHReturnType< MatrixType > >
Eigen::internal::traits< HessenbergDecompositionMatrixHReturnType< MatrixType > >
internal::traits< Homogeneous< MatrixType, Direction > >
internal::traits< homogeneous_left_product_impl< Homogeneous< MatrixType, Vertical >, Lhs > >
internal::traits< homogeneous_right_product_impl< Homogeneous< MatrixType, Horizontal >, Rhs > >
internal::traits< HouseholderSequence< VectorsType, CoeffsType, Side > >
internal::traits< image_retval_base< DecompositionType > >
internal::traits< inverse_impl< MatrixType > >
internal::traits< kernel_retval_base< DecompositionType > >
internal::traits< Map< PlainObjectType, MapOptions, StrideType > >
internal::traits< Map< Quaternion< _Scalar >, _PacketAccess > >
internal::traits< MappedSparseMatrix< _Scalar, _Flags, _Index > >
internal::traits< Matrix< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols > >
internal::traits< MatrixWrapper< ExpressionType > >
internal::traits< Minor< MatrixType > >
internal::traits< NestByValue< ExpressionType > >
internal::traits< PartialReduxExpr< MatrixType, MemberOp, Direction > >
internal::traits< permut_matrix_product_retval< PermutationType, MatrixType, Side, Transposed > >
internal::traits< PermutationMatrix< SizeAtCompileTime, MaxSizeAtCompileTime > >
internal::traits< ProductBase< Derived, _Lhs, _Rhs > >
internal::traits< Quaternion< _Scalar > >
internal::traits< Replicate< MatrixType, RowFactor, ColFactor > >
internal::traits< ReturnByValue< Derived > >
internal::traits< Reverse< MatrixType, Direction > >
internal::traits< Rotation2D< _Scalar > >
internal::traits< ScaledProduct< NestedProduct > >
internal::traits< Select< ConditionMatrixType, ThenMatrixType, ElseMatrixType > >
internal::traits< SelfadjointProductMatrix< Lhs, 0, true, Rhs, RhsMode, false > >
internal::traits< SelfadjointProductMatrix< Lhs, LhsMode, false, Rhs, 0, true > >
internal::traits< SelfadjointProductMatrix< Lhs, LhsMode, false, Rhs, RhsMode, false > >
internal::traits< SelfAdjointView< MatrixType, UpLo > >
internal::traits< SelfCwiseBinaryOp< BinaryOp, Lhs, Rhs > >
internal::traits< solve_retval_base< DecompositionType, Rhs > >
Eigen::internal::traits< solve_retval_base< DecompositionType, Rhs > >
internal::traits< SparseDenseOuterProduct< Lhs, Rhs, Tr > >
internal::traits< SparseDiagonalProduct< Lhs, Rhs > >
internal::traits< SparseInnerVectorSet< MatrixType, Size > >
internal::traits< SparseMatrix< _Scalar, _Options, _Index > >
internal::traits< SparseSelfAdjointTimeDenseProduct< Lhs, Rhs, UpLo > >
internal::traits< SparseSelfAdjointView< MatrixType, UpLo > >
internal::traits< SparseSparseProduct< LhsNested, RhsNested > >
internal::traits< SparseSymmetricPermutationProduct< MatrixType, UpLo > >
internal::traits< SparseTimeDenseProduct< Lhs, Rhs > >
internal::traits< SparseTriangularView< MatrixType, Mode > >
internal::traits< SparseVector< _Scalar, _Options, _Index > >
internal::traits< SparseView< MatrixType > >
internal::traits< SwapWrapper< ExpressionType > >
internal::traits< Transpose< MatrixType > >
internal::traits< Transpose< PermutationMatrix< SizeAtCompileTime, MaxSizeAtCompileTime > > >
internal::traits< transposition_matrix_product_retval< TranspositionType, MatrixType, Side, Transposed > >
internal::traits< TriangularProduct< Mode, LhsIsTriangular, Lhs, false, Rhs, false > >
internal::traits< TriangularProduct< Mode, LhsIsTriangular, Lhs, false, Rhs, true > >
internal::traits< TriangularProduct< Mode, LhsIsTriangular, Lhs, true, Rhs, false > >
internal::traits< TriangularView< MatrixType, _Mode > >
internal::traits< TridiagonalizationMatrixTReturnType< MatrixType > >
Eigen::internal::traits< TridiagonalizationMatrixTReturnType< MatrixType > >
internal::traits< VectorBlock< VectorType, Size > >
Transform< _Scalar, _Dim, _Mode >
internal::transform_construct_from_matrix< Other, AffineCompact, Dim, HDim, HDim, HDim >
internal::transform_construct_from_matrix< Other, Mode, Dim, HDim, Dim, Dim >
internal::transform_construct_from_matrix< Other, Mode, Dim, HDim, Dim, HDim >
internal::transform_construct_from_matrix< Other, Mode, Dim, HDim, HDim, HDim >
internal::transform_left_product_impl< Other, AffineCompact, Dim, HDim, Dim, HDim >
internal::transform_left_product_impl< Other, AffineCompact, Dim, HDim, HDim, HDim >
internal::transform_left_product_impl< Other, Mode, Dim, HDim, Dim, Dim >
internal::transform_left_product_impl< Other, Mode, Dim, HDim, Dim, HDim >
internal::transform_left_product_impl< Other, Mode, Dim, HDim, HDim, HDim >
internal::transform_product_result< LhsMode, RhsMode >
internal::transform_right_product_impl< TransformType, MatrixType, false >
internal::transform_right_product_impl< TransformType, MatrixType, true >
internal::transform_take_affine_part< TransformType >
internal::transform_take_affine_part< Transform< Scalar, Dim, AffineCompact > >
internal::transform_traits< Transform >
internal::transform_transform_product_impl< Transform< Scalar, Dim, LhsMode >, Transform< Scalar, Dim, RhsMode >, false >
internal::transform_transform_product_impl< Transform< Scalar, Dim, LhsMode >, Transform< Scalar, Dim, RhsMode >, true >
Translation< _Scalar, _Dim >
Transpose< MatrixType >Expression of the transpose of a matrix
Transpose< PermutationMatrix< SizeAtCompileTime, MaxSizeAtCompileTime > >
Transpose< Transpositions< SizeAtCompileTime, MaxSizeAtCompileTime > >
TransposeImpl< MatrixType, Dense >
TransposeImpl< MatrixType, Sparse >
internal::TransposeImpl_base< MatrixType, HasDirectAccess >
internal::TransposeImpl_base< MatrixType, false >
internal::transposition_matrix_product_retval< TranspositionType, MatrixType, Side, Transposed >
Transpositions< SizeAtCompileTime, MaxSizeAtCompileTime >Represents a sequence of transpositions (row/column interchange)
mrpt::vision::TRelativeFeaturePosOne relative feature observation entry, used with some relative bundle-adjustment functions
mrpt::opengl::CRenderizable::TRenderInfoInformation about the rendering process being issued
mrpt::opengl::COctreePointRenderer< Derived >::TRenderQueueElement
mrpt::math::CLevenbergMarquardtTempl< VECTORTYPE, USERPARAM >::TResultInfo
mrpt::graphslam::TResultInfoSpaLevMarqOutput information for mrpt::graphslam::optimize_graph_spa_levmarq()
mrpt::slam::CGridMapAligner::TReturnInfoThe ICP algorithm return information
mrpt::slam::CICP::TReturnInfoThe ICP algorithm return information
internal::triangular_assignment_selector< Derived1, Derived2, Mode, UnrollCount, ClearOpposite >
internal::triangular_assignment_selector< Derived1, Derived2, Lower, Dynamic, ClearOpposite >
internal::triangular_assignment_selector< Derived1, Derived2, Mode, 0, ClearOpposite >
internal::triangular_assignment_selector< Derived1, Derived2, SelfAdjoint|Lower, 0, ClearOpposite >
internal::triangular_assignment_selector< Derived1, Derived2, SelfAdjoint|Lower, Dynamic, ClearOpposite >
internal::triangular_assignment_selector< Derived1, Derived2, SelfAdjoint|Upper, 0, ClearOpposite >
internal::triangular_assignment_selector< Derived1, Derived2, SelfAdjoint|Upper, Dynamic, ClearOpposite >
internal::triangular_assignment_selector< Derived1, Derived2, StrictlyLower, Dynamic, ClearOpposite >
internal::triangular_assignment_selector< Derived1, Derived2, StrictlyUpper, Dynamic, ClearOpposite >
internal::triangular_assignment_selector< Derived1, Derived2, UnitLower, Dynamic, ClearOpposite >
internal::triangular_assignment_selector< Derived1, Derived2, UnitUpper, Dynamic, ClearOpposite >
internal::triangular_assignment_selector< Derived1, Derived2, Upper, Dynamic, ClearOpposite >
internal::triangular_assignment_selector< Derived1, Derived2,(SelfAdjoint|Lower), UnrollCount, ClearOpposite >
internal::triangular_assignment_selector< Derived1, Derived2,(SelfAdjoint|Upper), UnrollCount, ClearOpposite >
internal::triangular_solve_matrix< Scalar, Index, OnTheLeft, Mode, Conjugate, TriStorageOrder, ColMajor >
internal::triangular_solve_matrix< Scalar, Index, OnTheRight, Mode, Conjugate, TriStorageOrder, ColMajor >
internal::triangular_solve_matrix< Scalar, Index, Side, Mode, Conjugate, TriStorageOrder, RowMajor >
internal::triangular_solve_vector< LhsScalar, RhsScalar, Index, OnTheLeft, Mode, Conjugate, ColMajor >
internal::triangular_solve_vector< LhsScalar, RhsScalar, Index, OnTheLeft, Mode, Conjugate, RowMajor >
internal::triangular_solve_vector< LhsScalar, RhsScalar, Index, OnTheRight, Mode, Conjugate, StorageOrder >
internal::triangular_solver_selector< Lhs, Rhs, OnTheLeft, Mode, CompleteUnrolling, 1 >
internal::triangular_solver_selector< Lhs, Rhs, OnTheRight, Mode, CompleteUnrolling, 1 >
internal::triangular_solver_selector< Lhs, Rhs, Side, Mode, NoUnrolling, 1 >
internal::triangular_solver_selector< Lhs, Rhs, Side, Mode, NoUnrolling, Dynamic >
internal::triangular_solver_unroller< Lhs, Rhs, Mode, Index, Size, false >
internal::triangular_solver_unroller< Lhs, Rhs, Mode, Index, Size, true >
TriangularBase< Derived >
TriangularProduct< Mode, false, Lhs, true, Rhs, false >
TriangularProduct< Mode, LhsIsTriangular, Lhs, false, Rhs, false >
TriangularProduct< Mode, true, Lhs, false, Rhs, true >
TriangularView< _MatrixType, _Mode >Base class for triangular part in a matrix
MatrixBase< Derived >::TriangularViewReturnType< Mode >
internal::tribb_kernel< LhsScalar, RhsScalar, Index, mr, nr, ConjLhs, ConjRhs, UpLo >
Tridiagonalization< _MatrixType >
Eigen::Tridiagonalization< _MatrixType >
Eigen::internal::tridiagonalization_inplace_selector< MatrixType, Size, IsComplex >
internal::tridiagonalization_inplace_selector< MatrixType, Size, IsComplex >
internal::tridiagonalization_inplace_selector< MatrixType, 1, IsComplex >
Eigen::internal::tridiagonalization_inplace_selector< MatrixType, 1, IsComplex >
Eigen::internal::tridiagonalization_inplace_selector< MatrixType, 3, false >
internal::tridiagonalization_inplace_selector< MatrixType, 3, false >
internal::TridiagonalizationMatrixTReturnType< MatrixType >
Eigen::internal::TridiagonalizationMatrixTReturnType< MatrixType >
internal::TridiagonalMatrix< Scalar, Size, Options >Represents a tridiagonal matrix with a compact banded storage
mrpt::hwdrivers::CActivMediaRobotBase::TRobotDescriptionA structure describing the robot
mrpt::hmtslam::CLocalMetricHypothesis::TRobotPosesPartitioningUsed by AA thread
mrpt::vision::TROIA structure for storing a 3D ROI
mrpt::hwdrivers::CRovio::TRovioState
internal::trsolve_traits< Lhs, Rhs, Side >
internal::true_type
mrpt::utils::TRuntimeClassIdA structure that holds runtime class type information
mrpt::math::TSegment2D2D segment, consisting of two points
mrpt::math::TSegment3D3D segment, consisting of two points
mrpt::hwdrivers::TSensorClassIdA structure for runtime ID class type information in the context of hwdrivers::CGenericSensor
mrpt::hwdrivers::CHokuyoURG::TSensorInfoUsed in CHokuyoURG::displayVersionInfo
mrpt::vision::TSequenceFeatureObservationsA complete sequence of observations of features from different camera frames (poses)
mrpt::slam::TSetOfMetricMapInitializersA 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::TSimple3DPointData within each particle
mrpt::poses::TSimple3DPointPtr
mrpt::math::ModelSearch::TSpecies< TModelFit >
mrpt::vision::CFeatureExtraction::TOptions::TSpinImagesOptions
mrpt::slam::CMetricMapBuilderRBPF::TStatsThis structure will hold stats after each execution of processActionObservation
mrpt::utils::TStereoCameraStructure to hold the parameters of a pinhole stereo camera model
mrpt::utils::TStereoCameraPtr
mrpt::slam::TStereoImageFeatures
mrpt::vision::TStereoSystemParamsParameters associated to a stereo system
mrpt::vision::CFeatureExtraction::TOptions::TSURFOptions
mrpt::detectors::CFaceDetection::TTestsOptions
mrpt::system::TThreadHandleThis structure contains the information needed to interface the threads API on each platform:
mrpt::system::TTimePartsThe parts of a date/time (it's like the standard 'tm' but with fractions of seconds)
mrpt::opengl::CSetOfTriangles::TTriangleTriangle definition
mrpt::opengl::CSetOfTexturedTriangles::TTriangleTriangle
mrpt::utils::TTypeName< T >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::TUpdateCellsInfoChangeOnlyAn internal structure for storing data related to counting the new information apported by some observation
mrpt::slam::CObservationGPS::TUTCTimeA UTC time-stamp structure for GPS messages
mrpt::opengl::CSetOfTexturedTriangles::TVertexTriangle vertex
type
internal::unaligned_assign_impl< IsAligned >
internal::unaligned_assign_impl< false >
internal::unary_result_of_select< Func, ArgType, SizeOf >
internal::unary_result_of_select< Func, ArgType, sizeof(has_std_result_type)>
internal::unary_result_of_select< Func, ArgType, sizeof(has_tr1_result)>
mrpt::utils::metaprogramming::UnaryMemberFunctionWrapper< T, U, V >This template encapsulates an unary member function and a single object into a function expecting the parameter of the member function
UniformScaling< _Scalar >
internal::unitOrthogonal_selector< Derived, Size >
internal::unitOrthogonal_selector< Derived, 2 >
internal::unitOrthogonal_selector< Derived, 3 >
TCLAP::UnlabeledMultiArg< T >Just like a MultiArg, except that the arguments are unlabeled
TCLAP::UnlabeledValueArg< T >The basic unlabeled argument that parses a value
internal::unpacket_traits< T >
internal::unpacket_traits< Packet1cd >
internal::unpacket_traits< Packet2cf >
internal::unpacket_traits< Packet2d >
internal::unpacket_traits< Packet4f >
internal::unpacket_traits< Packet4i >
internal::UpperBidiagonalization< _MatrixType >
TCLAP::ValueArg< T >The basic labeled argument that parses a value
TCLAP::VALUE_ARG_HELPER::ValueExtractor< T >This class is used to extract a value from an argument
TCLAP::MULTI_ARG_HELPER::ValueExtractor< T >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< T >A Constraint that constrains the Arg to only those values specified in the constraint
internal::variable_if_dynamic< T, Value >
internal::variable_if_dynamic< T, Dynamic >
std::vector< T, EIGEN_ALIGNED_ALLOCATOR< T > >
VectorBlock< VectorType, Size >Expression of a fixed-size or dynamic-size sub-vector
VectorwiseOp< ExpressionType, Direction >Pseudo expression providing partial reduction operations
TCLAP::VersionVisitorA 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::math::CDirectedTree< TYPE_EDGES >::VisitorVirtual base class for user-defined visitors
TCLAP::VisitorA base class that defines the interface for visitors
internal::visitor_impl< Visitor, Derived, UnrollCount >
internal::visitor_impl< Visitor, Derived, 1 >
internal::visitor_impl< Visitor, Derived, Dynamic >
WithFormat< ExpressionType >Pseudo expression providing matrix output with given format
stlplus::wrong_object
mrpt::gui::WxSubsystemThis class implements the GUI thread required for the wxWidgets-based GUI
TCLAP::XorHandlerThis class handles lists of Arg's that are to be XOR'd on the command line



Page generated by Doxygen 1.7.3 for MRPT 0.9.4 SVN:exported at Tue Jan 25 21:56:31 UTC 2011