MMM Namespace Reference

A template that can be used as a superclass of a class hierarchy that wants to provide a factory method which allows instantiation of objects based on a string identifier. More...

Data Structures
class	AbstractFactoryMethod
class	AbstractMotion
	An interface for all motion classes. More...
class	AbstractMotionSegment
class	ActionLabelAnnotation
class	ActionLabelAnnotationFactory
class	ActionObject
class	AnnotationFactory
class	AttachedSensor
class	BasicKinematicSensor
class	BasicModelPoseSensor
class	BasicSensor
	The templated interface with already implemented methods for implementing new sensor classes. More...
class	BimanualAnnotationFactory
class	CommentEntry
class	Converter
	An interface for all converter classes. A converter maps an input motion to an output motion. Two main applications are intended with converters. More...
class	ConverterFactory
class	CustomPose
class	CustomSensor
class	CustomSensorFactory
class	CustomSensorMeasurement
struct	DetectorContext
class	EnvironmentalContactSensor
class	EnvironmentalContactSensorFactory
class	EnvironmentalContactSensorMeasurement
class	FactoryPluginLoader
	A templated class for easy plugin loading from libraries with unique ids. More...
class	Force1DSensor
class	Force1DSensorFactory
class	Force1DSensorMeasurement
class	Force3DSensor
class	Force3DSensorFactory
class	Force3DSensorMeasurement
class	IAttachedSensor
class	IMUSensor
class	IMUSensorFactory
class	IMUSensorMeasurement
class	InterpolatableSensor
	The templated interface with already implemented methods for implementing new interpolatable sensor classes. More...
class	InterpolatableSensorMeasurement
	Template for interpolatable sensor measurements. More...
class	KinematicSensor
class	KinematicSensorConfiguration
class	KinematicSensorFactory
class	KinematicSensorMeasurement
class	LegacyMarkerData
	A data entry of a MarkerMotion. More...
class	LegacyMotion
	A Motion defines a series of MotionFrame snapshots. More...
class	LegacyMotionConverter
	Converter for create a motion from the model pose and kinematics of a legacy motion. More...
class	LegacyMotionReaderC3D
	This legacy reader parses a Vicon C3D data file and creates a MarkerMotion object. More...
class	LegacyMotionReaderXML
	The generic XML reader for legacy MMM motions. The following XML tags are initially supported by this reader: "comments", "description","joint_order","motion". Custom tag processors can be registered in order to read other data. Unknown tags are ignored by default. More...
struct	LoadModelStrategy
class	MarkerBasedConverter
class	MarkerData
	Stores three-dimensional position of unlabeled and labeled motion capture markers. More...
class	MarkerMotion
	This calls defines a Cartesian motion of a set of markers. More...
class	MoCapMarkerSensor
class	MoCapMarkerSensorFactory
class	MoCapMarkerSensorMeasurement
class	ModelPoseSensor
class	ModelPoseSensorFactory
class	ModelPoseSensorMeasurement
class	ModelProcessor
	A processor to adapt a generic model to user specific demands. More...
class	ModelProcessorFactory
class	ModelProcessorFactoryWinter
class	ModelProcessorWinter
class	ModelReaderXML
	This reader parses a model file in order to generate an MMM Model. The model syntax is compatible with the Simox::VirtualRobot package. More...
class	Motion
	Stores a recorded motion with a corresponding virtual model and real measurements. More...
class	MotionAnnotation
	The public interface for the annotation classes. More...
class	MotionContactDetector
class	MotionEntry
class	MotionFrame
class	MotionFrameEntry
class	MotionObserver
class	MotionReaderC3D
	This reader parses a Vicon C3D data file and creates a PrefixMarkerData object. More...
class	MotionReaderXML
	A generic xml reader for motions in the mmm dataformat. More...
class	MotionRecording
class	MotionRecordingContactDetector
class	MotionRecordingSegment
class	MotionSegment
class	MotionSegmentation
class	MotionSegmentObserver
class	MultipleFactoryPluginLoader
	A templated class for easy plugin loading from libraries having same ids but different locations. More...
class	NaturalLanguageAnnotation
class	PrefixMarkerData
	Stores motion capture data at certain times grouping them by their motion prefix in the c3d file. More...
