Aibo3DControllerBehavior | Listens to aibo3d control commands coming in from the command port |
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 | |
plist::ArrayBase | Maintains an array of value, see ArrayOf, and the Array typedef |
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 |
plist::ArrayBase::DeniedValueConversions | Indicates that no value conversions are allowed |
plist::ArrayBase::EntryConstraint< PO > | |
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) |
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) |
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::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::ArrayOf< PO, Alloc > | A collection of plist objects, similar to a Dictionary, but no keys -- order matters!, see plist::Array |
AutoGetupBehavior | Little background behavior to keep the robot on its feet |
BallDetectionGenerator | Uses segmented color region information to detect round objects |
BallDetectionGenerator::VObject | High level vision ouput structure for detected 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 which will monitor the power level and flip the ears when appropriate on a 210, or blink the headlight if a 220 |
BehaviorActivatorControl | Upon activation, will start, stop, or toggle a behavior |
BehaviorBase | The basis from which all other Behaviors should inherit |
BehaviorReportControl | Reads the set of currently instantiated behaviors and sends a report to sout |
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 |
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 |
Buffer | Buffer |
BufferedImageGenerator | Receives camera frames as they are loaded by the simulator -- or eventually other sources |
BufferedImageGenerator::ImageSource | Stores information about the current frame, (not the image itself, but meta data a pointer to it) |
CameraStreamBehavior | Base class for camera streaming communication classes, handles upstream communication |
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 |
Cloneable | An interface for cloning objects -- needed for making copies with polymorphism (operator= doesn't work as virtual) |
plist::Collection | Provides a common base class for the collection-oriented primitives, Dictionary and Array |
plist::Collection::conversion_policy< U, V > | Specifies that a collection of collections cannot contain any primitive values |
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() |
CMVision::color_class_state | |
CompareTrans< T > | Causes a transition if a value (through a pointer) goes above a given value |
CompletionTrans | Causes a transition when at least n sources have signalled completion; n = 0 means "all" (default) |
ThreadNS::Condition | Provides an inter-thread signaling and synchronization mechanism |
Config | Root configuration object, provides some global functionality like porting pathnames (portPath()) |
Config::behaviors_config | Place for users to put their own configuration |
Config::controller_config | Controller information |
Config::main_config | General configuration options |
Config::motion_config | Motion information |
Config::sound_config | Sound information |
Config::sound_config::streaming_config | Audio streaming configuration |
Config::vision_config | Vision configuration options (this is a *big* section, with sub-sections) |
Config::vision_config::CameraCalibration | These values represent a "Plumb Bob" model introduced by Brown in 1966 |
Config::vision_config::RawCamConfig | Settings specific to the "RawCam" (original camera images) for streaming video over the network |
Config::vision_config::RegionCamConfig | Settings specific to the "RegionCam" (only display a box for each blob of color) for streaming over the network |
Config::vision_config::SegCamConfig | Settings specific to the "SegCam" (segmented color images) for streaming video over the network |
Config::vision_config::StreamingConfig | Settings related to streaming video over the network |
Config::wireless_config | Wireless configuration options |
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 |
ConfigurationEditor::AddCollectionEntry | Displays a list of template objects (see ConfigurationEditor::getObjectTemplates()) which can be added to a target collection |
ConfigurationEditor::LoadSettings | File browser to load a plist from the file system |
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) |
ConfigurationEditor::NewCollectionEntry | Interface to set up a new collection entry before inserting it |
ConfigurationEditor::SaveSettings | File browser to save a plist from the file system |
ConnectionMadeTrans | Transition that occurs as soon as a connection is made |
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 |
DataEvent< T, TID > | For passing around data (or pointers to data) |
DeadReckoningBehavior< ParticleT > | Subscribes to LocomotionEvents and attempts to track robot movement over time using a fairly generic HolonomicMotionModel |
plist::DictionaryBase | Maintains a set of (key,value) pairs, see DictionaryOf, and the Dictionary typedef |
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::DictionaryBase::DeniedValueConversions | Indicates that no value conversions are allowed |
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::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::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::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) |
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 |
plist::DictionaryOf< PO, Alloc > | A dictionary which requires all elements to be subtypes of the PO template argument |
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...) |
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 |
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 |
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 |
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 |
EventLogger::StateMachineListener | Separate processEvent to distinguish between events requested for logging and events requested by a remote monitor |
EventProxy | |
EventRouter | This class will handle distribution of events as well as management of timers |
EventRouter::EventMapper | Does the actual storage of the mapping between EventBase's and the EventListeners/EventTrappers who should receive them |
EventRouter::PostingStatus | Information regarding the progress of posting an event |
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 |
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 |
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 |
Factory0_1Arg< Base, A1 >::Factory< T > | Concrete class for constructing products of a specified subtype of Base |
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 |
Factory0Arg1Member< Base, M1 >::Factory< T > | Concrete class for constructing products of a specified subtype of Base |
Factory0Arg1Static< Base, S1, s1 > | This class produces objects based on a constant specified as a template parameter |
Factory0Arg1Static< Base, S1, s1 >::Factory< T > | Concrete class for constructing products of a specified subtype of Base |
Factory0Arg2Static< Base, S1, s1, S2, s2 > | This class produces objects based on constant values specified as a template parameters |
Factory0Arg2Static< Base, S1, s1, S2, s2 >::Factory< T > | Concrete class for constructing products of a specified subtype of Base |
Factory0Arg< Base >::Factory< T > | Concrete class for constructing products of a specified subtype of Base |
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 |
Factory1Arg1Static< Base, A1, S1, s1 >::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 |
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 |
Factory1Static1Arg< Base, S1, s1, A1 >::Factory< T > | Concrete class for constructing products of a specified subtype of Base |
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.. |
Factory1Static_1Arg< Base, S1, s1, A1 >::Factory< T > | Concrete class for constructing products of a specified subtype of Base |
FactoryInvalidT<> | A factory interface which doesn't actually allow anything to be produced (for completeness, like 'NULL') |
FactoryInvalidT<>::Factory< U > | Concrete class for not doing anything |
FactoryT | |
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) |
FamilyFactory< FamilyT, NameT, FactoryBaseT, FactoryT >::FactoryType< T > | Allows indirect access to create factory classes |
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 |
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 |
Graphics | Provides basic graphics capabilities for drawing into any bitmap, particularly FilterBankGenerators |
GroupNode | Allows a group of StateNodes to be activated together |
hashcmp_eqstr | |
HeadPointControllerBehavior | 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 |
HolonomicMotionModel< ParticleT > | This class can model the path of a holonomic robot in two dimensions (x and y) |
CMVision::image< pixel > | |
CMVision::image_idx< pixel > | |
CMVision::image_yuv< element > | |
InstanceTracker< FamilyT, ClassNameT, FactoryBaseT, FactoryT > | Attempts to provide references to all currently instantiated objects of a class (and its subclasses) |
InstanceTracker< FamilyT, ClassNameT, FactoryBaseT, FactoryT >::FactoryType< T > | Allows indirect access to create factory classes |
InstanceTracker< FamilyT, ClassNameT, FactoryBaseT, FactoryT >::InstanceEntry | Provides a wrapper for non-plistDictionary entries |
InterleavedYUVGenerator | Generates FilterBankEvents containing raw camera images with interleaved pixels (YUVYUVYUV... instead of YYY...UUU...VVV...) |
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 |
Kinematics | Provides access to the mathematical functionality of the ROBOOP package using Tekkotsu data structures |
Kinematics::hashstring | Allows us to use the STL hash_map with strings |
Kinematics::InterestPoint | Holds the position and attached link of a given interest point |
Kinematics::JointMap | Allows mapping from tekkotsu output index to chain and link indicies |
LedEngine | Provides basic LED effects via subclassing (e.g. LedMC) or embedding (e.g. EmergencyStopMC) |
LedEngine::LEDInfo | Holds all the information needed by each of the LEDs |
LedMC | This is just a simple wrapper - you probably want to be looking at LedEngine |
LedNode | A simple StateNode that executes a LedMC motion command and throws a status event upon completion |
LGmixin | Mix-in for the BehaviorBase or StateNode class to give access to Looking Glass variables |
plist::Listener | Base class for the plist listener callbacks |
ListMemBuf< T_t, MAX, idx_t > | Provides some degree of dynamic allocation of a templated type from a buffer of set size |
ListMemBuf< T_t, MAX, idx_t >::entry_t | Holds data about an entry in the free/used lists |
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...) |
LoadSave | Intended as an interface to allow easy and portable serialization operations |
LoadWalkControl | When activated, loads a set of walk parameters from a file specified by user |
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 |
ThreadNS::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 |
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 |
MarkScope | Provides a way to mark a resource as used for the duration of the instance's scope |
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 |
MessageQueue< MAX_UNREAD, MAX_RECEIVERS, MAX_SENDERS > | An implementation of MessageQueueBase, which provides mechanisms for sending shared memory regions between processes |
MessageQueue< MAX_UNREAD, MAX_RECEIVERS, MAX_SENDERS >::entry | Data storage needed for each message |
MessageQueueBase | Defines the interface for sending new shared memory regions between processes |
MessageQueueBase::MessageFilter | Interface for filtering (or otherwise monitoring) messages being sent through a MessageQueue, see MessageQueueBase::addMessageFilter() |
MessageQueueStatusThread | Description of MessageQueueStatusThread |
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) |
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 |
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 |
MotionManager::CommandEntry | All the information we need to maintain about a MotionCommand |
MotionManager::OutputState | Holds the full requested value of an output |
MotionManager::PIDUpdate | Used to request pids for a given joint |
MotionManagerMsg | A small header that precedes data sent by MotionManager between processes |
MotionSequenceEngine | A handy class for storing a sequence of keyframed movements |
MotionSequenceEngine::Move | This struct holds all the information needed about a frame for a particular output |
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) |
MutexLock< num_doors > | Implements a mutual exclusion lock using semaphores (SYSV style through SemaphoreManager) |
MutexLockBase | The main purpose of this base class is actually to allow setting of usleep_granularity across all locks |
MutexLockBase::no_more_semaphores | Exception if a lock is created but there aren't any more semaphores available |
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::NamedEnumeration< T >::conversion_policy< U, V > | |
plist::NamedEnumerationBase | Some accessors common across NamedEnumeration types |
NetworkBuffer | |
NetworkStatusControl | Will display current network status such as wireless signal strength |
NoOpEventTranslator | For completeness, if you want to have events be piped directly to the local erouter instead having to be encoded and decoded |
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 |
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 |
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 |
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 |
ParticleBase | 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 |
ParticleFilter< ParticleT >::DistributionPolicy | A distribution policy provides the ability to randomize ("redistribute") or tweak the values of a group of particles |
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 |
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 |
ParticleFilter< ParticleT >::ResamplingPolicy | The resampling policy focuses the particle filter on those particles which are performing well, and dropping those which are poorly rated |
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 |
PIDMC | A nice little MotionCommand for manually manipulating the PID values |
PitchDetector | Generates a PitchEvent whenever a notable frequency is detected using FFT |
PitchDetector::PitchInfo | Stores info about the pitch currently being detected |
PitchEvent | Provides information about a tone detected from the microphone(s) |
PlaySoundControl | Upon activation, loads a position from a file name read from cin (stored in ms/data/motion...) |
PNGGenerator | Generates FilterBankEvents containing PNG compressed images |
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 |
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 |
plist::Primitive< T > | |
plist::Primitive< T >::conversion_policy< U, V > | |
plist::Primitive< char > | |
plist::Primitive< char >::conversion_policy< U, V > | |
plist::Primitive< std::string > | Provides a std::string specialization of Primitive<T> |
plist::Primitive< std::string >::conversion_policy< U, V > | |
plist::Primitive< unsigned char > | unsigned char specialization of plist::Primitive<T>, adds a unique numeric property to the usual template implementation |
plist::Primitive< unsigned char >::conversion_policy< U, V > | |
plist::PrimitiveBase | Provides common functionality to all primitive value classes (implemented in a templated subclass Primitive) |
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 |
Profiler::AutoInit | Automatically causes initialization of the histogram buckets when the first Profiler is instantiated |
Profiler::SectionInfo | Holds all the information needed for book keeping for each timer |
Profiler::Timer | Measures the time that this class exists, reports result to a profiler |
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 |
QBotPlusInfo::QBotPlusCapabilities | Polymorphic robot capability detection/mapping |
RandomTrans | A transition that fires immediately, randomly choosing one destination node to activate |
RawCamBehavior | Forwards images from camera over wireless |
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 |
RCRegion::Identifier | All information needed to attach this region from a different process |
RebootControl | When activated, this will cause the aibo to reboot |
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 |
RegionGenerator | Connects regions of CMVision format runs in RLEGenerator |
RegionRegistry< MAX_REGIONS, NAME_LEN > | Keeps track of currently available shared memory regions |
RegionRegistry< MAX_REGIONS, NAME_LEN >::entry | Holds information regarding a shared memory region available for listening |
Regis1Info::Regis1Capabilities | Polymorphic robot capability detection/mapping |
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 | |
Resource | Provides a generic interface for resources which need to keep track of when they are in use, such as mutex locks |
Resource::Data | Base class for holding data required for requesting to use/release the resource |
ResourceAccessor< R > | A variation of MarkScope which allows you to forward access to the resource via the '->' operator, smart-pointer style |
rgb | |
rgba | |
rgbaf | |
rgbf | |
RLEGenerator | Generates RLE compressed FilterBankEvents (generally from indexed color images from, say, SegmentedColorGenerator) |
RoverControllerBehavior | DESCRIPTION |
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...) |
SaveWalkControl | When activated, saves walk parameters to a file specified from cin |
SegCamBehavior | Forwards segmented images from camera over wireless |
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 |
SegmentedColorGenerator::NoThresholdException | Thrown if no threshold maps are available |
SemaphoreManager | Initializes, manages, and releases a set of System V style semaphores |
SensorObserverControl | Allows logging of sensor information to the console or file |
SensorObserverControl::RTViewControl | The real time view for SensorObserverControl is split into a separate class for more straightfoward handling of refreshes |
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 from stateSignalEGID occurs with a specific value |
SimulatorAdvanceFrameControl | Requests the next camera frame and sensor data, for use when running in simulation |
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 |
SoundManager | Provides sound effects and caching services, as well as mixing buffers for the SoundPlay process |
SoundManager::PlayState | Holds data about sounds currently being played |
SoundManager::SoundData | Holds data about the loaded sounds |
SoundManagerMsg | A small header that preceeds data sent by SoundManager between processes |
SoundNode | A simple StateNode that plays a sound upon startup and throws a status event on completion |
SpeakerServer | Plays streamed audio via the speaker |
SpeakerServer::Packet | Stores information about current sound buffer |
stacktrace::StackFrame | Stores information about a single stack frame |
StateNode | Recursive data structure - both a state machine controller as well as a node within a state machine itself |
StewartPlatformBehavior | Moves the legs in synchrony to emulate the capabilities of a stewart platform |
StringInputControl | Upon activation, prompts the user for a string and stores it |
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 |
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 |
TimerEvent | Adds a target field to EventBase so listeners can resolve source ID conflict between different behaviors |
ToggleControl | Simple control for turning things on and off |
ToggleControl::RadioGroup | Little class for managing the currently active ToggleControl to allow radio buttons |
TorqueCalibrate | Provides an interface for making measurements to correlate PID duty cycle and actual force output for each of the motors |
TorqueCalibrate::TakeMeasurementControl | |
Transition | Represents a transition between StateNodes |
value_conversion | |
value_conversion | |
tz | |
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 | |
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 |
VisionObjectEvent | Extends EventBase to also include location in the visual field and distance (though distance is not implimented yet) |
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 |
WalkCalibration | Allows interactive calibration of a walk engine |
WalkControllerBehavior | Listens to control commands coming in from the command port for remotely controlling the walk |
WalkEngineNode< W, mcName, mcDesc > | A StateNode for walking in a direction, use the template parameter to specify a custom walk MC, or use the WalkNode typedef to accept the "default" walk |
WalkMC | A nice walking class from Carnegie Mellon University's 2001 Robosoccer team, modified to fit this framework, see their license |
WalkMC::CalibrationParam | Holds information to correct for slippage, non-idealities |
WalkMC::LegParam | Holds parameters about how to move each leg |
WalkMC::LegWalkState | Holds state about each leg's path |
WalkMC::WalkParam | Holds more general parameters about the walk |
WalkToTargetNode | State node for walking towards a visual target |
WAV | |
WaypointEngine< MAX_WAY > | Provides computation and management of a desired path through a series of waypoints |
WaypointEngine< MAX_WAY >::Waypoint | Holds information about each waypoint, see WaypointEngine for overview |
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 |
WaypointWalkControl::WaypointEditControl | Handles editing of individual waypoints |
Wireless | Tekkotsu wireless class |
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* |
WorldStatePool | Holds multiple instances of WorldState, allows one process to be updating while another is reading |
WorldStatePool::ReadRequest | Retrieves the current WorldState entry, and through it's destructor, marks the entry available again when it goes out of scope |
WorldStatePool::Request | Common base class for ReadRequest or WriteRequest |
WorldStatePool::UpdateInfo | Returned by isUnread containing information parsed from the incoming message |
WorldStatePool::WriteRequest | Retrieves the current WorldState entry, and through it's destructor, marks the entry available again when it goes out of scope |
WorldStateSerializerBehavior | Copies WorldState into a buffer for transmission over the network |
WorldStateVelDaemon | Listens for LocomotionEvents and updates the velocity fields of WorldState |
XMLLoadSave | XMLLoadSave adds functions for XML format serialization, although if you write binary LoadSave functions as well, you can do either |
XMLLoadSave::AutoInit | Allows automatic (de)initialization of libxml when the first or last XMLLoadSave class is created or destroyed |
XMLLoadSave::bad_format | Exception to be thrown when a bad XML file is parsed, allows file position information to be passed to the user |
yuv | |
yuvf | |
yuvi | |
yuyv | |