KrisLibrary  1.0.0
Class Hierarchy
This inheritance list is sorted roughly, but not completely, alphabetically:
[detail level 1234]
 CMath3D::AABB2DA 2D axis-aligned bounding box
 CMath3D::AABB3DA 3D axis-aligned bounding box
 CMath3D::AABBTemplate< T >
 CAnalyticalIKSolverHook for an analytic inverse kinematics solver. The Solve method must be defined by the subclass
 CAnalyticIKSolutionA structure containing computed analytic IK solutions
 CMath3D::AngleAxisRotationAngle-axis 3D rotation parameterization
 CMath::AngleIntervalA contiguous range of angles
 CAnyCollectionA flexible hierarchical collection of AnyValues, which can be easily initialized to contain primitive values, arrays, or maps. Arrays and maps can be nested as well
 CGeometry::AnyCollisionQueryA class that stores information regarding a collision query. May be slightly faster than running individual queries
 CAnyDataA helper class that points to any kind of data
 CGeometry::AnyGeometry3DA class that stores any kind of geometry we've defined
 CAnyKeyableAny primitive value (bool, char, unsigned char, int, unsigned int, float, double, string) that we know how to make into a hashable object
 CAnyValueA polymorphic container class that can contain data of any type
 CMeshing::ApproximateGeodesicComputes an approximate geodesic distance over a mesh, from a single source
 CGeometry::ApproximatePenetrationDepthUses a propagation method to calculate an approximate penetration distance of mesh m1 inside m2
 CGraph::ApproximateShortestPathProblem< Node, Edge >Approximate single-source shortest paths, whose output is at most (1+epsilon)^d times the true shortest path, where d is the depth of the node. This can be somewhat faster than running true shortest paths
 CGeometry::Arrangement1DAn arrangement of 1-D intervals. Intervals identified by an integer ID
 CArray2D< T >A two-dimensional m x n array
 CArray2D< bool >
 CArray2D< Data >
 CArray2D< Geometry::AnyCollisionQuery * >
 CArray2D< iterator >
 CArray2D< Real >
 CArray2D< Vector2 >
 CArray2D< Vector3 >
 CArray3D< T >A three-dimensional m x n x parray
 CArray3D< Real >
 CArrayMappingAn invertible mapping from indices in [0,imax), which operates in two modes: offset mode adds an offset, and mapping mode stores an explicit mapping
 CArrayND< T >
 CArrayND< int >
 CArrayND< Real >
 CArrayNDRef< T >
 CAsyncPipeQueueAsynchronous reader/writer with queues
 CAsyncReaderQueueAsynchronous reader with queue
 CAsyncWriterQueueAsynchronous writer with queue
 CAxisSweptPointParameterizes a circle in space by sweeping a point around a line
 COptimization::BCMinimizationProblemA bound-constrained MinimizationProblem. Uses an active-set method to determine the components of the free search direction at x
 CBidirectionalRRTKPA bidirectional RRT planner for kinodynamic systems
 CMath::BLASInterfaceAn interface to BLAS. Activated with the preprocessor flag HAVE_BLAS=1
 COptimization::BoundedLSQRSolverSolve the bounded least-squares problem min||Ax-b||^2 s.t. l <= x <= b accepts infinite constraints too
 CGeometry::BoxCmp< Box >
 CGeometry::BoxTraits< Box >
 CSpline::BSplineBasisDefines the B-spline basis for a given knot vector, number of control points
 CGraph::CallbackBase< Node >A template base class for a graph traversal
 CGraph::CallbackBase< int >
 CChainA tree-based chain structure
 CMath::CholeskyDecomposition< T >Performs the Cholesky decomposition
 CMath3D::Circle2DA 2D circle class
 CMath3D::Circle3DA 2D circle in 3D space class
 Cstd::cmp_func< T, Less >A templated function class like strcmp: returns -1 if a<b, 0 if a==b, 1 if a>b
 CGraph::CoEdgeIterator< Data >
 CGeometry::CollisionMeshQueryA general-purpose distance querying class
 CCombinationA class that enumerates combinations
 CMath::ComplexComplex number class (x + iy)
 CConstMappedAccessor< T, Key >A helper class that allows a const vector to be accessed by either indexes or some other keys, given a map from keys to indexes
 COptimization::ConstrainedMinimizationProblemSame as MinimizationProblem but with nonlinear constraints C(x)=0 and D(x)<=0, bound constraints bmin/bmax
 CContactFormationA robot-environment contact formation. The list of contacts contacts[i] is associated with links[i] (pointing from the opposing body into the robot). Usually the opposing body is the environment, but if targets is non-empty, it gives the index of the body for which contact is made
 CContactPointA single contact point, i.e. a position, normal, and friction coefficient
 CContactPoint2DA 2D contact point, i.e. a position, normal, and friction coefficient
 CContextStackA helper for maintaining and printing context
 CMath3D::ConvexPolyhedron3DA convex polyhedron given in a dual representation, planes and vertices of convex hull
 CCSpaceMotion planning configuration space base class
 CCSVTableA table read from a CSV file
 CMath3D::Cylinder3DA 3D cylinder
 CDataDatabaseA heirarchical database of arbitrary values
 CDisplacementPlannerA planner that minimizes the the displacement cost of violated constraints using a RRT-like strategy
 CStatistics::DistributionCollectorIncrementally collects samples from a univariate distribution
 CStatistics::DistributionCollectorNDIncrementally collects samples from a multivariate distribution
 CDynamicStructureDeltaA change to a DynamicStructure
 CDynamicStructureViewThe partner class for DynamicStructure that allows accessing members via [key] syntax and setting values using the = operator
 CDynamicStructureWatcherBaseA base class that captures changes to a DynamicStructure
 CDynamicValue< T >Convenience class for accessing primitive members of DynamicStructures. Can treat like an object of type T (references are not allowed)
 CGraph::EdgeIterator< Data >
 CEdgePlannerAbstract base class for an edge planner
 CEquilibriumTesterTesting COM equilibrium given some number of contacts
 CEZCallTraceHelper class that eases function call tracing
 CEZTraceA Trace that dumps on destruction. Only one may be active at any time
 CFastFindHeap< type, ptype >Implements a heap that stores objects of type type, with priority keys of type ptype
 CFastSamplerSamples from a weighted discrete set in O(log(n)) time after an O(n) initialization
 CFileA cross-platform class for reading/writing binary data
 CFixedSizeHeap< ptype >A heap of fixed maximum size N. Each element is indexed by an integer 0...N-1. The priority key of each element is of type ptype
 CFixedSizeHeap< Real >
 CFrictionConePolygonPolygonal pyramid representation of the friction cone
 CMath::Gaussian< T >Multivariate gaussian N(mu,K) of d dimensions
 CMath::Gaussian< Real >
 CStatistics::GaussianHMMA model of a temporal sequence consisting of k discrete states each with a gaussian emission probability
 CStatistics::GaussianMixtureModelA model of a probability distribution consisting of k gaussians
 CStatistics::GaussianMixtureModelRawA more ``raw'' model of a GMM that does not perform a cholesky decomposiition
 CAI::GeneralizedAStar< S, C >
 CAI::GeneralizedAStar< int, double >
 CAI::GeneralizedAStar< int, SubsetCost >
 CAI::GeneralizedAStar< pair< int, Subset >, SubsetCost >
 CAI::GeneralizedAStar< S, double >
 CAI::GeneralizedAStar< S, int >
 CGeneralizedCubicBezierCurveA generalized Bezier curve that uses the CSpace's Interpolate routine to generate the smooth interpolation
 CGeneralizedCubicBezierSplineA Bezier spline with segment durations
 CGeodesicManifoldExtra information for a CSpace about manifold derivatives
 CMath3D::GeometricPrimitive3DA generic geometric primitive class
 CGLDraw::GLColorAn rgba color
 CGLDraw::GLLightAn OpenGL light
 CGLDraw::GLMaterialAn OpenGL material
 COptimization::GLPKInterfaceAn interface to the GLPK linear program solver. Activated with the HAVE_GLPK preprocessor define
 CGLDraw::GLTexture1D1D texture data for use in OpenGL
 CGLDraw::GLTexture2D2D texture data for use in OpenGL
 CGLDraw::GLTextureObjectA GL texture object class. Simplifies allocating and cleaning up texture objects. Usually you only need to interact with GLTexture[X]D and the texture management is handled for you
 CGraph::Graph< NodeData, EdgeData >Basic template graph structure
 CGraph::Graph< Config, SmartPointer< EdgePlanner > >
 CGraph::Graph< CSpace *, CSpace * >
 CGraph::Graph< Graph::TreeNode, EdgePlanner >
 CGraph::Graph< int, MultiModalPRM::TransitionInfo * >
 CGraph::Graph< Milestone, Edge >
 CGraph::Graph< Mode, Transition >
 CGraph::Graph< ModeInfo, TransitionInfo >
 CGraph::Graph< Node, Edge >
 CGraph::Graph< PRTPlanner::Tree, PRTPlanner::TreeEdge >
 CGraph::Graph< SBLTree *, MilestonePath >
 CGraph::Graph< VisibilityGraphPlanner::Vertex, SmartPointer< EdgePlanner > >
 CGeometry::GridA gridding of n-dimensional space
 CGrid2IndicesA 2D lattice of irregular ranges
 CGeometry::GridHashA grid containing objects (referenced by void pointers)
 CGeometry::GridSubdivisionA grid with a list of arbitrary objects (given by void pointers)
 CGeometry::GridTable< T >A table with entry T on a gridding of n-dimensional space
 CHaltingConditionA termination condition for a planner. Supports max iteration count, time limit, absolute cost, and cost improvement conditions
 CHeap< type, ptype >Implements a heap that stores objects of type type, with priority keys of type ptype
 CGeometry::HiGreater< Box >
 CStatistics::Histogram1-D histogram class
 CStatistics::Histogram2D2-D histogram class
 CStatistics::Histogram3D3-D histogram class
 CStatistics::HistogramNDN-D histogram class
 CHollowBallA 3-D annulus innerRadius <= |x-center| <= outerRadius
 CIKGoalA structure defining a link's desired configuration for IK
 Cstd::IndexedPriorityQueue< IT, PT >Contains a priority queue with an associated index, allowing updates of the priority value. Priority defined with lowest value first
 Cstd::IndexedPriorityQueue< int, double >
 CIndexSetA generic set of indices, either listed explicitly or in a range. If imax < imin, this indicates that the indices should be used instead
 CMath::IntervalA generic interval {a,b}, where { and } can be either (,[ or ),]
 CStatistics::IntervalMap< Data >Division of the real numbers into interval sets. Each interval is assigned data of type Data
 CStatistics::IntervalMap2D< Data >
 CIntPairA lightweight integer 2-tuple class
 CIntTripleA lightweight integer 3-tuple class
 CIntTupleAn integer tuple class
 CArray2D< T >::iterator
 CArray3D< T >::iterator
 CArrayND< T >::iterator
 CRedBlack::Tree< T, Cmp >::iterator
 CMath::JacobiPreconditioner< Matrix >Jacobi preconditioning (inverse of diagonal)
 CJointStructureCalculates workspace bounds for a robot with constrained links
 CGeometry::KDTreeA node of a kd-tree
 CKeyBezierCubic< Point >
 CKeyCardinal< Point >
 CKeyHermite< Point >
 CKeyTCB< Point >
 CKinodynamicMilestonePathStores a kinodynamic path with piecewise constant controls
 CKinodynamicTreeData structure for a kinodynamic planning tree
 CStatistics::KMeansA simple clustering method to choose k clusters from a set of data
 CMath::LAPACKInterfaceAn interface to LAPACK. Activated with the preprocessor flag HAVE_CLAPACK=1
 CLazyLoader< T >A utility that allows objects from files to be loaded from and saved to disk on demand
 CMath::LDLDecomposition< T >Performs the LDL^t decompositoin of a symmetric matrix A
 CMath::LDLDecomposition< Real >
 COptimization::LeastSquaresA least-squares problem definition
 CStatistics::LeastSquares1D1-D least squares y = ax+b
 COptimization::LemkeLCPSolves a linear complementarity problem
 CMath3D::Line2DA 2D line class
 CMath3D::Line3DA 3D line class
 COptimization::LinearConstraintsLinear constraints for LP's and QP'sRepresents the constraints
 COptimization::LinearConstraints_SparseSparse linear constraints for LP's and QP'sUnlike dense constraints, AddVariable/AddConstraint are relatively efficient
 CStatistics::LinearModelA linear model of n-dimensional data
 CStatistics::LinearProcessHMMA model of a temporal sequence consisting of k discrete states each with a gaussian emission probability depending on the prior continuous state
 CStatistics::LogisticModelModels the probability of a boolean outcome using a logit
 CGeometry::LoLess< Box >
 COptimization::LP_InteriorPointSolves a general LP using LP_InteriorPointSolver
 CGeometry::LPSolvePointCallbackHelper callback used in PolytopeProjection2D
 CMeshing::LSConformalMappingAn approximately-conformal parameterization a genus-0 mesh, found by a least-squares method
 COptimization::LSQRInterfaceAn interface to a sparse least-squares solver (lsqr)
 CMath::LUDecomposition< T >Forms the LU decomposition A=PLU
 CMappedAccessor< T, Key >A helper class that allows a vector to be accessed by either indexes or some other keys, given a map from keys to indexes
 CMath3D::Matrix2A 2x2 matrix class
 CMath3D::Matrix3A 3x3 matrix class
 CMath3D::Matrix4A 4x4 matrix class
 CMath::MatrixIterator< T >An iterator through MatrixTemplate elements
 CMath::MatrixTemplate< T >A matrix over the field T
 CMath::MatrixTemplate< Real >
 CMCRPlannerA planner that minimizes the the number of violated constraints using a RRT-like strategy
 CMCRPlannerGoalSetA planner that minimizes the the number of violated constraints using a RRT-like strategy
 CMilestonePathA sequence of locally planned paths between milestones
 COptimization::MinimizationProblemAn iterative solution to minimize f over multidimensional x. May only find a local minimum, depending on the initial point
 CSpline::MonotonicSplineA b-spline based monotonic spline
 CMotionPlannerFactoryA motion planner creator
 CMotionPlannerInterfaceAn abstract class for a sample-based motion planner
 CMotionPlanningProblemA structure to specify the space, endpoints, and cost function of a motion planning problem
 CMultiModalCSpace< Mode >Multi-modal configuration space base class
 CMultiModalCSpace< int >
 Cmyarray< type >
 Cmyhashtable< type >
 Cmylist< type >
 CNewtonEulerSolverThe Featherstone algorithm for O(n) computation of either joint torques from accelerations, or accelerations from torques
 COptimization::NewtonRootA globally convergent Newton's method for multidimensional root solving. Solves for func(x)=0
 COptimization::NewtonSolverA newton's-method style solver for a NLP
 CRedBlack::Node< T >
 CAI::GeneralizedAStar< S, C >::Node
 COptimization::NonlinearProgramA structure defining a nonlinear program
 CMath::NormAccumulator< T >
 CMath::NRQRDecomposition< T >The QR decomposition as computed by the algorithm in Numerical Recipes in C
 CMath::NullPreconditioner< Matrix >Identity precondtioner
 CObjectPrinter< T >Provides a unified interface to "pretty print" objects to the console, or other ostreams
 CObstacleCheckerBaseAbstract base class for an obstacle
 CStatistics::OnlineLeastSquaresOnline estimation of least-squares solution to y = A x
 CStatistics::OnlineMomentsOnline calculation of mean, covariance, min/max of vectors
 COrientedSupportPolygonCalculation of a support polygon with a non-vertical gravity vector
 CPathCoordinate< PathRot, PathTrans >
 CPermutationA class that enumerates permutations
 CMath3D::Plane2DA 2D plane classRepresents plane with a normal and offset such that x on the plane satisfy dot(normal,x) = offset
 CMath3D::Plane3DA 3D plane classRepresents plane with a normal and offset such that x on the plane satisfy dot(normal,x) = offset
 CMeshing::PointCloud3DA 3D point cloud class
 CGeometry::PointCloudKMeansSegmentationUses KMeans + connected components to segment a point cloud. Good for getting "superpixels"
 CGeometry::PointCloudNeighborGraphSegmentationUses a neighbor-graph in XYZ space + connected components to segment a point cloud. Good for separating well-separated components
 CPointLocationBaseA uniform abstract interface to point location data structures
 CMath3D::Polygon2DAn arbitrary connected polygon given by a vertex list
 CMath3D::Polygon3DAn arbitrary connected polygon in 3D space given by a vertex list
 CSpline::Polynomial< T >A simple polynomial class, p(x) = sum_{i=0}^n coef[i]*x^i
 CGeometry::PolytopeProjection2DA method for projecting a polytope defined by the feasible set of a linear program lp onto a 2D subspace. Handles unbounded and infeasible problems
 CPrimitiveValueA basic primitive value type, including integers, floats, and strings
 CProgressPrinterPrints the progress of an iterative, long computation
 CPRTPlannerThe PRT (Probabilistic Roadmap of Trees) planner
 CMath::QNHessianUpdaterMaintains the Cholesky decomposition of the hessian H over Quasi-Newton steps
 CMath::QRDecomposition< T >Calculates the QR decomposition
 COptimization::QuadProgPPInterfaceAn interface to the QuadProg++ quadratic programming solver. Enable with the HAVE_QUADPROGPP=1 preprocessor define
 CMath::QuaternionComplex quaternion class (w + ix + jy + kz)
 CRange2IndicesA 2D lattice of regular ranges
 CRange3IndicesA 3D lattice of regular ranges
 CRangeIndicesA regular range of indices ik = start+k*stride, for k=0 to size-1
 CRangeMap< T >Same as RangeSet, but a map rather than a set. O(1) find as well
 CRangeMap2D< T >Same as RangeSet2D but a map. O(1) find as well as count
 CRangeSetA set of integers within a range. Operates in two modes, set or bit vector mode. In bit-vector mode, allows O(1) membership testing (but the range is fixed). Set mode is just like a regular set
 CRangeSet2DA set of 2d indices within a range. Operates in two modes, set or bit matrix mode. In bit-matrix mode, allows O(1) membership testing (but the range is fixed). Set mode is just like a regular set
 CMeshing::Rasterizer2DA base class that allows rasterizing of 2D triangles into a grid
 CMath::RealFunctionA function from R to R
 CRefPointer< obj >
 CRefStorage< obj >
 CResourceBaseA generic "resource" that can be saved/loaded to disk
 CResourceLibraryA collection of resources, which may be loaded/saved as separate files in a directory or inlined into a single XML file. Helps with managing subdirectories of data
 CRigidBodyDynamicsA class for simulating a rigid body. Uses Euler integration
 CMath3D::RigidTransformA rigid-body transformation
 CMath3D::RigidTransform2DSame as above, but in 2D
 CRLGA sampler for closed-chain kinematics that takes joint workspace bounds into account
 CRNG48Uses the ANSI C rand48 functions
 CRoadmapPlannerA base roadmap planner class
 CRobotIKSolverA Newton-Raphson robot IK solver
 CRobotLink3DKinematic and physical parameters of a link
 COptimization::RobustLPSolverA class that tries out as many available routines as possible to solve an LP
 CMath::RobustSVD< T >Performs a pre/postconditioned singular value decomposition
 CMath::RobustSVD< Real >
 CMath::RowEchelon< T >Compute reduced row-eschelon form for a matrix A
 CRRTKinodynamicPlannerThe RRT planner for kinodynamic systems
 CSBLPlannerThe SBL motion planner
 CSBLPRTA probabilistic roadmap of trees, where SBL is used for local planning
 CSBLSubdivisionA grid-based subdivision to be used for SBL
 CSBLTreeA tree of configurations to be used in the SBL motion planner
 CMath::ScalarFieldFunctionA function from R^n to R
 CMath3D::Segment2DA 2D segment class
 CMeshing::SegmentMeshA basic 2D segment mesh (i.e. collection of polylines)
 CGeometry::SegmentOverlayComputes the overlay of a set of segments using a sweep line algorithm
 CGraph::ShortestPathProblem< Node, Edge >Single-source shortest paths (Dijkstra's algorithm)
 CGraph::ShortestPathProblem< Config, SmartPointer< EdgePlanner > >
 CGraph::ShortestPathProblem< int, MultiModalPRM::TransitionInfo * >
 CSignalHandlerA base class for an object-oriented signal handler. Properly restores old signal handlers once the class is destroyed
 CSimpleFileA simple file format that has named items and whitespace-delimited values
 CSimpleParserA simple class to break files into tokens, punctuation, comments, and whitespace
 CSmartPointer< T >A smart pointer class. Performs automatic reference counting
 CSmartPointer< AnyCollection >
 CSmartPointer< CSpace >
 CSmartPointer< EdgePlanner >
 CSmartPointer< Geometry::OctreePointSet >
 CSmartPointer< Image >
 CSmartPointer< int >
 CSmartPointer< Math::RealFunction >
 CSmartPointer< Math::ScalarFieldFunction >
 CSmartPointer< Math::VectorFieldFunction >
 CSmartPointer< Meshing::TriMesh >
 CSmartPointer< MotionPlannerInterface >
 CSmartPointer< PointLocationBase >
 CSmartPointer< SBLPlanner >
 CSmartPointer< TransportBase >
 CSmartPointer< unsigned int >
 CGeometry::Spanning< Box >
 CSparseArray< T >A sparse 1D array class
 CMath::SparseMatrixTemplate_CR< T >Row-major, compressed-row sparse matrix
 CMath::SparseMatrixTemplate_RM< T >Row-major sparse matrix
 CMath::SparseMatrixTemplate_RM< Real >
 CMath::SparseVectorAccessor< T >
 CMath::SparseVectorCompressed< T >
 CMath3D::Sphere3DA 3D sphere class
 CStandardRNGInterface for a random number generator
 CStatCollectorCollects statistics (min,max,mean,stddev,etc) on floating-point data
 CStatDatabaseA heirarchical database of statistical data (counts and StatCollectors). Useful for performance testing
 CStatistics::StochasticLeastSquaresStochastic gradient descent estimation of least-squares solution to y = A x
 CStatistics::StochasticPseudoLASSOStochastic estimation of solution to y = A x via a LASSO-like procedure min_x ||b-A x||^2 + alpha*||x||_1
 CStringSerializerA helper class that automatically serializes data to a string and deserializes data using the as<T>() function
 CStripe2IndicesA 2D lattice indexing into a linear sequence, in a striping pattern
 CStripe3IndicesA 3D lattice indexing into a linear sequence, in a striping pattern
 CSubsetA finite subset of numbered items with convenient operators for union, intersection, difference, etc
 CSubsetProjectorA subset of a configuration space equipped with a projection mechanism
 CMath::SVDecomposition< T >Performs the singular value decomposition
 CMath::SVDecomposition< Real >
 CDisplacementPlanner::TestResultStores all values for a single obstacle displacement test
 CTraceAllows detailed tracing of program execution
 CTransportBaseA base class for a transport protocol for unstructured data
 CRedBlack::Tree< T, Cmp >
 CRedBlack::Tree< Event, EventCmp >
 CRedBlack::Tree< int, StatusCmp >
 CTreeRoadmapPlannerA base class to be used for tree-based roadmap planners
 CMath3D::Triangle2DA 2D triangle class
 CMath3D::Triangle3DA 3D triangle class
 CMeshing::TriMeshA basic triangle mesh
 CMeshing::TriMeshAtlasTODO: a non-genus 0 mesh partitioned into charts
 CMeshing::TriMeshChartA chart maps a genus 0 triangle mesh to a 2d disk
 CMeshing::TriMeshTraversalCallbackA callback base class for traversing triangle mesh topology
 CMeshing::TriSplitterA class that allows incremental plane-splitting of a triangle mesh
 Cmylist< type >::type_node
 CGeometry::UnboundedPolytope2DA representation of a possibly unbounded polytope in the 2d plane
 CGraph::UndirectedEdgeIterator< Data >
 CUnionFindFrom an indexed set of elments, allows fast unioning of the elements into sets
 CUniquePointer< T >A unique pointer class that duplicates on non-const access. It's used to implement non-conflicting writes to data stored in multiple locations, for example in sparse state representations
 CMath3D::Vector2A 2D vector class
 CMath3D::Vector3A 3D vector class
 CMath3D::Vector4A 4D vector class
 CMath::VectorFieldFunctionA function from R^n to R^m
 CMath::VectorFunctionA function from R to R^n, identical to RealFunction except a vector is returned
 CMath::VectorIterator< T >An iterator through VectorTemplate elements
 CMath::VectorTemplate< T >A vector over the field T
 CMath::VectorTemplate< Real >
 CMeshing::VolumeGridA 3D array over a 3D volume, containing Real values
 CMeshing::VolumeGridIterator< T >Iterator over a 3D volume grid
 CRedBlack::WalkCallback< T >
 CGLDraw::WidgetBase class for a visual widget
 CWildcardAn any-schema is a simple validation and mapping scheme for AnyCollections. The keys in the document must match up with the schema
 CWorkspaceBoundBounds the workspace of a robot linkage with a simple bound
 CGeometry::XMonotoneChainA polyline with vertices ordered in nondecreasing order