class	ProcessedModelWrapper
class	RootOrientation
	A standard entry: The root orientation as RPY angles. More...
class	RootOrientationAcc
	A standard entry: The acceleration of the root Orientation. More...
class	RootOrientationVel
	A standard entry: The velocity of the root orientation. More...
class	RootPosition
	A standard entry: The root position (3d) of the model given in millimeters. More...
class	RootPositionAcc
	A standard entry: The acceleration of the root position. More...
class	RootPositionVel
	A standard entry: The velocity of the root position. More...
class	SegmentationFactory
class	Sensor
	The public interface for the sensor classes. More...
class	SensorFactory
class	SensorMeasurement
	The public interface for the sensor measurement classes. More...
class	SMCloneable
struct	TestHelper
class	UnknownMotionAnnotation
class	UnknownSensor
	Models unknown sensor types loaded from XML. More...
class	UnknownSensorMeasurement
	Models unknown sensor measurements loaded from XML. More...
class	UnlabeledMarkerData
	A data entry of an UnlabeledMarkerMotion. More...
class	UnlabeledMarkerMotion
class	WholeBodyDynamicSensor
class	WholeBodyDynamicSensorFactory
class	WholeBodyDynamicSensorMeasurement
class	XMLMotionFrameTagProcessor
class	XMLMotionTagProcessor
	Use this interface to register custom Motion XML tags. To be used for tags within a <Motion> ... </Motion> structure. More...

Typedefs
typedef std::vector< AbstractMotionPtr >	AbstractMotionList
typedef std::shared_ptr< AbstractMotion >	AbstractMotionPtr
typedef std::shared_ptr< AbstractMotionSegment >	AbstractMotionSegmentPtr
typedef std::weak_ptr< AbstractMotionSegment >	AbstractMotionSegmentWeakPtr
typedef std::shared_ptr< AnnotationFactory >	AnnotationFactoryPtr
typedef std::shared_ptr< BasicKinematicSensor >	BasicKinematicSensorPtr
typedef std::shared_ptr< BasicModelPoseSensor >	BasicModelPoseSensorPtr
typedef std::shared_ptr< CommentEntry >	CommentEntryPtr
typedef std::shared_ptr< ConverterFactory >	ConverterFactoryPtr
typedef std::shared_ptr< Converter >	ConverterPtr
typedef std::shared_ptr< CustomPose >	CustomPosePtr
typedef std::vector< CustomSensorPtr >	CustomSensorList
typedef std::shared_ptr< CustomSensorMeasurement >	CustomSensorMeasurementPtr
typedef std::shared_ptr< CustomSensor >	CustomSensorPtr
typedef std::map< std::string, std::map< std::string, std::map< float, float > > >	DistanceMap
	DistanceMap node name -> (other motion name -> (timestep -> distance))
