Directory dependency graph for algo:
Files | |
| file | vgl_algo_fwd.h [code] |
| file | vgl_compute_rigid_3d.h [code] |
| Compute a rigid transformation between two corresponding sets of 3D points. | |
| file | vgl_compute_rigid_3d.hxx [code] |
| file | vgl_compute_similarity_3d.h [code] |
| Compute a similarity transformation between two corresponding sets of 3D points. | |
| file | vgl_compute_similarity_3d.hxx [code] |
| file | vgl_conic_2d_regression.h [code] |
| Fits a conic to a set of points using linear regression. | |
| file | vgl_conic_2d_regression.hxx [code] |
| file | vgl_convex_hull_2d.h [code] |
| Compute the convex hull of a 2-d point set. | |
| file | vgl_convex_hull_2d.hxx [code] |
| two-dimensional convex hull read points from stdin, one point per line, as two numbers separated by whitespace on stdout, points on convex hull in order around hull, given by their numbers in input order the results should be "robust", and not return a wildly wrong hull, despite using floating point works in O(n log n); I think a bit faster than Graham scan; somewhat like Procedure 8.2 in Edelsbrunner's "Algorithms in Combinatorial
Geometry", and very close to: A.M. | |
| file | vgl_fit_conics_2d.h [code] |
| Fits a contiguous set of conic segments to a sampled curve. | |
| file | vgl_fit_conics_2d.hxx [code] |
| file | vgl_fit_lines_2d.h [code] |
| Fits a contiguous set of line segments to a sampled curve. | |
| file | vgl_fit_lines_2d.hxx [code] |
| file | vgl_fit_plane_3d.h [code] |
| Fits a plane to a set of 3D points. | |
| file | vgl_fit_plane_3d.hxx [code] |
| file | vgl_fit_quadric_3d.h [code] |
| Fits a quadric surface to a set of 3D points. | |
| file | vgl_fit_quadric_3d.hxx [code] |
| file | vgl_fit_sphere_3d.h [code] |
| Fits a sphere to a set of 3D points. | |
| file | vgl_fit_sphere_3d.hxx [code] |
| file | vgl_h_matrix_1d.h [code] |
| 2x2 line-to-line projectivity | |
| file | vgl_h_matrix_1d.hxx [code] |
| file | vgl_h_matrix_1d_compute.h [code] |
| Virtual base class of classes to generate a line-to-line projectivity from a set of matched points. | |
| file | vgl_h_matrix_1d_compute_3point.cxx [code] |
| file | vgl_h_matrix_1d_compute_3point.h [code] |
| Calculate the line projectivity which matches three 1D point correspondences. | |
| file | vgl_h_matrix_1d_compute_linear.cxx [code] |
| file | vgl_h_matrix_1d_compute_linear.h [code] |
| find line-to-line projectivity from a set of matched points using SVD | |
| file | vgl_h_matrix_1d_compute_optimize.cxx [code] |
| file | vgl_h_matrix_1d_compute_optimize.h [code] |
| compute the h_matrix using Levenberg-Marquardt. | |
| file | vgl_h_matrix_2d.h [code] |
| 3x3 plane-to-plane projectivity | |
| file | vgl_h_matrix_2d.hxx [code] |
| file | vgl_h_matrix_2d_compute.h [code] |
| contains class vgl_h_matrix_2d_compute | |
| file | vgl_h_matrix_2d_compute_4point.cxx [code] |
| file | vgl_h_matrix_2d_compute_4point.h [code] |
| vgl_h_matrix_2d_compute_linear contains a linear method to calculate the plane projectivity which relates four 2D point correspondences. | |
| file | vgl_h_matrix_2d_compute_linear.cxx [code] |
| file | vgl_h_matrix_2d_compute_linear.h [code] |
| contains class vgl_h_matrix_2d_compute_linear | |
| file | vgl_h_matrix_2d_compute_rigid_body.cxx [code] |
| file | vgl_h_matrix_2d_compute_rigid_body.h [code] |
| contains class vgl_h_matrix_2d_compute_rigid_body | |
| file | vgl_h_matrix_2d_optimize.h [code] |
| Refine an initial 2d homography by minimizing projection error. | |
| file | vgl_h_matrix_2d_optimize_lmq.cxx [code] |
| file | vgl_h_matrix_2d_optimize_lmq.h [code] |
| contains class vgl_h_matrix_2d_optimize_lmq | |
| file | vgl_h_matrix_3d.h [code] |
| 4x4 3D-to-3D projectivity | |
| file | vgl_h_matrix_3d.hxx [code] |
| file | vgl_h_matrix_3d_compute.h [code] |
| contains class vgl_h_matrix_3d_compute | |
| file | vgl_h_matrix_3d_compute_affine.cxx [code] |
| file | vgl_h_matrix_3d_compute_affine.h [code] |
| contains class vgl_h_matrix_3d_compute_affine | |
| file | vgl_h_matrix_3d_compute_linear.cxx [code] |
| file | vgl_h_matrix_3d_compute_linear.h [code] |
| contains class vgl_h_matrix_3d_compute_linear | |
| file | vgl_homg_operators_1d.h [code] |
| 1D homogeneous functions | |
| file | vgl_homg_operators_1d.hxx [code] |
| file | vgl_homg_operators_2d.h [code] |
| 2D homogeneous operations | |
| file | vgl_homg_operators_2d.hxx [code] |
| file | vgl_homg_operators_3d.h [code] |
| 3D homogeneous functions | |
| file | vgl_homg_operators_3d.hxx [code] |
| file | vgl_intersection.h [code] |
| Set of intersection functions. | |
| file | vgl_intersection.hxx [code] |
| file | vgl_line_2d_regression.h [code] |
| A helper class for line fitting. | |
| file | vgl_line_2d_regression.hxx [code] |
| file | vgl_norm_trans_2d.h [code] |
| The similarity transform that normalizes a point set. | |
| file | vgl_norm_trans_2d.hxx [code] |
| file | vgl_norm_trans_3d.h [code] |
| The similarity transform that normalizes a 3-d point set. | |
| file | vgl_norm_trans_3d.hxx [code] |
| file | vgl_orient_box_3d.h [code] |
| A bounding oriented box. | |
| file | vgl_orient_box_3d.hxx [code] |
| file | vgl_orient_box_3d_operators.h [code] |
| Compute the minimal oriented bounding box for several 3D shapes. | |
| file | vgl_orient_box_3d_operators.hxx [code] |
| file | vgl_p_matrix.h [code] |
| General 3x4 perspective projection matrix. | |
| file | vgl_p_matrix.hxx [code] |
| file | vgl_rotation_3d.h [code] |
| A class representing a 3d rotation. | |
| file | vgl_rtree.h [code] |
| Templated rtree class and associated classes and functions. | |
| file | vgl_rtree.hxx [code] |
| file | vgl_rtree_c.h [code] |
| C helper classes for vgl_rtree. | |
