mirror of https://github.com/CGAL/cgal
552 lines
17 KiB
C++
552 lines
17 KiB
C++
// Copyright (c) 2005 Stanford University (USA).
|
|
// All rights reserved.
|
|
//
|
|
// This file is part of CGAL (www.cgal.org); you can redistribute it and/or
|
|
// modify it under the terms of the GNU Lesser General Public License as
|
|
// published by the Free Software Foundation; version 2.1 of the License.
|
|
// See the file LICENSE.LGPL distributed with CGAL.
|
|
//
|
|
// Licensees holding a valid commercial license may use this file in
|
|
// accordance with the commercial license agreement provided with the software.
|
|
//
|
|
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
|
|
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
|
|
//
|
|
// $URL$
|
|
// $Id$
|
|
//
|
|
//
|
|
// Author(s) : Daniel Russel <drussel@alumni.princeton.edu>
|
|
|
|
#ifndef CGAL_KINETIC_KINETIC_DELAUNAY_2_H
|
|
#define CGAL_KINETIC_KINETIC_DELAUNAY_2_H
|
|
#include <CGAL/Kinetic/basic.h>
|
|
|
|
#include <CGAL/Delaunay_triangulation_2.h>
|
|
#include <CGAL/Kinetic/Delaunay_triangulation_face_base_2.h>
|
|
#include <CGAL/Kinetic/Delaunay_triangulation_visitor_base_2.h>
|
|
#include <CGAL/Kinetic/Active_objects_listener_helper.h>
|
|
#include <CGAL/Kinetic/Simulator_kds_listener.h>
|
|
#include <CGAL/Kinetic/internal/tds_2_helpers.h>
|
|
#include <CGAL/Triangulation_data_structure_2.h>
|
|
#include <CGAL/Kinetic/Ref_counted.h>
|
|
#include <iterator>
|
|
#include <map>
|
|
#include <set>
|
|
|
|
CGAL_KINETIC_BEGIN_NAMESPACE
|
|
|
|
template <class This>
|
|
class Delaunay_edge_failure_event
|
|
{
|
|
public:
|
|
//! Make sure that the s has been advanced
|
|
Delaunay_edge_failure_event(typename This::SOC_certificate &s,
|
|
const typename This::Edge &e,
|
|
This *kdel): s_(s), e_(e), kdel_(kdel) {
|
|
//if (!s.empty()) s_.pop();
|
|
}
|
|
void process(const typename This::Time&) {
|
|
kdel_->flip(e_);
|
|
}
|
|
void write(std::ostream &out) const
|
|
{
|
|
out << "Flip " << This::TDS_helper::origin(e_)->point() << ","
|
|
<< This::TDS_helper::destination(e_)->point();
|
|
}
|
|
protected:
|
|
typename This::SOC_certificate s_;
|
|
const typename This::Edge e_;
|
|
This *kdel_;
|
|
};
|
|
|
|
template <class This>
|
|
class Delaunay_hull_edge_failure_event
|
|
{
|
|
public:
|
|
//! Make sure that the s has been advanced
|
|
Delaunay_hull_edge_failure_event(typename This::O2_certificate &s,
|
|
const typename This::Edge &e,
|
|
This *kdel): s_(s), e_(e), kdel_(kdel) {
|
|
//if (!s.empty()) s_.pop();
|
|
}
|
|
void process(const typename This::Time&) {
|
|
kdel_->flip(e_);
|
|
}
|
|
void write(std::ostream &out) const
|
|
{
|
|
out << "Flip " << This::TDS_helper::origin(e_)->point() << ","
|
|
<< This::TDS_helper::destination(e_)->point();
|
|
}
|
|
protected:
|
|
typename This::O2_certificate s_;
|
|
const typename This::Edge e_;
|
|
This *kdel_;
|
|
};
|
|
|
|
template <class T>
|
|
std::ostream& operator<<(std::ostream &out, const Delaunay_edge_failure_event<T> &e)
|
|
{
|
|
e.write(out);
|
|
return out;
|
|
}
|
|
|
|
|
|
template <class T>
|
|
std::ostream& operator<<(std::ostream &out, const Delaunay_hull_edge_failure_event<T> &e)
|
|
{
|
|
e.write(out);
|
|
return out;
|
|
}
|
|
|
|
|
|
//! A 2D kinetic Delaunay triangulation.
|
|
/*! Points are added via the Moving_point_table, so the public
|
|
interface is very limited. See kinetic_Delaunay_2.cc for a useage example.
|
|
*/
|
|
template <class Simulation_traits, class Visitor= Delaunay_triangulation_visitor_base_2,
|
|
class Delaunay
|
|
= CGAL::Delaunay_triangulation_2<typename Simulation_traits::Instantaneous_kernel,
|
|
CGAL::Triangulation_data_structure_2<
|
|
CGAL::Triangulation_vertex_base_2<typename Simulation_traits::Instantaneous_kernel>,
|
|
CGAL::Kinetic::Delaunay_triangulation_face_base_2<Simulation_traits > > > >
|
|
class Delaunay_triangulation_2:
|
|
public Ref_counted<Delaunay_triangulation_2<Simulation_traits, Visitor, Delaunay> >
|
|
{
|
|
public:
|
|
typedef Delaunay_triangulation_2<Simulation_traits, Visitor, Delaunay> This;
|
|
|
|
typedef typename Simulation_traits::Kinetic_kernel Kinetic_kernel;
|
|
typedef typename Simulation_traits::Simulator Simulator;
|
|
typedef typename Simulation_traits::Active_objects_table Moving_point_table;
|
|
|
|
typedef typename Moving_point_table::Key Point_key;
|
|
typedef typename Simulator::Event_key Event_key;
|
|
//typedef typename Simulator::Root_stack Root_stack;
|
|
typedef typename Simulator::Time Time;
|
|
|
|
typedef typename Delaunay::Edge_circulator Edge_circulator;
|
|
typedef typename Delaunay::Face_circulator Face_circulator;
|
|
typedef typename Delaunay::Finite_edges_iterator Finite_edges_iterator;
|
|
//typedef typename Delaunay::Edge_iterator Edge_iterator;
|
|
|
|
typedef typename Delaunay::Geom_traits::Point_2 Del_point;
|
|
|
|
typedef typename Delaunay::Vertex_handle Vertex_handle;
|
|
typedef typename Delaunay::Face_handle Face_handle;
|
|
typedef typename Delaunay::Edge Edge;
|
|
typedef typename Delaunay::All_faces_iterator Face_iterator;
|
|
typedef typename Delaunay::All_edges_iterator Edge_iterator;
|
|
typedef typename Kinetic_kernel::Positive_side_of_oriented_circle_2 SOC;
|
|
typedef typename Kinetic_kernel::Positive_orientation_2 O2;
|
|
typedef typename SOC::result_type SOC_certificate;
|
|
typedef typename O2::result_type O2_certificate;
|
|
typedef internal::Triangulation_data_structure_helper_2<typename Delaunay::Triangulation_data_structure> TDS_helper;
|
|
|
|
typedef Delaunay_edge_failure_event<This> SOC_event;
|
|
typedef Delaunay_hull_edge_failure_event<This> O2_event;
|
|
|
|
friend class Delaunay_edge_failure_event<This>;
|
|
friend class Delaunay_hull_edge_failure_event<This>;
|
|
|
|
typedef typename CGAL::Kinetic::Simulator_kds_listener<typename Simulator::Listener, This> Simulator_listener;
|
|
friend class CGAL::Kinetic::Simulator_kds_listener<typename Simulator::Listener, This>;
|
|
typedef typename CGAL::Kinetic::Active_objects_listener_helper<typename Moving_point_table::Listener, This> Moving_point_table_listener;
|
|
friend class CGAL::Kinetic::Active_objects_listener_helper<typename Moving_point_table::Listener, This>;
|
|
public:
|
|
|
|
Delaunay_triangulation_2(Simulation_traits st,
|
|
Visitor w= Visitor()): traits_(st),
|
|
del_(traits_.instantaneous_kernel_object()),
|
|
soc_(traits_.kinetic_kernel_object().positive_side_of_oriented_circle_2_object()),
|
|
o2_(traits_.kinetic_kernel_object().positive_orientation_2_object()),
|
|
watcher_(w) {
|
|
siml_ = Simulator_listener(st.simulator_pointer(), this);
|
|
motl_= Moving_point_table_listener(st.active_objects_table_pointer(), this);
|
|
}
|
|
|
|
//! Just write the objects in order;
|
|
void write(std::ostream &out) const
|
|
{
|
|
out << del_;
|
|
}
|
|
|
|
typedef Delaunay Triangulation;
|
|
const Triangulation &triangulation(const typename Simulator::NT &t) const
|
|
{
|
|
//update_instantaneous_kernel_time();
|
|
del_.geom_traits().set_time(t);
|
|
return del_;
|
|
}
|
|
|
|
typedef typename Delaunay::Triangulation_data_structure Triangulation_data_structure;
|
|
const Triangulation_data_structure &triangulation_data_structure() const
|
|
{
|
|
return del_.tds();
|
|
}
|
|
|
|
/*const std::set<Edge>& recent_edges() const {
|
|
return new_edges_;
|
|
}*/
|
|
|
|
//! Verify that the current state of the
|
|
void audit() const
|
|
{
|
|
audit_structure();
|
|
CGAL_KINETIC_LOG(CGAL::Kinetic::LOG_LOTS, *this);
|
|
if (del_.dimension() != 2) return;
|
|
Delaunay sdel(traits_.instantaneous_kernel_object());
|
|
sdel.geom_traits().set_time(traits_.simulator_pointer()->rational_current_time());
|
|
sdel.insert(traits_.active_objects_table_pointer()->keys_begin(),
|
|
traits_.active_objects_table_pointer()->keys_end());
|
|
|
|
CGAL_KINETIC_LOG(CGAL::Kinetic::LOG_LOTS, sdel << std::endl);
|
|
|
|
CGAL_assertion(del_.dimension() == sdel.dimension());
|
|
|
|
for (typename Delaunay::All_vertices_iterator vit = sdel.all_vertices_begin();
|
|
vit != sdel.all_vertices_end(); ++vit) {
|
|
bool found=false;
|
|
//Object_key k= vit->point();
|
|
for (typename Delaunay::All_vertices_iterator vit2= del_.all_vertices_begin();
|
|
vit2 != del_.all_vertices_end(); ++vit2) {
|
|
//Object_key k2= vit2->point();
|
|
if (vit->point() == vit2->point()) {
|
|
found=true;
|
|
//int d= vit->degree();
|
|
//int d2= vit2->degree();
|
|
CGAL_assertion(vit->degree() == vit2->degree());
|
|
}
|
|
}
|
|
CGAL_assertion(found);
|
|
}
|
|
|
|
}
|
|
|
|
void set_has_certificates(bool) {
|
|
// always has certificates
|
|
}
|
|
bool has_certificates() {
|
|
return true;
|
|
}
|
|
|
|
void audit_structure() const
|
|
{
|
|
if (del_.dimension() != 2) return;
|
|
CGAL_KINETIC_LOG(CGAL::Kinetic::LOG_LOTS, *this);
|
|
|
|
/*for (typename Delaunay::All_edges_iterator eit= del_.all_edges_begin();
|
|
eit != del_.all_edges_end(); ++eit) {
|
|
Event_key key= TDS_helper::get_undirected_edge_label(*eit);
|
|
CGAL_assertion(key);
|
|
typename Simulator::Root_stack s= compute_failure_time(*eit);
|
|
if (key == traits_.simulator_pointer()->null_event()) {
|
|
CGAL_exactness_assertion(s.top() == std::numeric_limits<Time>::infinity());
|
|
}
|
|
else {
|
|
CGAL_exactness_assertion(s.top() != std::numeric_limits<Time>::infinity());
|
|
}
|
|
}*/
|
|
}
|
|
|
|
void erase(Point_key k) {
|
|
// erase all incident certificates
|
|
Vertex_handle vh= vhs_[k];
|
|
watcher_.remove_vertex(vh);
|
|
Face_circulator fc= vh->incident_faces(), fe=fc;
|
|
if (fc != NULL) {
|
|
do {
|
|
for (unsigned int j=0; j<3; ++j) {
|
|
Edge e(fc, j);
|
|
Event_key k= TDS_helper::get_undirected_edge_label(e);
|
|
if (k) {
|
|
traits_.simulator_pointer()->delete_event(k);
|
|
TDS_helper::set_undirected_edge_label(e, Event_key());
|
|
}
|
|
}
|
|
++fc;
|
|
} while (fc != fe);
|
|
}
|
|
// remove from triangulation
|
|
del_.geom_traits().set_time(traits_.simulator_pointer()->rational_current_time());
|
|
del_.remove(vh);
|
|
//new_edges_.clear();
|
|
if (del_.dimension()==2) {
|
|
std::vector<Face_handle> faces;
|
|
|
|
del_.get_conflicts(k,std::back_inserter(faces));
|
|
|
|
for (unsigned int i=0; i< faces.size(); ++i) {
|
|
for (unsigned int j=0; j<3; ++j) {
|
|
Edge e(faces[i],j);
|
|
Event_key k= TDS_helper::get_undirected_edge_label(e);
|
|
if (!k) {
|
|
// a bit redundant for certificates which don't fail
|
|
new_certificate(e);
|
|
}
|
|
else {
|
|
//CGAL_assertion(new_edges_.find(TDS_helper::mirror_edge(e)) != new_edges_.end());
|
|
}
|
|
//new_edges_.insert(e);
|
|
}
|
|
}
|
|
watcher_.create_faces(faces.begin(), faces.end());
|
|
}
|
|
|
|
}
|
|
|
|
//! The assertion will catch that the object is in the same sorted order
|
|
void set(Point_key k) {
|
|
//std::cout << "Object changed " << k << std::endl;
|
|
|
|
//new_edges_.clear();
|
|
|
|
if (del_.dimension() != 2) {
|
|
CGAL_KINETIC_LOG(CGAL::Kinetic::LOG_SOME,"Triangulation is still 1D.\n");
|
|
return;
|
|
}
|
|
Vertex_handle vh= vhs_[k];
|
|
watcher_.modify_vertex(vh);
|
|
Edge_circulator ec= vh->incident_edges(), ef=ec;
|
|
if (ec != NULL) {
|
|
do {
|
|
rebuild_certificate(*ec);
|
|
++ec;
|
|
} while (ec != ef);
|
|
}
|
|
Face_circulator fc= vh->incident_faces(), fe= fc;
|
|
if (fc != NULL) {
|
|
do {
|
|
int i= fc->index(vh);
|
|
rebuild_certificate(Edge(fc, i));
|
|
++fc;
|
|
} while (fc != fe);
|
|
}
|
|
//write(std::cout);
|
|
}
|
|
|
|
//!
|
|
/*!
|
|
Some old certificate edges will be lost, have to find all conflicts first
|
|
*/
|
|
void insert(Point_key k) {
|
|
bool was_2d= (del_.dimension()==2);
|
|
|
|
del_.geom_traits().set_time(traits_.simulator_pointer()->rational_current_time());
|
|
if (was_2d) {
|
|
//std::cout << "removing extra certificates.\n";
|
|
std::vector<Face_handle> faces;
|
|
del_.get_conflicts(k, std::back_inserter(faces));
|
|
for (unsigned int i=0; i< faces.size(); ++i) {
|
|
Face_handle f= faces[i];
|
|
for (unsigned int j=0; j<3; ++j) {
|
|
Edge e(f, j);
|
|
Event_key k= TDS_helper::get_undirected_edge_label(e);
|
|
if (k) {
|
|
traits_.simulator_pointer()->delete_event(k);
|
|
TDS_helper::set_undirected_edge_label(e, Event_key());
|
|
}
|
|
}
|
|
}
|
|
watcher_.remove_faces(faces.begin(), faces.end());
|
|
}
|
|
|
|
vhs_[k]= del_.insert(k);
|
|
watcher_.create_vertex(vhs_[k]);
|
|
// now have to update
|
|
if (!was_2d && del_.dimension()==2) {
|
|
//std::cout << "Creating certificates from scratch.\n";
|
|
for (Edge_iterator eit = del_.all_edges_begin(); eit != del_.all_edges_end(); ++eit) {
|
|
TDS_helper::set_undirected_edge_label(*eit, Event_key());
|
|
new_certificate(*eit);
|
|
}
|
|
watcher_.create_faces(del_.all_faces_begin(), del_.all_faces_end());
|
|
}
|
|
else {
|
|
set(k);
|
|
}
|
|
CGAL_expensive_postcondition_code(audit_structure());
|
|
//write(std::cout);
|
|
}
|
|
|
|
Edge flip(const Edge &e) {
|
|
//CGAL_KINETIC_LOG(CGAL::Kinetic::LOG_NONE, "Flipping edge " << TDS_helper::origin(e)->point());
|
|
//CGAL_KINETIC_LOG(CGAL::Kinetic::LOG_NONE, TDS_helper::destination(e)->point() << std::endl);
|
|
//CGAL_KINETIC_LOG(CGAL::Kinetic::LOG_NONE, " at " << traits_.simulator()->current_time() << std::endl);
|
|
|
|
Face_handle face= e.first;
|
|
int index= e.second;
|
|
int mirror_index = face->mirror_index(index);
|
|
Face_handle mirror_face = face->neighbor(index);
|
|
|
|
for (unsigned int i=0; i<3; ++i) {
|
|
Edge e0(face, i);
|
|
if (e0.second != index) {
|
|
traits_.simulator_pointer()->delete_event(TDS_helper::get_undirected_edge_label(e0));
|
|
TDS_helper::set_undirected_edge_label(e0, Event_key());
|
|
}
|
|
Edge e1(mirror_face, i);
|
|
if (e1.second != mirror_index) {
|
|
traits_.simulator_pointer()->delete_event(TDS_helper::get_undirected_edge_label(e1));
|
|
TDS_helper::set_undirected_edge_label(e1, Event_key());
|
|
}
|
|
}
|
|
|
|
TDS_helper::set_undirected_edge_label(e, Event_key());
|
|
watcher_.before_flip(e);
|
|
del_.tds().flip(face,index);
|
|
|
|
// we also know that CGAL preserves the edge index of the flipped edge
|
|
mirror_index = mirror_face->index(face);
|
|
index= face->index(mirror_face);
|
|
|
|
Edge flipped_edge(face,index);
|
|
//CGAL_postcondition(del_.is_face(face));
|
|
|
|
mirror_index = face->mirror_index(index);
|
|
mirror_face = face->neighbor(index);
|
|
|
|
for (unsigned int i=0; i<3; ++i) {
|
|
Edge e0(face, i);
|
|
if (!TDS_helper::get_undirected_edge_label(e0)) {
|
|
new_certificate(e0);
|
|
}
|
|
Edge e1(mirror_face, i);
|
|
if (!TDS_helper::get_undirected_edge_label(e1)) {
|
|
new_certificate(e1);
|
|
}
|
|
}
|
|
|
|
//write(std::cout);
|
|
//new_edges_.clear();
|
|
//new_edges_.insert(flipped_edge);
|
|
|
|
CGAL_KINETIC_LOG(CGAL::Kinetic::LOG_SOME, "Created " << TDS_helper::origin(flipped_edge)->point());
|
|
CGAL_KINETIC_LOG(CGAL::Kinetic::LOG_SOME, TDS_helper::destination(flipped_edge)->point() << std::endl);
|
|
|
|
CGAL_expensive_postcondition_code(audit_structure());
|
|
watcher_.after_flip(flipped_edge);
|
|
return flipped_edge;
|
|
}
|
|
|
|
Visitor &visitor() {
|
|
return watcher_;
|
|
}
|
|
|
|
const Visitor &visitor() const
|
|
{
|
|
return watcher_;
|
|
}
|
|
|
|
protected:
|
|
Simulation_traits traits_;
|
|
Simulator_listener siml_;
|
|
Moving_point_table_listener motl_;
|
|
Delaunay del_;
|
|
std::map<Point_key, Vertex_handle> vhs_;
|
|
SOC soc_;
|
|
O2 o2_;
|
|
//std::set<Edge> new_edges_;
|
|
Visitor watcher_;
|
|
|
|
const typename Moving_point_table::Data& point(Point_key k) const
|
|
{
|
|
return traits_.active_objects_table_pointer()->at(k);
|
|
}
|
|
|
|
bool is_hull_edge(const Edge &e) const {
|
|
return !TDS_helper::mirror_vertex(e)->point()
|
|
|| !TDS_helper::third_vertex(e)->point()
|
|
|| !TDS_helper::origin(e)->point()
|
|
|| !TDS_helper::destination(e)->point();
|
|
}
|
|
|
|
SOC_certificate compute_failure_time(const Edge &e) const {
|
|
Point_key ks[4];
|
|
ks[0]= TDS_helper::origin(e)->point();
|
|
ks[1]= TDS_helper::third_vertex(e)->point();
|
|
ks[2]= TDS_helper::destination(e)->point();
|
|
ks[3]= TDS_helper::mirror_vertex(e)->point();
|
|
|
|
//bool odd_parity=false;
|
|
//bool infinity=false;
|
|
|
|
SOC_certificate s=soc_(point(ks[0]), point(ks[1]),
|
|
point(ks[2]), point(ks[3]),
|
|
traits_.simulator_pointer()->current_time(),
|
|
traits_.simulator_pointer()->end_time());
|
|
|
|
return s;
|
|
}
|
|
|
|
O2_certificate compute_hull_failure_time(const Edge &e) const {
|
|
Point_key ks[4];
|
|
ks[0]= TDS_helper::origin(e)->point();
|
|
ks[1]= TDS_helper::third_vertex(e)->point();
|
|
ks[2]= TDS_helper::destination(e)->point();
|
|
ks[3]= TDS_helper::mirror_vertex(e)->point();
|
|
|
|
bool odd_parity=false;
|
|
bool infinity=false;
|
|
for (unsigned int i=0; i<4; ++i) {
|
|
if (infinity) {
|
|
ks[i-1]=ks[i];
|
|
}
|
|
else {
|
|
if (!ks[i]) {
|
|
infinity=true;
|
|
odd_parity= ((i%2)==1);
|
|
}
|
|
}
|
|
}
|
|
if (odd_parity) {
|
|
std::swap(ks[0], ks[1]);
|
|
}
|
|
O2_certificate s=o2_(point(ks[0]), point(ks[1]), point(ks[2]),
|
|
traits_.simulator_pointer()->current_time(),
|
|
traits_.simulator_pointer()->end_time());
|
|
return s;
|
|
}
|
|
|
|
void new_certificate( const Edge &e) {
|
|
CGAL_precondition(!TDS_helper::get_undirected_edge_label(e));
|
|
Event_key k;
|
|
|
|
if (is_hull_edge(e)) {
|
|
O2_certificate s= compute_hull_failure_time(e);
|
|
Time t= s.failure_time();
|
|
s.pop_failure_time();
|
|
k =traits_.simulator_pointer()->new_event(t, O2_event(s, e, this));
|
|
} else {
|
|
SOC_certificate s= compute_failure_time(e);
|
|
Time t= s.failure_time();
|
|
s.pop_failure_time();
|
|
k =traits_.simulator_pointer()->new_event(t, O2_event(s, e, this));
|
|
}
|
|
TDS_helper::set_undirected_edge_label(e, k);
|
|
}
|
|
|
|
//! rebuild a certificates
|
|
/*! I need to check if there is a valid one before since I use
|
|
change_object to initialize the certificates of a new object.
|
|
*/
|
|
void rebuild_certificate( const Edge &e) {
|
|
if (TDS_helper::get_undirected_edge_label(e)) {
|
|
traits_.simulator_pointer()->delete_event(TDS_helper::get_undirected_edge_label(e));
|
|
TDS_helper::set_undirected_edge_label(e, Event_key());
|
|
}
|
|
new_certificate(e);
|
|
}
|
|
};
|
|
|
|
template <class Sim, class Del, class W>
|
|
std::ostream &operator<<(std::ostream &out, const Delaunay_triangulation_2<Sim, Del, W> &kd)
|
|
{
|
|
kd.write(out);
|
|
return out;
|
|
}
|
|
|
|
|
|
CGAL_KINETIC_END_NAMESPACE
|
|
#endif
|