typedef std::vector< EnvironmentalContactSensorPtr >	EnvironmentalContactSensorList
typedef std::shared_ptr< EnvironmentalContactSensorMeasurement >	EnvironmentalContactSensorMeasurementPtr
typedef std::shared_ptr< EnvironmentalContactSensor >	EnvironmentalContactSensorPtr
typedef std::vector< Force1DSensorPtr >	Force1DSensorList
typedef std::shared_ptr< Force1DSensorMeasurement >	Force1DSensorMeasurementPtr
typedef std::shared_ptr< Force1DSensor >	Force1DSensorPtr
typedef std::vector< Force3DSensorPtr >	Force3DSensorList
typedef std::shared_ptr< Force3DSensorMeasurement >	Force3DSensorMeasurementPtr
typedef std::shared_ptr< Force3DSensor >	Force3DSensorPtr
typedef std::shared_ptr< IAttachedSensor >	IAttachedSensorPtr
typedef std::vector< IMUSensorPtr >	IMUSensorList
typedef std::shared_ptr< IMUSensorMeasurement >	IMUSensorMeasurementPtr
typedef std::shared_ptr< IMUSensor >	IMUSensorPtr
typedef std::shared_ptr< KinematicSensorConfiguration >	KinematicSensorConfigurationPtr
typedef std::vector< KinematicSensorPtr >	KinematicSensorList
typedef std::shared_ptr< KinematicSensorMeasurement >	KinematicSensorMeasurementPtr
typedef std::shared_ptr< KinematicSensor >	KinematicSensorPtr
typedef std::shared_ptr< LegacyMarkerData >	LegacyMarkerDataPtr
typedef std::shared_ptr< LegacyMotionConverter >	LegacyMotionConverterPtr
typedef std::vector< LegacyMotionPtr >	LegacyMotionList
typedef std::shared_ptr< LegacyMotion >	LegacyMotionPtr
typedef std::shared_ptr< LegacyMotionReaderC3D >	LegacyMotionReaderC3DPtr
typedef std::shared_ptr< LegacyMotionReaderXML >	LegacyMotionReaderXMLPtr
typedef std::shared_ptr< MarkerBasedConverter >	MarkerBasedConverterPtr
typedef std::shared_ptr< MarkerData >	MarkerDataPtr
typedef std::shared_ptr< MarkerInfo >	MarkerInfoPtr
typedef std::shared_ptr< MarkerMotion >	MarkerMotionPtr
typedef std::vector< MoCapMarkerSensorPtr >	MoCapMarkerSensorList
typedef std::shared_ptr< MoCapMarkerSensorMeasurement >	MoCapMarkerSensorMeasurementPtr
typedef std::shared_ptr< MoCapMarkerSensor >	MoCapMarkerSensorPtr
typedef std::vector< ModelPoseSensorPtr >	ModelPoseSensorList
typedef std::shared_ptr< ModelPoseSensorMeasurement >	ModelPoseSensorMeasurementPtr
typedef std::shared_ptr< ModelPoseSensor >	ModelPoseSensorPtr
typedef std::shared_ptr< ModelProcessorFactory >	ModelProcessorFactoryPtr
typedef std::shared_ptr< ModelProcessorFactoryWinter >	ModelProcessorFactoryWinterPtr
typedef std::shared_ptr< ModelProcessor >	ModelProcessorPtr
typedef std::shared_ptr< ModelProcessorWinter >	ModelProcessorWinterPtr
typedef VirtualRobot::RobotPtr	ModelPtr
typedef std::shared_ptr< ModelReaderXML >	ModelReaderXMLPtr
typedef std::vector< MotionAnnotationPtr >	MotionAnnotationList
typedef std::shared_ptr< MotionAnnotation >	MotionAnnotationPtr
typedef std::shared_ptr< MotionEntry >	MotionEntryPtr
typedef std::shared_ptr< MotionFrameEntry >	MotionFrameEntryPtr
typedef std::shared_ptr< MotionFrame >	MotionFramePtr
typedef std::shared_ptr< MotionObserver >	MotionObserverPtr
typedef std::shared_ptr< Motion >	MotionPtr
typedef std::shared_ptr< MotionReaderC3D >	MotionReaderC3DPtr
typedef std::shared_ptr< MotionReaderXML >	MotionReaderXMLPtr
typedef std::shared_ptr< MotionRecording >	MotionRecordingPtr
typedef std::shared_ptr< MotionRecordingSegment >	MotionRecordingSegmentPtr
typedef std::weak_ptr< MotionRecording >	MotionRecordingWeakPtr
typedef std::vector< MotionSegmentationPtr >	MotionSegmentationList
typedef std::shared_ptr< MotionSegmentation >	MotionSegmentationPtr
typedef std::weak_ptr< MotionSegmentation >	MotionSegmentationWeakPtr
typedef std::vector< MotionSegmentPtr >	MotionSegmentList
typedef std::shared_ptr< MotionSegmentObserver >	MotionSegmentObserverPtr
typedef std::shared_ptr< MotionSegment >	MotionSegmentPtr
typedef std::map< std::string, std::map< float, std::string > >	MultiContactChanges
	MultiContactChanges node name -> timestep where the contact changes including the first timestep -> motion name of new contact.
typedef std::map< std::string, std::map< float, std::string > >	MultiContacts
	MultiContacts node name -> timestep -> motion name of the nearest contact.
typedef std::map< std::string, int >	NodeDepths
	NodeDepths node name -> child depth.
