| _0RL_cd_12c42ade728de8dd_00000000 | |
| _0RL_cd_12c42ade728de8dd_20000000 | |
| _0RL_cd_12c42ade728de8dd_50000000 | |
| _0RL_cd_12c42ade728de8dd_70000000 | |
| _0RL_cd_12c42ade728de8dd_90000000 | |
| _0RL_cd_12c42ade728de8dd_b0000000 | |
| _0RL_cd_1473fd27e4f46097_00000000 | |
| _0RL_cd_1473fd27e4f46097_01000000 | |
| _0RL_cd_1473fd27e4f46097_20000000 | |
| _0RL_cd_1473fd27e4f46097_21000000 | |
| _0RL_cd_1473fd27e4f46097_40000000 | |
| _0RL_cd_1473fd27e4f46097_80000000 | |
| _0RL_cd_1473fd27e4f46097_a0000000 | |
| _0RL_cd_1473fd27e4f46097_c0000000 | |
| _0RL_cd_1473fd27e4f46097_e0000000 | |
| _0RL_cd_26cb7021134ed319_00000000 | |
| _0RL_cd_26cb7021134ed319_20000000 | |
| _0RL_cd_26cb7021134ed319_40000000 | |
| _0RL_cd_53325218d1337e1a_00000000 | |
| _0RL_cd_53325218d1337e1a_20000000 | |
| _0RL_cd_53325218d1337e1a_40000000 | |
| _0RL_cd_53325218d1337e1a_80000000 | |
| _0RL_cd_53325218d1337e1a_a0000000 | |
| _0RL_cd_53325218d1337e1a_c0000000 | |
| _0RL_cd_53325218d1337e1a_e0000000 | |
| _0RL_cd_97112014c61d6e2e_00000000 | |
| _0RL_cd_97112014c61d6e2e_20000000 | |
| _0RL_cd_9796BC3FD8C2649B_00000000 | |
| _0RL_cd_9796bc3fd8c2649b_00000000 | |
| _0RL_cd_9796BC3FD8C2649B_20000000 | |
| _0RL_cd_9796bc3fd8c2649b_20000000 | |
| _0RL_cd_9796BC3FD8C2649B_40000000 | |
| _0RL_cd_9796bc3fd8c2649b_40000000 | |
| _0RL_cd_9796BC3FD8C2649B_70000000 | |
| _0RL_cd_9796bc3fd8c2649b_70000000 | |
| _0RL_cd_9796BC3FD8C2649B_90000000 | |
| _0RL_cd_9796bc3fd8c2649b_90000000 | |
| _0RL_cd_c803e3f5fea6e958_00000000 | |
| _0RL_cd_c803e3f5fea6e958_20000000 | |
| _0RL_cd_c803e3f5fea6e958_40000000 | |
| _0RL_cd_c803e3f5fea6e958_60000000 | |
| _0RL_cd_c803e3f5fea6e958_80000000 | |
| __F__BeobotEvents__AbortMessage | |
| __F__BeobotEvents__AbortMessage__Init | |
| __F__BeobotEvents__CameraMessage | |
| __F__BeobotEvents__CameraMessage__Init | |
| __F__BeobotEvents__CancelSearchMessage | |
| __F__BeobotEvents__CancelSearchMessage__Init | |
| __F__BeobotEvents__CornerLocationMessage | |
| __F__BeobotEvents__CornerLocationMessage__Init | |
| __F__BeobotEvents__CornerMotorRequest | |
| __F__BeobotEvents__CornerMotorRequest__Init | |
| __F__BeobotEvents__CurrentLocationMessage | |
| __F__BeobotEvents__CurrentLocationMessage__Init | |
| __F__BeobotEvents__FacesMessage | |
| __F__BeobotEvents__FacesMessage__Init | |
| __F__BeobotEvents__GistSalMessage | |
| __F__BeobotEvents__GistSalMessage__Init | |
| __F__BeobotEvents__GPSMessage | |
| __F__BeobotEvents__GPSMessage__Init | |
| __F__BeobotEvents__GUISpeechMessage | |
| __F__BeobotEvents__GUISpeechMessage__Init | |
| __F__BeobotEvents__IMUMessage | |
| __F__BeobotEvents__IMUMessage__Init | |
| __F__BeobotEvents__LandmarkDBSearchResultMessage | |
| __F__BeobotEvents__LandmarkDBSearchResultMessage__Init | |
| __F__BeobotEvents__LandmarkMatchResultMessage | |
| __F__BeobotEvents__LandmarkMatchResultMessage__Init | |
| __F__BeobotEvents__LandmarkSearchQueueMessage | |
| __F__BeobotEvents__LandmarkSearchQueueMessage__Init | |
| __F__BeobotEvents__LandmarkSearchStatMessage | |
| __F__BeobotEvents__LandmarkSearchStatMessage__Init | |
| __F__BeobotEvents__LandmarkTrackMessage | |
| __F__BeobotEvents__LandmarkTrackMessage__Init | |
| __F__BeobotEvents__LRFMessage | |
| __F__BeobotEvents__LRFMessage__Init | |
| __F__BeobotEvents__MotorMessage | |
| __F__BeobotEvents__MotorMessage__Init | |
| __F__BeobotEvents__MotorRequest | |
| __F__BeobotEvents__MotorRequest__Init | |
| __F__BeobotEvents__NextFrameMessage | |
| __F__BeobotEvents__NextFrameMessage__Init | |
| __F__BeobotEvents__SearchDoneMessage | |
| __F__BeobotEvents__SearchDoneMessage__Init | |
| __F__BeobotEvents__SLAMMessage | |
| __F__BeobotEvents__SLAMMessage__Init | |
| __F__BeobotEvents__SonarMessage | |
| __F__BeobotEvents__SonarMessage__Init | |
| __F__EventsNS__Event | |
| __F__EventsNS__Event__Init | |
| __F__EventsNS__Message1 | |
| __F__EventsNS__Message1__Init | |
| __F__EventsNS__Message2 | |
| __F__EventsNS__Message2__Init | |
| __F__HawkMessages__CameraImageMessage | |
| __F__HawkMessages__CameraImageMessage__Init | |
| __F__HawkMessages__ControlCameraMessage | |
| __F__HawkMessages__ControlCameraMessage__Init | |
| __F__HawkMessages__ControlDriveVisionMessage | |
| __F__HawkMessages__ControlDriveVisionMessage__Init | |
| __F__HawkMessages__ControlLandMessage | |
| __F__HawkMessages__ControlLandMessage__Init | |
| __F__HawkMessages__ControlMoveMessage | |
| __F__HawkMessages__ControlMoveMessage__Init | |
| __F__HawkMessages__ControlRoomVisionMessage | |
| __F__HawkMessages__ControlRoomVisionMessage__Init | |
| __F__HawkMessages__ControlTakeOffMessage | |
| __F__HawkMessages__ControlTakeOffMessage__Init | |
| __F__HawkMessages__DriveFinderMessage | |
| __F__HawkMessages__DriveFinderMessage__Init | |
| __F__HawkMessages__ExampleMessage | |
| __F__HawkMessages__ExampleMessage__Init | |
| __F__HawkMessages__ExecuteMissionMessage | |
| __F__HawkMessages__ExecuteMissionMessage__Init | |
| __F__HawkMessages__Message | |
| __F__HawkMessages__Message__Init | |
| __F__HawkMessages__MissionListMessage | |
| __F__HawkMessages__MissionListMessage__Init | |
| __F__HawkMessages__RoomFinderMessage | |
| __F__HawkMessages__RoomFinderMessage__Init | |
| __F__HawkMessages__SensorDataMessage | |
| __F__HawkMessages__SensorDataMessage__Init | |
| __F__HawkMessages__SlamDataMessage | |
| __F__HawkMessages__SlamDataMessage__Init | |
| __F__IceStorm__AlreadySubscribed | |
| __F__IceStorm__AlreadySubscribed__Init | |
| __F__IceStorm__BadQoS | |
| __F__IceStorm__BadQoS__Init | |
| __F__IceStorm__LinkExists | |
| __F__IceStorm__LinkExists__Init | |
| __F__IceStorm__NoSuchLink | |
| __F__IceStorm__NoSuchLink__Init | |
| __F__IceStorm__NoSuchTopic | |
| __F__IceStorm__NoSuchTopic__Init | |
| __F__IceStorm__TopicExists | |
| __F__IceStorm__TopicExists__Init | |
| __F__RobotSimEvents__ActionMessage | |
| __F__RobotSimEvents__ActionMessage__Init | |
| __F__RobotSimEvents__AttendedRegionMessage | |
| __F__RobotSimEvents__AttendedRegionMessage__Init | |
| __F__RobotSimEvents__BeeStemConfigMessage | |
| __F__RobotSimEvents__BeeStemConfigMessage__Init | |
| __F__RobotSimEvents__BeeStemMessage | |
| __F__RobotSimEvents__BeeStemMessage__Init | |
| __F__RobotSimEvents__BeeStemMotorControllerMessage | |
| __F__RobotSimEvents__BeeStemMotorControllerMessage__Init | |
| __F__RobotSimEvents__BeoHawkEyeSpyMessage | |
| __F__RobotSimEvents__BeoHawkEyeSpyMessage__Init | |
| __F__RobotSimEvents__BuoyColorSegmentConfigMessage | |
| __F__RobotSimEvents__BuoyColorSegmentConfigMessage__Init | |
| __F__RobotSimEvents__BuoyColorSegmentMessage | |
| __F__RobotSimEvents__BuoyColorSegmentMessage__Init | |
| __F__RobotSimEvents__CameraConfigMessage | |
| __F__RobotSimEvents__CameraConfigMessage__Init | |
| __F__RobotSimEvents__CameraImageMessage | |
| __F__RobotSimEvents__CameraImageMessage__Init | |
| __F__RobotSimEvents__ChatMessage | |
| __F__RobotSimEvents__ChatMessage__Init | |
| __F__RobotSimEvents__ControlCameraMessage | |
| __F__RobotSimEvents__ControlCameraMessage__Init | |
| __F__RobotSimEvents__ControlDriveVisionMessage | |
| __F__RobotSimEvents__ControlDriveVisionMessage__Init | |
| __F__RobotSimEvents__ControlLandMessage | |
| __F__RobotSimEvents__ControlLandMessage__Init | |
| __F__RobotSimEvents__ControlMoveMessage | |
| __F__RobotSimEvents__ControlMoveMessage__Init | |
| __F__RobotSimEvents__EventMessage | |
| __F__RobotSimEvents__EventMessage__Init | |
| __F__RobotSimEvents__ExecuteMissionMessage | |
| __F__RobotSimEvents__ExecuteMissionMessage__Init | |
| __F__RobotSimEvents__GoalProgressMessage | |
| __F__RobotSimEvents__GoalProgressMessage__Init | |
| __F__RobotSimEvents__GoalStateMessage | |
| __F__RobotSimEvents__GoalStateMessage__Init | |
| __F__RobotSimEvents__GPSMessage | |
| __F__RobotSimEvents__GPSMessage__Init | |
| __F__RobotSimEvents__IMUDataServerMessage | |
| __F__RobotSimEvents__IMUDataServerMessage__Init | |
| __F__RobotSimEvents__JoyStickControlMessage | |
| __F__RobotSimEvents__JoyStickControlMessage__Init | |
| __F__RobotSimEvents__LandmarksMessage | |
| __F__RobotSimEvents__LandmarksMessage__Init | |
| __F__RobotSimEvents__LocalizationMessage | |
| __F__RobotSimEvents__LocalizationMessage__Init | |
| __F__RobotSimEvents__MotionMessage | |
| __F__RobotSimEvents__MotionMessage__Init | |
| __F__RobotSimEvents__MovementControllerMessage | |
| __F__RobotSimEvents__MovementControllerMessage__Init | |
| __F__RobotSimEvents__ObjectMessage | |
| __F__RobotSimEvents__ObjectMessage__Init | |
| __F__RobotSimEvents__PipeColorSegmentConfigMessage | |
| __F__RobotSimEvents__PipeColorSegmentConfigMessage__Init | |
| __F__RobotSimEvents__PipeColorSegmentMessage | |
| __F__RobotSimEvents__PipeColorSegmentMessage__Init | |
| __F__RobotSimEvents__RemoteControlMessage | |
| __F__RobotSimEvents__RemoteControlMessage__Init | |
| __F__RobotSimEvents__RetinaMessage | |
| __F__RobotSimEvents__RetinaMessage__Init | |
| __F__RobotSimEvents__SalientPointMessage | |
| __F__RobotSimEvents__SalientPointMessage__Init | |
| __F__RobotSimEvents__SeaBeePositionMessage | |
| __F__RobotSimEvents__SeaBeePositionMessage__Init | |
| __F__RobotSimEvents__SeaBeeStateConditionMessage | |
| __F__RobotSimEvents__SeaBeeStateConditionMessage__Init | |
| __F__RobotSimEvents__SensorDataMessage | |
| __F__RobotSimEvents__SensorDataMessage__Init | |
| __F__RobotSimEvents__SlamDataMessage | |
| __F__RobotSimEvents__SlamDataMessage__Init | |
| __F__RobotSimEvents__StateMessage | |
| __F__RobotSimEvents__StateMessage__Init | |
| __F__RobotSimEvents__StraightEdgeMessage | |
| __F__RobotSimEvents__StraightEdgeMessage__Init | |
| __F__RobotSimEvents__VisionObjectMessage | |
| __F__RobotSimEvents__VisionObjectMessage__Init | |
| __F__RobotSimEvents__VisionRectangleMessage | |
| __F__RobotSimEvents__VisionRectangleMessage__Init | |
| __F__SeaBeeSimEvents__CameraConfigMessage | |
| __F__SeaBeeSimEvents__CameraConfigMessage__Init | |
| __F__SimEvents__CameraCtrlBiasMessage | |
| __F__SimEvents__CameraCtrlBiasMessage__Init | |
| __F__SimEvents__CameraCtrlMessage | |
| __F__SimEvents__CameraCtrlMessage__Init | |
| __F__SimEvents__EventMessage | |
| __F__SimEvents__EventMessage__Init | |
| __F__SimEvents__GUIInputMessage | |
| __F__SimEvents__GUIInputMessage__Init | |
| __F__SimEvents__GUIOutputMessage | |
| __F__SimEvents__GUIOutputMessage__Init | |
| __F__SimEvents__HippocampusBiasMessage | |
| __F__SimEvents__HippocampusBiasMessage__Init | |
| __F__SimEvents__HippocampusMessage | |
| __F__SimEvents__HippocampusMessage__Init | |
| __F__SimEvents__InfrotemporalCortexBiasMessage | |
| __F__SimEvents__InfrotemporalCortexBiasMessage__Init | |
| __F__SimEvents__InfrotemporalCortexMessage | |
| __F__SimEvents__InfrotemporalCortexMessage__Init | |
| __F__SimEvents__PrimaryMotorCortexBiasMessage | |
| __F__SimEvents__PrimaryMotorCortexBiasMessage__Init | |
| __F__SimEvents__PrimaryMotorCortexMessage | |
| __F__SimEvents__PrimaryMotorCortexMessage__Init | |
| __F__SimEvents__PrimaryMotorCortexRelativeServoMessage | |
| __F__SimEvents__PrimaryMotorCortexRelativeServoMessage__Init | |
| __F__SimEvents__PrimaryMotorCortexResetEncodersMessage | |
| __F__SimEvents__PrimaryMotorCortexResetEncodersMessage__Init | |
| __F__SimEvents__RetinaMessage | |
| __F__SimEvents__RetinaMessage__Init | |
| __F__SimEvents__SaliencyMapBiasMessage | |
| __F__SimEvents__SaliencyMapBiasMessage__Init | |
| __F__SimEvents__SaliencyMapMessage | |
| __F__SimEvents__SaliencyMapMessage__Init | |
| __F__SimEvents__SegmenterBiasMessage | |
| __F__SimEvents__SegmenterBiasMessage__Init | |
| __F__SimEvents__SegmenterMessage | |
| __F__SimEvents__SegmenterMessage__Init | |
| __F__SimEvents__VisualCortexMessage | |
| __F__SimEvents__VisualCortexMessage__Init | |
| __F__SimEvents__VisualTrackerBiasMessage | |
| __F__SimEvents__VisualTrackerBiasMessage__Init | |
| __F__SimEvents__VisualTrackerMessage | |
| __F__SimEvents__VisualTrackerMessage__Init | |
| _AccelAndAngRateRecord | |
| _MagnetometerRecord | |
| _RegionInformation | |
| _RollPitchYawRecord | |
| Action | |
| AerialRetina | |
| AffineTransform | |
| Agent | |
| AgentManager | |
| AgentManagerA | |
| AgentManagerB | |
| AgentManagerCommand | |
| aligned_alloc | Allocate memory that is aligned on an NALIGN-byte boundary |
| alloc_info | Auxiliary information about an aligned memory allocation |
| AlphaDecoder | A Rate decoder using an alpha function |
| Angle | Embodiment of an angular value |
| AnimationDelegate | |
| AnimationModel | |
| AnnotationObject | |
| AnnotationObjectFrame | A simple struct to hold the state of an annotation object at a single frame |
| AnnotationObjectManager | |
| AnnotationObjectMgrDelegate | |
| AnnotationObjectVertex | |
| ArmController | |
| ArmController::JointPos | |
| ArmPlanner | |
| ArmPosition | |
| ArmSim | |
| ArmSim::ArmParam | |
| ArrayCreator | |
| ArrayData< T > | Implements a ref-counted 2-D array, should only be used via ArrayHandle |
| ArrayHandle< T > | This class provides ref-counting and copy-on-write for ArrayData's |
| ArrayHelper< T, isTrivial > | This is a helper template struct for ArrayData's constructors |
| ArrayHelper< T, true > | Specialization of ArrayHelper for builtin/trivial types |
| ArrayItem | |
| ART1 | |
| ART1::Layer | |
| ART1::Unit | |
| Attentionator | |
| AttentionGate | The Attention Gate Class |
| AttentionGateConfigurator | AttentionGate configurator |
| AttentionGateStd | The standard attention gate |
| AttentionGateStub | The standard map |
| AttentionGuidanceMap | The attentional guidance map base class |
| AttentionGuidanceMapConfigurator | AttentionGuidanceMap configurator |
| AttentionGuidanceMapOpt | The Optimized Attention Guidance Map |
| AttentionGuidanceMapStd | The standard attentional guidance map |
| Attitude | A BeoSub three-dimensional attitude |
| audio_index_entry | |
| AudioBuffer< T > | AudioBuffer is a buffer of audio data |
| AudioGrabber | Class to grab audio samples from an audio device |
| AudioMixer | Simple interface to the Linux audio mixer |
| AutomateXWin | |
| avi_t | |
| AVIStreamHeader | |
| AVISTREAMINFO | |
| BackpropLearner | Learn feature/position pairings with a backprop-training neural network |
| BackpropNetwork | Development in progress; not ready for prime-time yet! |
| band_info | |
| BandpassFilter | |
| BarItem | |
| BarStimuli | FrameIstream subclass that generates bar stimuli images |
| BasicBrainComponentI | |
| BasicVisionBrainComponentI | |
| Bayes | |
| Bayes::ClassInfo | |
| BayesianBiaser | |
| BayesNetworkDialog | |
| BeeSTEM | BeeSTEM.H Interface to Rand Voorhies' BeeSTEM device |
| BeeStem3 | |
| BeeStem3::MotorControllerIDs | |
| BeeSTEM_PID_Listener | Our own little BeeSTEMListener |
| BeeStemData | |
| BeeStemI | |
| BeeStemI::BeeStemFlags | |
| BeeStemI::DropperState | |
| BeeStemI::FiringDeviceID | |
| BeeStemI::ShooterState | |
| BeeSTEMListener | BeoChip event listener |
| BeeStemSim | |
| BeeStemTiny | |
| Beobot | This class is a complete Beobot |
| Beobot2::MotorCommand | |
| Beobot2_GistSalLocalizerMasterI | |
| Beobot2_GistSalLocalizerWorkerI | |
| Beobot2GistSalMasterI | |
| BeobotAction | This class defined motor actions for the Beobots |
| BeobotBeoChipListener | Beobot BeoChipListener |
| BeobotBrainMT | |
| BeobotCamera | This class abstracts an asynchronous Beobot camera |
| BeobotCameraListener | BeobotCamera event listener |
| BeobotConfig | |
| BeobotControl | |
| BeobotEffectors | This class contains all the effectors of a Beobot |
| BeobotEvents::AbortMessage | |
| BeobotEvents::CameraMessage | |
| BeobotEvents::CancelSearchMessage | |
| BeobotEvents::CornerLocationMessage | |
| BeobotEvents::CornerMotorRequest | |
| BeobotEvents::CurrentLocationMessage | |
| BeobotEvents::FacesMessage | |
| BeobotEvents::GistSalMessage | |
| BeobotEvents::GPSMessage | |
| BeobotEvents::GUISpeechMessage | |
| BeobotEvents::IMUMessage | |
| BeobotEvents::LandmarkDBSearchResultMessage | |
| BeobotEvents::LandmarkMatchResultMessage | |
| BeobotEvents::LandmarkSearchJob | |
| BeobotEvents::LandmarkSearchQueueMessage | |
| BeobotEvents::LandmarkSearchStatMessage | |
| BeobotEvents::LandmarkTrackMessage | |
| BeobotEvents::LRFMessage | |
| BeobotEvents::MotorMessage | |
| BeobotEvents::MotorMessage__staticInit | |
| BeobotEvents::MotorRequest | |
| BeobotEvents::NextFrameMessage | |
| BeobotEvents::SalientRegion | |
| BeobotEvents::SearchDoneMessage | |
| BeobotEvents::SLAMMessage | |
| BeobotEvents::SonarMessage | |
| BeoBotIcon | |
| BeobotLauncherApp | Description of applications which we handle: |
| BeobotLauncherListener | Our own little BeoChipListener |
| BeoBotMap | |
| BeobotMemory | Memory of a Beobot |
| BeoBotQtMainForm | |
| BeobotSensation | This class contains all the sensory informations but not the action |
| BeobotSensors | All the sensors of a Beobot |
| BeoBotSim | |
| BeobotVisualCortex | Visual Cortex of a Beobot |
| BeoCamera | |
| BeoChip | BeoChip.H Interface to Brian Hudson's BeoChip device |
| BeoChipListener | BeoChip event listener |
| BeoChipMainForm | Implementation of slots and signals for the BeoChipMaiForm Qt4 dialog |
| BeoGPS | |
| BeoHawkSim | |
| BeoHead | |
| BeoHeadBrain | |
| BeoIMU | |
| BeoLogger | |
| BeoLRF | |
| BeoMap | Definition and access functions for the BeoMap base class |
| BeoMonkey | |
| BeoPilot | |
| BeoSLAM | |
| BeoSonar | |
| BeoSub | Definition and access functions for the BeoSub base class |
| BeoSubAction | Helper base class for BeoSub motor actions |
| BeoSubActionDive | Helper base class for BeoSub dive actions |
| BeoSubActionTurn | Helper base class for BeoSub turn actions |
| BeoSubBallast | BeoSub Ballast Class - responsible for the lower level movement of the Sub |
| BeoSubBin | |
| BeoSubBin::BinAngles | |
| BeoSubCanny | Definition and access functions for the BeoSubCanny |
| BeoSubCross | |
| BeoSubDB | A BeoSub mapping database |
| BeoSubDepthSensor | Class for interfacing with a depth sensor |
| BeoSubIMU | Class for interfacing with the IMU |
| BeoSubIMUListener | A hook which will be called when a new IMU reading is received |
| BeoSubLeakDetector | |
| BeoSubListener | Class definition for BeoSubListener |
| BeoSubMappingQtMainForm | |
| BeoSubMotor | Low-level driver for the BeoSub motors |
| BeoSubOneBal | Definition and access functions for the BeoSub |
| BeoSubPipe | |
| BeoSubQtMainForm | |
| BeoSubSaliency | |
| BeoSubSensor< T > | Definition and access functions for a BeoSub sensor |
| BeoSubSim | Definition and access functions for the BeoSub |
| BeoSubSimuQtMainForm | |
| BeoSubTaskDecoder | Definition and access functions for the BeoSubCanny |
| BeoSubTwoBal | Definition and access functions for the BeoSub |
| Beowulf | Simple interfacing to a Beowulf cluster |
| BiasCenterSurroundThread | |
| biasData | |
| BiasImageForm | |
| BiasParam | |
| BiasSettingsDialog | |
| BiasValImage | |
| binary< N > | |
| binary< 0 > | |
| BinFinder | |
| BinRecognizer | |
| BITMAPINFOHEADER_avilib | |
| BitObject | Object defined by a connected binary pixel region |
| Blob | |
| BlobItem | |
| blobProp | |
| BlobTracker | |
| BlueChannel | A blue color channel |
| BlueYellowChannel | A blue-yellow double-opponent color channel |
| BlurFoveator | A class that does space-variant processing with progressive blurring |
| Board | |
| BobDeinterlacer | Deinterlace frames using the "bob" method |
| BorderWatchData | Log data from the BorderWatch application, used by BorderWatchGui |
| BorderWatchQt | Simple GUI to display and browse BorderWatch results |
| BotArmControlServer | |
| BotControl | |
| BotControlServer_i | |
| Box | |
| BPneuron | Neuron for a back prop neural net (BPnnet) |
| BPnnet | Describes structure of a 3 layer back prop neural net |
| Brain | This is the brain, a holder for various vision objects |
| BrainObjects::Hippocampus | |
| BrainObjects::HomeInterface | |
| BrainObjects::InferotemporalCortex | |
| BrainObjects::PrefrontalCortex | |
| BrainObjects::PrimaryMotorCortex | |
| BrainObjects::PTZ | |
| BrainObjects::Retina | |
| BrainObjects::SaliencyMap | |
| BrainObjects::Segmenter | |
| BrainObjects::SimulationViewer | |
| BrainObjects::VisualCortex | |
| BrainObjects::VisualTracker | |
| buffer | |
| Buffer< T > | Templated circular buffer |
| BufferedFrameIstream | Puts a frame-buffering layer on top of any other FrameIstream object |
| BufferedFrameIstream::Checkpoint | |
| BufferedInputFrameSeries | Buffered version of InputFrameSeries |
| BufferedInputFrameSeries::Checkpoint | |
| BufferedSerial | |
| BuoySensor | |
| button | |
| ByteCount | A class to handle parsing + converting byte counts |
| Cache | |
| CachedFrameLoader | Cached interface to InputFrameSeries which directly delivers QImage images |
| CalibrationTransform | |
| CalibrationTransform::Data | |
| CalPt | |
| Camera | |
| cameraConf | This class uses readConfig to extract config parameters for CameraControl |
| CameraControl | This class is an interface to pan, tilt, and otherwise move the camera |
| CameraDisplay | |
| CameraIntrinsicParam | A class that stores a camera's intrinsic parameter |
| CameraManager | |
| CameraParams | |
| CaptainAgent | |
| Capture | |
| CartesianPosition | |
| cascadeHold | This is a container class for holding cascading energy values |
| cb_list | |
| CcodeWriter | Writes images as C-language arrays |
| Cell | |
| CenterSurroundThread | |
| ChannelBase | ChannelBase represents the various computational modules in VisualCortex |
| ChannelFacet | Base class for facets that can be held in a ChannelFacetMap |
| ChannelFacetGainComplex | One gain per subchannel |
| ChannelFacetGainSingle | One gain per feature map |
| ChannelFacetMap | Mix-in class designed to be inherited to provide facets to the subclass |
| ChannelFacetMap::Impl | |
| ChannelFacetScalar | ChannelFacet that contains one scalar value per feature map |
| ChannelFacetScalarComplex | Specialization of ChannelFacetScalar for ComplexChannel |
| ChannelFacetScalarSingle | Specialization of ChannelFacetScalar for SingleChannel |
| ChannelMaps | ChannelMaps hold maps from a channel hierarchy |
| ChannelVisitor | Abstract base class for algorithms that traverse an entire tree of channel objects |
| ChannelVisitorInstallFacet< CFS, CFC > | ChannelVisitorInstallFacet install some ChannelFacet |
| cheb_series_struct | |
| CheckedIterator< T > | A range-checked iterator class for memory debugging |
| CheetahExt | |
| CheetahVersion | |
| ChipData | Simple struct for each chip |
| ChipInfoIceMod::AMI_ChipInfoServerIce_update | |
| ChipInfoIceMod::ChipInfoServerFactoryIce | |
| ChipInfoIceMod::ChipInfoServerIce | |
| ChipQLabel | Clickable QLabel |
| ChipValidatorQt | Simple GUI to display and browse BorderWatch results |
| chunk_struct | |
| CIELabChannel | A double opponent color channel class that combines r/g, b/y subchannels |
| cimg_library::CImg< T > | Class representing an image (up to 4 dimensions wide), each pixel being of type T |
| cimg_library::CImg< T >::_cimg_math_parser | |
| cimg_library::CImg< T >::_functor2d_expr | |
| cimg_library::CImg< T >::_functor2d_float | |
| cimg_library::CImg< T >::_functor2d_int | |
| cimg_library::CImg< T >::_functor3d_expr | |
| cimg_library::CImg< T >::_functor3d_float | |
| cimg_library::CImg< T >::_functor3d_int | |
| cimg_library::CImg< T >::_functor4d_int | |
| cimg_library::CImg< T >::_functor4d_streamline2d_directed | |
| cimg_library::CImg< T >::_functor4d_streamline2d_oriented | |
| cimg_library::CImg< T >::_functor4d_streamline3d_directed | |
| cimg_library::CImg< T >::_functor4d_streamline3d_oriented | |
| cimg_library::CImg< T >::_functor4d_streamline_expr | |
| cimg_library::cimg::last< t1, t2 > | |
| cimg_library::cimg::superset< T, t > | |
| cimg_library::cimg::superset2< t1, t2, t3 > | |
| cimg_library::cimg::superset3< t1, t2, t3, t4 > | |
| cimg_library::cimg::superset< bool, char > | |
| cimg_library::cimg::superset< bool, double > | |
| cimg_library::cimg::superset< bool, float > | |
| cimg_library::cimg::superset< bool, int > | |
| cimg_library::cimg::superset< bool, long > | |
| cimg_library::cimg::superset< bool, short > | |
| cimg_library::cimg::superset< bool, signed char > | |
| cimg_library::cimg::superset< bool, unsigned char > | |
| cimg_library::cimg::superset< bool, unsigned int > | |
| cimg_library::cimg::superset< bool, unsigned long > | |
| cimg_library::cimg::superset< bool, unsigned short > | |
| cimg_library::cimg::superset< char, double > | |
| cimg_library::cimg::superset< char, float > | |
| cimg_library::cimg::superset< char, int > | |
| cimg_library::cimg::superset< char, long > | |
| cimg_library::cimg::superset< char, short > | |
| cimg_library::cimg::superset< char, signed char > | |
| cimg_library::cimg::superset< char, unsigned char > | |
| cimg_library::cimg::superset< char, unsigned int > | |
| cimg_library::cimg::superset< char, unsigned long > | |
| cimg_library::cimg::superset< char, unsigned short > | |
| cimg_library::cimg::superset< float, double > | |
| cimg_library::cimg::superset< int, double > | |
| cimg_library::cimg::superset< int, float > | |
| cimg_library::cimg::superset< int, long > | |
| cimg_library::cimg::superset< int, unsigned int > | |
| cimg_library::cimg::superset< int, unsigned long > | |
| cimg_library::cimg::superset< long, double > | |
| cimg_library::cimg::superset< long, float > | |
| cimg_library::cimg::superset< short, double > | |
| cimg_library::cimg::superset< short, float > | |
| cimg_library::cimg::superset< short, int > | |
| cimg_library::cimg::superset< short, long > | |
| cimg_library::cimg::superset< short, unsigned int > | |
| cimg_library::cimg::superset< short, unsigned long > | |
| cimg_library::cimg::superset< short, unsigned short > | |
| cimg_library::cimg::superset< signed char, char > | |
| cimg_library::cimg::superset< signed char, double > | |
| cimg_library::cimg::superset< signed char, float > | |
| cimg_library::cimg::superset< signed char, int > | |
| cimg_library::cimg::superset< signed char, long > | |
| cimg_library::cimg::superset< signed char, short > | |
| cimg_library::cimg::superset< signed char, unsigned char > | |
| cimg_library::cimg::superset< signed char, unsigned int > | |
| cimg_library::cimg::superset< signed char, unsigned long > | |
| cimg_library::cimg::superset< signed char, unsigned short > | |
| cimg_library::cimg::superset< unsigned char, char > | |
| cimg_library::cimg::superset< unsigned char, double > | |
| cimg_library::cimg::superset< unsigned char, float > | |
| cimg_library::cimg::superset< unsigned char, int > | |
| cimg_library::cimg::superset< unsigned char, long > | |
| cimg_library::cimg::superset< unsigned char, short > | |
| cimg_library::cimg::superset< unsigned char, signed char > | |
| cimg_library::cimg::superset< unsigned char, unsigned int > | |
| cimg_library::cimg::superset< unsigned char, unsigned long > | |
| cimg_library::cimg::superset< unsigned char, unsigned short > | |
| cimg_library::cimg::superset< unsigned int, char > | |
| cimg_library::cimg::superset< unsigned int, double > | |
| cimg_library::cimg::superset< unsigned int, float > | |
| cimg_library::cimg::superset< unsigned int, int > | |
| cimg_library::cimg::superset< unsigned int, long > | |
| cimg_library::cimg::superset< unsigned int, short > | |
| cimg_library::cimg::superset< unsigned int, signed char > | |
| cimg_library::cimg::superset< unsigned int, unsigned long > | |
| cimg_library::cimg::superset< unsigned long, char > | |
| cimg_library::cimg::superset< unsigned long, double > | |
| cimg_library::cimg::superset< unsigned long, float > | |
| cimg_library::cimg::superset< unsigned long, int > | |
| cimg_library::cimg::superset< unsigned long, long > | |
| cimg_library::cimg::superset< unsigned long, short > | |
| cimg_library::cimg::superset< unsigned long, signed char > | |
| cimg_library::cimg::superset< unsigned short, char > | |
| cimg_library::cimg::superset< unsigned short, double > | |
| cimg_library::cimg::superset< unsigned short, float > | |
| cimg_library::cimg::superset< unsigned short, int > | |
| cimg_library::cimg::superset< unsigned short, long > | |
| cimg_library::cimg::superset< unsigned short, short > | |
| cimg_library::cimg::superset< unsigned short, signed char > | |
| cimg_library::cimg::superset< unsigned short, unsigned int > | |
| cimg_library::cimg::superset< unsigned short, unsigned long > | |
| cimg_library::cimg::type< T > | |
| cimg_library::cimg::type< bool > | |
| cimg_library::cimg::type< char > | |
| cimg_library::cimg::type< double > | |
| cimg_library::cimg::type< float > | |
| cimg_library::cimg::type< int > | |
| cimg_library::cimg::type< long > | |
| cimg_library::cimg::type< short > | |
| cimg_library::cimg::type< signed char > | |
| cimg_library::cimg::type< unsigned char > | |
| cimg_library::cimg::type< unsigned int > | |
| cimg_library::cimg::type< unsigned long > | |
| cimg_library::cimg::type< unsigned short > | |
| cimg_library::CImgArgumentException | |
| cimg_library::CImgDisplay | This class represents a window which can display CImg images and handles mouse and keyboard events |
| cimg_library::CImgDisplayException | |
| cimg_library::CImgException | Instances of this class are thrown when errors occur during a CImg library function call |
| cimg_library::CImgInstanceException | |
| cimg_library::CImgIOException | |
| cimg_library::CImgList< T > | Class representing list of images CImg<T> |
| cimg_library::CImgWarningException | |
| CINNIC | Main class to run an image in CINNICtest for contours |
| CINNIC2 | Main class to run an image in CINNICtest for contours |
| CINNICstatsRun | |
| CircleDetectionComponent | |
| CircleFillMeter | |
| CircleItem | |
| CircleShape | A Circle ShapeModel |
| ClassicSearchItem | |
| ClassicSearchItemFactory | |
| CLIST | |
| CloseButtonListener | Watch for close button actions with all registered XWinManaged windows |
| CMap_i | |
| CmapThread | |
| CMapThreads | |
| CMapWorkerThread | |
| CmdlineOptionManager | OptionManager implementation for command-line parsing |
| CmdlineOptionManager::Impl | |
| CmtAnalogInData | |
| CmtBinaryData | |
| CmtCalData | |
| CmtDataFormat | A structure for storing data formats |
| CmtDeviceConfiguration | Structure containing a full device configuration as returned by the ReqConfig message |
| CmtDeviceConfiguration::_devInfo | |
| CmtDeviceMode | A structure for storing device modes |
| CmtDeviceMode2 | A structure for storing device modes using period and skip factor (new default) |
| CmtEuler | |
| CmtGpsPvtData | |
| CmtGpsSatelliteInfo | |
| CmtGpsStatus | |
| CmtMatrix | |
| CmtPortInfo | Structure for storing information about a serial port |
| CmtQuat | |
| CmtRawData | |
| CmtRawPressureData | |
| CmtScenario | A structure for storing scenario information |
| CmtShortVector | |
| CmtSyncInSettings | A structure for storing sync in settings |
| CmtSyncOutSettings | A structure for storing sync out settings |
| CmtUtcTime | A structure for storing UTC Time values |
| CmtVector | |
| CmtVersion | A structure for storing the firmware version |
| CoerceVideoFormatOfilt | Output filter that coerces output into a particular VideoFormat |
| CollectedData | |
| ColorBandChannel | A color band channel |
| ColorbarsInput | FrameIstream class that generates a static "colorbars" test pattern |
| ColorBrain | |
| ColorChannel | A double opponent color channel class that combines r/g, b/y subchannels |
| ColorDef | |
| ColorHist | |
| ColorizeOfilt | Output filter that converts grayscale images to color via a colormap |
| ColorMap | Simple colormaps with N colors |
| ColorPixelClassifier | |
| ColorPixelClassifier::ColorCat | |
| ColorSegmenter | |
| ColorSegmenterI | |
| ColorSpectrum | |
| ColorTracker | Definition and access functions for ColorTracker class |
| CommandInfo | |
| common_struct | |
| comp | |
| CompassMeter | |
| CompassSensor | |
| CompLayer< EUnit, IUnit > | |
| ComplexChannel | A an abstract channel class that pools across several subchannels |
| ComplexChannel::Impl | |
| ComplexChannel::SubchanKey | Refer to a subchannel by one of: its index, its tagname, its address |
| ComplexMovement | |
| ComplexObject | |
| ComponentCreator< T > | |
| ComponentFactory< P > | Factory to create ModelComponent-derivative objects from a key string |
| CompositeColorChannel | A composite color channel class that contains single and double ! |
| CondVarSemaphore | |
| ConnectionDialog | |
| Context | |
| Contour | |
| ContourBoundaryDetector | |
| ContourChannel | |
| ContourConnection | The connection kernel between orientation-tuned units |
| ContourConnectionBraun | |
| ContourConnectionCinnic | |
| ContourLayer | Represents a single scale band in which contour facilitation is run |
| ContourLayerDynamic | Based on Achim Braun's unpublished Neural Computation paper |
| ContourLayerStatic | Based on CINNIC (Nathan Mundhenk) |
| ContourNeuronCreate< TC2 > | This class will create the neuron connection template |
| ContourNeuronProp< CH, X, Y > | Holds the property for each neuron |
| ContourNeuronProp2< FLOAT, INT > | Holds the property for each neuron |
| contourRun | Run the hyper column on a given image with a given connection template |
| contourRun2 | Run the hyper column on a given image with a given connection template |
| Contours | |
| Contours::Contour | |
| Contours::ContourCmp | |
| CONTRIB | |
| Controller | |
| ControllerLoopListener | |
| conversion_error | Type of exception that is thrown from throwBadConversion |
| convert_helper< dst_type, src_type, false, false > | |
| convert_helper< dst_type, src_type, false, true > | |
| convert_helper< dst_type, src_type, true, false > | |
| convert_helper< dst_type, src_type, true, true > | |
| convolutionMap< T > | Container class for convolution maps |
| ConvolveChannel | A generic convolution channel |
| ConvolvePyrBuilder< T > | Builds pyramids based on arbitrary filters |
| Convolver | |
| CopyStreamer | |
| cornerDB | |
| CornerNavigation | |
| CornersFeatures | |
| CornersFeatures::CornerState | |
| covEstimate< T > | This method attmepts to estimate eignen values and vectors |
| covHolder< FLOAT > | A general purpose container for holding guassian signatures |
| CpuTimer | Utility class for monitoring user/system cpu usage plus wall-clock time |
| crappyCompass | Can map crappy compass values to real headings as long as the crappy input is consistent |
| CrossRecognizer | |
| CtrlPolicy | |
| CudaDevices | |
| CudaFramework | |
| CudaHmax | Object recognition model inspired from Riesenhuber & Poggio's HMAX model |
| CudaHmaxCBCL | |
| CudaHmaxFL | Object recognition model inspired from Riesenhuber & Poggio's HMAX model |
| CudaHmaxFLSal | |
| CudaImage< T > | CudaImage template class |
| CudaImageDisplayGL | |
| CudaImageSet< T > | This class implements a set of images, often used as a dyadic pyramid |
| CudaPyramidCache< T > | |
| CudaPyramidCache< T >::Item | |
| CudaPyrBuilder< T > | An interface class for creating dyadic pyramids from input images |
| CudaReichardtPyrBuilder< T > | This class implements Reichardt motion detections |
| CudaSaliency | |
| CUDAVisualObject | Describes name and attributes of a visual object |
| currentIMUData | |
| CvHidHaarClassifier | |
| CvHidHaarClassifierCascade | |
| CvHidHaarFeature | |
| CvHidHaarStageClassifier | |
| CvHidHaarTreeNode | |
| DBManager | |
| DC1394Grabber2 | FireWire grabber class based on libdc1394 version 2.x |
| DcolorChannel | A D-component of DKL color channel |
| dec_hufftbl | |
| decision_function | |
| DecisionNode | |
| DecisionTree | |
| DefaultFactoryError< ReturnType, KeyType > | |
| Deinterlacer | Base class for deinterlacers |
| Demo::HelloWorld | |
| DepthChannel | A Depth channel for computing saliency based on a distance/depth to objects |
| DepthMeter | |
| DepthMotionChannel | A Depth channel for computing saliency based on a distance/depth to objects |
| DescriptorVec | Descriptor vector class |
| DescriptorVecDialog | |
| DetLocation | |
| Digest< N > | Template message digest class represting a digest with N bytes |
| Dims | A simple struct to hold a pair of width/height dimensions |
| DirectFeedChannel | Direct Feed Channel |
| DirectionChannel | Motion sensitive channel with direction selectivity |
| DirectionOpticalFlowChannel | |
| DirectionSpatioTemporalChannel | |
| DiskDataStream | A multi-threaded data streamer to disk |
| DiskDataStream::Impl | |
| DisparityChannel | An disparity channel |
| DisplayController | A thread to control the psycho display from an external controller |
| DispThread | |
| DKLcolorChannel | A DKL color channel |
| DoNothingFactoryError< ReturnType, KeyType > | |
| DOT | For drawing clouds of dots |
| DotStimuli | FrameIstream subclass that generates random images |
| DownwardVisionAgent | |
| DPM | |
| DPM::Detection | |
| DPM::DPMJob | |
| DPM::HOGFeatures | |
| DPM::Model | |
| DPM::ModelComponent | |
| DPM::ModelPart | |
| DPM::ModelScore | |
| DpxFile | DPX (Digital Picture Exchange) image file format |
| DpxFile::FileHeader | |
| DpxFile::FilmIndustryHeader | |
| DpxFile::ImageElementInfo | |
| DpxFile::ImageHeader | |
| DpxFile::OrientationHeader | |
| DpxFile::TelevisionIndustryHeader | |
| DpxParser | This class handles reading/parsing of DPX (Digital Picture Exchange) image files |
| dummy_namespace_to_avoid_gcc411_bug_CmdlineOptionManager_C::OptionInfo | OptionInfo holds mutable information related to a ModelOptionDef |
| dummy_namespace_to_avoid_gcc411_bug_ComplexChannel_C::ChannelHierarchySorter | |
| dummy_namespace_to_avoid_gcc411_bug_ComplexChannel_C::SubchanInfo | |
| dummy_namespace_to_avoid_gcc411_bug_ContourChannel_C::Accum | |
| dummy_namespace_to_avoid_gcc411_bug_ContourChannel_C::SaveSet | |
| dummy_namespace_to_avoid_gcc411_bug_DiskDataStream_C::DiskDumpJob | |
| dummy_namespace_to_avoid_gcc411_bug_DiskDataStream_C::DiskDumpStreamData | |
| dummy_namespace_to_avoid_gcc411_bug_IntegerComplexChannel_C::ChannelHierarchySorter | |
| dummy_namespace_to_avoid_gcc411_bug_IntegerComplexChannel_C::SubchanInfo | |
| dummy_namespace_to_avoid_gcc411_bug_ModelComponent_C::ParamInfo | Helper class to keep track of possibly-exported command-line options |
| dummy_namespace_to_avoid_gcc411_bug_ModelComponent_C::PtrChecker | Helper class to ensure that no one tries to do rutz::shared_ptr<ModelComponent> |
| dummy_namespace_to_avoid_gcc411_bug_ModelManagerWizard_ui_h::DefInfo | |
| dummy_namespace_to_avoid_gcc411_bug_ParamMap_C::Param | |
| dummy_namespace_to_avoid_gcc411_bug_YuvParser_C::VideoFileInfo | |
| DummyChannel | A dummy channel that simply passes its greyscale input to its output |
| EBNeuron | |
| EchoImageServer_i | |
| edge | |
| Edge | |
| Edgel | |
| EGMM | |
| EIEdgeImage | |
| EigenSpace | |
| ellipse | |
| EndPointChannel | An end point detector channel that detects line ends at different |
| Engine | |
| EntropyChannel | An entropy channel |
| env_alloc_stats | |
| env_color_job_data | |
| env_dims | A simple struct to hold a pair of width/height dimensions |
| env_direction_job_data | |
| env_flicker_job_data | |
| env_image | Basic image class |
| env_intens_job_data | |
| env_job | |
| env_math | |
| env_motion_channel | A composite channel containing a set of direction channels |
| env_motion_job_data | |
| env_ori_job_data | |
| env_ori_subjob_data | |
| env_params | |
| env_pyr | This class implements a set of images, often used as a dyadic pyramid |
| env_rgb_pixel | RGB pixel class |
| env_visual_cortex | The Visual Cortex |
| EnvBrain | |
| EnvInferoTemporal | |
| Environment | Environment class |
| EnvisionStreamer | |
| EnvObjDetection | |
| EnvSaliencyMap | |
| EnvSaliencyMap::LocInfo | |
| EnvSaliencyMap::State | |
| EnvSegmenter | Base class for segmentation algorithms |
| EnvSegmenterCannyContour | |
| EnvSegmenterColorRegion | FOA segmenter |
| EnvSegmenterConfigurator | Configurator for EnvSegmenter subclasses |
| EnvSimulationViewer | |
| EnvVisualCortex | A VisualCortex using the fast envision saliency computations, version with byte outputs |
| EnvVisualCortexBase | Base class for a VisualCortex using the fast envision saliency computations |
| EnvVisualCortexFloat | A VisualCortex using the fast envision saliency computations, version with float outputs |
| EventFilt | Class to filter events |
| EventLog | EventLog is a simple text-based event logger |
| EventsNS::AMI_Events_evolve | |
| EventsNS::Event | |
| EventsNS::Event__staticInit | |
| EventsNS::Events | |
| EventsNS::Message1 | |
| EventsNS::Message2 | |
| ExhaustiveBrain | |
| ExpDecoder | A Exponential rate decoder |
| EyeData | Simple struct for eye-tracker data |
| EyeFilter | |
| EyeHeadController | This is the base class for an eye and head controller |
| EyeHeadControllerConfigurator | EyeHeadController configurator for eye |
| EyeLinkAscParser | |
| EyesalData | Simple class for an eyesal output file data, represents data and I/O |
| EyeSFile | Read data from a .eyeS eye position file |
| EyeTrace | An eye movement trace |
| EyeTracker | Abstraction of an eye tracker device, virtual base class |
| EyeTrackerConfigurator | EyeTracker configurator |
| EyeTrackerDML | Interface to eye-tracker used in Doug Munoz' lab |
| EyeTrackerEyeHeadController | EyeTracker eye/head controller |
| EyeTrackerEyeLink | Interface to an EyeLink-II eye-tracker |
| EyeTrackerISCAN | Interface to an ISCAN RK-464 eye-tracker |
| EyeTrackerStub | Stub implementation of the EyeTracker class |
| EyeTrackerTIL | Interface to eye-tracker used in Tadashi Isa's lab |
| EyeTrackerUDP | Interface to eye-tracker used in Doug Munoz' lab |
| FaceDetector | |
| fCV_STM | |
| FeatureBiaser | Bias the features at submap idx with mean, intra-class std. dev and inter-sub-class std. dev |
| featureClusterVision< FLOAT > | Main class for VFAT. This combines all the methods etc |
| FeatureExtractor | Base class for topdown feature extractors |
| FeatureVector | The FeatureVector class |
| FeedbackMotor | |
| FeedForwardNetwork | A Feed Forward Network |
| FfmpegDecoder | Low-level class for using ffmpeg to decode movie files |
| FfmpegEncoder | Low-level class for using ffmpeg to decode movie files |
| FfmpegPacketDecoder | Decode a movie using ffmpeg's libavformat packet streaming API |
| FFNtrainInfo | |
| FFTBinAffinePrediction | |
| FFTWWrapper | |
| fillColor | |
| fillTexture | |
| fillTool | |
| filter_Image | |
| FilterLabel | |
| findColorIndex | |
| FindLandmark | |
| Fixation | |
| FixedRasterOutputSeries< F > | Implements RasterOutputSeries with a fixed file type |
| FixedSaccadeController | Fixed saccade controller |
| FlickerChannel | A temporal flicker channel |
| FlickerNBackChannel | A temporal flicker channel |
| float3_t | Structure to handle 3 dimensional float |
| float4_t | Structure to handle 4 dimensional float |
| FlowVector | |
| FoeDetector | |
| FOEestimator | Compute the focus of expansion (FOE) from the pixel-based optical flow |
| FoeMSTChannel | A FOE MST channel that detects FOE |
| ForegroundDetectionChannel | A channel for separating foreground from background |
| ForwardVisionAgent | |
| FourierEngine< T > | Thin wrapper around the fftw3 library for the discrete fourier transform |
| FourierFeatureExtractor | Extract topdown features using fourier decomposition |
| FourierInvEngine< T > | Thin wrapper around the fftw3 for computing inverse fourier transforms |
| FovealTransform | |
| FovealTransformModule | |
| Foveator | An abstract class for space-variant image processing |
| FpsTimer | Utility class for monitoring framerates and cpu usage ratios |
| FpsTimer::State | |
| frame | |
| FrameCounter | Frame counting based on a given FrameRange |
| FrameGrabberConfigurator | This class is for run-time selection of a frame grabber driver |
| FrameInfo | Simple struct for holding auxiliary info about an output frame |
| FrameIstream | Abstract interface class representing a source of Image frames |
| FrameListener | Listener class that can get called each time a FrameIstream grabs a frame |
| FrameOfilt | Generic base class for output frame filters |
| FrameOstream | Abstract interface class representing a destination for Image frames |
| FrameRange | Specification of a range of frames with given inter-frame delay |
| free_list | Base class for maintaining a free-list memory pool |
| free_list_node | Free-node class for free-list memory pools |
| FrictionSaccadeController | Friction-damped mass-spring saccade controller |
| FSNeuron | |
| FuzzyART | |
| FuzzyART::Unit | |
| GaborChannel | An orientation-tuned gabor channel |
| gaborElement | |
| GaborPatch | Manages a pixmap representation of a gabor patch |
| GaborPatchItem | |
| GaborPatchItemFactory | |
| GaborPyrBuilder< T > | A pyramid based on convolution with oriented Gabor filters |
| GaborSnake | |
| GaborSpec | |
| GAChromosome | Chromosome class for genetic algorithm |
| GameOfLifeInput | |
| Ganglion | |
| GAPopulation | Population class for genetic algorithm |
| GaussianDef | Definition for a gaussian used for GMM |
| GaussianPyrBuilder< T > | Builds pyramids based on Gaussian filters |
| GaussianPyrChannel | |
| GaussianRadialPyrBuilder< T > | Builds pyramids based on Gaussian filters with boundary conditions for radially transformed images |
| GeneralGUI | |
| GenericFactory< ReturnType, KeyType, TypeCreator, ErrorPolicy > | |
| GenericFrame | Discriminated union of rgb, grayscale, floating-point, and video-yuv images |
| GenericFrame::MetaData | MetaData for storing frame spacific information |
| GenericFrameSpec | Gives specification of a GenericFrame |
| GenericPyrBuilder< T > | Builds pyramids of a type specified by a PyramidType |
| GenericRasterOutputSeries | Implements RasterOutputSeries using a command-line option to determine the output format |
| GenSumFunc< T, Tail...> | |
| GenSumFunc<> | |
| GentleBoost | Multi-Class Gentle-AdaBoost using a One vs All, MAX wins voting scheme |
| GentleBoostBinary | |
| GentleBoostComponent | Double inheritence from SimComponent GentleBoost |
| geom::vec2< V > | Gfx::vec2 is a 2-D vector class for representing 2-D points or distances |
| GeometricHashing | |
| GeometricHashing::Acc | |
| GeometricHashing::AccCmp | |
| GeometricHashing::Model | |
| GeometricHashing::ModelTableEntry | |
| GeometricHashing::TableEntry | |
| Geons2D | |
| Geons2D::Geons2DState | |
| Geons3D | |
| Geons3D::GeonState | |
| GetSaliency | This class allows for easy access to the list of salient points in an image |
| GHough | |
| GHough::Acc | |
| GHough::AccCmp | |
| GHough::Feature | |
| GHough::Model | |
| GHough::RTable | |
| Gist_Navigation | |
| GistEstimator | Abstract base class; see GistEstimatorStd for the standard implementation |
| GistEstimatorAdapter | Gist save adapter class |
| GistEstimatorBeyondBoF | Gist estimator for ``Beyond Bags of Features ...'' by Lazebnik, et al |
| GistEstimatorBeyondBoF::SiftDescriptor | |
| GistEstimatorConfigurator | GistEstimator configurator |
| GistEstimatorContextBased | Gist estimator for ``Context-based vision system...'' by Torralba, et al |
| GistEstimatorFFT | |
| GistEstimatorGen | |
| GistEstimatorStd | |
| GistEstimatorStub | Abstract base class; see GistEstimatorStd for the standard implementation |
| GistEstimatorSurfPMK | |
| GistEstimatorTexton | |
| GistPixelClassifier | |
| GistSal_Grapher | |
| GistSal_Navigation | Vision Navigation using Gist and Salient Regions |
| gPatch | |
| GPS | Interface with a GPS unit (tested with Garmin Geko 301) using NMEA 0183 |
| GPS_USGlobalSat_EM_408 | |
| GPSdata | Data received from the GPS unit |
| GpsData | |
| GPSlistener | GPS event listener |
| GPSPos | |
| GrabJob | A grab job (we grab from all cameras in parallel) |
| GrabQtMainForm | |
| Graph | |
| GreenChannel | A green color channel |
| GreenRedChannel | A green-red double-opponent color channel |
| GridMap | Topological map using a list of landmarks |
| gsl::block | |
| gsl::matrix | |
| gsl::vector | |
| gsl::view_of< T > | |
| GSlocalizer | |
| GSlocJobData | |
| GSnav_M_Result | |
| GSnavResult | |
| GSparticle | |
| GTEvaluator | |
| GuidedSearchBiaser | Implementation of Guided Search, aka biased saliency computation |
| GumbotI | |
| GVX_DBG_REGISTER::ErrnoSaver | |
| Gyro | |
| H2SVChannel | A double opponent color channel class that combines r/g, b/y subchannels |
| Hack_Navigation | |
| HalfFieldDeinterlacer< BottomField > | "Deinterlace" frames by always returning either the top (or bottom) half-field |
| HandController | |
| HandControllerConfigurator | |
| HandData | Simple struct for hand movement data |
| HandTrace | A hand movement trace |
| HarrierSim | |
| HashOutputSeries | FrameOstream subclass that writes image hashes to an output file |
| HashOutputSeries::Impl | |
| HawkAgent | |
| HawkAgent::Parameter | |
| HawkExample | |
| HawkFreezer | |
| HawkMessages::CameraImageMessage | |
| HawkMessages::ControlCameraMessage | |
| HawkMessages::ControlDriveVisionMessage | |
| HawkMessages::ControlLandMessage | |
| HawkMessages::ControlMoveMessage | |
| HawkMessages::ControlRoomVisionMessage | |
| HawkMessages::ControlTakeOffMessage | |
| HawkMessages::DriveFinderMessage | |
| HawkMessages::ExampleMessage | |
| HawkMessages::ExecuteMissionMessage | |
| HawkMessages::Message | |
| HawkMessages::Message__staticInit | |
| HawkMessages::MessageAgent | |
| HawkMessages::MissionListMessage | |
| HawkMessages::Pose | |
| HawkMessages::RoomFinderMessage | |
| HawkMessages::SensorDataMessage | |
| HawkMessages::SlamDataMessage | |
| HawkMessages::Sonar | |
| HawkNavigator | |
| HawkScanner | |
| HawkSimulator | |
| HawkSlammer | |
| HawkVisionDrive | |
| HawkVisionSign | |
| HeliPose | |
| HeliPose::Pose | |
| HelloWorldI | |
| HippocampusI | |
| HippocampusI::Landmark | |
| HippocampusI::Particle | |
| HippocampusI::TopicInfo | |
| HippocampusService | |
| HistDecoder | A histogram (non overlapping) decoder, spike count |
| Histogram | Histogram |
| HistogramOfGradients | |
| Hmax | Object recognition model inspired from Riesenhuber & Poggio's HMAX model |
| HmaxFL | Object recognition model inspired from Riesenhuber & Poggio's HMAX model |
| HMM< T > | |
| HMM< T >::Path | |
| HMM< T >::SeqInfo | |
| HMR3300 | Class for interfacing with a Honeywell HMR-3300 compass |
| HMR3300Listener | A hook which will be called when a new compass reading is received |
| HMRlistener | |
| HOG | |
| HoldDecoder | A decoder that just passes through the data, possibly with a delay |
| HTTPClient | Interface to a HTTPClient port |
| HttpEncoder | Low-level class for using ffmpeg to decode movie files |
| HttpServer | Interface to a HttpServer port |
| Hue1Channel | A hue1 red-green double-opponent color channel |
| Hue2Channel | A hue1 red-green double-opponent color channel |
| HueChannel | A hue similarity channel |
| hufftblp | |
| HyperRectangle | Represents a rectangle in n-dimensional space |
| IceCommunicator | |
| IceDelegate::BeobotEvents::AbortMessage | |
| IceDelegate::BeobotEvents::CameraMessage | |
| IceDelegate::BeobotEvents::CancelSearchMessage | |
| IceDelegate::BeobotEvents::CornerLocationMessage | |
| IceDelegate::BeobotEvents::CornerMotorRequest | |
| IceDelegate::BeobotEvents::CurrentLocationMessage | |
| IceDelegate::BeobotEvents::FacesMessage | |
| IceDelegate::BeobotEvents::GistSalMessage | |
| IceDelegate::BeobotEvents::GPSMessage | |
| IceDelegate::BeobotEvents::GUISpeechMessage | |
| IceDelegate::BeobotEvents::IMUMessage | |
| IceDelegate::BeobotEvents::LandmarkDBSearchResultMessage | |
| IceDelegate::BeobotEvents::LandmarkMatchResultMessage | |
| IceDelegate::BeobotEvents::LandmarkSearchQueueMessage | |
| IceDelegate::BeobotEvents::LandmarkSearchStatMessage | |
| IceDelegate::BeobotEvents::LandmarkTrackMessage | |
| IceDelegate::BeobotEvents::LRFMessage | |
| IceDelegate::BeobotEvents::MotorMessage | |
| IceDelegate::BeobotEvents::MotorRequest | |
| IceDelegate::BeobotEvents::NextFrameMessage | |
| IceDelegate::BeobotEvents::SearchDoneMessage | |
| IceDelegate::BeobotEvents::SLAMMessage | |
| IceDelegate::BeobotEvents::SonarMessage | |
| IceDelegate::BrainObjects::Hippocampus | |
| IceDelegate::BrainObjects::HomeInterface | |
| IceDelegate::BrainObjects::InferotemporalCortex | |
| IceDelegate::BrainObjects::PrefrontalCortex | |
| IceDelegate::BrainObjects::PrimaryMotorCortex | |
| IceDelegate::BrainObjects::PTZ | |
| IceDelegate::BrainObjects::Retina | |
| IceDelegate::BrainObjects::SaliencyMap | |
| IceDelegate::BrainObjects::Segmenter | |
| IceDelegate::BrainObjects::SimulationViewer | |
| IceDelegate::BrainObjects::VisualCortex | |
| IceDelegate::BrainObjects::VisualTracker | |
| IceDelegate::ChipInfoIceMod::ChipInfoServerFactoryIce | |
| IceDelegate::ChipInfoIceMod::ChipInfoServerIce | |
| IceDelegate::Demo::HelloWorld | |
| IceDelegate::EventsNS::Event | |
| IceDelegate::EventsNS::Events | |
| IceDelegate::EventsNS::Message1 | |
| IceDelegate::EventsNS::Message2 | |
| IceDelegate::HawkMessages::CameraImageMessage | |
| IceDelegate::HawkMessages::ControlCameraMessage | |
| IceDelegate::HawkMessages::ControlDriveVisionMessage | |
| IceDelegate::HawkMessages::ControlLandMessage | |
| IceDelegate::HawkMessages::ControlMoveMessage | |
| IceDelegate::HawkMessages::ControlRoomVisionMessage | |
| IceDelegate::HawkMessages::ControlTakeOffMessage | |
| IceDelegate::HawkMessages::DriveFinderMessage | |
| IceDelegate::HawkMessages::ExampleMessage | |
| IceDelegate::HawkMessages::ExecuteMissionMessage | |
| IceDelegate::HawkMessages::Message | |
| IceDelegate::HawkMessages::MessageAgent | |
| IceDelegate::HawkMessages::MissionListMessage | |
| IceDelegate::HawkMessages::RoomFinderMessage | |
| IceDelegate::HawkMessages::SensorDataMessage | |
| IceDelegate::HawkMessages::SlamDataMessage | |
| IceDelegate::ImageIceMod::ImageShuttle | |
| IceDelegate::RobotBrainObjects::Hippocampus | |
| IceDelegate::RobotBrainObjects::InferotemporalCortex | |
| IceDelegate::RobotBrainObjects::LateralGeniculateNucleus | |
| IceDelegate::RobotBrainObjects::Observer | |
| IceDelegate::RobotBrainObjects::PrefrontalCortex | |
| IceDelegate::RobotBrainObjects::PrimaryMotorCortex | |
| IceDelegate::RobotBrainObjects::PrimarySomatosensoryCortex | |
| IceDelegate::RobotBrainObjects::Retina | |
| IceDelegate::RobotBrainObjects::SaliencyModule | |
| IceDelegate::RobotBrainObjects::SupplementaryMotorArea | |
| IceDelegate::Robots::Gumbot | |
| IceDelegate::Robots::IRobot | |
| IceDelegate::Robots::ScorbotIce | |
| IceDelegate::RobotSimEvents::ActionMessage | |
| IceDelegate::RobotSimEvents::AttendedRegionMessage | |
| IceDelegate::RobotSimEvents::BeeStemConfigMessage | |
| IceDelegate::RobotSimEvents::BeeStemMessage | |
| IceDelegate::RobotSimEvents::BeeStemMotorControllerMessage | |
| IceDelegate::RobotSimEvents::BeoHawkEyeSpyMessage | |
| IceDelegate::RobotSimEvents::BuoyColorSegmentConfigMessage | |
| IceDelegate::RobotSimEvents::BuoyColorSegmentMessage | |
| IceDelegate::RobotSimEvents::CameraConfigMessage | |
| IceDelegate::RobotSimEvents::CameraImageMessage | |
| IceDelegate::RobotSimEvents::ChatMessage | |
| IceDelegate::RobotSimEvents::ControlCameraMessage | |
| IceDelegate::RobotSimEvents::ControlDriveVisionMessage | |
| IceDelegate::RobotSimEvents::ControlLandMessage | |
| IceDelegate::RobotSimEvents::ControlMoveMessage | |
| IceDelegate::RobotSimEvents::EventMessage | |
| IceDelegate::RobotSimEvents::Events | |
| IceDelegate::RobotSimEvents::ExecuteMissionMessage | |
| IceDelegate::RobotSimEvents::GoalProgressMessage | |
| IceDelegate::RobotSimEvents::GoalStateMessage | |
| IceDelegate::RobotSimEvents::GPSMessage | |
| IceDelegate::RobotSimEvents::IMUDataServerMessage | |
| IceDelegate::RobotSimEvents::JoyStickControlMessage | |
| IceDelegate::RobotSimEvents::LandmarksMessage | |
| IceDelegate::RobotSimEvents::LocalizationMessage | |
| IceDelegate::RobotSimEvents::MotionMessage | |
| IceDelegate::RobotSimEvents::MovementControllerMessage | |
| IceDelegate::RobotSimEvents::ObjectMessage | |
| IceDelegate::RobotSimEvents::PipeColorSegmentConfigMessage | |
| IceDelegate::RobotSimEvents::PipeColorSegmentMessage | |
| IceDelegate::RobotSimEvents::RemoteControlMessage | |
| IceDelegate::RobotSimEvents::RetinaMessage | |
| IceDelegate::RobotSimEvents::SalientPointMessage | |
| IceDelegate::RobotSimEvents::SeaBeePositionMessage | |
| IceDelegate::RobotSimEvents::SeaBeeStateConditionMessage | |
| IceDelegate::RobotSimEvents::SensorDataMessage | |
| IceDelegate::RobotSimEvents::SlamDataMessage | |
| IceDelegate::RobotSimEvents::StateMessage | |
| IceDelegate::RobotSimEvents::StraightEdgeMessage | |
| IceDelegate::RobotSimEvents::VisionObjectMessage | |
| IceDelegate::RobotSimEvents::VisionRectangleMessage | |
| IceDelegate::ScorbotIce::Scorbot | |
| IceDelegate::ScorbotSimpleIce::ScorbotSimple | |
| IceDelegate::SeaBeeSimEvents::CameraConfigMessage | |
| IceDelegate::SimEvents::CameraCtrlBiasMessage | |
| IceDelegate::SimEvents::CameraCtrlMessage | |
| IceDelegate::SimEvents::EventMessage | |
| IceDelegate::SimEvents::Events | |
| IceDelegate::SimEvents::GUIInputMessage | |
| IceDelegate::SimEvents::GUIOutputMessage | |
| IceDelegate::SimEvents::HippocampusBiasMessage | |
| IceDelegate::SimEvents::HippocampusMessage | |
| IceDelegate::SimEvents::InfrotemporalCortexBiasMessage | |
| IceDelegate::SimEvents::InfrotemporalCortexMessage | |
| IceDelegate::SimEvents::PrimaryMotorCortexBiasMessage | |
| IceDelegate::SimEvents::PrimaryMotorCortexMessage | |
| IceDelegate::SimEvents::PrimaryMotorCortexRelativeServoMessage | |
| IceDelegate::SimEvents::PrimaryMotorCortexResetEncodersMessage | |
| IceDelegate::SimEvents::RetinaMessage | |
| IceDelegate::SimEvents::SaliencyMapBiasMessage | |
| IceDelegate::SimEvents::SaliencyMapMessage | |
| IceDelegate::SimEvents::SegmenterBiasMessage | |
| IceDelegate::SimEvents::SegmenterMessage | |
| IceDelegate::SimEvents::VisualCortexMessage | |
| IceDelegate::SimEvents::VisualTrackerBiasMessage | |
| IceDelegate::SimEvents::VisualTrackerMessage | |
| IceDelegate::TestPub::Publisher1 | |
| IceDelegate::TestPub::Publisher2 | |
| IceDelegate::TestPub::Subscriber1 | |
| IceDelegate::TestPub::Subscriber2 | |
| IceDelegate::TestSIFT::SIFTMatcher | |
| IceDelegateD::BeobotEvents::AbortMessage | |
| IceDelegateD::BeobotEvents::CameraMessage | |
| IceDelegateD::BeobotEvents::CancelSearchMessage | |
| IceDelegateD::BeobotEvents::CornerLocationMessage | |
| IceDelegateD::BeobotEvents::CornerMotorRequest | |
| IceDelegateD::BeobotEvents::CurrentLocationMessage | |
| IceDelegateD::BeobotEvents::FacesMessage | |
| IceDelegateD::BeobotEvents::GistSalMessage | |
| IceDelegateD::BeobotEvents::GPSMessage | |
| IceDelegateD::BeobotEvents::GUISpeechMessage | |
| IceDelegateD::BeobotEvents::IMUMessage | |
| IceDelegateD::BeobotEvents::LandmarkDBSearchResultMessage | |
| IceDelegateD::BeobotEvents::LandmarkMatchResultMessage | |
| IceDelegateD::BeobotEvents::LandmarkSearchQueueMessage | |
| IceDelegateD::BeobotEvents::LandmarkSearchStatMessage | |
| IceDelegateD::BeobotEvents::LandmarkTrackMessage | |
| IceDelegateD::BeobotEvents::LRFMessage | |
| IceDelegateD::BeobotEvents::MotorMessage | |
| IceDelegateD::BeobotEvents::MotorRequest | |
| IceDelegateD::BeobotEvents::NextFrameMessage | |
| IceDelegateD::BeobotEvents::SearchDoneMessage | |
| IceDelegateD::BeobotEvents::SLAMMessage | |
| IceDelegateD::BeobotEvents::SonarMessage | |
| IceDelegateD::BrainObjects::Hippocampus | |
| IceDelegateD::BrainObjects::HomeInterface | |
| IceDelegateD::BrainObjects::InferotemporalCortex | |
| IceDelegateD::BrainObjects::PrefrontalCortex | |
| IceDelegateD::BrainObjects::PrimaryMotorCortex | |
| IceDelegateD::BrainObjects::PTZ | |
| IceDelegateD::BrainObjects::Retina | |
| IceDelegateD::BrainObjects::SaliencyMap | |
| IceDelegateD::BrainObjects::Segmenter | |
| IceDelegateD::BrainObjects::SimulationViewer | |
| IceDelegateD::BrainObjects::VisualCortex | |
| IceDelegateD::BrainObjects::VisualTracker | |
| IceDelegateD::ChipInfoIceMod::ChipInfoServerFactoryIce | |
| IceDelegateD::ChipInfoIceMod::ChipInfoServerIce | |
| IceDelegateD::Demo::HelloWorld | |
| IceDelegateD::EventsNS::Event | |
| IceDelegateD::EventsNS::Events | |
| IceDelegateD::EventsNS::Message1 | |
| IceDelegateD::EventsNS::Message2 | |
| IceDelegateD::HawkMessages::CameraImageMessage | |
| IceDelegateD::HawkMessages::ControlCameraMessage | |
| IceDelegateD::HawkMessages::ControlDriveVisionMessage | |
| IceDelegateD::HawkMessages::ControlLandMessage | |
| IceDelegateD::HawkMessages::ControlMoveMessage | |
| IceDelegateD::HawkMessages::ControlRoomVisionMessage | |
| IceDelegateD::HawkMessages::ControlTakeOffMessage | |
| IceDelegateD::HawkMessages::DriveFinderMessage | |
| IceDelegateD::HawkMessages::ExampleMessage | |
| IceDelegateD::HawkMessages::ExecuteMissionMessage | |
| IceDelegateD::HawkMessages::Message | |
| IceDelegateD::HawkMessages::MessageAgent | |
| IceDelegateD::HawkMessages::MissionListMessage | |
| IceDelegateD::HawkMessages::RoomFinderMessage | |
| IceDelegateD::HawkMessages::SensorDataMessage | |
| IceDelegateD::HawkMessages::SlamDataMessage | |
| IceDelegateD::ImageIceMod::ImageShuttle | |
| IceDelegateD::RobotBrainObjects::Hippocampus | |
| IceDelegateD::RobotBrainObjects::InferotemporalCortex | |
| IceDelegateD::RobotBrainObjects::LateralGeniculateNucleus | |
| IceDelegateD::RobotBrainObjects::Observer | |
| IceDelegateD::RobotBrainObjects::PrefrontalCortex | |
| IceDelegateD::RobotBrainObjects::PrimaryMotorCortex | |
| IceDelegateD::RobotBrainObjects::PrimarySomatosensoryCortex | |
| IceDelegateD::RobotBrainObjects::Retina | |
| IceDelegateD::RobotBrainObjects::SaliencyModule | |
| IceDelegateD::RobotBrainObjects::SupplementaryMotorArea | |
| IceDelegateD::Robots::Gumbot | |
| IceDelegateD::Robots::IRobot | |
| IceDelegateD::Robots::ScorbotIce | |
| IceDelegateD::RobotSimEvents::ActionMessage | |
| IceDelegateD::RobotSimEvents::AttendedRegionMessage | |
| IceDelegateD::RobotSimEvents::BeeStemConfigMessage | |
| IceDelegateD::RobotSimEvents::BeeStemMessage | |
| IceDelegateD::RobotSimEvents::BeeStemMotorControllerMessage | |
| IceDelegateD::RobotSimEvents::BeoHawkEyeSpyMessage | |
| IceDelegateD::RobotSimEvents::BuoyColorSegmentConfigMessage | |
| IceDelegateD::RobotSimEvents::BuoyColorSegmentMessage | |
| IceDelegateD::RobotSimEvents::CameraConfigMessage | |
| IceDelegateD::RobotSimEvents::CameraImageMessage | |
| IceDelegateD::RobotSimEvents::ChatMessage | |
| IceDelegateD::RobotSimEvents::ControlCameraMessage | |
| IceDelegateD::RobotSimEvents::ControlDriveVisionMessage | |
| IceDelegateD::RobotSimEvents::ControlLandMessage | |
| IceDelegateD::RobotSimEvents::ControlMoveMessage | |
| IceDelegateD::RobotSimEvents::EventMessage | |
| IceDelegateD::RobotSimEvents::Events | |
| IceDelegateD::RobotSimEvents::ExecuteMissionMessage | |
| IceDelegateD::RobotSimEvents::GoalProgressMessage | |
| IceDelegateD::RobotSimEvents::GoalStateMessage | |
| IceDelegateD::RobotSimEvents::GPSMessage | |
| IceDelegateD::RobotSimEvents::IMUDataServerMessage | |
| IceDelegateD::RobotSimEvents::JoyStickControlMessage | |
| IceDelegateD::RobotSimEvents::LandmarksMessage | |
| IceDelegateD::RobotSimEvents::LocalizationMessage | |
| IceDelegateD::RobotSimEvents::MotionMessage | |
| IceDelegateD::RobotSimEvents::MovementControllerMessage | |
| IceDelegateD::RobotSimEvents::ObjectMessage | |
| IceDelegateD::RobotSimEvents::PipeColorSegmentConfigMessage | |
| IceDelegateD::RobotSimEvents::PipeColorSegmentMessage | |
| IceDelegateD::RobotSimEvents::RemoteControlMessage | |
| IceDelegateD::RobotSimEvents::RetinaMessage | |
| IceDelegateD::RobotSimEvents::SalientPointMessage | |
| IceDelegateD::RobotSimEvents::SeaBeePositionMessage | |
| IceDelegateD::RobotSimEvents::SeaBeeStateConditionMessage | |
| IceDelegateD::RobotSimEvents::SensorDataMessage | |
| IceDelegateD::RobotSimEvents::SlamDataMessage | |
| IceDelegateD::RobotSimEvents::StateMessage | |
| IceDelegateD::RobotSimEvents::StraightEdgeMessage | |
| IceDelegateD::RobotSimEvents::VisionObjectMessage | |
| IceDelegateD::RobotSimEvents::VisionRectangleMessage | |
| IceDelegateD::ScorbotIce::Scorbot | |
| IceDelegateD::ScorbotSimpleIce::ScorbotSimple | |
| IceDelegateD::SeaBeeSimEvents::CameraConfigMessage | |
| IceDelegateD::SimEvents::CameraCtrlBiasMessage | |
| IceDelegateD::SimEvents::CameraCtrlMessage | |
| IceDelegateD::SimEvents::EventMessage | |
| IceDelegateD::SimEvents::Events | |
| IceDelegateD::SimEvents::GUIInputMessage | |
| IceDelegateD::SimEvents::GUIOutputMessage | |
| IceDelegateD::SimEvents::HippocampusBiasMessage | |
| IceDelegateD::SimEvents::HippocampusMessage | |
| IceDelegateD::SimEvents::InfrotemporalCortexBiasMessage | |
| IceDelegateD::SimEvents::InfrotemporalCortexMessage | |
| IceDelegateD::SimEvents::PrimaryMotorCortexBiasMessage | |
| IceDelegateD::SimEvents::PrimaryMotorCortexMessage | |
| IceDelegateD::SimEvents::PrimaryMotorCortexRelativeServoMessage | |
| IceDelegateD::SimEvents::PrimaryMotorCortexResetEncodersMessage | |
| IceDelegateD::SimEvents::RetinaMessage | |
| IceDelegateD::SimEvents::SaliencyMapBiasMessage | |
| IceDelegateD::SimEvents::SaliencyMapMessage | |
| IceDelegateD::SimEvents::SegmenterBiasMessage | |
| IceDelegateD::SimEvents::SegmenterMessage | |
| IceDelegateD::SimEvents::VisualCortexMessage | |
| IceDelegateD::SimEvents::VisualTrackerBiasMessage | |
| IceDelegateD::SimEvents::VisualTrackerMessage | |
| IceDelegateD::TestPub::Publisher1 | |
| IceDelegateD::TestPub::Publisher2 | |
| IceDelegateD::TestPub::Subscriber1 | |
| IceDelegateD::TestPub::Subscriber2 | |
| IceDelegateD::TestSIFT::SIFTMatcher | |
| IceDelegateM::BeobotEvents::AbortMessage | |
| IceDelegateM::BeobotEvents::CameraMessage | |
| IceDelegateM::BeobotEvents::CancelSearchMessage | |
| IceDelegateM::BeobotEvents::CornerLocationMessage | |
| IceDelegateM::BeobotEvents::CornerMotorRequest | |
| IceDelegateM::BeobotEvents::CurrentLocationMessage | |
| IceDelegateM::BeobotEvents::FacesMessage | |
| IceDelegateM::BeobotEvents::GistSalMessage | |
| IceDelegateM::BeobotEvents::GPSMessage | |
| IceDelegateM::BeobotEvents::GUISpeechMessage | |
| IceDelegateM::BeobotEvents::IMUMessage | |
| IceDelegateM::BeobotEvents::LandmarkDBSearchResultMessage | |
| IceDelegateM::BeobotEvents::LandmarkMatchResultMessage | |
| IceDelegateM::BeobotEvents::LandmarkSearchQueueMessage | |
| IceDelegateM::BeobotEvents::LandmarkSearchStatMessage | |
| IceDelegateM::BeobotEvents::LandmarkTrackMessage | |
| IceDelegateM::BeobotEvents::LRFMessage | |
| IceDelegateM::BeobotEvents::MotorMessage | |
| IceDelegateM::BeobotEvents::MotorRequest | |
| IceDelegateM::BeobotEvents::NextFrameMessage | |
| IceDelegateM::BeobotEvents::SearchDoneMessage | |
| IceDelegateM::BeobotEvents::SLAMMessage | |
| IceDelegateM::BeobotEvents::SonarMessage | |
| IceDelegateM::BrainObjects::Hippocampus | |
| IceDelegateM::BrainObjects::HomeInterface | |
| IceDelegateM::BrainObjects::InferotemporalCortex | |
| IceDelegateM::BrainObjects::PrefrontalCortex | |
| IceDelegateM::BrainObjects::PrimaryMotorCortex | |
| IceDelegateM::BrainObjects::PTZ | |
| IceDelegateM::BrainObjects::Retina | |
| IceDelegateM::BrainObjects::SaliencyMap | |
| IceDelegateM::BrainObjects::Segmenter | |
| IceDelegateM::BrainObjects::SimulationViewer | |
| IceDelegateM::BrainObjects::VisualCortex | |
| IceDelegateM::BrainObjects::VisualTracker | |
| IceDelegateM::ChipInfoIceMod::ChipInfoServerFactoryIce | |
| IceDelegateM::ChipInfoIceMod::ChipInfoServerIce | |
| IceDelegateM::Demo::HelloWorld | |
| IceDelegateM::EventsNS::Event | |
| IceDelegateM::EventsNS::Events | |
| IceDelegateM::EventsNS::Message1 | |
| IceDelegateM::EventsNS::Message2 | |
| IceDelegateM::HawkMessages::CameraImageMessage | |
| IceDelegateM::HawkMessages::ControlCameraMessage | |
| IceDelegateM::HawkMessages::ControlDriveVisionMessage | |
| IceDelegateM::HawkMessages::ControlLandMessage | |
| IceDelegateM::HawkMessages::ControlMoveMessage | |
| IceDelegateM::HawkMessages::ControlRoomVisionMessage | |
| IceDelegateM::HawkMessages::ControlTakeOffMessage | |
| IceDelegateM::HawkMessages::DriveFinderMessage | |
| IceDelegateM::HawkMessages::ExampleMessage | |
| IceDelegateM::HawkMessages::ExecuteMissionMessage | |
| IceDelegateM::HawkMessages::Message | |
| IceDelegateM::HawkMessages::MessageAgent | |
| IceDelegateM::HawkMessages::MissionListMessage | |
| IceDelegateM::HawkMessages::RoomFinderMessage | |
| IceDelegateM::HawkMessages::SensorDataMessage | |
| IceDelegateM::HawkMessages::SlamDataMessage | |
| IceDelegateM::ImageIceMod::ImageShuttle | |
| IceDelegateM::RobotBrainObjects::Hippocampus | |
| IceDelegateM::RobotBrainObjects::InferotemporalCortex | |
| IceDelegateM::RobotBrainObjects::LateralGeniculateNucleus | |
| IceDelegateM::RobotBrainObjects::Observer | |
| IceDelegateM::RobotBrainObjects::PrefrontalCortex | |
| IceDelegateM::RobotBrainObjects::PrimaryMotorCortex | |
| IceDelegateM::RobotBrainObjects::PrimarySomatosensoryCortex | |
| IceDelegateM::RobotBrainObjects::Retina | |
| IceDelegateM::RobotBrainObjects::SaliencyModule | |
| IceDelegateM::RobotBrainObjects::SupplementaryMotorArea | |
| IceDelegateM::Robots::Gumbot | |
| IceDelegateM::Robots::IRobot | |
| IceDelegateM::Robots::ScorbotIce | |
| IceDelegateM::RobotSimEvents::ActionMessage | |
| IceDelegateM::RobotSimEvents::AttendedRegionMessage | |
| IceDelegateM::RobotSimEvents::BeeStemConfigMessage | |
| IceDelegateM::RobotSimEvents::BeeStemMessage | |
| IceDelegateM::RobotSimEvents::BeeStemMotorControllerMessage | |
| IceDelegateM::RobotSimEvents::BeoHawkEyeSpyMessage | |
| IceDelegateM::RobotSimEvents::BuoyColorSegmentConfigMessage | |
| IceDelegateM::RobotSimEvents::BuoyColorSegmentMessage | |
| IceDelegateM::RobotSimEvents::CameraConfigMessage | |
| IceDelegateM::RobotSimEvents::CameraImageMessage | |
| IceDelegateM::RobotSimEvents::ChatMessage | |
| IceDelegateM::RobotSimEvents::ControlCameraMessage | |
| IceDelegateM::RobotSimEvents::ControlDriveVisionMessage | |
| IceDelegateM::RobotSimEvents::ControlLandMessage | |
| IceDelegateM::RobotSimEvents::ControlMoveMessage | |
| IceDelegateM::RobotSimEvents::EventMessage | |
| IceDelegateM::RobotSimEvents::Events | |
| IceDelegateM::RobotSimEvents::ExecuteMissionMessage | |
| IceDelegateM::RobotSimEvents::GoalProgressMessage | |
| IceDelegateM::RobotSimEvents::GoalStateMessage | |
| IceDelegateM::RobotSimEvents::GPSMessage | |
| IceDelegateM::RobotSimEvents::IMUDataServerMessage | |
| IceDelegateM::RobotSimEvents::JoyStickControlMessage | |
| IceDelegateM::RobotSimEvents::LandmarksMessage | |
| IceDelegateM::RobotSimEvents::LocalizationMessage | |
| IceDelegateM::RobotSimEvents::MotionMessage | |
| IceDelegateM::RobotSimEvents::MovementControllerMessage | |
| IceDelegateM::RobotSimEvents::ObjectMessage | |
| IceDelegateM::RobotSimEvents::PipeColorSegmentConfigMessage | |
| IceDelegateM::RobotSimEvents::PipeColorSegmentMessage | |
| IceDelegateM::RobotSimEvents::RemoteControlMessage | |
| IceDelegateM::RobotSimEvents::RetinaMessage | |
| IceDelegateM::RobotSimEvents::SalientPointMessage | |
| IceDelegateM::RobotSimEvents::SeaBeePositionMessage | |
| IceDelegateM::RobotSimEvents::SeaBeeStateConditionMessage | |
| IceDelegateM::RobotSimEvents::SensorDataMessage | |
| IceDelegateM::RobotSimEvents::SlamDataMessage | |
| IceDelegateM::RobotSimEvents::StateMessage | |
| IceDelegateM::RobotSimEvents::StraightEdgeMessage | |
| IceDelegateM::RobotSimEvents::VisionObjectMessage | |
| IceDelegateM::RobotSimEvents::VisionRectangleMessage | |
| IceDelegateM::ScorbotIce::Scorbot | |
| IceDelegateM::ScorbotSimpleIce::ScorbotSimple | |
| IceDelegateM::SeaBeeSimEvents::CameraConfigMessage | |
| IceDelegateM::SimEvents::CameraCtrlBiasMessage | |
| IceDelegateM::SimEvents::CameraCtrlMessage | |
| IceDelegateM::SimEvents::EventMessage | |
| IceDelegateM::SimEvents::Events | |
| IceDelegateM::SimEvents::GUIInputMessage | |
| IceDelegateM::SimEvents::GUIOutputMessage | |
| IceDelegateM::SimEvents::HippocampusBiasMessage | |
| IceDelegateM::SimEvents::HippocampusMessage | |
| IceDelegateM::SimEvents::InfrotemporalCortexBiasMessage | |
| IceDelegateM::SimEvents::InfrotemporalCortexMessage | |
| IceDelegateM::SimEvents::PrimaryMotorCortexBiasMessage | |
| IceDelegateM::SimEvents::PrimaryMotorCortexMessage | |
| IceDelegateM::SimEvents::PrimaryMotorCortexRelativeServoMessage | |
| IceDelegateM::SimEvents::PrimaryMotorCortexResetEncodersMessage | |
| IceDelegateM::SimEvents::RetinaMessage | |
| IceDelegateM::SimEvents::SaliencyMapBiasMessage | |
| IceDelegateM::SimEvents::SaliencyMapMessage | |
| IceDelegateM::SimEvents::SegmenterBiasMessage | |
| IceDelegateM::SimEvents::SegmenterMessage | |
| IceDelegateM::SimEvents::VisualCortexMessage | |
| IceDelegateM::SimEvents::VisualTrackerBiasMessage | |
| IceDelegateM::SimEvents::VisualTrackerMessage | |
| IceDelegateM::TestPub::Publisher1 | |
| IceDelegateM::TestPub::Publisher2 | |
| IceDelegateM::TestPub::Subscriber1 | |
| IceDelegateM::TestPub::Subscriber2 | |
| IceDelegateM::TestSIFT::SIFTMatcher | |
| IceImageCompressor | |
| IceImageDecompressor | |
| IceProxy::BeobotEvents::AbortMessage | |
| IceProxy::BeobotEvents::CameraMessage | |
| IceProxy::BeobotEvents::CancelSearchMessage | |
| IceProxy::BeobotEvents::CornerLocationMessage | |
| IceProxy::BeobotEvents::CornerMotorRequest | |
| IceProxy::BeobotEvents::CurrentLocationMessage | |
| IceProxy::BeobotEvents::FacesMessage | |
| IceProxy::BeobotEvents::GistSalMessage | |
| IceProxy::BeobotEvents::GPSMessage | |
| IceProxy::BeobotEvents::GUISpeechMessage | |
| IceProxy::BeobotEvents::IMUMessage | |
| IceProxy::BeobotEvents::LandmarkDBSearchResultMessage | |
| IceProxy::BeobotEvents::LandmarkMatchResultMessage | |
| IceProxy::BeobotEvents::LandmarkSearchQueueMessage | |
| IceProxy::BeobotEvents::LandmarkSearchStatMessage | |
| IceProxy::BeobotEvents::LandmarkTrackMessage | |
| IceProxy::BeobotEvents::LRFMessage | |
| IceProxy::BeobotEvents::MotorMessage | |
| IceProxy::BeobotEvents::MotorRequest | |
| IceProxy::BeobotEvents::NextFrameMessage | |
| IceProxy::BeobotEvents::SearchDoneMessage | |
| IceProxy::BeobotEvents::SLAMMessage | |
| IceProxy::BeobotEvents::SonarMessage | |
| IceProxy::BrainObjects::Hippocampus | |
| IceProxy::BrainObjects::HomeInterface | |
| IceProxy::BrainObjects::InferotemporalCortex | |
| IceProxy::BrainObjects::PrefrontalCortex | |
| IceProxy::BrainObjects::PrimaryMotorCortex | |
| IceProxy::BrainObjects::PTZ | |
| IceProxy::BrainObjects::Retina | |
| IceProxy::BrainObjects::SaliencyMap | |
| IceProxy::BrainObjects::Segmenter | |
| IceProxy::BrainObjects::SimulationViewer | |
| IceProxy::BrainObjects::VisualCortex | |
| IceProxy::BrainObjects::VisualTracker | |
| IceProxy::ChipInfoIceMod::ChipInfoServerFactoryIce | |
| IceProxy::ChipInfoIceMod::ChipInfoServerIce | |
| IceProxy::Demo::HelloWorld | |
| IceProxy::EventsNS::Event | |
| IceProxy::EventsNS::Events | |
| IceProxy::EventsNS::Message1 | |
| IceProxy::EventsNS::Message2 | |
| IceProxy::HawkMessages::CameraImageMessage | |
| IceProxy::HawkMessages::ControlCameraMessage | |
| IceProxy::HawkMessages::ControlDriveVisionMessage | |
| IceProxy::HawkMessages::ControlLandMessage | |
| IceProxy::HawkMessages::ControlMoveMessage | |
| IceProxy::HawkMessages::ControlRoomVisionMessage | |
| IceProxy::HawkMessages::ControlTakeOffMessage | |
| IceProxy::HawkMessages::DriveFinderMessage | |
| IceProxy::HawkMessages::ExampleMessage | |
| IceProxy::HawkMessages::ExecuteMissionMessage | |
| IceProxy::HawkMessages::Message | |
| IceProxy::HawkMessages::MessageAgent | |
| IceProxy::HawkMessages::MissionListMessage | |
| IceProxy::HawkMessages::RoomFinderMessage | |
| IceProxy::HawkMessages::SensorDataMessage | |
| IceProxy::HawkMessages::SlamDataMessage | |
| IceProxy::IceStorm::Topic | |
| IceProxy::IceStorm::TopicManager | |
| IceProxy::ImageIceMod::ImageShuttle | |
| IceProxy::RobotBrainObjects::Hippocampus | |
| IceProxy::RobotBrainObjects::InferotemporalCortex | |
| IceProxy::RobotBrainObjects::LateralGeniculateNucleus | |
| IceProxy::RobotBrainObjects::Observer | |
| IceProxy::RobotBrainObjects::PrefrontalCortex | |
| IceProxy::RobotBrainObjects::PrimaryMotorCortex | |
| IceProxy::RobotBrainObjects::PrimarySomatosensoryCortex | |
| IceProxy::RobotBrainObjects::Retina | |
| IceProxy::RobotBrainObjects::SaliencyModule | |
| IceProxy::RobotBrainObjects::SupplementaryMotorArea | |
| IceProxy::Robots::Gumbot | |
| IceProxy::Robots::IRobot | |
| IceProxy::Robots::ScorbotIce | |
| IceProxy::RobotSimEvents::ActionMessage | |
| IceProxy::RobotSimEvents::AttendedRegionMessage | |
| IceProxy::RobotSimEvents::BeeStemConfigMessage | |
| IceProxy::RobotSimEvents::BeeStemMessage | |
| IceProxy::RobotSimEvents::BeeStemMotorControllerMessage | |
| IceProxy::RobotSimEvents::BeoHawkEyeSpyMessage | |
| IceProxy::RobotSimEvents::BuoyColorSegmentConfigMessage | |
| IceProxy::RobotSimEvents::BuoyColorSegmentMessage | |
| IceProxy::RobotSimEvents::CameraConfigMessage | |
| IceProxy::RobotSimEvents::CameraImageMessage | |
| IceProxy::RobotSimEvents::ChatMessage | |
| IceProxy::RobotSimEvents::ControlCameraMessage | |
| IceProxy::RobotSimEvents::ControlDriveVisionMessage | |
| IceProxy::RobotSimEvents::ControlLandMessage | |
| IceProxy::RobotSimEvents::ControlMoveMessage | |
| IceProxy::RobotSimEvents::EventMessage | |
| IceProxy::RobotSimEvents::Events | |
| IceProxy::RobotSimEvents::ExecuteMissionMessage | |
| IceProxy::RobotSimEvents::GoalProgressMessage | |
| IceProxy::RobotSimEvents::GoalStateMessage | |
| IceProxy::RobotSimEvents::GPSMessage | |
| IceProxy::RobotSimEvents::IMUDataServerMessage | |
| IceProxy::RobotSimEvents::JoyStickControlMessage | |
| IceProxy::RobotSimEvents::LandmarksMessage | |
| IceProxy::RobotSimEvents::LocalizationMessage | |
| IceProxy::RobotSimEvents::MotionMessage | |
| IceProxy::RobotSimEvents::MovementControllerMessage | |
| IceProxy::RobotSimEvents::ObjectMessage | |
| IceProxy::RobotSimEvents::PipeColorSegmentConfigMessage | |
| IceProxy::RobotSimEvents::PipeColorSegmentMessage | |
| IceProxy::RobotSimEvents::RemoteControlMessage | |
| IceProxy::RobotSimEvents::RetinaMessage | |
| IceProxy::RobotSimEvents::SalientPointMessage | |
| IceProxy::RobotSimEvents::SeaBeePositionMessage | |
| IceProxy::RobotSimEvents::SeaBeeStateConditionMessage | |
| IceProxy::RobotSimEvents::SensorDataMessage | |
| IceProxy::RobotSimEvents::SlamDataMessage | |
| IceProxy::RobotSimEvents::StateMessage | |
| IceProxy::RobotSimEvents::StraightEdgeMessage | |
| IceProxy::RobotSimEvents::VisionObjectMessage | |
| IceProxy::RobotSimEvents::VisionRectangleMessage | |
| IceProxy::ScorbotIce::Scorbot | |
| IceProxy::ScorbotSimpleIce::ScorbotSimple | |
| IceProxy::SeaBeeSimEvents::CameraConfigMessage | |
| IceProxy::SimEvents::CameraCtrlBiasMessage | |
| IceProxy::SimEvents::CameraCtrlMessage | |
| IceProxy::SimEvents::EventMessage | |
| IceProxy::SimEvents::Events | |
| IceProxy::SimEvents::GUIInputMessage | |
| IceProxy::SimEvents::GUIOutputMessage | |
| IceProxy::SimEvents::HippocampusBiasMessage | |
| IceProxy::SimEvents::HippocampusMessage | |
| IceProxy::SimEvents::InfrotemporalCortexBiasMessage | |
| IceProxy::SimEvents::InfrotemporalCortexMessage | |
| IceProxy::SimEvents::PrimaryMotorCortexBiasMessage | |
| IceProxy::SimEvents::PrimaryMotorCortexMessage | |
| IceProxy::SimEvents::PrimaryMotorCortexRelativeServoMessage | |
| IceProxy::SimEvents::PrimaryMotorCortexResetEncodersMessage | |
| IceProxy::SimEvents::RetinaMessage | |
| IceProxy::SimEvents::SaliencyMapBiasMessage | |
| IceProxy::SimEvents::SaliencyMapMessage | |
| IceProxy::SimEvents::SegmenterBiasMessage | |
| IceProxy::SimEvents::SegmenterMessage | |
| IceProxy::SimEvents::VisualCortexMessage | |
| IceProxy::SimEvents::VisualTrackerBiasMessage | |
| IceProxy::SimEvents::VisualTrackerMessage | |
| IceProxy::TestPub::Publisher1 | |
| IceProxy::TestPub::Publisher2 | |
| IceProxy::TestPub::Subscriber1 | |
| IceProxy::TestPub::Subscriber2 | |
| IceProxy::TestSIFT::SIFTMatcher | |
| IceStorm::AlreadySubscribed | |
| IceStorm::BadQoS | |
| IceStorm::LinkExists | |
| IceStorm::LinkInfo | |
| IceStorm::NoSuchLink | |
| IceStorm::NoSuchTopic | |
| IceStorm::Topic | |
| IceStorm::TopicExists | |
| IceStorm::TopicManager | |
| iconImage | |
| IEEE1394grabber | Definition and access functions for FireWire digital camera frame capture |
| IIC_NS::buff_dest_mgr | |
| IIDC_NS::buff_src_mgr | |
| Image< T > | Generic image template class |
| ImageCache< T > | Base class for image caches that do computations on the fly |
| ImageCacheAvg< T > | Image cache to compute the running average |
| ImageCacheMinMax< T > | Image cache to compute a running min/max |
| ImageCanvas | |
| imageData | |
| imageDB | For loading simulation images |
| ImageDisplayLayout | Create image display layout using Qt |
| ImageDisplayStream | A FrameOstream class that sends images to (multiple) on-screen window(s) |
| ImageDisplayStream::WindowMap | |
| ImageGraphicsItem | |
| ImageIceMod::DimsIce | |
| ImageIceMod::ImageIce | |
| ImageIceMod::ImageShuttle | |
| ImageIceMod::LineIce | |
| ImageIceMod::Point2DIce | |
| ImageIceMod::Point3DIce | |
| ImageIceMod::QuadrilateralIce | |
| ImageIceMod::RectangleIce | |
| ImageIceMod::SensorPose | |
| ImageIceMod::SensorVote | |
| ImageIceMod::WaypointIce | |
| ImageInfo | Monitor an image over time, to detect interesting events |
| ImageInfo::ImageStats | Various statistical measures of interestingness returned by this object |
| ImageMap | 3D image map created from the image at diff' orientations |
| ImageObj< T > | |
| ImageQtMainForm | |
| ImageSet< T > | This class implements a set of images, often used as a dyadic pyramid |
| ImageShuttleI | |
| ImageSpring< T > | This class is some sort of self organizing map used for clustering |
| ImageSync | |
| ImageTk< T > | |
| ImageTk< T >::Instance | |
| ImageTk< T >::Master | |
| ImageView | |
| ImagizeAlphaChannel | Alpha-component of Imagize color channel |
| ImagizeBetaChannel | Beta-component of Imagize color channel |
| ImagizeColorChannel | A complex color channel for the 3-channel Imagize silicon retina |
| ImagizeLedChannel | A L-component of DKL color channel |
| IMU_MicroStrain_3DM_GX2 | |
| IMU_SFE_Atomic | |
| IMU_SFE_Atomic::IMUData | |
| IMUDataServer | |
| IMUDataServer::Mode | |
| IMUListener | |
| in | |
| InferoTemporal | Abstract inferotemporal interface |
| InferoTemporalConfigurator | InferoTemporal configurator |
| InferotemporalCortexI | |
| InferotemporalCortexI::CameraParam | |
| InferotemporalCortexI::TopicInfo | |
| InferotemporalCortexService | |
| InferoTemporalCudaHmax | Inferotemporal interface using HMAX with feature learning |
| InferoTemporalHmax | Inferotemporal interface using HMAX with feature learning |
| InferoTemporalSalBayes | InferoTemporalSalBayes |
| InferoTemporalSIFT | Inferotemporal interface using SIFT with feature learning |
| InferoTemporalStd | InferoTemporalStd |
| InferoTemporalStub | Do-nothing stub implementation of InferoTemporal |
| InfoOutputSeries | Very simple output source that just prints basic info about the frames it receives |
| InfoOutputSeries::Impl | |
| InfoOutputSeries::Impl::ChanInfo | |
| InformationChannel | An information channel |
| InputFrame | |
| InputFrameSeries | A FrameSeries with additional facilities for reading input frames |
| InputFrameSeries::Impl | |
| InputHandler | Auxiliary class that can override parts of SingleChannel's functionality |
| InputHandlerThreaded | InputHandler subclass than can be plugged into SingleChannel to get multi-threaded computations |
| InputHandlerThreaded::Job | Represents a pending SingleChannel input job |
| InputMbariFrameSeries | InputMbariFrameSeries manages a series of input frames |
| InputMPEGStream | InputMPEGStream is a wrapper class to read video frames from mpeg-1 |
| InstanceCounter | |
| integer_math | |
| IntegerChannel | Base class for channels that will use integer math |
| IntegerColorChannel | A double opponent color channel class that combines r/g, b/y subchannels |
| IntegerComplexChannel | Like ComplexChannel, but avoids floating-point arithmetic |
| IntegerComplexChannel::Impl | |
| IntegerComplexChannel::SubchanKey | Refer to a subchannel by one of: its index, its tagname, its address |
| IntegerDirectionChannel | Motion sensitive channel with direction selectivity |
| IntegerFlickerChannel | A temporal flicker channel |
| IntegerInput | |
| IntegerIntensityChannel | An intensity channel |
| IntegerMathEngine | |
| IntegerMotionChannel | A composite channel containing a set of direction channels |
| IntegerOrientationChannel | A composite channel containing a set of orientation-tuned gabor channels |
| IntegerRawVisualCortex | The Visual Cortex Class |
| IntegerSimpleChannel | IntegerSimpleChannel is like SingleChannel, but avoids floating-point arithmetic |
| IntensityBandChannel | A composite channel containing a set of intensity-band channels |
| IntensityChannel | An intensity channel |
| IntgGaussianPyrBuilder | Builds pyramids based on Gaussian filters |
| IntgOrientedPyrBuilder | Builds pyramid based on oriented Laplacian filters |
| IntgReichardtPyrBuilder | This class implements Reichardt motion detections |
| IntgTrigTable< tabsiz_, nbits_ > | |
| IntString | |
| iotaGen | |
| iPlayer | |
| IRobotI | |
| IRobotSim | |
| IRobotSim::Object | |
| IRobotSimService | |
| IT | |
| IT::GHTAcc | |
| IT::Object | |
| IT::ObjectState | |
| IT::RTableEntry | |
| IZCompLayer | |
| IZNeuron | |
| IZNeuronFunc | |
| Janitor< T > | Simple utility class for running a cleanup function during stack unwinding |
| Jet< T > | This class specifies a Jet, i.e., array of feature values for one location |
| JetFiller | Fill the components of the given Jet that relate to the called channel |
| JetSpec | This class specifies the features, scales and indices represented in a Jet |
| JetSpecFiller | Fill the specification of a Jet with data that relate to the called channel |
| jobData | |
| JobServer | Abstract interface for running generic computation jobs |
| JobServer::Job | Base class for jobs that can be submitted to a JobServer |
| JobServerConfigurator | |
| JobWithSemaphore | Convenience subclass of JobServer::Job that includes a semaphore to communicate job completion |
| JoyStick | Driver for a Linux joystick |
| JoyStickListener | Simple listener for JoyStick events |
| jpeg_decdata | |
| JPEGCompressor | |
| JPEGDecompressor | |
| JpegParser | Parser class for reading jpeg image files by using libjpeg |
| JpegParser::Impl | |
| jpginfo | |
| JunctionChannel | A junction channel |
| JunctionHOG | |
| kalman_filter | |
| KalmanFilter | Implementation of a 2nd order linear Kalman Filter |
| KalmanFilterData | |
| KcolorChannel | A K-component of DKL color channel |
| KDTree | A simple KD tree implementation |
| Kernel | |
| KeyBoard | Simple interface to a keyboard |
| KeyPoint | |
| Keypoint | The keypoint base class |
| KeypointMatch | A simple struct to store Keypoint matches |
| KeypointTracker | Landmark class to take into account temporal info |
| KLScorer | |
| KnowledgeBase | This class holds a knowledge base |
| ks0108iLab | |
| Landmark | Visual object-base Landmark class |
| LandmarkDB | LandmarkDB class |
| LandmarkDBMatch | |
| LandmarkDBWorkerI | |
| LaplacianPyrBuilder< T > | Builds pyramids based on Laplacian filters |
| LateralGeniculateNucleusI | |
| Layer< T, W > | |
| LayerDecoder | Clas for a layer decoder |
| Layout< T > | Represents tiled layouts of arbitrary numbers of images of different sizes |
| lcd | Lcd.H Interface to an LCD screen via serial port |
| lcdCoord | |
| LcolorChannel | A L-component of DKL color channel |
| LeakDetector | |
| LeakDetectorListener | |
| LeakyIntegrator | A leaky integrator neuron, used by standard saliency map (SM) |
| LeakyIntFire | A leaky integrate & fire neuron, used by standard winner-take-all (WTA) |
| LeakyIntFireAdp | A leaky integrate & fire neuron, used by standard winner-take-all (WTA) |
| LeastSquaresLearner | Learn feature/position pairings with a linear least-squares best fit |
| LEDcontroller | |
| lessClassInfo | |
| lessKP | |
| LevelSpec | A utility class for use with SingleChannel |
| lfatal_exception | Type of exception that is thrown from LFATAL if (LOG_FLAGS&LFATAL_THROWS) |
| LFLineFitter | |
| LFLineSegment | |
| LGN | |
| Line | |
| LineFitting | |
| LineGrouping | |
| LineGrouping::LineInfo | |
| LineGrouping::LineInfoCmp | |
| LineGrouping::LinesGroup | |
| LineMatching | |
| LineMatching::Shape2D | |
| LineSegment2D | A segment of a straight line in the 2D plane |
| LJunctionChannel | An L junction channel that detects L junctions at different |
| LMDirectionalIntegralDistanceImage | |
| LMDistanceImage | |
| LMLineMatcher | |
| LMLineMatcher::Rect | |
| lobot::abs_diff | |
| lobot::accumulator< T > | |
| lobot::add_uniform_distribution | |
| lobot::App | An application object that ties together various I/O and other modules and runs the main thread |
| lobot::Arbiter | An ABC defining the common interface for lobot's motor control arbiters |
| lobot::Arbiter::vote_data | |
| lobot::Arbiter::VoteBase | |
| lobot::arbiter_error | |
| lobot::AutoMutex | Mutexes created on the stack that acquire an "underlying" mutex on initialization and release it when the object goes out of scope |
| lobot::AutoReadLock | Read locks created on the stack that acquire an "underlying" read/write lock for reading on initialization and release it when the object goes out of scope |
| lobot::AutoWriteLock | Write locks created on the stack that acquire an "underlying" read/write lock for writing on initialization and release it when the object goes out of scope |
| lobot::BaylogAnalyzer | A class for loading and parsing the metrics logs for a Bayesian TTI prediction dataset in a separate thread |
| lobot::Behavior | An ABC defining the common interface for all of lobot's behaviours |
| lobot::behavior_error | |
| lobot::BumpCounter | A behaviour for "counting" bump events |
| lobot::bus_error | |
| lobot::CalibrateLET | A do-nothing behaviour for calibrating lgmd_extricate_tti |
| lobot::camera_error | |
| lobot::Clipper | A line clipper |
| lobot::Compositor< pixel_type > | Quick-and-dirty "panaromic" image stitcher |
| lobot::Condition | A simple encapsulation of pthread condition variables |
| lobot::ConfigDB | Robolocust/lobot configuration database |
| lobot::Configuration | A more user-friendly API for the ConfigDB |
| lobot::CorrFinder | A class for finding point correspondences between a lobot::Experiment and a refernce Experiment in a separate thread |
| lobot::Countdown | A "stop watch" behaviour that either pauses the robot or quits the controller application once the counter hits zero |
| lobot::customization_error | |
| lobot::DangerZone | An object for monitoring the robot's danger zone |
| lobot::DangerZone::Block | |
| lobot::Dataset | A thread-safe container for storing parsed metlogs and performing various operations on them |
| lobot::Dataset::eol | |
| lobot::DirList | An object to help keep track of which dataset should be analyzed next |
| lobot::DirList::eol | |
| lobot::draw_contours | |
| lobot::draw_grid_lines | |
| lobot::Drawable | A base class for Robolocust drawable objects |
| lobot::Drawable::Geometry | |
| lobot::dump_pair< T1, T2 > | Function object to dump an std::pair to the given output stream |
| lobot::EatMap | |
| lobot::EMD< input_type > | A generic Elementary Motion Detector |
| lobot::EMD< input_type * > | |
| lobot::EMD< void * > | |
| lobot::EmergencyStop | A behaviour for stopping the robot dead in its tracks when it senses things getting too close for comfort |
| lobot::Experiment | A class for storing all the relevant info from trajectory-related metrics logs |
| lobot::Extricate | A behaviour for unsticking the robot after the emergency stop behaviour stops it dead in its tracks because things have gotten too close for comfort |
| lobot::FastSLAM | An implementation of the grid-based FastSLAM algorithm |
| lobot::FireWireBus | Encapsulation of libdc1394 initialization, handles, etc |
| lobot::Forward | A behaviour for driving the robot forward |
| lobot::GabbianiModel | Implementation of Gabbiani's LGMD model |
| lobot::gaussian_weight< T > | A function object to perform Gaussian weighting |
| lobot::generic_stats< T > | A structure to hold several descriptive statistics together |
| lobot::GLCanvas | An encapsulation of window-viewport primitives for 2D graphics with OpenGL |
| lobot::GLColor | |
| lobot::Goal | A behaviour for driving the robot toward a list of goals |
| lobot::Grabber | |
| lobot::ImageSource< pixel_type > | Just a source of Images |
| lobot::InputSource | Input sources wrapper for Lobot/Robolocust project |
| lobot::io_error | |
| lobot::LaserRangeFinder | Encapsulation of liburg API for interfacing with Hokuyo laser range finders |
| lobot::LaserViz | A drawable for visualizing laser range finder data |
| lobot::LaserVizFlat | A drawable for visualizing laser range finder data |
| lobot::LaserWindow | The main window for the laser range finder's test program |
| lobot::LaserWindowGrid | A helper class for drawing the laser range finder's measurements grid |
| lobot::LaserWindowMarkings | A helper class for drawing markers indicating distances |
| lobot::LaserWindowMarkings::Params | |
| lobot::LaserWindowRings | A helper class for drawing the laser range finder's measurements rings |
| lobot::LGMDExtricateEMD | A behaviour for moving the robot away from obstacles by running the raw LGMD inputs via an EMD array |
| lobot::LGMDExtricateSimple | A behaviour for moving the robot away from obstacles by stopping and spinning it in the direction of least LGMD spiking |
| lobot::LGMDExtricateTTI | A behaviour for moving the robot away from obstacles by applying a virtual force field comprised of repulsive and attractive forces based on time-to-impact estimates derived from LGMD inputs |
| lobot::LGMDExtricateVFF | A behaviour for moving the robot away from obstacles by applying a virtual force field comprised of repulsive and attractive forces based on the raw LGMD inputs |
| lobot::LoApp | |
| lobot::LocustModel | Abstract base class for locust models of different types |
| lobot::LocustModel::InitParams | |
| lobot::LocustViz | A drawable for visualizing the LGMD spike rates |
| lobot::lrf_error | |
| lobot::LRFData | Convenient API to locally copy and use LRF measurements so as to minimize update lock usage by different behaviours |
| lobot::LRFData::Reading | |
| lobot::MainWindow | The Lobot/Robolocust main window |
| lobot::Map | An application-wide obstacle map |
| lobot::map_value_comp< M, C > | |
| lobot::map_value_comp_less< M > | |
| lobot::max< T > | |
| lobot::messages | |
| lobot::MetlogList | An object to help keep track of which metrics log should be loaded next |
| lobot::MetlogList::eol | |
| lobot::MetlogLoader | A class for loading and parsing Robolocust metrics logs in a separate thread |
| lobot::Metrics | A behaviour for gathering performance metrics about the robot |
| lobot::Metrics::endl | |
| lobot::Metrics::Log | A class for creating metrics related log messages and buffering them with the metrics behaviour for subsequent output to the log file |
| lobot::Metrics::newl | |
| lobot::min< T > | |
| lobot::misc_error | |
| lobot::missing_libs | |
| lobot::ModelManagerStarter | |
| lobot::MonitorDZone | A behaviour for monitoring the robot's danger zone and taking one of several possible actions depending on the user's config settings |
| lobot::motor_error | |
| lobot::Mutex | A simple encapsulation of pthread mutexes |
| lobot::OccGrid | A log-odds occupancy grid |
| lobot::Odometry | A simple API for various odometry-related operations |
| lobot::OpenPath | A behaviour for steering the robot toward the most open path that can accommodate it |
| lobot::out_of_range< T > | |
| lobot::Params | |
| lobot::Particle | Encapsulation of particle used in FastSLAM algorithm |
| lobot::Particle::Viz | |
| lobot::Pause | A Boolean flag to indicate whether threads should work as usual or wait until the application is unpaused |
| lobot::PID< T > | Simple implementation of a PID controller |
| lobot::PointList | A container for storing lists of points |
| lobot::PointMatrix | A thread-safe container for storing "normalized" point lists |
| lobot::Pose | A simple structure for representing a robot's pose |
| lobot::RCCar | High-level API for driving and steering the R/C car based robot and retrieving the value of its RPM sensor |
| lobot::RemoteControl | A behaviour for controlling the iRobot Roomba/Create using its remote |
| lobot::RenderBuffer | An encapsulation of an OpenGL framebuffer object |
| lobot::RenderResults | An offline behaviour for rendering the robot's trajectory from start to finish and the locations where its emergency stop and extrication behaviours were active |
| lobot::Robot | High-level API for driving and steering the robot and keeping track of its sensors |
| lobot::Robot::Sensors | |
| lobot::RoombaCM | High-level API for driving and steering the Roomba and retrieving its sensor data |
| lobot::RoombaCM::Comm::Cmd | |
| lobot::RoombaCM::Comm::Sensors | |
| lobot::RWLock | A simple encapsulation of pthread read/write locks |
| lobot::scale_vote | |
| lobot::Scan | An encapsulation of a laser range finder scan |
| lobot::Scan::RangeReading | |
| lobot::SensorModel | Data structure encapsulating sensor model required for Bayesian time-to-impact state estimation |
| lobot::Serial | Serial communications API |
| lobot::Shutdown | A thread that waits for a shutdown signal and allows other modules/threads to query whether shutdown is in progress or not |
| lobot::SlamParams | A helper class for holding the various SLAM related parameters |
| lobot::SpeedArbiter | A DAMN speed arbiter for controlling Robolocust's speed |
| lobot::SpeedArbiter::Vote | |
| lobot::SpinArbiter | A DAMN spin arbiter for steering Robolocust using in-place turns |
| lobot::SpinArbiter::Vote | |
| lobot::StaffordModel | Implementation of Stafford's LGMD model |
| lobot::sum_of_squares< T > | |
| lobot::Survey | A behaviour for updating the Robolocust occupancy grid |
| lobot::TestScanMatching | A behaviour for testing the laser range finder scan matching algorithm |
| lobot::Thread | An ABC for POSIX threads |
| lobot::thread_error | |
| lobot::Track | A behaviour for maintaining pose history and dumping it to a file every now and then |
| lobot::Transformation | An encapsulation of a transformation for "converting" one scan to another |
| lobot::trigger_hook | |
| lobot::TTIEstimator | Encapsulation of Bayesian time-to-impact estimation using LGMD spike rates |
| lobot::TTIMap | A mapping between actual times-to-impact recorded in logs generated during the Bayesiant TTI prediction experiments and the corresponding LGMD spike rates, predicted times-to-impact and prediction confidence levels |
| lobot::TurnArbiter | A DAMN turn arbiter for controlling Robolocust's steering |
| lobot::TurnArbiter::Vote | |
| lobot::TurnArbiter::Vote::iterator | |
| lobot::uhoh | |
| lobot::unknown_model | |
| lobot::UpdateLock | An object to help coordinate read-write accesses to various shared objects within the Robolocust controller |
| lobot::VFH | A behaviour for driving and steering the robot based on a repulsive vector field |
| lobot::VideoRecorder | Video stream recorder for Lobot/Robolocust project |
| lobot::VideoStream | Video stream wrapper for Lobot/Robolocust project |
| lobot::vstream_error | |
| LocalBinaryPatterns | Multiclass LocalBinaryPatterns Class |
| LocalEdge | |
| Localization | Functions for tracking the position of the sub using particle filter technic |
| LocalizationMap | |
| LocalizationMapEntity | |
| LocalizationMapEntity::FillType | |
| LocalizationMapEntity::InteractionType | |
| LocalizationMapEntity::ObjectType | |
| LocalizationMapEntity::ShapeType | |
| LocalizationParticle | |
| LocalizationParticle::State | |
| LocalizationSensorReader | |
| LocalizationSensorReader::Flags | |
| LocalizationSensorReader::SensorType | |
| LocalizationUtil | |
| LocalizationWaypointController | |
| LocalizationWaypointController::LoopState | |
| LocalizationWaypointController::MovementState | |
| LocalizationWaypointController::State | |
| LocalizationWaypointController::Waypoint | |
| Localizer | |
| LocalParts | |
| LocalParts::PartState | |
| Location | |
| locData | |
| LoggerModule | |
| LogLikelihoodClassifier | |
| LogPolarTransform | |
| LoweSIFT | |
| LowLevelEncoder | Base class for low-level encoder objects that can be used with LowLevelEncoderMap |
| LowLevelEncoderMap | A partial implementation of FrameOstream, using a map between 'shortnames' and LowLevelEncoder objects |
| LowLevelEncoderMap::Impl | |
| LowpassCompLayer | |
| LowPassExpEuler | |
| LowPassFilter< RateFunc, IntType > | |
| LowPassFwdEuler | |
| LowpassNeuronImpl< RateFunc, IntType > | |
| LowpassSC | |
| LPTFoveator | A class that does space-variant processing with log polar transform |
| LRF_Occupancy | |
| lrfData | |
| LuminanceOfilt | Output filter that converts rgb images to their grayscale luminance |
| MainDisplay | |
| MainWindow | |
| Map | |
| mapedge | |
| MapperI | |
| MapperI::MapObject | |
| MappingData | |
| MaskBiaser | |
| MatchJob | |
| Matlab::Engine | |
| Matlab::File | |
| Matlab::Matrix | |
| Matrix< T > | |
| MbariResultViewer | Class to facilitate displaying and saving of intermediate results |
| md5_context | |
| MeanEyeposLearner | Control learner that just learns the mean eye position |
| MeterInfo | Simple struct to define a bargraph meter |
| MexBuf | This streambuf is used to re-direct std::cout and std::cerr |
| MexBufInit | This class triggers the redirection of the standard streams at construction |
| MexModelManager | A special form of ModelManager used in mex files |
| MexReturn | Class to help manage return values in mex files |
| MgzDecoder | Low-level decoder for multi-frame "mgz" file format |
| MgzEncoder | Low-level class to write mgz files |
| MgzInputStream | MgzInputStream is a wrapper class to read frames from .mgz files |
| MgzJDecoder | Low-level decoder for multi-frame "mgzJ" file format |
| MgzJEncoder | |
| MgzJEncoder::journalEntry | |
| MgzJInputStream | MgzJInputStream is a wrapper class to read frames from .mgzj files |
| MgzJOutputStream | |
| MgzOutputStream | MgzOutputStream writes multiframe gzipped (.mgz) files |
| MichelsonChannel | A Michelson contrast channel, computes Michelson contrast in an image patch |
| MiddleTemporal | |
| MissileLauncher | |
| MissileLauncher::TopicInfo | |
| MissileLauncherService | |
| Mission | |
| ModelComponent | Base class for parameterized model components |
| ModelComponent::Impl | Private "pimpl" implementation class for ModelComponent |
| ModelComponentSaveInfo | Provide some information about howto save() things |
| ModelManager | Manages a collection of ModelComponent objects forming a model |
| ModelManager::Impl | This is the internal implementation struct for ModelManager |
| ModelManagerControl | |
| ModelManagerDialog | |
| ModelManagerWizard | |
| ModelManagerWizardItem | |
| ModelOptionCateg | Holds information about a group of command-line options; used for printing --help message |
| ModelOptionDef | Specification of a known model option |
| ModelOptionType | ModelOptionType -- represents a ModelOptionKind plus type info |
| ModelParamAuxImpl | Helper implementation class for NModelParam and OModelParam |
| ModelParamBase | ModelParamBase is a persistent ModelComponent parameter base class |
| ModelParamBatch | A helper class for batch setting and restoring groups of parameter values |
| ModelRun | |
| MonkeyEyeHeadController | Realistic rhesus monkey eye/head controller |
| MonkeySaccadeController | Realistic Monkey Eye or Head controller |
| moreVOM | |
| MotionChannel | A composite channel containing a set of direction channels |
| MotionEnergyPyrBuilder< T > | This class implements Spatiotemporal Energy motion detections |
| MotionOpticalFlowChannel | |
| MotionSpatioTemporalChannel | A composite channel containing a set of direction spatio temporal channels |
| Motor | |
| motorCommand | |
| motorData | |
| MovementAgent | |
| MovementController | |
| MovementControllerI | |
| MovementControllerI::SensorPose | |
| MovementControllerI::SensorVote | |
| MovieDecoder | Abstract base class for low-level movie decoders |
| MovingAvgLearner | Transform another learner with a moving average |
| MPlayerWrapper | Base class for simple input-output streaming applications |
| MrawvDecoder | Low-level decoder for multi-frame raw video formats |
| MrawvDecoder::Rep | |
| MrawvEncoder | Low-level encoder for multi-frame raw video formats |
| MrawvInputStream | MrawvInputStream is a wrapper class to read frames from raw video files |
| MrawvOutputStream | MrawvOutputStream writes multiple multi-frame rawvideo files |
| MSTChannel | A MST channel |
| mt_struct_stripped | |
| MulticastScorer | |
| MultiColorBandChannel | A composite channel containing a set of color-band channels |
| MultiConvolveChannel | A generic multi-convolution channel |
| MultiDirectFeedChannel | Multi Direct Feed Channel |
| MultiSpectralResidualChannel | A complex channel holding several spectral residual sub-channels |
| MyBeeSTEMListener | Our own little BeeSTEMListener |
| MyBeoChipListener | Our own little BeoChipListener |
| Myrgb16 | |
| Myrgb24 | |
| Myrgb32 | |
| MyYUV422 | |
| MyYUV444 | |
| NamedImage< T > | NamedImage is an Image with a name. It inherits all functionality of Image |
| NavBot | |
| NCursesUI | |
| ND_Navigation | |
| NeoBrain | |
| NeoBrain::Stats | |
| neovision2cuda | |
| NeuralColumn< T > | A container for a column of SimUnits. The user can specify |
| NeuralDecoder | |
| NeuralDecoderDerived< Derived > | |
| NeuralFieldCS | |
| NeuralFieldDoG | |
| NeuralFieldGauss | |
| NeuralFieldModule | An interface to neural field models |
| NeuralFieldSC | |
| NeuralSimModule< T > | A SimModule interface to various models created with the ModelNeuron |
| NewDBEntryDialog | |
| NFAInfo | |
| NModelParam< T > | A class for params of type T that don't have command-line options |
| Node | |
| NormalDataCluster | |
| NPclassify | |
| NPclassify2< FLOAT > | Non parametric classifier version 2.0 |
| NssScorer | |
| nub::detail::default_unref_policy< T > | Policy class which unrefs objects by decrementing their ref count |
| nub::detail::handle< T, unref_policy > | A shared implementation class for nub::floating_ref and nub::ref |
| nub::detail::no_delete_unref_policy< T > | Policy class which decrements ref count without deletion |
| nub::detail::weak_handle< T > | Internal helper class for soft_ref |
| nub::floating_ref< T > | |
| nub::invalid_uid_error | |
| nub::obj_factory | Singleton wrapper for a nub::object factory |
| nub::object | |
| nub::objectdb | |
| nub::objectdb::casting_iterator< T > | A filtering iterator class; only exposes objects matching a given type |
| nub::objectdb::impl | |
| nub::ref< T > | |
| nub::ref_counted | |
| nub::ref_counts | |
| nub::soft_ref< T > | |
| NullOutputStream | NullOutputStream writes nothing, it is a fake output stream |
| NumEntries | |
| nv2_image_patch | Represents an image patch, with image data stored in row-major fashion |
| nv2_label_reader | |
| nv2_label_server | |
| nv2_patch_label | Represents a label for an image patch |
| Nv2LabelReader | |
| Nv2LabelReader::LabeledImage | |
| Nv2UiData | |
| Nv2UiJob | |
| Obj3DBox | |
| Obj3DCircle | |
| Obj3DComponent | |
| Obj3DComposite | |
| Obj3DCylinder | |
| Obj3DRectangle | |
| Obj3DSphere | |
| ObjDetBrain | |
| ObjDetChannel | A template-matching channel for detecting pedestrians |
| Object | |
| ObjectAnimation | |
| ObjectAnimation::FrameState | A structure to hold all necessary information about frame |
| ObjectData | |
| ObjectDBData | |
| ObjectFinder | |
| ObjectFinderService | |
| ObjectRecData | |
| Objects | |
| Objects::ObjectState | |
| Objects::Table | |
| ObjInfo | |
| ObjRec | |
| ObjRecBOF | |
| ObjRecBOF::Keypoint | |
| ObjRecBOF::Object | |
| ObjRecBrain | |
| ObjRecHMax | |
| ObjRecSalBayes | |
| ObjRecSPM | |
| ObjRecSPM::Descriptor | |
| ObjRecSPM::Object | |
| ObjRecSPM::SiftKeypoint | |
| ObjState | |
| ObjTrajectory | |
| OceanObject | |
| OctagonShape | An Octagon ShapeModel |
| Omni< T > | Omni directional correction tool |
| OModelParam< T > | A class for params of type T that have a command-line option |
| ONE_CLASS_Q | |
| OpenDBEntryDialog | |
| ops::bitwise_and | |
| ops::bitwise_or | |
| ops::bitwise_xor | |
| ops::divides | |
| ops::minus | |
| ops::modulo | |
| ops::multiplies | |
| ops::plus | |
| OpticalFlow | |
| OptimalGainsFinder | Compute the optimal gains that maximize SNR |
| OptionedModelParam | OptionedModelParam extends ModelParamBase for params associated with a ModelOptionDef |
| OptionManager | Abstract interface for the option-managing part of ModelManager |
| OriChamferMatching | |
| OrientationChannel | A composite channel containing a set of orientation-tuned gabor channels |
| OrientedPyrBuilder< T > | Builds pyramid based on oriented Laplacian filters |
| OriIntegralImage | |
| OutputFrameSeries | A FrameSeries with additional facilities for writing output frames |
| OutputFrameSeries::Impl | |
| OutputHttpStream | OutputHttpStream writes mpeg video frames using the avcodec library through http |
| OutputMbariFrameSeries | OutputMbariFrameSeries manages a series of output frames |
| OutputMPEGStream | OutputMPEGStream writes mpeg video frames using the avcodec library |
| ParallelShape | A Parallel-lines ShapeModel |
| ParamClient | An abstract interface class for clients of model params |
| ParamData | |
| ParamMap | Allows reading and writing of parameters to and from files or streams |
| ParamMap::Impl | |
| ParamMap::key_iterator | |
| ParamMap::key_iterator::IterRep | |
| ParPort | This is a minimalistic interface to a PC parallel port under Linux |
| ParticleFilter | |
| ParticleFilter::GraphicsFlags | |
| ParticleFilter::GraphicsFlags::SnapState | |
| ParticleFilter::InitializationState | |
| ParticleFilter::Particle | |
| ParticleFilter::SensorFlags | |
| ParticleFilter::SimulationState | |
| ParticleTracker | |
| Patch | |
| PatchSet | |
| PauseWaiter | Simple class to help main loops handle pause/unpause events |
| PCamera | |
| PCamera::Square | |
| PedestrianChannel | A template-matching channel for detecting pedestrians |
| Pelco | |
| PercentileScorer | |
| PfmParser | This class handles reading/parsing of PFM image files |
| PfmParser::Rep | |
| PfmWriter | Write pfm image files |
| PfzParser | This class handles reading/parsing of PFM image files |
| PfzParser::Rep | |
| PfzWriter | Write pfz image files |
| PGH | |
| PGH::Line | |
| PGH::ModelInfo | |
| PIC | |
| PID< T > | Definition and access functions for a BeoSub PID |
| PIDTuner | |
| PingSonar | |
| PipeRecognizer | |
| PipeSensor | |
| pix< T > | |
| pix_ops_mixin< pixtype, T > | A "mix-in" class that injects all arithmetic operators into the class that inherits it |
| pix_ops_mixin_hyper< pixtype, T, dim > | |
| PixDKL< T > | This is the basic DKL pixel class |
| PixelClassifier | |
| PixelizerI | |
| PixelPoint | |
| Pixels< T, dim > | This is the base Pixel class for a pixel of any size |
| PixH2SV1< T > | This is the H2SV1 pixel class |
| PixH2SV2< T > | This is the H2SV2 pixel class |
| PixH2SV3< T > | This is the H2SV3 pixel class |
| PixHSL< T > | This is the basic HSL pixel class |
| PixHSV< T > | This is the basic HSV pixel class |
| PixHyper< T, dim > | This is the hyper pixel class |
| PixJpegYUV< T > | This is the basic jpeg-YUV pixel class |
| PixLab< T > | This is the basic Lab pixel class |
| PixPerDeg | |
| PixRGB< T > | This is the basic RGB pixel class |
| PixVideoYUV< T > | This is the basic video-YUV pixel class |
| PixXYZ< T > | This is the basic XYZ pixel class |
| PixYIQ< T > | This is the basic YIQ pixel class |
| PlaintextWriter | Plaintext image-file writer class |
| playlist | |
| PlotBuffer | |
| PlotBufferList | |
| PluginFallback | Class that can be used as a fallback for rutz::factory::set_fallback() |
| PN03contrastChannel | A Contrast channel (based on Parkhurst & Niebur 2003) |
| PngParser | This class handles reading/parsing of PNG image files |
| PngParser::Rep | |
| PngWriter | Write PNG image files |
| PnmParser | This class handles reading/parsing of PBM/PGM/PPM image files |
| PnmParser::Rep | |
| PnmWriter | Write pbm/pgm/ppm image files |
| Point2D< T > | This is a basic class to encode 2D integer coordinates |
| Point2DT | This is a fairly trivial (i, j, t) set representing a timestamped Point2D<int> |
| Point3D< T > | This is a basic class to encode 3D integer coordinates |
| Point3DwithColor< T > | |
| Pololu | Interface to a serial-servo-controller |
| Polygon | |
| POMDP | |
| POMDP::State | |
| POMDP::StateAction | |
| PoolImage | |
| PopulationHeadingMap | Lappe&Rauschecker's Population Heading Map algorithm |
| Position | |
| PosixSemaphore | Wrapper around posix sem_t semaphore |
| pParticle | |
| PreferencesDialog | |
| PrefItem | Base class for preference items to be used in a PrefsWindow |
| PrefItemMPNum< MP, T > | Template class for numeric preference items based on OModelParam or NModelParam |
| PrefItemMPStr | Template class for non-numeric preference items based on OModelParam or NModelParam |
| PrefItemNum< T > | Template class for numeric preference items |
| PrefItemStr | String preference item; includes value history |
| PrefrontalCortex | The PrefrontalCortex base class |
| PreFrontalCortexAgent | |
| PrefrontalCortexConfigurator | PrefrontalCortex configurator |
| PrefrontalCortexGS | GuidedSearch PrefrontalCortex implementation |
| PrefrontalCortexI | |
| PrefrontalCortexI::StateInfo | |
| PrefrontalCortexI::TopicInfo | |
| PrefrontalCortexOG | OptimalGains PrefrontalCortex implementation |
| PrefrontalCortexSB | SalBayes PrefrontalCortex implementation |
| PrefrontalCortexService | |
| PrefrontalCortexStub | "Stub" PrefrontalCortex implementation |
| PrefsWindow | A simple X window to allow online manipulation of preferences values |
| PreMotorComplex | |
| PressureMeter | |
| PrimaryMotorCortexI | |
| PrimaryMotorCortexI::TopicInfo | |
| PrimaryMotorCortexService | |
| PrimarySomatosensoryCortexI | |
| projectIO | |
| promote_trait< T1, T2 > | Promote from T1 and T2 to a type than can hold T1 * T2 |
| promote_trait< byte, byte > | |
| promote_trait< byte, double > | |
| promote_trait< byte, float > | |
| promote_trait< byte, int16 > | |
| promote_trait< byte, int32 > | |
| promote_trait< byte, long double > | |
| promote_trait< double, long double > | |
| promote_trait< float, double > | |
| promote_trait< float, long double > | |
| promote_trait< int16, byte > | |
| promote_trait< int16, double > | |
| promote_trait< int16, float > | |
| promote_trait< int16, int16 > | |
| promote_trait< int16, int32 > | |
| promote_trait< int16, long double > | |
| promote_trait< int32, double > | |
| promote_trait< int32, float > | |
| promote_trait< int32, long double > | |
| promoteFromTo< T1, T2 > | |
| promoteFromTo< double, byte > | |
| promoteFromTo< double, float > | |
| promoteFromTo< double, int16 > | |
| promoteFromTo< double, int32 > | |
| promoteFromTo< float, byte > | |
| promoteFromTo< float, int16 > | |
| promoteFromTo< float, int32 > | |
| promoteFromTo< int16, byte > | |
| promoteFromTo< int32, byte > | |
| promoteFromTo< int32, int16 > | |
| promoteFromTo< long double, byte > | |
| promoteFromTo< long double, double > | |
| promoteFromTo< long double, float > | |
| promoteFromTo< long double, int16 > | |
| promoteFromTo< long double, int32 > | |
| promoteFromTo< T, T > | |
| PropertyVectorSet | Class that contains a set of property vectors for events |
| PropHold | This is a container class for the property at each hyper pixel for ContourNeuronCreate |
| PsychoDisplay | Class fo do various psychophysics displays |
| PsychoTask | A summary struct to handle task settings |
| PTZI | |
| PTZI::TopicInfo | |
| PTZService | |
| Publisher1I | |
| Publisher1Service | |
| Publisher2I | |
| Publisher2Service | |
| PWiiController | |
| PyramidCache< T > | |
| PyramidCache< T >::Item | |
| PyramidFeatureExtractor | Extract topdown features from dyadic pyramids |
| PyrBuilder< T > | An interface class for creating dyadic pyramids from input images |
| PyrFoveator | A class that does space-variant processing with dyadic pyramid |
| QAppLockClass | |
| QMatrix | |
| QT_Navigation | |
| QtDisplayStream | FrameOstream subclass that displays images in a QWidgetStack |
| QtIconLoader | |
| QtImageFrame | A simple image frame in Qt4 |
| QtImageFrame::Impl | |
| QtImageStack | A simple image stack in Qt4 |
| QtImageStack::Impl | |
| QtImageStack::Impl::Entry | |
| QtTestForm | |
| QuadNode | |
| QuadNode::NodeState | |
| QuadTree | |
| QuickTimeGrabber | Grab frames (e.g. from a camera) using QuickTime's SequenceGrabber APIs |
| RadioDecoder | This class runs a thread which records servo position from sound card |
| RadioStatus | |
| random_sequence | |
| RandomBrain | |
| RandomFeatureExtractor | Random control for topdown feature extractors |
| RandomInput | FrameIstream subclass that generates random images |
| Range< T > | A class for managing min/max range information |
| RangeFinder | |
| rankOrderNeuron | |
| RasterInputOptions | Helper class to expose command-line options for various low-level parameters controlling raster file input |
| RasterInputSeries | FrameIstream subclass that reads raster files |
| RasterlistInputSeries | Reads image files from a list of filenames contained in a separate file |
| RasterOutputSeries | FrameOstream subclass that writes raster files |
| RasterParser | This class defines a generic interface for parsing image files |
| RasterWriter | Abstract image-file writer class |
| RateFunctions::EmptyFunction | |
| RateFunctions::FullRectifyFunction | |
| RateFunctions::LogThreshFunction | |
| RateFunctions::MaxRectFunction | |
| RateFunctions::RectifyFunction | |
| RateFunctions::SigmoidFunction | |
| RateFunctions::StepFunction | |
| RawGistEstimatorStd | |
| RawVisualCortex | The Visual Cortex Class |
| RawWriter | Write RAW image files |
| readConfig | Open a config file and parse it for data retreaval |
| readMatrix | |
| ReadTemp | |
| rebind< C, T > | Helper struct to provide a generic way to "rebind" template parameters |
| rebind< C< T >, U > | |
| rebind< C< T1, T2 >, U1 > | |
| Receptor::AMPA | Return current from AMPA receptor |
| Receptor::GABAA | Return current from GABAA receptor |
| Receptor::GABAB | Return current from GABAB receptor |
| Receptor::NMDA | Return current from NMDA receptor |
| Rect | |
| Rectangle | A basic rectangle class |
| RectangleSensor | |
| RectangleShape | A Rectangle ShapeModel |
| RectDecoder | A decoder using a sliding rectangular window, or moving average |
| Rectify | |
| RecurBayes | |
| RecurBayes::ClassInfo | |
| RedChannel | A red color channel |
| RedGreenChannel | A red-green double-opponent color channel |
| RefHolder | Base class for TRefHolder |
| Regions | |
| Regions::RegionState | |
| RegSaliency | |
| ReichardtPyrBuilder< T > | This class implements Reichardt motion detections |
| RemoveSurprise< PIXTYPE, BETATYPE, FLOAT > | Smooth surprise in a movie |
| renderDot | |
| renderObject | |
| ResizeSpec | Represents multiple methods for transforming image dimensions |
| ResultData | |
| Retina | The retina base class |
| RetinaAdapter | |
| RetinaConfigurator | Retina configurator |
| RetinaCT | |
| RetinaI | |
| RetinaService | |
| RetinaStd | Standard Retina implementation |
| RetinaStub | "Stub" Retina implementation |
| ReusableFactory< ReturnType, KeyType, TypeCreator, ErrorPolicy > | |
| RG_Lane | |
| RgbByteToFloatJob | |
| RgbByteToLuminanceJob | |
| RGBConvolveChannel | A generic convolution channel using color filters |
| RGBConvolvePyrBuilder< T > | Builds pyramids based on arbitrary color filters |
| riff_struct | |
| RobotArm | |
| RobotBrainComponent | |
| RobotBrainObjects::Hippocampus | |
| RobotBrainObjects::InferotemporalCortex | |
| RobotBrainObjects::LateralGeniculateNucleus | |
| RobotBrainObjects::Observer | |
| RobotBrainObjects::PrefrontalCortex | |
| RobotBrainObjects::PrimaryMotorCortex | |
| RobotBrainObjects::PrimarySomatosensoryCortex | |
| RobotBrainObjects::Retina | |
| RobotBrainObjects::SaliencyModule | |
| RobotBrainObjects::SupplementaryMotorArea | |
| RobotBrainServiceService | |
| RobotBrainStimulator | |
| RobotBrainStimulatorService | |
| robotCmd | |
| RobotHeadForm | |
| Robots::ArmPos | |
| Robots::Gumbot | |
| Robots::IRobot | |
| Robots::ScorbotIce | |
| RobotSimEvents::ActionMessage | |
| RobotSimEvents::AttendedRegionMessage | |
| RobotSimEvents::BeeStemConfigMessage | |
| RobotSimEvents::BeeStemMessage | |
| RobotSimEvents::BeeStemMotorControllerMessage | |
| RobotSimEvents::BeoHawkEyeSpyMessage | |
| RobotSimEvents::BeoHawkEyeSpyMessage__staticInit | |
| RobotSimEvents::BuoyColorSegmentConfigMessage | |
| RobotSimEvents::BuoyColorSegmentMessage | |
| RobotSimEvents::CameraConfigMessage | |
| RobotSimEvents::CameraImageMessage | |
| RobotSimEvents::ChatMessage | |
| RobotSimEvents::ControlCameraMessage | |
| RobotSimEvents::ControlDriveVisionMessage | |
| RobotSimEvents::ControlLandMessage | |
| RobotSimEvents::ControlMoveMessage | |
| RobotSimEvents::EventMessage | |
| RobotSimEvents::EventMessage__staticInit | |
| RobotSimEvents::Events | |
| RobotSimEvents::ExecuteMissionMessage | |
| RobotSimEvents::GoalProgressMessage | |
| RobotSimEvents::GoalStateMessage | |
| RobotSimEvents::GPSMessage | |
| RobotSimEvents::IMUDataServerMessage | |
| RobotSimEvents::JoyStickControlMessage | |
| RobotSimEvents::LandmarkInfo | |
| RobotSimEvents::LandmarksMessage | |
| RobotSimEvents::LocalizationMessage | |
| RobotSimEvents::Location | |
| RobotSimEvents::Lrf | |
| RobotSimEvents::MotionMessage | |
| RobotSimEvents::MovementControllerMessage | |
| RobotSimEvents::ObjectMessage | |
| RobotSimEvents::PipeColorSegmentConfigMessage | |
| RobotSimEvents::PipeColorSegmentMessage | |
| RobotSimEvents::RemoteControlMessage | |
| RobotSimEvents::RetinaMessage | |
| RobotSimEvents::SalientPointMessage | |
| RobotSimEvents::SeaBeePositionMessage | |
| RobotSimEvents::SeaBeeStateConditionMessage | |
| RobotSimEvents::SensorDataMessage | |
| RobotSimEvents::SlamDataMessage | |
| RobotSimEvents::Sonar | |
| RobotSimEvents::StateMessage | |
| RobotSimEvents::StraightEdgeMessage | |
| RobotSimEvents::VisionObjectMessage | |
| RobotSimEvents::VisionRectangleMessage | |
| RoiExtractor | |
| Roomba | |
| roRetina< T > | |
| round_helper< dst_type, src_type, false > | |
| round_helper< dst_type, src_type, true > | |
| Rovio | |
| RSNeuron | |
| RT100 | Interface to a serial-servo-controller |
| RT100ControlForm | |
| RTSPGrabber | |
| rutz::assoc_array< value_t > | Rutz::assoc_array is a typesafe wrapper of rutz::assoc_array_base |
| rutz::assoc_array_base | A non-typesafe wrapper around std::map<string, void*> |
| rutz::assoc_array_base::impl | |
| rutz::assoc_array_base::impl::fstring_cmp | |
| rutz::backtrace | Represents an instantaneous state of the call stack |
| rutz::bidir_iter< T > | Concrete bidirectional iterator class |
| rutz::bidir_iter_adapter< real_iter_t, T > | Adapts bidirectional iterators to the bidir_iter_ifx interface |
| rutz::bidir_iter_ifx< T > | Abstract interface class for bidirectional iterators |
| rutz::bidir_pipe | An exception-safe wrapper around a pipe-fork-exec sequence |
| rutz::bound_first< base_functor, bound_t > | Bound_first wraps another functor type with a fixed first argument |
| rutz::bound_last< base_functor, bound_t > | Bound_last wraps another functor type with a fixed last argument |
| rutz::char_range | |
| rutz::child_process | An exception-safe wrapper around a child process from fork() |
| rutz::circular_queue< T > | Circular fixed-size queue; T must have a default constructor |
| rutz::concrete_iter< T, ifx_t > | A template base class for all concrete iterator classes |
| rutz::creator_base< T > | Abstract interface for creating objects of a particular type |
| rutz::creator_from_func< base_t, derived_t > | Implements rutz::creator_base by calling a function pointer |
| rutz::cuda_free_list< T > | Typesafe wrapper of free_list_base for maintaining free-list memory pools |
| rutz::cuda_free_list_base | Un-typesafe base class for maintaining a free-list memory pool |
| rutz::darwin_atomic_int | Atomic integer operations implemented using Apple Darwin's OSAtomicAdd32Barrier() |
| rutz::dynamic_block< T > | A dynamically-allocated array whose size may be changed at runtime |
| rutz::error | rutz::error is a basic exception class |
| rutz::error_context | Don't use this class directly; use the GVX_ERR_CONTEXT() macro instead |
| rutz::error_context_entry | Don't use this class directly; use the GVX_ERR_CONTEXT() macro instead |
| rutz::exec_pipe | An exception-safe wrapper around a pipe-fork-exec sequence |
| rutz::factory< T > | Create objects base on 'key' strings |
| rutz::factory_base | Non-template helper class for rutz::factory |
| rutz::factory_fallback | Abstract class for a fallback strategy when factory lookup fails |
| rutz::file_pos | Represent a position (line number) within a source file |
| rutz::fixed_block< T > | A dynamically-allocated array whose size is fixed at construction |
| rutz::free_list< T > | Typesafe wrapper of free_list_base for maintaining free-list memory pools |
| rutz::free_list_base | Un-typesafe base class for maintaining a free-list memory pool |
| rutz::fstring | |
| rutz::full_object_caster< T, false > | |
| rutz::full_object_caster< T, true > | |
| rutz::func_args< R, A1, A2, A3, A4, A5, A6, A7, A8 > | Holds typedefs for the types of a function's arguments and return value |
| rutz::func_traits< func > | A traits class for holding information about functions/functors |
| rutz::func_traits< bound_first< base_functor, bound_t > > | Func_traits specialization for bound_first |
| rutz::func_traits< bound_last< base_functor, bound_t > > | Func_traits specialization for bound_last |
| rutz::func_traits< mem_functor< MF > > | Specialization of func_traits for mem_functor |
| rutz::func_traits< mem_functor_base< MF > > | Func_traits specialization for mem_functor_base |
| rutz::func_traits< R(*)()> | Specialization for free functions with no arguments |
| rutz::func_traits< R(*)(P1)> | Specialization for free functions with 1 argument |
| rutz::func_traits< R(*)(P1, P2)> | Specialization for free functions with 2 arguments |
| rutz::func_traits< R(*)(P1, P2, P3)> | Specialization for free functions with 3 arguments |
| rutz::func_traits< R(*)(P1, P2, P3, P4)> | Specialization for free functions with 4 arguments |
| rutz::func_traits< R(*)(P1, P2, P3, P4, P5)> | Specialization for free functions with 5 arguments |
| rutz::func_traits< R(*)(P1, P2, P3, P4, P5, P6)> | Specialization for free functions with 6 arguments |
| rutz::func_traits< R(C::*)() const > | Specialization for member functions with "this" plus 0 arguments |
| rutz::func_traits< R(C::*)()> | Specialization for member functions with "this" plus 0 arguments |
| rutz::func_traits< R(C::*)(P1) const > | Specialization for member functions with "this" plus 1 argument |
| rutz::func_traits< R(C::*)(P1)> | Specialization for member functions with "this" plus 1 argument |
| rutz::func_traits< R(C::*)(P1, P2) const > | Specialization for member functions with "this" plus 2 arguments |
| rutz::func_traits< R(C::*)(P1, P2)> | Specialization for member functions with "this" plus 2 arguments |
| rutz::func_traits< R(C::*)(P1, P2, P3) const > | Specialization for member functions with "this" plus 3 arguments |
| rutz::func_traits< R(C::*)(P1, P2, P3)> | Specialization for member functions with "this" plus 3 arguments |
| rutz::func_traits< R(C::*)(P1, P2, P3, P4) const > | Specialization for member functions with "this" plus 4 arguments |
| rutz::func_traits< R(C::*)(P1, P2, P3, P4)> | Specialization for member functions with "this" plus 4 arguments |
| rutz::func_traits< R(C::*)(P1, P2, P3, P4, P5) const > | Specialization for member functions with "this" plus 5 arguments |
| rutz::func_traits< R(C::*)(P1, P2, P3, P4, P5)> | Specialization for member functions with "this" plus 5 arguments |
| rutz::func_traits< R(C::*)(P1, P2, P3, P4, P5, P6) const > | Specialization for member functions with "this" plus 6 arguments |
| rutz::func_traits< R(C::*)(P1, P2, P3, P4, P5, P6)> | Specialization for member functions with "this" plus 6 arguments |
| rutz::func_traits< tcl::func_wrapper< N, F, Func > > | Specialization of func_traits for tcl::func_wrapper |
| rutz::functor_of< fptr > | Traits struct for specifying a "functor" type given a function pointer |
| rutz::functor_of< R(C::*)() > | Specialization for zero-arg mem func |
| rutz::functor_of< R(C::*)() const > | Specialization for zero-arg const mem func |
| rutz::functor_of< R(C::*)(P1) > | Specialization for one-arg mem func |
| rutz::functor_of< R(C::*)(P1) const > | Specialization for one-arg const mem func |
| rutz::functor_of< R(C::*)(P1, P2) > | Specialization for two-arg mem func |
| rutz::functor_of< R(C::*)(P1, P2) const > | Specialization for two-arg const mem func |
| rutz::functor_of< R(C::*)(P1, P2, P3) > | Specialization for three-arg mem func |
| rutz::functor_of< R(C::*)(P1, P2, P3) const > | Specialization for three-arg const mem func |
| rutz::functor_of< R(C::*)(P1, P2, P3, P4) > | Specialization for four-arg mem func |
| rutz::functor_of< R(C::*)(P1, P2, P3, P4) const > | Specialization for four-arg const mem func |
| rutz::functor_of< R(C::*)(P1, P2, P3, P4, P5) > | Specialization for 5-arg mem func |
| rutz::functor_of< R(C::*)(P1, P2, P3, P4, P5) const > | Specialization for 5-arg const mem func |
| rutz::functor_of< R(C::*)(P1, P2, P3, P4, P5, P6) > | Specialization for 6-arg mem func |
| rutz::functor_of< R(C::*)(P1, P2, P3, P4, P5, P6) const > | Specialization for 6-arg const mem func |
| rutz::fwd_iter< T > | Concrete forward iterator class |
| rutz::fwd_iter_adapter< real_iter_t, T > | Adapts forward iterators to the fwd_iter_ifx interface |
| rutz::fwd_iter_ifx< T > | Abstract interface class for forward iterators |
| rutz::gzstreambuf | A std::streambuf implementation that handles gzip-encoded data |
| rutz::icstrstream | An input stream class based on imembuf that makes a private copy |
| rutz::imembuf | An input streambuf that reads from memory |
| rutz::imemstream | An input stream class based on imembuf |
| rutz::is_class< T > | Traits class to tell us whether T is a class type or not |
| rutz::is_polymorphic< T > | Traits class to tell whether T is a polymorphic type (i.e. has virtual functions) |
| rutz::is_polymorphic_imp1< T > | Helper struct for telling whether T is a polymorphic type or not |
| rutz::is_polymorphic_imp1< T >::d1 | |
| rutz::is_polymorphic_imp1< T >::d2 | |
| rutz::is_polymorphic_imp1< T >::d2::unique | |
| rutz::is_polymorphic_imp2< T > | |
| rutz::is_polymorphic_selector< is_class > | |
| rutz::is_polymorphic_selector< is_class >::rebind< T > | |
| rutz::is_polymorphic_selector< true > | |
| rutz::is_polymorphic_selector< true >::rebind< T > | |
| rutz::is_sub_super< sub, super > | Determine whether sub derives from super |
| rutz::iter_end_t | Symbol class for representing generic "end of iteration" |
| rutz::ix86_atomic_int | Atomic integer class for ix86 CPUs |
| rutz::ix86_atomic_int_t | |
| rutz::mapped_infile | An mmap()/munmap() wrapper class for fast input file reading |
| rutz::mem_functor< mem_func > | Mem_functor extends mem_functor_base smart pointers for "this" |
| rutz::mem_functor_base< mem_func > | Mem_functor_base adapts a member function to an ordinary operator() |
| rutz::mutex_atomic_int | Heavyweight atomic integer implementation using mutexes |
| rutz::mutex_lock_class | Quick mutex locking class |
| rutz::out_of_range | Exception class for range errors |
| rutz::pipe_fds | An exception-safe wrapper around a pair of file descriptors from pipe() |
| rutz::prof | Accumulates profiling information for a given execution context |
| rutz::rxs_iter< T > | Concrete random-access iterator class |
| rutz::rxs_iter_adapter< real_iter_t, T > | Adapts random-access iterators to the rxs_iter_ifx interface |
| rutz::rxs_iter_ifx< T > | Abstract interface class for random-access iterators |
| rutz::scoped_ptr< T > | A smart-pointer for unshared objects |
| rutz::select_if< test, if_true, if_false > | Select between two types based on a compile-time constant boolean expression |
| rutz::select_if< false, if_true, if_false > | Specialization of select_if for 'false' |
| rutz::shared_array< T > | A reference-counted smart pointer for arrays |
| rutz::shared_ptr< T > | A thread-safe smart pointer with reference counted copy semantics |
| rutz::shell_pipe | Adapts UNIX-style process pipes to a std::iostream interface |
| rutz::spin_lock_darwin | |
| rutz::spin_lock_locker | |
| rutz::spin_lock_pthreads | |
| rutz::static_block< T, N > | A simple wrapper around a C-style array |
| rutz::static_stack< T, N > | STL-style class for fixed-size stacks whose size is known at compile time |
| rutz::stdiobuf | A C++ streambuf that wraps a standard posix file descriptor |
| rutz::stdiostream | |
| rutz::stopwatch | Tracks elapsed wall-clock time |
| rutz::string_rep | |
| rutz::time | A simple wrapper around timeval |
| rutz::trace | Times and traces execution in and out of a lexical scope |
| rutz::traits::no_type | |
| rutz::traits::yes_type | |
| rutz::type_match< T > | Helper class for is_sub_super |
| rutz::type_traits< T > | Basic type traits class |
| rutz::type_traits< const T & > | Specialization of type traits for const references |
| rutz::type_traits< nub::ref< T > > | Type_traits specialization for nub::ref smart pointer |
| rutz::type_traits< nub::soft_ref< T > > | Type_traits specialization for soft_ref smart pointer |
| rutz::type_traits< T & > | Specialization of type traits for references |
| rutz::type_traits< T * > | Specialization of type traits for pointers |
| rutz::urand | Uniform random distribution |
| rutz::urand_frange | Uniform distribution over a specified floating-point range |
| rutz::urand_irange | Uniform distribution over a specified integer range |
| rutz::value | |
| SaccadeController | A base class to implement saccade controllers |
| SaccadeControllerEyeConfigurator | SaccadeController configurator for eye |
| SaccadeControllerHeadConfigurator | SaccadeController configurator for head |
| SafeCopyHelper< T, isTrivial > | Helper template struct for pointer version of safecopy() |
| SafeCopyHelper< T, true > | Specialized implementation for trivial types |
| SalGlassesServer | |
| SaliencyBrain | |
| SaliencyMap | The saliency map base class |
| SaliencyMapAdapter | A partial implementation of SaliencyMap for further subclasses |
| SaliencyMapConfigurator | SaliencyMap configurator |
| SaliencyMapFast | The fast saliency map: a 2D array of floats |
| SaliencyMapFeatureExtractor | Bottom-up saliency-map-based feature extractor |
| SaliencyMapI | |
| SaliencyMapI::TopicInfo | |
| SaliencyMapService | |
| SaliencyMapStd | The standard saliency map: a 2D array of LeakyIntegrator neurons |
| SaliencyMapStdOptim | Optimized version of the standard saliency map |
| SaliencyMapStdOptim::UpdateJob | |
| SaliencyMapStub | A do-nothing stub implementation of SaliencyMap |
| SaliencyMapTrivial | The trivial saliency map: a 2D array of floats |
| SaliencyModuleI | |
| SaliencyMT | |
| SalientRegionSegmenter | |
| SalientRegionTracker | |
| SaturationChannel | A hue1 red-green double-opponent color channel |
| SC | |
| SC8000 | Interface to a serial-servo-controller |
| ScaleRemoveSurprise< FLOAT > | Remove surprise using scales, FLOAT is either float or double for precision |
| ScaleSpace | ScaleSpace is like a Gaussian pyramid but with several images per level |
| ScaleSurpriseControl< FLOAT > | Remove surprise using scales, FLOAT is either float or double for precision |
| scan | |
| SceneGenerator | |
| SceneGenerator::ObjectInfo | |
| SceneRec | Class to recognize scenes and get landmark positions |
| SceneRecServer_i | |
| SceneSettingsDialog | |
| SceneSetup | |
| SceneSetup::Object | |
| SceneUnderstanding | |
| SceneUnderstandingForm | |
| SCInterface | |
| Scorbot | |
| Scorbot::ArmPos | |
| Scorbot::ArmVelParam | |
| Scorbot::VelParam | |
| ScorbotConsole | |
| ScorbotController | |
| ScorbotI | |
| ScorbotIce::Scorbot | |
| ScorbotInterface | |
| ScorbotInterfaceThread | |
| ScorbotReallySimple | |
| ScorbotSimple | |
| ScorbotSimpleI | |
| ScorbotSimpleIce::ScorbotSimple | |
| Scorer | Score the fit between predicted and actual eye positions |
| ScorrChannel | A spatial correlation channel |
| SCTracker | |
| SDLdisplay | Class fo do various fast graphics displays |
| SDLdisplayStream | A FrameOstream class that sends images to SDL windows |
| SDLdisplayStream::WindowMap | |
| SeaBee | Definition and access functions for the BeoSub |
| SeaBee3_Sonar::DataToFFT | |
| SeaBee3GUICommunicator | |
| SeaBee3GUIIce | |
| SeaBee3GUIService | |
| SeaBee3MainDisplayForm | |
| SeaBee3Simulator | |
| SeaBeeInjector | |
| SeaBeeSimEvents::CameraConfigMessage | |
| SeaBeeSimEvents::CameraConfigMessage__staticInit | |
| SearchArray | SearchArray represents an 2-D spatial array of search items |
| SearchItem | |
| SearchItemFactory | |
| SeC< T > | SeC class to assist with checking for events |
| segHolder< FLOAT, INT, dim > | A general purpose container for holding guassian signatures |
| Segment | |
| SegmenterI | |
| SegmenterI::TopicInfo | |
| SegmenterService | |
| segmentImage | |
| segmentImage2 | |
| segmentImageMC | This is a class to track hyper spectal blobs |
| segmentImageMC2 | This is a class to track hyper spectal blobs |
| segmentImageMerge | |
| segmentImageMerge2 | |
| segmentImageTrack | |
| segmentImageTrack2 | |
| segmentImageTrackMC | This is a class to track hyper spectal blobs |
| SelectAnnotationSourceDialog | |
| SensorAgent | |
| SensorAgent::Job | |
| SensorInput | |
| SensorResult | |
| SequenceFileStream | |
| Serial | Interface to a serial port |
| SerialAdvanced | Interface to a serial port |
| SESSION_EXP12 | |
| SESSION_EXP3 | |
| SESSION_EXP4 | |
| SFS | |
| sha1_context | |
| sha256_context | |
| ShapeEstimator | Everything related to the shape estimation procedure |
| ShapeModel | The base class for shape models |
| SharedBuffer< T > | |
| ShiftedImage | FrameIstream subclass that generates random images |
| SIFTaffine | A simple struct to store 2D affine transforms as used in the SIFT code |
| SIFTChannel | A SIFT channel |
| SiftData | |
| SIFTegomotion | A class that calculates 3D egomotion from a set of matches |
| SIFThough | SIFThough accumalates data for the Hough transform used in SIFT |
| SIFTMatcherI | |
| SiftPoint | |
| SiftRec | |
| SImage< T > | Templated image class |
| SimCallback< Module, Event > | Template class for SimEventQueue callbacks |
| SimCallbackBase | A SimEventQueue callback for SimModule |
| SimCallbackClient | Client for SimCallback hooks |
| SimCallbackCompare | Functor used to compare two SimCallbackBase objects, sorting by priority |
| SimEvent | Base class for events that arise in simulation |
| SimEventAttentionGateOutput | A new output is available from the AttentionGate |
| SimEventAttentionGateStageTwoObjects | |
| SimEventAttentionGateStageTwoSegments | |
| SimEventAttentionGuidanceMapOutput | A new output(s) is available from the AttentionGuidanceMap |
| SimEventBreak | Request to break the simulation |
| SimEventBuffer | |
| SimEventClockTick | Posted by SimEventQueue at the beginning of each clock tick |
| SimEventContoursBias | |
| SimEventContoursOutput | |
| SimEventCornersOutput | |
| SimEventEyeTrackerData | An EyeTrackerSaccadeController may post this |
| SimEventGanglionOutput | |
| SimEventGeons2DOutput | |
| SimEventGeons3DOutput | |
| SimEventGeons3DPrior | |
| SimEventGistOutput | A new output is available from the GistEstimator |
| SimEventHandTrackerData | An TrackerHandController may post this |
| SimEventInputDescription | Get a description of the current input |
| SimEventInputFrame | A new input frame is available |
| SimEventITOutput | The output of the IT cortex, i.e. information about the object |
| SimEventLGNOutput | |
| SimEventLineMatchingOutput | |
| SimEventObjectDescription | A Description of an object |
| SimEventObjectToBias | Indicate which object we are biasing for (use for statistics) |
| SimEventQueue | Helper class to gather events generated while running a simulation |
| SimEventQueue::RealmData | |
| SimEventQueue::TypeInfoCompare | |
| SimEventQueueConfigurator | |
| SimEventQueueDebug | Debug version of SimEventQueue |
| SimEventRegionsOutput | |
| SimEventRegionsPrior | |
| SimEventRequestFrameNum | Request that the input module seek to a new frame |
| SimEventRequestSaveOutput | Request that outputs be saved now |
| SimEventRetinaImage | A new image is available from the retina |
| SimEvents::ArmPosition | |
| SimEvents::CameraCtrlBiasMessage | |
| SimEvents::CameraCtrlMessage | |
| SimEvents::EventMessage | |
| SimEvents::EventMessage__staticInit | |
| SimEvents::Events | |
| SimEvents::GUIInputMessage | |
| SimEvents::GUIOutputMessage | |
| SimEvents::HippocampusBiasMessage | |
| SimEvents::HippocampusMessage | |
| SimEvents::InfrotemporalCortexBiasMessage | |
| SimEvents::InfrotemporalCortexMessage | |
| SimEvents::LocInfo | |
| SimEvents::ObjectState | |
| SimEvents::PrimaryMotorCortexBiasMessage | |
| SimEvents::PrimaryMotorCortexMessage | |
| SimEvents::PrimaryMotorCortexRelativeServoMessage | |
| SimEvents::PrimaryMotorCortexResetEncodersMessage | |
| SimEvents::RetinaMessage | |
| SimEvents::SaliencyMapBiasMessage | |
| SimEvents::SaliencyMapMessage | |
| SimEvents::SegInfo | |
| SimEvents::SegmenterBiasMessage | |
| SimEvents::SegmenterMessage | |
| SimEvents::TrackInfo | |
| SimEvents::VisualCortexMessage | |
| SimEvents::VisualTrackerBiasMessage | |
| SimEvents::VisualTrackerMessage | |
| SimEventSaccadeStatus | A SaccadeController may post this at every evolve |
| SimEventSaccadeStatusEye | An Eye SaccadeController may post this at every evolve |
| SimEventSaccadeStatusHead | An Head SaccadeController may post this at every evolve |
| SimEventSaliencyMapOutput | A new output is available from the SaliencyMap |
| SimEventSaveOutput | Save your outputs |
| SimEventSceneDescription | A Description of the scene |
| SimEventSetVisualTracker | |
| SimEventShapeEstimatorOutput | A new output is available from the ShapeEstimator |
| SimEventShowMemStats | Requests that memory stats be shown now |
| SimEventSMapOutput | |
| SimEventsUtils::TopicInfo | |
| SimEventTargetMask | A new target mask is available, TargetChecker will check for this and use the new mask |
| SimEventTargetsHit | The TargetChecker hit a one or more targets |
| SimEventTaskRelevanceMapOutput | A new output is available from the TaskRelevanceMap |
| SimEventTwoHalfDSketchOutput | |
| SimEventUserInput | Send the user mouse and keyboard events |
| SimEventUserWait | Wait until user presses RETURN key |
| SimEventV1Bias | |
| SimEventV1Output | |
| SimEventV2Output | |
| SimEventV4BiasOutput | |
| SimEventV4dOutput | |
| SimEventV4Output | |
| SimEventVisualBufferOutput | A new output is available from the VisualBuffer |
| SimEventVisualCortexOutput | A new output is available from the VisualCortex |
| SimEventVisualTracker | |
| SimEventWTAwinner | The WinnerTakeAll selected a winner |
| SimInputFrameSeries | An InputFrameSeries encapsulated into a SimModule |
| SimLayer | |
| SimLayerDerived< Derived > | A class to derive from to create new SimLayers. New |
| SimModule | SimModule is an extension of ModelComponent for simulation modules |
| SimModuleSaveInfo | Provide info that SimModule objects need to save() their results |
| SimOutputFrameSeries | An OutputFrameSeries encapsulated into a SimModule |
| SimpleEyeHeadController | Simple eye/head controller |
| SimpleFont | A simple font class |
| SimpleLED | |
| SimpleMeter | |
| SimpleMotor | |
| SimpleRectangleFinder | |
| SimpleRobotBrainComponent | |
| SimpleVisualObject | Describes name and attributes of a visual object |
| SimReq | Base class for requests that arise in simulation |
| SimReqHandler< Module, Req > | Template class for SimEventQueue requests |
| SimReqHandlerBase | A SimEventQueue callback for SimModule |
| SimReqHandlerClient | Client for SimReqHandler hooks |
| SimReqVCXchanVis | Trigger a ChannelVisitor on VisualCortex |
| SimReqVCXfeatures | Request VCX features at a given location |
| SimReqVCXmaps | Request VCX internal maps |
| SimStructure | |
| simTexture | |
| SimTime | Encapsulated representation of simulation time |
| Simulation | Encapsulation of the main loop of a simulation |
| SimulationViewer | This class provides an abstract interface for a simulation viewer |
| SimulationViewerAdapter | |
| SimulationViewerCompress | Do multi-foveated saliency-based image compression |
| SimulationViewerConfigurator | SimulationViewer configurator |
| SimulationViewerEyeHand | Measure salience at human eye positions |
| SimulationViewerEyeHand::GEyeFormat | |
| SimulationViewerEyeHand::GHandFormat | |
| SimulationViewerEyeMvt | Measure salience at human eye positions |
| SimulationViewerEyeMvt2 | Measure salience at human eye positions |
| SimulationViewerEyeMvt::GEyeFormat | |
| SimulationViewerEyeMvtNeuro | Measure salience at receptive field center of a neuron |
| SimulationViewerEyeRegion | |
| SimulationViewerEyeSim | Simulate an eye-tracker recording |
| SimulationViewerHand | Measure salience at human eye positions |
| SimulationViewerHand::GHandFormat | |
| SimulationViewerI | |
| SimulationViewerI::ObjectState | |
| SimulationViewerI::TopicInfo | |
| SimulationViewerNerdCam | This class provides interface with vision and NerdCam |
| SimulationViewerRecStats | |
| SimulationViewerService | |
| SimulationViewerStats | View/save a bunch of stats about the saliency map |
| SimulationViewerStd | This class provides a standard set of visualization tools |
| SimulationViewerStub | Stub implementation of SimulationViewer; all operations are no-ops |
| SimulationViewerSurpCont | This class provides an interface into SurpriseControl (ASAC) |
| SimUnit | |
| SimUnitDerived< Derived > | A class to derive from to create new SimUnits. New |
| SingleChannel | SingleChannel represents a single stream of processing |
| SingleChannel::TPyr | Time-stamped pyramid |
| SingleChannelBeo | Wrapper to run a SingleChannel on a distant CPU |
| SingleChannelBeoServer | Server to work with SingleChannelBeo |
| SingleChannelSurprise< SMODEL > | SingleChannelSurprise is a Surprise extension to SingleChannel |
| SingleOpponentChannel | |
| SingleSvChannel | SingleSvChannel represents a single stream of processing in space variant mode |
| SingularMatrixException | Exception class thrown if a singular matrix is encountered |
| SkinHueChannel | A channel for detecting skin color |
| SLAM_Navigation | |
| SMap | |
| SMap::SMapState | |
| SobelChannel | A SOBEL channel |
| SOBlueYellowChannel | Single Opponent BlueYellowChannel member definitions: |
| SockServ | This is a multi-socket connection server |
| SOColorChannel | |
| SOFM | |
| SOFM::Layer | |
| SOGreenRedChannel | Single Opponent GreenRedChannel member definitions: |
| Solver | |
| Solver::SolutionInfo | |
| Solver_NU | |
| sonarData | |
| SonarListenAgent | |
| SORedGreenChannel | Single Opponent RedGreenChannel member definitions: |
| SortObj | |
| SoxChannel | A short-range orientation interactions channel |
| SOYellowBlueChannel | Single Opponent YellowBlueChannel member definitions: |
| SpaceVariantDoGModule | |
| SpaceVariantEdgeModule | |
| SpaceVariantModule | |
| SpaceVariantTransform | |
| SpatialMetrics | |
| SpatioTemporalEnergyPyrBuilder< T > | This class implements Spatiotemporal Energy motion detections |
| SpectralResidualChannel | "Spectral Residual" channel based on Hou&Zhang (CVPR 2007) |
| SpectralResidualChannel::Downsizer | This helps share downsizing calculations across multiple subchannels in a MultiSpectralResidualChannel |
| SpeechSynth | |
| SpikingSC | |
| SplitRgbOfilt | Output filter that splits rgb images into separate r/g/b components |
| SquareItem | |
| SquareShape | A Square ShapeModel |
| SSC | Interface to a serial-servo-controller |
| SSCMainForm | |
| Staircase | A staircase procedure to measure psychophysical thresholds |
| State | |
| staticContourNeuronProp< FLOAT, INT > | Holds the property for each neuron |
| stats< T > | |
| StatsOutputSeries | FrameOstream subclass that writes image statistics to an output file |
| StatsOutputSeries::Impl | |
| status_data | |
| std::deque< T, Alloc > | The STL deque container class. Use with #include <deque> |
| std::iterator_traits< Image< T > > | |
| std::list< T, Alloc > | The STL list container class. Use with #include <list> |
| std::map< Key, Data, Compare, Alloc > | The STL map container class. Use with #include <map> |
| std::multimap< Key, Data, Compare, Alloc > | The STL multimap container class. Use with #include <map> |
| std::multiset< Key, Compare, Alloc > | The STL multiset container class. Use with #include <set> |
| std::set< Key, Compare, Alloc > | The STL set container class. Use with #include <set> |
| std::slist< T, Alloc > | The STL slist container class. Use with #include <slist> |
| std::string | The STL string class. Use with #include <string> |
| std::vector< T, Alloc > | The STL vector container class. Use with #include <vector> |
| StdBrain | A subclass of Brain that automatically sets up the standard modules |
| Stepper | This class is a disaster |
| StereoChannel | A composite channel containing a set of Disparity channels |
| StereoRetinaI | |
| StereoVision | |
| StimAnalyzer | Analize stats from stim maker and surprise |
| StimController | Class to control psychodisplay from a host sending commands |
| StimData | |
| StimListener | Interface for a stimulus listener |
| StimListenerDML | Class to control communication with the Rex experimental control system |
| StimMaker | Class for making visual stimuli |
| StimMakerParam | Holder class for parameters used in StimMaker |
| Stimulus2D | A class for to represent a stimulus |
| stitchminmax | |
| StraightEdgeFinder | |
| StraightLine2D | A straight line in the 2D plane |
| Streamer | Base class for simple input-output streaming applications |
| StrictFactoryError< ReturnType, KeyType > | |
| Structure< T > | |
| StructureDerived< T, Derived > | A class to derive from to create new Structures. New |
| StructurePlot | |
| StubEyeHeadController | Stub eye/head controller |
| StubHandController | |
| StubSaccadeController | Stub saccade controller |
| SubController | |
| SubGUI | |
| subMap | |
| SubmapAlgorithm | Abstract strategy class for computing submaps in SingleChannel objects |
| SubmapAlgorithmBiased | Compute SingleChannel submaps with Bayesian biasing |
| SubmapAlgorithmStd | Standard strategy for computing submaps in SingleChannel objects |
| SubmarineAgent | |
| Subscriber1I | |
| Subscriber1Service | |
| Subscriber2I | |
| Subscriber2Service | |
| SubSim | |
| SumFunc | |
| SupColliculusModule | A class to represent different superior colliculus (multi-layered) models |
| SuperQuadric | |
| SupplementaryMotorAreaI | |
| SurpriseControl< PIXTYPE, BETATYPE, FLOAT > | Control surprise in a movie |
| SurpriseImage< T > | A 2D array of SurpriseModel objects |
| SurpriseMap< T > | A Surprise Map |
| SurpriseMapFFT< T > | A Surprise Map |
| SurpriseModel | A local (single-point) surprise model |
| SurpriseModelCS | A Chi-Square SurpriseModel |
| SurpriseModelGG | A joint Gamma/Gaussian SurpriseModel |
| SurpriseModelOD | A single-Poisson Outlier-based model |
| SurpriseModelPM | A single-Poisson/Gamma SurpriseModel with inertia |
| SurpriseModelSG | A single-Gaussian SurpriseModel |
| SurpriseModelSP | A single-Poisson/Gamma SurpriseModel |
| SurpriseModelSP1 | A single-Poisson/Gamma SurpriseModel |
| SurpriseModelSPC | A single-Poisson/Gamma SurpriseModel |
| SurpriseModelSPF | A single-Poisson/Gamma SurpriseModel |
| SVC_Q | |
| SVChanLevels | |
| SVEMNPlot::PlotBuf | |
| svm_model | |
| svm_node | |
| svm_parameter | |
| svm_problem | |
| SVMClassifier | SVM Classifier Class |
| SVMClassifierModule | Double inheritence from SimModule SVMClassifier |
| SVMObject | |
| SVMObjectDB | |
| SVR_Q | |
| SweepPoint | |
| SWIProlog | |
| SwpeScorer | Saliency-weighted prediction error scorer |
| Synapse< SynType, IntType > | |
| SyncJobServer | A simple synchronous JobServer class that just runs each job immediately when it is submitted |
| TargetChecker | Check and count targets hit during a neural simulation |
| TaskRelevanceMap | The task-relevance map base class |
| TaskRelevanceMapAdapter | Partial implementation of TaskRelevanceMap for further derivation |
| TaskRelevanceMapConfigurator | TaskRelevanceMap configurator |
| TaskRelevanceMapGistClassify | A GistClassify task-relevance map |
| TaskRelevanceMapKillN | A KillN task-relevance map |
| TaskRelevanceMapKillStatic | A killStatic task-relevance map |
| TaskRelevanceMapSocial | |
| TaskRelevanceMapStd | The standard task-relevance map |
| TaskRelevanceMapStub | Stub implementation of TaskRelevanceMap |
| TaskRelevanceMapTigs | A Tigs task-relevance map |
| TaskRelevanceMapTigs2 | A Tigs task-relevance map A Tigs combined image PCA task-relevance map |
| tcl::arg_dispatcher | |
| tcl::arg_spec | Specify how many args a command can take |
| tcl::call_context | |
| tcl::cobj_caster< C > | Cobj_caster implements obj_caster with dynamic_cast |
| tcl::command | |
| tcl::command::impl | |
| tcl::command_group | Represents a set of overloaded tcl::command objects |
| tcl::command_group::impl | |
| tcl::emu_namesp | |
| tcl::event_loop | Singleton class that operates the main Tcl event loop |
| tcl::event_loop_impl | |
| tcl::func_wrapper< N, R, Func > | Generic tcl::func_wrapper definition |
| tcl::func_wrapper< 0, R, Func > | Tcl::func_wrapper<0> -- zero arguments |
| tcl::func_wrapper< 1, R, Func > | Tcl::func_wrapper<1> -- one argument |
| tcl::func_wrapper< 2, R, Func > | Tcl::func_wrapper<2> -- two arguments |
| tcl::func_wrapper< 3, R, Func > | Tcl::func_wrapper<3> -- three arguments |
| tcl::func_wrapper< 4, R, Func > | Tcl::func_wrapper<4> -- four arguments |
| tcl::func_wrapper< 5, R, Func > | Tcl::func_wrapper<5> -- five arguments |
| tcl::func_wrapper< 6, R, Func > | Tcl::func_wrapper<6> -- six arguments |
| tcl::func_wrapper< 7, R, Func > | Tcl::func_wrapper<7> -- seven arguments |
| tcl::func_wrapper< 8, R, Func > | Tcl::func_wrapper<8> -- eight arguments |
| tcl::function | Abstract interface for the core function to be embedded in a tcl::command |
| tcl::generic_function< R, func_wrapper > | Generic_function implements tcl::command using a held functor |
| tcl::generic_function< void, func_wrapper > | Specialization for functors with void return types |
| tcl::interpreter | Tcl::interpreter provides a wrapper around Tcl_Interp calls |
| tcl::list | |
| tcl::list::appender | A back-insert iterator for tcl::list |
| tcl::list::iterator< T > | |
| tcl::list::iterator_base | |
| tcl::native_namesp | |
| tcl::obj | |
| tcl::obj_caster | Obj_caster class encapsulates casts to see if objects match a given type |
| tcl::package_info | |
| tcl::pkg | |
| tcl::pkg::impl | |
| tcl::returnable< T > | Trait class for extracting an appropriate return-type from T |
| tcl::returnable< const T & > | Specialization of tcl::returnable for const T& |
| tcl::returnable< const T > | Specialization of tcl::returnable for const T |
| tcl::script_app | Use inside main() to initialize and run a scripting application |
| tcl::vec_context | |
| tcl::vec_dispatcher | |
| TCoerceVideoFormatOfilt< VF > | Subclass of CoerceVideoFormatOfilt that specifies the dest format as a template parameter |
| TcorrChannel | A temporal correlation channel |
| TCPcliServ | A client/server to receive/send TCPmessage |
| TCPcommunicator | This class handles passing TCPmessages in and out |
| TCPmessage | This class defines a modular message to be passed over TCP connections |
| TDexpData | |
| TDexpDataReport | |
| TemplateMatchChannel | Convolves each level of its pyramid with a feature template |
| TemplateMatchPyrBuilder | A PyrBuilder that does template matching |
| TensorField | Here we represent tensors as an image set with 4 images indexed as: |
| TensorVoting | |
| TestBeoSubIMUListener | A hook which will be called when a new IMU reading is received |
| TestData | |
| TestGPSlistener | GPS listener for our test application |
| TestHMR3300Listener | |
| TestImages | TestImages |
| TestImages::ObjData | |
| TestImages::SceneData | |
| TestJoyStickListener | A simple joystick listener |
| TestPub::Publisher1 | |
| TestPub::Publisher2 | |
| TestPub::Subscriber1 | |
| TestPub::Subscriber2 | |
| TestrigGUI | |
| TestSIFT::keypoint | |
| TestSIFT::SIFTMatcher | |
| TestSuite | TestSuite manages a set of tests |
| TestSuite::Impl | |
| Texture | |
| ThresholdCircuit | A Threshold circuit that slowly accumulates input and then |
| ThresholdFrictionSaccadeController | Threshold-limited friction-damped controller |
| ThresholdSaccadeController | Threshold-limited controller that eliminates small or unreliable shifts |
| TigsInputFrame | Class that lets us do lazy computation of luminance/rg/by from an input frame |
| TigsInputFrameSeries | |
| TigsJob | |
| Timer | This class implements a real-time timer |
| TJunctionChannel | A T junction channel that detects T junctions at different |
| TNOobject | |
| Token | Public class that contains information for a visual token for tracking |
| TopdownLearner | Base class for learning associations between visual features and eye positions |
| TopologicalMap | Topological map using a list of landmarks |
| track_s | |
| TrackerHandController | |
| TrackFeature | |
| TrainingSet | Manage a paired set of eye position data and input feature vectors |
| Tree | |
| Tree::Node | |
| TRefHolder< T > | Template implementation of RefHolder |
| trial | |
| trialAgenda | |
| TrivialSaccadeController | Trivial saccade controller |
| TV_Lane | |
| TwoHalfDSketch | |
| TwoHalfDSketch::rect | |
| TwoHalfDSketch::rect_iter | |
| TwoHalfDSketch::SurfaceState | |
| type_if< T, B > | Makes a type a typedef for T only if B is true |
| type_if< T, true > | |
| type_with_N_bits< T, N > | A compile-time check that T has N bits |
| TypeTraits< T > | The generic TypeTraits implementation |
| TypeTraits< bool > | |
| TypeTraits< char > | |
| TypeTraits< double > | |
| TypeTraits< float > | |
| TypeTraits< int > | |
| TypeTraits< long > | |
| TypeTraits< long double > | |
| TypeTraits< PixDKL< T > > | Specialize TypeTraits to indicate that PixDKL is a "trivial" type |
| TypeTraits< Pixels< T, dim > > | Specialize TypeTraits to indicate that Pixels is a "trivial" type |
| TypeTraits< PixH2SV1< T > > | Specialize TypeTraits to indicate that PixH2SV1 is a "trivial" type |
| TypeTraits< PixH2SV2< T > > | Specialize TypeTraits to indicate that PixH2SV2 is a "trivial" type |
| TypeTraits< PixH2SV3< T > > | Specialize TypeTraits to indicate that PixH2SV3 is a "trivial" type |
| TypeTraits< PixHSL< T > > | Specialize TypeTraits to indicate that PixHSL is a "trivial" type |
| TypeTraits< PixHSV< T > > | Specialize TypeTraits to indicate that PixHSV is a "trivial" type |
| TypeTraits< PixHyper< T, dim > > | Specialize TypeTraits to indicate that PixHyper is a "trivial" type |
| TypeTraits< PixJpegYUV< T > > | Specialize TypeTraits to indicate that PixJpegYUV is a "trivial" type |
| TypeTraits< PixLab< T > > | Specialize TypeTraits to indicate that PixLab is a "trivial" type |
| TypeTraits< PixRGB< T > > | Specialize TypeTraits to indicate that PixRGB is a "trivial" type |
| TypeTraits< PixVideoYUV< T > > | Specialize TypeTraits to indicate that PixVideoYUV is a "trivial" type |
| TypeTraits< PixXYZ< T > > | Specialize TypeTraits to indicate that PixXYZ is a "trivial" type |
| TypeTraits< PixYIQ< T > > | Specialize TypeTraits to indicate that PixYIQ is a "trivial" type |
| TypeTraits< short > | |
| TypeTraits< unsigned char > | |
| TypeTraits< unsigned int > | |
| TypeTraits< unsigned long > | |
| TypeTraits< unsigned short > | |
| UcbMpegEncoder | Thin c++ wrapper around mpeg_encode/ppmtompeg |
| UcbMpegOutputStream | Write mpeg video frames using mpeg_encode/ppmtompeg |
| UcbMpegParams | |
| Ui::BeoChipMainForm | |
| Ui::testrig | |
| Ui::VisionGUI | |
| Ui_BeoChipMainForm | |
| Ui_testrig | |
| Ui_VisionGUI | |
| UKF | |
| uni_elt | |
| universe | |
| uvc_xu_control | |
| uvc_xu_control_info | |
| uvc_xu_control_mapping | |
| V1 | |
| V1::EdgesState | |
| V1::SpatialBias | |
| V2 | |
| V2::ContourState | |
| V2::coorlist | |
| V2::CornerState | |
| V2::LineSegment | |
| V2::point | |
| V2::rect | |
| V2::rect_iter | |
| V2::SymmetryState | |
| V4 | |
| V4::GeonOutline | |
| V4::GeonState | |
| V4::GHTAcc | |
| V4::RTableEntry | |
| V4d | |
| V4d::FeatureTemplate | |
| V4d::GHTAcc | |
| V4d::NAFState | |
| V4d::RTableEntry | |
| V4L2grabber | Definition and access functions for video4linux2 frame grabber |
| V4Lgrabber | Definition and access functions for video4linux frame grabber |
| ValueChangeTransaction< T > | Helper class to provide transactional semantics for a value change |
| ValueIntensityChannel | A hue1 red-green double-opponent color channel |
| VarianceChannel | A variance channel, computes the variance in an image patch |
| VCC4 | Interface with the pan-tilt mechanism of a Canon VC-C4 camera |
| VCC4CMD | |
| vdIn | |
| Vector2D | A vector in the 2D plane |
| VectorField | |
| VectorHistField | |
| velocityQue< T > | |
| vfatTargetInfo< FLOAT > | A general purpose container for holding guassian signatures |
| video_index_entry | |
| VideoFormatCoercion | |
| VideoFormatConverter | |
| VideoFrame | Simple class that encpasulates information about a video frame |
| VideoFrame::Storage | Abstract base class for various storage back-ends |
| ViewPort | |
| ViewPort3D | |
| ViewPort3D::Line | |
| ViewPort::BITMAPINFOHEADER | |
| ViewPort::DSObject | |
| ViewPort::mapcoord_type | |
| ViewPort::polygon_type | |
| ViewPort::vertex_type | |
| VirtualSensorMessage::BuoyColorSegmentMessage | |
| VirtualSensorMessage::IMUDataServerMessage | |
| VirtualSensorMessage::PipeColorSegmentMessage | |
| VirtualSensorMessage::VirtualSensorMessage | |
| VirtualSensorMessage::VisionRectangleMessage | |
| Visca | |
| VisionBrainComponentI | |
| VisionGUI | |
| VisionGUIService | |
| VisionInput | |
| VisionRecognizer | |
| VisionRectangle | |
| ViSTARSmodel | |
| ViSTARSmodelState | |
| VisualBuffer | An integrative visual buffer, base class |
| VisualBufferConfigurator | VisualBuffer configurator |
| VisualBufferStd | An integrative visual buffer, std implementation |
| VisualBufferStub | An integrative visual buffer, stub implementation, does nothing |
| VisualCortex | The Visual Cortex Base Class |
| VisualCortexConfigurator | VisualCortex configurator |
| VisualCortexEnv | An optimized C-based Integer-based VisualCortex |
| VisualCortexEyeMvt | The VisualCortexEyeMvt Class |
| VisualCortexFeatureExtractor | Derive topdown features from a VisualCortex |
| VisualCortexI | |
| VisualCortexI::TopicInfo | |
| VisualCortexInt | An Integer-based VisualCortex |
| VisualCortexService | |
| VisualCortexStd | The Standard Visual Cortex |
| VisualCortexSurprise | This is a derivation of VisualCortex using SingleChannelSurprise channels |
| VisualEvent | Stores a visual event as a sequence of tokens with additional information |
| VisualEventSet | Set of visual events to which a set of tokens can be matched |
| VisualObject | Describes name and attributes of a visual object |
| VisualObjectDB | VisualObjectDatabase |
| VisualObjectDBQt | Simple GUI to display and browse VisualObjectDB |
| VisualObjectMatch | Simple class to store lists of Keypoint matches between two VisualObject |
| VisualTracker | |
| VisualTrackerI | |
| VisualTrackerI::TopicInfo | |
| VisualTrackerService | |
| VPImage | |
| wave_header | |
| WAVEFORMATEX_avilib | |
| WaypointControllerI | |
| WaypointControllerI::Waypoint | |
| WeightFinder | Weight of the channel is the maximum weight of its subchannels |
| Weights | |
| Weights1D | |
| Weights2D | |
| WeightsAll | |
| WeightsBinomial | |
| WeightsCS | |
| WeightsDerived< Derived > | |
| WeightsDoG | |
| WeightsEmpty | |
| WeightsMask | |
| WeightsUniform | |
| WeirdParamType | |
| WiiMote | |
| WiiMote::SensorData | |
| WiimoteGR::Acceleration | |
| WiimoteGR::Database | |
| WiimoteGR::DBCloser | |
| WiimoteGR::DefaultQuantizer | |
| WiimoteGR::Gesture | |
| WiimoteGR::HMM | |
| WiimoteGR::HMMLib | |
| WiimoteGR::M32Quantizer | |
| WiimoteGR::Quantizer | |
| WiimoteGR::TimeSlot | |
| WinnerTakeAll | The winner-take-all base class |
| WinnerTakeAllAdapter | A partial winner-take-all implementation with a few common member variables |
| WinnerTakeAllConfigurator | WinnerTakeAll configurator |
| WinnerTakeAllFast | A fast winner-take-all |
| WinnerTakeAllGreedy | A greedy attention selection mechanism, not exactly winner-take-all |
| WinnerTakeAllStd | The standard winner-take-all |
| WinnerTakeAllStdOptim | Optimized version of the standard winner-take-all |
| WinnerTakeAllStdOptim::EvolveJob | |
| WinnerTakeAllStub | A do-nothing stub implementation of WinnerTakeAll |
| WinnerTakeAllTempNote | Winner take all adapted for temporal noticing |
| WorkingMemory | |
| WorkThreadServer | Generic low-level thread-server class |
| WorkThreadServer::Checkpoint | |
| WorkThreadServer::JobStats | |
| WorkThreadServer::ThreadData | |
| World2DInput | |
| World3DInput | |
| World3DInput::Object | |
| World3DInput::ObjectsData | |
| WriteJob | An Async Image Writer which works on a separate thread |
| WTAwinner | This is a an open class representing a WTA winner (covert attention shift) |
| XBox360RemoteControl::ControlAxis | |
| XBox360RemoteControl::ControlAxis::Axis | |
| XBox360RemoteControl::ControlAxis::Btn | |
| XBox360RemoteControl::Keys | |
| XBox360RemoteControl::Keys::Actions | |
| XBox360RemoteControl::Keys::Axes | |
| XBox360RemoteControl::Keys::Btns | |
| XBox360RemoteControlI | |
| XCgrabber | |
| XCgrabberFlex | |
| XJunctionChannel | A X junction channel that detects crosses at different |
| XMLInput | |
| xsens::Cmt1f | The low-level file communication class |
| xsens::Cmt1s | The low-level serial communication class |
| xsens::Cmt2f | The mid-level file communication class |
| xsens::Cmt2s | Mid-level serial communication class |
| xsens::Cmt3 | High-level communication class |
| xsens::FifoQueue< T, E > | A FIFO queue with limited length (cyclic) |
| xsens::FifoQueueBasic< T > | A FIFO queue with limited length (cyclic) |
| xsens::Itypes | |
| xsens::JanitorClassFunc< T, R > | Class function calling janitor class |
| xsens::List< T > | Dynamic list class |
| xsens::Message | Class for storing a single message |
| xsens::MessageHeader | A message header |
| xsens::MessageHeader::_mdl | |
| xsens::MessageHeader::_mdl::_mextd | |
| xsens::MessageHeader::_mdl::_mextd::_mlen | |
| xsens::Packet | A structure containing MT data + timestamp and formatting information |
| xsens::Packet::PacketInfo | Contains information about data in the packet and the format of that data |
| XWindow | A simple X-window to display images |
| XWindow::XWinImage | |
| XWinManaged | A window class with active window management |
| YellowBlueChannel | A yellow-blue double-opponent color channel |
| YellowChannel | A yellow double-opponent color channel |
| YuvParser | This class handles reading/parsing of RASFMT_RAW_VIDEO image files |
| YuvParser::Rep | |
| YuvWriter | Write raw yuv image files |
| YUYV | |
| yy_buffer_state | |
| yy_trans_info | |
| yyalloc | |
| yyguts_t | |
| ZeroChannel | Trivial channel that just returns a map full of zeroes |
1.6.3