Back to list of all libraries | See all modules
mrpt-baseThis is the most fundamental library in MRPT, since it provides a vast amount of utilities and OS-abstraction classes upon which the rest of MRPT is built. Here resides critical functionality such as mathematics, linear algebra, serialization, smart pointers and multi-threading. l This library comprises classes in a number of namespaces, briefly described below (click on the namespaces names to see the complete list of its classes):
A comprehensive collection of geometry-related classes to represent all kind of 2D and 3D geomtry transformations in different formats (Euler angles, rotation matrices, quaternions), as well as networks of pose constrains (as used typically in SLAM problems).
There are also implemented representations for probability distributions over all of these transformations, in a generic way that allow mono and multi-modal Gaussians and particle-based representations.
See mrpt::poses for the complete list of classes here.
RTTI (RunTime Type Information): A cross-platform, compiler-independent RTTI system is built around the base class mrpt::utils::CObject.
Smart pointers: Based on the STLplus library, any class CFoo inheriting from CObject, automatically has an associated smart pointer class CFooPtr. MRPT implements advanced smart pointers capable of multi-thread safe usage and smart pointer typecasting with runtime check for correct castings (tutorial).
Image handling: The class mrpt::utils::CImage represents a wrapper around OpenCV IplImage's, plus extra functionality such as on-the-fly loading of images stored in disk upon first usage. The internal IplImage is always available so OpenCV's functions can be still used to operate on MRPT images.
Serialization/Persistence: Object serialization in a simple but powerful (including versioning) format is supported by dozens of MRPT classes, all based on mrpt::utils::CSerializable.
Streams: Stream classes (see the base mrpt::utils::CStream) allow serialization of MRPT objects. There are classes for tranparent GZ-compressed files, sockets, serial ports, etc.
XML-based databases: Simple databases can be mantained, loaded and saved to files with mrpt::utils::CSimpleDatabase.
Name-based argument passing: See the structure mrpt::utils::TParameters
Configuration files: There is one base virtual class (mrpt::utils::CConfigFileBase) which can be used to read/write configuration files (including basic types, vectors, matrices,...) from any "configuration source" transparently (an actual configuration file, a text block created on the fly, etc.).
MRPT defines a number of generic math containers, which are:
For a more in-depth description of these types, and their relation to the base Eigen classes, read this page.
Notice that fixed-size containers should be preferred where possible, since they allow more compile-time optimizations.
Apart from the containers, this namespace contains much more functionality:
This namespace includes threading tools such as critical sections, semaphores or utilities such as the template mrpt::synch::CThreadSafeVariable that converts any variable into a pair variable-critical section.
Here can be found functions for filesystem managing, watching directories, creating and handling threads in an OS-independent way, etc.
GZip compression methods can be found in this namespace.
|
Classes | |
| class | mrpt::bayes::CParticleFilter |
| This class acts as a common interface to the different interfaces (see CParticleFilter::TParticleFilterAlgorithm) any bayes::CParticleFilterCapable class can implement: it is the invoker of particle filter algorithms. More... | |
| class | mrpt::bayes::CParticleFilterCapable |
| This virtual class defines the interface that any particles based PDF class must implement in order to be executed by a mrpt::bayes::CParticleFilter. More... | |
| class | mrpt::bayes::CParticleFilterData |
| This template class declares the array of particles and its internal data, managing some memory-related issues and providing an easy implementation of virtual methods required for implementing a CParticleFilterCapable. More... | |
| struct | mrpt::bayes::CProbabilityParticle |
| A template class for holding a the data and the weight of a particle. More... | |
| class | mrpt::math::CArray |
| A STL container (as wrapper) for arrays of constant size defined at compile time - Users will most likely prefer to use CArrayPOD and its derived classes instead. More... | |
| class | mrpt::math::CBinaryRelation |
| This class models a binary relation through the elements of any given set. More... | |
| class | mrpt::math::CHistogram |
| This class provides an easy way of computing histograms for unidimensional real valued variables. More... | |
| class | mrpt::math::CLevenbergMarquardtTempl |
| An implementation of the Levenberg-Marquardt algorithm for least-square minimization. More... | |
| class | mrpt::math::CMatrix |
| This class is a "CSerializable" wrapper for "CMatrixFloat". More... | |
| class | mrpt::math::CMatrixB |
| This class is a "CSerializable" wrapper for "CMatrixBool". More... | |
| class | mrpt::math::CMatrixD |
| This class is a "CSerializable" wrapper for "CMatrixTemplateNumeric<double>". More... | |
| class | mrpt::math::CMatrixFixedNumeric |
| A numeric matrix of compile-time fixed size. More... | |
| class | mrpt::math::CMatrixTemplate |
| This template class provides the basic functionality for a general 2D any-size, resizable container of numerical or non-numerical elements. More... | |
| class | mrpt::math::CMatrixTemplateNumeric |
| A matrix of dynamic size. More... | |
| class | mrpt::math::CMatrixTemplateObjects |
| This template class extends the class "CMatrixTemplate" for storing "objects" at each matrix entry. More... | |
| class | mrpt::math::CMonteCarlo |
| Montecarlo simulation for experiments in 1D. More... | |
| class | mrpt::math::CQuaternion |
A quaternion, which can represent a 3D rotation as pair  , with a real part "r" and a 3D vector  , or alternatively, q = r + ix + jy + kz. More... | |
| class | mrpt::math::CSparseMatrix |
| A sparse matrix capable of efficient math operations (a wrapper around the CSparse library) The type of cells is fixed to "double". More... | |
| class | mrpt::math::CSparseMatrixTemplate |
| A sparse matrix container (with cells of any type), with iterators. More... | |
| class | mrpt::math::KDTreeCapable |
| A generic adaptor class for providing Approximate Nearest Neighbors (ANN) (via the nanoflann library) to MRPT classses. More... | |
| class | mrpt::random::CRandomGenerator |
| A thred-safe pseudo random number generator, based on an internal MT19937 randomness generator. More... | |
| class | mrpt::system::CDirectoryExplorer |
| This class allows the enumeration of the files/directories that exist into a given path. More... | |
| class | mrpt::system::CFileSystemWatcher |
| This class subscribes to notifications of file system changes, thus it can be used to efficiently stay informed about changes in a directory tree. More... | |
| class | mrpt::utils::CCanvas |
| This virtual class defines the interface of any object accepting drawing primitives on it. More... | |
| class | mrpt::utils::CConfigFile |
| This class allows loading and storing values and vectors of different types from ".ini" files easily. More... | |
| class | mrpt::utils::CConfigFileBase |
| This class allows loading and storing values and vectors of different types from a configuration text, which can be implemented as a ".ini" file, a memory-stored string, etc... More... | |
| class | mrpt::utils::CConfigFileMemory |
| This class implements a config file-like interface over a memory-stored string list. More... | |
| class | mrpt::utils::CConsoleRedirector |
| By creating an object of this class, all the output to std::cout (and std::cerr) will be redirected to a text file, and optionally also shown on the console. More... | |
| class | mrpt::utils::CDebugOutputCapable |
| This base class provides a common printf-like method to send debug information to std::cout, with the purpose of allowing its redirection to other streams if desired. More... | |
| class | mrpt::utils::CDynamicGrid |
| A 2D grid of dynamic size which stores any kind of data at each cell. More... | |
| class | mrpt::utils::CEnhancedMetaFile |
| This class represents a Windows Enhanced Meta File (EMF) for generating and saving graphics. More... | |
| class | mrpt::utils::CFileGZInputStream |
| Transparently opens a compressed "gz" file and reads uncompressed data from it. More... | |
| class | mrpt::utils::CFileInputStream |
| This CStream derived class allow using a file as a read-only, binary stream. More... | |
| class | mrpt::utils::CFileOutputStream |
| This CStream derived class allow using a file as a write-only, binary stream. More... | |
| class | mrpt::utils::CFileStream |
| This CStream derived class allow using a file as a read/write binary stream, creating it if the file didn't exist. More... | |
| class | mrpt::utils::CImage |
| A class for storing images as grayscale or RGB bitmaps. More... | |
| class | mrpt::utils::CListOfClasses |
| A list (actually based on a std::set) of MRPT classes, capable of keeping any class registered by the mechanism of CSerializable classes. More... | |
| class | mrpt::utils::CLoadableOptions |
| This is a virtual base class for sets of options than can be loaded from and/or saved to configuration plain-text files. More... | |
| class | mrpt::utils::CLog |
| A decorator of CStringList special for keeping logs. More... | |
| class | mrpt::utils::CMappedImage |
| This class encapsulates a MRPT Image and allows the sampling of individual pixels with sub-pixel accuracy and with a change of coordinates (eg, meters). More... | |
| class | mrpt::utils::CMemoryChunk |
| A memory buffer (implements CStream) which can be itself serialized. More... | |
| class | mrpt::utils::CMemoryStream |
| This CStream derived class allow using a memory buffer as a CStream. More... | |
| class | mrpt::utils::CMessage |
| A class that contain generic messages, that can be sent and received from a "CClientTCPSocket" object. More... | |
| class | mrpt::utils::CMHPropertiesValuesList |
| An arbitrary list of "annotations", or named attributes, each being an instance of any CSerializable object (Multi-hypotheses version). More... | |
| class | mrpt::utils::CObjectPtr |
| A smart pointer to a CObject object. More... | |
| struct | mrpt::utils::TRuntimeClassId |
| A structure that holds runtime class type information. More... | |
| struct | mrpt::utils::CLASSINIT |
| Auxiliary structure used for CObject-based RTTI. More... | |
| class | mrpt::utils::CObject |
| The virtual base class of all MRPT classes with a unified RTTI system. More... | |
| class | mrpt::utils::CObservable |
| Inherit from this class for those objects capable of being observed by a CObserver class. More... | |
| class | mrpt::utils::CObserver |
| Inherit from this class to get notified about events from any CObservable object after subscribing to it. More... | |
| class | mrpt::utils::CProbabilityDensityFunction |
| A generic template for probability density distributions (PDFs). More... | |
| class | mrpt::utils::CPropertiesValuesList |
| An arbitrary list of "annotations", or named attributes, each being an instance of any CSerializable object. More... | |
| class | mrpt::utils::CReferencedMemBlock |
| Represents a memory block (via "void*") that can be shared between several objects through copy operator (=). More... | |
| class | mrpt::utils::CRobotSimulator |
| This class can be used to simulate the kinematics and dynamics of a differential driven planar mobile robot, including odometry errors and dynamics limitations. More... | |
| class | mrpt::utils::CSerializable |
| The virtual base class which provides a unified interface for all persistent objects in MRPT. More... | |
| class | mrpt::utils::CSimpleDatabaseTable |
| This class implements the tables of databases. More... | |
| class | mrpt::utils::CStartUpClassesRegister |
| A helper class that automatically register at start up a custom function to register all the CObject-derived classes in a given MRPT library or user application. More... | |
| class | mrpt::utils::CStdOutStream |
| This CStdOutStream derived class allow printing to standard out, normally the console text output. More... | |
| class | mrpt::utils::CStream |
| This base class is used to provide a unified interface to files,memory buffers,..Please see the derived classes. More... | |
| class | mrpt::utils::CStringList |
| A class for storing a list of text lines. More... | |
| class | mrpt::utils::CTextFileLinesParser |
| A class for parsing text files, returning each non-empty and non-comment line, along its line number. More... | |
| class | mrpt::utils::CThreadSafeQueue |
| A thread-safe template queue for object passing between threads; for a template argument of T, the objects being passed in the queue are "T*". More... | |
| class | mrpt::utils::CTicTac |
| This class implements a high-performance stopwatch. More... | |
| class | mrpt::utils::CTimeLogger |
| A versatile "profiler" that logs the time spent within each pair of calls to enter(X)-leave(X), among other stats. More... | |
| class | mrpt::utils::CTypeSelector |
| This class represents a std::string derived class which is also CSerializable. More... | |
| class | mrpt::utils::CUncopiable |
| The base class of classes that cannot be copied: compile-time errors will be issued on any copy operation. More... | |
| class | mrpt::utils::CMRPTException |
| The base for MRPT-especific exceptions. More... | |
| class | mrpt::utils::mrptEvent |
| The basic event type for the observer-observable pattern in MRPT. More... | |
| class | mrpt::utils::mrptEventOnDestroy |
| An event sent by any CObservable object (automatically) just before being destroyed and telling its observers to unsubscribe. More... | |
| class | mrpt::utils::PLY_Importer |
| A virtual base class that implements the capability of importing 3D point clouds and faces from a file in the Stanford PLY format. More... | |
| class | mrpt::utils::PLY_Exporter |
| A virtual base class that implements the capability of exporting 3D point clouds and faces to a file in the Stanford PLY format. More... | |
| class | mrpt::utils::TCamera |
| Structure to hold the parameters of a pinhole camera model. More... | |
| struct | mrpt::utils::TColor |
| A RGB color - 8bit. More... | |
| struct | mrpt::utils::TColorf |
| A RGB color - floats in the range [0,1]. More... | |
| struct | mrpt::utils::TEnumTypeFiller |
| Only specializations of this class are defined for each enum type of interest. More... | |
| struct | mrpt::utils::TEnumType |
| A helper class that can convert an enum value into its textual representation, and viceversa. More... | |
| struct | mrpt::utils::TMatchingPair |
| A structure for holding correspondences between two sets of points or points-like entities in 2D or 3D. More... | |
| class | mrpt::utils::TMatchingPairList |
| A list of TMatchingPair. More... | |
| struct | mrpt::utils::TParameters |
| For usage when passing a dynamic number of (numeric) arguments to a function, by name. More... | |
| struct | mrpt::utils::TPixelCoordf |
| A pair (x,y) of pixel coordinates (subpixel resolution). More... | |
| struct | mrpt::dynamicsize_vector |
| The base class of MRPT vectors, actually, Eigen column matrices of dynamic size with specialized constructors that resemble std::vector. More... | |
Namespaces | |
| namespace | mrpt::bayes |
The namespace for Bayesian filtering algorithm: different particle filters and Kalman filter algorithms. | |
| namespace | mrpt::compress |
Data compression/decompression algorithms. | |
| namespace | mrpt::compress::zip |
Compression using the "zip" algorithm and from/to gzip (gz) files. | |
| namespace | mrpt::math::jacobians |
A collection of functions to compute jacobians of diverse transformations, etc (some functions are redirections to existing methods elsewhere, so this namespace is actually used with grouping purposes). | |
| namespace | mrpt::math |
This base provides a set of functions for maths stuff. | |
| namespace | mrpt::random |
A namespace of pseudo-random numbers genrators of diferent distributions. | |
| namespace | mrpt::system |
This namespace provides a OS-independent interface to many useful functions: filenames manipulation, time and date, string parsing, file I/O, threading, memory allocation, etc. | |
| namespace | mrpt::system::os |
This namespace provides a OS-independent interface to low-level functions. | |
| namespace | mrpt::utils |
Classes for serialization, sockets, ini-file manipulation, streams, list of properties-values, timewatch, extensions to STL. | |
Modules | |
| 2D/3D points and poses | |
| 2D/3D point and pose PDFs | |
| Synchronization, multi-threading synch tools | |
| Time and date functions | |
| Directories, files, and file names | |
| OS and compiler abstraction | |
| Networking, sockets, DNS | |
| Statistics functions, probability distributions | |
| Fourier transform functions | |
| Geometry: lines, planes, intersections, SLERP, "lightweight" point & pose classes | |
| KD-Trees | |
| Vector and matrices mathematical operations and other utilities | |
| RANSAC and other model fitting algorithms | |
| Gaussian PDF transformation functions | |
| Interpolation, least-squares fit, splines | |
| Memory utilities | |
| String management and utilities | |
| Threads | |
| STL extensions and metaprogramming | |
Defines | |
| #define | CFileGZOutputStream CFileOutputStream |
| Saves data to a file and transparently compress the data using the given compression level. | |
Typedefs | |
| typedef CThreadSafeQueue < CMessage > | mrpt::utils::CMessageQueue |
| A thread-safe class for message passing between threads. | |
Enumerations | |
| enum | mrpt::utils::TInterpolationMethod { mrpt::utils::IMG_INTERP_NN = 0, mrpt::utils::IMG_INTERP_LINEAR = 1, mrpt::utils::IMG_INTERP_CUBIC = 2, mrpt::utils::IMG_INTERP_AREA = 3 } |
| Interpolation methods for images. More... | |
RTTI classes and functions | |
| typedef safe_ptr< TRuntimeClassId > | mrpt::utils::TRuntimeClassIdPtr |
| A wrapper class for a "TRuntimeClassId *", well-defined with respect to copy operators and constructors. | |
| class BASE_IMPEXP | mrpt::utils::CObject |
| void BASE_IMPEXP | mrpt::utils::registerClass (const mrpt::utils::TRuntimeClassId *pNewClass) |
| Register a class into the MRPT internal list of "CSerializable" descendents. | |
| void BASE_IMPEXP | mrpt::utils::registerClassCustomName (const char *customName, const TRuntimeClassId *pNewClass) |
| Mostly for internal use within mrpt sources, to handle exceptional cases with multiple serialization names for backward compatibility (CMultiMetricMaps, CImage,...) | |
| std::vector< const mrpt::utils::TRuntimeClassId * > BASE_IMPEXP | mrpt::utils::getAllRegisteredClasses () |
| Returns a list with all the classes registered in the system through mrpt::utils::registerClass. | |
| const TRuntimeClassId BASE_IMPEXP * | mrpt::utils::findRegisteredClass (const std::string &className) |
| Return info about a given class by its name, or NULL if the class is not registered. | |
| #define CFileGZOutputStream CFileOutputStream |
Saves data to a file and transparently compress the data using the given compression level.
The generated files are in gzip format ("file.gz"). This class requires compiling MRPT with wxWidgets. If wxWidgets is not available then the class is actually mapped to the standard CFileOutputStream
Definition at line 49 of file CFileGZOutputStream.h.
| typedef CThreadSafeQueue<CMessage> mrpt::utils::CMessageQueue |
A thread-safe class for message passing between threads.
Definition at line 42 of file CMessageQueue.h.
| typedef safe_ptr<TRuntimeClassId> mrpt::utils::TRuntimeClassIdPtr |
Interpolation methods for images.
Used for OpenCV related operations with images, but also with MRPT native classes.
| const TRuntimeClassId BASE_IMPEXP* mrpt::utils::findRegisteredClass | ( | const std::string & | className | ) |
Return info about a given class by its name, or NULL if the class is not registered.
| std::vector<const mrpt::utils::TRuntimeClassId*> BASE_IMPEXP mrpt::utils::getAllRegisteredClasses | ( | ) |
Returns a list with all the classes registered in the system through mrpt::utils::registerClass.
| void BASE_IMPEXP mrpt::utils::registerClass | ( | const mrpt::utils::TRuntimeClassId * | pNewClass | ) |
Register a class into the MRPT internal list of "CSerializable" descendents.
Used internally in the macros DEFINE_SERIALIZABLE, etc...
Referenced by mrpt::hwdrivers::CGenericSensor::CLASSINIT_GENERIC_SENSOR::CLASSINIT_GENERIC_SENSOR(), and mrpt::utils::CLASSINIT::CLASSINIT().
| void BASE_IMPEXP mrpt::utils::registerClassCustomName | ( | const char * | customName, |
| const TRuntimeClassId * | pNewClass | ||
| ) |
Mostly for internal use within mrpt sources, to handle exceptional cases with multiple serialization names for backward compatibility (CMultiMetricMaps, CImage,...)
| class BASE_IMPEXP mrpt::utils::CObject |
| Page generated by Doxygen 1.7.5 for MRPT 0.9.5 SVN: at Thu Oct 13 21:25:36 UTC 2011 |