typedef std::shared_ptr< PrefixMarkerData >	PrefixMarkerDataPtr
typedef std::shared_ptr< ProcessedModelWrapper >	ProcessedModelWrapperPtr
typedef std::shared_ptr< RootOrientationAcc >	RootOrientationAccPtr
typedef std::shared_ptr< RootOrientation >	RootOrientationPtr
typedef std::shared_ptr< RootOrientationVel >	RootOrientationVelPtr
typedef std::shared_ptr< RootPositionAcc >	RootPositionAccPtr
typedef std::shared_ptr< RootPosition >	RootPositionPtr
typedef std::shared_ptr< RootPositionVel >	RootPositionVelPtr
typedef std::shared_ptr< SegmentationFactory >	SegmentationFactoryPtr
typedef std::shared_ptr< SensorFactory >	SensorFactoryPtr
typedef std::vector< SensorPtr >	SensorList
typedef std::shared_ptr< SensorMeasurement >	SensorMeasurementPtr
typedef std::shared_ptr< Sensor >	SensorPtr
typedef std::shared_ptr< UnknownMotionAnnotation >	UnknownMotionAnnotationPtr
typedef std::shared_ptr< UnknownSensorMeasurement >	UnknownSensorMeasurementPtr
typedef std::shared_ptr< UnknownSensor >	UnknownSensorPtr
typedef std::shared_ptr< UnlabeledMarkerData >	UnlabeledMarkerDataPtr
typedef std::shared_ptr< UnlabeledMarkerMotion >	UnlabeledMarkerMotionPtr
typedef std::vector< WholeBodyDynamicSensorPtr >	WholeBodyDynamicSensorList
typedef std::shared_ptr< WholeBodyDynamicSensorMeasurement >	WholeBodyDynamicSensorMeasurementPtr
typedef std::shared_ptr< WholeBodyDynamicSensor >	WholeBodyDynamicSensorPtr
typedef std::shared_ptr< XMLMotionFrameTagProcessor >	XMLMotionFrameTagProcessorPtr
typedef std::shared_ptr< XMLMotionTagProcessor >	XMLMotionTagProcessorPtr

Functions
ActionLabel	ActionLabelFromString (const std::string &label)
Failure	FailureFromString (const std::string &failure)
BOOST_EXTENSION_EXPORT_DECL SensorFactoryPtr	getFactory ()
MotionType	getMotionTypeFromModel (const std::string &modelName)
BOOST_EXTENSION_EXPORT_DECL std::string	getVersion ()
bool	hasNode (ModelPtr model, const std::string &nodeName)
template<class Sensor >
std::string	NAME_STR ()
void	savitzkyGolayFilter (const Eigen::Ref< const Eigen::MatrixXd > positions, Eigen::MatrixXd &vel, Eigen::MatrixXd &acc, unsigned int window, unsigned int order, double timestepDelta)
std::filesystem::path	xml_path (const std::filesystem::path &path)

Variables
template class MMM_IMPORT_EXPORT	AbstractFactoryMethod< ConverterFactory, void * >
template class MMM_IMPORT_EXPORT	AbstractFactoryMethod< ModelProcessorFactory, void * >
std::set< std::string >	mmmJointNamesToInvert

Detailed Description

A template that can be used as a superclass of a class hierarchy that wants to provide a factory method which allows instantiation of objects based on a string identifier.

The main MMM namespace.

The first template argument is the base class of your class hierarchy. The second argument is the parameter type for the initialisation function each subclass has to provide. If you need multiple constructor arguments it is recommended to use a boost::tuple.

Variable Documentation

mmmJointNamesToInvert

std::set<std::string> MMM::mmmJointNamesToInvert

Initial value:

= {"LSCz_joint", "LSCy_joint", "LSz_joint", "LSy_joint", "LEz_joint", "LWy_joint",
                                                           "LHz_joint", "LHy_joint", "LAz_joint", "LAy_joint", "LMrot_joint",
                                                           "RSCz_joint", "RSCy_joint", "RSz_joint", "RSy_joint", "REz_joint", "RWy_joint",
                                                           "RHz_joint", "RHy_joint", "RAz_joint", "RAy_joint", "RMrot_joint",
                                                           "BPz_joint", "BPy_joint", "BTz_joint", "BTy_joint",
                                                           "BUNz_joint", "BUNy_joint", "BLNz_joint", "BLNy_joint"}