| ConfigurationEditor::AddCollectionEntry | Displays a list of template objects (see ConfigurationEditor::getObjectTemplates()) which can be added to a target collection |
| Aibo3DControllerBehavior | Listens to aibo3d control commands coming in from the command port |
| plist::Angle | Handles angle measurements by adding a 'unit' attribute to numeric values, or a character suffix in a string value. */ |
| AngPi | Circular arithmetic on angles between 0 and pi (180 degrees) |
| AngSignPi | Circular arithmetic on angles between -pi and pi (360 degrees) |
| AngTwoPi | Circular arithmetic on angles between 0 and two pi (360 degrees) |
| argb | |
| argbf | |
| ArmControllerBehavior | Listens to control commands coming in from the command port for remotely controlling the head |
| ArmMC | |
| ArmNode | A simple StateNode that executes a ArmMC motion command |
| plist::ArrayBase | Maintains an array of value, see ArrayOf, and the Array typedef |
| plist::ArrayOf< PO, Alloc > | A collection of plist objects, similar to a Dictionary, but no keys -- order matters!, see plist::Array |
| plist::AutoCollectionListener | Monitors a collection to keep tabs on all its entries, so PrimitiveListener::plistValueChanged will be called if any entry is changed |
| Profiler::AutoInit | Automatically causes initialization of the histogram buckets when the first Profiler is instantiated |
| XMLLoadSave::AutoInit | Allows automatic (de)initialization of libxml when the first or last XMLLoadSave class is created or destroyed |
| plist::AutoPrimitiveListener | Auto subscribe/unsubscribe from a Primitive |
| XMLLoadSave::bad_format | Exception to be thrown when a bad XML file is parsed, allows file position information to be passed to the user |
| plist::OutputSelector::bad_value | |
| BallDetectionGenerator | Uses segmented color region information to detect round objects |
| basic_inetstream< charT, traits > | |
| basic_ionetstream< charT, traits > | |
| basic_netbuf< charT, traits > | |
| basic_netbuf_interface< charT, traits > | |
| basic_onetstream< charT, traits > | |
| basic_streambuf | |
| BatteryCheckControl | When activated, this will print a battery report to stdout and light up LEDs to specify power level |
| BatteryMonitorBehavior | A background behavior that monitors the power level and has the robot indicate when its battery is getting low |
| BehaviorActivatorControl | Upon activation, will start, stop, or toggle a behavior |
| BehaviorBase | The basis from which all other Behaviors should inherit |
| BehaviorSwitchControlBase::BehaviorGroup | A simple utility class to allow the BehaviorSwitchControl's to be able to deactivate the current behavior when a new one becomes active |
| BehaviorReportControl | Reads the set of currently instantiated behaviors and sends a report to sout |
| Config::behaviors_config | Place for users to put their own configuration |
| BehaviorSwitchActivatorControl | Upon activation, will tell the specified BehaviorSwitchControl to start or stop the behavior |
| BehaviorSwitchControl< B, Al > | Allows proper switching between major behaviors, calling DoStart and DoStop |
| BehaviorSwitchControlBase | Holds some utility classes and functions for BehaviorSwitchControl which shouldn't be stored in a templated class |
| DualCoding::BoundedDistributionPolicy< ParticleT > | |
| KinematicJoint::BranchListener | |
| Buffer | Buffer |
| BufferedImageGenerator | Receives camera frames as they are loaded by the simulator -- or eventually other sources |
| WalkMC::CalibrationParam | Holds information to correct for slippage, non-idealities |
| CallbackPollThread | |
| CallbackThread | A simple adapter to cause a callback under a new thread |
| CalliopeInfo::CalliopeCapabilities | Polymorphic robot capability detection/mapping |
| CameraBehavior | Will take images and write to log file |
| CameraCalibrationBehavior | A behavior to calibrate the camera using the robots own LEDs as reference |
| CameraStreamBehavior | Base class for camera streaming communication classes, handles upstream communication |
| Thread::cancellation_exception | This is thrown by testCancel() on systems where pthread_testcancel() doesn't do what we want |
| RobotInfo::Capabilities | Allows behaviors to lookup output/button/sensor names from other models to support basic cross-model portability |
| CDTGenerator | Generates SegmentedColorFilterBankEvents with images provided from the system |
| ChiaraInfo::ChiaraCapabilities | Polymorphic robot capability detection/mapping |
| CircularObstacle | Circular defined obstacle designated by a center point and a radius |
| Cloneable | An interface for cloning objects -- needed for making copies with polymorphism (operator= doesn't work as virtual) |
| plist::Collection | |
| plist::CollectionCallbackMember< O > | Produces a callback on a member function when a value in the collection changes |
| plist::CollectionListener | If you wish to be notified any time an entry is added, removed, or replaced from a Dictionary, Array, or Vector, inherit from this and implement one or both of the functions, then register it with the collection's addCollectionListener() |
| CollisionChecker | Interface for planner collision checking |
| CMVision::color_class_state | |
| fmat::Column< N, R > | |
| MotionManager::CommandEntry | All the information we need to maintain about a MotionCommand |
| CompareTrans< T > | Causes a transition if a value (through a pointer) goes above a given value |
| fmat::fmat_internal::CompileTimeAssert< MSG, true > | |
| CompletionTrans | Causes a transition when at least n sources have signalled completion; n = 0 means "all" (default) |
| PhysicsBody::ComponentListener | This object subscribes to a LinkComponent (usually the root KinematicJoint of a chain) and creates a corresponding PhysicsBodies for it and its children |
| KinematicJoint::ComponentsListener | |
| Thread::Condition | Provides an inter-thread signaling and synchronization mechanism |
| IKSolver::Cone | Cone allows 1-2 freedoms (roll, trade off pitch vs. yaw) |
| Config | Root configuration object, provides some global functionality like porting pathnames (portPath()) |
| ConfigDictionary | Subclass of plist::Dictionary which adds support for filtering settings by robot model, each configuration section is based on this |
| ConfigurationEditor | Provides interactive editing and loading/saving of a plist::Collection |
| ConnectionMadeTrans | Transition that occurs as soon as a connection is made |
| ConstraintInterface | |
| DriverMessaging::ContactPoint | |
| ControlBase | Base class for all items in the Controller hierarchy |
| Controller | Handles the menu/command system... when it detects the EmergencyStopMC is activated, it'll kick into high priority |
| Config::controller_config | Controller information |
| KinematicJoint::ControllerInfo | Parameters for joint motion model, used for simulation |
| plist::ObjectBase::conversion_policy< U, V > | That collections (e.g. plist::Array or plist::Dictionary) of these abstract base classes (ObjectBase, PrimitiveBase) can convert any primitive type to a plist::Primitive wrapper |
| plist::Collection::conversion_policy< U, V > | Specifies that a collection of collections cannot contain any primitive values |
| plist::Primitive< T >::conversion_policy< U, V > | |
| plist::Primitive< char >::conversion_policy< U, V > | |
| plist::Primitive< unsigned char >::conversion_policy< U, V > | |
| plist::NamedEnumeration< T >::conversion_policy< U, V > | |
| plist::Primitive< std::string >::conversion_policy< U, V > | |
| plist::DictionaryBase::ConversionTo< PO > | This conversion policy accepts entries of the specified template type, and will try to create new instances of that type constructed from any values which are passed |
| plist::ArrayBase::ConversionTo< PO > | This conversion policy accepts entries of the specified template type, and will try to create new instances of that type constructed from any values which are passed |
| CreateMotionModel< ParticleT > | |
| Resource::Data | Base class for holding data required for requesting to use/release the resource |
| DataEvent< T, TID > | Event type for passing around data (or pointers to data). In a state machine, use a SignalTrans to test for a specific data value and make the sid the address of the node posting the event |
| DeadReckoningBehavior< ParticleT > | Subscribes to LocomotionEvents and attempts to track robot movement over time using a fairly generic HolonomicMotionModel |
| plist::DictionaryBase::DeniedValueConversions | Indicates that no value conversions are allowed |
| plist::ArrayBase::DeniedValueConversions | Indicates that no value conversions are allowed |
| plist::DictionaryBase | Maintains a set of (key,value) pairs, see DictionaryOf, and the Dictionary typedef |
| plist::DictionaryOf< PO, Alloc > | A dictionary which requires all elements to be subtypes of the PO template argument |
| DirectController | |
| DirectLinearController | |
| ParticleFilter< ParticleT >::DistributionPolicy | A distribution policy provides the ability to randomize ("redistribute") or tweak the values of a group of particles |
| fmat::fmat_internal::do_promotion< T1, T2, promoteT1 > | |
| fmat::fmat_internal::do_promotion< T1, T2, false > | |
| CMVision::DummyI3< x, y, z > | |
| DummySocket | Tekkotsu wireless DummySocket class |
| CMVision::DummyT1< T > | |
| CMVision::DummyT1I3< T, x, y, z > | |
| DumpFileControl | Upon activation, loads a position from a file name read from cin (stored in ms/data/motion...) |
| DynamicInfo::DynamicCapabilities | Polymorphic robot capability detection/mapping |
| DynamicInfo::DynamicInfoRow< T, N > | 2D array of constant width |
| DynamicMotionSequence | Uses STL's vector for dynamic memory allocation - don't use this as a motion command, pointers in shared memory regions can be invalid in other processes |
| DynamicMotionSequenceNode | A StateNode for playing a DynamicMotionSequence (and looping it if desired) |
| EchoBehavior | Waits for a connection, echos any data received back to the sender |
| EmergencyStopMC | Overrides all joints with high priority freeze, blinks tail pink/red/blue cycle |
| EmptyResource | No-op resource, since we don't want Resource itself to be directly instantiatable |
| MessageQueue< MAX_UNREAD, MAX_RECEIVERS, MAX_SENDERS >::entry | Data storage needed for each message |
| RegionRegistry< MAX_REGIONS, NAME_LEN >::entry | Holds information regarding a shared memory region available for listening |
| ListMemBuf< T_t, MAX, idx_t >::entry_t | Holds data about an entry in the free/used lists |
| plist::DictionaryBase::EntryConstraint< PO > | This base conversion policy doesn't actually specify any conversions at all -- this serves as a base class to provide the ability to directly add entries of the specified type; the subclasses will add value conversions |
| plist::ArrayBase::EntryConstraint< PO > | |
| ERS210Info::ERS210Capabilities | Polymorphic robot capability detection/mapping |
| ERS220Info::ERS220Capabilities | Polymorphic robot capability detection/mapping |
| ERS2xxInfo::ERS2xxCapabilities | Polymorphic robot capability detection/mapping |
| ERS7Info::ERS7Capabilities | Polymorphic robot capability detection/mapping |
| EStopControllerBehavior | Listens to control commands coming in from the command port for remotely controlling the head |
| EventBase | Forms the basis of communication between modules/behaviors in the framework |
| EventCallbackAs< EV > | Listens for a specified event and then forwards to the specified callback |
| EventGeneratorBase | A simple convenience class for event generators |
| EventListener | An interface to allow a standard method of passing events |
| EventLogger | Allows logging of events to the console or a file, also provides some remote logging facilities over logSocket, required by Storyboard tool |
| EventRouter::EventMapper | Does the actual storage of the mapping between EventBase's and the EventListeners/EventTrappers who should receive them |
| EventProxy | |
| EventRouter | This class will handle distribution of events as well as management of timers |
| EventTrans | Causes a transition when the specified event is received |
| EventTranslator | EventTranslator receives events from EventRouters in non-Main processes and adds them into a SharedQueue for Main to pick up |
| EventTrapper | An interface to allow a standard method of trapping events |
| FactoryInvalidT< typename >::Factory< U > | Concrete class for not doing anything |
| Factory0Arg< Base >::Factory< T > | Concrete class for constructing products of a specified subtype of Base |
| Factory0Arg1Static< Base, S1, s1 >::Factory< T > | Concrete class for constructing products of a specified subtype of Base |
| Factory0Arg1Member< Base, M1 >::Factory< T > | Concrete class for constructing products of a specified subtype of Base |
| Factory0Arg2Static< Base, S1, s1, S2, s2 >::Factory< T > | Concrete class for constructing products of a specified subtype of Base |
| Factory1Arg< Base, A1 >::Factory< T > | Concrete class for constructing products of a specified subtype of Base |
| Factory1Arg1Static< Base, A1, S1, s1 >::Factory< T > | Concrete class for constructing products of a specified subtype of Base |
| Factory1Static1Arg< Base, S1, s1, A1 >::Factory< T > | Concrete class for constructing products of a specified subtype of Base |
| Factory0_1Arg< Base, A1 >::Factory< T > | Concrete class for constructing products of a specified subtype of Base |
| Factory1Static_1Arg< Base, S1, s1, A1 >::Factory< T > | Concrete class for constructing products of a specified subtype of Base |
| Factory0_1Arg< Base, A1 > | Base class for factories which can create products more than one way, in this case via default constructor (0 arguments) or 1-argument constructor |
| Factory0Arg< Base > | Typed base class for factories which don't require any arguments to construct their product, see Factories.h file notes |
| Factory0Arg1Member< Base, M1 > | This class produces objects based on a constant specified as a factory member |
| Factory0Arg1Static< Base, S1, s1 > | This class produces objects based on a constant specified as a template parameter |
| Factory0Arg2Static< Base, S1, s1, S2, s2 > | This class produces objects based on constant values specified as a template parameters |
| Factory0ArgBase | Untyped base class for factories which don't require any arguments to construct their product, see Factories.h file notes (see Factory0Arg) |
| Factory1Arg< Base, A1 > | Typed base class for factories which require a single argument to construct their product, which is passed to the concrete Factory's functor |
| Factory1Arg1Static< Base, A1, S1, s1 > | This class produces objects based on a functor argument and a constant specified as a template parameter |
| Factory1ArgBase< A1 > | Untyped base class for factories which require a single argument to construct their product, which is passed to the concrete Factory's functor (see Factory1Arg) |
| Factory1Static1Arg< Base, S1, s1, A1 > | This class produces objects based on a constant specified as a template parameter and a constructor argument |
| Factory1Static_1Arg< Base, S1, s1, A1 > | Variant of Factory0_1Arg, this uses a constant non-type template parameter to specify a default value to use when the 0-argument functor is called.. |
| FactoryInvalidT< typename > | A factory interface which doesn't actually allow anything to be produced (for completeness, like 'NULL') |
| FactoryT | |
| FamilyFactory< FamilyT, NameT, FactoryBaseT, FactoryT >::FactoryType< T > | Allows indirect access to create factory classes |
| InstanceTracker< FamilyT, ClassNameT, FactoryBaseT, FactoryT >::FactoryType< T > | Allows indirect access to create factory classes |
| FailsafeThread | Enforces a timeout on another thread |
| FamilyFactory< FamilyT, NameT, FactoryBaseT, FactoryT > | A class which can track a set of subclass types (with shared base class FamilyT), generating new instances on demand based on some form of identifier (the NameT template parameter) |
| FileBrowserControl | Displays the contents of a directory in a control menu, probably useful as a baseclass for other controls |
| FileInputControl | Upon activation, allows user to browse files and select one; stores path in a string |
| FilterBankEvent | This event gives access to a set of image channels at different resolutions, see FilterBankGenerator |
| FilterBankGenerator | Abstract base class for generators of FilterBankEvent's |
| DriverMessaging::FixedPoints | For simulation purposes, notifies visualizer to hold the specified points fixed relative to the world, and move the base frame instead |
| FlashIPAddrBehavior | Displays IP address by speaking the digits and flashing a series of numbers on the LED face panel |
| FreeMemReportControl | Gives reports on free memory size at variable rates, can also warn if free memory drops too low |
| GenericAngularPositionInterface | |
| GenericAngularPositionMotorInterface | |
| GenericRRT | |
| Graphics | Provides basic graphics capabilities for drawing into any bitmap, particularly FilterBankGenerators |
| GrasperEvent | Event for reporting the results of a Grasper operation |
| GrasperNode | Creates a GrasperRequest graspreq that the user can modify in their DoStart() function, then executes the request when DoStart() returns |
| GrasperRequest | Request to the Grasper to manipulate something |
| GroupNode | Allows a group of StateNodes to be activated together |
| HandEyeInfo::HandEyeCapabilities | Polymorphic robot capability detection/mapping |
| HandEyeGripper | |
| HandEyeZInfo::HandEyeZCapabilities | Polymorphic robot capability detection/mapping |
| hashcmp_eqstr | |
| Kinematics::hashstring | Allows us to use the STL hash_map with strings |
| HeadControllerBehavior | Listens to control commands coming in from the command port for remotely controlling the head |
| HeadPointerMC | This class gives some quick and easy functions to point the head at things |
| HeadPointerNode | A simple StateNode that executes a HeadPointerMC motion command |
| HelpControl | Recurses through the menu system and outputs the name and description of each item |
| HingeAngularMotorInterface | |
| HingePositionInterface | |
| HingeVelocityInterface | |
| HolonomicMotionModel< ParticleT > | This class can model the path of a holonomic robot in two dimensions (x and y) |
| RCRegion::Identifier | All information needed to attach this region from a different process |
| fmat::Matrix< H, W, R >::IdentityMatrix | |
| IKGradientSolver | Performs gradient descent on the joints to find a solution |
| IKSolver | Provides an abstract interface to inverse kinematic solvers |
| IKThreeLink | Performs gradient descent on the joints to find a solution |
| CMVision::image< pixel > | |
| CMVision::image_idx< pixel > | |
| CMVision::image_yuv< element > | |
| BufferedImageGenerator::ImageSource | Stores information about the current frame, (not the image itself, but meta data a pointer to it) |
| InstanceTracker< FamilyT, ClassNameT, FactoryBaseT, FactoryT >::InstanceEntry | Provides a wrapper for non-plistDictionary entries |
| InstanceTracker< FamilyT, ClassNameT, FactoryBaseT, FactoryT > | Attempts to provide references to all currently instantiated objects of a class (and its subclasses) |
| InstanceTypeLoader | Pre-loads dictionaries for InstanceTracker::loadXML to extract ".type" entries so matching instances can be created for loading |
| plist::DictionaryBase::IntegerConversion | Abstract base class to test whether the collection will accept integers (possibly converting to another value type, or storing directly as a [unsigned] long depending on concrete type) |
| plist::ArrayBase::IntegerConversion | Abstract base class to test whether the collection will accept integers (possibly converting to another value type, or storing directly as a [unsigned] long depending on concrete type) |
| Kinematics::InterestPoint | Holds the position and attached link of a given interest point |
| InterleavedYUVGenerator | Generates FilterBankEvents containing raw camera images with interleaved pixels (YUVYUVYUV... instead of YYY...UUU...VVV...) |
| InverseMarkScope | Provides a way to mark a resource as unused for the duration of the instance's scope, thus negating MarkScope for a portion |
| IPaddr | |
| IPCEventTranslator | An implementation of EventTranslator which will forward events using the inter-process mechanisms of the current platform |
| JPEGGenerator | Generates FilterBankEvents containing JPEG compressed images |
| KinematicJoint | Manages parameters which define the position and type of motion produced by an actuator (i.e. forward kinematics) |
| KinematicJointLoader | Handles the recursive loading of a tree of joints |
| KinematicJointSaver | Handles the recursive saving of a tree of joints |
| Kinematics | Forward and inverse kinematics calculations using Tekkotsu output indices |
| LedNode | A simple StateNode that executes a LedMC motion command and throws a status event upon completion |
| WalkMC::LegParam | Holds parameters about how to move each leg |
| XWalkParameters::LegParameters | Specifies parameters for each leg |
| XWalkMC::LegState | Cached information about each leg's stride |
| WalkMC::LegWalkState | Holds state about each leg's path |
| fmat::Length_mismatch_or_non_vector | |
| LGmixin | Mix-in for the BehaviorBase or StateNode class to give access to Looking Glass variables |
| IKSolver::Line | Lines allow 1 freedom, slide along line |
| LinkComponent | These let you build the link from a series of model and material settings instead of one static model/material for the whole link |
| plist::Listener | Base class for the plist listener callbacks |
| DriverMessaging::Listener | Interface for drivers to receive messages, see addListener() and removeListener() |
| ListMemBuf< T_t, MAX, idx_t > | Provides some degree of dynamic allocation of a templated type from a buffer of set size |
| LoadCalibration | Will load calibration parameters from a text file into a forward and backward matrix |
| LoadPostureControl | Upon activation, loads a position from a file name read from cin (stored in ms/data/motion...) |
| DriverMessaging::LoadPrediction | Encodes a set of load predictions for joints so driver can offset target positions accordingly |
| LoadSave | Intended as an interface to allow easy and portable serialization operations |
| ConfigurationEditor::LoadSettings | File browser to load a plist from the file system |
| LoadWalkControl | When activated, loads a set of walk parameters from a file specified by user |
| LocalizationNode | Maintain a running estimate of robot pose using odometry plus visual landmarks |
| LocalizationParticle | Each Particle represents a hypothesis about the match of the local map to the world map |
| LocalizationParticleDistributionPolicy< ParticleT > | Provides parameters and methods for randomizing and tweaking LocalizationParticles |
| Thread::Lock | Inter-thread lock -- doesn't work across processes, only threads within a process. (see MutexLock for inter-process locks) |
| LocomotionEvent | Gives updates regarding the current movement of the robot through the world |
| LogNode | On activation, start logging data to disk as a series of image and/or sensor files |
| LookoutEvent | Abstract base class for all Lookout Events |
| LookoutIREvent | |
| LookoutPointAtEvent | |
| LookoutScanEvent | |
| LookoutSketchEvent | |
| LostTargetTrans | Causes a transition if the target has not been seen minframe times within delay milliseconds |
| ParticleFilter< ParticleT >::LowVarianceResamplingPolicy | This class provides a generic, default ResamplingPolicy. It is based on the low variance resampling policy algorithm found in "Probabilistic Robotics" by Sebastian Thrun, Wolfram Burgard, Dieter Fox |
| Config::main_config | General configuration options |
| DualCoding::MarkerLocalization | |
| DualCoding::MarkerSensorModel< ParticleT > | |
| MarkScope | Provides a way to mark a resource as used for the duration of the instance's scope |
| fmat::Matrix< H, W, R > | |
| fmat::Matrix_multiplication_left_width_must_match_right_height | |
| MCNode< T, mcName, mcDesc, completes > | A generic wrapper for any MotionCommand. Note that some functions are provided by the MCNodeBase common base class, namely MCNodeBase::setMC() and MCNodeBase::getMC_ID() |
| MCNodeBase | Common parent class for all the templated MCNode, which is what you want to instantiate |
| MCValueEditControl< T > | Allows you to modify a value in memory, much like ValueEditControl, but will check out a MotionCommand first to maintain proper mutual exclusion |
| DriverMessaging::Message | Base class for all driver messages, this subclasses XMLLoadSave in case we want to serialize for messages from non-threaded (full multi-process) IPC, or offboard computation |
| MessageQueueBase::MessageFilter | Interface for filtering (or otherwise monitoring) messages being sent through a MessageQueue, see MessageQueueBase::addMessageFilter() |
| MessageQueue< MAX_UNREAD, MAX_RECEIVERS, MAX_SENDERS > | An implementation of MessageQueueBase, which provides mechanisms for sending shared memory regions between processes |
| MessageQueueBase | Defines the interface for sending new shared memory regions between processes |
| MessageQueueStatusThread | Description of MessageQueueStatusThread |
| MessageReceiver | Spawns a thread for monitoring a MessageQueue, calls a specified function when new messages are available |
| MicrophoneServer | Streams audio from the microphone over the network |
| MMAccessor< MC_t > | This class allows convenient ways of accessing a motion command |
| fmat::fmat_internal::mmops< T1, T2 > | |
| fmat::fmat_internal::mmops< T1< 2, 2, R1 >, T2< 2, 2, R2 > > | |
| fmat::fmat_internal::mmops< T1< 3, 3, R1 >, T2< 3, 3, R2 > > | |
| fmat::fmat_internal::mmops< T1< 4, 4, R1 >, T2< 4, 4, R2 > > | |
| BehaviorBase::MonitorMotion | An instance is created for each motion activated through addMotion(), listening in case the motion is removed by some other means, thus invalidating the MC_ID |
| Config::motion_config | Motion information |
| MotionCommand | The abstract base class for motions, provides common interface. All motions should inherit from this |
| MotionManager | The purpose of this class is to repeatedly compute the final set of joint angles for the robot, managing a set of (possibly conflicting) MotionCommands |
| MotionManagerMsg | A small header that precedes data sent by MotionManager between processes |
| ParticleFilter< ParticleT >::MotionModel | A motion model is retained by the particle filter to query before evaluating sensor measurements so all known influences are accounted for before testing the particles |
| MotionPtr< T > | A shared_ptr for MotionCommands; provides allocation and access to a MotionCommand, ensuring mutually exclusive access and scope-based deallocation |
| MotionReport | Triggers MotionManager::motionReport() to display currently active motions and their output usage on stderr |
| MotionSequenceEngine | A handy class for storing a sequence of keyframed movements |
| MotionSequenceMC< MAXMOVE > | Instantiates MotionSequenceEngines - when you want to run a motion sequence, make one of these |
| MotionSequenceNode< SIZE > | A StateNode for playing a MotionSequence (and looping it if desired) |
| MotorController | |
| MotionSequenceEngine::Move | This struct holds all the information needed about a frame for a particular output |
| MutexLock< num_doors > | Implements a mutual exclusion lock using pthread mutex |
| MutexLockBase | The main purpose of this base class is actually to allow setting of usleep_granularity across all locks |
| fmat::fmat_internal::mvops< M, V > | |
| fmat::fmat_internal::mvops< T1< 2, 2, R1 >, T2< 2, R2 > > | |
| fmat::fmat_internal::mvops< T1< 3, 3, R1 >, T2< 3, R2 > > | |
| fmat::fmat_internal::mvops< T1< 4, 4, R1 >, T2< 4, R2 > > | |
| plist::NamedEnumeration< T > | Provides an interface for the use of enumerations in a plist -- you can specify values by either the string name or the corresponding integer value |
| plist::NamedEnumerationBase | Some accessors common across NamedEnumeration types |
| ConfigurationEditor::NamedEnumerationEditor | Based on a string input control for easier mixing with other primitives (which just use a basic string input control as an editor) |
| netstream_server | |
| NetworkBuffer | |
| ConfigurationEditor::NewCollectionEntry | Interface to set up a new collection entry before inserting it |
| Thread::NoCancelScope | |
| GenericRRT::Node | Node storage class |
| SharedObjectBase::NoInit | When passed to the SharedObject constructor, indicates that no RCRegion should be created |
| fmat::fmat_internal::NoInit | |
| fmat::NonSquare_Matrix | |
| NoOpEventTranslator | For completeness, if you want to have events be piped directly to the local erouter instead having to be encoded and decoded |
| SegmentedColorGenerator::NoThresholdException | Thrown if no threshold maps are available |
| NullControl | When activated, this will return immediately (handy for fake items in a menu) |
| NullTrans | Transition that occurs (via a 0 msec Timer event) as soon as the source node finishes starting up |
| plist::ObjectBase | This base class provides the root functionality for all plist entities -- Dictionary and the various templated subclasses of PrimitiveBase |
| OCdtInfo | |
| OCdtVectorData | |
| ODataVectorInfo | Compatability with the OPEN-R type of the same name |
| OFbkImage | |
| OFbkImageInfo | Compatability with the OPEN-R type of the same name |
| OFbkImageVectorData | Compatability with the OPEN-R type of the same name |
| IKSolver::Orientation | Abstract base class for orientation information |
| OSoundInfo | Compatability with the OPEN-R type of the same name |
| OSoundVectorData | Compatability with the OPEN-R type of the same name |
| OutputCmd | This object holds all the information needed to control a single output |
| OutputConfig< T > | Stores an item for each joint, can be accessed via joint name or array offset |
| OutputNode | A very simple StateNode that outputs its name to a given ostream upon activation, handy for debugging |
| OutputPID | This object holds all the information needed to control a single output |
| plist::OutputSelector | Handles mapping <string> elements to the appropriate numeric offset using Capabilities database |
| MotionManager::OutputState | Holds the full requested value of an output |
| SpeakerServer::Packet | Stores information about current sound buffer |
| IKSolver::Parallel | Parallel allows 1 freedom (roll along z vector) |
| XWalkMC::ParameterTransition | |
| ParticleBase< ParticleT > | Provides a common base class for particles used by the ParticleFilter |
| ParticleFilter< ParticleT > | Implements a particle filter with support for a variety of applications through the usage of arbitrary combination of a variety of models and policies |
| PhysicsBody | Interface to the Bullet physics engine, although parameters controlled by PhysicsBody::ComponentListener and its associated LinkComponent |
| PhysicsWorld | Description of PhysicsWorld |
| PIDController | |
| PIDMC | A nice little MotionCommand for manually manipulating the PID values |
| MotionManager::PIDUpdate | Used to request pids for a given joint |
| PitchDetector | Generates a PitchEvent whenever a notable frequency is detected using FFT |
| PitchEvent | Provides information about a tone detected from the microphone(s) |
| PitchDetector::PitchInfo | Stores info about the pitch currently being detected |
| PlanarThreeLinkArm | |
| IKSolver::Plane | Planes allow 2 freedoms, move in plane |
| PlaneEquation | Representation of a plane as ax + by + cz = d; used for representing the ground plane |
| PlannerObstacle | Base class for all obstacles |
| PlaySoundControl | Upon activation, loads plays a selected sound stored in ms/data/sound) |
| SoundManager::PlayState | Holds data about sounds currently being played |
| PNGGenerator | Generates FilterBankEvents containing PNG compressed images |
| plist::Point | A simple class for storing 3D points, will be serialized as an array and provides operator[], but you can also use the x, y, z fields directly if preferred |
| IKSolver::Point | Points allow 0 freedoms |
| PollThread | Description of PollThread |
| plist::PolymorphicLoader | Allows us to use the LoadSave suite for loading and parsing general XML functions, but forwards loadXML to plist::loadXML() and stores the result as a member |
| IKSolver::Position | Abstract base class for position information |
| EventRouter::PostingStatus | Information regarding the progress of posting an event |
| PostureEditor | Allows logging of events to the console or a file |
| PostureEngine | A class for storing a set of positions and weights for all the outputs |
| PostureMC | MotionCommand shell for PostureEngine |
| PostureNode | A simple StateNode that executes a PostureMC motion command |
| fmat::fmat_internal::precision_trait< T > | |
| fmat::fmat_internal::precision_trait< bool > | |
| fmat::fmat_internal::precision_trait< char > | |
| fmat::fmat_internal::precision_trait< double > | |
| fmat::fmat_internal::precision_trait< float > | |
| fmat::fmat_internal::precision_trait< int > | |
| fmat::fmat_internal::precision_trait< long > | |
| fmat::fmat_internal::precision_trait< long double > | |
| fmat::fmat_internal::precision_trait< short > | |
| fmat::fmat_internal::precision_trait< unsigned char > | |
| fmat::fmat_internal::precision_trait< unsigned int > | |
| fmat::fmat_internal::precision_trait< unsigned long > | |
| fmat::fmat_internal::precision_trait< unsigned short > | |
| plist::Primitive< T > | |
| plist::Primitive< char > | |
| plist::Primitive< std::string > | Provides a std::string specialization of Primitive<T> |
| plist::Primitive< unsigned char > | unsigned char specialization of plist::Primitive<T>, adds a unique numeric property to the usual template implementation |
| plist::PrimitiveBase | Provides common functionality to all primitive value classes (implemented in a templated subclass Primitive) |
| plist::PrimitiveCallbackMember< O > | Produces a callback on a member function when the value changes |
| plist::PrimitiveListener | If you wish to be notified any time a particular plist primitive's value has been changed, inherit from this and implement the callback, then register it with the plist object through Primitive::addPrimitiveListener() |
| Profiler | Manages a hierarchy of timers for profiling time spent in code, gives microsecond resolution |
| ProfilerCheckControl | Causes the WorldState::mainProfile and WorldState::motionProfile to display reports to sout |
| ProfilerOfSize< MaxSections > | Templated subclass allows compile-time flexibility of how much memory to use |
| fmat::fmat_internal::promotion_trait< T1, T2 > | |
| QBotPlusInfo::QBotPlusCapabilities | Polymorphic robot capability detection/mapping |
| ToggleControl::RadioGroup | Little class for managing the currently active ToggleControl to allow radio buttons |
| RandomTrans | A transition that fires immediately, randomly choosing one destination node to activate |
| RawCamBehavior | Forwards images from camera over wireless |
| Config::vision_config::RawCamConfig | Settings specific to the "RawCam" (original camera images) for streaming video over the network |
| RawCameraGenerator | Generates FilterBankEvents containing raw camera images directly from the system (doesn't make a copy) |
| RCRegion | Compatability with the OPEN-R type of the same name |
| plist::DictionaryBase::RealConversion | Abstract base class to test whether the collection will accept floating point numbers (possibly converting to another value type, or storing directly as a double depending on concrete type) |
| plist::ArrayBase::RealConversion | Abstract base class to test whether the collection will accept floating point numbers (possibly converting to another value type, or storing directly as a double depending on concrete type) |
| RebootControl | When activated, this will cause the aibo to reboot |
| RecordMotionNode | DESCRIPTION |
| RecordRange | |
| RectangularObstacle | Rectangular defined obstacle designated by 4 corners and its rotation matrix from axis alignment |
| ReferenceCounter | Performs simple reference counting, will delete the object when removing the last reference |
| CMVision::region | |
| CMVision::region_small | |
| CMVision::region_tiny | |
| RegionCamBehavior | Forwards segmented images from camera over wireless |
| Config::vision_config::RegionCamConfig | Settings specific to the "RegionCam" (only display a box for each blob of color) for streaming over the network |
| RegionGenerator | Connects regions of CMVision format runs in RLEGenerator |
| RegionRegistry< MAX_REGIONS, NAME_LEN > | Keeps track of currently available shared memory regions |
| Regis1Info::Regis1Capabilities | Polymorphic robot capability detection/mapping |
| RelaxBehavior | A behavior that sets all the pids to zero for the tail and legs servos |
| RemoteControllerMC | This class is used for setting all outputs to a certain set of values (not the gains, just the joint positions) |
| RemoteEvents | |
| RemoteRequest | |
| RemoteRouter | |
| RemoteState | |
| ParticleFilter< ParticleT >::ResamplingPolicy | The resampling policy focuses the particle filter on those particles which are performing well, and dropping those which are poorly rated |
| Resource | Provides a generic interface for resources which need to keep track of when they are in use, such as mutex locks |
| ResourceAccessor< R > | A variation of MarkScope which allows you to forward access to the resource via the '->' operator, smart-pointer style |
| rgb | |
| rgba | |
| rgbaf | |
| plist::RGBColor< T > | |
| rgbf | |
| RLEGenerator | Generates RLE compressed FilterBankEvents (generally from indexed color images from, say, SegmentedColorGenerator) |
| IKSolver::Rotation | Rotation allow 0 freedoms (here specified as a quaternion) |
| fmat::Rotation_requires_larger_dimensions | |
| fmat::Row< N, R > | |
| RRTFunctorBase | Base Functor definition to use as a node predicate in an RRTPlanner |
| RRTPlanner | Instance of dual-tree RRT planning |
| RRTState | A single instance of an arm state |
| RRTStateVector | |
| SensorObserverControl::RTViewControl | The real time view for SensorObserverControl is split into a separate class for more straightfoward handling of refreshes |
| CMVision::run< cclass > | |
| CMVision::run_mini< cclass > | |
| RunSequenceControl< SequenceSize > | Upon activation, loads a position from a file name read from cin (stored in ms/data/motion...) |
| SavePostureControl | Upon activation, saves the current position to a file name read from user (default is /ms/data/motion...) |
| ConfigurationEditor::SaveSettings | File browser to save a plist from the file system |
| SaveWalkControl | When activated, saves walk parameters to a file specified from cin |
| Profiler::SectionInfo | Holds all the information needed for book keeping for each timer |
| SegCamBehavior | Forwards segmented images from camera over wireless |
| Config::vision_config::SegCamConfig | Settings specific to the "SegCam" (segmented color images) for streaming video over the network |
| SegmentedColorFilterBankEvent | This event provides some additional color information over its superclass for image banks made up of indexed colors |
| SegmentedColorGenerator | Generates FilterBankEvents indexed color images based on a color threshold file |
| SemaphoreManager | Ideally, this would be SEMMSL, but that is hard to portably determine at compile time |
| KinematicJoint::SensorInfo | Base class for sensor descriptions, actual subclass name stored in sensorType |
| PostureEngine::SensorInfo | Used for storing sensor data loaded from file |
| ParticleFilter< ParticleT >::SensorModel | A sensor model is used to update particle weights to account based on each particle's ability to explain observations taken from the system |
| SensorMonitorBehavior | |
| SensorObserverControl | Allows logging of sensor information to the console or file |
| DriverMessaging::SensorPriority | Indicates priority of polling outputs/buttons/sensors, for those drivers which must actively poll for sensor data |
| KinematicJoint::SensorRangeFinder | |
| basic_netbuf< charT, traits >::SetScope< T > | This allows us to reset status variables like openInProgress if a thread cancel occurs |
| ShapeSpaceCollisionChecker | |
| ShapeSpacePlanner | |
| SharedObject< MC > | This templated class allows convenient creation of any type of class wrapped in a shared memory region |
| SharedObjectBase | It's nice to have a parent class of SharedObject (which is what you probably want to be reading) so that you can pass around the data structure without worrying about what type is inside the shared memory region |
| ShutdownControl | When activated, this will cause the aibo to shut down |
| SignalTrans< T > | Causes a transition if a DataEvent<T> from stateSignalEGID occurs, and checks for a specific value if one is specified |
| SimulatorAdvanceFrameControl | Requests the next camera frame and sensor data, for use when running in simulation |
| SineMC | Moves one or more outputs through a sinusoidal pattern |
| SingletonFactory< T > | A factory for singleton classes which return the instance via getInstance() |
| XWalkParameters::SinusoidalParameters | Specifies parameters for shifting the body position while in motion |
| SmoothCompareTrans< T > | A subclass of CompareTrans, which provides monitoring of exponentially weighted averages to a threshold |
| Socket | Tekkotsu wireless Socket class |
| SocketListener | Interface for notifications from Wireless |
| PlanarThreeLinkArm::Solutions | |
| Config::sound_config | Sound information |
| SoundManager::SoundData | Holds data about the loaded sounds |
| SoundManager | Provides sound effects and caching services, as well as mixing buffers for the SoundPlay process |
| SoundManagerMsg | A small header that preceeds data sent by SoundManager between processes |
| SoundNode | A simple StateNode that plays a sound upon startup and posts a status event on completion |
| SpeakerServer | Plays streamed audio via the speaker |
| SpeechNode | A simple StateNode that plays a sound upon startup and posts a status event on completion |
| stacktrace::StackFrame | Stores information about a single stack frame |
| EventLogger::StateMachineListener | Separate processEvent to distinguish between events requested for logging and events requested by a remote monitor |
| StateNode | Recursive data structure - both a state machine controller as well as a node within a state machine itself |
| MessageQueueStatusThread::StatusListener | An interface to allow you to receive callbacks when a message has been read from a MessageQueue, subscribed via an external class which is monitoring the queue's MessageQueueBase::pollStatus() (e.g. LoadFileThread) |
| Config::sound_config::streaming_config | Audio streaming configuration |
| Config::vision_config::StreamingConfig | Settings related to streaming video over the network |
| plist::ArrayBase::StringConversion | Abstract base class to test whether the collection will accept strings (possibly converting to a value type, or storing directly as string depending on concrete type) |
| plist::DictionaryBase::StringConversion | Abstract base class to test whether the collection will accept strings (possibly converting to a value type, or storing directly as string depending on concrete type) |
| StringInputControl | Upon activation, prompts the user for a string and stores it |
| fmat::SubMatrix< H, W, R > | |
| fmat::SubMatrix_has_more_columns_than_source | |
| fmat::SubMatrix_has_more_rows_than_source | |
| fmat::SubVector< N, R > | |
| fmat::SubVector_is_longer_than_source | |
| TailWagMC | A simple motion command for wagging the tail - you can specify period, magnitude, and tilt |
| TailWagNode | A simple StateNode that executes a TailWagMC motion command |
| TorqueCalibrate::TakeMeasurementControl | |
| TextMsgEvent | Extends EventBase to also include actual message text |
| TextMsgTrans | Fires when a matching string is received |
| Thread | Provides a nice wrapping of pthreads library |
| TimeET | Nice class for handling time values with high precision |
| TimeOutTrans | Causes a transition after a specified amount of time has passed |
| Profiler::Timer | Measures the time that this class exists, reports result to a profiler |
| EventRouter::TimerEntry | Contains all the information needed to maintain a timer by the EventRouter |
| EventRouter::TimerEntryPtrCmp | Used by STL to sort the timer list in order of activation time |
| TimerEvent | Adds a target field to EventBase so listeners can resolve source ID conflict between different behaviors |
| fmat::fmat_internal::tmemset_pattern< T, W > | |
| fmat::fmat_internal::tmemset_pattern< T, 1 > | |
| ToggleControl | Simple control for turning things on and off |
| TorqueCalibrate | Provides an interface for making measurements to correlate PID duty cycle and actual force output for each of the motors |
| fmat::fmat_internal::transformOps< R1, R2 > | |
| fmat::TransformT< R > | |
| Transition | Represents a transition between StateNodes |
| tz | |
| fmat::fmat_internal::unconst< T > | |
| fmat::fmat_internal::unconst< const bool > | |
| fmat::fmat_internal::unconst< const char > | |
| fmat::fmat_internal::unconst< const double > | |
| fmat::fmat_internal::unconst< const float > | |
| fmat::fmat_internal::unconst< const int > | |
| fmat::fmat_internal::unconst< const long > | |
| fmat::fmat_internal::unconst< const long double > | |
| fmat::fmat_internal::unconst< const short > | |
| fmat::fmat_internal::unconst< const unsigned char > | |
| fmat::fmat_internal::unconst< const unsigned int > | |
| fmat::fmat_internal::unconst< const unsigned long > | |
| fmat::fmat_internal::unconst< const unsigned short > | |
| UPennWalkControllerBehavior | Listens to control commands coming in from the command port for remotely controlling the walk |
| UPennWalkMC | Uses the UPennalizers' 2004 RoboCup code to compute walking gaits |
| uyvy | |
| value_conversion | |
| value_conversion | |
| value_conversion | |
| value_conversion | |
| value_conversion | |
| value_conversion | |
| value_conversion | |
| value_conversion | |
| value_conversion | |
| value_conversion | |
| value_conversion | |
| ValueEditControl< T > | Allows real-time modification of a value through a pointer |
| ValueSetControl< T > | Upon activation, this control will set the target pointer to the specified value |
| ViewWMVarsBehavior | Simply launches the Watchable Memory GUI, which should connect to the already-running WMMonitorBehavior |
| Config::vision_config | Vision configuration options (this is a *big* section, with sub-sections) |
| VisionObjectEvent | Extends EventBase to also include location in the visual field and distance (though distance is not implimented yet) |
| VisualRoutinesBehavior | |
| VisualRoutinesStateNode | |
| VisualTargetCloseTrans | Causes a transition when a visual object is "close" |
| VisualTargetTrans | Causes a transition when a visual object has been seen for at least 6 camera frames |
| BallDetectionGenerator::VObject | High level vision ouput structure for detected objects |
| WalkCalibration | Allows interactive calibration of a walk engine |
| WalkControllerBehavior | Listens to control commands coming in from the command port for remotely controlling the walk |
| WalkEdit | Editor for the CMPack-based Aibo walk engine |
| WalkEngineNode< W, mcName, mcDesc > | A StateNode for walking in a direction, use the template parameter to specify a custom walk MC, or use WalkNode to accept the "default" walk |
| WALKMC | |
| WalkMC | A nice walking class from Carnegie Mellon University's 2001 Robosoccer team, modified to fit this framework, see their license |
| WalkNode | A StateNode for walking using WalkMC; a special case of WalkEngineNode |
| WalkMC::WalkParam | Holds more general parameters about the walk |
| WalkRequest | A request to walk at a specified velocity or for a specific distance, to be used in a SignalTrans |
| WalkToTargetNode | State node for walking towards a visual target |
| WAV | |
| WaypointEngine< MAX_WAY >::Waypoint | Holds information about each waypoint, see WaypointEngine for overview |
| WaypointWalkControl::WaypointEditControl | Handles editing of individual waypoints |
| WaypointEngine< MAX_WAY > | Provides computation and management of a desired path through a series of waypoints |
| WaypointEngineNode< W, mcName, mcDesc > | A StateNode for doing a waypoint walk, use the template parameter to specify a custom walk MC, or use the WaypointWalkNode typedef to accept the "default" walk |
| WaypointWalk< MAX_WAY > | Combines a WaypointEngine with a WalkMC so you can walk between a set of waypoints |
| WaypointWalkControl | Allows interactive control and execution of a set of waypoints |
| Wireless | Tekkotsu wireless class |
| Config::wireless_config | Wireless configuration options |
| WMentry | A WMentry is an entry in a WMregistry |
| WMitem< T > | WMitem<T> is a reference to the variable of type T described by the associated WMentry |
| WMitem_base | WMitem_base is the base class from which all WMitem<T> subclasses are derived |
| WMMonitorBehavior | Listens to wmmonitor control commands coming in from the command port |
| WMregistry | A WMregistry is a namespace; it holds a collection of WMEntry instances describing the variables that live in this registry |
| WorldState | The state of the robot and its environment |
| WorldStateLookup | This class masquerades as a simple WorldState pointer, but actually checks the process ID of the referencing thread to allow each thread group to have a separate WorldState* |
| WorldStateSerializerBehavior | Copies WorldState into a buffer for transmission over the network |
| WorldStateVelDaemon | Listens for LocomotionEvents and updates the velocity fields of WorldState |
| plist::ArrayBase::WrapValueConversion< PO > | This conversion policy accepts any entries of the specified template type, values will be directly wrapped as Primitives so no conversion at all is actually performed |
| plist::DictionaryBase::WrapValueConversion< PO > | This conversion policy accepts any entries of the specified template type, values will be directly wrapped as Primitives so no conversion at all is actually performed |
| XMLLoadSave | XMLLoadSave adds functions for XML format serialization, although if you write binary LoadSave functions as well, you can do either |
| XWalkControllerBehavior | Listens to control commands coming in from the command port for remotely controlling the walk |
| XWalkMC | Extreme walk engine handles legged locomotion on hexapods and beyond |
| XWalkNode | A StateNode for walking using XWalkMC; a special case of WalkEngineNode |
| XWalkParameters | Parameters used by XWalkMC to control gait |
| yuv | |
| yuvf | |
| yuvi | |
| yuyv | |
