mirror of https://github.com/CGAL/cgal
minor changes
This commit is contained in:
Daniel Russel
parent
3fd1aba9ac
commit
8f5fff9bfd
|
|
@ -20,7 +20,7 @@
|
|||
|
||||
|
||||
This container holds a set of objects of a particular type. It creates
|
||||
notifications using the standard \ccc{ulti_listener<Interface>}
|
||||
notifications using the standard \ccc{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.
|
||||
|
||||
|
|
@ -62,7 +62,7 @@ allow you to iterate through the objects in the set \ccc{Foo}.
|
|||
|
||||
\ccMethod{Data operator[](Key key) const;}{Access the object referenced by the key.}
|
||||
|
||||
\ccMethod{Data at(Key key) const;}{Access the object referencd by the key.}
|
||||
\ccMethod{Data at(Key key) const;}{Access the object referenced by the key.}
|
||||
|
||||
\ccMethod{void set_is_editing(bool is_editing);}{Set the editing state of
|
||||
the object. A notification is sent when the editing state is set to
|
||||
|
|
@ -71,7 +71,7 @@ allow you to iterate through the objects in the set \ccc{Foo}.
|
|||
|
||||
\ccMethod{bool is_editing() const;}{Access the editing state.}
|
||||
|
||||
\ccMethod{void set(Key key, Moving_object object);}{This method changes
|
||||
\ccMethod{void set(Key key, Data object);}{This method changes
|
||||
the motion of one moving object. The position at the current time
|
||||
should not be different from the previous current position. However,
|
||||
at the moment I do not check this as there is no reference to time
|
||||
|
|
@ -99,7 +99,7 @@ allow you to iterate through the objects in the set \ccc{Foo}.
|
|||
|
||||
\ccSeeAlso
|
||||
|
||||
\ccc{Multi_listener<Interface>}.
|
||||
\ccc{Multi_listener<Interface>},
|
||||
\ccc{Kinetic::Active_objects_listener_helper<ActiveObjectsTable, KDS>}
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -28,7 +28,7 @@ to remove all reference counts for the table or to call \ccc{clear()}.
|
|||
|
||||
\ccIsModel
|
||||
|
||||
Kinetic::ActiveObjectsTable
|
||||
\ccc{Kinetic::ActiveObjectsTable}
|
||||
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -24,7 +24,7 @@ needed for Delaunay triangulations and regular triangulations.
|
|||
|
||||
For technical reasons, the user must pick out one particular type of
|
||||
primitive to use when instantiating a model. For example, if the user
|
||||
passes a model of \ccc{Kinetic::Active_objects_vector} with a
|
||||
passes a model of \ccc{Kinetic::Active_objects_vector<Data, Object>} with a
|
||||
\ccc{Kinetic::Kernel::Point_2} as the kinetic primitive, then the type
|
||||
\ccc{Point_2} will be properly defined and the predicates on it will
|
||||
work properly, but the other predicates will not work.
|
||||
|
|
@ -33,7 +33,7 @@ work properly, but the other predicates will not work.
|
|||
|
||||
\ccIsModel
|
||||
|
||||
Kinetic::InstantaneousKernel
|
||||
\ccc{Kinetic::InstantaneousKernel}
|
||||
|
||||
\end{ccRefClass}
|
||||
|
||||
|
|
|
|||
|
|
@ -24,7 +24,7 @@ This class provides a model of \ccc{Kinetic::Kernel} for use with general Cartes
|
|||
|
||||
\ccTypes
|
||||
|
||||
\ccNestedType{Certificate}{This is a \ccc{Kinetic::Certificate} model.}
|
||||
\ccNestedType{Certificate}{This is a model of \ccc{Kinetic::Certificate}.}
|
||||
|
||||
\ccNestedType{Point_1}{}
|
||||
|
||||
|
|
|
|||
|
|
@ -23,11 +23,15 @@ This concept is for proxy objects which get notified when a kinetic Delaunay tri
|
|||
|
||||
\ccMethod{void create_vertex(Vertex_handle);}{The vertex was just created.}
|
||||
|
||||
\ccMethod{void modify_vertex(Vertex_handle);}{Something changed at the vertex.}
|
||||
\ccMethod{void modify_vertex(Vertex_handle);}{The trajectory of the point at the vertex changed.}
|
||||
|
||||
\ccMethod{template <class It> void create_faces(It begin, It end);}{New faces have just been made. The \ccc{value_type} of the iterator is a \ccc{TriangulationDataStructure_2::Face_handle}.}
|
||||
\ccMethod{template <class It> void create_faces(It begin, It
|
||||
end);}{New faces have just been made. The \ccc{value_type} of the
|
||||
iterator is a \ccc{TriangulationDataStructure_2::Face_handle}.}
|
||||
|
||||
\ccMethod{template <class It> void remove_faces(It, It);}{The faces in the range are about to be deleted. The \ccc{value_type} of the iterator is a \ccc{TriangulationDataStructure_2::Face_handle}.}
|
||||
\ccMethod{template <class It> void remove_faces(It, It);}{The faces in
|
||||
the range are about to be deleted. The \ccc{value_type} of the
|
||||
iterator is a \ccc{TriangulationDataStructure_2::Face_handle}.}
|
||||
|
||||
\ccMethod{void before_flip(Edge);}{The edge is about to be flipped.}
|
||||
|
||||
|
|
@ -36,7 +40,9 @@ This concept is for proxy objects which get notified when a kinetic Delaunay tri
|
|||
|
||||
\ccHasModels
|
||||
|
||||
\ccc{Kinetic::Delaunay_triangulation_visitor_base_2}, \ccc{Kinetic::Delaunay_triangulation_recent_edges_visitor_2<Triangulation>}, \ccc{Kinetic::Delaunay_triangulation_event_log_visitor_2}
|
||||
\ccc{Kinetic::Delaunay_triangulation_visitor_base_2},
|
||||
\ccc{Kinetic::Delaunay_triangulation_recent_edges_visitor_2<Triangulation>},
|
||||
\ccc{Kinetic::Delaunay_triangulation_event_log_visitor_2}
|
||||
|
||||
\end{ccRefConcept}
|
||||
|
||||
|
|
|
|||
|
|
@ -23,7 +23,7 @@ This concept is for proxy objects which get notified when a kinetic Delaunay tri
|
|||
|
||||
\ccMethod{void create_vertex(Vertex_handle);}{The vertex was just created.}
|
||||
|
||||
\ccMethod{void modify_vertex(Vertex_handle);}{Something changed at the vertex.}
|
||||
\ccMethod{void modify_vertex(Vertex_handle);}{The trajectory of the point at the vertex changed.}
|
||||
|
||||
\ccMethod{template <class It> void create_cells(It begin, It end);}{New faces have just been made. The iterator \ccc{value_type} is a \ccc{TriangulationDataStructure_3::Cell_handle}.}
|
||||
|
||||
|
|
|
|||
|
|
@ -19,23 +19,25 @@
|
|||
\ccDefinition
|
||||
|
||||
The class \ccRefName\ maintains a Delaunay triangulation on top of the
|
||||
points contained in a \ccc{Kinetic::ActiveObjectsTable}. It has one main method
|
||||
of interest. \ccc{triangulation()} which returns the triangulation it
|
||||
is maintaining.
|
||||
points contained in a \ccc{Kinetic::ActiveObjectsTable}. It has one
|
||||
main method of interest, \ccc{triangulation()}, which returns the
|
||||
triangulation it is maintaining.
|
||||
|
||||
The class \ccc{Kinetic::Qt_triangulation_2<KineticTriangulation_2,
|
||||
QtWidget_2, QtMovingPoints_2>} displays a kinetic Delaunay
|
||||
QtWidget_2, QtMovingPoints_2>} displays a kinetic Delaunay
|
||||
triangulation using the Qt widget.
|
||||
|
||||
This class is a good example of a simple, but non-trivial, kinetic
|
||||
data structure.
|
||||
|
||||
The Triangulation template parameter must use
|
||||
\ccc{Traits::Instantaneous_kernel} as its geometric traits and the
|
||||
\ccc{Triangulation::Face} must inherit from \ccc{Kinetic::Delaunay_triangulation_face_base_2<Traits, Base>}.
|
||||
The \ccc{Triangulation} template parameter must be a model of
|
||||
\ccc{CGAL::Delaunay_triangulation_2<Traits, Tds>} which uses
|
||||
\ccc{Traits::Instantaneous_kernel} as its geometric traits and a
|
||||
\ccc{Tds} whose face inherits from
|
||||
\ccc{Kinetic::Delaunay_triangulation_face_base_2<Traits, Base>}.
|
||||
|
||||
The optional \ccc{Visitor} parameter takes a model of
|
||||
Kinetic::DelaunayTriangulationVisitor2. Methods on this object will be called
|
||||
\ccc{Kinetic::DelaunayTriangulationVisitor2}. Methods on this object will be called
|
||||
whenever the triangulation changes.
|
||||
|
||||
\ccInclude{CGAL/Kinetic/Delaunay_triangulation_2.h}
|
||||
|
|
@ -47,16 +49,22 @@ whenever the triangulation changes.
|
|||
|
||||
\ccTypes
|
||||
|
||||
\ccNestedType{Triangulation}{The type of the Delaunay triangulation it maintains. This is a \ccc{CGAL::Delaunay_triangulation<Traits, Tds>} built using the \ccc{Kinetic::InstantaneousKernel} as the kernel.}
|
||||
\ccNestedType{Triangulation}{The template argument triangulation.}
|
||||
|
||||
\ccNestedType{Visitor}{The template argument for the visitor.}
|
||||
|
||||
\ccCreation
|
||||
\ccCreationVariable{dt} %% choose variable name
|
||||
|
||||
\ccConstructor{Delaunay_triangulation_2(Traits tr);}{Maintain the Delaunay triangulation of the points in \ccc{mot}.}
|
||||
\ccConstructor{Delaunay_triangulation_2(Traits tr);}{Maintain the
|
||||
Delaunay triangulation of the points in
|
||||
\ccc{tr.active_points_2_handle()}.}
|
||||
|
||||
\ccOperations
|
||||
|
||||
\ccMethod{const Triangulation& triangulation();}{Access the triangulation that is maintained. }
|
||||
\ccMethod{const Triangulation& triangulation() const;}{Access the triangulation that is maintained. }
|
||||
|
||||
\ccMethod{Visitor& visitor();}{Access the visitor. }
|
||||
|
||||
\ccSeeAlso
|
||||
|
||||
|
|
|
|||
|
|
@ -27,7 +27,7 @@ a large number of changes to the underlying points to be made at one
|
|||
time without recomputing the certificates each time a single point
|
||||
changes.
|
||||
|
||||
The class \ccc{Kinetic::Qty_triangulation_3<Traits>}, included as part
|
||||
The class \ccc{Kinetic::Qt_triangulation_3<Traits>}, included as part
|
||||
of the demo code, displays a kinetic Delaunay triangulation in three
|
||||
dimensions using the Coin library.
|
||||
|
||||
|
|
@ -45,12 +45,14 @@ type.
|
|||
|
||||
\ccTypes
|
||||
|
||||
\ccNestedType{Triangulation}{The type of the Delaunay triangulation it maintains. This is a \ccc{CGAL::Delaunay_triangulation_3<Traits, Tds>} built using the \ccc{Kinetic::InstantaneousKernel} as the kernel.}
|
||||
\ccNestedType{Triangulation}{The template argument.}
|
||||
|
||||
\ccNestedType{Visitor}{The template argument.}
|
||||
|
||||
\ccCreation
|
||||
\ccCreationVariable{dt} %% choose variable name
|
||||
|
||||
\ccConstructor{Delaunay_triangulation_3(Traits tr);}{Maintain the Delaunay triangulation of the points in \ccc{mot}.}
|
||||
\ccConstructor{Delaunay_triangulation_3(Traits tr);}{Maintain the Delaunay triangulation of the points in \ccc{tr.active_points_3_handle()}.}
|
||||
|
||||
\ccOperations
|
||||
|
||||
|
|
@ -60,6 +62,8 @@ type.
|
|||
|
||||
\ccMethod{void set_has_certificates(bool tf);}{This method allows you to control whether the triangulation is maintaining certificates.}
|
||||
|
||||
\ccMethod{Visitor& visitor();}{Access the visitor.}
|
||||
|
||||
\ccSeeAlso
|
||||
|
||||
\ccc{Kinetic::Regular_triangulation_3<Traits, Triangulation, Visitor>},
|
||||
|
|
|
|||
|
|
@ -18,7 +18,7 @@
|
|||
|
||||
\ccDefinition
|
||||
|
||||
This is the base class for faces used by \ccc{Kinetic::Delaunay_triangulation_3<Traits, Triangulation, Visitor>}.
|
||||
This is the base class for faces used by \ccc{Kinetic::Delaunay_triangulation_3<Traits, Triangulation, Visitor>::Triangulation}.
|
||||
|
||||
\ccInclude{CGAL/Kinetic/Delaunay_triangulation_cell_base_3.h}
|
||||
|
||||
|
|
|
|||
|
|
@ -19,12 +19,12 @@
|
|||
\ccDefinition
|
||||
|
||||
The concept \ccRefName\ provides a model of
|
||||
Kinetic::DelaunayTriangulationVisitor2 and \ccc{Kinetic::EventLogVisitor} which logs edge flip events.
|
||||
\ccc{Kinetic::DelaunayTriangulationVisitor2} and \ccc{Kinetic::EventLogVisitor} which logs edge flip events.
|
||||
|
||||
|
||||
\ccIsModel
|
||||
|
||||
Kinetic::DelaunayTriangulationVisitor2, \ccc{Kinetic::EventLogVisitor}
|
||||
\ccc{Kinetic::DelaunayTriangulationVisitor2}, \ccc{Kinetic::EventLogVisitor}
|
||||
|
||||
\ccSeeAlso
|
||||
|
||||
|
|
|
|||
|
|
@ -19,12 +19,12 @@
|
|||
\ccDefinition
|
||||
|
||||
The concept \ccRefName\ provides a model of
|
||||
Kinetic::DelaunayTriangulationVisitor3 and \ccc{Kinetic::EventLogVisitor}
|
||||
which logs edge and facet flip events.
|
||||
\ccc{Kinetic::DelaunayTriangulationVisitor3} and
|
||||
\ccc{Kinetic::EventLogVisitor} which logs edge and facet flip events.
|
||||
|
||||
\ccIsModel
|
||||
|
||||
Kinetic::DelaunayTriangulationVisitor3, \ccc{Kinetic::EventLogVisitor}
|
||||
\ccc{Kinetic::DelaunayTriangulationVisitor3}, \ccc{Kinetic::EventLogVisitor}
|
||||
|
||||
\ccSeeAlso
|
||||
|
||||
|
|
|
|||
|
|
@ -18,7 +18,9 @@
|
|||
|
||||
\ccDefinition
|
||||
|
||||
This is the base class for faces used by \ccc{Kinetic::Delaunay_triangulation_2<Traits, Triangulation, Visitor>}.
|
||||
This is the base class for faces used by the triangulation used in
|
||||
\ccc{Kinetic::Delaunay_triangulation_2<Traits, Triangulation,
|
||||
Visitor>}.
|
||||
|
||||
\ccInclude{CGAL/Kinetic/Delaunay_triangulation_face_base_2.h}
|
||||
|
||||
|
|
|
|||
|
|
@ -24,7 +24,7 @@ the most recent change.
|
|||
|
||||
\ccIsModel
|
||||
|
||||
Kinetic::DelaunayTriangulationVisitor2
|
||||
\ccc{Kinetic::DelaunayTriangulationVisitor2}
|
||||
|
||||
\ccCreation
|
||||
\ccCreationVariable{a} %% choose variable name
|
||||
|
|
@ -37,7 +37,7 @@ Kinetic::DelaunayTriangulationVisitor2
|
|||
|
||||
\ccMethod{iterator begin() const;}{Begin iteration through the recent edges.}
|
||||
|
||||
\ccMethod{iterator end() const;}{Begin iteration through the recent edges.}
|
||||
\ccMethod{iterator end() const;}{End iteration through the recent edges.}
|
||||
|
||||
\ccMethod{bool contains(Triangulation::Edge) const;}{Returns true if this edge exists in the set.}
|
||||
|
||||
|
|
|
|||
|
|
@ -19,12 +19,12 @@
|
|||
\ccDefinition
|
||||
|
||||
The concept \ccRefName\ provides a model of
|
||||
Kinetic::DelaunayTriangulationVisitor2. You can extend this class if you only
|
||||
want to implement a few methods from \ccc{Kinetic::DelaunayTriangulationVisitor}2.
|
||||
\ccc{Kinetic::DelaunayTriangulationVisitor2}. You can extend this class if you only
|
||||
want to implement a few methods from \ccc{Kinetic::DelaunayTriangulationVisitor2}.
|
||||
|
||||
\ccIsModel
|
||||
|
||||
Kinetic::DelaunayTriangulationVisitor2
|
||||
\ccc{Kinetic::DelaunayTriangulationVisitor2}
|
||||
|
||||
\ccCreation
|
||||
\ccCreationVariable{a} %% choose variable name
|
||||
|
|
|
|||
|
|
@ -19,8 +19,8 @@
|
|||
\ccDefinition
|
||||
|
||||
The concept \ccRefName\ provides a model of
|
||||
Kinetic::DelaunayTriangulationVisitor3. You can extend this class if you only
|
||||
want to implement a few methods from \ccc{Kinetic::DelaunayTriangulationVisitor}2.
|
||||
\ccc{Kinetic::DelaunayTriangulationVisitor3}. You can extend this class if you only
|
||||
want to implement a few methods from \ccc{Kinetic::DelaunayTriangulationVisitor3}.
|
||||
|
||||
\ccIsModel
|
||||
|
||||
|
|
|
|||
|
|
@ -22,8 +22,10 @@ The class \ccRefName\ keeps the points in the simulation inside of a
|
|||
box. Whenever the points come close to the wall of the box they bounce off of the wall.
|
||||
|
||||
Note that, in general, points hit the wall of the box at times which
|
||||
are not easily represented by number types. In order to handle this,
|
||||
the \ccRefName\ bounces the points at the nearest easily representable
|
||||
are not easily represented by standard (rational) number types. The
|
||||
resulting trajectories would also have non-rational coefficients,
|
||||
complicating and slowing the simulation. In order to handle this, the
|
||||
\ccRefName\ bounces the points at the nearest easily representable
|
||||
time before the point would leave the box.
|
||||
|
||||
\ccInclude{CGAL/Kinetic/Enclosing_box_2.h}
|
||||
|
|
|
|||
|
|
@ -19,11 +19,15 @@
|
|||
\ccDefinition
|
||||
|
||||
The class \ccRefName\ keeps the points in the simulation inside of a
|
||||
box. Whenever the points come close to the wall of the box they bounce off of the wall.
|
||||
box. Whenever the points come close to the wall of the box they bounce
|
||||
off of the wall.
|
||||
|
||||
|
||||
Note that, in general, points hit the wall of the box at times which
|
||||
are not easily represented by number types. In order to handle this,
|
||||
the \ccRefName\ bounces the points at the nearest easily representable
|
||||
are not easily represented by standard (rational) number types. The
|
||||
resulting trajectories would also have non-rational coefficients,
|
||||
complicating and slowing the simulation. In order to handle this, the
|
||||
\ccRefName\ bounces the points at the nearest easily representable
|
||||
time before the point would leave the box.
|
||||
|
||||
\ccInclude{CGAL/Kinetic/Enclosing_box_3.h}
|
||||
|
|
|
|||
|
|
@ -26,7 +26,10 @@ scheduling events which will in turn pass them to the
|
|||
|
||||
\ccOperations
|
||||
|
||||
\ccMethod{void process();}{This method is called when the event occurs, and the time when it occurs is passed in as \ccc{t}. \ccc{Time} is the type defined by the \ccc{Simulator}. This method will only be called once per time this event is scheduled and the event will be removed from the queue immediately afterwards.}
|
||||
\ccMethod{void process();}{This method is called when the event
|
||||
occurs. This method will only be called once per time this event is
|
||||
scheduled and the event will be removed from the queue immediately
|
||||
afterwards.}
|
||||
|
||||
\ccGlobalFunction{std::ostream& operator<<(std::ostream&, Event);}{Write a text description of the event to a standard stream.}
|
||||
|
||||
|
|
@ -36,7 +39,7 @@ All over the place.
|
|||
|
||||
\ccSeeAlso
|
||||
|
||||
Kinetic::EventQueue
|
||||
\ccc{Kinetic::EventQueue}
|
||||
|
||||
\ccExample
|
||||
|
||||
|
|
@ -45,15 +48,19 @@ All of the kinetic data structures provided have models of
|
|||
sorting kinetic data structure.
|
||||
|
||||
\begin{ccExampleCode}
|
||||
template <class Sort, class Id, class Root_enumerator>
|
||||
template <class Certificate, class Id, class Root_enumerator>
|
||||
class Swap_event {
|
||||
public:
|
||||
Swap_event(Id o, typename Sort::Pointer sorter,
|
||||
const Root_enumerator &s): left_object_(o), sorter_(sorter), s_(s){}
|
||||
Swap_event(Id o, typename Sort::Handle sorter,
|
||||
const Certificate &s): left_object_(o),
|
||||
sorter_(sorter),
|
||||
s_(s){}
|
||||
void process(){
|
||||
sorter_->swap(left_object_, s_);
|
||||
}
|
||||
Id left_object_; typename Sort::Pointer sorter_; Solver s_;
|
||||
Id left_object_;
|
||||
typename Sort::Handle sorter_;
|
||||
Certificate s_;
|
||||
};
|
||||
\end{ccExampleCode}
|
||||
|
||||
|
|
|
|||
|
|
@ -26,14 +26,18 @@ queue must implement the \ccc{Event} concept.
|
|||
|
||||
\ccTypes
|
||||
|
||||
\ccNestedType{Key}{The type used to access items in the queue in order to change or delete them.}
|
||||
\ccNestedType{Key}{The type used to access items in the queue in order
|
||||
to change or delete them.}
|
||||
|
||||
\ccNestedType{Priority}{The priority type for items in the queue. This is typically the same as \ccc{Kinetic::Simulator}::Time}.
|
||||
\ccNestedType{Priority}{The priority type for items in the queue. This
|
||||
is typically the same as \ccc{Kinetic::Simulator::Time}}.
|
||||
|
||||
\ccCreation
|
||||
\ccCreationVariable{q} %% choose variable name
|
||||
|
||||
\ccConstructor{EventQueue(Priority start, Priority end, int size_hint);}{Construct a queue which will start at time start and run until time end.}
|
||||
\ccConstructor{EventQueue(Priority start, Priority end, int
|
||||
size_hint);}{Construct a queue which will start at time start and
|
||||
run until time end.}
|
||||
|
||||
\ccOperations
|
||||
|
||||
|
|
|
|||
|
|
@ -37,21 +37,29 @@ capability is not needed.
|
|||
|
||||
\ccNestedType{Root}{A type representing the roots of a \ccc{Function}.}
|
||||
|
||||
\ccNestedType{Root_stack}{A model of \ccc{RootEnumerator}. These objects can be created by calling the \ccc{root_enumerator_object} method with a \ccc{Function} and two (optional) \ccc{Root} objects. The enumerator then enumerates all roots of the function in the open inverval defined by the two root arguments. They optional arguments default to positive and negative infinity. }
|
||||
\ccNestedType{Root_stack}{A model of \ccc{RootStack}. These objects can be created by calling the \ccc{root_stack_object} method with a \ccc{Function} and two (optional) \ccc{Root} objects. The enumerator then enumerates all roots of the function in the open inverval defined by the two root arguments. They optional arguments default to positive and negative infinity. }
|
||||
|
||||
\ccNestedType{Root_enumerator_traits}{The traits for the \ccc{Root_enumerator} class.}
|
||||
|
||||
Each of the following types has a corresponding \ccc{type_object} method (not explicitly documented) which takes a \ccc{Function} as an argument.
|
||||
Each of the following types has a corresponding \ccc{type_object}
|
||||
method (not explicitly documented) which takes a \ccc{Function} as an
|
||||
argument.
|
||||
|
||||
\ccNestedType{Sign_at}{A functor which returns the sign of a \ccc{Function} at a \ccc{NT} or \ccc{Root}.}
|
||||
\ccNestedType{Sign_at}{A functor which returns the sign of a
|
||||
\ccc{Function} at a \ccc{NT} or \ccc{Root}.}
|
||||
|
||||
\ccNestedType{Multiplicity}{A functor which returns the multiplicity of roots.}
|
||||
|
||||
\ccNestedType{Sign_above}{A functor which returns sign of a function immediately above a root.}
|
||||
\ccNestedType{Sign_above}{A functor which returns sign of a function
|
||||
immediately above a root.}
|
||||
|
||||
The following functor likewise have a \ccc{type_object} method, but these take arguments other than a \ccc{Function}. The arguments are given below.
|
||||
The following functor likewise have a \ccc{type_object} method, but
|
||||
these take arguments other than a \ccc{Function}. The arguments are
|
||||
given below.
|
||||
|
||||
\ccNestedType{Sign_between_roots}{This functor, creation of which requires two \ccc{Root}s, returns the sign of a passed function between the pair of roots.}
|
||||
\ccNestedType{Sign_between_roots}{This functor, creation of which
|
||||
requires two \ccc{Root}s, returns the sign of a passed function
|
||||
between the pair of roots.}
|
||||
|
||||
%\ccNestedType{Compare_isolated_roots_in_interval}{This functor, creation of which requires two functions, compares the roots of two functions in an isolating invterval. More specifically, it takes two \ccc{NT}s as an argument. These numbers must isolate a root for each of the functions the functor is constructed with. The functor then returns true if the isolated root of the first function is less than that of the second.}
|
||||
|
||||
|
|
@ -61,7 +69,7 @@ The following functor likewise have a \ccc{type_object} method, but these take a
|
|||
|
||||
%\ccNestedType{Remainder}{Compute the remainder of one \ccc{Functions} divided by another.}
|
||||
|
||||
\ccNestedType{Are_negations_object}{Return true of the two functions passed are negations of one another.}
|
||||
%\ccNestedType{Are_negations_object}{Return true of the two functions passed are negations of one another.}
|
||||
|
||||
%\ccNestedType{Sturm_sequence}{This object evaluates the Sturm sequence of two \ccc{Function}s at a \ccc{NT} value. Construction requires two \ccc{Function}s.}
|
||||
|
||||
|
|
@ -95,7 +103,7 @@ The following methods do not require any arguments to get the functor and take o
|
|||
%\ccMethod{void foo();}{some member functions}
|
||||
|
||||
\ccHasModels
|
||||
\ccc{POLYNOMIAL::Kernel<RootEnumerator>}, \ccc{POLYNOMIAL::Filtered_kernel<RootEnumerator>}.
|
||||
\ccc{POLYNOMIAL::Kernel<RootStack>}, \ccc{POLYNOMIAL::Filtered_kernel<RootStack>}.
|
||||
|
||||
\ccSeeAlso
|
||||
|
||||
|
|
@ -105,7 +113,7 @@ Kinetic::RootEnumerator
|
|||
|
||||
We provide several models of the concept, which are not documented
|
||||
separately. The models of \ccc{Kinetic::SimulationTraits} all choose
|
||||
appropriate models, so the user should have have to pick. However, if
|
||||
appropriate models. However, if
|
||||
more control is desired, we here provide examples of how to create the
|
||||
various supported \ccc{Kinetic::FunctionKernel}.
|
||||
|
||||
|
|
@ -120,7 +128,7 @@ typedef CGAL::POLYNOMIAL::Kernel<Function, Root_stack> Function_kernel;
|
|||
A wrapper for \ccc{CORE::Expr} which implements the necessary
|
||||
operations:
|
||||
\begin{ccExampleCode}
|
||||
typedef CGAL::POLYNOMIAL::CORE_kernel Function_kernel;
|
||||
typedef CGAL::POLYNOMIAL::CORE_kernel Function_kernel;
|
||||
\end{ccExampleCode}
|
||||
|
||||
A function kernel which computes approximations to the roots of the polynomials:
|
||||
|
|
|
|||
|
|
@ -18,28 +18,46 @@
|
|||
|
||||
\ccDefinition
|
||||
|
||||
This event inserts a point into the \ccc{ActiveObjectsTable} when the event is processed.
|
||||
This event inserts a point into the \ccc{ActiveObjectsTable} when it
|
||||
is processed.
|
||||
|
||||
\ccInclude{CGAL/Kinetic/Insert_event.h}
|
||||
|
||||
\ccIsModel
|
||||
Kinetic::Event
|
||||
\ccc{Kinetic::Event}
|
||||
|
||||
\ccCreation
|
||||
\ccCreationVariable{i} %% choose variable name
|
||||
|
||||
\ccConstructor{Insert_event(ActiveObjectsTable::Data o, ActiveObjectsTable::Handle t);}{Insert the object o, into the table t when processed.}
|
||||
\ccConstructor{Insert_event(ActiveObjectsTable::Data o,
|
||||
ActiveObjectsTable::Handle t);}{Insert the object o, into the table
|
||||
t when processed.}
|
||||
|
||||
|
||||
\ccSeeAlso
|
||||
|
||||
Kinetic::ActiveObjectsTable,
|
||||
\ccc{Kinetic::ActiveObjectsTable},
|
||||
\ccc{Kinetic::Active_objects_vector<MovingObject>}.
|
||||
|
||||
\ccExample
|
||||
|
||||
\begin{ccExampleCode}
|
||||
typedef CGAL::Kinetic::Exact_simulation_traits_2 Simulation_traits;
|
||||
typedef Simulation_traits::Kinetic_kernel::Point_2 Moving_point_2;
|
||||
typedef CGAL::Kinetic::Insert_event<Simulation_traits::Active_points_2_table> Insert_event;
|
||||
typedef CGAL::Kinetic::Delaunay_triangulation_2<Simulation_traits> KDel;
|
||||
|
||||
\verb|\ccIncludeExampleCode{Kinetic_data_structures/insert_event.C}|
|
||||
Simulation_traits tr;
|
||||
|
||||
KDel kdel(tr);
|
||||
|
||||
Moving_point_2 mp(Moving_point_2::NT(0),
|
||||
Moving_point_2::NT(0));
|
||||
tr.simulator_handle()->new_event(Simulation_traits::Simulator::Time(3),
|
||||
Insert_event(mp,
|
||||
tr.active_points_2_table_handle()));
|
||||
|
||||
\end{ccExampleCode}
|
||||
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -24,7 +24,7 @@ typically only supports one type of moving object.
|
|||
|
||||
Currently, each model is created for one particular type of kinetic
|
||||
primitive. The primitives are identified by
|
||||
Kinetic::ActiveObjectsTable::Key objects.
|
||||
\ccc{Kinetic::ActiveObjectsTable::Key} objects.
|
||||
|
||||
\ccTypes
|
||||
|
||||
|
|
|
|||
|
|
@ -26,13 +26,20 @@ them.
|
|||
\ccCreationVariable{kk}
|
||||
\ccTypes
|
||||
|
||||
\ccNestedType{Motion_function}{The type which is used to represent coordinates of moving primitives. This is the analog of the CGAL kernel \ccc{RT}.}
|
||||
\ccNestedType{Certificate}{The type representing the results of predicates. See \ccc{Kinetic::Certificate}.}
|
||||
\ccNestedType{Function_kernel}{The type of the function kernel used. See \ccc{Kinetic::FunctionKernel}.}
|
||||
\ccNestedType{Motion_function}{The type which is used to represent
|
||||
coordinates of moving primitives. This is the analog of the CGAL
|
||||
kernel \ccc{RT}.}
|
||||
|
||||
\ccNestedType{Certificate}{The type representing the results of
|
||||
predicates. See \ccc{Kinetic::Certificate}.}
|
||||
|
||||
\ccNestedType{Function_kernel}{The type of the function kernel used.
|
||||
See \ccc{Kinetic::FunctionKernel}.}
|
||||
|
||||
\ccOperations
|
||||
|
||||
\ccMethod{Function_kernel function_kernel_object() const;}{Gets a copy of the function kernel.}
|
||||
\ccMethod{Function_kernel function_kernel_object() const;}{Gets a copy
|
||||
of the function kernel.}
|
||||
|
||||
\ccCreationVariable{a} %% choose variable name
|
||||
|
||||
|
|
|
|||
|
|
@ -31,10 +31,10 @@ method on the proxy, passing the type of the notification. The proxy
|
|||
stores a reference counted pointer to the notifier, ensuring that
|
||||
there are never any dangling pointers in the system.
|
||||
|
||||
The class \ccRefName\ provides base class for listener proxy
|
||||
objects. An notifier should provide class which uses this base. To use
|
||||
this base class, implement a class, here called Interface, which
|
||||
defines a type \ccc{Interface::Notification_type} and a type
|
||||
The class \ccRefName\ provides base class for listener proxy objects.
|
||||
A notifier should provide a class which inherits from this base. To
|
||||
use this base class, implement a class, here called \ccc{Interface},
|
||||
which defines a type \ccc{Interface::Notification_type} and a type
|
||||
\ccc{Interface::Notifier_handle}.
|
||||
|
||||
The \ccc{Notification_type} is generally an enum with one value for
|
||||
|
|
@ -48,16 +48,17 @@ pointer.
|
|||
The \ccRefName\ maintains a ref counted pointer to the object
|
||||
performing notifications. It is registered for notifications on
|
||||
construction and unregistered on destruction using the function
|
||||
\ccc{set_listener} on the object providing the notifications. The use
|
||||
of ref counted pointers means that as long as the notification object
|
||||
exists, the object providing the notifications must exist, ensuring
|
||||
that the object providing the notifications is not prematurely
|
||||
destroyed.
|
||||
\ccc{set_listener(Listener<Interface>*)} on the object providing the
|
||||
notifications. The use of ref counted pointers means that as long as
|
||||
the notification object exists, the object providing the notifications
|
||||
must exist, ensuring that the object providing the notifications is
|
||||
not prematurely destroyed.
|
||||
|
||||
These objects cannot be copied since the notifier only support one
|
||||
listener.
|
||||
listener. If copying and more than one listener are desired, the
|
||||
\ccc{Multi_listener<Interface>} base class should be used instead.
|
||||
|
||||
Boost provides a similar functionality in the Boost.Signal
|
||||
As a side note, Boost provides a similar functionality in the Boost.Signal
|
||||
package. However, it is quite a bit more complex (and flexible). This
|
||||
complexity add significantly to compile time and (although I did not
|
||||
test this directly), I suspect it is much slower at runtime due to the
|
||||
|
|
@ -95,7 +96,53 @@ writing my own.
|
|||
|
||||
\ccExample
|
||||
|
||||
\ccIncludeExampleCode{Kinetic_data_structures/listener.C}
|
||||
Here is a simplier class that provides notifications:
|
||||
\begin{ccExampleCode}
|
||||
struct Notifier: public CGAL::Kinetic::Ref_counted<Notifier>
|
||||
{
|
||||
public:
|
||||
Notifier(): data_(0), listener_(NULL){}
|
||||
|
||||
struct Listener_interface
|
||||
{
|
||||
public:
|
||||
typedef enum Notification_type {DATA_CHANGED} Notification_type;
|
||||
typedef Notifier::Handle Notifier_handle;
|
||||
};
|
||||
|
||||
typedef CGAL::Kinetic::Listener<Listener_interface> Listener;
|
||||
friend class CGAL::Kinetic::Listener<Listener_interface>;
|
||||
|
||||
void set_data(int d) {
|
||||
data_=d;
|
||||
if (listener_ != NULL) listener_->new_notification(Listener_interface::DATA_CHANGED);
|
||||
}
|
||||
|
||||
protected:
|
||||
void set_listener(Listener *l) {
|
||||
listener_= l;
|
||||
}
|
||||
Listener* listener() const {return listener_;}
|
||||
|
||||
int data_;
|
||||
Listener *listener_;
|
||||
};
|
||||
\end{ccExampleCode}
|
||||
|
||||
Now the listener:
|
||||
\begin{ccExampleCode}
|
||||
|
||||
struct My_listener: public Notifier::Listener, public CGAL::Kinetic::Ref_counted<My_listener>
|
||||
{
|
||||
typedef Notifier::Listener::Notifier_handle PP;
|
||||
My_listener(PP p): P(p){}
|
||||
|
||||
void new_notification(P::Notification_type nt) {
|
||||
...
|
||||
}
|
||||
};
|
||||
|
||||
\end{ccExampleCode}
|
||||
|
||||
|
||||
\end{ccRefClass}
|
||||
|
|
|
|||
|
|
@ -18,7 +18,11 @@
|
|||
|
||||
\ccDefinition
|
||||
|
||||
The class \ccRefName\ implements a base class for listeners where more than one listener is allowed to subscribe to a notifier. See \ccc{Listener} for full documentation.
|
||||
The class \ccRefName\ implements a base class for listeners where more
|
||||
than one listener is allowed to subscribe to a notifier. See
|
||||
\ccc{Listener} for full documentation. This uses the function calls
|
||||
\ccc{new_listener()} and \ccc{delete_listener()} to register and
|
||||
unrester the listener (instead of \ccc{set_listener()}).
|
||||
|
||||
\ccInclude{CGAL/Kinetic/Multi_listener.h}
|
||||
|
||||
|
|
|
|||
|
|
@ -20,6 +20,8 @@
|
|||
|
||||
The class \ccRefName\ displays a set of moving points in 2D.
|
||||
|
||||
See Section~\ref{sec:delaunay_2_example} for an example using this class.
|
||||
|
||||
\ccInclude{CGAL/Kinetic/IO/Qt_moving_points_2.h}
|
||||
|
||||
|
||||
|
|
@ -35,11 +37,6 @@ The class \ccRefName\ displays a set of moving points in 2D.
|
|||
|
||||
\ccc{Kinetic::Qt_widget_2<Simulator>}.
|
||||
|
||||
\ccExample
|
||||
|
||||
\ccIncludeExampleCode{Kinetic_data_structures/Delaunay_triangulation_2.C}
|
||||
|
||||
|
||||
\end{ccRefClass}
|
||||
|
||||
% +------------------------------------------------------------------------+
|
||||
|
|
|
|||
|
|
@ -18,10 +18,12 @@
|
|||
|
||||
\ccDefinition
|
||||
|
||||
The class draws a triangulation into the \ccc{QtWidget_2}. This class is
|
||||
The class draws a triangulation into a \ccc{CGAL::Qt_widget_2}. This class is
|
||||
very simple and a good one to look at if you want to see how to draw
|
||||
your own two dimensional kinetic data structure.
|
||||
|
||||
See Section~\ref{sec:delaunay_2_example} for an example using this class.
|
||||
|
||||
\ccInclude{CGAL/Kinetic/IO/Qt_triangulation_2.h}
|
||||
|
||||
\ccCreation
|
||||
|
|
|
|||
|
|
@ -18,7 +18,11 @@
|
|||
|
||||
\ccDefinition
|
||||
|
||||
The class \ccRefName\ implements a base class for objects which are reference counted. To use it simply inherit from \ccRefName\ (passing the type to be reference counted as the template argument) and then access the object through \ccc{Pointer} objects rather than bare C++ pointers.
|
||||
The class \ccRefName\ implements a base class for objects which are
|
||||
reference counted. To use it simply inherit from \ccRefName\ (passing
|
||||
the type to be reference counted as the template argument) and then
|
||||
access the object through \ccc{Handle} objects rather than bare C++
|
||||
pointers.
|
||||
|
||||
\ccInclude{CGAL/Kinetic/Ref_counted.h}
|
||||
|
||||
|
|
@ -37,13 +41,6 @@ The class \ccRefName\ implements a base class for objects which are reference co
|
|||
|
||||
There are no methods which should be called by users of this class.
|
||||
|
||||
|
||||
\ccExample
|
||||
|
||||
\ccIncludeExampleCode{Kinetic_data_structures/ref_counted.C}
|
||||
|
||||
|
||||
|
||||
\end{ccRefClass}
|
||||
|
||||
% +------------------------------------------------------------------------+
|
||||
|
|
|
|||
|
|
@ -23,7 +23,7 @@ This concept is for proxy objects which get notified when a kinetic regular tria
|
|||
|
||||
\ccMethod{void create_vertex(Vertex_handle);}{The vertex was just created.}
|
||||
|
||||
\ccMethod{void modify_vertex(Vertex_handle);}{Something changed at the vertex.}
|
||||
\ccMethod{void modify_vertex(Vertex_handle);}{The trajectory of the vertex just changed.}
|
||||
|
||||
\ccMethod{template <class It> void create_cells(It begin, It end);}{New faces have just been made. The iterator \ccc{value_type} is a \ccc{TriangulationDataStructure_3::Cell_handle}.}
|
||||
|
||||
|
|
|
|||
|
|
@ -22,9 +22,12 @@ The class \ccRefName\ maintains a triangulation of set of moving
|
|||
weighted points. Its interface is the same as
|
||||
\ccc{Kinetic::Delaunay_triangulation_3<Traits, Visitor, Triangulation>}.
|
||||
|
||||
The \ccc{Triangulation} template argument must have
|
||||
The optional \ccc{Triangulation} template argument must be a model of
|
||||
\ccc{CGAL::RegularTriangulation_3} which has
|
||||
\ccc{Kinetic::Regular_triangulation_cell_base_3<Traits, Base>} as a
|
||||
cell base and \ccc{Kinetic::Regular_triangulation_vertex_base_3<Traits, Base>} as a vertex base.
|
||||
cell base and
|
||||
\ccc{Kinetic::Regular_triangulation_vertex_base_3<Traits, Base>} as a
|
||||
vertex base.
|
||||
|
||||
\ccInclude{CGAL/Kinetic/Regular_triangulation_3.h}
|
||||
|
||||
|
|
|
|||
|
|
@ -19,12 +19,12 @@
|
|||
\ccDefinition
|
||||
|
||||
The concept \ccRefName\ provides a model of
|
||||
Kinetic::RegularTriangulationVisitor3 and \ccc{EventLogVisitor} which logs edge flip events.
|
||||
\ccc{Kinetic::RegularTriangulationVisitor3} and \ccc{EventLogVisitor} which logs edge flip events.
|
||||
|
||||
|
||||
\ccIsModel
|
||||
|
||||
Kinetic::RegularTriangulationVisitor\_3, \ccc{Kinetic::EventLogVisitor}
|
||||
\ccc{Kinetic::RegularTriangulationVisitor3}, \ccc{Kinetic::EventLogVisitor}
|
||||
|
||||
\ccSeeAlso
|
||||
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@
|
|||
% +------------------------------------------------------------------------+
|
||||
|
||||
|
||||
\begin{ccRefClass}{Kinetic::Regular_triangulation_instantaneous_traits_3<ActiveObjectsTable, StaticKernel>} %% add template arg's if necessary
|
||||
\begin{ccRefClass}{Kinetic::Regular_triangulation_instantaneous_traits_3<ActiveObjectsTable, StaticKernel>}
|
||||
|
||||
%% \ccHtmlCrossLink{} %% add further rules for cross referencing links
|
||||
%% \ccHtmlIndexC[class]{} %% add further index entries
|
||||
|
|
@ -20,14 +20,15 @@
|
|||
|
||||
The class \ccRefName\ is an instantaneous kernel for use with a
|
||||
regular triangulation data structure. There is not currently a reason
|
||||
for the user to call this directly as it is included as part of the
|
||||
for the user to call this directly unless the user wants created their
|
||||
own simulation traits as it is included as part of the
|
||||
\ccc{Kinetic::Regular_triangulation_exact_simulation_traits_3}.
|
||||
|
||||
\ccInclude{CGAL/Kinetic/Regular_triangulation_instantaneous_traits_3.h}
|
||||
|
||||
\ccIsModel
|
||||
|
||||
RegularTriangulationTraits\_3, \ccc{Kinetic::InstantaneousKernel}
|
||||
\ccc{CGAL::RegularTriangulationTraits\_3}, \ccc{Kinetic::InstantaneousKernel}
|
||||
|
||||
\ccSeeAlso
|
||||
|
||||
|
|
|
|||
|
|
@ -18,7 +18,9 @@
|
|||
|
||||
\ccDefinition
|
||||
|
||||
This is the base class for faces used by \ccc{Kinetic::Regular_triangulation_3<Traits, Triangulation, Visitor>}.
|
||||
This is the base class for the vertices of the triangulation class
|
||||
used by \ccc{Kinetic::Regular_triangulation_3<Traits, Triangulation,
|
||||
Visitor>}.
|
||||
|
||||
\ccInclude{CGAL/Kinetic/Regular_triangulation_vertex_base_3.h}
|
||||
|
||||
|
|
|
|||
|
|
@ -19,12 +19,12 @@
|
|||
\ccDefinition
|
||||
|
||||
The concept \ccRefName\ provides a model of
|
||||
Kinetic::RegularTriangulationVisitor\_3. You can extend this class if you only
|
||||
want to implement a few methods from \ccc{Kinetic::RegularTriangulationVisitor}\_3.
|
||||
\ccc{Kinetic::RegularTriangulationVisitor3}. You can extend this class if you only
|
||||
want to implement a few methods from \ccc{Kinetic::RegularTriangulationVisitor3}.
|
||||
|
||||
\ccIsModel
|
||||
|
||||
Kinetic::RegularTriangulationVisitor\_3
|
||||
\ccc{Kinetic::RegularTriangulationVisitor3}
|
||||
|
||||
\ccCreation
|
||||
\ccCreationVariable{a} %% choose variable name
|
||||
|
|
|
|||
|
|
@ -18,9 +18,11 @@
|
|||
|
||||
\ccDefinition
|
||||
|
||||
The concept \ccRefName\ enumerates through roots of a function. Most
|
||||
of the root stacks maintain the invariant that
|
||||
\ccc{pop()} can be called exactly once per root in the interval. However, certain of the \ccRefName s delay prooving that there are no remaining root, and so might return one root with the value \ccc{std::numeric_limits<Root>::infinity()} which does not correspond to an existing root. Comparing \ccc{top()} to the \ccc{Root} defining the end of the interval will allow you to make sure that it corresponds to an actual root of the polynomial (it is greater or equal then it is not in the interval).
|
||||
The concept \ccRefName\ enumerates through roots of a function
|
||||
contained in a certain interval. They may return one extra root which
|
||||
has value \ccc{std::numeric_limits<Root>::infinity()}, as this allows
|
||||
the root stacks to delay isolating roots until the isolation is needed
|
||||
to properly evaluate comparisons.
|
||||
|
||||
\ccTypes
|
||||
|
||||
|
|
@ -48,7 +50,7 @@ of the root stacks maintain the invariant that
|
|||
|
||||
\ccSeeAlso
|
||||
|
||||
Kinetic::FunctionKernel, \ccc{Kinetic::Certificate}.
|
||||
\ccc{Kinetic::FunctionKernel}, \ccc{Kinetic::Certificate}.
|
||||
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -17,20 +17,44 @@
|
|||
\ccDefinition
|
||||
|
||||
This concept ties together the parts needed in order to run a kinetic
|
||||
data structure.
|
||||
data structure. We provide several models of this concept:
|
||||
\begin{itemize}
|
||||
\item \ccc{Kinetic::Exact_simulation_traits_1}
|
||||
\item \ccc{Kinetic::Exact_simulation_traits_2}
|
||||
\item \ccc{Kinetic::Exact_simulation_traits_3}
|
||||
\item \ccc{Kinetic::Inexact_simulation_traits_1}
|
||||
\item \ccc{Kinetic::Inexact_simulation_traits_2}
|
||||
\item \ccc{Kinetic::Inexact_simulation_traits_3}
|
||||
\item \ccc{Kinetic::Exact_linear_simulation_traits_2}
|
||||
\item \ccc{Kinetic::Exact_linear_simulation_traits_3}
|
||||
\item \ccc{Kinetic::Inexact_linear_simulation_traits_2}
|
||||
\item \ccc{Kinetic::Inexact_linear_simulation_traits_3}
|
||||
\item \ccc{Kinetic::Regular_triangulation_exact_simulation_traits_3}
|
||||
\item \ccc{Kinetic::Regular_triangulation_inexact_simulation_traits_3}
|
||||
\end{itemize}
|
||||
|
||||
All support trajectories defined by polynomial coordinates. The
|
||||
\ccc{Exact} vs \ccc{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
|
||||
\ccc{Kinetic::InstantaneousKernel} and the
|
||||
\ccc{Kinetic::ActiveObjectsTable}.
|
||||
|
||||
|
||||
\ccTypes
|
||||
|
||||
\ccNestedType{NT}{The number type used for representation.}
|
||||
|
||||
\ccNestedType{Static_kernel}{A CGAL kernel which can be used for static computations.}
|
||||
|
||||
\ccNestedType{Instantaneous_kernel}{A model of
|
||||
\ccc{Kinetic::InstantaneousKernel} which can be used to apply static CGAL
|
||||
data structures to snapshots of moving data.}
|
||||
|
||||
\ccNestedType{Kinetic_kernel}{A model of Kineti::Kernel.}
|
||||
\ccNestedType{Kinetic_kernel}{A model of \ccc{Kinetic::Kernel}.}
|
||||
|
||||
\ccNestedType{Active_points_[123]_table}{A model of
|
||||
\ccc{Kinetic::ActiveObjectsTable} which holds the relevant kinetic
|
||||
primitives.}
|
||||
|
||||
\ccNestedType{Simulator}{A model of \ccc{Kinetic::Simulator} which will be
|
||||
used by all the kinetic data structures.}
|
||||
|
|
@ -40,13 +64,16 @@ used by all the kinetic data structures.}
|
|||
\ccOperations
|
||||
\ccCreationVariable{st}
|
||||
|
||||
\ccMethod{Static_kernel static_kernel_object();}{Get a new static kernel.}
|
||||
|
||||
\ccMethod{Instantaneous_kernel instantaneous_kernel_object();}{Get a new instantaneous kernel.}
|
||||
|
||||
\ccMethod{Kinetic_kernel kinetic_kernel_object();}{Get a new kinetic kernel.}
|
||||
|
||||
\ccMethod{Simulator::Handle simulator_handle();}{Return a pointer to the \ccc{Simulator} which is to be used in the simulation.}
|
||||
\ccMethod{Simulator::Handle simulator_handle();}{Return a pointer to the \ccc{Kinetic::Simulator} which is to be used in the simulation.}
|
||||
|
||||
\ccMethod{Active_points_[123]_table::Handle
|
||||
active_points_[123]_table_handle();}{Return a pointer to the
|
||||
\ccc{Kinetic::ActiveObjectsTable} which is to be used in the
|
||||
simulation.}
|
||||
|
||||
%\ccMethod{Active_objects_table* active_objects_table_pointer();}{Return a pointer to the table holding points which is to be used in the simulation.}
|
||||
|
||||
|
|
@ -61,7 +88,9 @@ used by all the kinetic data structures.}
|
|||
\ccc{Kinetic::Exact_linear_simulation_traits_2},
|
||||
\ccc{Kinetic::Exact_linear_simulation_traits_3},
|
||||
\ccc{Kinetic::Inexact_linear_simulation_traits_2},
|
||||
\ccc{Kinetic::Inexact_linear_simulation_traits_3}
|
||||
\ccc{Kinetic::Inexact_linear_simulation_traits_3},
|
||||
\ccc{Kinetic::Regular_triangulation_exact_simulation_traits_3},
|
||||
\ccc{Kinetic::Regular_triangulation_inexact_simulation_traits_3}
|
||||
|
||||
\end{ccRefConcept}
|
||||
|
||||
|
|
|
|||
|
|
@ -19,8 +19,8 @@
|
|||
\ccDefinition
|
||||
|
||||
The class \ccRefName\ controls kinetic data structures by maintaining
|
||||
a concept of time and ensuring that events are processed when
|
||||
necessary.
|
||||
a the current time and ensuring that events are processed when
|
||||
necessary.
|
||||
|
||||
In addition, the \ccRefName\ can call on the kinetic data structures
|
||||
to audit themselves at appropriate times. When the last event
|
||||
|
|
|
|||
|
|
@ -22,7 +22,7 @@ The class \ccRefName\ acts as a helper class for kinetic data
|
|||
structures which want to respond to
|
||||
\ccc{Simulator::Listener::HAS_AUDIT_TIME} notifications. When kinetic
|
||||
data structures can audit themselves, the \ccRefName\ calls the
|
||||
\ccc{audit()} method on the \ccc{KDS}.
|
||||
\ccc{audit()} method on the kinetic data structure.
|
||||
|
||||
\ccInclude{CGAL/Kinetic/Simulator_kds_listener.h}
|
||||
|
||||
|
|
@ -34,7 +34,7 @@ data structures can audit themselves, the \ccRefName\ calls the
|
|||
|
||||
\ccSeeAlso
|
||||
|
||||
Kinetic::Simulator, Listener.
|
||||
\ccc{Kinetic::Simulator}, \ccc{Listener<Interface>}.
|
||||
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -4,87 +4,142 @@
|
|||
\ccHeading{Definition}
|
||||
|
||||
Kinetic data structures are a way of adding motion to classical
|
||||
geometric data structures. \cgal provides a number of classes to aid
|
||||
geometric data structures. \cgal\ provides a number of classes to aid
|
||||
implementation of kinetic data structures as well as a number of
|
||||
prepackaged kinetic data structures.
|
||||
|
||||
There are three levels at which the user can interact with the
|
||||
package. The can use an existing kinetic data structure, write a new
|
||||
kinetic data structure, or replace parts of the framework. The
|
||||
package. The user can use an existing kinetic data structure, write a
|
||||
new kinetic data structure, or replace parts of the framework. The
|
||||
concepts and models are grouped into these three classes.
|
||||
|
||||
\ccHeading{Existing Kinetic Data Structures}
|
||||
|
||||
First we have the
|
||||
existing kinetic data structures and the helper classes that allow
|
||||
their activity to monitored.
|
||||
First we have the existing kinetic data structures and the helper
|
||||
classes that allow their activity to monitored.
|
||||
|
||||
\ccRefIdfierPage{Kinetic::Delaunay_triangulation_2<Traits, Visitor, Triangulation>}
|
||||
|
||||
\ccRefIdfierPage{Kinetic::Delaunay_triangulation_3<Traits, Visitor, Triangulation>}
|
||||
|
||||
\ccRefIdfierPage{Kinetic::Enclosing_box_2<Traits>}
|
||||
|
||||
\ccRefIdfierPage{Kinetic::Enclosing_box_3<Traits>}
|
||||
\ccRefIdfierPage{Kinetic::Regular_triangulation_3<Traits, Visitor, Triangulation>}
|
||||
|
||||
\ccRefIdfierPage{Kinetic::Regular_triangulation_3<Traits, Visitor, Triangulation>}
|
||||
|
||||
\ccRefIdfierPage{Kinetic::Sort<Traits, Visitor>}
|
||||
|
||||
The visitors:
|
||||
|
||||
\ccRefConceptPage{Kinetic::DelaunayTriangulationVisitor2}
|
||||
|
||||
\ccRefConceptPage{Kinetic::DelaunayTriangulationVisitor3}
|
||||
|
||||
\ccRefIdfierPage{Kinetic::Delaunay_triangulation_event_log_visitor_2}
|
||||
|
||||
\ccRefIdfierPage{Kinetic::Delaunay_triangulation_event_log_visitor_3}
|
||||
|
||||
\ccRefIdfierPage{Kinetic::Delaunay_triangulation_recent_edges_visitor_2<Triangulation>}
|
||||
|
||||
\ccRefIdfierPage{Kinetic::Delaunay_triangulation_visitor_base_2}
|
||||
|
||||
\ccRefIdfierPage{Kinetic::Delaunay_triangulation_visitor_base_3}
|
||||
|
||||
\ccRefConceptPage{Kinetic::RegularTriangulationVisitor3}
|
||||
|
||||
\ccRefIdfierPage{Kinetic::Regular_triangulation_visitor_base_3}
|
||||
|
||||
\ccRefIdfierPage{Kinetic::Regular_triangulation_event_log_visitor_3}
|
||||
|
||||
\ccRefConceptPage{Kinetic::SortVisitor}
|
||||
|
||||
\ccRefIdfierPage{Kinetic::Sort_visitor_base}
|
||||
|
||||
\ccRefIdfierPage{Kinetic::Sort_event_log_visitor}
|
||||
|
||||
The support classes:
|
||||
\ccRefIdfierPage{Kinetic::Delaunay_triangulation_face_base_2<Traits, Base>}
|
||||
|
||||
\ccRefIdfierPage{Kinetic::Delaunay_triangulation_cell_base_3<Traits, Base>}
|
||||
|
||||
\ccRefIdfierPage{Kinetic::Regular_triangulation_cell_base_3<Traits, Base>}
|
||||
|
||||
\ccRefIdfierPage{Kinetic::Regular_triangulation_vertex_base_3<Traits, Base>}
|
||||
|
||||
\ccHeading{Graphical display}
|
||||
Next we have some support classes which are used to display kinetic data structures:
|
||||
|
||||
\ccRefIdfierPage{Kinetic::Qt_moving_points_2<Traits, QtWidget_2>}
|
||||
|
||||
\ccRefIdfierPage{Kinetic::Qt_triangulation_2<KineticTriangulation_2, QtWidget_2, QtMovingPoints_2>}
|
||||
|
||||
\ccRefIdfierPage{Kinetic::Qt_widget_2<Simulator>}
|
||||
|
||||
|
||||
\ccHeading{Main support classes and concepts}
|
||||
Here we list the main classes and concepts provided by the framework to support implementing kinetic data structures
|
||||
|
||||
\ccRefConceptPage{Kinetic::ActiveObjectsTable}
|
||||
|
||||
\ccRefConceptPage{Kinetic::FunctionKernel}
|
||||
|
||||
\ccRefConceptPage{Kinetic::Kernel}
|
||||
|
||||
\ccRefConceptPage{Kinetic::InstantaneousKernel}
|
||||
|
||||
|
||||
\ccRefConceptPage{Kinetic::SimulationTraits}
|
||||
|
||||
\ccRefConceptPage{Kinetic::Simulator}
|
||||
|
||||
|
||||
|
||||
\ccRefIdfierPage{Kinetic::Active_objects_vector<MovingObject>}
|
||||
|
||||
\ccRefIdfierPage{Kinetic::Cartesian_instantaneous_kernel<ActiveObjectsTable, StaticKernel>}
|
||||
|
||||
\ccRefIdfierPage{Kinetic::Cartesian_kinetic_kernel<FunctionKernel>}
|
||||
|
||||
\ccRefIdfierPage{Kinetic::Simulator<FunctionKernel, EventQueue>}
|
||||
|
||||
|
||||
|
||||
|
||||
\ccHeading{Miscellaneous classes and concepts}
|
||||
|
||||
\ccRefIdfierPage{Kinetic::Regular_triangulation_instantaneous_traits_3<ActiveObjectsTable, StaticKernel>}
|
||||
|
||||
\ccRefConceptPage{Kinetic::EventLogVisitor}
|
||||
|
||||
\ccRefConceptPage{Kinetic::EventQueue}
|
||||
|
||||
|
||||
\ccRefConceptPage{Kinetic::Event}
|
||||
|
||||
\ccRefConceptPage{Key}
|
||||
|
||||
\ccRefConceptPage{Kinetic::Certificate}
|
||||
|
||||
\ccRefConceptPage{Kinetic::RootStack}
|
||||
|
||||
\ccRefConceptPage{Kinetic::Time}
|
||||
|
||||
|
||||
|
||||
|
||||
\ccRefIdfierPage{Kinetic::Active_objects_listener_helper<ActiveObjectsTable, KDS>}
|
||||
|
||||
\ccRefIdfierPage{Kinetic::Insert_event<ActiveObjectsTable>}
|
||||
|
||||
\ccRefIdfierPage{CGAL::Listener<Interface>}
|
||||
|
||||
\ccRefIdfierPage{CGAL::Multi_listener<Interface>}
|
||||
|
||||
\ccRefIdfierPage{CGAL::Ref_counted<T>}
|
||||
|
||||
\ccRefIdfierPage{Kinetic::Simulator_kds_listener<Listener, KDS>}
|
||||
|
||||
\ccRefIdfierPage{Kinetic::Simulator_objects_listener<Simulator_listener, KDS>}
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -1,11 +1,8 @@
|
|||
#include <CGAL/Kinetic/Regular_triangulation_exact_simulation_traits_3.h>
|
||||
#include <CGAL/Kinetic/Regular_triangulation_3.h>
|
||||
|
||||
int main(int, char *[])
|
||||
{
|
||||
|
||||
int main(int, char *[]) {
|
||||
typedef CGAL::Kinetic::Regular_triangulation_exact_simulation_traits_3 Traits;
|
||||
|
||||
typedef CGAL::Kinetic::Regular_triangulation_3<Traits> KDel;
|
||||
|
||||
Traits tr;
|
||||
|
|
|
|||
Loading…
Reference in New Issue