int main( )
{
std::cout << "insertion of 1000 random points" << std::endl;
Triangulation t;
CGAL::Random_points_in_square_2<Point, Creator> g(1.);
CGAL::cpp11::copy_n( g, 1000, std::back_inserter(t));
//verbose mode of is_valid ; shows the number of vertices at each level
std::cout << "The number of vertices at successive levels" << std::endl;
assert(t.is_valid(true));
return 0;
}
int
main( )
{
Triangulation cdt;
std::cout << "Inserting a grid 5 x 5 of constraints " << std::endl;
for (int i = 1; i < 6; ++i)
cdt.insert_constraint( Point(0,i), Point(6,i));
for (int j = 1; j < 6; ++j)
cdt.insert_constraint( Point(j,0), Point(j,6));
int count = 0;
for (Triangulation::Subconstraint_iterator scit = cdt.subconstraints_begin();
scit != cdt.subconstraints_end();
++scit) ++count;
std::cout << "The number of resulting constrained edges is ";
std::cout << count << std::endl;
//verbose mode of is_valid ; shows the number of vertices at each level
std::cout << "The number of vertices at successive levels" << std::endl;
assert(cdt.is_valid(true));
return 0;
}
int main()
{
Triangulation t;
Random random(1284141159);
std::cout << "Seed: " << random.get_seed () << std::endl;
// Random_points_in_square g(0.495, random);
Random_points_on_circle g(0.495, random);
Vector midpoint(0.5, 0.5);
for (int i = 0; i < N_PTS; ++i)
{
t.insert(*(++g) + midpoint);
}
if (!t.is_valid(true))
{
std::cout << "l:" << __LINE__ << std::endl;
std::exit(1);
}
return 0;
}
int main()
{
Random random(1284141159);
Random_points_in_square g(0.495, random);
Vector midpoint(0.5, 0.5);
#if 0
// Should take 5 seconds on the iMac
std::vector<Point> pts;
pts.resize(500000);
for (size_t i = 0; i < pts.size(); ++i) pts[i] = *(++g) + midpoint;
Gt gt;
for (size_t i = 0; i < pts.size() - 2; ++i) gt.orientation_2_object()(pts[i], pts[i + 1], pts[i + 2]);
return 0;
#endif
std::cout << "i" << ", \t"
<< "total time" << ", \t"
<< "total_time cumm" << ", \t"
<< "locate_time" << ", \t" << "insert_time" << ", \t"
<< "periodic_insert_time" << ", \t" << "periodic_insert_time" << std::endl;
// First run is for heating up the CPU, don't output the stats
for (int run = 0; run < N_RUNS; ++run)
{
// Reset timings
total_time = 0.0;
locate_time = 0.0;
insert_time = 0.0;
periodic_locate_time = 0.0;
periodic_insert_time = 0.0;
#ifdef PERIODIC
Triangulation t;
const bool insert_periodic_copies = false;
#else
EuclideanTriangulation t;
const bool insert_periodic_copies = false;
#endif
std::clock_t start_time = std::clock();
// Do one additional point to get the statistics right
for (int i = 0; i <= N_PTS; ++i)
{
Point p = *(++g) + midpoint;
t.insert(p);
if (insert_periodic_copies)
{
for (int x = 0; x < 3; ++x)
{
for (int y = 0; y < 3; ++y)
{
if (x + y > 0)
{
t.insert(p + Vector(x, y));
}
}
}
}
if (i % 500 == 0)
{
std::cout << i << ", \t"
<< (std::clock() - start_time) / (double)CLOCKS_PER_SEC << ", \t"
<< total_time << ", \t"
<< locate_time << ", \t" << insert_time << ", \t"
<< periodic_insert_time << ", \t" << periodic_insert_time << std::endl;
}
}
CGAL_assertion(t.is_valid());
std::cout << std::endl;
}
return 0;
}
int main()
{
Triangulation t;
Face_handle fh;
// Check the empty triangulation
fh = test_point_location(t, Point(0.5, 0.5), Triangulation::EMPTY);
CGAL_assertion(fh == Face_handle());
// Insert the first point
Point p0(0.5, 0.5);
Vertex_handle vh0 = t.insert(p0);
CGAL_assertion(t.is_valid(true));
CGAL_USE(vh0);
fh = test_point_location(t, p0, Triangulation::VERTEX);
CGAL_assertion(fh->has_vertex(vh0));
fh = test_point_location(t, p0 + Vector(0.1, 0.1), Triangulation::EDGE);
CGAL_assertion(fh->has_vertex(vh0));
fh = test_point_location(t, p0 + Vector(-0.1, -0.1), Triangulation::EDGE);
CGAL_assertion(fh->has_vertex(vh0));
fh = test_point_location(t, p0 + Vector(-0.2, -0.3), Triangulation::FACE);
CGAL_assertion(fh->has_vertex(vh0));
CGAL_assertion(t.is_valid(true));
// Insert the second point on an edge
Point p1(0.7, 0.7);
Vertex_handle vh1 = t.insert(p1);
CGAL_USE(vh1);
CGAL_assertion(t.is_valid(true));
fh = test_point_location(t, p0, Triangulation::VERTEX);
CGAL_assertion(fh->has_vertex(vh0));
fh = test_point_location(t, p1, Triangulation::VERTEX);
CGAL_assertion(fh->has_vertex(vh1));
fh = test_point_location(t, p0 + Vector(0.1, 0.1), Triangulation::EDGE);
CGAL_assertion(fh->has_vertex(vh0));
CGAL_assertion(fh->has_vertex(vh1));
fh = test_point_location(t, p0 + Vector(-0.1, -0.1), Triangulation::EDGE);
CGAL_assertion(fh->has_vertex(vh0));
CGAL_assertion(!fh->has_vertex(vh1));
fh = test_point_location(t, p1 + Vector(0.1, 0.1), Triangulation::EDGE);
CGAL_assertion(!fh->has_vertex(vh0));
CGAL_assertion(fh->has_vertex(vh1));
fh = test_point_location(t, p0 + Vector(-0.02, -0.03), Triangulation::FACE);
CGAL_assertion(fh->has_vertex(vh0));
fh = test_point_location(t, p1 + Vector(-0.02, -0.03), Triangulation::FACE);
CGAL_assertion(fh->has_vertex(vh1));
CGAL_assertion(t.is_valid(true));
// Insert the third point in a face
Point p2(0.8, 0.6);
Vertex_handle vh2 = t.insert(p2);
CGAL_USE(vh2);
CGAL_assertion(t.is_valid(true));
fh = test_point_location(t, p0, Triangulation::VERTEX);
CGAL_assertion(fh->has_vertex(vh0));
fh = test_point_location(t, p1, Triangulation::VERTEX);
CGAL_assertion(fh->has_vertex(vh1));
fh = test_point_location(t, p2, Triangulation::VERTEX);
CGAL_assertion(fh->has_vertex(vh2));
fh = test_point_location(t, Point(0.6, 0.6), Triangulation::EDGE);
CGAL_assertion(fh->has_vertex(vh0));
CGAL_assertion(fh->has_vertex(vh1));
test_point_location(t, Point(0.7, 0.6), Triangulation::FACE);
test_point_location(t, p0 + Vector(-0.02, -0.03), Triangulation::FACE);
test_point_location(t, p0 + Vector(0.02, -0.03), Triangulation::FACE);
test_point_location(t, p0 + Vector(-0.02, 0.03), Triangulation::FACE);
test_point_location(t, p0 + Vector(0.02, 0.03), Triangulation::FACE);
return 0;
}
CVCGEOM_NAMESPACE::cvcgeom_t*
pocket_tunnel_fromsurf(const CVCGEOM_NAMESPACE::cvcgeom_t* molsurf, int num_pockets, int num_tunnels ) // input surface data.
{
map<int, cell_cluster> cluster_set;
// int output_seg_count = DEFAULT_OUTPUT_SEG_COUNT;
// robust cocone parameters.
double bb_ratio = DEFAULT_BIGBALL_RATIO;
double theta_ff = M_PI/180.0*DEFAULT_THETA_FF_d;
double theta_if = M_PI/180.0*DEFAULT_THETA_IF_d;
vector<Point> pts_list;
for(int i = 0; i < molsurf->points().size(); i++)
{
float x = molsurf->points()[i][0],
y = molsurf->points()[i][1],
z = molsurf->points()[i][2];
pts_list.push_back(Point(x,y,z));
}
//CGAL::Timer timer;
//timer.start();
// cout <<"list size:" << pts_list.size() << endl;
cerr << "Delaunay ";
Triangulation triang;
triang.insert(pts_list.begin(), pts_list.end());
assert(triang.is_valid());
cerr << "done." << endl;
//cerr << "Time: " << timer.time() << endl; timer.reset();
// ------------------------------------------
// Initialization of all the required fields
// needed for Tight Cocone and Segmentation
// ------------------------------------------
cerr << "Initialization ";
initialize(triang);
cerr << ".";
// compute voronoi vertex
compute_voronoi_vertex_and_cell_radius(triang);
cerr << ". done." << endl;
//cerr << "Time: " << timer.time() << endl; timer.reset();
// ------------------------------------------
// Surface Reconstruction using Tight Cocone
// ------------------------------------------
cerr << "Surface Reconstruction ";
tcocone(DEFAULT_ANGLE, DEFAULT_SHARP, DEFAULT_FLAT, DEFAULT_RATIO, triang);
cerr << " done." << endl;
//cerr << "Time: " << timer.time() << endl; timer.reset();
#ifdef _DEBUG_OUTPUT_
write_wt(triang, "debug_output/temp_recon");
#endif
cerr << "Computing S_MAX ";
double mr = 1.3; // not used in this routine.
vector<int> sorted_smax_index_vector = compute_smax(triang, cluster_set, mr);
cerr << " done." << endl;
// detect pocket, tunnel, void.
cerr << "Computing Pocket-Tunnels ";
detect_handle(triang, cluster_set);
cerr << " done." << endl;
//cerr << "Time: " << timer.time() << endl; timer.reset();
#ifdef _DEBUG_OUTPUT_
// write_handle(triang, cluster_set, sorted_smax_index_vector, output_seg_count, "debug_output/temp_PTV");
#endif
// convert the handles into rawc geometries to be viewed by TexMol.
CVCGEOM_NAMESPACE::cvcgeom_t* PTV;
convert_pocket_tunnel_to_rawc_geometry(&PTV, triang, cluster_set,
sorted_smax_index_vector, num_pockets, num_tunnels);
return PTV;
}
int main()
{
Triangulation t;
Vector midpoint(0.5, 0.5);
Face_handle fh;
Triangulation::Locate_type lt;
int i;
fh = t.locate(Point(0, 0) + midpoint, lt, i);
CGAL_assertion(lt == Triangulation::EMPTY);
Vertex_handle vh_midpoint = t.insert(Point(0, 0) + midpoint);
fh = t.locate(Point(0, 0) + midpoint, lt, i);
CGAL_assertion(lt == Triangulation::VERTEX && fh->vertex(i) == vh_midpoint);
t.remove(vh_midpoint);
CGAL_assertion(t.empty());
// High degree vertex
for (int n = 3; n < 8; ++n)
{
vh_midpoint = t.insert(Point(0, 0) + midpoint);
for (int i = 0; i < n; ++i)
{
t.insert(Point(0.3 * sin(i * 1.0 / n * 2 * M_PI), 0.3 * cos(i * 1.0 / n * 2 * M_PI)) + midpoint);
}
t.remove(vh_midpoint);
CGAL_assertion(t.is_valid(true));
while (!t.empty())
{
t.remove(t.vertices_begin());
CGAL_assertion(t.is_valid(true));
}
}
Random random(1284141159);
std::cout << "Seed: " << random.get_seed () << std::endl;
Random_points_in_square g(0.495, random);
CGAL_assertion(t.is_valid());
std::cout << "Removing first point" << std::endl;
Vertex_handle vh0 = t.insert(Point(0.5, 0.5));
CGAL_assertion(t.is_valid());
t.remove(vh0);
CGAL_assertion(t.is_valid());
CGAL_assertion(t.empty());
{
Random random(1284141159);
std::cout << "Seed: " << random.get_seed () << std::endl;
Random_points_in_square g(0.495, random);
Vector midpoint(0.5, 0.5);
Triangulation t;
CGAL_assertion(t.is_valid());
std::cout << "Removing first point" << std::endl;
Vertex_handle vh0 = t.insert(Point(0.5, 0.5));
CGAL_assertion(t.is_valid());
t.remove(vh0);
CGAL_assertion(t.is_valid());
CGAL_assertion(t.empty());
std::cout << "Inserting random points and removing them." << std::endl;
for (int i = 0; i < N_PTS; ++i)
{
t.insert(*(++g) + midpoint);
}
CGAL_assertion(t.is_valid());
for (int i = 0; i < N_PTS; ++i)
{
// Find a random vertex
Vertex_handle vh = t.locate(*(++g) + midpoint)->vertex(0);
vh = t.get_original_vertex(vh);
t.remove(vh);
CGAL_assertion(t.is_valid());
}
}
return 0;
}
int main(int narg, char** argv)
{
if (narg>1 && (!strcmp(argv[1],"-h") || !strcmp(argv[1],"-?")) )
{
std::cout<<"Usage : voronoi_3 filename"<<std::endl
<<" filename being a fine containing 3D points used to "
<<" compute the Delaunay_triangulation_3."<<std::endl;
return EXIT_FAILURE;
}
std::string filename;
if ( narg==1 )
{
filename=std::string("data/points_3");
std::cout<<"No filename given: use data/points_3 by default."<<std::endl;
}
else
filename=std::string(argv[1]);
// 1) Compute the Delaunay_triangulation_3.
Triangulation T;
std::ifstream iFile(filename.c_str());
if (!iFile)
{
std::cout << "Problem reading file " << filename << std::endl;
return EXIT_FAILURE;
}
std::istream_iterator<Point> begin(iFile), end;
T.insert(begin, end);
CGAL_assertion(T.is_valid(false));
// 2) Convert the triangulation into a 3D lcc.
LCC_3 lcc;
std::map<Triangulation::Cell_handle,
LCC_3::Dart_handle > vol_to_dart;
Dart_handle dh=CGAL::import_from_triangulation_3<LCC_3, Triangulation>
(lcc, T, &vol_to_dart);
std::cout<<"Delaunay triangulation :"<<std::endl<<" ";
lcc.display_characteristics(std::cout) << ", valid="
<< lcc.is_valid() << std::endl;
// 3) Compute the dual lcc.
LCC_3 dual_lcc;
Dart_handle ddh=lcc.dual(dual_lcc, dh);
// Here, dual_lcc is the 3D Voronoi diagram.
CGAL_assertion(dual_lcc.is_without_boundary());
// 4) We update the geometry of dual_lcc by using the std::map
// face_to_dart.
transform_dart_to_their_dual<LCC_3,Triangulation>
(lcc, dual_lcc, vol_to_dart);
set_geometry_of_dual<LCC_3,Triangulation>(dual_lcc, T, vol_to_dart);
// 5) Display the dual_lcc characteristics.
std::cout<<"Voronoi subdvision :"<<std::endl<<" ";
dual_lcc.display_characteristics(std::cout) << ", valid="
<< dual_lcc.is_valid()
<< std::endl;
display_voronoi(dual_lcc, ddh);
return EXIT_SUCCESS;
}
