  boost | |
  archive | |
| DTLib | |
  CAffine | |
| CCircleMasks | |
| CDOG | |
| CFilterbank | |
| CGaussKernel | |
| CHistogram | |
| CImgVec | |
| CImg | |
| CJPEG | |
| CKMeans | |
| MATFILE | |
| CSparsePatImg | |
| CTextureScale | |
| ergo | |
| mh_proposal_result | |
| kjb | Classes and functions for dealing with trajectory files |
| bbb | |
| Activity_library | |
| Activity_sequence | |
| Output_activity | |
| Get_name | |
| Get_start | |
| Get_end | |
| Get_trajectories | |
| Activity_sequence_prior | |
| Group | Group |
| Association | |
| Association_prior | |
| Data | |
| Description | |
| Description_info | Extract sparse information from description (for write()) |
| Activity_info | |
| Description_prior | |
| Sample_tree | |
| Endpoint | Class that holds information for endpoints |
| Intentional_activity | |
| Likelihood | |
| Parameter_prior | |
| Physical_activity | |
| Traj_set | |
| Trajectory | |
| Trajectory_prior | |
| Visualizer | Visualize a description and the corresponding data |
| debug | |
| flandmark | |
| geometry | |
| gpu | |
| gui | |
| Interactive_object | |
| Selectable | |
| mcmcda | |
| Compare_tracks | Functor to compare two tracks. If this were not defined, an association would order its tracks using operator<(pair, pair), which would eventually order by the address of the detection. We use this one to avoid this comparison by address and instead use a value comparison. This way the order will not change every time we read an association |
| Association | A class that represents a MCMCDA association |
| Data | A class that holds data for the tracking problem |
| Association_directory | Later |
| Experiment_directory | Later |
| Gibbs_proposer | Gibbs proposal mechanism for tracking. Complies with Gibbs proposer concept |
| Likelihood | Computes the GP-based likelihood of an association |
| Prior | Computes the prior of an MCMCDA association |
| Proposer | |
| Generic_track | A class that represents a generic MCMCDA track |
| opencv | |
| CV_features_to_track_detector | |
| CV_term_criteria | |
| opengl | |
| Glew | |
| Opengl_callable | |
| psi | |
| metrics | |
| Action | |
| Action_descriptor | |
| Entity_state | |
| Simple_simulator | |
| Deva_skeleton_boxes | |
| File_format_exception | |
| Bbox_pairwise_likelihood | |
| Bbox_noise_likelihood | |
| Frame_likelihood | |
| Model_evaluator | |
| Cylinder_world_likelihood | |
| Track_frame_metrics | |
| Track_metrics | |
| Model | |
| Person_flow_blob | A class represent the blob detection based on the optical flow magnitude images |
| Progress_recorder | |
| Psi_step_size | |
| Psi_body_part | Body parts |
| Psi_skeleton | Skeleton class, a vector of body parts |
| Skeleton_detection | Skeleton class, a vector of body parts |
| Start_state | |
| Cuboid | |
| Weighted_box | |
| pt | |
| Body_2d | 2D body information resulting from projecting the 3D body |
| Box_likelihood | Class that represents likelihood of a set of projected boxes given. detections. At the moment it only uses box size and optical flow; in the future, it may be use other data information |
| Camera_prior | Class that represents the camera prior |
| Color_likelihood | Class that represents color likelihood of a set of projected boxes given detections |
| Complete_state | Represents the state of an actor at a frame |
| Head | Simple struct representing a head |
| Box_data | |
| Detection_box | Class that represents a detection bounding box from any source |
| Direction_prior | Class that represents the prior distribution of a trajectory |
| Face_direction_prior | Class that represents the prior distribution of the face direction |
| Face_2d | 2D face information resulting from projecting the 3D head/face |
| Face_flow_likelihood | Class to compute face optical flow likelihood |
| Facemark_likelihood | Class to compute facemark likelihood |
| Input_directory | Represents the input directory for the people tracking project |
| Output_directory | Represents the output directory for the PT tracking project |
| Optimize_likelihood | Approximate complete-data likelihood via HMC optimziation |
| Optical_flow_likelihood | Class to compute face optical flow likelihood |
| Position_prior | Class that represents the prior distribution of a trajectory |
| Posterior_detail_recorder | Records the details about the posterior |
| Propose_person_size | Proposal distribution/mechanism for the size of targets |
| Sample_scenes | Use HMC to draw samples from the scene posterior using HMC |
| Scene | Class that represents a full scene in the PT universe |
| Scene_recorder | Record a series of scenes to a directory |
| Write_scene_iterator | Record a series of scenes to a directory |
| container_type | Fake container type. Needed for recorder to find the type |
| Scene_adapter | Adapts a Scene into a VectorModel for HMC sampling |
| Scene_gradient | Wrapper for generic gradient function |
| Scene_hessian | Wrapper for generic hessian function |
| Gradient_adapter | Wraps Scene_gradient to work with ergo::hmc_step |
| Pixel_move | Functor designed to move 3D points by pixels in image plane |
| Scene_posterior | Posterior distribution of a scene |
| Scene_posterior_ind | Posterior adapter to work with independent gradient computation |
| Target | Class that represents a target moving through space |
| Propagated_2d_info | Propagated 2D information using optical flow |
| Comparator_2d | Comparator for Propagated_2d_info |
| Feature_score | |
| Visibility | Represents the information regarding visibility of an actor at a given frame and given all other actors |
| qd | Support for the path algorithm I call the quasi-Dijkstra method |
| Doubly_connected_edge_list | Data structure for a planar subdivision made by edges |
| Edge_record | |
| Face_record | |
| Vertex_record | |
| DijkstraPriorityQueue | Pure virtual interface for priority queue in Dijkstra's algorithm |
| DoubleCircle | Parameterized circle in the plane |
| PixPath_expander | Expand, if possible, a PixPath to fill a specified minimum size |
| PixPath | Representation of a sequence of pixel coordinates |
| PixPoint | Representation of an (x,y) pair of pixel coordinates |
| Is_inbounds | Predicate functor tests whether a PixPoint is in a bounding box |
| Unused | Exception thrown if the PixPoint is used while uninitialized |
| PolyPath | Open polygonal path with a tangent at each point |
| PixPathAc | This is like PixPath except that it has an arclength cache, for teh performance |
| RatPoint | Very basic structure to represent X, Y points with rational coords |
| PixPoint_line_segment | Basic line segment when endpoints are PixPoints (int coords) |
| RatPoint_line_segment | Closed line segment with rational coords |
| Redblack_subtree_sum | Balanced binary search tree storing subtree sums in each node |
| const_iterator | Iterator class for a tree – lets you access node locators |
| StochasticPriorityQueue | Priority queue implementing a stochastic extract-near-min method |
| SvgWrap | Class used to render a PixPath as an SVG polygonal path picture |
| TopoFusion | This namespace hold structures and code written by Scott Morris |
| AutoLayer | RAII approach to the old TopoFusion Layer data structure |
| Tile_manager | RAII tool for opening and closing the DOQ master index |
| DOrthoQuad | Digital orthoquad buffer |
| tile_entry | Data structure for downloaded UTM tiles, like a pt |
| Ellipsoid | TopoFusion data structure used to represent an ellipsoid earth |
| pt | Definition for a TopoFusion pt |
| seg | Old TopoFusion data structure for a sequence of pt structures |
| track | Old TopoFusion data structure: metadata for a seg |
| waypoint | Definition used for waypoint |
| layer | Definition used for layer |
| tracking | |
| Entity_id | Entity + index; used for file I/O |
| Generic_trajectory | Represents a trajectory. Vector of optionals to trajectory elements |
| Generic_trajectory_map | Represents a set of trajectories; it is a map from entity to trajectory |
| Generic_trajectory_element | Represents an element of a trajectory of a particular entity |
| Spot_detector | A spot detector functor, comparable to a blob detector |
| Palette | Construct some colors, for visualizing grids of numbers |
| Calibrated_camera | |
| Back_projector | |
| Ground_back_projector | |
| Parametric_frustum | |
| Perspective_camera | |
| Turntable_camera | |
| Deva_detection | |
| Compare_box_distance | Functor for comparing box distance |
| Deva_facemark | |
| Face_detection | |
| Vector_adapter | Default adapter for the hessian function |
| Collinear_segment_chain | Represent a collinear line segment, a collinear line segment is inherited from an Line_segment |
| Comparable_omap |
- creates an omap from an image that can call compare_omap(compareto) to see how similar it is
|
| 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 |
| Edge_point | |
| Edge | |
| Edge_set | |
| Canny_edge_detector | Implements the Canny edge detection algorithm |
| Chamfer_transform | |
| Edge_segment | |
| Fh_type | |
| Feature_histogram | |
| Image_dart | |
| Features_manager | |
| Foreground_mask | |
| Geometric_context | |
| Hog_responses | |
| Line_segment_set | Class to manipulate a set of line segments |
| Edge_segment_set | Class to manipulate a set of edge segments |
| Manhattan_segment | A manhattan segment defined by a line segment and the vanishing point it converges to |
| Manhattan_corner_segment | |
| Manhattan_corner | |
| 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 |
| Omap_segment | |
| Omap_computer | |
| Segment_pair | |
| Vanishing_point | A vanishing point for a set of parallel lines in an image |
| Vanishing_point_detector | This class computes the position of the three vanishing points from a set of line segments. The ass |
| Compare_flow_features | Functor to compare two Feature_pair |
| Integral_flow | |
| Ransac_line_fitting | |
| Rotation_axis | |
| Calibration_descriptor | |
| Circle | |
| Circle_in_3d | |
| Cylinder | |
| Cylinder_section | Cylinder_section: a section of a cylinder, specified by angle and position |
| Line | Parametric representation of a 2D line in terms of three parameters (a,b,c) (as in ax+by+c = 0) |
| Vector_d | |
| Quaternion | |
| Transformable | Abstract class to apply a linear transformation to this object |
| Glut_parapiped | |
| Glut_perspective_camera | |
| Glut_polymesh | |
| 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 |
| Base_gl_interface | |
| Parametric_camera_gl_interface | |
| RenderableObject | |
| 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 |
| Offscreen_buffer | Offscreen rendering buffer |
| Matrix_d | |
| if_then_ | |
| if_then_< false, value1, value2 > | |
| Frustum | Frustum: a polyhedron of which each torso face is a trapezoid and the top and bottom surfaces are polygons |
| Parapiped | Parallelepiped: a hexahedron of which each face is a parallelegram |
| Polygon | |
| GL_Polygon_Renderer | |
| 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 |
| 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 |
| GL_Polymesh_Renderer | |
| Rectangle_2d | Class that represents an axis-aligned 2D rectangle. It is defined in terms of its (2D) center, its width and its height |
| Renderable | Abstract class to render this object with GL |
| Wire_renderable | Abstract class to render this object with GL as a wire-frame |
| Solid_renderable | Abstract class to render this object with GL |
| Wire_occlude_renderable | Abstract class to render this object with GL as an occluded wire-frame into the depth buffer, to hide unseen lines |
| Abstract_renderable | |
| Generic_renderable | |
| Generic_renderer | |
| Renderer | |
| Wire_renderer | |
| Wire_occlude_renderer | |
| Solid_renderer | |
| Renderer_renderable | |
| Mv_renderable | Abstract class to render an object that has many possible views |
| Mv_generic_renderable | |
| Mv_wire_occlude_render_wrapper | |
| Mv_wire_render_wrapper | |
| Mv_solid_render_wrapper | |
| Renderable_model | |
| Right_Triangle_Pair | |
| Rigid_object | |
| Sphere | |
| Triangular_mesh | Triangular_mesh: a polygonal mesh of which each face is a triangle |
| Gsl_multifit_fdf | |
| Gsl_Multimin_fdf | Wrapper for GSL's multidimensional minimizer, when you have gradient |
| Gsl_Multimin_f | Wrapper for GSL's multidimensional minimizer, without using gradient |
| Generic_multimin | |
| Gsl_Qrng_basic | Wrapper for one of GSL's quasi-random generators |
| Gsl_Qrng_Niederreiter | Quasi-random generator using the algorithm of Bratley et al |
| Gsl_Qrng_Sobol | Quasi-random generator using the algorithm of Antonov and Saleev |
| Gsl_Qrng_Halton | Quasi-random generator using the algorithm of Halton |
| Gsl_Qrng_Rvs_Halton | Quasi-random generator using the algorithm of Vandewoestyne et al |
| Gsl_ran_discrete | Randomly sample discrete events with an empirical distribution |
| Gsl_rng_basic | Basic RAII wrapper for GNU GSL random number generators |
| Gsl_Vector | RAII wrapper for GSL vector objects |
| 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 |
| Colormap | |
| Filter | Filter class |
| PixelHSVA | Alternative Pixel using hue, saturation, value, and opacity (alpha) |
| Image | Wrapped version of the C struct KJB_image |
| Fftw_image_convolution | This is a simple adaptation of Fftw_convolution_2d to Image input |
| Opengl_framebuffer_image | |
| PixelRGBA | Wrapped version of the C struct Pixel, with Alpha (opacity) |
| Cloneable | Abstract class to clone this object |
| Exception | Base class of all exceptions in the jwsc++ library |
| KJB_error | Exception often thrown when wrapped C functions return error codes |
| Not_implemented | Object thrown when attempting to use unimplemented functionality |
| Runtime_error | Object thrown when computation fails somehow during execution |
| Cant_happen | Object thrown when the program does something thought impossible |
| Illegal_argument | Object thrown when an argument to a function is not acceptable |
| Index_out_of_bounds | Object thrown when an index argument exceeds the size of a container |
| Dimension_mismatch | Object thrown when an argument is of the wrong size or dimensions |
| Divide_by_zero | Object thrown when an division is attempted with a zero divisor |
| Serialization_error | Object thrown when serialization or deserialization fails |
| IO_error | Object thrown when input or output fails |
| Result_error | Object thrown when a function cannot generate a valid result |
| Missing_dependency | Object thrown when a program lacks required resources or libraries |
| Option_exception | Object thrown for exceptions related to command-line options |
| Missing_option | Object thrown when an obligatory command-line option is absent |
| Stack_overflow | Object thrown if a finite size stack is full and pushed farther |
| Stack_underflow | Object thrown if stack is empty and popped |
| Resource_exhaustion | Object thrown if a resource allocation failed (memory, fp, etc.) |
| Increment | Generator that increments (++) its state everytime it is called. Useful for creating sequences of contigous values |
| Increase_by | Generator that increases (using +=) itself by the given value everytime it is called |
| Index_less_than | Predicate that compares the kth element of a indexable type |
| Select_coordinate | Selects a coordinate from a vector type |
| Identity | Identity function |
| Every_nth_element | Predicate that returns true every nth call |
| Compare_address | Predicate that returns true if address of element equals given |
| Get_address | Functor that returns the address of a given object |
| minimum | |
| maximum | |
| Heartbeat | A class for for indicating the status of slow-moving loops |
| Index_range | |
| End_type | |
| Int_matrix | This class implements matrices, in the linear-algebra sense, restricted to integer-valued elements |
| Int_vector | This class implements vectors, in the linear-algebra sense, restricted to integer-valued elements |
| const_circular_iterator | |
| circular_iterator | |
| Readable | Abstract class to read this object from an input stream |
| Scope_guard | |
| SerializableConcept | |
| File_Ptr | RAII wrapper on stdio.h FILE pointers (use a derived class though) |
| File_Ptr_Read | RAII wrapper on FILE* used to read a file |
| File_Ptr_Write | RAII wrapper on a FILE* used to write to a file |
| File_Ptr_Append | RAII wrapper on FILE* used to append a file (write only at the end) |
| File_Ptr_Read_Plus | RAII wrapper on FILE* opened with mode "r+" to read and write |
| Temporary_File | This class safely opens a temporary file in TEMP_DIR (usually /tmp) |
| Temporary_Directory | This class creates a temporary directory under TEMP_DIR (usu. /tmp) |
| Temporary_Recursively_Removing_Directory | Create a temp directory that destroys itself with "rm -rf" command |
| File_Ptr_Smart_Read | This class transparently opens gzipped or bzip2-ed files |
| to_ptr | Convert to a pointer |
| Word_list | Wrapper for the libKJB type Word_list (useful for globs) |
| const_iterator | Iterator class used to traverse and read the list |
| Writeable | Abstract class to write this object to an output stream |
| Pthread_mutex | Dynamically allocated mutex: unlock before you destroy it! |
| Pthread_locked_mutex | Same as Pthread_mutex, but starts off in "locked" state |
| Mutex_lock | Simple RAII class to grab and release a mutex |
| Pthread_attr | RAII class to manage an object of type kjb_pthread_attr_t |
| 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.. |
| compare_point_x_location | |
| 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 |
| Edge_lines_likelihood | |
| Correspondence | |
| Matched_point | |
| Compare_Normal_Distance | |
| Point | |
| Compare_Normal_Distance | |
| Independent_edge_points_likelihood | |
| Learned_discrete_prior | This class creates a histogram of a list of points and stores the number of bins in num_bins, the maximum and minimum values allowed in histo_max and histo_min, respectively, and the count of the number of points in each bin in histo_bins, which is a Vector of size num_bins |
| Model_edge | |
| Spline_curve | |
| Spline_surface | |
| Nurbs_curve | |
| Nurbs_surface | |
| Bezier_curve | |
| Polybezier_curve | |
| SimpleVector | |
| FFTW_Plan2d | RAII class to manage an FFTW plan |
| Fftw_convolution_2d | A class for performing 2d convolution using the FFTW library |
| Sizes | Utility aggregate stores all sizes – rarely used by caller |
| Matrix_traits | |
| Matrix_traits< int > | |
| Matrix_traits< double > | |
| Generic_matrix_view | |
| Generic_const_matrix_view | |
| Matrix | This class implements matrices, in the linear-algebra sense, with real-valued elements |
| Matrix_stream_io | Static functions to read and write matrix classes with iostream |
| Sequence | |
| Interval_sequence | |
| Generic_vector_view | |
| Generic_const_vector_view | |
| Vector | This class implements vectors, in the linear-algebra sense, with real-valued elements |
| Vector_stream_io | Functions to read and write vector classes with streams |
| Svd | Tuple that computes a singular value decomposition of a matrix |
| Conditional_distribution | A conditional distribution |
| Normal_on_normal_dependence | Represents the dependence between X and Y in p(x | y), where (x,y) is a bivariate normal |
| MV_normal_on_normal_dependence | Represents the dependence between X and Y in p(x | y), where (x,y) is a multivariate normal |
| Geometric_distribution | |
| Beta_binomial_distribution | |
| Distribution_traits | Generic traits struct for all distributions |
| Categorical_distribution | A categorical distribution |
| Distribution_traits< Categorical_distribution< T > > | Traits for the categorical distro |
| MV_gaussian_distribution | Multivariate Gaussian (normal) distribution |
| Distribution_traits< MV_gaussian_distribution > | Traits for the multivariate normal. Type is kjb::Vector |
| Log_normal_distribution | Log-normal distribution |
| Distribution_traits< Log_normal_distribution > | |
| Mixture_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) |
| Distribution_traits< Mixture_distribution< Distribution > > | Traits for the mixture distro. Type is the type of the mixed distributions |
| Uniform_sphere_distribution | |
| Distribution_traits< Uniform_sphere_distribution< D > > | Traits for the Uniform_sphere_distribution |
| Von_mises_fisher_distribution | |
| Distribution_traits< Von_mises_fisher_distribution< D > > | Traits for the Von-mises-fisher distribution |
| Chinese_restaurant_process | |
| Distribution_traits< Chinese_restaurant_process > | |
| Histogram | A class that represents a histogram of data. ATM, the data must be doubles |
| Histogram_2d | |
| Weight_array | Forward declarations |
| Abstract_dynamics | |
| Parapiped_camera_dynamics | |
| Parapiped_stretch_dynamics | |
| Focal_scale_dynamics | |
| Discrete_change_size | |
| Likelihood_dynamics | |
| Manhattan_hog | |
| Parametric_parapiped | |
| Parametric_sphere | |
| Kriging_interpolator | Class to interpolate elevation values using Gaussian processes |
| Ned13_one_degree_grid | Storage for a single NED13 grid tile, plus convenient access |
| IntegralLL | Integer-valued, latitude-style and longitude-style coordinates |
| Ned13_grid_cache | This caches a bunch (potentially) of one-degree grids for you |
| Ned13_caching_reader | Interface to an elevation-info object that caches its NED13 grids |
| Ned13_nearest_se_neighbor_reader | Support NED 13 elevation queries by using nearest southeast neighbor |
| Ned13_bilinear_reader | Support NED 13 elevation queries using bilinear interpolation |
| Ned13_gp_reader | |
| Video_frame | |
| Abstract_video | |
| Video | |
| OpenSSL_EVP | Generic OpenSSL hasher class, the base class for specific derivations |
| MD5 | Message Digest 5 computation, using OpenSSL code |
| kjb_c | |
| kjb_parallel | |
| 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 |
| semantics | |
| Key_slots | |
| Step_code | |
| Categorical_event | Look-up key class for contingency table |
| Categorical_event_base | Abstract base class for look-up keys |
| Cell | |
| Marginal_cell_base | |
| Context_cell_base | |
| Prior_cell | |
| Marginal_cell | Concrete class for contingency table cell |
| Cell_traits | |
| Cell_traits< T, 1 > | |
| Dependency_event | |
| Elaboration_tree | Main "Semantic tree" object |
| Event_db | Database class to read and count parse tree events |
| View_traits | |
| View_traits< S1_event > | |
| View_traits< S2_event > | |
| View_traits< U_event > | |
| View_traits< D1_event > | |
| View_traits< D2_event > | |
| View_traits< PCC1_event > | |
| View_traits< PCC2_event > | |
| View_traits< Hsem_event > | |
| View_traits< Msem_event > | |
| Cell_traits< semantics::D2_view, 2 > | |
| Event_view | Template class to represent different "views" of syntactic events |
| Head_semantic_event | |
| Lexicon_db | |
| Context_cell | Class containing conditioning context for marginal cells |
| Dummy_template_class | |
| Alpha_sampler | |
| Mod_semantic_event | |
| Nonterminal_db | |
| Null_semantic_event | |
| Punctuation_event | |
| Root_event | |
| Semantic_db | |
| Semantic_traits | Traits class storing information specific to given elaboration types |
| Semantic_data | Concrete semantic data class for storing hash codes about nodes |
| Terminal_elaboration | Class representing semantic nodes at the leaves of trees |
| Nonterminal_elaboration | |
| Semantic_data_base | Abstract base class of Semantic Data template |
| Semantic_elaboration | Base class for semantic elaborations |
| Semantic_step_event | |
| Semantic_step_proposal | |
| Semantic_traits< Null_primitive > | |
| Semantic_traits< Unary_relation_primitive > | |
| Semantic_traits< Binary_relation_primitive > | |
| Semantic_traits< Semantic_object > | |
| Semantic_traits< Category_primitive > | |
| Semantic_traits< Color_primitive > | |
| Semantic_traits< Size_primitive > | |
| Semantic_traits< Unary_predicate > | |
| Semantic_traits< Binary_predicate > | |
| Sentence_sem | |
| Sem_lexer | |
| Semspear_tree | The main syntactic tree object for semantic parsing |
| Semspear_tree_parser | |
| Syntactic_event | |
| Token_map | |
| TOP_event | |
| Tree_event | |
| Unary_event | |
| spear | |
| BankEdge | |
| CharArrayEqualFunc | |
| CharArrayHashFunc | |
| Edge | |
| EdgeLexer | |
| EdgeParser | |
| Exception | |
| HashMap | |
| Lexem | |
| Lexicon | |
| Model | |
| Pair | |
| Parameters | |
| RCObject | |
| RCIPtr | |
| StringMapEntry | |
| StringMap | |
| Tokenizer | |
| Trainer | |
| Pattern | |
| Tree | |
| Word | |
| std | |
| a | |
| Abstract | Abstract class to render this object |
| Abstract_gibbs_step | |
| Abstract_hmc_step | |
| Abstract_mh_step | |
| Abstract_sampler | |
| All_log_recorder | |
| All_model_recorder | |
| Annealable | |
| Annealing_mh_step | |
| Annealing_proposer_wrapper | |
| Annealing_sampler | |
| base_model_archetype | |
| BaseModel | |
| Basic_gibbs_step | |
| Basic_hmc_step | |
| Basic_mh_step | |
| Basic_sd_step | |
| Best_model_recorder | |
| Best_target_recorder | |
| Blob | A simple class that represents a blob |
| Blob_detector | A blob detector class. Use operator() to apply to image |
| Callback_recorder | |
| Compute_blob | |
| Computes | |
| Conditional_distribution_proposer | |
| Constant_parameter_evaluator | Returns the same result no matter what model is received |
| Constrained_target | Adapts a target distribution to be one with bounds |
| Control_scene | Class that represents a scene plus the control ouptuts; i.e. the model for the control-point trajectory sampler |
| Current_log_recorder | |
| Current_model_recorder | |
| Event_listener | |
| Expectation_recorder | |
| 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: |
| Gaussian_random_walk_proposer | |
| Gaussian_scale_space | |
| Gaussian_scale_space_generator | |
| Generic_adaptive_mh_step | |
| Get_model_parameter | Gets the specified parameter of a model. For now, we assume all parameters are type double |
| Gibbs_model_proposer | |
| GLUT_polymesh | |
| gsl_matrix | |
| gsl_multifit_function_fdf | |
| gsl_multimin_function | |
| gsl_multimin_function_fdf | |
| 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 | |
| Independent_gaussian_proposer | |
| Line | |
| Mh_model_proposer | |
| Mh_proposal_result | Indicates the result of an MH proposal. It is simply a pair of probabilities, forward and backward |
| Model_dimension | Returns the dimension of the model |
| Model_edge | |
| Model_evaluator | |
| model_evaluator_archetype | |
| Model_parameter_evaluator | |
| model_proposer_archetype | |
| Model_recorder | |
| model_recorder_archetype | |
| ModelEvaluator | |
| ModelProposer | |
| ModelRecorder | |
| Modulo_recorder | |
| Move_model_parameter | Moves the specified parameter of a model. For now, we assume all parameters are type double |
| Move_model_parameter_as_plus | Default move function; uses '+' |
| Multi_model_recorder | |
| Multi_proposer_proposer | |
| Multi_step_sampler | |
| null_deleter | |
| Mv_gaussian_proposer | |
| Null_event_listener | |
| Null_recorder | |
| Null_value | |
| Numerical_gradient | Approximates the gradient and/or curvature of a target distribution, evaluated at a certain location. The user must provide the mechanisms to change the model (see constructor) |
| Ostream_recorder | |
| Posterior | Generic posterior class |
| Real_hmc_step | |
| Real_numerical_gradient | Approximates the gradient of a target distribution, evaluated at a certain location. The model in question must be a vector model |
| Real_sd_step | |
| Recent_log_recorder | |
| Recent_model_recorder | |
| Sampler_step | |
| Serialize_recorder | |
| Set_model_parameter | Sets the specified parameter of a model. For now, we assume all parameters are type double |
| Simple_adaptive_mh_step | |
| Single_dimension_proposer | |
| Single_step_sampler | |
| ST_SPHERE | |
| Step_log | |
| Step_result | Structure for returning results of a single sampling move |
| triangulateio | |
| Updatable | |
| Vector_hmc_step | |
| vector_model_archetype | |
| Vector_numerical_gradient | Approximates the gradient of a target distribution, evaluated at a certain location. The model in question must be a vector model |
| Vector_sd_step | |
| Vector_srw_step | |
| VectorModel | |
| Viewing_recorder | |
1.8.6
