  boost | |
  asio | |
| cv | |
 DataType< mira::ImgPixel< T, Channels > > | |
| Eigen | |
| AmbiVector | |
| mira | Specialize cv::DataType for our ImgPixel and inherit from cv::DataType<Vec> |
| Private | |
 EdgeCuts | |
| ActiveEdgeCuts | |
| Interval | |
| Intervals | |
| Color | |
| RGB | The different color spaces |
| RGBA | Color in RGBA color space |
| HSV | Color in HSV color space |
| XYZ | Color in CIE 1931 XYZ color space The CIE XYZ color space is the master for the derived CIE Lab color space, which is perceptually uniform and hence will be used more often for visualization purposes |
| Lab | Color in CIE Lab color space The CIE Lab color space is derived from the XYZ color space and is designed to approximate human vision |
| ImgPainter | |
| detail | |
| CVDataTypeVecEnsureDepth | |
| CVDataTypeVecEnsureDepth< T, Channels, false > | |
| CVDataTypeVecEnsureDepthAndType | |
| CVDataTypeVecEnsureDepthAndType< T, Channels, false > | |
| PowerComputer | |
| PowerComputer< T, 1 > | |
| PowerComputer< T, 0 > | |
| NoValueEnum | |
| AutoCountingHelper | |
| AutoCountingHelper< T, CountType, true > | |
| AutoCountingEnum | |
| ExtensibleEnumBase | |
| ExtensibleEnumBase< T, true, CountType, UseMutex > | |
| ExtEnum_RemoveBrackets | |
| ExtEnum_RemoveBrackets< void(T)> | |
| HasAssignHelper | |
| json | |
| JSONDefaultPrecision | JSONDefaultPrecision is a singleton that provides a mechanism to control the default precision for output of floating-point JSON values |
| QueryValueResult | A struct used for return value of getElementIfExists() |
| QueryNumberResult | A struct used for return value of getNumberElementIfExists() |
| console | |
| serialization | |
| ReflectReadSeq | Reflects generic sequential containers like vectors, list, deque (Read Only / Serialization) |
| ReflectWriteSeq | Reflects generic sequencial containers like vectors, list, deque (Write Only / Deserialization) |
| ReflectReadSetItems | |
| ReflectReadSet | Reflects generic set containers like set, multiset |
| ReflectWriteSetItems | |
| ReflectWriteSet | Deserializes generic set containers like set, multiset |
| ReadMapPairHelper | |
| WriteMapPairHelper | |
| ReflectReadMapItems | |
| ReflectReadMap | Reflects generic associative containers like map, multimap, hash_map |
| ReflectWriteMapItems | |
| ReflectWriteMap | Reflects generic associative containers like map, multimap, hash_map |
| IgnoreMissing | Marker for indicating parameters that should be ignored if they are missing in the config file |
| ReflectCollectionCount< JSONSerializer, Collection > | Specialization for JSONSerializer which does not write the item count explicitly |
| ReflectCollectionCount< JSONDeserializer, Collection > | Specialization for JSONDeserializer which counts the item nodes in the parent node to recover the item count, which is much more user friendly, since the user does not need to provide the count himself |
| ReflectCollectionCount< JSONDeserializer, std::map< std::string, mapped_type > > | |
| ReflectReadMapItems< JSONSerializer, std::map< std::string, mapped_type > > | |
| ReflectWriteMapItems< JSONDeserializer, std::map< std::string, mapped_type > > | |
| ReflectedAsPointer | For internal use only: Holds value=true, if the type T is ever reflected as pointer with Reflector within this translation unit (C file), otherwise false |
| SetReflectedAsPointer | |
| ReflectCollectionCount | Can be specialized for a concrete derived RecursiveMemberReflector to reflect the size of collections like vectors, arrays, lists, maps, etc |
| ReflectCollectionItems | Can be specialized for a concrete derived RecursiveMemberReflector to reflect the items of collections like vectors, arrays, lists, maps, etc |
| AcceptDesiredVersion | Tag class used as parameter to ReflectorInterface::version() etc |
| ReflectCallHelper | |
| __NoReflectBarrier | |
| __ReflectBarrier | |
 SplitReflectMemberHelper | |
 __reflectRead | |
