| Abstract | Abstract class to render this object |
| kjb::Abstract_dynamics | |
| Abstract_gibbs_step< Model > | |
| Abstract_hmc_step< Model, CONSTRAINED_TARGET, INCLUDE_ACCEPT_STEP, REVERSIBLE > | |
| Abstract_mh_step< Model, Proposer > | |
| kjb::Abstract_renderable | |
| Abstract_sampler< Model, Recorder > | |
| kjb::Abstract_video | |
| kjb::psi::Action | |
| kjb::psi::Action_descriptor | |
| All_log_recorder< Model > | |
| All_model_recorder< Model > | |
| Annealable< X > | |
| Annealing_mh_step< Model, Proposer > | |
| Annealing_proposer_wrapper< Proposer, Model > | |
| Annealing_sampler< Model, Recorder > | |
| array | |
| kjb::stracking::Association< Track > | A class that represents a MCMCDA association |
| Association_directory | Later |
| kjb::Axis_aligned_rectangle_2d | Class that represents an axis-aligned 2D rectangle. It is defined in terms of its (2D) center, its width and its height |
| kjb::psi::Back_projector | |
| kjb::Base_gl_interface | |
| base_model_archetype | |
| BaseModel< X > | |
| Basic_gibbs_step< Model > | |
| Basic_hmc_step< Model, CONSTRAINED_TARGET, INCLUDE_ACCEPT_STEP, REVERSIBLE > | |
| Basic_mh_step< Model, Proposer_type > | |
| Basic_sd_step< Model, REVERSIBLE > | |
| kjb::psi::Bbox_noise_likelihood | |
| kjb::psi::Bbox_pairwise_likelihood | |
| Best_model_recorder< Model > | |
| Best_target_recorder< Model > | |
| kjb::Bezier_curve | |
| Blob | A simple class that represents a blob |
| Blob_detector | A blob detector class. Use operator() to apply to image |
| kjb::Calibrated_camera | |
| kjb::Calibration_descriptor | |
| kjb::Canny_edge_detector | |
| kjb::Cant_happen | |
| kjb::Cant_happen_exception | |
| kjb::Categorical_distribution< T > | A categorical distribution |
| kjb::Chamfer_transform | |
| kjb::Circle | |
| kjb::circular_iterator< iterator > | |
| kjb::Cloneable | Abstract class to clone this object |
| kjb::Collinear_segment_chain | Represent a collinear line segment, a collinear line segment is inherited from an Line_segment |
| kjb::Color_histogram | Class to compute an RGB colour histogram over an image or a rectangular portion of it. The histogram is normalized. We use the same number of bins for each of the channels (r,g,b). It is easy to extend this class so that it computes such histogram over a segment of a shape other than rectangular |
| kjb::Color_likelihood | Functor that computes the likelihood of a set of projected faces onto an image, using the color distribution of each projected face. More later.. |
| kjb::Colormap | |
| kjb::Comparable_omap | |
| kjb::Compare_address< T > | Predicate that returns true if address of element equals given |
| kjb::Line_correspondence::Line_bin::Compare_edge_segment_starting_points | Compare the corresponding Line_bin based on the x position of the starting point of the image edge segment |
| kjb::Correspondence::Point::Compare_Normal_Distance | |
| kjb::compare_point_x_location | |
| kjb::psi::Complete_state | |
| Compute_blob | |
| Computes | |
| kjb::Conditional_distribution< TargetVariable, GivenVariable, DependenceFunc > | A conditional distribution |
| Conditional_distribution_proposer< ConditionalDistribution, Model > | |
| kjb::const_circular_iterator< const_iterator > | |
| Constant_parameter_evaluator< Model > | Returns the same result no matter what model is received |
| Constrained_target< Model > | Adapts a target distribution to be one with bounds |
| kjb::Corner | Class to manipulate a 2D corner. The corener is defined in terms of a set of line segments all intersecting at a point in the image, which is the corner position. No consistency controls are performed here |
| kjb::Correspondence | |
| kjb::psi::Cuboid | |
| Current_log_recorder< Model > | |
| Current_model_recorder< Model > | |
| kjb::opencv::CV_features_to_track_detector | |
| kjb::opencv::CV_term_criteria | |
| kjb::Cylinder | Geometric cylinder class. For renderable cylinder, see kjb::opengl::Cylinder |
| kjb::psi::Cylinder_world_likelihood | |
| kjb::psi::Cylinder_world_visualizer | |
| kjb::stracking::Data< Element > | A class that holds data for the tracking problem |
| kjb::Dimension_mismatch | |
| kjb::Discrete_change_size | |
| kjb::Distribution_traits< Distribution > | Generic traits struct for all distributions |
| kjb::Distribution_traits< Categorical_distribution< T > > | Traits for the categorical distro |
| kjb::Distribution_traits< Log_normal_distribution > | |
| kjb::Distribution_traits< Mixture_distribution< Distribution > > | Traits for the mixture distro. Type is the type of the mixed distributions |
| kjb::Distribution_traits< MV_gaussian_distribution > | Traits for the multivariate normal. Type is kjb::Vector |
| kjb::Divide_by_zero | |
| kjb::Edge | |
| kjb::Edge_lines_likelihood | |
| kjb::Edge_point | |
| kjb::Edge_segment | |
| kjb::Edge_segment_set | Class to manipulate a set of edge segments |
| kjb::Edge_set | |
| kjb::Index_range::End_type | |
| kjb::psi::Entity_id | |
| kjb::psi::Entity_state | |
| Event_listener | |
| kjb::Every_nth_element< T > | Predicate that returns true every nth call |
| kjb::Exception | Base class of all exceptions in the jwsc++ library |
| Expectation_recorder< Model, Value > | |
| Experiment_directory | Later |
| kjb::psi::Face_data | |
| Features | Allows to manipulate basic 2d image features (edges, fitted line segments and manhattan worl). This is mostly useful for Manhattan world scenes so it might be renamed. This class contains the following features:
- edges detected from an image
- edge segments line segments fitted to the image edges
- manhattan world features for a Manhattan world scene
|
| kjb::Features_manager | |
| kjb::psi::File_format_exception | |
| kjb::Filter | Filter class |
| kjb::psi::Flow_feature_comparator | Compare two feature pairs |
| kjb::Focal_scale_dynamics | |
| kjb::psi::Frame_likelihood | |
| kjb::Gaussian_process< MeanFunction, CovarianceFunction > | Represents a Gaussian process which can be realized and from which one can predict and compute pdfs |
| Gaussian_random_walk_proposer | |
| Gaussian_scale_space | |
| Gaussian_scale_space_generator | |
| kjb::Generic_const_matrix_view< Matrix_type > | |
| kjb::Generic_matrix_view< Matrix_type > | |
| kjb::Generic_multimin< T > | |
| kjb::Generic_renderable | |
| kjb::Generic_renderer | |
| kjb::stracking::Generic_track< E > | A class that represents a generic MCMCDA track |
| kjb::psi::Generic_trajectory< T > | Represents a trajectory. Vector of optionals to trajectory elements |
| kjb::psi::Generic_trajectory_element< T > | Represents an element of a trajectory of a particular entity |
| kjb::psi::Generic_trajectory_map< T > | Represents a set of trajectories; it is a map from entity to trajectory |
| kjb::Geodesic_sphere | |
| kjb::Geometric_distribution | |
| kjb::Get_address< T > | Functor that returns the address of a given object |
| Get_model_parameter< Model > | Gets the specified parameter of a model. For now, we assume all parameters are type double |
| Gibbs_model_proposer< Model > | |
| kjb::stracking::Gibbs_proposer< Track, Lhood > | Gibbs proposal mechanism for tracking. Complies with Gibbs proposer concept |
| kjb::GL_Polygon_Renderer | |
| kjb::GL_Polymesh_Renderer | |
| kjb::opengl::Glew | |
| kjb::Glut_parapiped | |
| kjb::Glut_perspective_camera | |
| kjb::Glut_polymesh | |
| GLUT_polymesh | |
| kjb::psi::Ground_back_projector | |
| kjb::psi::Ground_truth_track_visualizer | |
| gsl_matrix | |
| kjb::Gsl_multifit_fdf | |
| gsl_multifit_function_fdf | |
| kjb::Gsl_Multimin_f | Wrapper for GSL's multidimensional minimizer, without using gradient |
| kjb::Gsl_Multimin_fdf | Wrapper for GSL's multidimensional minimizer, when you have gradient |
| gsl_multimin_function | |
| gsl_multimin_function_fdf | |
| kjb::Gsl_Qrng_basic< KIND > | Wrapper for one of GSL's quasi-random generators |
| kjb::Gsl_Qrng_Halton | Quasi-random generator using the algorithm of Halton |
| kjb::Gsl_Qrng_Niederreiter | Quasi-random generator using the algorithm of Bratley et al |
| kjb::Gsl_Qrng_Rvs_Halton | Quasi-random generator using the algorithm of Vandewoestyne et al |
| kjb::Gsl_Qrng_Sobol | Quasi-random generator using the algorithm of Antonov and Saleev |
| kjb::Gsl_ran_discrete | Randomly sample discrete events with an empirical distribution |
| kjb::Gsl_rng_basic< KIND > | Basic RAII wrapper for GNU GSL random number generators |
| Gsl_rng_cmrg | Random number generator using L'Ecuyer's 1996 algorithm. This implements the Combined Multiple Recursive Generator algorithm of L'Ecuyer (1996). Period is 10 ** 56. Defined using macro Gsl_rng_template |
| Gsl_rng_gfsr4 | Random number generator using a four-tap XOR using a shift register. This uses Ziff's offsets (1998) and is very fast |
| Gsl_rng_mrg | Random number generator using 1993 algorithm of L'Ecuyer et al. This implements the Multiple Recursive Generator algorithm of L'Ecuyer et al. (1993). Period is 10 ** 46. Defined using macro Gsl_rng_template |
| Gsl_rng_mt19937 | Random number generator using the "Mersenne Twister" algorithm. This implements the "Mersenne Twister" of Matsumoto and Nishimura. The period is about 10 ** 6000. This is an all-around good PRNG. Defined using macro Gsl_rng_template |
| Gsl_rng_ranlxd1 | Random number generator using the "RANLUX" algorithm, 48 bits, lvl. 1 This implements the "RANLUX" algorithm of Luescher at double precision. This is a "luxury random number" algorithm, i.e., slow. This one is "level 1" so it's not as decorrelated as level 2. Period is 10 ** 171. Defined using macro Gsl_rng_template |
| Gsl_rng_ranlxd2 | Random number generator using the "RANLUX" algorithm, 48 bits, lvl. 1 This implements the "RANLUX" algorithm of Luescher at double precision. This is a "luxury random number" algorithm, i.e., slow. This one is "level 2" so it's the most decorrelated. Period is 10 ** 171. Defined using macro Gsl_rng_template |
| Gsl_rng_ranlxs0 | Random number generator using the "RANLUX" algorithm, 24 bits. This implements the "RANLUX" algorithm of Luescher at single precision, i.e., meant for a float not a double. This is a "luxury random number" algorithm, i.e., slow. Nevertheless this one is "level 0" so it's the entry-level luxury model. Period is 10 ** 171. Defined using macro Gsl_rng_template |
| Gsl_rng_ranlxs1 | Random number generator using the "RANLUX" algorithm, 24 bits. This implements the "RANLUX" algorithm of Luescher at single precision, i.e., meant for a float not a double. This is a "luxury random number" algorithm, i.e., slow. This one is "level 1" so it's the mid-level luxury model. Period is 10 ** 171. Defined using macro Gsl_rng_template |
| Gsl_rng_ranlxs2 | Random number generator using the "RANLUX" algorithm, 24 bits. This implements the "RANLUX" algorithm of Luescher at single precision, i.e., meant for a float not a double. This is a "luxury random number" algorithm, i.e., slow. This one is "level 2" so it's the top-level luxury model. Period is 10 ** 171. Defined using macro Gsl_rng_template |
| Gsl_rng_taus2 | Random number generator using Tausworthe's algorithm. This is L'Ecuyer's version of Tausworthe's algorithm (or something like that). Period is 10 ** 26. Defined using macro Gsl_rng_template |
| gsl_vector | |
| kjb::Gsl_Vector | RAII wrapper for GSL vector objects |
| kjb::Histogram | A class that represents a histogram of data. ATM, the data must be doubles |
| kjb::psi::Human_boxes | |
| kjb::Identity< T > | Identity function |
| kjb::Illegal_argument | |
| kjb::Image | Wrapped version of the C struct KJB_image |
| kjb::Imogp_distribution | Convenienence class to handle the distributions of a multiple output GP, where each output is independent |
| kjb::Increase_by< T > | Generator that increases (using +=) itself by the given value everytime it is called |
| kjb::Increment< T > | Generator that increments (++) its state everytime it is called. Useful for creating sequences of contigous values |
| kjb::Independent_edge_points_likelihood | |
| kjb::Independent_mo_gaussian_process< MeanFunction, CovarianceFunction > | Represents a Gaussian process which can be realized and from which one can predict and compute pdfs |
| kjb::Index_less_than< T > | Predicate that compares the kth element of a indexable type |
| kjb::Index_out_of_bounds | |
| kjb::Index_range | |
| kjb::psi::Input_directory | Represents the input directory for the PSI tracking project |
| kjb::Int_matrix | This class implements matrices, in the linear-algebra sense, restricted to integer-valued elements |
| kjb::Int_vector | This class implements vectors, in the linear-algebra sense, restricted to integer-valued elements |
| kjb::gui::Interactive_object | |
| kjb::Interval_sequence | |
| kjb::IO_error | |
| kjb::KJB_error | |
| kjb::stracking::Likelihood< Track > | Computes the GP-based likelihood of an association |
| kjb::Likelihood_dynamics | |
| Line | |
| kjb::Line | Parametric representation of a 2D line in terms of three parameters (a,b,c) (as in ax+by+c = 0) |
| kjb::Line_correspondence::Line_bin | |
| kjb::Line_correspondence | |
| kjb::Line_segment | Class to manipulate a line segment The class is parametrized in terms the position of the centre, its length and orientation. This is thus compatible with the output of the Berkeley edge detector. We store also the start point, the end point and the line parameters describing this line segment (for more details on how the line parameters work, please see the class line). This is redundant information, but it is convenient to have all these parameters precomputed and at hand |
| kjb::Line_segment_set | Class to manipulate a set of line segments |
| kjb::Log_normal_distribution | Log-normal distribution |
| kjb::Manhattan_corner | |
| kjb::Manhattan_corner_segment | |
| kjb::Manhattan_segment | A manhattan segment defined by a line segment and the vanishing point it converges to |
| kjb::Manhattan_world | This class contains the three orthogonal vanishing points defining a Manhattan scene, where most or all planes are aligned with three main orthogonal directions. This class optionally contains a set of segments from the scene, assigned to the correct vanishing point |
| map | |
| kjb::Matrix | This class implements matrices, in the linear-algebra sense, with real-valued elements |
| kjb::Matrix_d< NROWS, NCOLS, TRANSPOSED > | |
| kjb::Matrix_stream_io | |
| kjb::Matrix_traits< value_type > | |
| kjb::Matrix_traits< double > | |
| kjb::Matrix_traits< int > | |
| kjb::MD5 | Message Digest 5 computation, using OpenSSL code |
| Mh_model_proposer< Model > | |
| Mh_proposal_result | Indicates the result of an MH proposal. It is simply a pair of probabilities, forward and backward |
| kjb::Missing_dependency | |
| kjb::Missing_option | |
| kjb::Mixture_distribution< Distribution > | This class implements a mixture distribution. In other words, it is the sum of a finite number of fractions of distributions of the same type (with different parameters) |
| kjb::psi::Model | |
| Model_dimension< Model > | Returns the dimension of the model |
| Model_edge | |
| kjb::Model_edge | |
| Model_evaluator< Model > | |
| kjb::psi::Model_evaluator | |
| model_evaluator_archetype< Model > | |
| Model_parameter_evaluator< Model > | |
| model_proposer_archetype< Model > | |
| Model_recorder< Model > | |
| model_recorder_archetype< Model > | |
| ModelEvaluator< Func, Model > | |
| ModelProposer< Func, Model > | |
| ModelRecorder< X > | |
| Modulo_recorder< Recorder > | |
| Move_model_parameter< Model > | Moves the specified parameter of a model. For now, we assume all parameters are type double |
| Move_model_parameter_as_plus< Model > | Default move function; uses '+' |
| Multi_model_recorder< Model > | |
| Multi_proposer_proposer< Model > | |
| Multi_step_sampler< Model, Recorder > | |
| kjb::MV_gaussian_distribution | Multivariate Gaussian (normal) distribution |
| kjb::Mv_generic_renderable | |
| kjb::MV_normal_on_normal_dependence | Represents the dependence between X and Y in p(x | y), where (x,y) is a multivariate normal |
| kjb::Mv_renderable | Abstract class to render an object that has many possible views |
| kjb::Mv_solid_render_wrapper | |
| kjb::Mv_wire_occlude_render_wrapper | |
| kjb::Mv_wire_render_wrapper | |
| kjb::Normal_on_normal_dependence | Represents the dependence between X and Y in p(x | y), where (x,y) is a bivariate normal |
| kjb::Not_implemented | |
| Null_event_listener | |
| Null_recorder< Model > | |
| Null_value | |
| Numerical_gradient< Model > | Approximates the gradient of a target distribution, evaluated at a certain location. The user must provide the mechanisms to change the model (see constructor) |
| kjb::Nurbs_curve | |
| kjb::Nurbs_surface | |
| kjb::Offscreen_buffer | Offscreen rendering buffer |
| kjb::opengl::Opengl_callable | |
| kjb::Opengl_framebuffer_image | |
| kjb::OpenSSL_EVP | Generic OpenSSL hasher class, the base class for specific derivations |
| kjb::Option | Base program option |
| kjb::Option_exception | |
| kjb::Option_no_arg | Option that does not take an argument |
| kjb::Option_with_arg | Option that takes an argument |
| kjb::Options | Collection of Options for processing |
| Ostream_recorder< Recorder > | |
| kjb::psi::Output_directory | Represents the output directory for the PSI tracking project |
| kjb::Parametric_camera_gl_interface | |
| kjb::Parametric_parapiped | |
| kjb::Parametric_sphere | |
| kjb::Parapiped | Parallelepiped: a hexahedron of which each face is a parallelegram |
| kjb::Parapiped_camera_dynamics | |
| kjb::Parapiped_stretch_dynamics | |
| kjb::Perspective_camera | |
| kjb::Pgpe< Evaluator > | |
| Pgpe | This class implements an gradient-based optimization method called Parameter-exploring Policy Gradients (Sehnke etc., 2010), is ported from an python implement in pybrain (http://pybrain.org/) |
| kjb::PixelHSVA | Alternative Pixel using hue, saturation, value, and opacity (alpha) |
| kjb::PixelRGBA | Wrapped version of the C struct Pixel, with Alpha (opacity) |
| kjb::Correspondence::Point | |
| kjb::Polybezier_curve | |
| kjb::Polygon | |
| kjb::Polymesh | Abstract class of connected polygons (faces) forming a mesh. We assume that each edge is shared between exactly two faces, that is to say the mesh has to be fully connected |
| kjb::Polymesh_Plane | This class contains a Vector of plane parameters, a vector of the face indices that lie in the plane, and the polymesh that the faces are from. The plane parameters are the coefficients of a plane of the form ax + by + cz + d = 0 |
| Posterior< Model > | Generic posterior class |
| kjb::stracking::Prior< Track > | Computes the prior of an MCMCDA association |
| kjb::psi::Progress_recorder | |
| kjb::psi::Psi_body_part | Body parts |
| kjb::psi::Psi_skeleton | Skeleton class, a vector of body parts |
| kjb::psi::Psi_step_size | |
| kjb::Quaternion | |
| kjb::Ransac_line_fitting | |
| kjb::Readable | Abstract class to read this object from an input stream |
| Real_hmc_step< Model, CONSTRAINED_TARGET, INCLUDE_ACCEPT_STEP, REVERSIBLE > | |
| Real_numerical_gradient< Model > | Approximates the gradient of a target distribution, evaluated at a certain location. The model in question must be a vector model |
| Real_sd_step< Model, REVERSIBLE > | |
| Recent_log_recorder< Model > | |
| Recent_model_recorder< Model > | |
| kjb::Rectangle_2d | Class that represents an axis-aligned 2D rectangle. It is defined in terms of its (2D) center, its width and its height |
| kjb::Renderable | Abstract class to render this object with GL |
| kjb::Renderable_model | |
| kjb::RenderableObject< X > | |
| kjb::Renderer | |
| kjb::Renderer_renderable | |
| kjb::Result_error | |
| kjb::Right_Triangle_Pair | |
| kjb::Rigid_object | |
| kjb::Rotation_axis | |
| kjb::Runtime_error | |
| Sampler_step< Model > | |
| kjb::Select_coordinate< V > | Selects a coordinate from a vector type |
| kjb::gui::Selectable | |
| kjb::Sequence | |
| kjb::SerializableConcept< X > | |
| kjb::Serialization_error | |
| Serialize_recorder< Recorder_type > | |
| Set_model_parameter< Model > | Sets the specified parameter of a model. For now, we assume all parameters are type double |
| kjb::psi::Simple_simulator | |
| kjb::SimpleVector< X > | |
| Single_dimension_proposer< Model > | |
| Single_step_sampler< Model, Recorder > | |
| kjb::Solid_renderable | Abstract class to render this object with GL |
| kjb::Solid_renderer | |
| kjb::Spline_curve | |
| kjb::Spline_surface | |
| kjb::Spot_detector | A blob detector class. Use operator() to apply to image |
| kjb::Squared_exponential | Class that represents the squared exponential covariance function |
| ST_SPHERE | |
| kjb::Stack_overflow | |
| kjb::Stack_underflow | |
| kjb::psi::Start_state | |
| Step_log | |
| Step_result | Structure for returning results of a single sampling move |
| kjb::Svd | Tuple that computes a singular value decomposition of a matrix |
| kjb::Quaternion::This | Sets the rotation mode of this rigid object. All euler modes are supported (XYZ, ZYZ, etc). All modes ar supported. For further details see adequately tested only in the case of mode = XYZR |
| kjb::to_ptr | Convert to a pointer |
| kjb::psi::Track_frame_metrics | |
| kjb::psi::Track_metrics | |
| kjb::psi::Track_visualizer | |
| kjb::Transformable | Abstract class to apply a linear transformation to this object |
| kjb::Triangular_mesh | Triangular_mesh: a polygonal mesh of which each face is a triangle |
| kjb::Turntable_camera | |
| Updatable< X > | |
| kjb::Vanishing_point | A vanishing point for a set of parallel lines in an image |
| kjb::Vanishing_point_detector | This class computes the position of the three vanishing points from a set of line segments. The ass |
| kjb::Vector | This class implements vectors, in the linear-algebra sense, with real-valued elements |
| kjb::Vector_d< D > | |
| Vector_hmc_step< Model, INCLUDE_ACCEPT_STEP, REVERSIBLE > | |
| vector_model_archetype | |
| Vector_numerical_gradient< Model > | Approximates the gradient of a target distribution, evaluated at a certain location. The model in question must be a vector model |
| Vector_sd_step< Model, REVERSIBLE > | |
| kjb::Vector_stream_io | |
| kjb::Vector_vector | |
| VectorModel< X > | |
| kjb::Video | |
| kjb::Video_frame | |
| Viewing_recorder< Recorder, Updater > | |
| kjb::psi::Weighted_box | |
| kjb::Wire_occlude_renderable | Abstract class to render this object with GL as an occluded wire-frame into the depth buffer, to hide unseen lines |
| kjb::Wire_occlude_renderer | |
| kjb::Wire_renderable | Abstract class to render this object with GL as a wire-frame |
| kjb::Wire_renderer | |
| kjb::Word_list | Wrapper for the libKJB type Word_list |
| kjb::Writeable | Abstract class to write this object to an output stream |
| kjb::Zero | Class that represents the zero mean function |
1.7.1
