| _KLT_FloatImageRec | |
| jafar::camera::AbstractCameraHandler | Class CameraHandler |
| jafar::qdisplay::AbstractEventHandler | This the base class for Qt events handler that you want to catch in your scripts |
| jafar::slam::AbstractMapManager | Abstract map manager |
| jafar::slam::AbstractMapObject | Class Abstract Map Object |
| jafar::ddfsimu::AcceleroSimu< T_OBS > | This is an accelerometer for an AccelMotion |
| jafar::ddfsimu::AcceleroSimuCorr | This class implements an accelerometer with correlated noise |
| jafar::ddfsimu::AcceleroSimuUncorr | This class implements an accelerometer with uncorrelated noise |
| jafar::ddfsimu::AccelMotion | Simulate an accelerated motion |
| jafar::ddfsimu::AccProfileItem | This is a point of the acceleration profile of an Accelmotion |
| jafar::rtslam::ActiveSearchGrid | Active search tesselation grid |
| jafar::rtslam::ActiveSegmentSearchGrid | Active search tesselation grid for segments |
| jafar::bundler::Adapter< TRACKERS > | Class Adapter, it acts as an interface between bundler module and detection modules |
| jafar::rtslam::simu::AdhocSimulator | The simulated environment and slam config |
| jafar::rtslam::DataManagerOnePointRansac< RawSpec, SensorSpec, FeatureSpec, RoiSpec, FeatureManagerSpec, DetectorSpec, MatcherSpec >::alg_params_t | |
| jafar::ride::Alloc | Group of threat to be treated by a jammer |
| jafar::gfm_v2::AllTimeTracker< DESCRIPTOR > | Class AllTimeTracker [detects] and matches features over an image sequence |
| jafar::slammm::AlwaysMergeMapsStrategy | This MergeMapsStragegy decide to merge maps whenever two non consecutive maps have overlapping features |
| jafar::facetsmap::Amer | |
| jafar::facetsmap::AmersMap::AmerCandidat | |
| jafar::facetsmap::AmerObservation | |
| jafar::facetsmap::AmersMap | |
| jafar::geom::AngleCovVisitor< dimension > | |
| jafar::geom::AngleCovVisitorImpl< _AtomT_ > | |
| jafar::rtslam::AppearanceAbstract | |
| jafar::rtslam::AppearanceImagePoint | Appearence for matching rtslam |
| jafar::rtslam::simu::AppearanceSimu | |
| jafar::learner::Apprentice | Class Apprentice It launches Harris, Sift or Surf detection on an images' sequence using the appropriate Detector |
| jafar::ride::Area | Store the valid area to place UAVs in the formation |
| jafar::ride::AreaBase | Basic geometric sphere |
| boost::numeric::ublas::array_adaptor< T > | |
| jafar::lgl::astar_goal_visitor< Vertex > | Visitor that terminates when we find the goal template : Vertex is the type of the vertex of boost graph (vertex_descriptor) |
| jafar::geom::Atom< dimension > | Class Atom Atom is the base class of geometric objects |
| jafar::geom::AtomBoundingBoxGetter< _dimension_, _TObject_ > | Example of BoudingBoxGetter for use with VoxelSpace which access an Atom from a _TObject_ which has the following function: const geom::Atom<_dimension_>& _TObject_::atom( ); |
| jafar::geom::AtomVisitor< dimension > | |
| jafar::geom::AtomVisitorInterface< dimension > | |
| jafar::gramer::Attributes | |
| jafar::textures::Attributes | This is the base class for textures attributes computation |
| jafar::lgl::Attributes | |
| jafar::sams::BackgroundAnalysis | This class provide methods to analysis image background |
| jafar::gramer::GeoData::BandDefinition | Definition of a band |
| boost::numeric::ublas::banded_adaptor< M > | |
| boost::numeric::ublas::banded_matrix< T, L, A > | |
| jafar::lgl::base_flexgrid_iterator< value_t, traits > | |
| jafar::filter::BaseCommandPredictModel | Base class for all prediction models with a input command |
| jafar::slam::BaseFeature | Generic feature |
| jafar::slam::BaseFeatureObserveModel | The root class for all feature models |
| jafar::filter::BaseKalmanFilter | Base class for kalman filters |
| jafar::filter::BaseObserveModel | Base class for observation models |
| jafar::filter::BasePredictModel | Base class for all prediction models |
| jafar::slam::BaseRobot | Base robot model |
| jafar::slam::BaseSlam | Base class for Slam algorithms that can be used by managers |
| boost::numeric::ublas::basic_range< Z, D > | |
| boost::numeric::ublas::basic_slice< Z, D > | |
| jafar::slam::BasisFeatureModel | A basis features includes the X,Y,Z coordinates of the origin, plus the raw, yaw and pitch angles |
| jafar::slam::BasisFeatureObserveModel | |
| jafar::slam::BearingOnlyFeatureObserveModel | Bearing only feature observation model |
| jafar::slam::BearingOnlySlam | Bearing only slam |
| jafar::slam::BearingPointFeatureObserveModel | Sizeless point bearing-only observe model |
| jafar::slam::BearingPointInfFeatureObserveModel | Point at infinity bearing-only observe model |
| jafar::slam::BearingPointInvDepthFeatureObserveModel | Sizeless 3D point using the inverse-depth parametrisation, bearings-only sensor |
| jafar::sas::BK_IRT | |
| jafar::sams::BackgroundAnalysis::Bkg | |
| jafar::filter::BlockExtendedKalmanFilter | This class implements an extended Kalman filter to be used for example to solve the SLAM problem |
| jafar::filter::BlockObserveModel | Non linear observation model defined by blocks (two blocks) |
| jafar::slam::BoSlamEventAdapter | Adapter for BoSlam listeners |
| jafar::slam::BoSlamEventListener | Interface for BoSlam listeners |
| boost::numeric::ublas::bounded_array< T, N, ALLOC > | |
| boost::numeric::ublas::bounded_matrix< T, M, N, L > | |
| jblas::bounded_symmetric_matrix< T, M, TRI, L > | Bounded symmetric matrix class |
| boost::numeric::ublas::bounded_vector< T, N > | |
| jafar::geom::BoundingBox< dimension > | A BoundingBox is the smallest box that contains an Atom |
| jafar::geom::Box< T > | |
| jafar::modeler::BPA | BPA is a surface reconstructor for a given points cloud by mean of the Ball Pivoting algorithm from Bernardini and al |
| jafar::bundle::bundleDimension | Container for problem dimensions (Number of cameras, number of 3D points, ...) |
| jafar::bundle::BundleException | Base class for all exceptions defined in the module bundle |
| jafar::bundle::bundleLinearSys | Mathematical part of our Bundle Adjustment implementation |
| jafar::bundle::bundleParameters | Container for bundle parameter storage |
| jafar::bundler::BundlerException | Base class for all exceptions defined in the module bundler |
| jafar::bundle::bundleVariables< Sensor > | Base class for parameters to refine during optimization process The class is templated in order to be generic with rapport to camera model |
| c_euler_std_tf_data_t | Simplified euler transformation in C |
| c_euler_tf_data_t | Euler transformation data in C |
| boost::numeric::ublas::c_matrix< T, N, M > | |
| c_new_map_data_t | Data used to informed the creation of a new map |
| boost::numeric::ublas::c_vector< T, N > | |
| jafar::stereo::CalibrageMatrices | Incapsulates all matrices used in calibrage |
| jafar::calife::CalifeException | Base class for all exceptions defined in the module calife |
| jafar::camera::CameraBarreto | Barreto central catadiopttric camera model |
| jafar::camera::CameraContainer | Class CameraContainer provides container for all available cameras |
| jafar::traversability::CameraDeltaParameters | This struct is used to pre-calculate the ingredients for the geometric homography estimation |
| jafar::camera::CameraException | Base class for all exceptions defined in the module camera |
| jafar::camera::CameraHandler< CAMERA > | Class CameraHandler |
| jafar::traversability::CameraIntrinsicParameters | Struct that contains the intrinsic parameters of the camera used for the pinhole camera model |
| jafar::camera::CameraMask | This class is a generic camera mask |
| jafar::camera::CameraParabolicBarreto | Barreto model specialized for a parabolic mirror |
| jafar::traversability::CameraParameters | Struct that contains all the above mentioned objects |
| jafar::camera::CameraPinhole | Camera Pinhole model |
| jafar::traversability::CameraPoseParameters | Position and pose parameters of the camera frame |
| jafar::facetsmap::CamParam | |
| jafar::gfm_v2::CamShiftTracker | Class CamShiftTracker [detects] and [matches] features over an image sequence |
| jafar::facetsmap::Candidat | |
| jafar::image::Capture | Wrapper around openCV Capture mechanism |
| jafar::slam::CartesianPointFeatureObserveModel | Sizeless point cartesian observe model |
| jafar::rtslam::MapManagerGrid::Cell | |
| jafar::rtslam::VisibilityMap::Cell | |
| jafar::lgl::CellRay | Defintion of a class use to define a ray traversing a cell |
| jafar::lines::CHAINE | |
| jafar::ddf::ChanFltrMsg | |
| jafar::ddf::ChannelFilterBase | Implements a channel filter belonging to node i and connected to another channel filter belonging to node j |
| jafar::sams::Match::checkFeature | |
| jafar::rtslam::ChildOf< Parent > | |
| CholeskyPreconditioner< Matrix > | Decomposes given matrix and solve L L^T x = b |
| jafar::kernel::Chrono | This class functions to measure time consumed by your algorithm |
| jafar::image::clear_ | |
| jafar::gdhe::Client | |
| jafar::kernel::Clock | This function returns an absolute time |
| jafar::viewer3d::Decorator::Color | |
| jafar::rtslam::display::ColorManager | |
| jafar::rtslam::display::colorRGB | |
| jafar::gdhe::ColorRGB | TODO: |
| jafar::ddf::CommBase | This is the base class for channel filter communication |
| jafar::ddf::CommFactoryBase | The base class for the communication factories |
| jafar::ddf::CommFactoryGeneric< T > | The generic class for the communication factories |
| jafar::ddf::CommThreadFunc< PARENT > | Class in charge of listening to a communication channel (continuously call the function Read) |
| jafar::spaf::ComparisonResult | Holds information about the comparison between two object, be it two Feature or two Location |
| jafar::klt::CompatTreatment | |
| jafar::ride::Config | Full Configuration of the formation, computes the next Slots config at each step |
| ConfigEstimation | |
| jafar::datareader::ConfigReader | Class ConfigReader used to verify user input for a process over a sequence |
| ConfigSetup | |
| jafar::ride::configState | Config state data |
| jafar::sas::Conspicuity | Base class for conspicuity computation |
| jafar::lgl::const_flexgrid_iterator< value_t > | |
| jafar::image::const_image_iterator< type > | |
| boost::numeric::ublas::basic_range< Z, D >::const_iterator | |
| boost::numeric::ublas::basic_slice< Z, D >::const_iterator | |
| boost::numeric::ublas::indirect_array< A >::const_iterator | |
| boost::numeric::ublas::vector< T, A >::const_iterator | |
| boost::numeric::ublas::zero_vector< T >::const_iterator | |
| boost::numeric::ublas::unit_vector< T >::const_iterator | |
| boost::numeric::ublas::scalar_vector< T >::const_iterator | |
| boost::numeric::ublas::c_vector< T, N >::const_iterator | |
| boost::numeric::ublas::banded_matrix< T, L, A >::const_iterator1 | |
| boost::numeric::ublas::banded_adaptor< M >::const_iterator1 | |
| boost::numeric::ublas::matrix< T, L, A >::const_iterator1 | |
| boost::numeric::ublas::vector_of_vector< T, L, A >::const_iterator1 | |
| boost::numeric::ublas::zero_matrix< T >::const_iterator1 | |
| boost::numeric::ublas::identity_matrix< T >::const_iterator1 | |
| boost::numeric::ublas::scalar_matrix< T >::const_iterator1 | |
| boost::numeric::ublas::c_matrix< T, N, M >::const_iterator1 | |
| boost::numeric::ublas::symmetric_matrix< T, TRI, L, A >::const_iterator1 | |
| boost::numeric::ublas::symmetric_adaptor< M, TRI >::const_iterator1 | |
| boost::numeric::ublas::banded_matrix< T, L, A >::const_iterator2 | |
| boost::numeric::ublas::banded_adaptor< M >::const_iterator2 | |
| boost::numeric::ublas::matrix< T, L, A >::const_iterator2 | |
| boost::numeric::ublas::vector_of_vector< T, L, A >::const_iterator2 | |
| boost::numeric::ublas::identity_matrix< T >::const_iterator2 | |
| boost::numeric::ublas::zero_matrix< T >::const_iterator2 | |
| boost::numeric::ublas::scalar_matrix< T >::const_iterator2 | |
| boost::numeric::ublas::c_matrix< T, N, M >::const_iterator2 | |
| boost::numeric::ublas::symmetric_matrix< T, TRI, L, A >::const_iterator2 | |
| boost::numeric::ublas::symmetric_adaptor< M, TRI >::const_iterator2 | |
| jafar::ddfsimu::demo::Const_speed_predict_model | |
| jafar::filter::ConstantVelocityKalmanFilter | Kalman filter for an one dimensional constant velocity model |
| jafar::dseg::ConstantVelocityPredictor | It's a Predictor that use a Constant Velocity model to predict the next postion of a segment |
| jafar::lines::ConstPositionKF | Kalman filter for an one dimensional constant position model |
| jafar::ride::Constraint | Generic constraint |
| jafar::ride::ConstraintCorridor | Corridor width constraint |
| jafar::ride::ConstraintDefence | Defence constraint tells if a threat should be taken into account |
| jafar::ride::ConstraintDmax | Maximum distance constraint |
| jafar::ride::ConstraintDmin | Minimum distance constraint |
| jafar::ride::ConstraintFormation | Formation configuration constraint impose a geometric configuration with tags on the slots |
| jafar::ride::ConstraintSplit | Split constraint for split and join maneuvers |
| jafar::image::ConvexRoi | |
| jafar::textures::CoOccuringAttributes | Implement the algorithm of computation of attributes using the matrix of cooccurence described by Haralick et al in "Textural Features for Image Classification" ( "IEEE Transactions on Systems, Man, and Cybernetics", 1973) |
| jafar::dseg::CopyPredictor | It's a Predictor that "grow" the covariance of the predictor from a given amount |
| jafar::traversability::Core | This is the central object combining the specific functionalities of the utility objects of this module |
| jafar::rtslam::ExtendedKalmanFilterIndirect::CorrectionStack | |
| jafar::stereo::CorrelationParams | Contains all parameters needed for Rectification |
| jafar::stereo::CorrelationResults | Contains the result of Correlation |
| jafar::correl::CorrelException | Base class for all exceptions defined in the module correl |
| jafar::geom::CosAngleCovVisitor< dimension > | |
| jafar::geom::CosAngleCovVisitorImpl< _AtomT_ > | |
| jafar::stereosimu::CosSin | A structure to store correspondance between angle and their cos / sin |
| jafar::lgl::CostManager | Cost manager take care of the cost computing between two given ADJACENT positions in a graph and conversion between the cost and the time taken by the robot to travel this edge |
| jafar::rtslam::DataManagerOnePointRansac< RawSpec, SensorSpec, FeatureSpec, RoiSpec, FeatureManagerSpec, DetectorSpec, MatcherSpec >::Counters | |
| jafar::rtslam::ObservationAbstract::Counters | Counters |
| jafar::sas::CParams | |
| jafar::sas::CS_IRT | Class CS_IRT |
| jafar::ddfsimu::CstAccPredictModelFactory | The factory for constant acceleration models |
| jafar::ddfsimu::CstAccPredParams | |
| jafar::ddfsimu::demo::CstPosePredictModelFactory | |
| jafar::ddfsimu::CstSpeedPredictModelFactory | |
| jafar::ddfsimu::CstSpeedPredParams | |
| jafar::kernel::CSVFile | Read a file containing comma separated values statements with or without first line as title |
| jafar::kernel::CSVFileLoad | Interface of an object which can be loaded using the CSVFile mechanism |
| jafar::kernel::CSVFileSave | Interface of an object which can be saved using the CSVFile mechanism |
| jafar::kernel::CSVFileSaveLoad | Interface of an object which can both be loaded and saved using the CSVFile mechanism |
| jafar::jmath::CubicInterpolate | Cubic interpolation of 1D function |
| jafar::cutter::CutterException | Base class for all exceptions defined in the module cutter |
| jafar::sas::CV_IRT | |
| jafar::sas::CV_IRT_BlobDetector | |
| jafar::slam::DalaManager | Class for managing Dala |
| jafar::lgl::Danger | |
| jafar::velodyneutils::Data< DataType > | |
| jafar::sift::DataBase | Very basic database of SIFT points |
| jafar::fusion::DataLoad | |
| jafar::kernel::DataLoggable | Interface DataLoggable |
| jafar::kernel::DataLogger | This object logs data in a single log file |
| jafar::rtslam::DataManagerAbstract | |
| jafar::rtslam::DataManagerOnePointRansac< RawSpec, SensorSpec, FeatureSpec, RoiSpec, FeatureManagerSpec, DetectorSpec, MatcherSpec > | This class implements the one-point-Ransac ActiveSearch strategy |
| jafar::traversability::DataProvider | The class DataProvider is an interface between the modules 'datareader' and 'traversability' |
| jafar::datareader::DataReader | This class is used to start accessing the data from a directory following the pelican specification |
| jafar::datareader::DatareaderException | Base class for all exceptions defined in the module datareader |
| jafar::lgl::DataType< T > | |
| jafar::lgl::DataType< double > | |
| jafar::lgl::DataType< float > | |
| jafar::lgl::DataType< unsigned char > | |
| jafar::lgl::DataType< unsigned int > | |
| jafar::slampt::DBFrame | An image frame as recorded in the frame database |
| jafar::slampt::DBFrameLandmark | An image point as recorded in the frame database |
| jafar::sift::DBKey | Key entry for the database |
| jafar::ddf::DdfException | Base class for all exceptions defined in the module ddf |
| jafar::ddfsimu::DdfsimuException | Base class for all exceptions defined in the module ddfsimu |
| jafar::debug::DebugStream | Debug message stream |
| jafar::lgl::Decomp | The geometric decomposition (quadtree, bintree or any rectangular-pattern based decomposition) |
| jafar::lgl::Decomp_iterator | Iterate over all clusters of the decomposition by iterating over grid cell from (xbegin,ybegin),(xend-1,yend-1) |
| jafar::lgl::DecompCluster | |
| jafar::viewer3d::Decorator | This is a base class for Decorator which allowed to control the color used for objects in clouds (PointsCloud , SegmentsCloud , FacetsCloud ...) |
| jafar::slam::DefaultMapManager | Default map manager |
| jafar::slam::DefaultMapManagerFactory | |
| jafar::jmath::Delaunay | |
| jafar::delaunay::Delaunay | ! Delaunay class |
| jafar::delaunay::DelaunayException | Base class for all exceptions defined in the module delaunay |
| jafar::geom::DenseOG | |
| jafar::traversability::Densificator | The Densificator is the unit that retrieves dense traversability information given the image I_i and the projection I_i^j of image I_j |
| jafar::facetsmap::DensityMap | |
| jafar::fdetect::Descriptor | This class is the base class of all descriptors |
| jafar::fdetect_v2::Descriptor | This class is the base class of all descriptors |
| jafar::spaf::Descriptor | |
| jafar::rtslam::DescriptorAbstract | |
| jafar::sams::DescriptorFactory | |
| jafar::fdetect::DescriptorFactory | This class is used by Engine to associate a descriptor with an interespoint |
| jafar::fdetect_v2::DescriptorFactory< InterestFeatureT > | This class is used by Engine to associate a descriptor with an interespoint |
| jafar::rtslam::DescriptorFactoryAbstract | |
| jafar::rtslam::DescriptorImagePointFirstView | This descriptor for image points only keeps the appearance of the feature the first time it was viewed |
| jafar::rtslam::DescriptorImagePointFirstViewFactory | |
| jafar::rtslam::DescriptorImagePointMultiView | This descriptor for image points stores appearances of the feature from different points of view |
| jafar::rtslam::DescriptorImagePointMultiViewFactory | |
| jafar::spafdb::DescriptorMatchQuery | This query return matches using only the spafgraph::NodeDescriptor comparison, this is individual matches |
| jafar::gfm_v2::DescriptorsBasedMatcher< InterestFeatureT > | This class implements a variation of Jung group matching algorithm |
| jafar::rtslam::DescriptorSegFirstView | This descriptor for image points only keeps the appearance of the feature the first time it was viewed |
| jafar::rtslam::DescriptorSegFirstViewFactory | |
| jafar::rtslam::simu::DescriptorSimu | |
| jafar::gfm_v2::DescriptorsBasedMatcher< InterestFeatureT >::DescriptorsMatchSourceInfo | |
| jafar::rtslam::display::ThreadSafeGarbageCollector< T >::Destroy | |
| detection_data | Holds feature data relevant to detection |
| jafar::fdetect::DetectionResult | This function stores the results of the interest feature detection |
| jafar::fdetect_v2::DetectionResult< InterestFeatureT > | This function stores the results of the interest feature detection |
| jafar::sams::Detector | |
| jafar::fdetect::Detector | This is the base class of a detector of interest points (like harris points) |
| jafar::fdetect_v2::Detector< FeatureT > | This is the base class of a detector of interest points (like harris points) |
| jafar::rtslam::ImagePointHarrisDetector::detector_params_t | |
| jafar::rtslam::simu::DetectorSimu< RoiSpec >::detector_params_t | |
| jafar::rtslam::simu::DetectorSimu< RoiSpec > | |
| boost::numeric::ublas::diagonal_adaptor< M > | |
| boost::numeric::ublas::diagonal_matrix< T, L, A > | |
| DiagonalPreconditioner< Matrix > | Scales x with diagonal of a given matrix |
| jafar::textures::DiffSumAttributes | Implement the algorithm of computation of attributes using an array of difference as described by Unser and Eden in "Multiresolution Feature Extraction and Selection for Texture Segmentation" ( "IEEE Transactions on Pattern Analysis and Machine Intelligence", 1989) |
| jafar::dseg3d::DirectSegments3DTracker | This is the main class for detecting and tracking 3D segments |
| jafar::dseg::DirectSegmentsBase | Base class for algorithms that wants to use the segment growing algorithm, for detection or tracking |
| jafar::dseg::DirectSegmentsDetector | This is the main class for detection segments in an image |
| jafar::dseg::DirectSegmentsDetectorBase | This is the base class for write a segment detector |
| jafar::dseg::DirectSegmentsTracker | This class implement a tracker of a segment, that were first detected using (DirectSegmentsDector or HierarchicalDirectSegmentsDector ) |
| jafar::dseg::DirRotationProbability2SegmentProbabilityEstimator | |
| jafar::dseg::DirRotationProbabilitySegmentProbabilityEstimator | |
| jafar::display::Display | |
| jafar::spaf::DisplayContext | |
| jafar::rtslam::display::DisplayDataAbstract | ************************************************************************** This is the base class for objects that will store display data for a viewer |
| jafar::display::DisplayException | Base class for all exceptions defined in the module display |
| jafar::geom::DistanceCovVisitor< dimension > | |
| jafar::geom::DistanceCovVisitorImpl< _AtomT_ > | |
| jafar::spafdb::DistanceProximityStrategy | This ProximityStrategy creates spafgraph::ProximitiesEdges between spafgraph::Node based on their distance |
| jafar::jmath::DNode | |
| jafar::delaunay::DNode | ! Node class |
| jafar::sams::DOGDetector | |
| jafar::fdetect::DoubleDescriptor | Generic descriptor based on a double array (for instance SIFT or SURF) |
| jafar::geom::Atom< dimension >::Driver | This is the base class for all geometric objects Drivers |
| jafar::geom::HyperPlane< dimension >::Driver | HyperPlane is the base Driver for all HyperPlane::Driver |
| jafar::geom::Line< dimension >::Driver | Base class of Drivers for a Line |
| jafar::geom::OrientedPlan< dimension >::Driver | The extra function needed to build a repere out on top of an hyperplan |
| jafar::geom::Point< dimension >::Driver | Class Driver Base class for driver of a point |
| jafar::geom::PolyLine< dimension >::Driver | |
| jafar::geom::Repere< dimension >::Driver | |
| jafar::geom::Segment< dimension >::Driver | Base class for the drivers of Segment |
| jafar::dseg3d::Dseg3dException | Base class for all exceptions defined in the module dseg3d |
| jafar::dseg::DsegException | Base class for all exceptions defined in the module dseg |
| jafar::dtm::Dtm | A wrapper for the calife DTM data struct |
| jafar::dtm::DtmException | Base class for all exceptions defined in the module dtm |
| jafar::graphmap::DummyMappingProcess | |
| jafar::graphmap::display::Edge | |
| jafar::spafgraph::Edge | |
| jafar::graphmap::Edge_Properties | |
| jafar::modeler::KinectModeler::edge_type | |
| jafar::spafgraph::EdgeProximity | This class represents a proximity edges between two Node |
| jafar::gml::ElementsLists | |
| jafar::traversability::Ellipse | |
| jafar::gdhe::Ellipsoid | |
| jafar::qdisplay::Ellipsoid | This class allow to display the uncertainty ellipsoid around a point |
| jafar::gdhe::EllipsoidWire | |
| jafar::image::endl_ | |
| jafar::hpm::Engine | HpmEngine encapsulates harris and ipm |
| jafar::sams::Engine | |
| jafar::sas::Engine | |
| jafar::locpano::Engine | Locpano engine |
| jafar::premodeler::Engine | Class Engine It launches Harris, Sift or Surf detection on an images' sequence using the appropriate Detector |
| jafar::gfm::Engine | You can use this class to match two images |
| jafar::gfm_v2::Engine< InterestFeatureT > | You can use this class to match two images |
| jafar::gfm::EngineCustom | This class is a matcher and tracker that allows to modify interest points that are used |
| jafar::gfm::EngineOfflineTracking | This class can be used to track features in a sequence of images |
| jafar::gfm::EngineStereoTracking | This class can be used to track features in a sequence of stereo images |
| jafar::gfm_v2::EngineStereoTracking< InterestFeatureT > | This class can be used to track features in a sequence of stereo images |
| jafar::gfm::EngineTracking | This class can be used to track features in a sequence of images |
| jafar::gfm_v2::EngineTracking< InterestFeatureT > | This class can be used to track features in a sequence of images |
| jafar::simu::Environment | A basic environment containing a collection of points and segments and a robot |
| jafar::geom::HyperPlane< dimension >::EquationDriver | |
| jafar::rtslam::hardware::HardwareSensorInertialAdhocSimulator::estimator_params_t | |
| jafar::geom::Line< dimension >::EuclideanDriver | An EuclideanDriver for a Line is used for Lines known from their origin (a point of the line) and the direction verctor |
| jafar::geom::Point< dimension >::EuclideanDriver | Class EuclideanDriver Euclidean Driver for a point that is defined by its absolute coordinates |
| jafar::graphmap::euler_std_tf_data_t | |
| jafar::graphmap::euler_tf_data_t | |
| jafar::rtslam::ObservationAbstract::Events | Events |
| jafar::ddfsimu::EventSimu | Used to trigger periodic events in a simulation |
| jafar::kernel::Exception | Base class for all exceptions defined in jafar |
| jafar::velodyneutils::Executive | |
| jafar::velodyneutils::ExecutiveFrameTransformer< PointT > | **************************************************************************** ExecutiveFrameTransformer |
| jafar::velodyneutils::ExecutiveNormalEstimatorImages3D< PointInT, PointOutT > | **************************************************************************** ExecutiveNormalEstimatorImages3D |
| jafar::velodyneutils::ExecutivePassThrough< PointT > | **************************************************************************** ExecutivePassThrough |
| jafar::velodyneutils::ExecutivePointCloudClassifier< PointT > | **************************************************************************** ExecutivePointCloudClassifier |
| jafar::velodyneutils::ExecutivePointCloudMapper< PointT > | **************************************************************************** ExecutivePointCloudMapper |
| jafar::velodyneutils::ExecutiveReader3DImage | **************************************************************************** ExecutiveReader3DImage |
| jafar::velodyneutils::ExecutiveReaderPosition | **************************************************************************** ExecutiveReaderPosition |
| jafar::velodyneutils::ExecutiveReaderRegionMap | **************************************************************************** ExecutiveReaderRegionMap |
| jafar::velodyneutils::ExecutiveReaderVelodyneImage3D | **************************************************************************** ExecutiveReaderVelodyneImage3D |
| jafar::velodyneutils::ExecutiveRegionMapEstimator< PointInT > | **************************************************************************** ExecutiveRegionMapEstimator |
| jafar::velodyneutils::ExecutiveToHDL< PointInT > | **************************************************************************** ExecutiveToHDL |
| jafar::velodyneutils::ExecutiveVisualizerCloud< PointT > | **************************************************************************** ExecutiveVisualizerCloud |
| jafar::velodyneutils::ExecutiveVisualizerNormals< PointT > | **************************************************************************** ExecutiveVisualizerNormals |
| jafar::velodyneutils::ExecutiveWriterPCD< PointT > | **************************************************************************** ExecutiveWriterPCD |
| jafar::rtslam::Expectation | Base class for all Gaussian expectations defined in the module rtslam |
| jafar::correl::Explorer< Correl > | |
| jafar::rtslam::ExporterAbstract | |
| jafar::rtslam::ExporterPoster | |
| jafar::rtslam::ExporterSocket | |
| jafar::filter::ExtendedKalmanFilter | This class implements an Extended Kalman filter |
| jafar::fusion::ExtendedKalmanFilterFusion | |
| jafar::filter::ExtendedKalmanFilterImplicit | This class implements an Extended Kalman filter for Implicit observation function |
| jafar::rtslam::ExtendedKalmanFilterIndirect | Base class for Kalman filters |
| jafar::rtslam::hardware::ExtLoc | |
| jafar::ddfsimu::ExtValStruct | |
| jafar::facetsmap::Facet | This class holds the information concerning a facet |
| jafar::geom::Facet< dimension > | |
| jafar::spaf::Facet3DFeature | Class to contains a 3D facet |
| jafar::facetsmap::FacetObservation | |
| jafar::facetsmap::FacetsAnalyser | |
| jafar::facetsmap::FacetsCloseness | |
| jafar::viewer3d::FacetsCloud | This class allows to display a cloud of Facet3D in a Viewer3D |
| jafar::facetsmap::FacetsContainer | This class is intended to store the facets |
| jafar::facetsmap::FacetsDetector | |
| jafar::facetsmap::FacetsGroup | |
| jafar::facetsmap::FacetsGroupBase | |
| jafar::facetsmap::FacetsMap | |
| jafar::facetsmap::FacetsmapException | Base class for all exceptions defined in the module facetsmap |
| jafar::facetsmap::FacetsMatch | This class is a proof of concept to demonstrates how matching of facets work |
| jafar::facetsmap::FacetsMatcher | |
| jafar::facetsmap::FacetsParams | |
| jafar::facetsmap::FacetsTrack | A track |
| jafar::facetsmap::FacetsTracker | |
| jafar::facetsmap::FacetsTrackingResult | Results of tracking |
| jafar::correl::FastTranslationMatcherZncc | |
| jafar::correl::FastZncc | Compared to Zncc, remove some robustness features, but add a lot of optimizations |
| jafar::fdetect::FdetectException | Base class for all exceptions defined in the module fdetect |
| jafar::sams::Feature | |
| feature | Structure to represent an affine invariant image feature |
| jafar::spaf::Feature | This class represents a geometric feature |
| jafar::rtslam::FeatureAbstract | Base class for all landmark appearances defined in the module rtslam |
| jafar::rtslam::FeatureImagePoint | Base class for all landmark appearances defined in the module rtslam |
| jafar::slam::FeatureModel | This class defines a generic feature model |
| jafar::slam::FeatureObserveModel | Fully observable feature observe model |
| jafar::gfm_v2::AllTimeTracker< DESCRIPTOR >::features_comp | Compare 2 interest features lhf and rhf |
| jafar::spaf::FeaturesBag | This class holds a list of features |
| jafar::slammm::FeaturesCountStartNewMapStrategy | This StartNewMapStrategy starts a new map whenever the number of features in the current map is bigger than a given number of features |
| jafar::spaf::FeaturesDetector | This is the base class for features detection |
| jafar::rtslam::simu::FeatureSimu | |
| jafar::spaf::FeaturesTracker | |
| jafar::rtslam::FeatureView | A feature view, storing the feature appearance and the conditions that correspond to this appearance |
| jafar::kernel::FifoMutex | This class implements a mutex with FIFO scheduling policy, based on boost mutexes and semaphores |
| jafar::traversability::FileInfoDataSet | The struct is used to pass information about the data sources (images, pose data) stored in the pelicanformat |
| jafar::filter::FilterException | Base class for all exceptions defined in the module filter |
| jafar::geom::VoxelSpace< _dimension_, _TObject_, _BoundingBoxGetter_ >::FindObjectsFunctor | This functor is used to retrieve all objects inside a bounding box |
| jafar::geom::VoxelSpace< _dimension_, _TObject_, _BoundingBoxGetter_ >::FindVoxelsFunctor | This functor is used to find all the voxels inside a bounding box |
| jafar::lgl::FlexGrid< value_t > | |
| jafar::lgl::flexgrid_const_iterator_traits< blah > | |
| jafar::lgl::flexgrid_iterator< value_t > | |
| jafar::lgl::flexgrid_iterator_traits< blah > | |
| jafar::lgl::flexgrid_traits< value_t > | |
| jafar::stereo::FloatBuffer | |
| jafar::fdetect::FloatDescriptor | Generic descriptor based on a float array (for instance SIFT or SURF) |
| jafar::image::flush_ | |
| jafar::kernel::details::ForeachInfo< T > | |
| jafar::kernel::details::ForeachInfoBase | |
| jafar::ride::Formation | List of UAVs state and formation parameters |
| jafar::ride::FormationCommand | FormationCommand only contains information for formation control |
| jafar::ride::formCmd | Formation command |
| jafar::ride::formExtraState | Extra aircraft state for UAVs not in the formation |
| jafar::ride::formParam | Parameters distributed control |
| jafar::lgl::found_goal | The planner works over a navigation graph structure |
| jafar::sams::Frame | |
| jafar::gdhe::Frame | |
| jafar::slampt::FrameDataBase | Generic frame database for loop closing |
| jafar::kernel::FrameRate | Class to generate framerate data |
| jafar::velodyneutils::FrameTransformer< PointT > | **************************************************************************** FrameTransformer |
| jafar::slam::FreeStateCollector | This class acts as a collector of free state in the SLAM |
| jafar::ddfsimu::demo::FSStorage | |
| jafar::ddf::FSStorageBase< PARAMS > | |
| jafar::slam::Full3dPredictModel | Full 3d predict model |
| jafar::fusion::FusionException | Base class for all exceptions defined in the module fusion |
| jafar::image::GaborPyramid | |
| jafar::rtslam::HistoryManagerSparse::Gate | |
| jafar::rtslam::Gaussian | Class for Gaussians having LOCAL or REMOTE storage |
| jafar::image::GaussianPyramid | |
| jafar::jmath::GaussianVector | A simple gaussian vector represented by its mean and covariance |
| joptimization::methods::GaussNewton< _TFunction_, _TType_ > | Use this class as a template parameter for the gaussNewton function if you want to use the Gauss-Newton method which uses only the jacobian |
| jafar::ride::GC | Global constant definition for default values |
| jafar::gdal::GdalException | Base class for all exceptions defined in the module gdal |
| GdheClient | Client interface for GDHE (terrible code, to be completely rewritten) |
| jafar::gdhe::GdheException | Base class for all exceptions defined in the module gdhe |
| jafar::lgl::GDInfoBand | Traversability raster band, data type in double [0,1.0] expressing the traversability probability of each raster cell |
| jafar::lgl::GDLandmarkBand | |
| jafar::lgl::GDRasterBand< T > | Traversability raster band, data type in unsigned char (0-255) expressing the trav probability of each raster cell |
| jafar::rtslam::WeakParentOf< Child >::generic_iterator< basic_iterator > | |
| jafar::gramer::GeoData | Class for GDAL data handling |
| jafar::lgl::GeoData | Class for GDAL data handling |
| jafar::geom::GeometricObject< dimension > | |
| jafar::geom::GeomException | Base class for all exceptions defined in the module geom |
| jafar::geomslam::GeomslamException | Base class for all exceptions defined in the module geomslam |
| jafar::gfm::GfmException | Base class for all exceptions defined in the module gfm |
| jafar::icp::GICP | Class GICP stands for Generalized ICP It is implementation of algorithm described in Generalized-ICP, Aleksandr V |
| jafar::sams::GIFTFactory | |
| jafar::ride::GlobalAlloc | List of all Alloc on the trajectory |
| jafar::slam::GlobalMapManager | Global (long term) map manager |
| jafar::slam::GlobalMapManagerFactory | |
| jafar::graphmap::GlobalRobotPoseOutputManager | |
| jafar::rtslam::SensorManagerOnline::GlobalStats | |
| jafar::ride::GlobalThreat | List of threats |
| jafar::gml::GmlException | Base class for all exceptions defined in the module gml |
| jafar::ddfsimu::GPSSimu< T_OBS > | A GPS sensor |
| jafar::ddfsimu::GPSSimuCorr | |
| jafar::ddfsimu::GPSSimuUncorr | |
| jafar::cutter::Grabber | Class Grabber This class operates on an image and extracts the region of interest on either a clear or a dark region |
| jafar::dseg::GradientsDescriptor | |
| jafar::dseg::GradientStatsDescriptor | |
| jafar::gramer::GramerException | Base class for all exceptions defined in the module gramer |
| jafar::spafgraph::Graph | The Graph is the root node containing all nodes |
| jafar::graphmap::Graph_Properties | |
| jafar::graphmap::GraphManager | |
| jafar::graphmap::GraphManagerAbstract | |
| jafar::graphmap::GraphmapException | Base class for all exceptions defined in the module graphmap |
| jafar::spafdb::GraphMatchQuery | |
| jafar::lgl::GraphPath< Vertex > | Path inside the graph |
| jafar::quasidense::greaterSimilScore | |
| jafar::sams::GreyDescFactory | |
| jafar::gdhe::Grid | |
| jafar::viewer3d::Grid | This class allows to add a grid to a view |
| jafar::model3d::Grid2D | |
| jafar::model3d::Grid3D | Uniform grid 3D it is formed of Grid3DCell we use a Image3D to build the grid we use RansacPlane to fit the plane in each cell |
| jafar::model3d::Grid3DCell | One cell in the Grid3D |
| jafar::gfm::GroupsMatcher::Group | |
| jafar::gfm_v2::GroupsMatcher< InterestFeatureT >::Group | |
| jafar::spaf::GroupFeature | |
| jafar::gfm::GroupsMatcher::GroupMatchHypothesis | |
| jafar::gfm_v2::GroupsMatcher< InterestFeatureT >::GroupMatchHypothesis | |
| jafar::gfm::GroupsMatcher::Group::GroupMember | |
| jafar::gfm_v2::GroupsMatcher< InterestFeatureT >::Group::GroupMember | |
| jafar::spafdb::GroupProximityStrategy | This ProximityStrategy creates spafgraph::ProximitiesEdges between spafgraph::Node belonging to the same spaf::GroupFeature |
| jafar::gfm::GroupsMatcher | This class implements a variation of Jung group matching algorithm |
| jafar::gfm_v2::GroupsMatcher< InterestFeatureT > | This class implements a variation of Jung group matching algorithm |
| jafar::facetsmap::GroupsMatching | |
| jafar::gfm::GroupsMatcher::GroupsMatchSourceInfo | |
| jafar::gfm_v2::GroupsMatcher< InterestFeatureT >::GroupsMatchSourceInfo | |
| jafar::dseg::GrowSegmentContext | |
| jafar::dseg::GrowStopCondition | This class control when the segment detection should stop growing a segment |
| jafar::rtslam::hardware::HardwareEstimatorAbstract | |
| jafar::rtslam::hardware::HardwareEstimatorOdo | |
| jafar::rtslam::hardware::HardwareSensorAbstract< T > | Generic implementation of hardware sensor based on ring buffer |
| jafar::rtslam::hardware::HardwareSensorAdhocSimulator | |
| jafar::rtslam::hardware::HardwareSensorCamera | This class allows to get images from firewire with non blocking procedure, using triple-buffering |
| jafar::rtslam::hardware::HardwareSensorCameraFirewire | This class allows to get images from firewire with non blocking procedure, using triple-buffering |
| jafar::rtslam::hardware::HardwareSensorCameraUeye | This class allows to get images from firewire with non blocking procedure, using triple-buffering |
| jafar::rtslam::hardware::HardwareSensorExternalLoc | |
| jafar::rtslam::hardware::HardwareSensorExteroAbstract | |
| jafar::rtslam::hardware::HardwareSensorGpsGenom | |
| jafar::rtslam::hardware::HardwareSensorInertialAdhocSimulator | |
| jafar::rtslam::hardware::HardwareSensorMocap | |
| jafar::rtslam::hardware::HardwareSensorMti | |
| jafar::rtslam::hardware::HardwareSensorOdomRmp400Genom | |
| jafar::rtslam::hardware::HardwareSensorProprioAbstract | |
| jafar::fdetect::HarrisDescriptor | This class implements a descriptor using the cornerness of Harris for weak comparison, and a zncc score for strong comparison |
| jafar::fdetect_v2::HarrisDescriptor | This class implements a descriptor using the cornerness of Harris for weak comparison, and a zncc score for strong comparison |
| jafar::fdetect::HarrisDetector | This class is the implements a detector of Harris points as described in : "A Combined
Corner and Edge Detector" par C |
| jafar::fdetect::HarrisLaplaceDetector | |
| jafar::hpm::HarrisPoint | Represent an interest point in an image |
| jafar::fdetect::HarrisDetector::HData | |
| jafar::slam::HeadingPointObservationsSelector | |
| jafar::helloworld::HelloWorld | HelloWorld class |
| jafar::helloworld::HelloworldException | Base class for all exceptions defined in the module helloworld |
| jafar::helloworld::HelloworldFormatException | Hello attribute not initialized |
| jafar::dseg::HierarchicalDirectSegmentsDetector | This is the main class for detection segments in an image |
| HistoFam | |
| jafar::spafgraph::NodeDescriptor::Histogram | |
| jafar::lines::Histogram | Wrap cvHistogram |
| HistoHeader | |
| HistoResult | |
| jafar::rtslam::HistoryManagerAbstract | |
| jafar::rtslam::HistoryManagerSparse | This class will manage a sparse history |
| jafar::traversability::HomMat | |
| jafar::geom::Point< dimension >::HomogenousDriver | |
| jafar::traversability::Homography | Homography is the base class for HomographyGeom, HomographyFine and HomographyMosaic |
| jafar::homography::HomographyEstimator | This is the base class of HomographyEstimator |
| jafar::homography::HomographyException | Base class for all exceptions defined in the module homography |
| jafar::traversability::HomographyFine | HomographyFine inherits from Homography |
| jafar::traversability::HomographyGeom | This class inherited from class Module homography and performs the calculation of an homography given the related camera poses, the intrinsic camera parameters and the plane parameters |
| jafar::traversability::HomographyMosaic | HomographyMosaic inherits from Homography |
| jafar::traversability::HomographyOld | |
| jafar::hseg::HoughSegment | Segment coordinates |
| jafar::hseg::HoughSegmentsDetector | Detect segments using the Probabilistic Hough method |
| jafar::hpm::HpmException | Base class for all exceptions defined in the module hpm |
| jafar::hpm::HpmGroup | This class hold the information about a group of points |
| jafar::rtslam::QuickHarrisDetector::HQuickData | |
| jafar::hseg::HsegException | Base class for all exceptions defined in the module hseg |
| jafar::image::hsep_ | |
| jafar::geom::HyperPlane< dimension > | An HyperPlane is a space of dimension (n-1), this correspond to a Plan in dimension 3 and to a Line in dimension 2 |
| jafar::rtslam::ObservationAbstract::Hypothesis | |
| jafar::sams::Hypothesis | |
| jafar::icp::IcpException | Base class for all exceptions defined in the module icp |
| jafar::kernel::IdCollectorList< T > | This collector correctly collects all ids, but does not perform all sanity checks, in particular it does not check if the released id was really taken Memory complexity: linear in number of collected ids Time complexity: constant |
| jafar::kernel::IdCollectorNone< T > | Forward declarations (cannot forward default parameters): |
| jafar::kernel::IdCollectorSet< T > | This collector correctly collects all ids, defragments, and performs all sanity checks Memory complexity: linear in number of collected ids, with defragmentation Time complexity: constant except releaseId that is logarithmic in number of collected ids, and defrag that can be linear in some cases |
| boost::numeric::ublas::identity_matrix< T > | |
| IdentityPreconditioner< MATRIX > | Do-nothing preconditioner |
| jafar::kernel::IdFactory< T, IdCollector > | This class allows to create an unique id |
| jafar::slampt::IdImagePointManager | Class for doing bearing-only slam with a monocular camera and when features are interest points extracted from an image using Inverse Depth parameterization |
| jafar::slampt::IdOmniImagePointManager | Class for doing bearing-only slam with an omni camera and when features are interest points extracted from an image using Inverse Depth parameterization |
| jafar::slampt::ImagePointManager::IdPredicate | |
| jafar::premodeler::IFManager | Class IFManager This class handle the detection result of premodeler::Engine and reorganise it in a better way for light bundle adjustment |
| jafar::image::Image | |
| jafar::calife::Image3d | |
| jafar::model3d::Image3DTemplate< PointType > | This template class is the base for all Image3D class |
| jafar::image::image_iterator< type > | |
| jafar::slam::ImageAnchorPluckerFeatureObserveModel | 3D segments using the anchored plucker parametrisation observed in a perspective image |
| jafar::slam::ImageEuclideanPluckerFeatureObserveModel | Segment extracted from an image observe model |
| jafar::image::ImageException | Base class for all exceptions defined in the module image |
| jafar::homography::ImageGradients | |
| jafar::slamlines::ImageHomogenCoordSegmentManager | |
| jafar::traversability::ImageInfo | Struct that contains some information about the images that are used for the module |
| jafar::image::ImageIO | I/O methods for Image serialization to file |
| jafar::slam::ImagePluckerFeatureObserveModel | Sizeless 3D segment using the homogenous coordinates parametrisation observed in a perspective image |
| jafar::slam::ImagePointFeatureObserveModel | Sizeless point from perspective image observe model |
| jafar::rtslam::ImagePointHarrisDetector | |
| jafar::slam::ImagePointInvDepthFeatureObserveModel | Sizeless 3D point using the inverse-depth parametrisation observed in a perspective image |
| jafar::slampt::ImagePointManager | Base class for doing slam using points extracted in an image |
| jafar::rtslam::ImagePointObservationMaker< ObsType, SenType, LmkType, AppType, SenTypeId, LmkTypeId > | |
| jafar::rtslam::ImagePointZnccMatcher | |
| jafar::image::ImagePreprocessor | This node contains a list of image preprocessor |
| jafar::image::ImagePreprocessorNode | Virtual interface to implement to add a different preprocess type for images |
| jafar::datareader::ImageReader | This class makes it easy to read images from a sequence |
| jafar::slam::ImageSegInvDepthFeatureObserveModel | Sizeless 3D point using the inverse-depth parametrisation observed in a perspective image |
| jafar::slam::ImageSegInvDepthInovFeatureObserveModel | Sizeless 3D point using the inverse-depth parametrisation observed in a perspective image |
| jafar::slamlines::ImageSegment | Class Image Segment |
| jafar::slamlines::ImageSegmentManager | Class Image Segment Manager |
| jafar::stereo::ImagesSizes | In this class we save all the values of the sizes of differents images |
| jafar::stereo::ImagesTemporary | Contains temporary buffers and variable needed in different algorithm |
| jafar::qdisplay::ImageView | This class manipulate the view of an image on a Viewer |
| jafar::lines::IMCT | Le type image de chaines de points de contour |
| jafar::imdesc::ImdescException | Base class for all exceptions defined in the module imdesc |
| jafar::quasidense::imgDataCensus | Base class to store an image and some additionnal layer : normalized image in range [0,1], image of intensity mean image of squared-intensity mean and mask image |
| jafar::quasidense::imgDataRank | Base class to store an image and some additionnal layer : normalized image in range [0,1], image of intensity mean image of squared-intensity mean and mask image |
| jafar::quasidense::imgDataZncc | Base class to store an image and some additionnal layer : normalized image in range [0,1], image of intensity mean image of squared-intensity mean and mask image |
| jafar::quasidense::imgPairCensus | Base class to store an image and some additionnal layer : normalized image in range [0,1], image of intensity mean image of squared-intensity mean and mask image |
| jafar::quasidense::imgPairRank | Base class to store the image couple |
| jafar::quasidense::imgPairZncc | Base class to store a couple of images This class supplies methods to evaluate a matching hypthesis (plausibility and scoring) |
| jafar::image::imout_t | |
| jafar::qdisplay::imout_t | |
| IncompleteCholeskyPreconditioner< Matrix > | Decomposes given matrix and solve L L^T x = b |
| jafar::filter::InconsistentUpdateException | This exception is thrown when an inconsistent update occurs in the Kalman filter |
| jafar::bundler::IncrementalBundler | Class IncrementalBundler, solves linearly the bundle adjustment problem only for the recovering 3D positions |
| jafar::rtslam::SphericalGrid< Cell >::Index | |
| boost::numeric::ublas::index_pair< V > | |
| boost::numeric::ublas::index_pair_array< V1, V2 > | |
| boost::numeric::ublas::index_triple< M > | |
| boost::numeric::ublas::index_triple_array< V1, V2, V3 > | |
| boost::numeric::ublas::indirect_array< A > | |
| jafar::slam::InfFeatureObserveModel | A feature at infinity observe model |
| jafar::ddf::InfoContainer | Class for manipulating information This class is a container class for communicating, storing information in a network of sensor nodes |
| jafar::slam::InitFeature | A generic bearing only feature |
| jafar::slam::InitStateMember | Initial state gaussian member (or hypothesis) |
| jafar::rtslam::Innovation | Base class for all Gaussian innovations defined in the module rtslam |
| jafar::graphmap::InputManager< DataType > | |
| jafar::graphmap::InputManagerAbstract | |
| jafar::geom::VoxelSpace< _dimension_, _TObject_, _BoundingBoxGetter_ >::InsertFunctor | This functor is used to insert a new object |
| jafar::fdetect::InterestFeature | This class represents an interest point |
| jafar::fdetect_v2::InterestFeature< DESCRIPTOR > | This class represents an interest point |
| jafar::gfm::GroupsMatcher::InterestFeatureInfo | |
| jafar::gfm_v2::GroupsMatcher< InterestFeatureT >::InterestFeatureInfo | |
| jafar::fdetect_v2::InterestFeatureWithData< DESCRIPTOR, T > | |
| jafar::geom::InterestPoint | This class represents an interest point |
| jafar::sams::interval | |
| jafar::ride::Interval | Interval between two waypoints, contains local constraints |
| jafar::kernel::InvalidParamException< T > | Special exception class for invalid parameter error |
| jafar::homography::InverseCompositionalHomographyEstimator | Implement the Homography Estimator from Simon Baker and Iain Matthews described in "Equivalence and Efficiency of Image Alignment Algorithms", 2001 http://www.ri.cmu.edu/pubs/pub_3805.html |
| jafar::ddf::IPCProcComm | An IPC implementation of CommBase |
| jafar::sas::IRD | Interest Region Detector class |
| jafar::sas::IRDM | |
| jafar::sas::IRDParams | |
| jafar::facetsmap::isCandidatForFacet | |
| boost::numeric::ublas::vector< T, A >::iterator | |
| boost::numeric::ublas::c_vector< T, N >::iterator | |
| boost::numeric::ublas::banded_matrix< T, L, A >::iterator1 | |
| boost::numeric::ublas::banded_adaptor< M >::iterator1 | |
| boost::numeric::ublas::matrix< T, L, A >::iterator1 | |
| boost::numeric::ublas::vector_of_vector< T, L, A >::iterator1 | |
| boost::numeric::ublas::c_matrix< T, N, M >::iterator1 | |
| boost::numeric::ublas::symmetric_matrix< T, TRI, L, A >::iterator1 | |
| boost::numeric::ublas::symmetric_adaptor< M, TRI >::iterator1 | |
| boost::numeric::ublas::banded_matrix< T, L, A >::iterator2 | |
| boost::numeric::ublas::banded_adaptor< M >::iterator2 | |
| boost::numeric::ublas::matrix< T, L, A >::iterator2 | |
| boost::numeric::ublas::vector_of_vector< T, L, A >::iterator2 | |
| boost::numeric::ublas::c_matrix< T, N, M >::iterator2 | |
| boost::numeric::ublas::symmetric_matrix< T, TRI, L, A >::iterator2 | |
| boost::numeric::ublas::symmetric_adaptor< M, TRI >::iterator2 | |
| jafar::filter::JacobianBlockCommandPredictModel | Non linear prediction with an input command model defined for one block |
| jafar::filter::JacobianBlockPredictModel | Non linear prediction model defined for one block |
| jafar::filter::JacobianCommandPredictModel | General non linear predict model with an input command |
| jafar::filter::JacobianImplicitObserveModel | Non linear implicit observation model |
| jafar::filter::JacobianObserveModel | Non linear observation model |
| jafar::filter::JacobianPredictModel | General non linear predict model |
| jafar::filter::JacobianStrongConstraintModel | Smooth constraint to be applied on a kalman filter state |
| jafar::kernel::JafarException | This class defines some standard exceptions to be used from all modules |
| jafar::jbn::JbnException | Base class for all exceptions defined in the module jbn |
| jafar::modeler::JfrEdge | |
| vcg::tri::io::JfrExporterPLY< SaveMeshType > | |
| jafar::modeler::JfrFace | |
| JfrImage_CImage | Jafar image C structure |
| JfrImage_ImageHeader | Jafar supplementary header |
| vcg::tri::io::JfrImporterPLY< OpenMeshType > | This class encapsulate a filter for opening ply meshes |
| vcg::tri::io::JfrMask | |
| jafar::modeler::JfrMesh | |
| jafar::modeler::JfrUsedTypes | |
| jafar::modeler::JfrVertex | |
| jafar::jmath::JmathException | Base class for all exceptions defined in the module jmath |
| jafar::jstereopixel::JStereopixelException | Base class for all exceptions defined in the module stereopixel |
| jafar::filter::KalmanFilter | This class implements a Kalman filter |
| jafar::imdesc::KBFeature | Salient feature item structure |
| kd_node | Node in a k-d tree |
| jafar::sams::Kdtree | |
| jafar::sams::Kdtree_node | |
| jafar::sams::Kdtree_result | |
| jafar::sams::Kdtree_result_vector | |
| jafar::kernel::KernelException | Base class for all exceptions defined in the module kernel |
| jafar::velodyneutils::KeyboardPort< NumType > | |
| jafar::velodyneutils::KeyboardPortBase | **************************************************************************** KeyboardPort |
| jafar::kernel::KeyValueFile | Read a file containing simple key value statements |
| jafar::kernel::KeyValueFileLoad | Interface of an object which can be loaded using the KeyValueFile mechanism |
| jafar::kernel::KeyValueFileSave | Interface of an object which can be saved using the KeyValueFile mechanism |
| jafar::kernel::KeyValueFileSaveLoad | Interface of an object which can both be loaded and saved using the KeyValueFile mechanism |
| jafar::modeler::KinectModeler | KinectModeler is a class that builds a mesh for an object from color and depth sequence |
| jafar::klt::Klt | This class is a Jafar wrapper (using Image) to the KLT tracker |
| KLT_FeatureHistoryRec | |
| KLT_FeatureListRec | |
| KLT_FeatureRec | |
| KLT_FeatureTableRec | |
| KLT_TrackingContextRec | |
| jafar::klt::KltException | Base class for all exceptions defined in the module klt |
| jafar::gdhe::Label | |
| jafar::qdisplay::LabelBlobs | |
| jafar::qdisplay::LabelBoundingBox | |
| jafar::qdisplay::LabeledImage | |
| jafar::qdisplay::Labeler | Keyboard: |
| jafar::qdisplay::LabelSizeOri | |
| jafar::rtslam::simu::Landmark | |
| jafar::rtslam::LandmarkAbstract | Base class for all landmarks defined in the module rtslam |
| jafar::rtslam::LandmarkAnchoredHomogeneousPoint | Class for anchored homogeneous 3D points |
| jafar::rtslam::LandmarkAnchoredHomogeneousPointsLine | Class for Anchored homogeneous points lines |
| jafar::rtslam::display::LandmarkDisplay | ************************************************************************** This is the base class for landmark objects that will store display data for a viewer |
| jafar::rtslam::LandmarkEuclideanPoint | Class for Euclidean 3D points |
| jafar::rtslam::display::LandmarkEx | |
| jafar::rtslam::LandmarkFactory< LandmarkInit, LandmarkConverged > | |
| jafar::rtslam::LandmarkFactoryAbstract | |
| jafar::slampt::LandmarkListRemovePred | |
| jafar::jmath::LapackException | This exception is thrown when a lapack routine fails |
| jafar::premodeler::Learner | Class Learner This class handles the learning result saving process If bundled 3D points are given they will be saved, else file won't contain this information |
| jafar::learner::LearnerException | Base class for all exceptions defined in the module learner |
| jafar::lgl::LglException | Base class for all exceptions defined in the module lgl |
| jafar::geom::Line< dimension > | This class defines a line (which is a space of dimension 1) |
| jafar::qdisplay::Line | |
| jafar::model3d::Line2D | Equation of the line is given in the form i.e |
| Linear_correlated_observe_model | |
| Linear_invertable_predict_model | |
| Linear_uncorrelated_observe_model | |
| jafar::filter::LinearCommandPredictModel | Linear prediction model with command |
| jafar::filter::LinearObserveModel | Linear observation model |
| jafar::filter::LinearPredictModel | Linear prediction model |
| jafar::image::LinearPyramid | Linear Pyramid class |
| jafar::geom::Segment< dimension >::LineDriver | |
| jafar::dseg::LineFitterKalman2 | |
| jafar::lines::LineSegment | Class for a line segment with descriptor |
| jafar::lines::LineSegmentSet | Container for a set of LineSegment |
| jafar::lines::LinesException | Base class for all exceptions defined in the module lines |
| jafar::graphmap::LinkInputManager | |
| jafar::slammm::ListMapsPoseManager | Store the pose of each maps in a list |
| jafar::image::LKTracker | Lukas-Kanade based tracker working on Harris corners |
| vcg::tri::io::JfrImporterPLY< OpenMeshType >::LoadPly_Camera | |
| vcg::tri::io::JfrImporterPLY< OpenMeshType >::LoadPly_FaceAux | |
| vcg::tri::io::JfrImporterPLY< OpenMeshType >::LoadPly_Feature | |
| vcg::tri::io::JfrImporterPLY< OpenMeshType >::LoadPly_RangeGridAux | |
| vcg::tri::io::JfrImporterPLY< OpenMeshType >::LoadPly_TristripAux | |
| vcg::tri::io::JfrImporterPLY< OpenMeshType >::LoadPly_VertAux< S > | |
| jafar::localizer::Localizer | Class Localizer, should be a wrap to opencv localizer functionnality TODO make it inherit from a generic localizer /!\ WARNING it is not tested yet /!\ will be rewritten soon |
| jafar::localizer::LocalizerException | Base class for all exceptions defined in the module localizer |
| jafar::slam::LocalMapManager | Local slam manager |
| jafar::slam::LocalMapManagerFactory | |
| jafar::graphmap::LocalRobotPoseOutputManager | |
| jafar::spaf::Location | Location is an approcimate description of a part of the environnement, it's usefull to focus the matching algorithm |
| jafar::spaf::LocationsBag | |
| jafar::locpano::LocPanoData | |
| jafar::locpano::LocpanoException | Base class for all exceptions defined in the module locpano |
| jafar::locpano::LocPanoHeader | |
| jafar::locpano::LocPanoInternal | |
| jafar::locpano::LocPanoParams | |
| jafar::kernel::Loggable | Interface Loggable |
| jafar::rtslam::SensorManagerOnline::LoggableChronogram | |
| jafar::rtslam::LoggableClose | |
| jafar::kernel::LoggableClose | Loggable object that closes a file stream (push it after the last object to log) |
| jafar::rtslam::hardware::HardwareSensorCamera::LoggableImage | |
| jafar::rtslam::LoggableMatchings | |
| jafar::rtslam::hardware::LoggableProprio | |
| jafar::rtslam::SensorManagerOnline::LoggableReplay | |
| jafar::rtslam::SensorManagerOnline::LoggableReplayInitialState | |
| jafar::kernel::LoggableString | Loggable object for DataLogger |
| jafar::kernel::LoggerTask | This object creates a thread that log objects |
| jafar::lsd::LsdException | Base class for all exceptions defined in the module lsd |
| jafar::lsd::LSDSegment | Segment coordinates |
| jafar::lsd::LSDSegmentsDetector | Line Segment Dector, using the Grompone's implementation from http://mw.cmla.ens-cachan.fr/megawave/algo/lsd/ |
| jafar::lines::LsExtractor | Class with functions to extract line segments of an image |
| jafar::lines::LsMatching | This class provides functions to match two lineSegmentSet |
| jafar::lines::LsPredictor2D | Class for prediction of the movement of a line in a sequenze of images |
| jafar::lines::LsTracker | Provides tracking of line segments |
| jafar::oracle::ObjectRecognizer::ltMRst | Least Matching Result structure used as comparator for the map |
| jafar::oracle::ltstr | |
| jafar::facetsmap::MaillagePoint | |
| jafar::ddf::ManagerThreadFunc< PARENT > | The main loop for the channel manager |
| jafar::rtslam::MapAbstract | Base class for all map types defined in the module rtslam |
| jafar::rtslam::display::MapDisplay | ************************************************************************** |
| jafar::rtslam::display::MapEx | |
| jafar::rtslam::MapManager | This class is a default implementation of MapManagerAbstract, that only reparametrize and kill landmarks with a too large search area |
| jafar::rtslam::MapManagerAbstract | This class is the abstract class for map managers, that manages the life of landmarks at the map level (creation, reparametrization, deletion, etc) |
| jafar::slam::MapManagerFactory | |
| jafar::rtslam::MapManagerGlobal | Map manager made for doing slam as long as possible while optimizing the use of the map |
| jafar::rtslam::MapManagerGrid | Map manager with visible landmarks grid management |
| jafar::rtslam::MapManagerLocal | Map manager made for managing a spatially local map in a hierarchical multimap framework |
| jafar::rtslam::MapManagerOdometry | Map manager with a very short memory policy |
| jafar::rtslam::MapObject | Class for generic mappable objects |
| jafar::rtslam::simu::MapObject | |
| jafar::slammm::ListMapsPoseManager::MapPoseInfo | |
| jafar::slammm::ListMapsPoseManager::MapPoseInfoEdge | |
| jafar::slammm::MapsPoseManager | This class countains the global level of a multimap approach |
| jafar::slammm::MapsPoseManagerEventAdapter | |
| jafar::slammm::MapsPoseManagerEventListener | This class is used to get events from a MapsPoseManager |
| jafar::spaf::MapsTransformation | This is use to transform information in spaf feature to different map reference |
| jafar::imdesc::Match | Class Match |
| jafar::sams::Match | |
| jafar::gfm::Match | |
| jafar::gfm_v2::Match< InterestFeatureT > | |
| jafar::gfm_v2::DescriptorsBasedMatcher< InterestFeatureT >::matched_feature | Matched feature consist of an observed feature of match and candidates in ref |
| jafar::sams::Matcher | |
| jafar::gfm_v2::Matcher< InterestFeatureT > | This class is the base class of all implementation of a matching algorithm |
| jafar::gfm::Matcher | This class is the base class of all implementation of a matching algorithm |
| jafar::rtslam::ImagePointZnccMatcher::matcher_params_t | |
| jafar::rtslam::simu::MatcherSimu< RoiSpec >::matcher_params_t | |
| jafar::rtslam::simu::MatcherSimu< RoiSpec > | |
| jafar::traversability::MatchesContainer | This class represents the actual interface between the modules and gfm and traversability |
| jafar::traversability::MatchesInfo | Struct that contains some information about the matches |
| jafar::gfm::MatchFocus | Base class for creating new method of focusing the matching algorithms |
| jafar::rtslam::LoggableMatchings::Matching | |
| jafar::gfm::MatchingResult | This structure contains the result of the matching |
| jafar::gfm_v2::MatchingResult< InterestFeatureT > | This structure contains the result of the matching |
| jafar::lines::MatchingSet | Container for a matching |
| jafar::spafdb::MatchQuery | This query is used to find matches between a group of features and features stored in the database |
| jafar::spafdb::MatchQueryGeometricRelationGroupSimilarity | This MatchQuery is an improvement over MatchQueryGeometricRelationSimilarity , since to make the matches, it takes into account multiple connections |
| jafar::spafdb::MatchQueryGeometricRelationSimilarity | This MatchQuery is strictly based on comparing GeometricRelation one by one with the database, and then the matches is computed based on the number of votes |
| jafar::spaf::MatchResult | This class holds the result of a single match between two features |
| jafar::gfm_v2::MatchSourceInfo< InterestFeatureT > | This class holds the information for matching |
| jafar::gfm::MatchSourceInfo | This class holds the information for matching |
| jafar::lines::MatchStatistic | Structure to store the result of a comparison of two matchings |
| jafar::jmath::MATLAB | Class for serializing boost arrays into Matlab format |
| jafar::jmath::matofmat< T, M, N > | |
| boost::numeric::ublas::matrix< T, L, A > | |
| matrix_container | |
| jafar::jmath::matrix_file< T > | Class matrix_file loads/saves data into/from a matrix from/to a file |
| boost::numeric::ublas::matrix_temporary_traits< banded_adaptor< M > > | |
| boost::numeric::ublas::matrix_temporary_traits< const banded_adaptor< M > > | |
| boost::numeric::ublas::matrix_temporary_traits< symmetric_adaptor< M, TRI > > | |
| jafar::ddfsimu::MeasureItem | Class containing a time stamped measurement vector |
| jafar::rtslam::Measurement | Base class for all Gaussian measurements defined in the module rtslam |
| jafar::slammm::MergeMapsStrategy | This class is used to define strategy for merging maps |
| jafar::modeler::Mesher | Mesher is the base class of all the modeling classes |
| edu::mines::jtk::mesh::Mesher | |
| jafar::mesher::MesherAdapter | |
| jafar::mesher::MesherException | Base class for all exceptions defined in the module mesher |
| jafar::metac::MetacException | Base class for all exceptions defined in the module metac |
| min_pq | Minimizing priority queue |
| jafar::locpano::MinMax | |
| jafar::modeler::Mixer | Mixer has nothing to do with the mathematician |
| jafar::geomslam::MMInvDepthPointDriver | This class provides a geom::Point3D::Driver for a geom::Point3D , that uses the 3D position of a point coming from a multimap slam map |
| jafar::geomslam::MMMap | |
| jafar::geomslam::MMPointDriver | This class provides a geom::Point3D::Driver for a geom::Point3D , that uses the 3D position of a point coming from a multimap slam map |
| jafar::geomslam::MMSegmentDriver | This class provides a geom::Segment3D::Driver for a geom::Segment3D , that uses the 3D position of a point coming from a multimap slam map |
| jafar::rtslam::simu::MobileObject | |
| jafar::sams::Model | |
| jafar::model3d::Model3dException | Base class for all exceptions defined in the module model3d |
| jafar::sams::ModelDB | |
| jafar::modeler::Modeler | Modeler is a class that builds a mesh for an object represented in a sequence of image |
| jafar::modeler::ModelerException | Base class for all exceptions defined in the module modeler |
| jafar::sams::ModelPart | |
| jafar::sams::ModelView | |
| jafar::slampt::MonoImageFrameDataBase | Frame Database for monocular images |
| jafar::slampt::MonoImagePointManager | Class for doing bearing-only slam with a monocular camera and when features are interest points extracted from an image |
| jafar::slamseg::MonoImageSegmentManager | |
| jafar::datareader::MonoReader | |
| jafar::traversability::Mosaic | Mosaic represents a mosaic of aerial images |
| jafar::traversability::MosaicTrv | MosaicTrv inherits from Mosaic |
| jafar::qdisplay::MouseGraphicsScene | |
| jafar::jmath::MultiDimNormalDistribution | Multi dimensionnal normal distribution generator using the Boost random library |
| jafar::jmath::MultiDimUniformDistribution | Multi dimensionnal uniform distribution generator using the Boost random library |
| jafar::slammm::MultiMapEventAdapter | Adapter for the event listener |
| jafar::slammm::MultiMapEventListener | This class is used to get events from a MultiMapsSlam |
| jafar::slammm::MultiMapsSlam | |
| jafar::ddfsimu::demo::MultiRobSimu | Groups the measurement of several robotsimu |
| jafar::ride::MultiTrajectory | MultiTrajectory Object |
| jafar::lgl::nav_heuristic< Graph, CostType, Vertex > | This file contains navigation heuristics functions for graph visitor algorithms (A*, D*) |
| jafar::lgl::nav_heuristic_rdv< Graph, CostType, Vertex > | |
| jafar::lgl::NavAStar< Graph, Vertex, CostType > | |
| jafar::lgl::NavGEdge | This structure models the navigation graph edge |
| jafar::lgl::NavGNode | NavGNode is the class for representing each node in the navigation graph |
| jafar::lgl::NavGraph | NavGraph build and manages the graph over a raster |
| jafar::lgl::NavGraphT< EDGE_BUNDLE, VERTEX_BUNDLE, EDGE_WEIGHT_T > | Navigation graph class Manipulate vertices as 2d positions and each position is unique |
| jafar::rednav::Navigator | |
| jafar::lgl::NavLocation | |
| jafar::graphmap::new_map_data_t | |
| joptimization::methods::Newton< _TFunction_, _TType_ > | Use this class as a template parameter for the gaussNewton function if you want to use the Newton method which uses the Hessian |
| jafar::graphmap::display::Node | |
| jafar::spafgraph::Node | A node represent a feature in the graph |
| jafar::spafgraph::NodeDescriptor | |
| nonassignable | |
| noncopyable | |
| jafar::jmath::NormalDistribution | Normal distribution generator using the Boost random library |
| jafar::velodyneutils::NormalEstimatorImages3D< PointInT, PointOutT > | **************************************************************************** NormalEstimatorImages3D |
| NormalPure | **************************************************************************** NormalPure |
| jafar::modeler::normals_estimator | |
| jafar::rtslam::simu::Object | |
| jafar::gdhe::Object | When creating a new object type, you have to inherit from this object, optionnally add some attributes with their accessors, call touch() every time an accessor modifies an attribute, and implement construction() |
| jafar::gml::Object | |
| jafar::rtslam::ObjectAbstract | Class for generic objects in rtslam |
| jafar::oracle::ObjectIdentifier | Class ObjectIdentifier This class is in charge of querying the Interest Feature Database about an unknown object image |
| jafar::oracle::ObjectLoader | Class ObjectLoader Loads all object learning data from an object model file |
| jafar::oracle::ObjectRecognizer | Class ObjectRecognizer This class is in charge of querying the Interest Feature Database about an unknown object image |
| jafar::oracle::ObjectTracker | Class ObjectTracker This class tracks an object on the scene |
| jafar::bundle::observation | Base class of observation object |
| jafar::slam::Observation | Observation |
| jafar::rtslam::ObservationAbstract | Base class for all observations defined in the module rtslam |
| jafar::rtslam::display::ObservationDisplay | ************************************************************************** This is the base class for observation objects that will store display data for a viewer |
| jafar::rtslam::display::ObservationEx | |
| jafar::rtslam::ObservationFactory | |
| jafar::simu::ObservationIdsManager | Usually the observation of the environment have the id associated with the feature in the environment |
| jafar::rtslam::ObservationMakerAbstract | |
| jafar::rtslam::ObservationModelAbstract | An observation model only contains pseudo-static functions A reference to the sensor is kepts because it has a lot of parameters that cannot easily be abstracted, and to avoid to cast an abstract sensor object every time |
| jafar::fusion::ObservationModelFusion | |
| jafar::rtslam::ObservationModelPinHoleAnchoredHomogeneousPoint | |
| jafar::rtslam::ObservationModelPinHoleAnchoredHomogeneousPointsLine | |
| jafar::rtslam::ObservationModelPinHoleEuclideanPoint | |
| jafar::rtslam::ObservationPinHoleAnchoredHomogeneousPoint | Class for Pin-Hole observations of Anchored Homogeneous 3D points |
| jafar::rtslam::ObservationPinHoleAnchoredHomogeneousPointsLine | Class for Pin-Hole observations of Lines based on Anchored Homogeneous 3D points |
| jafar::rtslam::ObservationPinHoleEuclideanPoint | Class for Pin-Hole observations of Euclidean 3D points |
| jafar::bundle::observationsContainer | Container for all observations used by the BA algorithm |
| jafar::slam::Odo3dPredictModel | 3d odometry predict model |
| jafar::slam::OdoNoiseModel | Odometry noise model |
| jafar::geom::OGSensorModel | |
| jafar::icp::OICP | Class OICP stands for Original ICP It is an implementation of Besl original ICP algorithm described in A method for icp of 3-D shapes, Besl and McKay in IEEE PAMI, 14(2):239 - 256, February 1992 It is aim is to align two 3D [later 2D] points cloud computing iteratively the best T3D that can perform it |
| jafar::image::oimstream | |
| jafar::quasidense::omniDataCensus | Base class to store an image and some additionnal layer : normalized image in range [0,1], image of intensity mean image of squared-intensity mean and mask image |
| jafar::slampt::OmniImageFrameDataBase | Frame Database for omni images |
| jafar::slam::OmniImagePointFeatureObserveModel | Sizeless point from omnidirectional image observe model |
| jafar::slam::OmniImagePointInfFeatureObserveModel | Point at infinity observed in a panoramique image |
| jafar::slam::OmniImagePointInvDepthFeatureObserveModel | Sizeless 3D point using the inverse-depth parametrisation observed in a panoramic image |
| jafar::slampt::OmniImagePointManager | Class for omni slam |
| jafar::quasidense::omniMask | Class designed to store a binary layer indicating pixel for which the correlation score can be computed |
| jafar::quasidense::omniPairCensus | |
| jafar::imdesc::oneMatch | OneMatch structure, contains the 2 patchs and the correlation score |
| jafar::learner::Oracle | Class Oracle Given bundled points and recognized object it tries to find transition matrix and barycenter Uses Tsai3dLocalizer |
| jafar::oracle::OracleException | Base class for all exceptions defined in the module oracle |
| jafar::sas::OrientedConspicuity | Class for Orientation Conspicuity computation |
| jafar::geom::OrientedPlan< dimension > | This class represent an hyperplan associated to a repere |
| jafar::graphmap::OutputManagerAbstract | |
| jafar::p3d::P3d | Class P3D is the main class of the module |
| jafar::p3d::P3D_MAP | P3D_MAP is a class which represents an internal map It really is close from a DTM, but it contains only local informations |
| jafar::p3d::P3dArcDumper | Class P3DArcDumper provides a way to dump and manipulate all the arcs used in p3d algorithm |
| jafar::p3d::P3dException | Base class for all exceptions defined in the module p3d |
| jafar::p3d::P3DPlanner | A planner class is a wrapper against a p3dPlanner |
| jafar::p3d::P3DPlanSolution | The class P3dPlanSolution represents a classic solution of the planner |
| jafar::p3d::P3DRobotConfig | One configuration of a robot at a time, aka its position in 3d world |
| jafar::camera::PanoMask | DEPRECATED This class allows to mask useless part of a panoramic image |
| jafar::locpano::Parabolic | |
| jafar::camera::ParabolicBarretoCameraHandler | Class ParabolicBarretoCameraHandler handles ParabolicBarretoCamera |
| jafar::spafdb::Parameter | Define the Parameter of a SpafDB |
| jafar::ddf::ParametersGeneric | |
| jafar::sams::BackgroundAnalysis::Params | BackgroundAnalysis parameters class |
| jafar::sams::SIFTFactory::Params | |
| jafar::sams::GIFTFactory::Params | |
| jafar::sams::GreyDescFactory::Params | |
| jafar::sams::SHDetector::Params | |
| jafar::sas::BK_IRT::Params | |
| jafar::rtslam::ParentOf< Child > | |
| jafar::gml::Parser | This class allow the parsing of GML file |
| jafar::gdal::Parser | |
| jafar::filter::ParticleFilter | Basic particle filter |
| jafar::graphmap::path_to_back_edge_recorder< OutputIterator, OutputIteratorValueType > | |
| jafar::graphmap::path_to_target_recorder< OutputIterator, OutputIteratorValueType, Vertex > | |
| jafar::rednav::PathTool | |
| jafar::lgl::PatternPoint | }}} |
| jafar::ddf::SensorNodePeriodic< PARAMS >::PerProcStruct | |
| jafar::rtslam::Perturbation | Base class for all Gaussian perturbation vectors defined in the module rtslam |
| jafar::pfdesc::PfdescException | Base class for all exceptions defined in the module pfdesc |
| jafar::camera::PinholeCameraHandler | Class PinholeCameraHandler handles PinholeCamera |
| jafar::image::Pixel | This class represents a convex 2D Region Of Interest |
| jafar::quasidense::pixel | |
| jafar::quasidense::pixelmatch | |
| jafar::viewer3d::PlainDecorator | |
| jafar::geom::Plane3D | |
| jafar::model3d::Plane3D | Equation of the plane is given in the Hessian form i.e |
| jafar::model3d::PlaneObserveModel | |
| jafar::traversability::PlaneParameters | Struct that contains plane parameters used for the geometric homography estimation |
| jafar::localizer::PlanLocalizer | Class PlanLocalizer This class is able to compute the transformation matrix between two plan (images) |
| jafar::lgl::pNavPos | |
| jafar::simu::Point | A point to put in the environment |
| jafar::stereosimu::Point | A structure to store a 3D point x, y and z are double, but represents point |
| jafar::geom::Point< dimension > | Class Point This class represents a point |
| jafar::model3d::Point2D | Simple Point2D class, where the x and y are int |
| jafar::localizer::Point2d3d | Class Point2d3d used to save 2D and 3D coordinates of the same point respectively in the camera, and world frames |
| jafar::model3d::Point3D | We use Homogeneous coordinates (X,Y,Z,W), and be default W=1 |
| jafar::gdhe::Point3D | |
| jafar::vme::Point3D | A 3D point with its uncertainty |
| jafar::bundler::Adapter< TRACKERS >::Point3DCompare | |
| jafar::spaf::Point3DFeature | Class to contains a 3D point |
| jafar::vme::Point3DPair | A Point3DPair links two 3D points which are matched between the two stereo frames |
| jafar::model3d::Point3DVar | Point 3D with Covariance matrix |
| jafar::locpano::Point_ij | |
| jafar::locpano::Point_xy | |
| jafar::velodyneutils::PointCloudClassifier< PointT > | **************************************************************************** PointCloudClassifier |
| jafar::velodyneutils::PointCloudMapper< PointT > | **************************************************************************** PointCloudMapper |
| jafar::simu::PointFactory | |
| jafar::slam::PointFeatureModel | Sizeless 3D point model |
| PointHDL | **************************************************************************** PointHDL |
| jafar::slam::PointInfFeatureModel | Sizeless 3D point at infinity model |
| jafar::dseg::SearchPointLineDebug::PointInfo | |
| jafar::slam::PointInvDepthFeatureModel | Sizeless 3D point using the inverse-depth parametrisation |
| PointNormalIL | **************************************************************************** PointNormalIL |
| PointNormalL | **************************************************************************** PointNormalL |
| PointRegionMap | **************************************************************************** PointRegionMap |
| jafar::viewer3d::PointsCloud | This class allows to display a cloud of Point3D in a Viewer3D |
| jafar::geom::PolyLine< dimension >::PointsDriver | |
| jafar::geom::Plane3D::PointsDriver | |
| jafar::slamptseg::PointSegmentManager | |
| jafar::geom::PolyLine< dimension >::PointsPointerDriver | |
| PointXYZIL | **************************************************************************** PointXYZIL |
| jafar::slam::PolarPointFeatureObserveModel | Sizeless point polar observe model |
| jafar::qdisplay::PolyLine | Allows to display a poly line on a viewer overlay |
| jafar::gdhe::Polyline | |
| jafar::geom::PolyLine< dimension > | |
| jafar::geom::PolyLine< dimension >::PolyLineNM1Driver | |
| jafar::geom::PolyLine< dimension >::PolyLineNP1Driver | |
| jafar::lgl::Pos | |
| jafar::lgl::Pos2d | TODO comments on Structure Pos2d |
| jafar::slam::PoseCopy | A special object of the map to estimate a local frame |
| jafar::lgl::PosFeature | |
| jafar::rtslam::hardware::Position | |
| jafar::datareader::Position | Class Position holds the different available T3D transforms of a pos file |
| jafar::lgl::PositionManager | Class that take care position management its algorithms reason over position instead of raster cells or clusters |
| jafar::lgl::PositionMap | The geometric decomposition (quadtree, bintree or any rectangular-pattern based decomposition) of the terrain represented over the position map |
| jafar::datareader::PositionReader | This class makes it easy to read positions from a sequence |
| jafar::ride::posTraj | Struct with position, direction of the trajectory and current waypoint if not on the traj, return last waypoint |
| pq_node | Element in a minimizing priority queue |
| jafar::ddf::PredictionEngineBase | This is a virtual class for state prediction |
| jafar::ddf::PredictionEngineGeneric< PARAMS > | This class allows to customize the set of parameters needed for updating the prediction model (specialization of PredictionEngineBase) |
| jafar::ddf::PredictModelFactoryBase | The factory for prediction models |
| jafar::ddf::PredictModelFactoryGeneric< T > | Specialized factory for prediction models |
| jafar::fusion::PredictModelFusion | |
| jafar::dseg::Predictor | This class defines a predictor of the position of a segment in an image |
| jafar::premodeler::PremodelerException | Base class for all exceptions defined in the module premodeler |
| jafar::dseg::PreprocessedImage | |
| jafar::preprocessing::Preprocessing | |
| jafar::preprocessing::PreprocessingException | Base class for all exceptions defined in the module preprocessing |
| jafar::geom::Line< dimension >::TwoPointsPointerDriver::Private | |
| jafar::geom::Segment< dimension >::TwoPointsPointerDriver::Private | |
| jafar::geom::Segment< dimension >::LineDriver::Private | |
| jafar::rtslam::SensorManagerAbstract::ProcessInfo | |
| jafar::facetsmap::ProcessStats | |
| jafar::premodeler::Profiler | Class Profiler This class is in charge of querying the Interest Feature Database about an unknown object image |
| jafar::kernel::ProgressBar | A simple text based progress bar |
| jafar::rtslam::hardware::ProprioLog | |
| jafar::spafdb::ProximityStrategy | This an interface to define strategy on how proximity edges are created when inserting a new spafgraph::Node in the graph of a SpafDB |
| jafar::lgl::ptr_cmp | }}} |
| jafar::lgl::ptr_greater< Pointer > | }}} |
| jafar::lgl::ptr_less< Pointer > | }}} |
| jafar::lgl::PursuitAPI | |
| jafar::lgl::PursuitGNode | PursuitGNode is the class for representing each node in the pursuit graph |
| jafar::lgl::PursuitGraph | }}} |
| jafar::lgl::PursuitInitParam | |
| jafar::lgl::PursuitNavigator | }}} |
| jafar::lgl::PursuitState | |
| jafar::lgl::PursuitStats | |
| jafar::lgl::PursuitTask | PursuitTask is the class used to describe a support task during the pursuit mission |
| jafar::lgl::PursuitTaskKey | }}} |
| jafar::lgl::PursuitTaskManager | }}} |
| jafar::image::Pyramid | |
| jafar::dseg::PyramidSP | |
| jafar::qdisplay::QdisplayException | Base class for all exceptions defined in the module qdisplay |
| jafar::qdisplay::QtAppStart | This class provides a simple way to control a qt display from c++, dealing with all the constraints of qt |
| jafar::lgl::QuadMat | Class for quadtree utility of the lgl module |
| jafar::lgl::QuadNode< T, RasterT > | Quadtree abstract node T is the data that each leaf holds |
| jafar::lgl::QuadNodeInternal< T, RasterT > | Internal node of the quadtree |
| jafar::lgl::QuadNodeLeaf< T, RasterT > | Leaf node of the quadtree T is the data type |
| jafar::lgl::Quadtree< T, RasterT > | Class for quadtree utility of the module |
| jafar::slampt::QualityIndexPoint | A feature point with a quality |
| jafar::quasidense::QuasidenseException | Base class for all exceptions defined in the module quasidense |
| jafar::traversability::Quaternion | This class represents a quaternion |
| jafar::rtslam::QuickHarrisDetector | Quick Harris detector class |
| jafar::viewer3d::RandomDecorator | This class associate a random color to an id, and always return the same color to that id |
| jafar::jmath::RandomIntTmplt< IntType > | |
| RandomIntTmplt | Random Integer Generator Template |
| jafar::jmath::RandomIntVectTmplt< IntType > | Vector of Random Inetegers |
| jafar::dseg::RandomStaticPredictor | It's a Predictor that "grow" the covariance of the predictor from a given amount |
| jafar::spaf::Feature::Range | |
| jafar::ride::rangeAlloc | List of Alloc with bounds on the trajectory |
| jafar::jmath::RANSAC< NUMTYPE > | An implementation of the RANSAC algorithm for robust fitting of models to data |
| jafar::model3d::RANSAC< ModelType > | Template RANSAC class: RANSAC (RANdom SAmple Consensus) |
| jafar::model3d::RansacLine2D | Ransac algorithm for extracting lines 2D |
| jafar::model3d::RansacPlane | Ransac algorithm for extracting planes 3D |
| jafar::rtslam::RansacSet | |
| jafar::lgl::Raster | Abtract class to define the type suitable for quadtree representation |
| jafar::gramer::RasterCell | |
| jafar::lgl::RasterCellIndex | Top left corner coordinates in 2D of a Cell (= a pixel or a cluster of pixels) |
| jafar::lgl::RasterIndex2d | TODO comments on Structure RasterIndex2d |
| jafar::lgl::RasterPoint | Point object in a Raster |
| jafar::lgl::RasterRect | RasterRect class |
| jafar::rtslam::RawAbstract | |
| jafar::rtslam::RawImage | Class for image |
| jafar::rtslam::RawInfo | |
| jafar::rtslam::RawInfos | |
| jafar::rtslam::simu::RawSimu | |
| jafar::rtslam::RawVec | |
| jafar::velodyneutils::Reader3DImage | **************************************************************************** Reader3DImage |
| jafar::velodyneutils::ReaderPosition | **************************************************************************** ReaderPosition |
| jafar::velodyneutils::ReaderRegionMap | **************************************************************************** ReaderRegionMap |
| jafar::velodyneutils::ReaderVelodyneImage3D | **************************************************************************** ReaderVelodyneImage3D |
| jafar::fdetect_v2::RealDescriptor< REALTYPE > | Generic descriptor based on a float array (for instance SIFT or SURF) |
| jafar::stereo::ReconstructionParams | Contains all parameters needed for Reconstruction 3D |
| jafar::geom::Rectangle< _T_ > | This class is used to represent a rectangle on an image |
| jafar::locpano::Rectangle | |
| jafar::stereo::RectificationParams | Contains all parameters needed for Rectification |
| jafar::rednav::RednavException | Base class for all exceptions defined in the module rednav |
| jafar::velodyneutils::RegionMapEstimator< PointInT > | **************************************************************************** RegionMapEstimator |
| jafar::geom::VoxelSpace< _dimension_, _TObject_, _BoundingBoxGetter_ >::RemoveFunctor | |
| jafar::rtslam::display::Viewer< WorldDisplayType, MapDisplayType, RobotDisplayType, SensorDisplayType, LandmarkDisplayType, ObservationDisplayType, GarbageType >::Render | |
| jafar::geom::Repere< dimension > | This class represent a Repere which can be used as a reference for other |
| jafar::facetsmap::Repere | |
| jafar::viewer3d::Repere | This class allows to add a repere to a view |
| jafar::geom::Repere3D | 3D Reference |
| jafar::geom::OrientedPlan< dimension >::RepereDriver | |
| jafar::facetsmap::Result | |
| jafar::slam::RhoThetaImagePluckerFeatureObserveModel | Observation Model using Rho Theta parametrisation |
| jafar::ride::RideException | Base class for all exceptions defined in the module ride |
| jafar::rtslam::simu::Robot | |
| jafar::gdhe::Robot | |
| jafar::simu::Robot | A simple simulated robot with one sensor |
| jafar::rtslam::RobotAbstract | Base class for all robots defined in the module rtslam |
| jafar::rtslam::RobotCenteredConstantVelocity | RobotCentric Constant velocity model robot class |
| jafar::rtslam::RobotConstantMotionModel< LIN_ORDER, ANG_ORDER > | Constant velocity model robot class |
| jafar::rtslam::RobotConstantVelocity | Constant velocity model robot class |
| jafar::rtslam::display::RobotDisplay | ************************************************************************** This is the base class for robot objects that will store display data for a viewer |
| jafar::rtslam::display::RobotEx | |
| jafar::rtslam::RobotInertial | Inertial measurements unit - robot motion model |
| jafar::slammm::MultiMapsSlam::RobotMaps | |
| jafar::rtslam::RobotOdometry | Odometry motion model robot class |
| jafar::simu::RobotPoseAnalysis | |
| jafar::graphmap::RobotPoseInputManager | |
| jafar::lgl::RobotPursuer | RobotPursuer is the structure (class) used to simulate the robots |
| jafar::rtslam::RobotQuantity | |
| jafar::ddfsimu::RobotSimu | This is the main class for robot simulation |
| jafar::ddfsimu::demo::RobotSimuNodesGen< SNODE_CLASS > | |
| jafar::image::ROI | |
| jafar::dseg::RotationProbabilitySegmentProbabilityEstimator | |
| jafar::quasidense::rotDataCensus | Base class to store an image and some additionnal layer : normalized image in range [0,1], image of intensity mean image of squared-intensity mean and mask image |
| jafar::quasidense::rotPairCensus | Base class to store an image and some additionnal layer : normalized image in range [0,1], image of intensity mean image of squared-intensity mean and mask image |
| jafar::rtmaps::RtmapsException | Base class for all exceptions defined in the module rtmaps |
| jafar::rtmaps::RtmapsReader | Read image from rtmaps raw data |
| jafar::rtslam::RtslamException | Base class for all exceptions defined in the module rtslam |
| jafar::dseg::RtslamPredictor | It's a Predictor that "grow" the covariance of the predictor from a given amount |
| jafar::sams::SamsException | Base class for all exceptions defined in the module sams |
| jafar::sas::SasException | Base class for all exceptions defined in the module sas |
| jafar::bundle::SBACamera | Class SBACamera Holds intrinsic and extrinsic camera parameters |
| jafar::bundle::SBACameras | |
| jafar::bundle::SBAObservation | Class SBAObsevation Holds structure of observed point |
| jafar::bundle::SBAObservations | |
| boost::numeric::ublas::scalar_matrix< T > | |
| boost::numeric::ublas::scalar_vector< T > | |
| jafar::slam::ScaledHomogeneousImagePluckerFeatureObserveModel | Observation Model using Scaled Homogeneous parametrisation |
| jafar::lgl::sdeque< value_t > | |
| jafar::dseg::SearchPointLineDebug | |
| jafar::sams::searchrecord | |
| jafar::homography::SecondOrderHomographyEstimator | Implement the Second Order Homography estimator from Ezio Malis described in "Improving vision-based control using efficient second-order minimization techniques" http://www-sop.inria.fr/icare/personnel/malis/call/publications_call.html |
| jafar::slam::SegAnchorPluckerFeatureModel | 3D segments using anchored plucker parametrisation |
| jafar::rtslam::SegFeatureView | A feature view, storing the feature appearance and the conditions that correspond to this appearance |
| jafar::slam::SegInvDepthFeatureModel | 3D segments using 2 points inverse-depth parametrisation |
| jafar::simu::Segment | |
| jafar::geom::Segment< dimension > | This class defines a segment (which is a bounded space of dimension 1) |
| jafar::spaf::Segment3DFeature | Class to contains a 3D segment |
| jafar::dseg3d::Segment3DObservation | |
| jafar::slam::SegmentAnchorFeature | A plucker segment anchored feature, with its extremities |
| jafar::dseg::SegmentDebug | |
| jafar::simu::SegmentFactory | |
| jafar::slam::SegmentFeature | A segment feature, with its extremities |
| jafar::slam::SegmentFeatureContraintModel | Segment Feature constriant model |
| jafar::slam::SegmentFeatureModel | Segment model |
| jafar::dseg::SegmentHypothesis | This class contains information relative to a segment |
| jafar::dseg::SegmentHypothesisDebug | |
| jafar::slam::SegmentIDFeature | A segment inverse depth feature, with its extremities |
| jafar::slam::SegmentObservation | Observation of a segment |
| jafar::slam::SegmentObservationsSelector | |
| jafar::slam::SegmentPluckerConstraint | |
| jafar::dseg::SegmentProbabilityEstimator | |
| jafar::dseg::SegmentsClosestMatcher | |
| jafar::viewer3d::SegmentsCloud | This class allows to display a cloud of Segment3D in a Viewer3D |
| jafar::dseg::SegmentsSelector | This class is used to select Segments for tracking |
| jafar::dseg::SegmentsSet | This class contains a list of SegmentHypothesis |
| jafar::dseg::SegmentsSimpleMatcher | Simple match procedure that will consider that two segments (seg1, seg2) are matches if seg1 is the closest segment for seg2, and if seg2 is the closest segment for seg1: |
| jafar::slam::SegmentUConstraint | Director vector unit constraint |
| jafar::spafdb::SelectAllQuery | Select all features in the database |
| jafar::spafdb::SelectQuery | Base class for a query of features in a SpafDB |
| jafar::spafdb::SelectQueryProximity | Select all features that are close to a given geom::Atom |
| jafar::gdhe::Client::SendToServer | |
| jafar::rtslam::SensorManagerOnline::SenInfo | |
| jafar::simu::Sensor | An abstract sensor |
| jafar::rtslam::simu::Sensor | |
| jafar::ddfsimu::Sensor< T_OBS > | This class associate an observation model (T_OBS) and a sensor |
| jafar::rtslam::SensorAbsloc | Class for absolute localization sensors (gps, motion capture...) For now we assume that we have at least one reading before images and that is is very precise |
| jafar::rtslam::SensorAbstract | Base class for all types of sensors |
| jafar::datareader::SensorBase | |
| jafar::ddfsimu::SensorBase | Base class for sensors |
| jafar::rtslam::display::SensorDisplay | ************************************************************************** This is the base class for sensor objects that will store display data for a viewer |
| jafar::rtslam::display::SensorEx | |
| jafar::rtslam::SensorExteroAbstract | Base class for exteroceptive sensors (that need to map the environment) (cameras, lasers, ...) |
| jafar::rtslam::SensorImageParameters | Structure containing all non-extrinsic parameters of a camera |
| jafar::rtslam::SensorManagerAbstract | Base class for sensors managers, that decide which data of which sensor should be integrated in the filter next |
| jafar::rtslam::SensorManagerOffline | This sensors manager is made for offline processing |
| jafar::rtslam::SensorManagerOnline | This sensor managers tries to integrate several sensors according to their policy (all or latest) |
| jafar::rednav::SensorModel | Probabilistic sensor description |
| jafar::ddf::SensorNodeBase | This class implements the core functionalitires for a sensornode i.e |
| jafar::ddfsimu::demo::SensorNodeCompoundGen< SNODE_CLASS > | |
| jafar::ddf::SensorNodeGeneric< PARAMS > | This class uses template for binding a generic parameter container to the SensorNodeBase class This parameter is used for updating the prediction model i.e |
| jafar::ddf::SensorNodeIPC< PARAMS > | Implement a sensor node communications with IPC's (message queues) create a thread that handles connections/deconnections between nodes |
| jafar::ddf::SensorNodePeriodic< PARAMS > | |
| jafar::ddfsimu::SensorObs | Container class, tells thate the sensor measures some of the elements of a state vector |
| jafar::rtslam::SensorPinhole | Class for pin-hole cameras |
| jafar::simu::SensorPoint | Base class for points sensors |
| jafar::simu::SensorPointBearing | This sensor let the robot observe a point feature in polar coordinate (only bearing) |
| jafar::simu::SensorPointCartesian | This sensor let the robot observe a point feature in cartesian coordinate |
| jafar::simu::SensorPointImage | This sensor let the robot observe a point feature in a pseudo image |
| jafar::simu::SensorPointOmniImage | This sensor let the robot observe a point feature in a pseudo omniimage |
| jafar::simu::SensorPointPolar | This sensor let the robot observe a point feature in polar coordinate |
| jafar::simu::SensorPointSimple | |
| jafar::rtslam::SensorProprioAbstract | Base class for proprioceptive sensors (that directly observe the state of the robot) (IMU, odometry, GPS, movement models ...) |
| jafar::rtslam::SensorProprioPredictorAbstract | Base class for proprioceptive sensors that can be used for filter prediction step |
| jafar::simu::SensorRobot | This sensor can be used to observer an other robot in the environment |
| jafar::spaf::SensorsData | |
| jafar::simu::SensorSegmentImage | This sensor let the robot observe a segment in a pseudo image |
| jafar::simu::SensorSegmentStereoImage | This sensor let the robot observe a stereo segment in a pseudo image |
| jafar::ddfsimu::SensorSimu< T_OBS > | Sensor providing simulated measurements |
| jafar::ddfsimu::SensorSimuBase | Base class for all the simulated sensors |
| jafar::rtslam::SensorManagerOnline::SenStats | |
| jafar::qdisplay::Shape | Creates a shape (rectangle, cross or ellipse) to disaplay in a view |
| jafar::premodeler::Shaper | Class Shaper This class is in charge of geometrical shaping of points cloud |
| jafar::gfm_v2::MatchingResult< InterestFeatureT >::Shared | |
| jafar::sams::SHDetector | |
| jafar::premodeler::ShootPoint | |
| jafar::modeler::Modeler::shot | Structure to hold a shot |
| jafar::sift::SiftDetector | This class bind a SIFT detector to gfm |
| jafar::sift::SiftException | Base class for all exceptions defined in the module sift |
| jafar::sams::SIFTFactory | |
| jafar::sift::SiftPoint | A simple SIFT point |
| jafar::gfm_v2::DescriptorsBasedMatcher< InterestFeatureT >::similar_feature | Similar feature is a feature from ref lying at distance from match |
| jafar::gfm_v2::SimpleMatcher< InterestFeatureT > | This a simple matcher, which will look for the best points for matching in a small neighbourghood |
| jafar::gfm::SimpleMatcher | This a simple matcher, which will look for the best points for matching in a small neighbourghood |
| jafar::gfm_v2::SimpleMatcher2< DESCRIPTOR > | This a simple matcher, which will look for the best points with weak comparison (and reverse test), and confirm with strong comparison |
| jafar::gfm::SimpleMatcher2 | This a simple matcher, which will look for the best points with weak comparison (and reverse test), and confirm with strong comparison |
| jafar::simu::SimuException | Base class for all exceptions defined in the module simu |
| jafar::simupaf::SimupafException | Base class for all exceptions defined in the module simupaf |
| jafar::ride::SingleTrajectory | SingleTrajectory class |
| jafar::sas::sir | |
| jafar::slam::SlamEkf | This class solves SLAM problem using the EKF-based academic solution |
| jafar::slammm::MultiMapsSlam::SlamEkfInfo | This structure contains a filter and various information |
| jafar::slam::SlamEventAdapter | Adapter for Slam listeners |
| jafar::slam::SlamEventListener | Interface for Slam listeners |
| jafar::slam::SlamException | Base class for all exceptions defined in the module slam |
| jafar::geomslam::SlamInvDepthPointDriver | This class provides a geom::Point3D::Driver for a geom::Point3D , that uses the 3D position of a point coming from the slam |
| jafar::slamlines::SlamlinesException | Base class for all exceptions defined in the module slamlines |
| jafar::slammm::SlammmException | Base class for all exceptions defined in the module slammm |
| jafar::splamf::SlammmMapsTransformation | This is use to transform information in spaf feature to different map reference |
| jafar::splamf::SlammmSpafDBSynchroniser | |
| jafar::geomslam::SlamPointDriver | This class provides a geom::Point3D::Driver for a geom::Point3D , that uses the 3D position of a point coming from the slam |
| jafar::slamseg::SlamPredictor< _TModel_, _TFeature_ > | |
| jafar::slampt::SlamptException | Base class for all exceptions defined in the module slampt |
| jafar::slamptseg::SlamptsegException | Base class for all exceptions defined in the module slamptseg |
| jafar::slamseg::SlamsegException | Base class for all exceptions defined in the module slamseg |
| jafar::geomslam::SlamSegmentDriver | This class provides a geom::Segment3D::Driver for a geom::Segment3D , that uses the 3D position of a point coming from the slam |
| jafar::splamf::SlamSpafDBSynchroniser | |
| jafar::image::Slice | |
| jafar::image::SliceRoi::SliceImpl | |
| jafar::image::ConvexRoi::SliceImpl | |
| jafar::image::SliceRoi | Generic Roi (non convex) implemented with slices NOT TESTED AT ALL (in particular union, intersection and scaling) so NEEDS TESTING BEFORE USING |
| jafar::ride::Slot | Slot object |
| jafar::ddf::SNConnectCore | |
| jafar::ddf::SNConnectStruct | |
| jafar::sams::SNNMatcher | |
| jafar::dseg::SobelDirRotationProbability2SegmentProbabilityEstimator | |
| jafar::dseg::SobelSegmentProbabilityEstimator | |
| jafar::ddfsimu::RobotSimu::SortedBufferItem | |
| jafar::spafdb::SpafDB | This is the data base for storing features |
| jafar::spafdb::SpafdbException | Base class for all exceptions defined in the module spafdb |
| jafar::spaf::SpafException | Base class for all exceptions defined in the module spaf |
| jafar::spafgraph::SpafgraphException | Base class for all exceptions defined in the module spafgraph |
| jafar::bundle::SparseBundleAdjustment | Class SparseBundleAdjustment It's an interface to Lourakis Sparse Bundle Adjustment
I started recoding in cpp templated way but haven't time to finish it |
| jafar::geom::SparseOG | |
| jafar::rtslam::SpecificChildOf< Parent > | |
| jafar::ride::speedRange | |
| jafar::ddf::SpeedUpInfoStruct | |
| jafar::gdhe::Sphere | |
| jafar::rtslam::SphericalGrid< Cell > | A grid in spherical coordinates theta,phi,r with dynamic slicing of theta according to phi so that all (theta,phi) cells have approximately the same area (typically only one at the poles) |
| jafar::premodeler::Spheroid | |
| jafar::splamf::SplamfException | Base class for all exceptions defined in the module splamf |
| jafar::ride::SplitGroup | Define group parameters and constraints for split |
| jafar::sas::SRoi | Saliency Roi structure |
| jafar::imdesc::SSDetector | |
| jafar::sams::SSDetector | |
| jafar::rtslam::ExtendedKalmanFilterIndirect::StackedCorrection | |
| jafar::fdetect::STARDetector | This class binds OpenCV2 STARDetector to fdetect STAR detector is a modified version of CenSurE features detector |
| jafar::fdetect_v2::STARDetectorT< InterestFeatureT > | This class binds OpenCV2 STARDetector to fdetect STAR detector is a modified version of CenSurE features detector |
| jafar::slammm::StartNewMapStrategy | This class control when a new map is created by the MultiMapManager |
| jafar::rtslam::HistoryManagerSparse::State | |
| jafar::ride::State | State of an UAV in the formation |
| jafar::slam::FreeStateCollector::StateBlock | |
| jafar::facetsmap::StaticMaillage< T > | |
| jafar::dseg::StaticPredictor | It's a Predictor that "grow" the covariance of the predictor from a given amount |
| jafar::dseg::StatisticalComparison | This class should be used to compute repeatibility of segments detection on a "still" image (aka image taken with a camera that doesn't move, or an image which have been filtered) |
| jafar::homography::HomographyEstimator::Statistics | |
| jafar::slam::GlobalMapManager::Stats | |
| jafar::slam::SlamEkf::Stats | |
| jafar::slampt::ImagePointManager::Stats | |
| jafar::lgl::Stats< Class > | |
| jafar::slam::AbstractMapManager::Stats | |
| jafar::camera::StereoBench | Stereo bench model |
| jafar::camera::StereoBenchHandler | Class StereoBenchHandler handles StereoBench WARNING project and imageToCameraFrame methodes uses left camera |
| jafar::stereo::StereoException | Base class for all exceptions defined in the module stereo |
| jafar::hpm::StereoHarrisPoint | Represent an interest point |
| jafar::slam::StereoImagePluckerFeatureObserveModel | Observation Model using a Stereo head, two uvd points for init, two rho-thetas for updates |
| jafar::slam::StereoImagePointFeatureObserveModel | Sizeless point from stereo images observe model |
| jafar::slampt::StereoImagePointManager | Class for stereovision slam with a stereovision bench and when features are interest points extracted from an image |
| jafar::datareader::StereoImageReader | This class makes it easy to read stereo images from a sequence |
| jafar::stereo::StereoOGSensorModel | |
| jafar::jstereopixel::StereoPixel | Use this class for creating 3D images from a stereo bench |
| jafar::datareader::StereoReader | This class is use to access the data of stereo bench |
| jafar::slam::StereoSegmentObservation | Observation of a segment |
| jafar::stereosimu::Stereosimu | A class for representing a simulation of stereo For moment, we have a base DTM and we compute some 3d Image on the base of this DTM and a model of camera |
| jafar::stereosimu::StereosimuException | Base class for all exceptions defined in the module stereosimu |
| jafar::hpm::StereoTrackingEngine | Special engine to track points in a stereo image sequence |
| jafar::ddf::StopWatch | Measure the elapsed time |
| jafar::spafdb::Storage | This class is used to store features inside a SpafDB , there is no reason to use this class directly, except from inside a query |
| boost::numeric::ublas::storage_array< E > | |
| jafar::ddf::StoreiI< PARAMS > | |
| jafar::sas::sTrack | |
| jafar::geom::VoxelSpace< _dimension_, _TObject_, _BoundingBoxGetter_ >::StreamFunctor | |
| jafar::cutter::Substracter | Class Substracter Extracts an object over an image given a filled image and an empty image |
| jafar::surf::SurfDetector | This class bind a SURF detector to gfm |
| jafar::fdetect::SURFDetector | This class binds OpenCV2 SURF detector to fdetect |
| jafar::fdetect_v2::SURFDetectorT< InterestFeatureT > | This class binds OpenCV2 SURF detector to fdetect |
| jafar::surf::SurfException | Base class for all exceptions defined in the module surf |
| jafar::icp::SVDICP | Class SVDICP stands for ICP using SVD Taken from "Estimating 3-D rigid body transformations: a comparison of four major
algorithms", Eggert et al 97' Originally from Arun et al |
| boost::numeric::ublas::symmetric_adaptor< M, TRI > | |
| boost::numeric::ublas::symmetric_matrix< T, TRI, L, A > | |
| jafar::calife::T3D | |
| jafar::geom::T3D | A generic 3D transformation, support for uncertain transformation |
| jafar::geom::T3DEuler | A 3D transformation, the rotation is represented with Euler angles |
| jafar::geom::T3DIdentity | |
| jafar::geom::T3DQuaternion | A 3D transformation where the rotation is represented with a quaternion |
| jafar::geom::T3DRotationVector | A 3D transformation the rotation is represented with a quaternion |
| jafar::ride::tagSlot | Tag for slot allocation |
| jafar::ddfsimu::demo::Target | |
| jafar::ddfsimu::demo::TargetsPredictModelFactory | |
| jafar::rtslam::ObservationAbstract::Tasks | Tasks |
| jafar::modeler::Taylor | Taylor has nothing to do with the mathematician |
| jafar::lgl::TDecomposer< T, RasterT > | Abstract class that all terrain decomposers (bin tree, quadtree or any rectangular clustering) |
| jafar::rtslam::RobotConstantMotionModel< LIN_ORDER, ANG_ORDER >::TempVariables | |
| jafar::rtslam::RobotCenteredConstantVelocity::TempVariables | |
| jafar::rtslam::RobotInertial::TempVariables | |
| jafar::rtslam::RobotOdometry::TempVariables | |
| jafar::rtslam::RobotConstantVelocity::TempVariables | |
| jafar::ddfsimu::demo::Test_Dump< SNODE_CLASS > | |
| jafar::ddfsimu::demo::test_SimuSensorNode< SNODE_CLASS > | |
| jafar::textures::TexturesException | Base class for all exceptions defined in the module textures |
| jafar::ddf::Thread_Periodic_Func< T > | This is the class (functionnal object) associated to a nodal thread |
| jafar::rtslam::display::ThreadSafeGarbageCollector< T > | Release and garbageCollect are thread safe but garbageCollect is not thread safe with itself, but it is not useful (would need another mutex) |
| jafar::ride::Threat | Threat |
| jafar::kernel::detail::TicTocChrono | Global chronos for tic() and toc() interactive functions |
| jafar::ddf::time | A toolbox for time management (absolute and duration) |
| jafar::ride::TimeLine | Set of constraints structured with the trajectory |
| jafar::kernel::Timer | |
| jafar::ddf::Timer_Command | This is a class for controlling the execution of a thread (a nodal filter, a channel manager, etc) One can run/stop the execution of the thread, and kill the process (return from the main function) |
| jafar::ride::timeRange | |
| jafar::kernel::Timestamp | |
| TimestampManager | |
| TimestampSensor | |
| jafar::velodyneutils::ToHDL< PointInT > | **************************************************************************** ToHDL |
| jafar::lgl::tr1Node | Structure for intermediate computation during the PursuitGraph construction |
| jafar::lgl::tr2Node | }}} |
| jafar::gfm::tracks::track | This class is used to store a track (= a list of interests points) |
| jafar::klt::TrackedObject | Contains parameters to describe the object which is tracked, and some functions to update it |
| jafar::traversability::Tracker | Tracker is a wrapper class for the possible feature matchers and trackers available within JAFAR |
| jafar::sas::BK_IRT::tracker | |
| jafar::ddfsimu::TrackerSimu< T_OBS > | Measure the relative distance to targets and robots |
| jafar::ddfsimu::TrackerSimuUncorr | |
| jafar::hpm::TrackingEngine | Special engine to track points in an image sequence |
| jafar::dseg3d::TrackingResult | |
| jafar::gfm::tracks::TrackListRemovePred | This structure is designed to used remove_if of the STL |
| jafar::spaf::TrackResult | |
| jafar::ddfsimu::TrackRobot< T_OBS > | |
| jafar::ddfsimu::TrackRobotUncorr | |
| jafar::gfm::tracks | This class defines the container designed to store the list of tracks |
| jafar::ride::Trajectory | Trajectory object |
| jafar::gdhe::Trajectory | |
| jafar::slam::TrajectoryPoseRecord | A pose from the trajectory |
| jafar::slam::TrajectoryPoseRecordKey | |
| jafar::ride::TrajElt | Trajectory Element, line or circle's arc |
| jafar::geom::Transferrable< dimension > | Transferrable are objects whose reference can be changed |
| jafar::geom::Transformable< dimension > | Transferrable are objects whose reference can be changed |
| jafar::graphmap::Transformation | |
| jafar::dseg::TranslationPredictor | It's a Predictor that "grow" the covariance of the predictor from a given amount |
| jafar::traversability::TraversabilityException | Base class for all exceptions defined in the module traversability |
| jafar::localizer::Tsai2dLocalizer | Class Tsai2d, used to save image and localisation data |
| jafar::localizer::Tsai3dLocalizer | Class Tsai3d, used to compute a trsanformation matrix in 3D |
| jafar::localizer::TsaiLocalizer | Class TsaiLocalizer, mother class for Tasai2dLocalizer and Tsai3dLocalizer It's a reimplementation in jafar of calife TSAI2D_ext and TSAI3D_ext We choosed to make profit of inheritance mechanism to represent the above classes It uses camera's intrinsic parametes and linear least square resolver to compute the transition matrix |
| jafar::geom::Segment< dimension >::TwoPointsDriver | |
| jafar::geom::Line< dimension >::TwoPointsPointerDriver | The TwoPointsPointerDriver is used for Line for which we knows two points |
| jafar::geom::Segment< dimension >::TwoPointsPointerDriver | |
| boost::numeric::ublas::unbounded_array< T, ALLOC > | |
| jafar::jmath::uniform_distribution< double > | Uniform distribution double specialized |
| jafar::jmath::uniform_distribution< float > | Uniform distribution float specialized |
| jafar::jmath::uniform_distribution< int > | Uniform distribution int specialized |
| jafar::jmath::uniform_distribution< unsigned int > | Uniform distribution unsigned int specialized |
| jafar::jmath::UNIFORM_GENERATOR< T > | |
| jafar::jmath::UniformDistribution | Uniform distribution generator using the Boost random library |
| boost::numeric::ublas::unit_vector< T > | |
| jafar::ride::unprotectedSlot | Return status for defensive jamming (unprotected slots) |
| jafar::ddfsimu::Upd_const_acc | Prediction model for a constant acceleration process |
| jafar::ddfsimu::Upd_const_pose | Constant position model |
| jafar::ddfsimu::Upd_const_speed | Prediction model for a constant velocity process |
| jafar::ddf::Upd_lin_pred_model< PARAMS > | This class derives from a Linear_invertable_predict_model such as x(k|k-1) = F(x(k-1|k-1)) + G(k)w(k) q(k) = state noise covariance, q(k) is covariance of w(k) G(k) = state noise coupling invF exists and PredictionEngineBase |
| jafar::ddfsimu::Upd_targets | |
| jafar::kernel::VariableCondition< T > | This class represents a standalone variable condition quite limited but can be useful |
| VariableConditionPlus< T > | ############################################################################ ############################################################################# Slam function ########################################################################### |
| jafar::kernel::VariableMutex< T > | This class wraps a simple variable with a mutex very limited but can be useful for lazy people respects the Lockable concept |
| jafar::ride::Vect | Generic vector with operators for math operations |
| jafar::facetsmap::vect_op< dim, RT, C1, C2 > | This class is intended to compute a dot product between two vectors |
| jafar::facetsmap::vect_op< 1, RT, C1, C2 > | |
| boost::numeric::ublas::vector< T, A > | |
| vector_container | |
| jafar::jmath::vector_file< T > | Class vector_file loads/saves data into/from a vector from/to a file |
| boost::numeric::ublas::vector_of_vector< T, L, A > | |
| boost::numeric::ublas::vector_temporary_traits< banded_adaptor< M > > | |
| boost::numeric::ublas::vector_temporary_traits< const banded_adaptor< M > > | |
| boost::numeric::ublas::vector_temporary_traits< symmetric_adaptor< M, TRI > > | |
| jafar::geom::Repere< dimension >::VectorsDriver | |
| jafar::geom::HyperPlane< dimension >::VectorsDriver | |
| jafar::geom::OrientedPlan< dimension >::VectorsDriver | VectorsDriver builds an OrientedPlan given a frame, an origin and optionnaly a reference frame |
| jafar::ddfsimu::VelocitySimu< T_OBS > | This is a velocity sensor for an AccelMotion |
| jafar::ddfsimu::VelocitySimuUncorr | |
| jafar::velodyneutils::VelodyneutilsException | Base class for all exceptions defined in the module velodyneutils |
| jafar::modeler::KinectModeler::vertex | Holds all the data about a vertex |
| jafar::modeler::Modeler::vertex | Holds all the data about a vertex |
| jafar::graphmap::Vertex_Properties | |
| jafar::bundler::View | Class View, used to save image and localisation data |
| jafar::viewer3d::View3D | This class provides a simple View for 3D objects |
| jafar::graphmap::display::Viewer | |
| jafar::rtslam::display::Viewer< WorldDisplayType, MapDisplayType, RobotDisplayType, SensorDisplayType, LandmarkDisplayType, ObservationDisplayType, GarbageType > | ************************************************************************** This is the base class for a viewer that can render the scene |
| jafar::qdisplay::Viewer | This is the viewer, you can add ImageView to display on it, or overlay using Shape |
| jafar::viewer3d::Viewer3D | This class provide a window with an embedded View3D and some visual elements to control the camera, the configuration.. |
| jafar::viewer3d::Viewer3dException | Base class for all exceptions defined in the module viewer3d |
| jafar::rtslam::display::ViewerAbstract | ************************************************************************** This is the base class for a viewer |
| jafar::rtslam::display::ViewerEx | |
| jafar::qdisplay::ViewerManager | ViewerManager gives access to all active Viewer |
| jafar::premodeler::ViewIF | Structure used to save current View Interest Feature |
| jafar::premodeler::ViewMR | Structure used to save current View Matching Result |
| jafar::sams::ViewPartLink | |
| jafar::bundler::ViewsManager | Class ViewsManager, used to handle views |
| jafar::bundler::ViewsManager2 | Class ViewsManager2, used to do ray intersections computing |
| jafar::lgl::VisibilityMap | }}} |
| jafar::rtslam::VisibilityMap | This class is a map that keeps records of places frome where a landmark was or was not visible, in order to avoid to repeatedly search a landmark from a place it cannot be seen |
| jafar::lgl::VisibleArea | Definition of VisibleAreaClass |
| jafar::velodyneutils::Visualizer | **************************************************************************** Visualizer |
| jafar::velodyneutils::VisualizerCloud< PointT > | **************************************************************************** VisualizerCloud |
| jafar::velodyneutils::VisualizerNormals< PointT > | **************************************************************************** VisualizerNormals |
| jafar::vme::VmeEngine | Visual Motion Estimator (VME) |
| jafar::vme::VmeEngineParams | This class contains parameters for the vme algorithm |
| jafar::vme::VmeException | Base class for all exceptions defined in the module vme |
| jafar::ride::VoronoiBase | Basic voronoi cell |
| jafar::geom::VoxelSpace< _dimension_, _TObject_, _BoundingBoxGetter_ >::Voxel | |
| jafar::slam::details::VoxelCoord | |
| jafar::geom::VoxelIndexLess | |
| jafar::geom::VoxelMultiDimensionStorage< _dimension_, _T_, _level_ > | This class is use internally by VoxelSpace to store the data, there is no reason to use it directly |
| jafar::geom::VoxelMultiDimensionStorage< _dimension_, _T_, 1 > | |
| jafar::geom::VoxelSpace< _dimension_, _TObject_, _BoundingBoxGetter_ > | This class allow to store geometric objects in a voxel space |
| jafar::image::vsep_ | |
| jafar::rtslam::simu::Waypoint | |
| jafar::ride::Waypoint | Waypoint |
| jafar::rtslam::WeakParentOf< Child > | |
| jafar::rtslam::WeakParentOf< Child >::WeakPtrComparison | |
| jafar::jmath::WeightedGaussianVector | A weighted gaussian vector, add a weight to a GaussianVector |
| jafar::gfm::WindowMatchFocus | Focus the search on a rectangle around the interest point |
| jafar::rtslam::WorldAbstract | Base class for all world types defined in the module rtslam |
| jafar::rtslam::display::WorldDisplay | ************************************************************************** |
| jafar::rtslam::display::WorldEx | |
| jafar::velodyneutils::WriterPCD< PointT > | **************************************************************************** WriterPCD |
| jafar::modeler::XYZMayBeN | |
| boost::numeric::ublas::zero_matrix< T > | |
| boost::numeric::ublas::zero_vector< T > | |
| jafar::correl::Zncc | |