| __reflectWrite | |
| BinaryJSONConverter | |
| PropertyHints | Namespace to put all PropertyHint creation functions |
| atomic | |
| singleton | |
| CreateUsingNew | Implementation of the CreationPolicy that is used by the Singleton template |
| CreateStatic | Implementation of the CreationPolicy that is used by the Singleton template |
| CreateUsing | Implementation of the CreationPolicy that is used by the Singleton template |
| Allocator | |
| NormalLifetime | Implementation of the LifetimePolicy that is used by the Singleton template |
| NoDestroyLifetime | Implementation of the LifetimePolicy that is used by the Singleton template |
| LazyInstantiation | Implementation of the InstantiationPolicy that is used by the Singleton template |
| EagerInstantiation | Implementation of the InstantiationPolicy that is used by the Singleton template |
| ExplicitInstantiation | Implementation of the InstantiationPolicy that is used by the Singleton template |
| NoLock | Implementation of the LockPolicy that is used by the Singleton template |
| Lock | |
| Volatile | |
| MutexLock | Implementation of the LockPolicy that is used by the Singleton template |
| Volatile | |
| ChannelDragnDropUtils | |
| OgreUtils | |
| QtUtils | |
| IOService | Wrapper class for boost::asio::io_service |
| MulticastSender | This class acts as a sender for multicast messages |
| SerialPort | This class acts as a wrapper to boost::asio::serial_port |
| Baudrate | An internal class for handling the baudrate |
| SQLiteDB | An exception that occurs whenever accessing the SQLite db results in an error |
| SQLiteQuery | Class representing a result of a SQLite database query |
| SQLiteCachedQuery | A cached SQLite query object that supports serialization |
| StripedStorageBase | |
| StripedStorageXML | Stores data sequentially into different files (striped) providing a reliable way to retrieve data later from one of the files even if some of the files are corrupted (e.g |
| StripedStorageBinary | |
| CallStack | Encapsulates unix call stack functionality |
| Symbol | Contains all information of a single function symbol in the call stack |
| Exception | Base class for exceptions |
| Info | The info packet that is added in MIRA_THROW and MIRA_RETHROW |
| SerializableException | |
| LogConsoleSink | Special class that uses LogTxtStreamSink as a base and cout as stream Provided for logging to console |
| LogCustomizableFilter | A customizable log filter to match the users needs |
| AndOperator | Operator class used to combine two custom filters by the & operator |
| Class | Class filter, used to filter log entries with a given class name |
| CustomFilter | Helper class to get the type info of the derived class |
| CustomFilterBase | Abstract base class for custom filters |
| Namespace | Namespace filter, used to filter log entries with a given namespace |
| OrOperator | Operator class used to combine two custom filters by the | operator |
| Severity | Severity filter, used to filter log entries with a given severity level |
| Thread | ThreadID filter, used to filter log entries with a given thread id |
| LogCustomizableFormatter | A customizable formatter |
| Class | Class format, used to write the class name of the log entry to the log format |
| CustomFormatBase | Abstract base class for all CustomFormats |
| File | File format, used to write the file of the log entry to the log format |
| Function | Function format, used to write the function name of the log entry to the log format |
| Generic | Generic format, used to write various data to the log format |
| Line | Line format, used to write the line of the log entry to the log format |
| Message | Message format, used to write the message of the log entry to the log format |
| NameSpace | Namespace format, used to write the name space of the log entry to the log format |
| Severity | Severity format, used to write the severity level of the log entry to the log format |
| Thread | ThreadID format, used to write the thread id of the log entry to the log format |
| Time | Time format, used to write the time of the log entry to the log format |
| Uptime | Uptime format, used to write the up-time of the logging core to the log format |
| LogFileSink | A logging sink for file, which supports log file rotation and daily log files |
| LogRecord | Holds all the information about a log entry |
| LogRecordFunctionInfo | Holds information about a log entry function |
| LogFormatterBase | Abstract base class for sink formatters |
| LogFilterBase | Abstract base class for log filters |
| LogSink | Abstract base class for all log sinks |
| LogCore | Single instance of the core logging class |
| Logger | Helper class that is created to make one logging process atomic and thread safe |
| LogSimpleFormatter | Very simple log formatter logging the severity level, the time and the message |
| LogTimer | Class that can be used as a stop watch to measure execution time of operations |
| LogTxtStreamSink | Simple log sink for writing to streams like cout or file It uses the SimpleFormatter for output |
| IntSignal | Structure used in signal handlers to pass the signal and callstack |
| Class | Class object which supports some kind of class reflection |
| ClassProxy | The class proxy assures that the pointer to the class object is always valid |
| ClassFactory | What should i say, the class factory |
| HasPublicDefaultConstructor | Type trait that indicates whether or not a type can be constructed using the public default constructor |
| LibraryVersion | |
| LibraryInfo | |
| LibraryRegistry | A registry for shared libraries |
| ManifestClassInfo | Simple class encapsulation parent and class information stored in a "real" class object |
| ManifestAgent | Class for managing manifest files |
| NullClass | Marker class for marking an invalid "null" class |
| PseudoClass | This is an auxiliary to enable more verbose exception messages |
| Object | The object class acts as a generic base class for classes which should be used with the classFactory |
| TClass | The TClass object is the implementation of the class class for classes which are available since the corresponding library is loaded |
| TemplateClass | The TemplateClass object is the implementation of the Class class for template classes |
| VacantClass | The VacantClass object is the implementation of the Class class for classes which are NOT available since the corresponding library is NOT loaded |
| BresenhamLineIterator | Implements an iterator that is able to iterate over a Bresenham line point by point using the prefix ++operator and –operator |
| GeneralBresenhamLineIteratorCommonBase | |
| AxisBase | Data structure containing the numtype-independent relevant variables for one axis (dimension) of the line |
| GeneralBresenhamLineIteratorBase | Guaranteeing longest axis as drive axis allows some simplification/optimization in step |
| GeneralBresenhamLineIteratorBase< Drive, false > | Specialization for DrivenByLongestAxis=false (driving axis given explicitly: No need to determine the drive axis, but stepping is a little more complex |
| GeneralBresenhamLineIterator | This more general iterator basically follows the design of BresenhamLineIterator, but works on an arbitrary-dimensional line and handles real-valued start and end positions |
| Axis | Add the type-dependent start and end value to the axis data struct |
| Circle | Represents a circle with a center and a radius |
| DistanceLUT | This class creates a look up table (LUT) to calculate the minimum and maximum Euclidean distance between a point and cells that are arranged in a regular grid |
| CellDist | A struct to store the minimal and maximal distance of the cell towards the center point |
| Region | Provides a view on a portion of the Distance LUT and can be obtained by calling DistanceLUT::getRegion() |
| Line | Represents a line segment that is spanned by two given points |
| PointBase | The base template class of point, which covers the basic functionality of each point |
| Point | General point class template |
| Point< T, 2 > | Specialization of Point for 2 dimensions with specialized constructors and converters |
| Point< T, 3 > | Specialization of Point for 3 dimensions with specialized constructors and converters |
| IsCollection< boost::geometry::model::ring< PointType > > | |
| RasterTransformation | Map a rectangular area from one raster into another, with an arbitrary transformation (scale, translation, rotation) inbetween |
| iterator | |
| RectBase | The base class for rectangles |
| Rect | Rect class for defining rectangles |
| Rect< T, 2 > | Specialization for 2D |
| Rect< T, 3 > | Specialization for 3D |
| Size | Size class for defining sizes with different data types |
| Size< T, 2 > | Specialization for 2D with special members width() and height() |
| Size< T, 3 > | Specialization for 3D with special members width(),height() and depth() |
| ColorBase | Base interface for all colors in different color spaces The class provides a base interface for all color (space) classes |
| Colormap | Base class for color colormaps |
| iterator | Iterator that can iterate over the whole color colormap similar to STL iterators on containers |
| DiscreteColormap | Base class for discrete color colormaps |
| ContinuousColormap | Base class for continuous color colormaps |
| GradientColormapBase | Internal base class for linear gradient color maps |
| GradientColormap | A class for creating continuous color maps based on linear gradients between predefined points |
| FormulaeColormapBase | Internal base class for formulae based color maps |
| FormulaeColormap | A class for creating formula based color maps |
| TabularColormap | Base class for tabular color colormaps |
| GrayscaleColormap | A continuous grayscale colormap |
| HSVColormap | A continuous HSV colormap |
| JetColormap | A continuous Jet colormap |
| RedBlueColormap | A continuous Red-Blue colormap |
| Pm3dColormap | The default pm3d gnuplot palette (black-blue-red-yellow) |
| Complementary10Colormap | A discrete colormap with 10 complementary colors |
| Complementary6Colormap | A discrete colormap with 6 complementary colors |
| ImgBase | ImgBase class |
| ImgFormat | Image storage format description (used e.g |
| ImgTypedBase | Base class for typed images |
| Img | Class for typed images |
| Img< T, 1 > | Specialized typed image with 1 channel This template class provides convenient way to create an image with known type and only 1 channel by using Img<Type> |
| Img< void, 1 > | Untyped image class This class provides a fully dynamic image, where type and channels are not known at compile time |
| IsNotMetaSerializable< Img< TPixel, TChannels > > | Mark image classes as not meta-serializable |
| ImgIteratorBase | |
| ImgConstIterator | Const image iterator that allows to iterate over images or image regions pixel by pixel similar to iterators of containers |
| ImgIterator | Image iterator that allows to iterate over images or image regions pixel by pixel similar to iterators of containers |
| UntypedImgIteratorValue | |
| UntypedImgConstIterator | Untyped const image iterator, that allows to iterate over images or image regions pixel by pixel similar to iterators of containers |
| UntypedImgIterator | Untyped image iterator, that allows to iterate over images or image regions pixel by pixel similar to iterators of containers |
| ImgPixelBase | Base interface for ImgPixel classes This class wraps typed cv::Vect to represent an ImagePixel The Vect is typed by template parameter T and channels are set by template parameter Channels |
| ImgPixel | Dynamic ImgPixel class template ImgPixel class providing flexible types and channels |
| ImgPixel< T, 1 > | Specialization of PixelBase class for 1 channel |
| ImgPixel< T, 2 > | Specialization of PixelBase class for 2 channels |
| ImgPixel< T, 3 > | Specialization of PixelBase class for 3 channels |
| ImgPixel< T, 4 > | Specialization of PixelBase class for 4 channels |
| IsAtomicSerializable< JSONValue > | |
| AngleBase | Base class template for derived Angle implementations |
| DegreeBase | Base class for angle classes that represent angles using degrees |
| RadianBase | Base class for angle classes that represent angles using radians |
| Degree | Unsigned angle that is represented using degrees |
| SignedDegree | Signed angle that is represented using degrees |
| IsTransparentSerializable< SignedDegree< T >, SerializerTag > | |
| IsTransparentSerializable< Degree< T >, SerializerTag > | |
| Radian | Unsigned angle that is represented using radians |
| SignedRadian | Signed angle that is represented using radians |
| IsTransparentSerializable< SignedRadian< T >, SerializerTag > | |
| IsTransparentSerializable< Radian< T >, SerializerTag > | |
| Angle | Unsigned angle that is represented using radians |
| SignedAngle | Signed angle that is represented using radians |
| IsTransparentSerializable< SignedAngle< T >, SerializerTag > | |
| IsTransparentSerializable< Angle< T >, SerializerTag > | |
| Deg2RadNonNegativeType | A tag type used as parameter type in deg2radSetter, signalling that negative values are not permitted |
| CRSplineInterpolator | 1D cubic Hermite spline interpolator |
| EigenFormat | Base class for formatting eigen matrices |
| TEigenFormatReadOnly | Template class wrapping the serializing functionality of eigen to support stream operators using a given format |
| TEigenFormat | Template class wrapping the serializing functionality of eigen to support stream operators using a given format |
| IncrementalMoments | Incremental computation of one- and higher-dimensional statistical moments of first and higher orders (mean and variance, etc.) |
| IncrementalMoments< T, 1, 1 > | |
| Ctx | |
| IncrementalMoments< T, 1, 2 > | |
| IncrementalMoments< T, D, 1 > | |
| Ctx | |
| IncrementalMoments< T, D, 2 > | |
| IntervalFilter | Concept and base class for all Interpolators and Filters |
| LinearInterpolator | 1D linear interpolator |
| LinearInterpolatorNoExtrapolation | 1D linear interpolator |
| LinearInterpolatorNearestNeighbourExtrapolator | 1D linear interpolator |
| LinearInterpolatorExtrapolationLimit | 1D linear interpolator |
| NearestNeighborInterpolator | 1D nearest neighbor interpolator |
| NormalRandomDistribution | Random distribution for drawing samples from univariate or multivariate normal distributions |
| NormalRandomDistribution< 1, T > | |
| NormalRandomGenerator | Random generator for drawing samples from univariate or multivariate normal distributions |
| TPower | Computes the power base^exponent at compile time |
| TPower< base, 0 > | |
| RandomGeneratorSingleton | Singleton class for generating random numbers |
| RandomGenerator | Template class to easily generate random generators using the boost::random distributions and generators |
| SchmittTriggerHysteresis | Class realizing a Schmitt trigger |
| UniformRandomGenerator | A random generator that samples random numbers within the interval that is passed to the constructor |
| NetworkTypeTrait | Trait that specifies the conversion type of a given data type |
| NetworkTypeTrait< float > | Specialization for float |
| NetworkTypeTrait< double > | Specialization for double |
| MemoryUsage | Memory usage information in kB |
| MemoryBlockInfo | Detailed information of used memory within a memory block |
| Process | Encapsulates a process, that was launched from the current process |
| Environment | Holds the environment variables that can be passed to a process |
| DeferredInvokerFinishHandler | Handler that is called when a deferred RPC call was executed and finished and therefore when the response is available |
| AbstractDeferredInvoker | Abstract interface for DeferredInvoker which is a class to support different RPC backends |
| AbstractInterfaceCallbackHandler | Abstract interface for derived handler(s) |
| AbstractRPCClient | Abstract interface for RPCClient |
| AbstractRPCHandler | Abstract interface for derived RPCHandler(s) |
| BinaryRPCBackendTempl | Provides binary client and server side requests and responses |
| ClientRequest | Binary client-side request |
| ClientResponse | Binary client-side response |
| ServerRequest | Binary server-side request |
| ServerResponse | Binary server-side response |
| JSONRPCBackend | Provides JSON client and server side requests and responses |
| ClientRequest | JSON client-side request |
| ClientResponse | JSON client-side response |
| ServerRequest | JSON server-side request |
| ServerResponse | JSON server-side response |
| JSONRPCResponse | Wraps a JSON RPC call response |
| RPCCallDefinition | Stores info required to call an RPC method - service name, method name, arguments |
| RPCClient | The RPCClient is responsible for handling the client-side of an rpc call |
| PendingResponse | PendingResponse template class |
| PendingResponseBase | Interface for PendingResponse |
| XRPC | An exception that is thrown by the RPCServer if an RPC call fails |
| RPCFutureCommon | Wrapper for boost::unique_future that is specialized for RPC processing |
| RPCFuture | An RPCFuture is a proxy for the result of an asynchronous RPC call |
| RPCFuture< void > | This is a specialization for RPC calls with the return type of void, where the get() method does not return a value |
| RPCFuture< JSONRPCResponse > | This is a specialization for JSON RPC calls |
| RPCInvoker | Base of all TRPCInvoker classes which are templates to support different RPC backends |
| TRPCInvoker | Invoker that is used to invoke an RPC method call for a special backend |
| RPCManager | This class is for internal use only |
| RemoteFinishHandler | Handler that must be implemented by the remote module to send RPC responses to a remote server which sent a previous RPC request |
| RemoteRequestHandler | Handler that must be implemented by the remote module to send RPC requests to a remote server |
| RPCServer | The RPCServer is responsible for handling the server-side of an rpc call |
| DeferredInvoker | Stores all necessary information to invoke a previously decoded and prepared RPC call |
| Method | Contains all information on a registered RPC method, including the signature of the method |
| MethodInfo | Contains information on an existing RPC method: the signature of the method, comments, etc |
| ReflectMethodParamsDocumentation | |
| ParameterInfo | Contains information on an RPC method's parameter: name, description |
| RPCReflector | Special visitor for the reflect() method that visits all method() and interface() calls within the reflect() method to collect the methods and interfaces within the above Service object |
| ServiceInfo | Contains all available information about a single RPC service, including the service' name, its registered methods and all implemented RPC interfaces |
| RPCSignature | Stores the signature of an RPC method including the methods name and its parameter types |
| AESConfiguration | The AES configuration for encryption and decryption |
| HashDigest | A generic hash digest, which consists of an array of bytes |
| HashStreamBuf | A generic hash streambuf class |
| HashStream | A template base class for hash functions based on std::ostream |
| MD5StreamBuf | The MD5 hash function |
| RSAKey | Definition of a RSA key (public or private) |
| IsTransparentSerializable< RSAKey, SerializerTag > | |
| RSASignature | A class for signing and verifying messages using a RSA key pair |
| IsTransparentSerializable< RSASignature, SerializerTag > | |
| SHA1StreamBuf | The SHA1 hash function |
| SHA256StreamBuf | The SHA256 hash function |
| AbstractReflector | Abstract base class for most Reflectors |
| ReflectComplexIntrusive | For classes with reflect method call their reflect method directly |
| ReflectComplexNonintrusive | For classes without reflect method, where we need to look somewhere else to get the information for visiting it |
| ReflectMissing | |
| AccessorGetterPartInternalRedirect | This class is used as additional reflection redirect |
| IsTransparentSerializable< AccessorGetterPartInternalRedirect< T >, SerializerTag > | |
| AccessorGetterPart | Implements the "getter part" of an Accessor |
| AccessorGetterPart< Getter< T > > | |
| AccessorSetterPart | Implements the "setter part" of an Accessor |
| AccessorSetterPart< Setter< T > > | |
| NullSetter | "Null-Setter" tag-class where the AccessorSetterPart does nothing |
| AccessorSetterPart< NullSetter< T > > | |
| Accessor | The Accessor class is used as an adapter to reduce the code bloat within the reflection and serialization implementations |
| IsTransparentSerializable< Accessor< Getter, Setter >, SerializerTag > | |
| BinarySerializerMixin | Used by BinarySerializer and BinaryDeserializer |
| StreamAccessMixinBase | Base for buffered/unbuffered stream access |
| StreamAccessMixin | Direct stream access |
| StreamAccessMixin< BinaryStream, true > | Stream access buffered through BinaryBufferOstream, can be used to work around limitations of underlying stream (in particular, missing support of tellp/seekp) |
| BinarySerializerTag | Serializer that uses BinaryOstream to serialize the objects in binary format |
| BinarySerializer | |
| ConcreteBinarySerializer | |
| SerializerFormatMixin | Used by BinarySerializer, defines the binary format in particular for class versioning information: 0 = version numbers are stored inline in binary data when version() is called; 1 = same as version 0, except that version 1 (as all following versions) explicitly stores version number at the beginning of serialized data; 2 = the positions in binary data are fixed where each object part stores its version number (or a placeholder if not versioned [yet]!) |
| SerializerFormatMixin01Base | |
| SerializerFormatMixin< BinaryStream, 0, Buffered, StreamType > | |
| SerializerFormatMixin< BinaryStream, 1, Buffered, StreamType > | |
| SerializerFormatMixin< BinaryStream, 2, Buffered, StreamType > | |
| BinaryDeserializer | Deserializer that uses BinaryIstream to deserialize the objects from binary format |
| ConcreteBinaryDeserializer | |
| DeserializerFormatMixin | Used by BinaryDeserializer, see SerializerFormatMixin above |
| DeserializerFormatMixin01Base | |
| DeserializerFormatMixin< BinaryStream, 0 > | |
| DeserializerFormatMixin< BinaryStream, 1 > | |
| DeserializerFormatMixin< BinaryStream, 2 > | |
| BinarySerializerCodec | Abstract base class for codecs that can be used with BinarySerializer and BinaryDeserializer |
| Fourcc | A four-character code that is used to identify data formats and codecs |
| DefaultInitializer | Reflector that visits the reflect method of objects in order to initialize them using the specified default values |
| Deserializer | Is a special reflector that is used for deserialization |
| Getter | Holds a boost::function object to a special getter function that must meet the signature "T method()" |
| IsTransparentSerializable< Getter< T >, SerializerTag > | |
| Setter | Holds a boost::function object to a special setter function that must meet the signature "void method(T)" |
| IsTransparentSerializable< Setter< T >, SerializerTag > | |
| IsAtomicSerializable | Type trait that indicates whether a type can be serialized as an atomic value |
| IsAtomicSerializable< std::basic_string< CharT, Traits, Alloc > > | |
| IsBitwiseSerializable | Type trait that indicates whether a type can be serialized bitwise by just copying the data buffer |
| IsCollection | Type trait that indicates whether a type is a collection |
| IsNotMetaSerializable | Type trait that indicates whether a type does not support to gather meta information about it, e.g |
| IsObjectTrackable | Type trait that indicates whether pointer tracking can be enabled for this type |
| IsPointerOrSharedPointer | Type trait that indicates whether a type is a pointer type or a shared pointer |
| IsPointerOrSharedPointer< boost::shared_ptr< T > > | |
| IsPointerOrSharedPointer< std::shared_ptr< T > > | |
| IsTransparentSerializable | Type trait that indicates whether a type should be serialized "transparently", i.e |
| IsTransparentSerializableHelper | |
| JSONSerializer | Serializer for serializing objects in JSON format |
| JSONDeserializer | Deserializer for serializing objects from JSON format |
| TypeMeta | Meta Type information |
| MethodMeta | Meta information for RPC methods |
| Parameter | |
| CompoundMeta | Meta information for complex compounds, like classes and structs |
| Member | A single member of the compound |
| MetaTypeDatabase | Database that stores all meta type information and provides additional functions for accessing the database |
| IsCollection< MetaTypeDatabase > | |
| MetaSerializer | |
| TypeWithoutObjectAbstractHelper | |
| TypeWithoutObjectAbstractHelper< T *, true > | |
| TypeWithoutObjectAbstractHelper< T, true > | |
| TypeWithoutObjectHelper | |
| TypeWithoutObjectHelper< T *, true > | |
| TypeWithoutObjectHelper< T, true > | |
| PropertyHint | A property hint gives optional instructions to the property editor, i.e |
| PropertyManager | The property manager maintains the properties of objects that are added to the manager |
| TypedPropertyNode | Abstract base class for all typed property nodes |
| PropertyNodeInfo | |
| PropertyNode | Abstract base class for all derived property node classes |
| PropertyNodeListener | |
| RootPropertyNode | A special node that acts only as (empty) root node for a property tree |
| LockedPropertyNodeAccessCommon | |
| LockedPropertyNodeAccess | |
| LockedPropertyNodeAccess< NodeType, ValueType, false, true > | |
| LockedPropertyNodeAccess< NodeType, ValueType, true, false > | |
| LockedPropertyNodeAccess< NodeType, ValueType, true, true > | |
| TypedPropertyNodeImplGetSetMixinBase | |
| TypedPropertyNodeImplGetSetMixin | Partial Implementations of the get/set of TypedPropertyNode specialized for normal classes / for classes that are not copyable |
| TypedPropertyNodeImplGetSetMixin< T, false > | |
| TypedPropertyNodeImpl | Implementation of TypedPropertyNode |
| TypedPropertyNodeImpl< T * > | Implementation of TypedPropertyNode for pointers |
| TypedPropertyNodeImpl< Accessor< Getter, Setter > > | Implementation of TypedPropertyNode for Accessors, i.e |
| AbstractRemotePropertyNode | Special derived class of PropertyNode, that allows to handle "remote
properties" transparently |
| TypedRemotePropertyNode | Special TypedPropertyNode for remote properties |
| PropertyReflector | Base class for all Reflectors that take care of properties |
| PropertySerializer | A special PropertyReflector that creates a PropertyNode for each reflected property |
| PropertyTree | Helper class that is able to hold a complete property tree structure |
| XMemberNotFound_NoDefault | Can be thrown by subclasses of RecursiveMemberReflectorBase to indicate that they did not find a certain member, e.g |
| RecursiveMemberReflectorBase | The RecursiveMemberReflectorBase is a base class for all Reflectors that are used to visit the reflect methods of the classes recursively in order to collect information on the members of these classes |
| ChooseReflect | Detect the members type (A1,A2,A3,B1,B2,C) and choose the appropriate struct ReflectAtomic, etc |
| ReflectArray | Type A3: for arrays |
| ReflectAtomic | Type A1: for atomic members (float,int,etc.) |
| ReflectCollection | Type B?c: for collection types |
| ReflectComplex | Type B1/B2: for complex types |
| ReflectEnumeration | Type A2: for enums |
| ReflectPointer | Type C: for members that are pointers |
| ReflectPointerAbstract | Type C3: for members that are pointers to abstract classes not derived from mira::Object |
| ReflectPointerNormal | Type C1: for members that are pointers to normal classes |
| ReflectPointerPolymorphic | Type C2: for members that are pointers to polymorphic classes derived from mira::Object |
| ReflectUnknown | |
| RecursiveMemberReflector | The RecursiveMemberReflector extents the RecursiveMemberReflectorBase class and implements the member() and property() methods of the ReflectorInterface class by calling the appropriate methods of RecursiveMemberReflectorBase |
| ReflectMemberMeta | Stores meta information for each member |
| ReflectorInterface | This is the public interface of all reflectors that are able to visit a class' reflect() method |
| ReflectState | If 'reflect barriers' are used, each separated reflection block within an object has a separate state (defined by the Reflector) |
| Tag | |
| Serializer | Is a special reflector that is used for serialization |
| AObject | Is used to store the type and the address of all previously serialized objects in a map |
| XMLSerializerTag | Serializer for serializing objects in XML format |
| XMLSerializer | |
| XMLDeserializer | Deserializer for serializing objects from XML format |
| BinaryIosBase | Helper class that is a base for binaryostream and binaryistream in the same way as ios_base is a base of ostream and istream |
| BinaryBufferStreamBase | Although this class is not a template we must keep its methods inline for performance reasons! write() and read() are called very often! |
| BinaryOstream | Output stream adapter that can be assigned to any output stream and allows binary output using the << stream operators |
| BinaryIstream | Input stream adapter that can be assigned to any input stream and allows binary input using the >> stream operators |
| BufferStream | A stream class for input and output of data to/from a wrapped Buffer |
| gzstreambuf | |
| gzstreambase | |
| igzstream | Use igzstream and ogzstream analogously to ifstream and ofstream respectively |
| ogzstream | Use igzstream and ogzstream analogously to ifstream and ofstream respectively |
| NumericalOstream | Numerical stream adapter that can be assigned to any output stream and allows streaming of numerical values |
| NumericalIstream | Numerical stream adapter that can be assigned to any input stream and allows streaming of numerical values |
| CyclicRunnable | This class extends threads by the ability to execute an operation repeatedly in an defined interval |
| ScopedAccessBase | Base class for ScopedAccess with external or Protectee-internal mutex |
| ScopedAccess | Grants thread-safe access to an object (the Protectee) that should be protected from concurrent access |
| ScopedAccess< Protectee, void > | Specialization for Mutex=void, i.e |
| ProtecteeMixin | Mixin class that can be used to add the Protectee concept used by ScopedAccess<Protectee(, void)> to an existing class |
| Spinlock | A spinlock is similar to a mutex and allows thread synchronization of critical sections |
| ThreadMonitor | A thread monitor class |
| ThreadInfo | A thread information type |
| PoseVectorTrait | Typetrait that returns the correct vector type, that depends on whether the Eigen-datatypes of the pose need an alignment or not |
| PoseVectorTrait< Pose3 > | |
| PoseVectorTrait< PoseCov3 > | |
| RigidTransform | This class represents an affine transformation that supports a translation followed by a rotation (a so called rigid transform) |
| RigidTransformCov | This class represents an affine transformation that supports a translation followed by a rotation (a so called rigid transform) |
| RigidTransformBase | Implementation of RigidTransforms with different dimensionality D |
| RigidTransform< T, 2 > | Specialization of RigidTransform for 2 dimensions |
| RigidTransformCov< T, 2 > | Specialization of RigidTransformCov for 2 dimensions |
| RigidTransform< T, 3 > | Specialization of RigidTransform for 3 dimensions |
| RigidTransformCov< T, 3 > | Specialization of RigidTransformCov for 3 dimensions |
| TransformerBase | Base class for Transformer to decouple base functionality that is type independent from type dependent Transformer class template |
| Chain | Represents a chain or path through the transformation tree from a staring node to the target node containing nodes whose transforms need to be applied inverse and nodes whose transforms need to be applied forward |
| TransformDesc | Describes a path of transformations through the transformation tree |
| GenericTransformer | A generic transformer base class that can be used with different types of actual transformation nodes |
| Transformer | A full features transformer class based on GenericTransformer |
| AbstractTransformerNode | Abstract base class where all other different types of transformation nodes must be derived from |
| TransformerNode | Basic reference implementation of an AbstractTransformerNode that stores the transformation data internally in a StampedDataQueue that allows to query the transformation at specific time stamps |
| Buffer | Generic buffer class that can be used as a replacement for std::vector whenever copying and reallocation of internal array buffer needs to be avoided |
| IsObjectTrackable< Buffer< T, Allocator > > | |
| IsCollection< Buffer< T, Allocator > > | |
| ExtensibleEnum | ExtensibleEnum is a base for derived classes that can be extensible 'replacements' for enum types |
| ExtensibleEnum< T, true, Counting, CountType, UseMutex > | |
| has_assign | Evaluates to std::true_type, if U can be assigned to T, i.e |
| IsCopyAssignable | Type trait that evaluates to true if a type is copy assignable, false otherwise |
| IsDefaultConstructible | IsDefaultConstructible<T>::value evaluates to true, if T is default constructible, otherwise false |
| IteratorRangeContainer | Wraps an STL conform container around a range of values within another container |
| MakeString | Class for in-place stream formatting Used for constructs like: |
| IsTransparentSerializable< Path, SerializerTag > | |
| PoolAllocator | Provides a pool allocator that is compatible to STL allocators |
| Profiler | The main Profiler class |
| Scope | |
| ProgramOptions | A central singleton class for accessing command line parameters Underlying class is boost::program::options see http://www.boost.org/doc/libs/1_44_0/doc/html/program_options.html Usage: |
| Registrar | A template class that creates a static instance of TRegistrar |
| SharedLibrary | Class for loading a single shared library |
| SharedLibraryLoader | Class for loading multiple shared libraries |
| Singleton | A singleton template class that can be freely configured using policies that control the instantiation, creation, lifetime and thread-safety |
| LazySingleton | Provided for convenience |
| EagerSingleton | Provided for convenience |
| ExplicitSingleton | Provided for convenience |
| LazySingletonNoLock | Provided for convenience |
| EagerSingletonNoLock | Provided for convenience |
| StampedHeader | The common header for all stamped data |
| Stamped | Mix in for adding a time stamp, an optional frame id and an optional sequence id to data types like Pose, RangeScan, etc |
| Stamped< T * > | Stamped class specialization for polymorphic pointers |
| StampedPrimitive | Stamped class for primitive types like int, float, etc |
| StampedDataQueue | Implements a queue where Stamped data can be added |
| Duration | Use this class to represent time durations |
| Time | Wrapper class for boost::posix_time::ptime for adding more functionality to it |
| IsTransparentSerializable< Time, SerializerTag > | |
| IsTransparentSerializable< Duration, SerializerTag > | |
| IsTransparentSerializable< Date, SerializerTag > | |
| FromHex | Can be used with fromString to convert hex strings into numbers |
| ToHex | Can be used with toString to convert values to their string hex representation |
| FromOct | Can be used with fromString to convert oct strings into numbers |
| ToOct | Can be used with toString to convert values to their string oct representation |
| TypedVoidPtr | Class that allows to maintain type-safety when passing void pointers |
| TypedVoidConstPtr | Same as TypedVoidPtr but const |
| IsAtomicSerializable< UUID > | |
| XMLDom | A STL conform wrapper for libxml2 to read XML files as DOM |
| attribute_iterator | Iterator for iterating over attributes |
| const_attribute_iterator | Const iterator for iterating over attributes |
| const_data_iterator | Const iterator for iterating over data nodes |
| const_sibling_iterator | Const sibling_iterator for iterating over xml nodes that have the same parent (siblings) |
| data_iterator | Iterator for iterating over data nodes |
| iterator_base | Base iterator for iterating over xml nodes with the same parent (siblings) |
| NameSpace | Namespace information of a node |
| sibling_iterator | Iterator for iterating over xml nodes that have the same parent (sibligs) |
| XMLVariableValue | Variables defined in xml documents |
| XMLDomPreprocessor | Preprocesses XML documents and resolves all special tags like , <if>, <warning> and so on |
| IsTransparentSerializable< XMLDom, SerializerTag > | |
| IsTransparentSerializable< XMLDom, XMLSerializerTag > | |
| ChannelContentChange | Class that can be registered as a filter when subscribing to channels to only get a callback when the content of the channel changes |
| ChannelHysteresis | Class that can be registered as a filter when subscribing to channels to only get a callback when the state of the hysteresis trigger changes |
| ChannelInterval | Class that can be registered as a filter when subscribing to channels to only get a callback in a specified interval |
| ChannelSynchronizerBase | |
| ChannelSynchronizer | |
| ChannelVectorSynchronizer1 | Class that can be registered as a filter when subscribing to more than one channel to only get a callback when all channels have data with a similar timestamp (differ only in the specified tolerance) |
| AbstractAuthority | This is the abstract base class of local and remote authority classes |
| AbstractChannel | |
| AbstractChannelSubscriber | |
| Authority | Authorities act as a facade to the framework |
| RWAccessFlags | Channel access flags |
| AuthorityDescription | This is the descriptive part of an authority |
| SharedAuthority | A wrapper providing locked/shared access to an AbstractAuthority pointer (used by AuthorityManager::getAuthority()) The lifetime of the AbstractAuthority object the pointer points to is ensured as long as one wrapper instance exists that wraps the same AbstractAuthority pointer |
| AuthorityManager | Central instance that stores all created Authorities |
| IAuthorityProvider | Abstract interface for classes that can provide an authority via the getAuthority() method |
| AuthorityRuntime | This class contains threading functionality that can be shared among different authorities so that all of them use the same thread (dispatcher thread) |
| Channel | An exception that occurs whenever a channel has no data |
| ChannelBufferPromoterCommon | Forward decl |
| ChannelBufferPromoter | Forward decl |
| ChannelBufferBase | Base class that manages the slots of channels by providing read and write access to them |
| ListItem | Implements double-linked list item |
| Slot | Container for storing a single data element in the linked list |
| TypedChannelBufferBase | Base class for typed channel buffers |
| Slot | Typed slot derived from ChannelBufferBase::Slot |
| ChannelBuffer | Typed ChannelBuffer |
| ChannelBuffer< void > | Specialization for void (Untyped ChannelBuffer), which only holds the StampedHeader |
| Slot | Typed slot derived from ChannelBufferBase::Slot |
| PolymorphicChannelBuffer | A channel buffer for polymorphic types (classes derived from mira::Object) |
| ChannelBuffer< T * > | Specialization for polymorphic types (only classes derived from mira::Object are supported!) |
| ChannelBufferPromoter< U * > | Specialization of ChannelBufferPromoter for polymorphic pointer channel buffers |
| ChannelManager | An exception that occurred whenever a channel does not exist |
| ChannelInfo | Informations about a channel that also provides ordering of channels by id |
| ChannelReadInterval | An object that allows read access to a whole interval of channel data |
| const_iterator | Const iterator for iterating over the interval |
| ConcreteChannel | |
| ChannelReadWriteTraits | |
| ChannelReadWriteShared | Internally used by ChannelReadWriteBase! It contains the information about the channel and slot that can be shared between different ChannelRead/Write objects |
| ChannelReadWriteCommonBase | |
| ChannelReadWriteBase | |
| ChannelReadWriteBase< Derived, void > | Specialization for untyped channels which just return the StampedHeader as data |
| ChannelRead | An object that allows read access to data of a channel |
| ChannelWrite | An object that allows exclusive write access to data of a channel |
| ChannelReadWriteTraits< ChannelRead< T > > | |
| ChannelReadWriteTraits< ChannelWrite< T > > | |
| ChannelReadWriteTraits< ChannelRead< void > > | |
| ChannelReadWriteTraits< ChannelWrite< void > > | |
| ChannelSubscriber | Implements AbstractChannelSubscriber for a concrete data type |
| DiscoverService | Service that is used to discover other running frameworks in the same network using multicast on |
| AnnounceMessage | |
| IteratablePriorityQueue | |
| DispatcherThread | Class that can be used whenever you want to have ONE thread where several handlers are assigned to |
| QueueItem | XXX |
| Timer | Class representing timers and tasks that can be registered and executed by the dispatcher thread |
| XUnrecoverableFailure | Exception that can be thrown in every handler to indicate an unrecoverable failure |
| ErrorService | Class that allows to store errors persistently in a SQLite database |
| Error | Error informations |
| Framework | This class represents the core element of a modular application |
| FrameworkGraphMixin | |
| FrameworkGraphMixin< C, void > | |
| FrameworkGraph | Represents the whole computation graph with all known units/authorities and channels within their namespaces |
| AuthorityNode | Represents a single authority in the framwork computation graph |
| ChannelNode | Represents a single channel in the framwork computation graph |
| FrameworkNode | Represents a framework in the framework computation graph |
| NamespaceNode | Represents a namespace in the framework computation graph within the overall namespace hierarchy |
| Node | Base class for all nodes in the framework computation graph |
| FrameworkMessageHeader | Data that is sent as header in each message between remote frameworks |
| FrameworkTransformerNode | |
| IFrameworkTransformer | IFrameworkTransformer defines RPC methods provided by FrameworkTransformer |
| IFrameworkTransformerLinkType | Extension of IFrameworkTransformer supporting link types |
| FrameworkTransformer | |
| FrameworkTransformReadAccessor | |
| FrameworkTransformReadAccessor< ChannelTransformType, NearestNeighborInterpolator > | |
| FrameworkTransformReadAccessor< ChannelTransformType, LinearInterpolator > | |
| FrameworkTransformReadAccessor< ChannelTransformType, LinearInterpolatorNoExtrapolation > | |
| FrameworkTransformReadAccessor< ChannelTransformType, LinearInterpolatorNearestNeighbourExtrapolator > | |
| FrameworkTransformReadAccessor< ChannelTransformType, LinearInterpolatorExtrapolationLimit > | |
| FrameworkTransformWriteAccessor | |
| MicroUnit | Units are basic modules of a complex application |
| NameRegistry | Stores aliases for namespaces and allows to resolve local names to global fully qualified names |
| PerformanceStatistics | |
| RemoteAuthorityPropertyUpdater | |
| RemoteAuthorityRootPropertyNode | |
| RemoteAuthority | A remote authority is located in another framework |
| KnownFramework | Information and settings for a known remote framework |
| IsTransparentSerializable< KnownFramework, SerializerTag > | |
| TimeOffsetCompensation | |
| RemoteConnection | Base class of connections between frameworks |
| RPCRemoteFinishHandler | RPCHandler for getting notified when an rpc call on server side is finished and the response is ready |
| RPCRemoteRequestHandler | RPCHandler for sending a rpc call to the server side |
| SendData | |
| ConcreteRemoteConnection | |
| RemoteIncomingConnection | Connection class for incoming connections |
| RemoteOutgoingConnectionBase | Connection class for outgoing connections |
| ConcreteRemoteOutgoingConnection | |
| RemoteConnectionProxy | A proxy object that represents a connection |
| IsTransparentSerializable< RemoteConnectionProxy, SerializerTag > | |
| RemoteConnectionPool | Owner of every RemoteConnection |
| RemoteModule | Manages connections to other remote frameworks |
| AuthSettings | Contains the authentication settings |
| IsCopyAssignable< RemoteModule::ConnectionMap > | |
| RemoteServer | Server class handling incoming connections from remote frameworks |
| ResourceName | Class for storing/combining/managing resource names consisting of namespaces and names separated by '/' Resource names can be combined and normalized |
| IsTransparentSerializable< ResourceName, SerializerTag > | |
| RPCHandler | RPCHandler implements an AbstractRPCHandler |
| InvokerRunnable | |
| IRunnable | Base for all runnable classes that can be signaled when they need to run again |
| DiagnosticRunnable | |
| FunctionRunnable | Runnable that wraps any function pointer |
| ServiceInterfaceHandler | ServiceInterfaceHandler implements a AbstractInterfaceCallbackHandler |
| ServiceLevelBase | QoS management information for channels |
| ServiceLevel | ServiceLevel by channel name |
| TypeServiceLevel | ServiceLevel by channel type |
| ServiceProperty | Use this class instead of a string property whenever your module has a service as property |
| Status | Status entry class |
| DiagnosticsModule | Base class for modules that want to use diagnostics and set the current status |
| StatusManager | Manages the status of one or multiple modules inheriting from DiagnosticsModule |
| Tape | A tape is a binary file that contains recorded/serialized data of one or multiple channels |
| ChannelInfo | Information about a channel in a tape |
| FileInfo | Information about a tape file |
| Header | Header containing type and size of the following packet |
| Message | Struct for message data in a tape |
| MessageBlock | Struct for a message block in a tape |
| MessageIndex | Index entry for a message in the tape |
| TapePlayer | Class for playing back tape files |
| RecordedChannelInfo | Contains all settings for a recorded channel like compression, codecs,.. |
| TapeRecorderConfig | A config that can be passed to the TapeRecorder which contains all settings that should be used for recording |
| TapeRecorder | Class for recording channel data to tape |
| ChannelInfo | Informations about a recorded channel |
| TapeVisitor | Visitor class to inspect tapes by channels and/or time interval |
| iterator | Iterator to iterate over all messages in all tapes visited by the visitor |
| MessageInfo | Info about a message entry in a tape |
| MessageInstance | Instance of a message from a tape |
| TransformProperty | Use this class instead of a string property whenever your module has a transform frame as property |
| IsTransparentSerializable< TransformProperty, SerializerTag > | |
| IsObjectTrackable< TransformProperty > | |
| Unit | A more complex unit that adds a default timer to the thread dispatcher of the authority that acts as a worker thread (process()) |
| UnitManager | Class managing micro units and units |
| ConfigurationPreparePlugin | Base class for prepare plugins |
| ConfigurationLoaderPlugin | Base class for loader plugins |
| ConfigurationLoader | Class for loading, parsing, modifying and interpreting application configuration files |
| FrameworkWithGui | |
| Application | Implements our own Application derived from QApplication in order to overwrite the notify method |
| QtUnit | A unit that processes its dispatcher within Qt's main thread |
| TapeFileDialog | |
| TapePlayerWidget | |
| CodecDialog | A dialog for adding, removing and editing codecs |
| CodecWidget | Widget for displaying used codecs and changing them via a dialog |
| DurationDialog | A dialog for selecting a duration |
| TapeRecorderWidget | The recorder widget |
| RecordingConfig | |
| IAdaptable | An interface for an adaptable object |
| EditorPart | An editor is typically used to edit or browse data or objects |
| EditorPartArea | This is a replacement for QMdiArea |
| EditorPartAreaTabBar | |
| EditorPartTitleBar | |
| EditorPartWindow | |
| PageViewPart | Special view part for multi-page workbench views |
| IPartListener | |
| PerspectiveTabBar | |
| PerspectiveTabWidget | |
| TitleBar | Base class for all window title bars (EditorPartTitleBar, ViewPartTitleBar) |
| ViewPart | A view is typically used to display information or properties |
| ViewPartTitleBar | |
| WidgetResizeHandler | |
| Workbench | |
| MinimizedDockArea | |
| MinimizedDockWidgetState | |
| Perspective | |
| IWorkbenchPartSite | The primary interface between a workbench part and the workbench |
| IWorkbenchPart | |
| WorkbenchPart | A workbench part is a component within the workbench |
| PropertyView | This view part provides an editor/viewer for properties of other views |
| PropertyViewPage | PropertyViewPage page |
| Visualization2DView | 2D view of a scene that may contain different visualization objects which show the actual content of the scene |
| UI | |
| Visualization3DView | 3D view of a scene that may contain different visualization objects which show the actual content of the scene |
| VisualizationControl | View part for managing (adding, removing and editing properties) visualizations of the currently focused visualization view |
| VisualizationControlPage | VisualizationControl page |
| VisualizationTextItem | |
| DefaultTextVisualizationBase | |
| TypedDefaultTextVisualizationBase | |
| VisualizationView | Abstract base class for 2D, 3D, text and plot visualization views (namely Visualization2DView and Visualization3DView...) |
| VisualizationViewTransformable | Abstract base class for 2D, 3D, text and plot visualization views (namely Visualization2DView and Visualization3DView...) that support a target frame |
| CameraOrbitTool2D | |
| PointVectorObject | |
| PathPointItem | |
| PolygonTool2D | |
| PoseTool2D | |
| ArrowObject | |
| AxesCovObject | Visualization of covariances for AxesObject |
| AxesObject | |
| AxesVisualization | |
| CameraOrbitTool3D | |
| CovObject | Visualization of covariances |
| DynamicPoints | |
| PointData | |
| DynamicRenderable | Abstract base class for renderables based on dynamically growing vertex and index buffers |
| GridObject | |
| ImageObject | |
| LineListObject | Renders a line strip as billboard chain |
| LineStripObject | Renders one or more line strips |
| MeshFactory | Singleton that allows to load arbitrary meshes from file in different formats |
| MeshFormatInfo | Provides information for each format including a human readable description (e.g |
| MeshLoader | |
| MeshObject | |
| PolygonObject | |
| PolygonTool | Tool base class for selecting a polygon in the xy-plane of a 3D scene (in a Visualization3DView) |
| PoseTool | Tool base class for selecting a PoseCov2 pose in the xy-plane of a 3D scene (in a Visualization3DView) |
| InputModeOrientation | |
| InputModePosition | |
| RectObject | |
| RectTool3D | Tool base class for selecting a Rect2f rect in the yx-plane of a 3D scene (in a Visualization3DView) |
| SceneQueryTool | |
| TextObject | |
| VisualizationObject | |
| ChannelPropertyBase | Base class for ChannelProperty template class |
| ChannelPropertyProxy | Proxy class that is returned/set by the getter and setter methods of ChannelProperty |
| IsObjectTrackable< ChannelPropertyProxy > | |
| ChannelProperty | The concrete typed ChannelProperty template class |
| ChannelPropertyDelegateLineEdit | Special LineEdit for ChannelProperty delegate for Property Editor |
| ColormapProperty | A special property class that can be used as member, if you want to provide a ComboBox where the user is able to select the available and registered color colormaps |
| IsTransparentSerializable< ColormapProperty, SerializerTag > | |
| ColormapPropertyComboBox | |
| IndexSelectorPropertyBase | Base for template class IndexSelectorProperty |
| IndexSelectorProperty | A special property class that can be used to provide a mechanism for selecting an element by index from data representing a set of similar objects |
| IsTransparentSerializable< IndexSelectorProperty< true >, SerializerTag > | |
| IndexSelectorProperty< false > | Explicit specialization for Transparent=false (different reflect() method) |
| InteractionListener3D | Listener for mouse events on movable objects in a 3D view |
| VisualizationTextBase | |
| VisualizationTextJSONBase | |
| IVisualizationSite | The primary interface between a Visualization and the container of the visualization (e.g |
| IVisualizationSiteTransformable | The interface between a Visualization and the container of the visualization (e.g |
| Visualization | Abstract base class for all derived visualizations, namely Visualization3D and Visualization2D |
| DataConnection | The data structure that is returned by getDataConnection |
| IVisualization2DSite | |
| Camera | |
| Visualization2D | Abstract base class for all 2D visualization that are used by Visualization2DView |
| Visualization2DBasic | Inherit from this class if you want to implement a simple 2D visualization |
| Visualization2DContainer | |
| IVisualization3DSite | The interface of a Visualization3DSite |
| Camera | |
| Visualization3D | Abstract base class for all 3D visualization that are used by Visualization3DView |
| Visualization3DBasic | Inherit from this class if you want to implement a simple 3D visualization |
| Visualization3DContainer | A standalone container for 3D visualizations, similar to Visualization3DView but as lightweight standalone widget instead of a view within the RCP framework |
| VisualizationRegistry | Stores mappings from type names to Visualization classes of Visualizations that are able to show the data |
| Entry | |
| IVisualizationTextItem | |
| IVisualizationTextSite | |
| VisualizationText | Abstract base class for all text visualization |
| VisualizationTextBasic | |
| IVisualizationTextTraceItem | |
| IVisualizationTextTraceSite | |
| VisualizationTextTrace | Abstract base class for a text visualization tracing the data history |
| VisualizationTextTraceBasic | |
| VisualizationTool | |
| VisualizationTool2D | |
| VisualizationTool3D | |
| CollapsibleTreeHeader | Header for tree widgets with additional collapse/expand button in the first column |
| FlowLayout | Layout, where the items are first laid out horizontally and then vertically when each line in the layout runs out of space |
| ImgWidget | A widget that visualizes an Img |
| IMouseListener | The mouse listener interface that can be implemented to react on user interaction |
| LineEditClear | Provides a QLineEdit widget that has a small button on its right side for clearing the content |
| MultiInputDialog | |
| OgreSingletonHelper | |
| OgreWidget | |
| OgreWidgetEx | Extended version of OgreWidget that provides default setup of Ogre components (scene manager, light, camera, etc.) and hence provides a ready-to-use playground for 3D rendering |
| Pose2LineEdit | |
| PropertyEditor | Provides display and editing facilities for property items in the editor |
| SupportedType | |
| PropertyItemEditor | |
| QConsolePopupCompleter | Popup Completer class |
| QConsole | An abstract Qt console |
| ScrollView | ScrollView extends the QAbstractScrollArea by features like automatic scaling of scrollbars, signals when the visible are was moved and so on |
| SelectionListDialog | A dialog for providing the a list, where the items can be grouped in categories |
| SignalBinder | Class that provides different slots with different parameters |
| SingleSelectionListDialog | A dialog for providing the a list, where the items can be grouped in categories |
| SpinBoxDelegate | Delegate for a QTableWidgetItem (or any model-view item for that matter) |
| SplashScreen | Widget provides a splash screen that can be shown during application startup |
| TextEditAutoCompletion | |
| TreeViewFilter | |
| Ogre | |
| std | STL namespace |
| is_placeholder< placeholder_template< N > > | |
| placeholder_template | |
1.8.5
