| DualCoding::Pilot::PushObjectMachine::AddAcquirePt | |
| DualCoding::Pilot::PushObjectMachine::AddBackupPt | |
| ConfigurationEditor::AddCollectionEntry | Displays a list of template objects (see ConfigurationEditor::getObjectTemplates()) which can be added to a target collection |
| DualCoding::Pilot::ExecutePlan::AdjustHeading | Perform an adjusting turn if we localized successfully, or a collision occurred |
| DualCoding::Pilot::PushObjectMachine::AdjustPush | |
| AdmissibilityPredicate< NODE > | Base class for admissibility predicates to determine whether a node is admissible |
| 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) |
| AngSignTwoPi | Turn with an explicit direction: angles between -2*pi and 2*pi (+/- 360 degrees) |
| AngTwoPi | Circular arithmetic on angles between 0 and two pi (360 degrees) |
| argb | |
| argbf | |
| ArmController | Listens to control commands coming in from the command port for remotely controlling the arm |
| Grasper::ArmGrasp | Close fingers to grasp the object |
| ArmMC | |
| ArmNode | A simple StateNode that executes a ArmMC motion command |
| Grasper::ArmNudge | Move the object to test that it was grasped successfully |
| ArmPower | |
| Grasper::ArmPulse | Set or clear gripper pulsing to prevent load errors |
| Grasper::ArmRaise | Raise the object for transport |
| 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 |
| axisVarPair | |
| KoduInterpreter::GiveActionRunner::Backup | |
| 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 |
| DualCoding::Pilot::BearingLessThan | Functor used to sort gaze points by their relative bearing from the robot |
| 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 |
| Config::behaviors_config | Place for users to put their own configuration |
| 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 |
| binary_function | |
| BoundingBox< N, T > | Bounding box of a shape; used for coordinate calculations |
| BoxObstacle | |
| KinematicJoint::BranchListener | |
| Buffer | Buffer |
| BufferedImageGenerator | Receives camera frames as they are loaded by the simulator -- or eventually other sources |
| CMPackWalkMC::CalibrationParam | Holds information to correct for slippage, non-idealities |
| CallbackPollThread | |
| CallbackThread | A simple adapter to cause a callback under a new thread |
| Calliope2SPInfo::Calliope2SPCapabilities | Polymorphic robot capability detection/mapping |
| Calliope3Info::Calliope3Capabilities | |
| Calliope5KPInfo::Calliope5KPCapabilities | Polymorphic robot capability detection/mapping |
| Calliope5SPInfo::Calliope5SPCapabilities | Polymorphic robot capability detection/mapping |
| CalliopeInfo::CalliopeCapabilities | Polymorphic robot capability detection/mapping |
| CalliopeLPInfo::CalliopeLPCapabilities | Polymorphic robot capability detection/mapping |
| CalliopeSPInfo::CalliopeSPCapabilities | Polymorphic robot capability detection/mapping |
| CalliopeUInfo::CalliopeUCapabilities | 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 |
| CameraData | |
| CameraShapeEvaluator | |
| 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 |
| Capabilities | |
| RobotInfo::Capabilities | Allows behaviors to lookup output/button/sensor names from other models to support basic cross-model portability |
| CBracketGrasperPredicate< N > | |
| CDTGenerator | Generates SegmentedColorFilterBankEvents with images provided from the system |
| AprilTags::Gridder< T >::Cell | |
| CharPtrKey | |
| DualCoding::Pilot::VisualSearchMachine::Check | |
| Grasper::Verify::CheckAprilTag | |
| Grasper::Verify::CheckCross | |
| Grasper::Verify::CheckDomino | |
| DualCoding::Pilot::LocalizationUtility::CheckEnoughLandmarks | |
| KoduInterpreter::MotionActionRunner::ExecuteMotionAction::ExecuteSimpleMotion::CheckForValidTarget | |
| Grasper::Verify::CheckGripperLoad | |
| KoduInterpreter::MotionActionRunner::ExecuteMotionAction::CheckMotionType | |
| DualCoding::Pilot::PushObjectMachine::CheckObjectPos | |
| DualCoding::Pilot::GoToShapeMachine::CheckParameters | Check that the request's goToShape parameters are valid |
| DualCoding::Pilot::PushObjectMachine::CheckParameters | |
| Grasper::Verify::CheckUserVerify | |
| Chiara2Info::ChiaraCapabilities | Polymorphic robot capability detection/mapping |
| ChiaraInfo::ChiaraCapabilities | Polymorphic robot capability detection/mapping |
| DualCoding::Pilot::LocalizationUtility::ChooseGazePoints | |
| DualCoding::Pilot::PushObjectMachine::ChoosePathInitToObj | |
| DualCoding::Pilot::PushObjectMachine::ChoosePathObjToDest | |
| CircularObstacle | Circle/Sphere defined obstacle designated by a center point and a radius |
| DualCoding::Pilot::ClearOldPath | |
| Kodu::ClearSelfShape | |
| Cloneable | An interface for cloning objects -- needed for making copies with polymorphism (operator= doesn't work as virtual) |
| Grasper::CloseTheGripper | Close the gripper |
| CMPackWalkMC | A nice walking class from Carnegie Mellon University's 2001 Robosoccer team, modified to fit this framework, see their license |
| 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() |
| DualCoding::Pilot::CollisionChecker | Collision checker service; its behavior is model-dependent |
| RRTNode2DR< N >::CollisionChecker | |
| RRTNode3DR< N >::CollisionChecker | |
| RRTNodeXYTheta::CollisionChecker | |
| RRTNodeXY::CollisionChecker | Collision checker to be called by RRT search algorithm |
| DualCoding::Pilot::CollisionDispatch | Used by Pilot walk machines to decide how to respond to a collision |
| 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 > | |
| KoduInterpreter::CompleteSayActuator | |
| 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 | |
| DualCoding::Pilot::ConstructNavPlan | Construct a navigation plan: mixture of traveling, turning, and localizing steps |
| 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::NamedEnumeration< T >::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 |
| plist::DictionaryBase::ConversionTo< plist::Primitive< double > > | This is a specialization for double conversions to add RealConversions |
| plist::DictionaryBase::ConversionTo< plist::Primitive< float > > | This is a specialization for float conversions to add RealConversions |
| ConvexPolyObstacle | Manages collision detection with convex polygons |
| AStar::Node< State >::CostCmp | Search nodes should be sorted based on total cost (total) |
| KoduInterpreter::MotionActionRunner::ExecuteMotionAction::ExecuteSimpleMotion::CreateFinalApproachCommand | |
| KoduInterpreter::GrabActionRunner::ExecuteGrabAction::CreateGripMonTask | |
| KoduInterpreter::PerceptualMultiplexor::FailureRecovery::LocalizeAgent::CreateLocalizeTask | |
| CreateMotionModel< ParticleT > | |
| CreateOdometry | Holds particle-independent odometry code so we can avoid templating and just recompile the cc file |
| KoduInterpreter::InitializeAgent::CreateWorld | |
| CylindricalObstacle | Cylinder with central axis in alignment with z-axis by default |
| AprilTags::UnionFindSimple::Data | Identifies parent ids and sizes |
| 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 |
| DepthCam | |
| Config::vision_config::DepthCamConfig | |
| 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 |
| DualCoding::Pilot::Dispatch | |
| DualCoding::Pilot::ExecutePlan::DisplacementInstruction | Each turn or travel step in a navigation plan is a DisplacementInstruction |
| DualCoding::Pilot::PushObjectMachine::DisplayPathInitToObj | |
| DualCoding::Pilot::PushObjectMachine::DisplayPathObjToDest | |
| DualCoding::Pilot::PushObjectMachine::DisplayStraightLineInitToObj | |
| DualCoding::Pilot::PushObjectMachine::DisplayStraightLineObjToDest | |
| 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 > | |
| Grasper::DoArmApproach | Execute arm motion to get fingers around the object |
| Grasper::DoArmDeliver | Execute arm motion to deposit the object at its destination |
| Grasper::DoBodyApproach | Execute body motion to approach the object |
| Grasper::DoBodyApproach2 | For Calliope2SP: move body instead of arm to acquire the object |
| Grasper::DoBodyApproach3 | For Calliope2SP: move body instead of arm to acquire the object |
| Grasper::DoBodyTransport | Execute body move for dropoff |
| Grasper::DoWithdraw | DoWithdraw from the object |
| Draw | A very simple drawing environment, originally to visualize planner stuff |
| KoduInterpreter::GiveActionRunner::Drop | |
| KoduInterpreter::DropActionRunner::DropActionEnd | |
| KoduInterpreter::DropActionRunner | |
| KoduInterpreter::DropActionRunner::DropActionStart | |
| KoduInterpreter::DropActionRunner::ExecuteDrop::DropItem | |
| LookAtMarkers::DummyFinish | |
| 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) |
| DynamicRobotState | This class provides a dynamic storage and serialization of robot state, such as output positions, buttons, and sensors |
| EchoBehavior | Waits for a connection, echos any data received back to the sender |
| AprilTags::Edge | Represents an edge between adjacent pixels in the image |
| EllipsoidObstacle | |
| EllipticalObstacle | Elliptically defined obstacle |
| 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 |
| KoduInterpreter::PerceptualMultiplexor::FailureRecovery::EndRecovery | |
| 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 |
| EStopController | 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 |
| KoduInterpreter::PerceptualMultiplexor::MapBuilderTaskRunner::ExamineMapBuilderResults | |
| VL::Exception | Generic exception |
| KoduInterpreter::MotionActionRunner::ExecuteMotionAction::ExecuteDriverMotion | |
| KoduInterpreter::DropActionRunner::ExecuteDrop | |
| KoduInterpreter::MotionActionRunner::ExecuteMotionAction::ExecuteGoToShapeRequest | |
| KoduInterpreter::GrabActionRunner::ExecuteGrabAction | |
| KoduInterpreter::PerceptualMultiplexor::MapBuilderTaskRunner::ExecuteMapBuilderTask | |
| KoduInterpreter::MotionActionRunner::ExecuteMotionAction | |
| KoduInterpreter::PerceptualMultiplexor::PilotTaskRunner::ExecutePilotTask | |
| DualCoding::Pilot::ExecutePlan | Execute a navigation plan; used for both goToShape and pushObject |
| KoduInterpreter::MotionActionRunner::ExecuteMotionAction::ExecuteSimpleMotion | |
| KoduInterpreter::MotionActionRunner::ExecuteMotionAction::ExecuteSimpleMotion::ExecuteSimpleTurn | |
| KoduInterpreter::MotionActionRunner::ExecuteMotionAction::ExecuteSimpleMotion::ExecuteSimpleWalk | |
| DualCoding::Pilot::ExecutePlan::ExecuteStep | |
| KoduInterpreter::GrabActionRunner::PrepareBody::FaceObject | |
| KoduInterpreter::PerceptualMultiplexor::FailureRecovery::ObjectManipRecovery::PrepareForItemRecovery::FaceTarget | |
| 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 |
| KoduInterpreter::PerceptualMultiplexor::FailureRecovery | |
| 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) |
| DualCoding::Pilot::PushObjectMachine::FetchObj | |
| FFPlanner | |
| FFPlanNode | |
| 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 |
| KoduInterpreter::MotionActionRunner::ExecuteMotionAction::ExecuteSimpleMotion::FindMotionTarget | |
| Grasper::FindObj | Re-acquire object on local map after moving the body |
| KoduInterpreter::ReceiveActionRunner::FindObject | |
| KoduInterpreter::ReceiveActionRunner::ReceiveActionTurnAndGet::FindObject | |
| KoduInterpreter::GrabActionRunner::ExecuteGrabAction::PrepareForAnotherGrasp::FindObjectAgain | |
| KoduInterpreter::PerceptualMultiplexor::FailureRecovery::ObjectManipRecovery::PrepareForAnotherGrasp::FindObjectAgain | |
| Grasper::FingersApproach | Open fingers far enough to accomodate object |
| 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 |
| AprilTags::FloatImage | Represent an image as a vector of floats in [0,1] |
| FlowVector | |
| FreeMemReportControl | Gives reports on free memory size at variable rates, can also warn if free memory drops too low |
| GaitedFootstepMC | Executes a series of footsteps, probably generated by applying astar() to a GaitedFootsteps domain |
| GaitedFootsteps | |
| GamepadController | Listens to Gamepad events coming in from the gamepad port |
| AprilTags::Gaussian | |
| DualCoding::GazePoint | |
| GenericAngularForceInterface | |
| GenericAngularMotorInterface | |
| GenericAngularPositionInterface | |
| GenericRRT< NODE, N > | Generic RRT implementation that makes no assumptions about the nature of the state space; those details are handled by the NODE template argument, which must be a subclass of RRTNodeBase |
| GenericRRTBase | |
| Grasper::Verify::GetAprilTag | |
| Grasper::Verify::GetCross | |
| Grasper::Verify::GetDomino | |
| KoduInterpreter::PerceptualMultiplexor::FailureRecovery::ObjectManipRecovery::InitiateManipRecovery::GetObjectInfo | |
| Grasper::Rest::GetOpenGripperFlag | |
| Grasper::Rest::GetRestType | |
| KoduInterpreter::GrabActionRunner::GrabActionStart::GetTagId | |
| KoduInterpreter::PerceptualMultiplexor::FailureRecovery::ObjectManipRecovery::GetTagLocation | |
| KoduInterpreter::GiveActionRunner | |
| KoduInterpreter::GiveActionRunner::GiveActionSend | |
| KoduInterpreter::GiveActionRunner::GiveActionStart | |
| AprilTags::GLine2D | A 2D line |
| AprilTags::GLineSegment2D | A 2D line with endpoints |
| DualCoding::Pilot::GoToShapeMachine | |
| GPSSensor | |
| KoduInterpreter::ReceiveActionRunner::ReceiveActionTurnAndGet::Grab | |
| KoduInterpreter::GrabActionRunner::GrabActionEnd | |
| KoduInterpreter::GrabActionRunner | |
| KoduInterpreter::GrabActionRunner::GrabActionStart | |
| KoduInterpreter::GrabActionRunner::ExecuteGrabAction::GrabObject | |
| Graphics | Provides basic graphics capabilities for drawing into any bitmap, particularly FilterBankGenerators |
| Grasper | The Grasper is the member of the Tekkotsu Crew responsible for arm-based manipulation |
| GrasperEvent | Event for reporting the results of a Grasper operation |
| Grasper::GrasperFailed | Report failure of the grasper request via a GrasperEvent |
| 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 |
| Grasper::GrasperSucceeded | Report successful completion of the grasper request via a GrasperEvent |
| GrasperTrans | Causes a transition if a GrasperEvent from grasperEGID occurs, and checks for a specific error value if one is supplied |
| AprilTags::GrayModel | Fits a grayscale model over an area of pixels |
| GreedySampler | Iteratively samples over a one dimensional numeric region by subdividing the largest unsampled region |
| AprilTags::Gridder< T > | A lookup table in 2D for implementing nearest neighbor |
| GridWorld | |
| GripperPower | |
| 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 |
| Kodu::HasAprilTagID | |
| hashcmp_eqstr | |
| Hashtable< data, key, hashFunc, equals > | |
| HeadController | 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 |
| HierarchicalObstacle | Hierarchically defined obstacle containing multiple obstacles |
| HingeAngularMotorInterface | |
| HingePositionInterface | |
| HingeVelocityInterface | |
| HolonomicMotionModel< ParticleT > | This class can model the path of a holonomic robot in two dimensions (x and y) |
| Homography | |
| Homography33 | Compute 3x3 homography using Direct Linear Transform |
| HoughKey | |
| RCRegion::Identifier | All information needed to attach this region from a different process |
| fmat::Matrix< H, W, R >::IdentityMatrix< HH, WW, RR > | |
| Grasper::IfRequestIs | |
| IKCalliope | Kinematics solver for the 5-DOF Calliope Arm |
| IKGradientSolver | Performs gradient descent on the joints to find a solution |
| IKSolver | Provides an abstract interface to inverse kinematic solvers |
| IKThreeLink | Performs analytical solution for position control of a variety of three or fewer link configurations |
| CMVision::image< pixel > | |
| CMVision::image_idx< pixel > | |
| CMVision::image_yuv< element > | |
| ImageBuffer | |
| DualCoding::ImageProfileOdometry | Image profile visual odometry |
| BufferedImageGenerator::ImageSource | Stores information about the current frame, (not the image itself, but meta data a pointer to it) |
| KoduInterpreter::InitializeAgent | |
| KoduInterpreter::PerceptualMultiplexor::FailureRecovery::ObjectManipRecovery::InitiateManipRecovery | |
| 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 |
| DualCoding::LookoutRequestBase::IRTask | |
| Kodu::IsMatchForTargetObject | |
| Kodu::IsNotExcludedShape | |
| Kodu::IsNotWorldShape | |
| KoduInterpreter::GrabActionRunner::GrabActionStart::IsObjectNear | |
| Kodu::IsShapeOfType | |
| Kodu::IsStar | |
| AprilTags::Gridder< T >::Iterator | Iterator for Segment class |
| RRTNode2DR< N >::CollisionChecker::JointObstacle | |
| RRTNode3DR< N >::CollisionChecker::JointObstacle | Coarse box-type obstacle representing a joint and all its components |
| JPEGGenerator | Generates FilterBankEvents containing JPEG compressed images |
| KDTree | |
| keygroup | |
| keypoint | |
| VL::Sift::Keypoint | SIFT keypoint |
| keypointPair | |
| 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 |
| KnowledgeBase | |
| Kodu::Parser::KodeCreator | Used to create the pages, rules, conditions, and actions of a Kodu program |
| Kodu::KoduAction | Kodu Action (derived from Kodu Behavior) |
| Kodu::KoduActionDoNothing | |
| Kodu::KoduActionDrop | Kodu Action Drop class (derived from Kodu Action) |
| Kodu::KoduActionGive | Kodu Action Give class (derived from Kodu Action) |
| Kodu::KoduActionGrab | Kodu Action Grab (derived from Kodu Action) |
| Kodu::KoduActionMotion | Kodu Action Motion (derived from Kodu Action) |
| Kodu::KoduActionPageSwitch | Kodu Action Page Switch class (derived from Kodu Action) |
| Kodu::KoduActionPlay | Kodu Action Play class (derived from Kodu Action) |
| KoduInterpreter::KoduActionRunner | Kodu Action Runner |
| Kodu::KoduActionSay | Kodu Action Say class (derived from Kodu Speech Action) |
| Kodu::KoduActionScore | Kodu Action Score (derived from Kodu Action) |
| Kodu::KoduAgent | |
| Kodu::KoduCondition | Kodu Condition (derived from Kodu Primitive) |
| Kodu::KoduConditionAlways | Kodu Condition Always (derived from Kodu Condition) |
| Kodu::KoduConditionBump | |
| KoduInterpreter::KoduConditionEvaluator | |
| Kodu::KoduConditionGamepad | |
| Kodu::KoduConditionGot | |
| Kodu::KoduConditionHear | |
| Kodu::KoduConditionScored | Kodu Condition Scored (derived from Kodu Condition) |
| Kodu::KoduConditionSee | |
| Kodu::KoduConditionTimer | |
| KoduConfig | |
| KoduDiscover | |
| KoduEventBase | |
| KoduInterpreter::KoduEventListener | |
| KoduGiveEvent | |
| KoduInterpreter | |
| Kodu::KoduObject | Kodu Object class |
| Kodu::KoduPage | Kodu Page |
| Kodu::KoduPrimitive | Kodu Primitive |
| Kodu::KoduRule | Kodu Rule |
| KoduSayEvent | |
| Kodu::KoduState | |
| Kodu::KoduWorld | |
| LedActivate | Simpler version of LedNode that turns on the specified LEDs on entry and explicitly turns them off again on exit |
| 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 | StateNode that executes a LedMC motion command and posts a status event upon completion |
| CMPackWalkMC::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 |
| CMPackWalkMC::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 |
| LGNode | A simple StateNode that provides the Looking Glass display methods via LGmixin |
| IKSolver::Line | Lines allow 1 freedom, slide along line |
| LinearMotorController | |
| 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 |
| RRTNode2DR< N >::CollisionChecker::LinkObstacle | |
| RRTNode3DR< N >::CollisionChecker::LinkObstacle | An obstacle representing the actual shape of one robot component |
| DriverMessaging::Listener | Interface for drivers to receive messages, see addListener() and removeListener() |
| 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 |
| Kodu::LiteralGenerator | |
| 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 |
| DualCoding::Pilot::LocalizationMachine | |
| LocalizationParticle | Each Particle represents a hypothesis about the robot's 2D position and heading |
| LocalizationParticleDistributionPolicy< ParticleT > | Provides parameters and methods for randomizing and tweaking LocalizationParticles |
| DualCoding::Pilot::LocalizationUtility | State machine called by various Pilot functions to perform a landmark search and localization |
| DualCoding::Pilot::LocalizationUtility::Localize | |
| KoduInterpreter::PerceptualMultiplexor::FailureRecovery::LocalizeAgent | |
| KoduInterpreter::DropActionRunner::ExecuteDrop::LocalizeAgent | |
| LocalShapeEvaluator | Provides evaluation of the match between local or camera and world given a candidate particle |
| KoduInterpreter::PerceptualMultiplexor::FailureRecovery::ObjectManipRecovery::PrepareForItemRecovery::LocateLostObject | |
| 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 |
| KoduInterpreter::InitializeAgent::LookAround | |
| KoduInterpreter::GrabActionRunner::ExecuteGrabAction::PrepareForAnotherGrasp::LookAroundForObject | |
| LookAtGripper | |
| LookAtMarkers | |
| KoduInterpreter::DropActionRunner::ExecuteDrop::LookAtObjectAprilTag | |
| KoduInterpreter::GrabActionRunner::ExecuteGrabAction::VerifyObjectWasGrabbed::LookAtTheGripper | |
| KoduInterpreter::PerceptualMultiplexor::FailureRecovery::ObjectManipRecovery::VerifyObjectWasGrabbed::LookAtTheGripper | |
| KoduInterpreter::ReceiveActionRunner::ReceiveActionTurnAndGet::LookDown | |
| DualCoding::Pilot::LookForObject | |
| KoduInterpreter::DropActionRunner::ExecuteDrop::RepositionReleasedObject::LookForObjectAgain | |
| KoduInterpreter::PerceptualMultiplexor::FailureRecovery::ObjectManipRecovery::PrepareForAnotherGrasp::LookForTag | |
| DualCoding::Pilot::LookForTarget | |
| DualCoding::Lookout | The Lookout accepts LookoutRequests to move the head and collect sensor information |
| LookoutEvent | Abstract base class for all Lookout Events |
| LookoutIREvent | |
| LookoutPointAtEvent | |
| DualCoding::LookoutPointRequest | Take a picture of or measure a distance to a point in space |
| DualCoding::LookoutRequestBase | Base class for requests to the Lookout |
| LookoutScanEvent | |
| DualCoding::LookoutScanRequest | |
| DualCoding::LookoutSearchRequest | Search for an object and return when found |
| LookoutSketchEvent | |
| DualCoding::LookoutTrackRequest | |
| 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 |
| MantisArmInfo::MantisArmCapabilities | Polymorphic robot capability detection/mapping |
| MantisInfo::MantisCapabilities | Polymorphic robot capability detection/mapping |
| MantisLegInfo::MantisLegCapabilities | Polymorphic robot capability detection/mapping |
| DualCoding::MapBuilder | |
| MapBuilderNode | Creates a MapBuilderRequest mapreq that the user can modify in their doStart() function, then executes the request when doStart() returns |
| DualCoding::MapBuilderRequest | |
| KoduInterpreter::PerceptualMultiplexor::MapBuilderTaskRunner | |
| MarkScope | Provides a way to mark a resource as used for the duration of the instance's scope |
| Kodu::MatchesObjectTagInGripper | A functor that will check if the object is still in the robot's gripper |
| matchInfo | |
| AprilTags::MathUtil | Miscellaneous math utilities and fast exp functions |
| 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 > > | |
| MoCapEvent | Provides notification of new external localization data |
| MoCapLogger | Provides display and logging of mocap data |
| model | |
| KnowledgeBase::modelMatchingInfo | |
| 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 |
| KoduInterpreter::MotionActionRunner | |
| Kodu::MotionCommand | |
| MotionCommand | The abstract base class for motions, provides common interface. All motions should inherit from this |
| KoduInterpreter::MotionActionRunner::MotionEnd | |
| 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 |
| 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) |
| KoduInterpreter::MotionActionRunner::MotionStart | |
| MotorController | Sync entries here with those in KinematicJoint::ControllerInfo |
| MotionSequenceEngine::Move | This struct holds all the information needed about a frame for a particular output |
| Grasper::MoveArm | Moves the body |
| DualCoding::Pilot::PushObjectMachine::MoveObjectPos | |
| KoduInterpreter::PerceptualMultiplexor::MultiplexorEnd | |
| KoduInterpreter::PerceptualMultiplexor::MultiplexorStart | |
| 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 | |
| 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) |
| DualCoding::PilotTypes::NavigationPlan | Stores and indexes into a sequence of actions to complete a navigation task |
| DualCoding::PilotTypes::NavigationStep | |
| KoduInterpreter::GrabActionRunner::ExecuteGrabAction::PrepareForAnotherGrasp::NeedToLookAround | |
| KoduInterpreter::PerceptualMultiplexor::FailureRecovery::ObjectManipRecovery::PrepareForAnotherGrasp::NeedToLookAround | |
| netstream_server | |
| NetworkBuffer | |
| ConfigurationEditor::NewCollectionEntry | Interface to set up a new collection entry before inserting it |
| Grasper::NextRequest | Move on to the next grasper request |
| DualCoding::Pilot::ExecutePlan::NextTask | |
| Thread::NoCancelScope | |
| AStar::Node< State > | Stores user state along with search context |
| nodeSqDistPair | |
| RRTNodeXYTheta::NodeValue_t | |
| RRTNode3DR< N >::NodeValueWrapper | |
| RRTNode2DR< N >::NodeValueWrapper | |
| fmat::fmat_internal::NoInit | |
| SharedObjectBase::NoInit | When passed to the SharedObject constructor, indicates that no RCRegion should be created |
| 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 |
| KoduInterpreter::NotificationMonitor | |
| NullControl | When activated, this will return immediately (handy for fake items in a menu) |
| NullTrans | Transition that occurs (via a 1 msec Timer event) as soon as the source node finishes starting up |
| Kodu::NumericGenerator | |
| object | |
| plist::ObjectBase | This base class provides the root functionality for all plist entities -- Dictionary and the various templated subclasses of PrimitiveBase |
| Kodu::ObjectKeeper | |
| KoduInterpreter::PerceptualMultiplexor::FailureRecovery::ObjectManipRecovery | |
| OCdtInfo | |
| OCdtVectorData | |
| ODataVectorInfo | Compatability with the OPEN-R type of the same name |
| OdometrySensor | Odometry is presently only used for the Create robot, which reports cumulative distances and angles |
| OFbkImage | |
| OFbkImageInfo | Compatability with the OPEN-R type of the same name |
| OFbkImageVectorData | Compatability with the OPEN-R type of the same name |
| OpenGripper | |
| KoduInterpreter::PerceptualMultiplexor::FailureRecovery::ObjectManipRecovery::InitiateManipRecovery::OpenGripper | |
| Grasper::OpenTheGripper | Open the gripper |
| OpticalFlow | |
| DualCoding::OpticalFlowOdometry | Optical flow implementation of visual odometry |
| KoduInterpreter::InitializeAgent::OrganizeWorld | |
| 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 |
| KoduInterpreter::PageSwitchActionRunner | |
| KoduInterpreter::PageSwitchActionRunner::PageSwitchEnd | |
| KoduInterpreter::PageSwitchActionRunner::PageSwitchStart | |
| IKSolver::Parallel | Parallel allows 1 freedom (roll along z vector) |
| XWalkMC::ParameterTransition | |
| ParkArm | |
| Kodu::ParsedPage | |
| Kodu::ParsedPhrase | Phrase class |
| Kodu::ParsedRule | |
| KoduInterpreter::InitializeAgent::ParseKode | |
| Kodu::Parser | |
| 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 |
| Grasper::PathPlanConstrained | Plan a constrained path |
| Grasper::PathPlanToRest | Plan a path to the rest state |
| KoduInterpreter::PerceptualMultiplexor::FailureRecovery::PauseInterpretation | |
| KoduInterpreter::PerceptualMultiplexor | |
| Kodu::PerceptualTaskBase | |
| PfAprilTag | An apriltag landmark |
| PfBlob | A blob landmark |
| PfCylinder | A cylinder landmark |
| PfEllipse | An ellipse landmark |
| PfLine | A line landmark; world lines will have two of these, with the endpoints switched |
| PfMarker | A marker landmark |
| PfPoint | A point landmark |
| PfRoot | Root class for the particle filter landmark classes |
| VL::PgmBuffer | PGM buffer descriptor |
| PGMImg | |
| PhysicsBody | Interface to the Bullet physics engine, although parameters controlled by PhysicsBody::ComponentListener and its associated LinkComponent |
| PhysicsWorld | Description of PhysicsWorld |
| PIDMC | A nice little MotionCommand for manually manipulating the PID values |
| PIDMotorController | |
| PIDNode | A simple StateNode that executes a PIDMC motion command |
| MotionManager::PIDUpdate | Used to request pids for a given joint |
| DualCoding::Pilot | The Pilot is the top-level navigation engine for Tekkotsu |
| PilotEvent | Event for reporting the results of a Pilot operation |
| PilotNode | Creates a PilotRequest pilotreq that the user can modify in their doStart() function, then executes the request when doStart() returns |
| DualCoding::PilotRequest | Request to the Pilot for motion or navigation |
| KoduInterpreter::PerceptualMultiplexor::PilotTaskRunner | |
| PilotTrans | Causes a transition if a PilotEvent from pilotEGID occurs, and checks for a specific error value if one is supplied |
| 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 |
| Grasper::PlanArmApproach | Plan arm motion to get fingers around the object |
| Grasper::PlanArmDeliver | Plan arm move to dropoff location |
| Grasper::PlanBodyApproach | Plan body motion to approach the object |
| Grasper::PlanBodyTransport | Plan body move to dropoff location |
| 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< N > | Base class for all obstacles |
| GenericRRTBase::PlannerResult< N > | Relays planner success/failure, as well as obstacles in the case of initial collision states |
| DualCoding::Pilot::PlanPath | |
| KoduInterpreter::PlayActionRunner | |
| KoduInterpreter::PlayActuator | |
| KoduInterpreter::PlayActionRunner::PlayEnd | |
| player_identity | |
| PlaySoundControl | Upon activation, loads plays a selected sound stored in ms/data/sound) |
| KoduInterpreter::PlayActionRunner::PlayStart | |
| 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 |
| KoduInterpreter::InitializeAgent::PointHeadFwd | |
| PollThread | Description of PollThread |
| IKSolver::Position | Abstract base class for position information |
| KoduInterpreter::GiveActionRunner::PositionBody | |
| Kodu::PosOrientState | |
| EventRouter::PostingStatus | Information regarding the progress of posting an event |
| PostMachineCompletion | This node can be included in an embedded state machine to make its parent post a completion event |
| PostMachineFailure | This node can be included in an embedded state machine to make its parent post a failure event |
| PostMachineSuccess | This node can be included in an embedded state machine to make its parent post a success event |
| PostStateCompletion | This node posts a completion event; it is used to construct dummy behaviors |
| 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 |
| PQueue< T > | Convenient priority queue implemented using the STL's heap algorithm |
| 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 > | |
| KoduInterpreter::GrabActionRunner::PrepareBody | |
| KoduInterpreter::PerceptualMultiplexor::FailureRecovery::ObjectManipRecovery::PrepareForAnotherGrasp | |
| KoduInterpreter::GrabActionRunner::ExecuteGrabAction::PrepareForAnotherGrasp | |
| KoduInterpreter::PerceptualMultiplexor::FailureRecovery::ObjectManipRecovery::PrepareForItemRecovery | |
| DualCoding::Pilot::LocalizationUtility::PrepareForNextGazePoint | |
| plist::Primitive< T > | |
| 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 |
| ProfilerOfSize< MaxSections > | Templated subclass allows compile-time flexibility of how much memory to use |
| fmat::fmat_internal::promotion_trait< T1, T2 > | |
| ProportionalMotorController | |
| DualCoding::Pilot::PushObjectMachine | |
| QBotPlusInfo::QBotPlusCapabilities | Polymorphic robot capability detection/mapping |
| AprilTags::Quad | Represents four segments that form a loop, and might be a tag |
| fmat::QuaternionT< R > | Quaternions can be more efficient and more stable for a series of rotations than a corresponding 3x3 matrix, also more compact storage |
| 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 |
| GreedySampler::range | |
| RawCam | 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) |
| RawImage | |
| RawImagePyramid | |
| 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 |
| KoduInterpreter::ReceiveActionRunner::ReceiveActionEnd | |
| KoduInterpreter::ReceiveActionRunner | |
| KoduInterpreter::ReceiveActionRunner::ReceiveActionStart | |
| KoduInterpreter::ReceiveActionRunner::ReceiveActionTurnAndGet | |
| ThreadedMessageQueue< T >::ReceiverThread< F, C > | Pulls messages out of the queue and gives them to the specified callback |
| ThreadedMessageQueue< T >::ReceiverThreadBase | Holds controller flags for the receiver thread to indicate exit conditions |
| KoduInterpreter::DropActionRunner::ExecuteDrop::RecordAprilTagPos | |
| RecordMotionNode | DESCRIPTION |
| 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 | |
| RegionCam | 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 |
| Grasper::ReleaseArm | Release the object |
| 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 | |
| DualCoding::Pilot::ReportCompletion | |
| KoduInterpreter::GrabActionRunner::ExecuteGrabAction::PrepareForAnotherGrasp::RepositionBody | |
| KoduInterpreter::PerceptualMultiplexor::FailureRecovery::ObjectManipRecovery::PrepareForAnotherGrasp::RepositionBody | |
| KoduInterpreter::GrabActionRunner::ExecuteGrabAction::PrepareForAnotherGrasp::RepositionGripperObject | |
| KoduInterpreter::PerceptualMultiplexor::FailureRecovery::ObjectManipRecovery::PrepareForAnotherGrasp::RepositionGripperObject | |
| KoduInterpreter::DropActionRunner::ExecuteDrop::RepositionReleasedObject::RepositionObject | |
| KoduInterpreter::DropActionRunner::ExecuteDrop::RepositionReleasedObject | |
| ParticleFilter< ParticleT >::ResamplingPolicy | The resampling policy focuses the particle filter on those particles which are performing well, and dropping those which are poorly rated |
| ResetArm | |
| ResetGripper | |
| 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 |
| Grasper::Rest | Moves the arm to the rest state |
| AStar::Results< State, Cmp > | Search results, including unexpanded nodes |
| KoduInterpreter::PerceptualMultiplexor::FailureRecovery::ObjectManipRecovery::RetrieveLostObject | |
| DualCoding::Pilot::LocalizationUtility::ReturnToInitialHeading | |
| KoduInterpreter::PerceptualMultiplexor::FailureRecovery::ObjectManipRecovery::PrepareForItemRecovery::Reverse | |
| KoduInterpreter::GrabActionRunner::PrepareBody::ReverseBody | |
| KoduInterpreter::DropActionRunner::ExecuteDrop::ReverseBody | |
| rgb | |
| rgba | |
| rgbaf | |
| plist::RGBColor< T > | |
| rgbf | |
| RLEGenerator | Generates RLE compressed FilterBankEvents (generally from indexed color images from, say, SegmentedColorGenerator) |
| KoduInterpreter::ReceiveActionRunner::ReceiveActionTurnAndGet::Rotate | |
| DualCoding::Pilot::VisualSearchMachine::Rotate | |
| KoduInterpreter::GiveActionRunner::PositionBody::Rotate | |
| IKSolver::Rotation | Rotation (here specified as a quaternion) allows 0 freedoms |
| fmat::Rotation_requires_larger_dimensions | |
| fmat::Row< N, R > | |
| RRTNode2DR< N > | |
| RRTNode3DR< N > | |
| RRTNodeBase | Base class for RRT nodes used by GenericRRT |
| RRTNodeXY | |
| RRTNodeXYTheta | |
| 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 > | |
| DualCoding::Pilot::RunMotionModel | Run the particle filter's motion model every few hundred milliseconds to provide odometry |
| DualCoding::Pilot::RunOpticalFlow | Compute optical flow for visual odometry. Currently disabled |
| RunSequenceControl< SequenceSize > | Upon activation, loads a position from a file name read from cin (stored in ms/data/motion...) |
| EventRouter::SameID | Predicate used to remove old events from the same event source from eventQueue (see requeueEvent()) |
| 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 |
| KoduInterpreter::SayActuator | |
| KoduInterpreter::ScoreActuator | |
| Kodu::ScoreChange | |
| Kodu::ScoreKeeper | Score Keeper |
| ScorePoint | |
| DualCoding::Pilot::VisualSearchMachine::Search | |
| LookAtMarkers::Search | |
| Profiler::SectionInfo | Holds all the information needed for book keeping for each timer |
| SegCam | 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 |
| AprilTags::Segment | Represents a line fit to a set of pixels whose gradients are similiar |
| 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 |
| LookAtMarkers::SelectMarker | |
| SemaphoreManager | Ideally, this would be SEMMSL, but that is hard to portably determine at compile time |
| SensorContact | Sets value to 1 if there are any contact constraints within the specified region of the associated body; 0 otherwise |
| SensorFeedback | Sets value to the current joint position. This is created automatically by Mirage for named joints where min≠max, so typically you don't need to explicitly request this sensor |
| PostureEngine::SensorInfo | Used for storing sensor data loaded from file |
| SensorInfo | Base class for sensor descriptions, actual subclass name stored in sensorType |
| 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 |
| 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 |
| SensorRangeFinder | Configures a sensor to take range measurements |
| KoduInterpreter::PerceptualMultiplexor::FailureRecovery::ObjectManipRecovery::PrepareForItemRecovery::SetGrasperTarget | |
| Grasper::SetJoint | Set joint to specified angle |
| DualCoding::Pilot::PushObjectMachine::SetMaxTurn | |
| DualCoding::Pilot::GoToShapeMachine::SetMaxTurn | |
| DualCoding::Pilot::SetOdometryMachine | |
| basic_netbuf< charT, traits >::SetScope< T > | This allows us to reset status variables like openInProgress if a thread cancel occurs |
| KoduInterpreter::PerceptualMultiplexor::PilotTaskRunner::SetTaskFailure | |
| KoduInterpreter::PerceptualMultiplexor::PilotTaskRunner::SetTaskSuccess | |
| DualCoding::Pilot::PushObjectMachine::SetUpExecute2 | |
| DualCoding::Pilot::PushObjectMachine::SetUpInitToObj | |
| DualCoding::Pilot::SetupLandmarkExtractor | |
| DualCoding::Pilot::PushObjectMachine::SetUpObjToDest | |
| DualCoding::Pilot::PushObjectMachine::SetUpObjToDest2 | |
| DualCoding::Pilot::GoToShapeMachine::SetUpPlanNode | |
| DualCoding::Pilot::SetVelocityMachine | |
| DualCoding::Pilot::SetVelocityMachine::SetVelocityMachine_Walker | |
| DualCoding::Pilot::WalkMachine::SetWalking | |
| DualCoding::Pilot::WaypointWalkMachine::SetWalking | |
| DualCoding::ShapeBasedParticleFilter | Bundles a motion model (DeadReckoningBehavior or CreateMotionModel) and a ShapeSensorModel for easy use of a shape-based particle filter for localization |
| DualCoding::ShapeParticleDistributionPolicy< ParticleT > | |
| ShapeSensorModel< ParticleT > | This wraps the ParticleShapeEvaluator in a ParticleFilter::SensorModel so it can be used by the particle filter |
| DualCoding::ShapeSLAMParticle | Each Particle represents a hypothesis about the match of the local map to the world map, considering changes to the map |
| DualCoding::ShapeSLAMParticleEvaluator | Extends ParticleShapeEvaluator to handle the addition and removal of landmarks as necessary |
| DualCoding::ShapeSLAMParticleFilter | Bundles a DeadReckoning motion model and a ShapeSLAMSensorModel for easy use of a shape-based particle filter for mapping and localization |
| DualCoding::ShapeSLAMSensorModel< ParticleT > | This wraps the ShapeSLAMParticleEvaluator in a ParticleFilter::SensorModel so it can be used by the particle filter |
| ShapeSpaceCollisionCheckerBase< N > | Base class for doing collision checking in world shape space |
| ShapeSpacePlanner2DR< N > | Plans a path in a n-dimensional angular space, uses forward kinematics for collision testing |
| ShapeSpacePlanner3DR< N > | Plans a path in a n-dimensional angular space, uses forward kinematics for collision testing |
| ShapeSpacePlannerXY | Plans a path in a 2D linear space, assuming the robot has circular shape |
| ShapeSpacePlannerXYTheta | Plans a path in a 2D linear space with smooth angle changes (if turnLimit is small), using multiple bounding boxes for collision checking |
| 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 |
| VL::Sift | SIFT filter |
| SIFTImage | |
| SiftMatch | |
| SiftTekkotsu | |
| Grasper::SignalGraspError | Signal the failure of a grasp sub-statemachine via a signalTrans |
| SignalTrans< T > | Causes a transition if a DataEvent<T> from stateSignalEGID occurs, and checks for a specific value if one is specified |
| 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 |
| IKCalliope::Solutions | Struct to enclose joint angles for 5-dof solution |
| 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 StateNode that speaks text upon startup and posts a status event on completion |
| SphericalObstacle | Spherically defined obstacle |
| stacktrace::StackFrame | Stores information about a single stack frame |
| KoduInterpreter::PerceptualMultiplexor::FailureRecovery::StartRecovery | |
| GridWorld::State | Stores context used per node in path planning, stores row and column position |
| GaitedFootsteps::State | |
| AStar::StateCmp< State, Cmp > | For efficient lookup of existance of states in open or closed list, uses user's Cmp on the user state within the search node |
| AStar::StateEq< State > | Tests equality of states using State::operator== |
| AStar::StateHash< State > | Calls State::hash(), which should return value distributed over size_t |
| 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) |
| GaitedFootsteps::StepData | |
| 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 | |
| KoduInterpreter::PageSwitchActionRunner::SwitchToNewPage | |
| AprilTags::TagFamily::TableInitializer | Initializes the static popCountTable |
| AprilTags::TagDetection | |
| AprilTags::TagDetector | |
| AprilTags::TagFamily | Generic class for all tag encoding families |
| 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 |
| DualCoding::Pilot::LocalizationUtility::TakeInitialPicture | |
| TorqueCalibrate::TakeMeasurementControl | |
| DualCoding::Pilot::LocalizationUtility::TakeNextPicture | |
| DualCoding::LookoutRequestBase::Task | Base class for Lookout tasks; cannot instantiate directly |
| DualCoding::Pilot::TerminateDueToCollision | Terminate a walk operation and indicate that a collision was responsible |
| 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 |
| ThreadedMessageQueue< T > | Provides a mechanism for exchanging messages between threads |
| 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 |
| Kodu::TokenBase | |
| Kodu::Parser::TokenParser | |
| TorqueCalibrate | Provides an interface for making measurements to correlate PID duty cycle and actual force output for each of the motors |
| LookAtMarkers::TrackMarker | |
| TrackNode | Creates a LookoutTrackRequest trackreq that the user can modify in their doStart() function, then has the Lookout execute the request when doStart() returns |
| fmat::fmat_internal::transformOps< R1, R2 > | Expanded calculations to facilitate optimized compilation of these operations for TransformT |
| fmat::TransformT< R > | Efficient computation of affine transform operations |
| Transition | Represents a transition between StateNodes |
| DualCoding::Pilot::ExecutePlan::Turn | Perform a turn step |
| Turn | |
| DualCoding::Pilot::SetOdometryMachine::TurnHead | |
| unary_function | |
| UnaryShapeRootPred | |
| UnaryShapeRootPred | |
| 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 > | |
| AprilTags::UnionFindSimple | Implementation of disjoint set data structure using the union-find algorithm |
| 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 |
| Kodu::KoduState::utterance | |
| uyvy | |
| value_conversion | |
| value_conversion | |
| value_conversion | |
| value_conversion | |
| 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 |
| Grasper::Verify | Verify that object is grasped |
| Grasper::Verify::VerifyDispatch | |
| KoduInterpreter::GrabActionRunner::ExecuteGrabAction::VerifyObjectWasGrabbed::VerifyObjectInGripper | |
| KoduInterpreter::PerceptualMultiplexor::FailureRecovery::ObjectManipRecovery::VerifyObjectWasGrabbed::VerifyObjectInGripper | |
| KoduInterpreter::GrabActionRunner::ExecuteGrabAction::VerifyObjectWasGrabbed | |
| KoduInterpreter::PerceptualMultiplexor::FailureRecovery::ObjectManipRecovery::VerifyObjectWasGrabbed | |
| 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) |
| DualCoding::LookoutRequestBase::VisionObjectTask | Uses bult-in object detectors (like pink ball detector) via VisionObjectEvent stream |
| DualCoding::LookoutRequestBase::VisionRegionTask | Uses built-in colored region detectors via Region event stream |
| DualCoding::LookoutRequestBase::VisionTask | Base class for vision tasks, should not be instantiated |
| Kodu::VisualBumpDetectionTask | |
| Kodu::VisualGripperMonitorTask | |
| Kodu::VisualLocalizationTask | |
| Kodu::VisualNavErrMonTask | |
| DualCoding::VisualOdometry | Generic visual odometry class; can be used for multiple algorithms |
| VisualRoutinesBehavior | |
| VisualRoutinesStateNode | |
| DualCoding::Pilot::VisualSearchMachine | |
| 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 |
| KoduInterpreter::GiveActionRunner::PositionBody::Walk | |
| DualCoding::Pilot::ExecutePlan::Walk | Perform a travel step by walking forward or backward |
| DualCoding::Pilot::PushObjectMachine::WalkBackward | |
| WalkCalibration | Allows interactive calibration of a walk engine |
| WalkController | Listens to control commands coming in from the command port for remotely controlling the walk |
| WalkEdit | Editor for the CMPack-based Aibo walk engine |
| WalkForward | |
| DualCoding::Pilot::PushObjectMachine::WalkForward | |
| DualCoding::Pilot::WalkMachine | |
| DualCoding::Pilot::WalkMachine::WalkMachine_Walker | |
| KoduInterpreter::WalkMonitor | |
| WalkNode | A StateNode for walking using WalkMC |
| CMPackWalkMC::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 |
| WalkSideways | |
| WalkToTargetNode | State node for walking towards a visual target |
| WAV | |
| Waypoint | Holds information about each waypoint, see WaypointEngine for overview |
| WaypointWalkControl::WaypointEditControl | Handles editing of individual waypoints |
| WaypointEngine | 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 |
| WaypointList | |
| WaypointWalkControl | Allows interactive control and execution of a set of waypoints |
| DualCoding::Pilot::WaypointWalkMachine | |
| DualCoding::Pilot::WaypointWalkMachine::WaypointWalkMachine_WaypointWalker | |
| WaypointWalkMC | Combines a WaypointEngine with a WalkMC so you can walk between a set of waypoints |
| WheeledWalkMC | Provides a 'WalkMC' implementation for wheeled robots (diff-drive or theoretically holonomic configurations as well) |
| WheeledWalkMC::WheelInfo | Stores information about the configuration and current target state of each wheel |
| 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 |
| 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::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 |
| XMLLoadSave | XMLLoadSave adds functions for XML format serialization, although if you write binary LoadSave functions as well, you can do either |
| XWalkEdit | |
| XWalkMC | Extreme walk engine handles legged locomotion on hexapods and beyond |
| XWalkParameters | Parameters used by XWalkMC to control gait |
| AprilTags::XYWeight | Represents a triple holding an x value, y value, and weight value |
| yuv | |
| yuvf | |
| yuvi | |
| yuyv | |
