\( \newcommand{\E}{\mathrm{E}} \) \( \newcommand{\A}{\mathrm{A}} \) \( \newcommand{\R}{\mathrm{R}} \) \( \newcommand{\N}{\mathrm{N}} \) \( \newcommand{\Q}{\mathrm{Q}} \) \( \newcommand{\Z}{\mathrm{Z}} \) \( \def\ccSum #1#2#3{ \sum_{#1}^{#2}{#3} } \def\ccProd #1#2#3{ \sum_{#1}^{#2}{#3} }\)
CGAL 4.6 - Kinetic Framework
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Groups Pages
Class and Concept List
Here is the list of all concepts and classes of this package. Classes are inside the namespace CGAL. Concepts are in the global namespace.
[detail level 123]
oNCGAL
|oNKinetic
||oCActive_objects_vectorMovingObjects are stored in a vector
||oCCartesianThis class provides a model of Kinetic::Kernel for use with general Cartesian geometry
||oCDefault_instantaneous_kernelThis class provides a model of the Kinetic::InstantaneousKernel for use with general Cartesian Geometry
||oCDefault_simulatorThe class Kinetic::Default_simulator controls kinetic data structures by maintaining a concept of time and ensuring that events are processed when necessary
||oCActive_objects_listenerThe class Kinetic::Active_objects_listener acts as an intermediate between a moving object table and a KDS
||oCSimulator_listenerThe class Kinetic::Simulator_listener acts as a helper class for kinetic data structures which want to respond to Simulator::Listener::HAS_AUDIT_TIME notifications
||\CSimulator_objects_listenerThe class Kinetic::Simulator_objects_listener is a helper for classes which wish to react to Simulator::Listener::DIRECTION_OF_TIME notifications
|oCListenerThe Listener class provides the core of the run time notification system used by the kinetic data structures package
|oCMulti_listenerThe class Multi_listener implements a base class for listeners where more than one listener is allowed to subscribe to a notifier
|\CRef_countedThe class Ref_counted implements a base class for objects which are reference counted
\NKinetic
 oCActiveObjectsTableThis container holds a set of objects of a particular type. It creates notifications using the standard Multi_listener<Interface> interface when a primitive changes or is added or deleted. Objects which are listening for events can then ask which primitives changed
 oCCertificateGeneratorThis functor allows you to create certificate objects of some type. The models of this "concept" take some set of arguments which depend on the certificate being computed (for example three points for a two dimensional orientation) followed by either one or two instances of the Kinetic::Simulator::Time concept. The functions either return a Certificate or the corresponding value at the current time (if only a time value rather than an interval is passed)
 oCEventQueueThe concept for priority queues used by the Simulator. The concept basically defines a priority queue which supports deletions and changes of items in the queue (but not their priorities). Items in the queue must implement the Event concept
 oCFunctionKernelThe concept Kinetic::FunctionKernel encapsulates all the methods for representing and handing functions. The set is kept deliberately small to easy use of new Kinetic::FunctionKernels, but together these operations are sufficient to allow the correct processing of events, handling of degeneracies, usage of static data structures, run-time error checking as well as run-time verification of the correctness of kinetic data structures. The computation of a polynomial with the variable negated is used for reversing time in kinetic data structures and can be omitted if that capability is not needed
 |oCConstructFunctionThe concept ConstructFunction is used to construct functions
 |\CFunctionThe concept Function represents a function
 oCInstantaneousKernelThe concept Kinetic::InstantaneousKernel covers models that act as adaptors allowing CGAL static data structures to act on snapshots of kinetic data. Different methods for evaluating predicates are used depending on whether time is set using an NT or a Time object. Evaluating predicates when time is the former is much cheaper
 oCKeyThe concept Key is a unique identifier for something in some sort of table. In general, they can be only created by the table and are returned when a appropriate new_foo() method is called on the table. There are two classes of values for a Key, valid and invalid. The latter cannot refer to something in a table. Use the method is_valid() to differentiate
 oCCertificateThe concept Kinetic::Certificate represents certificate. Its main purpose is to provide a way of creating Time objects corresponding to when the certificate fails and to cache any useful work done in find the Time for later
 oCKernelThe concept Kinetic::Kernel acts as the kinetic analog of a CGAL kernel. It provides some set of primitives and predicats acting on them. The predicates are instances of Kinetic::CertificateGenerator and can be used to either create Certificates or to evaluate instantaneous predicates
 oCRootStackThe concept Kinetic::RootStack enumerates through roots of a function contained in a half open interval [lb \( \dots\) ub)
 oCSimulationTraitsThis concept ties together the parts needed in order to run a kinetic data structure. All support trajectories defined by polynomial coordinates. The Exact vs Inexect picks whether the roots of the certificate functions are compared exactly or approximated numerically. The regular triangulation models have weighted points of the appropriate dimension as the primitive used in the Kinetic::InstantaneousKernel and the Kinetic::ActiveObjectsTable
 \CSimulatorThe class Kinetic::Simulator controls kinetic data structures by maintaining a the current time and ensuring that events are processed when necessary
  oCEventThe concept Event represents a single event. Models of Event should be passed to the Kinetic::Simulator when scheduling events which will in turn pass them to the EventQueue
  \CTimeThe concept Time represents time in the simulator