int main(int argc, char* argv[])
{
CGAL::Timer timer;
// first param is dimension
// second param is number of points
int dimension = 4;
int n = 100;
int m = 100;
if (argc > 1 && std::string(argv[1])== std::string("-h")) {
std::cout<<"usage: "<<argv[0]<<" [dim] [#points] [max coords]\n";
return 1;
}
if (argc > 1) dimension = atoi(argv[1]);
if (argc > 2) n = atoi(argv[2]);
if (argc > 3) m = atoi(argv[2]);
Delaunay_d T(dimension);
std::list<Point_d> L;
random_points_in_range(n,dimension,-m,m,L);
timer.start();
int i=0;
std::list<Point_d>::iterator it;
for(it = L.begin(); it!=L.end(); ++it) {
T.insert(*it); i++;
if (i%10==0)
std::cout << i << " points inserted" << std::endl;
}
timer.stop();
std::cout << "used time for inserts " << timer.time() << std::endl;
std::cout << "entering check" << std::endl;
timer.reset();
timer.start();
T.is_valid();
timer.stop();
std::cout << "used time for sanity check " << timer.time() << std::endl;
std::cout << "entering nearest neighbor location" << std::endl;
L.clear();
random_points_in_range(n/10,dimension,-m,m,L);
timer.reset();
timer.start();
i = 0;
for(it = L.begin(); it!=L.end(); ++it) {
T.nearest_neighbor(*it); i++;
if (i%10==0) std::cout << i << " points located" << std::endl;
}
timer.stop();
std::cout << "used time for location " << timer.time() << std::endl;
T.print_statistics();
std::cout << "done" << std::endl;
return 0;
}
int main() {
const unsigned int N = 50;
CGAL::Timer timer;
timer.start();
std::vector<Point_3> points, queries;
Point_3 p;
std::ifstream point_stream("points.xyz");
while(point_stream >> p){
points.push_back(p);
}
My_point_property_map ppmap(points);
Distance tr_dist(ppmap);
std::ifstream query_stream("queries.xyz");
while(query_stream >> p ){
queries.push_back(p);
}
timer.stop();
std::cerr << "reading points took " << timer.time() << " sec." << std::endl;
timer.reset();
timer.start();
Tree tree( boost::counting_iterator<std::size_t>(0),
boost::counting_iterator<std::size_t>(points.size()),
Splitter(),
Traits(ppmap));
tree.build();
timer.stop();
std::cerr << "tree construction took " << timer.time() << " sec." << std::endl;
// Initialize the search structure, and search all N points
double d = 0;
timer.reset();
timer.start();
for(int i = 0; i < queries.size(); i++){
K_neighbor_search search(tree, queries[i], 50, 0, true, tr_dist);
// report the N nearest neighbors and their distance
// This should sort all N points by increasing distance from origin
for(K_neighbor_search::iterator it = search.begin(); it != search.end(); ++it){
//std::cout << it->first << std::endl;
d += get(ppmap,it->first).x();
}
}
timer.stop();
std::cerr << d << std::endl;
std::cerr << queries.size() << " queries in " << timer.time() << " sec." << std::endl;
return 0;
}
void time_insertion_and_check(pp_int V, int n, int d,
CGAL::Convex_hull_d<R>& C, std::string s, bool check=true)
{
typedef typename CGAL::Convex_hull_d<R>::chull_has_local_non_convexity
chull_has_local_non_convexity;
typedef typename CGAL::Convex_hull_d<R>::chull_has_double_coverage
chull_has_double_coverage;
typedef typename CGAL::Convex_hull_d<R>::
chull_has_center_on_wrong_side_of_hull_facet
chull_has_center_on_wrong_side_of_hull_facet;
std::cout << " timing of " << s << std::endl;
std::vector< CGAL::Point_d<R> > P(n); int i;
for(i=0; i<n; ++i)
P[i] = CGAL::Point_d<R>(d,V[i],V[i]+d,1);
timer.reset(); timer.start(); // float ti = used_time();
for(i=0; i<n; ++i) {
C.insert(P[i]);
if (i%10==0) std::cout << i << " points inserted" << std::endl;
}
timer.stop();
double t = timer.time(); timer.reset(); // float t = used_time(ti);
(*p_table_file) << s << "\t" << d << " " << n << " "
<< C.number_of_vertices() << " " << C.number_of_facets()
<< "\t" << t;
C.print_statistics();
std::cout << "used time for inserts " << t << std::endl;
C.clear(d);
timer.start(); // ti = used_time();
C.initialize(P.begin(),P.end());
timer.stop(); t = timer.time(); timer.reset();
// t = used_time(ti);
C.print_statistics();
std::cout << "used time for inserts " << t << std::endl;
if (check) {
timer.start();
std::cout << "entering check" << std::endl;
try { C.is_valid(true); }
catch ( chull_has_local_non_convexity )
{ std::cerr << "local non-convexity determined\n"; }
catch ( chull_has_double_coverage )
{ std::cerr << "double coverage determined\n"; }
catch ( chull_has_center_on_wrong_side_of_hull_facet )
{ std::cerr << "facet center problem determined\n"; }
// t = used_time(ti);
timer.stop(); t = timer.time();
(*p_table_file) << "\t" << t <<std::endl;
std::cout<<"used time for sanity check "<< t <<std::endl<<std::endl;
} else {
(*p_table_file) << "\t" << "no"<<std::endl;
std::cout<<"no check"<<std::endl;
}
p_table_file->flush();
}
void
insert_constraints_using_spatial_sort(SDG& sdg)
{
typedef typename Points_container::const_iterator Points_iterator;
typedef std::vector<Points_iterator> Indices;
typedef std::vector<typename SDG::Vertex_handle> Vertices;
Sort_traits_2<K, Points_iterator> sort_traits;
Indices indices;
indices.reserve(points.size());
for(Points_iterator it = points.begin(); it != points.end(); ++it) {
indices.push_back(it);
}
std::random_shuffle(indices.begin(), indices.end());
CGAL::spatial_sort(indices.begin(), indices.end(),
sort_traits);
std::cerr << "Inserting " << points.size() << " points...";
CGAL::Timer timer;
timer.start();
Vertices vertices;
vertices.resize(points.size());
typename SDG::Vertex_handle hint;
for(typename Indices::const_iterator
pt_it_it = indices.begin(), end = indices.end();
pt_it_it != end; ++pt_it_it) {
typename SDG::Vertex_handle vh = sdg.insert(**pt_it_it, hint);
hint = vh;
vertices[*pt_it_it - points.begin()] = vh;
}
timer.stop();
std::cerr << " done (" << timer.time() << "s)\n";
std::cerr << "Inserting " << constraints.size() << " constraints...";
timer.reset();
timer.start();
for(typename Constraints_container::const_iterator
cit = constraints.begin(), end = constraints.end();
cit != end; ++cit) {
const typename SDG::Vertex_handle& v1 = vertices[cit->first];
const typename SDG::Vertex_handle& v2 = vertices[cit->second];
if(v1 != v2)
sdg.insert(v1, v2);
}
timer.stop();
std::cerr << " done (" << timer.time() << "s)\n";
}
template < class Traits > double test_sort(unsigned int degree, unsigned int n)
{
typedef CGAL::Kinetic::Sort < Traits > Sort;
Traits tr(0, 10000);
Sort sort(tr);
CGAL::Random r;
for (unsigned int i = 0; i < n; ++i) {
std::vector < double >cf;
for (unsigned int j = 0; j < degree + 1; ++j) {
cf.push_back(r.get_double());
}
typename Traits::Kinetic_kernel::Motion_function fn(cf.begin(),
cf.end());
typename Traits::Kinetic_kernel::Point_1 pt(fn);
tr.active_points_1_table_handle()->insert(pt);
}
CGAL::Timer timer;
timer.start();
int ne = 0;
while (tr.simulator_handle()->next_event_time() !=
tr.simulator_handle()->end_time()) {
tr.simulator_handle()->set_current_event_number(tr.
simulator_handle()->
current_event_number()
+ 1);
++ne;
if (ne == 1000)
break;
}
timer.stop();
return timer.time() / static_cast < double >(ne);
}
int main( int argc, char **argv) {
if ( argc != 3) {
cerr << "Usage: " << argv[0] << " <infile1> <infile2>" << endl;
cerr << " Minkowsky sum of two 3d polyhedra in OFF format."
<< endl;
cerr << " Output in OFF to stdout." << endl;
exit(1);
}
Polyhedron P1;
Polyhedron P2;
read( argv[1], P1);
read( argv[2], P2);
CGAL::Timer t;
t.start();
vector<Point> points;
Add_points add;
fold( P1.vertices_begin(), P1.vertices_end(),
P2.vertices_begin(), P2.vertices_end(),
back_inserter( points),
add);
Polyhedron P3;
convex_hull_3( points.begin(), points.end(), P3);
t.stop();
std::cout << "Runtime Minkowski Sum: " << t.time() << std::endl;
// cout << P3;
return 0;
}
int main (int argc, char *argv[]) {
// Cube
std::list<Plane> planes;
planes.push_back(Plane(1, 0, 0, -1));
planes.push_back(Plane(-1, 0, 0, -1));
planes.push_back(Plane(0, 1, 0, -1));
planes.push_back(Plane(0, -1, 0, -1));
planes.push_back(Plane(0, 0, 1, -1));
planes.push_back(Plane(0, 0, -1, -1));
std::vector<Point> points;
int N, steps;
// Number of points
if (argc > 1) {
N = atoi(argv[1]);
} else {
N = 50;
}
// Number of steps
if (argc > 2) {
steps = atoi(argv[2]);
} else {
steps = 10;
}
CGAL::Random_points_in_sphere_3<Point> g;
for (int i = 0; i < N; i++) {
Point p = *g++;
points.push_back(p);
}
std::ofstream bos("before_lloyd.xyz");
std::copy(points.begin(), points.end(),
std::ostream_iterator<Point>(bos, "\n"));
// Apply Lloyd algorithm: will generate points
// uniformly sampled inside a cube.
for (int i = 0; i < steps; i++) {
std::cout << "iteration " << i + 1 << std::endl;
CGAL::Timer timer;
timer.start();
lloyd_algorithm(planes.begin(),
planes.end(),
points);
timer.stop();
std::cout << "Execution time : " << timer.time() << "s\n";
}
std::ofstream aos("after_lloyd.xyz");
std::copy(points.begin(), points.end(),
std::ostream_iterator<Point>(aos, "\n"));
return 0;
}
int main (int argc, char *argv[])
{
// Get the name of the input file from the command line, or use the default
// fan_grids.dat file if no command-line parameters are given.
const char * filename = (argc > 1) ? argv[1] : "fan_grids.dat";
// Open the input file.
std::ifstream in_file (filename);
if (! in_file.is_open()) {
std::cerr << "Failed to open " << filename << " ..." << std::endl;
return (1);
}
// Read the segments from the file.
// The input file format should be (all coordinate values are integers):
// <n> // number of segments.
// <sx_1> <sy_1> <tx_1> <ty_1> // source and target of segment #1.
// <sx_2> <sy_2> <tx_2> <ty_2> // source and target of segment #2.
// : : : :
// <sx_n> <sy_n> <tx_n> <ty_n> // source and target of segment #n.
std::list<Segment_2> segments;
unsigned int n;
in_file >> n;
unsigned int i;
for (i = 0; i < n; ++i) {
int sx, sy, tx, ty;
in_file >> sx >> sy >> tx >> ty;
segments.push_back (Segment_2 (Point_2 (Number_type(sx), Number_type(sy)),
Point_2 (Number_type(tx), Number_type(ty))));
}
in_file.close();
// Construct the arrangement by aggregately inserting all segments.
Arrangement_2 arr;
CGAL::Timer timer;
std::cout << "Performing aggregated insertion of "
<< n << " segments." << std::endl;
timer.start();
insert (arr, segments.begin(), segments.end());
timer.stop();
// Print the arrangement dimensions.
std::cout << "V = " << arr.number_of_vertices()
<< ", E = " << arr.number_of_edges()
<< ", F = " << arr.number_of_faces() << std::endl;
std::cout << "Construction took " << timer.time()
<< " seconds." << std::endl;
return 0;
}
void test_speed_for_query(const Tree& tree,
const Query_type query_type,
const char *query_name,
const double duration)
{
typedef typename K::Ray_3 Ray;
typedef typename K::Line_3 Line;
typedef typename K::Point_3 Point;
typedef typename K::Vector_3 Vector;
typedef typename K::Segment_3 Segment;
CGAL::Timer timer;
unsigned int nb = 0;
timer.start();
while(timer.time() < duration)
{
switch(query_type)
{
case RAY_QUERY:
{
Point source = random_point_in<K>(tree.bbox());
Vector vec = random_vector<K>();
Ray ray(source, vec);
tree.do_intersect(ray);
break;
}
case SEGMENT_QUERY:
{
Point a = random_point_in<K>(tree.bbox());
Point b = random_point_in<K>(tree.bbox());
tree.do_intersect(Segment(a,b));
break;
}
break;
case LINE_QUERY:
{
Point a = random_point_in<K>(tree.bbox());
Point b = random_point_in<K>(tree.bbox());
tree.do_intersect(Line(a,b));
break;
}
}
nb++;
}
unsigned int speed = (unsigned int)(nb / timer.time());
std::cout.precision(10);
std::cout.width(15);
std::cout << speed << " intersections/s with " << query_name << std::endl;
timer.stop();
}
void build_skeleton(const char* fname)
{
typedef typename Kernel::Point_2 Point_2;
typedef CGAL::Polygon_2<Kernel> Polygon_2;
typedef CGAL::Straight_skeleton_builder_traits_2<Kernel> SsBuilderTraits;
typedef CGAL::Straight_skeleton_2<Kernel> Ss;
typedef CGAL::Straight_skeleton_builder_2<SsBuilderTraits,Ss> SsBuilder;
Polygon_2 pgn;
std::ifstream input(fname);
FT x,y;
while(input)
{
input >> x;
if (!input) break;
input >> y;
if (!input) break;
pgn.push_back( Point_2( typename Kernel::FT(x), typename Kernel::FT(y) ) );
}
input.close();
std::cout << "Polygon has " << pgn.size() << " points\n";
if(!pgn.is_counterclockwise_oriented()) {
std::cerr << "Polygon is not CCW Oriented" << std::endl;
}
if(!pgn.is_simple()) {
std::cerr << "Polygon is not simple" << std::endl;
}
CGAL::Timer time;
time.start();
SsBuilder ssb;
ssb.enter_contour(pgn.vertices_begin(), pgn.vertices_end());
boost::shared_ptr<Ss> straight_ske = ssb.construct_skeleton();
time.stop();
std::cout << "Time spent to build skeleton " << time.time() << "\n";
if(!straight_ske->is_valid()) {
std::cerr << "Straight skeleton is not valid" << std::endl;
}
std::cerr.precision(60);
print_straight_skeleton(*straight_ske);
}
void
run_benchmark(SDG& sdg)
{
load_cin_file(std::cin, sdg);
CGAL::Timer timer;
timer.start();
if(! sdg.is_valid(true, 1) ){
std::cerr << "invalid data structure" << std::endl;
} else {
std::cerr << "valid data structure" << std::endl;
}
timer.stop();
std::cerr << "Data structure checking time = " << timer.time() << "s\n";
}
int main()
{
Polygon_2 poly ;
poly.push_back( Point(-1,-1) ) ;
poly.push_back( Point(0,-12) ) ;
poly.push_back( Point(1,-1) ) ;
poly.push_back( Point(12,0) ) ;
poly.push_back( Point(1,1) ) ;
poly.push_back( Point(0,12) ) ;
poly.push_back( Point(-1,1) ) ;
poly.push_back( Point(-12,0) ) ;
SsPtr ss = CGAL::create_interior_straight_skeleton_2(poly);
double offset = 1 ;
{
CGAL::Timer time; time.start();
PolygonPtrVector outer_polygons =
CGAL::create_exterior_skeleton_and_offset_polygons_2(offset, poly);
time.stop();
std:: cout << outer_polygons.size() << " built in " << time.time() << "\n";
}
{
CGAL::Timer time; time.start();
PolygonPtrVector outer_polygons =
CGAL::create_offset_polygons_2<Polygon_2>(offset,
*CGAL::create_exterior_straight_skeleton_2( offset, poly));
time.stop();
std:: cout << outer_polygons.size() << " built in " << time.time() << "\n";
}
return 0;
}
int main(int argc, const char *argv[])
{
CavConfig cfg;
const char *run_control_file = "cavity_volumes_fin.inp";
if (argc > 1)
run_control_file = argv[1];
if (!cfg.init(run_control_file)) {
std::cerr << "Error while initializing from run control file : " << run_control_file << std::endl;
return 2;
}
cfg.out_inf << "Run control file : " << run_control_file << std::endl;
CGAL::Timer t;
int processed_cnt = 0;
cfg.out_inf << std::endl;
t.start();
while (cfg.next_timestep()) {
const Array_double_3 &a = cfg.atoms.back();
cfg.out_inf << "Number of input atoms : " << cfg.atoms.size() << std::endl;
cfg.out_inf << "MD info : " << cfg.ts_info << std::endl;
cfg.out_inf << "Box : [ " << cfg.box[0] << ", " << cfg.box[1] << ", " << cfg.box[2] << " ]" << std::endl;
cfg.out_inf << "Last atom : " << a[0] << " " << a[1] << " " << a[2] << std::endl;
if (!process_conf(cfg)) {
cfg.out_inf << "process_conf() error. Exiting..." << std::endl;
return 1;
}
processed_cnt++;
}
t.stop();
// save accumulated per-atom surfaces
if (cfg.out_asf.is_open()) {
long double total_surf = std::accumulate(cfg.atom_confs_surf.begin(), cfg.atom_confs_surf.end(), 0.0L);
cfg.out_asf << total_surf << std::endl; // first line is total exposed surface of all atoms in all confs
cfg.out_asf << cfg.atom_confs_surf.size() << std::endl; // second line is the number of atoms
for (size_t i = 0; i < cfg.atom_confs_surf.size(); i++)
cfg.out_asf << cfg.atom_confs_surf[i] << std::endl;
}
cfg.out_inf << "Processed " << processed_cnt << " (of " << cfg.traj_ts_cnt() << ") configurations." << std::endl;
cfg.out_inf << "Time: " << t.time() << " sec." << std::endl;
return 0;
}
TrianglesList meshRemoveIntersectedTriangles(TrianglesList &triangles)
{
CGAL::Timer timer;
timer.start();
TrianglesList result;
//Collision boxes
std::vector<BoxInt> boxes;
std::list<Triangle>::iterator triangleIter;
for(triangleIter = triangles.begin(); triangleIter != triangles.end(); ++triangleIter)
{
//Triangle t = *triangleIter;
TriangleVisitedInfoMC *tvi = new TriangleVisitedInfoMC;
tvi->triangle = &(*triangleIter); //Use the pointer, it should not change into the container, since there aren't new added elements
tvi->intersected = false;
boxes.push_back( BoxInt( (*triangleIter).bbox(), tvi ));
}
//Do intersection
CGAL::box_self_intersection_d( boxes.begin(), boxes.end(), reportSelfIntersectionCallback);
//cycle on boxes and build result and delete tvi
std::vector<BoxInt>::iterator vectorBoxesIter;
for(vectorBoxesIter = boxes.begin(); vectorBoxesIter != boxes.end(); ++vectorBoxesIter)
{
BoxInt boxInt = *vectorBoxesIter;
TriangleVisitedInfoMC *tviHandled = boxInt.handle();
if ((!(tviHandled->intersected)) && (!(tviHandled->triangle->is_degenerate())))
{
Triangle t = *(tviHandled->triangle);
result.push_back(t);
}
delete tviHandled;
}
timer.stop();
std::cout << "Total meshRemoveIntersectedTriangles time: " << timer.time() << std::endl;
return result;
}
int main()
{
int i, loops=10000000;
CGAL::Timer t;
double dt;
#if 0
// Those timings were made on my laptop, which is now not mine anymore,
// so I need to make them again to be able to make useful comparisons...
// Maybe automazing the process would be useful to test on different
// platforms...
// mp / mp1 / mp2 / mp3
// Cartesian : 3.44 / 2.71 / 2.67 / 3.5
// PointC2 : 2.27 / 2.26 / 2.17 / 2.78
// Advanced kernel : 2.25 / 2.26 / 2.17 / 2.78
// SimpleCartesian : 1.23 (1.21) (= without the wrapper classes)
// Homogeneous : 4.46 (3.47)
dt = t.time(); t.start();
for (i=0; i<loops; i++)
Point2 C = CGAL::midpoint(A,B);
#else
// Cartesian : 4.13 / 3.68 / 3.63 / 4.65
// PointC2 : 3.29 / 3.29 / 3.16 / 3.5
// Advanced kernel : 3.29 / 3.29 / 3.16 / 3.51
// SimpleCartesian : 1.32 (1.21)
// Homogeneous : 5.23 (4.22)
Point2 C;
dt = t.time(); t.start();
for (i=0; i<loops; i++)
C = CGAL::midpoint(A,B);
#endif
t.stop();
std::cout << "time = " << t.time()-dt << std::endl;
return 0;
}
//TODO: still sometimes is crashing: test on linux and using a different compiler or TBB libs
std::list<MeshData> voronoiShatter(MeshData &meshData, std::list<KDPoint> points, bool useDelaunay, double bCriteria, double sCriteria)
{
CGAL::Timer timer;
timer.start();
std::list<MeshData> resultMeshdata;
//tbb::concurrent_vector<MeshData> concurrentResultMeshdata;
Delaunay T(points.begin(), points.end());
std::cout << "T.number_of_vertices:" << T.number_of_vertices() << std::endl;
std::cout << "T.number_of_edges:" << T.number_of_finite_edges() << std::endl;
std::cout << "T.is_valid:" << T.is_valid() << std::endl;
std::vector<DVertex_handle> vertexHandleVector;
Delaunay::Finite_vertices_iterator vit;
for (vit = T.finite_vertices_begin(); vit != T.finite_vertices_end(); ++vit)
{
DVertex_handle vh = vit;
vertexHandleVector.push_back(vh);
}
//Run multiple Thread using TBB
//TBBVoronoiCell tbbVC(meshData, T, concurrentResultMeshdata);
TBBVoronoiCell tbbVC(meshData, T, resultMeshdata, useDelaunay, bCriteria, sCriteria);
int numberThreads = tbb::task_scheduler_init::default_num_threads();
std::cout << "numberThreads: " << numberThreads << std::endl;
tbb::task_scheduler_init init(numberThreads);
//tbb::parallel_do(T.finite_vertices_begin(), T.finite_vertices_end(), tbbVC);
tbb::parallel_do(vertexHandleVector.begin(), vertexHandleVector.end(), tbbVC);
/*
//Build result
std::cout << "Building result..." << std::endl;
tbb::concurrent_vector<MeshData>::iterator crmi;
for (crmi = concurrentResultMeshdata.begin(); crmi != concurrentResultMeshdata.end(); ++crmi)
{
//MeshData md = *crmi;
resultMeshdata.push_back(*crmi);
}
*/
timer.stop();
std::cout << "Total tbb voronoiShatter construction took " << timer.time() << " seconds, total cells:" << resultMeshdata.size() << std::endl;
return resultMeshdata;
}
void read_handle_difs_and_deform(DeformMesh& deform_mesh, InputIterator begin, InputIterator end)
{
typedef CGAL::Simple_cartesian<double>::Vector_3 Vector;
if(!deform_mesh.preprocess()) {
std::cerr << "Error: preprocess() failed!" << std::endl;
assert(false);
}
std::ifstream dif_stream("data/cactus_handle_differences.txt");
std::vector<Vector> dif_vector;
double x, y, z;
while(dif_stream >> x >> y >> z)
{ dif_vector.push_back(Vector(x, y, z)); }
CGAL::Timer timer;
//the original behavior of translate was to overwrite the previous
//translation. Now that it is cumulative, we need to substract the
//previous translation vector to mimic the overwrite
Vector previous(0,0,0);
for(std::size_t i = 0; i < dif_vector.size(); ++i)
{
timer.start();
deform_mesh.translate(begin, end, dif_vector[i]-previous);
deform_mesh.deform();
timer.stop();
previous=dif_vector[i];
// read pre-deformed cactus
std::stringstream predeformed_cactus_file;
predeformed_cactus_file << "data/cactus_deformed/cactus_deformed_" << i << ".off";
Mesh predeformed_cactus;
OpenMesh::IO::read_mesh(predeformed_cactus, predeformed_cactus_file.str().c_str());
compare_mesh(predeformed_cactus, deform_mesh.halfedge_graph());
// for saving deformation
//std::ofstream(predeformed_cactus_file) << deform_mesh.halfedge_graph();
//std::cerr << predeformed_cactus_file << std::endl;
}
std::cerr << "Deformation performance (with default number_of_iteration and tolerance) " << std::endl
<< dif_vector.size() << " translation: " << timer.time() << std::endl;
}
int main ()
{
// Open the input file.
std::ifstream in_file ("tight.dat");
if (! in_file.is_open())
{
std::cerr << "Failed to open the input file." << std::endl;
return (1);
}
// Read the input polygon.
Polygon_2 P;
in_file >> P;
in_file.close();
std::cout << "Read an input polygon with "
<< P.size() << " vertices." << std::endl;
// Approximate the offset polygon.
const Number_type radius = 1;
const double err_bound = 0.00001;
std::list<Offset_polygon_2> inset_polygons;
std::list<Offset_polygon_2>::iterator iit;
CGAL::Timer timer;
timer.start();
approximated_inset_2 (P, radius, err_bound,
std::back_inserter (inset_polygons));
timer.stop();
std::cout << "The inset comprises "
<< inset_polygons.size() << " polygon(s)." << std::endl;
for (iit = inset_polygons.begin(); iit != inset_polygons.end(); ++iit)
{
std::cout << " Polygon with "
<< iit->size() << " vertices." << std::endl;
}
std::cout << "Inset computation took "
<< timer.time() << " seconds." << std::endl;
return (0);
}
int main()
{
const int d = 10; // change this in order to experiment
const int n = 100000; // change this in order to experiment
// generate n random d-dimensional points in [0,1]^d
CGAL::Random rd;
std::vector<Point_d> points;
for (int j =0; j<n; ++j) {
std::vector<double> coords;
for (int i=0; i<d; ++i)
coords.push_back(rd.get_double());
points.push_back (Point_d (d, coords.begin(), coords.end()));
}
// benchmark all pricing strategies in turn
CGAL::Quadratic_program_pricing_strategy strategy[] = {
CGAL::QP_CHOOSE_DEFAULT, // QP_PARTIAL_FILTERED_DANTZIG
CGAL::QP_DANTZIG, // Dantzig's pivot rule...
CGAL::QP_PARTIAL_DANTZIG, // ... with partial pricing
CGAL::QP_BLAND, // Bland's pivot rule
CGAL::QP_FILTERED_DANTZIG, // Dantzig's filtered pivot rule...
CGAL::QP_PARTIAL_FILTERED_DANTZIG // ... with partial pricing
};
CGAL::Timer t;
for (int i=0; i<6; ++i) {
// test strategy i
CGAL::Quadratic_program_options options;
options.set_pricing_strategy (strategy[i]);
t.reset(); t.start();
// is origin in convex hull of the points? (most likely, not)
solve_convex_hull_containment_lp
(Point_d (d, CGAL::ORIGIN), points.begin(), points.end(),
ET(0), options);
t.stop();
std::cout << "Time (s) = " << t.time() << std::endl;
}
return 0;
}
int main(int argc, char** argv)
{
size_type number_of_elements = 100000;
int nb_elements = static_cast<int>(number_of_elements);
int number_of_loops = 10;
if(argc > 1)
number_of_elements = std::atoi(argv[1]);
if(argc > 2)
number_of_loops = std::atoi(argv[2]);
Map f;
CGAL::Timer time_insert;
CGAL::Timer time_pop;
CGAL::Timer time;
CGAL::Memory_sizer memory;
time.start();
for(int loop = 0; loop < number_of_loops; ++loop)
{
time_pop.start();
while(!f.empty())
f.pop_front();
time_pop.stop();
time_insert.start();
for (int i = 0; i < nb_elements; ++i)
f.insert(i, i);
time_insert.stop();
}
time.stop();
std::cerr << "Total time: " << time.time()
<< "\nTime for 'insert': " << time_insert.time()
<< "\nTime for 'pop_front': " << time_pop.time()
<< "\nResident memory: " << memory.resident_size()
<< "\nVirtual memory: " << memory.virtual_size()
<< "\n";
return 0;
}
template < class Traits > double test_del(unsigned int degree, unsigned int n)
{
typedef CGAL::Kinetic::Delaunay_triangulation_3 < Traits > Del;
Traits tr;
Del del(tr);
CGAL::Random r;
for (unsigned int i = 0; i < n; ++i) {
std::vector < double >cf[3];
for (unsigned int j = 0; j < degree + 1; ++j) {
for (int k = 0; k < 3; ++k) {
cf[k].push_back(r.get_double());
}
}
typename Traits::Kinetic_kernel::Motion_function fn[3];
for (unsigned int k = 0; k < 3; ++k)
fn[k] =
typename Traits::Kinetic_kernel::Motion_function(cf[k].begin(),
cf[k].end());
typename Traits::Kinetic_kernel::Point_3 pt(fn[0], fn[1], fn[2]);
tr.active_objects_table_pointer()->insert(pt);
}
del.set_has_certificates(true);
CGAL::Timer timer;
timer.start();
int ne = 0;
while (tr.simulator_pointer()->next_event_time() !=
tr.simulator_pointer()->end_time()) {
tr.simulator_pointer()->set_current_event_number(tr.
simulator_pointer()->
current_event_number()
+ 1);
++ne;
if (ne == 1000)
break;
}
timer.stop();
return timer.time() / static_cast < double >(ne);
}
int main(int argc, char **argv)
{
int n=1000000;
int rep=100;
if (argc>=2)
n=atoi(argv[1]);
if (argc>=3)
rep=atoi(argv[2]);
std::vector<Point> points;
points.reserve(n);
CGAL::Random_points_in_disc_2<Point,Creator> g(1);
CGAL::copy_n( g, n, std::back_inserter(points));
Delaunay original;
original.insert(points.begin(),points.end());
double res=0;
for (int r=0;r<rep;++r){
Delaunay delaunay=original;
std::vector<Vertex_handle> vertices;
for(FVI fvi = delaunay.finite_vertices_begin(); fvi != delaunay.finite_vertices_end();++fvi){
vertices.push_back(fvi);
}
CGAL::Timer t;
t.start();
for (int k=0; k<vertices.size(); ++k)
delaunay.remove(vertices[k]);
t.stop();
res+=t.time();
if (delaunay.number_of_vertices()!=0){
std::cerr << "ERROR"<< std::endl;
return 1;
}
}
std::cout << res/rep << std::endl;
return 0;
}
int main ()
{
// Open the input file.
std::ifstream in_file ("spiked.dat");
if (! in_file.is_open())
{
std::cerr << "Failed to open the input file." << std::endl;
return (1);
}
// Read the input polygon.
Polygon_2 P;
in_file >> P;
in_file.close();
std::cout << "Read an input polygon with "
<< P.size() << " vertices." << std::endl;
// Compute the offset polygon.
Conic_traits_2 traits;
const Rational radius = 5;
Offset_polygon_with_holes_2 offset;
CGAL::Timer timer;
timer.start();
offset = offset_polygon_2 (P, radius, traits);
timer.stop();
std::cout << "The offset polygon has "
<< offset.outer_boundary().size() << " vertices, "
<< offset.number_of_holes() << " holes." << std::endl;
std::cout << "Offset computation took "
<< timer.time() << " seconds." << std::endl;
return (0);
}
int main()
{
CGAL::Timer t;
t.start();
Tr tr; // 3D-Delaunay triangulation
C2t3 c2t3 (tr); // 2D-complex in 3D-Delaunay triangulation
// defining the surface
Surface_3 surface(klein_function, // pointer to function
Sphere_3(CGAL::ORIGIN, 2.)); // bounding sphere
// Note that "2." above is the *squared* radius of the bounding sphere!
// defining meshing criteria
CGAL::Surface_mesh_default_criteria_3<Tr> criteria(30., // angular bound
0.1, // radius bound
0.1); // distance bound
// meshing surface
CGAL::make_surface_mesh(c2t3, surface, criteria, CGAL::Non_manifold_tag());
CGAL::Random rand;
t.stop();
std::cout << "Time elapsed for building the mesh: " << t.time() << std::endl;
t.reset();
t.start();
int nr = 1000;
std::vector<Point_3> points;
points.reserve(nr);
CGAL::Random_points_on_surface_mesh_3<Point_3, C2t3> g(c2t3);
t.stop();
std::cout << "Time elapsed for init Random_points_in_surface_mesh_3: " <<
t.time() << std::endl;
t.reset();
t.start();
CGAL::cpp11::copy_n( g, nr, std::back_inserter(points));
t.stop();
std::cout << "Time elapsed for generating the points: " << t.time() << std::endl;
t.reset();
std::cout << "Actual number of facet: " <<c2t3.number_of_facets() << "\n";
int cont = 0;
C2t3::Facet_iterator it = c2t3.facets_begin();
for (; it != c2t3.facets_end(); ++it) {
Vertex v[4];
int k = 0;
for(int j = 0; j < 4; j++)
{
if(j == it->second) continue;
v[k] = it->first->vertex(j);
k++;
}
Triangle_3 aux(v[0]->point(), v[1]->point(),
v[2]->point());
std::cout << aux.vertex(0).x() << " "<< aux.vertex(0).y() << " "<<
aux.vertex(0).z() << "\n";
std::cout << aux.vertex(1).x() << " "<< aux.vertex(1).y() << " "<<
aux.vertex(1).z() << "\n";
std::cout << aux.vertex(2).x() << " "<< aux.vertex(2).y() << " "<<
aux.vertex(2).z() << "\n";
cont++;
}
std::cout << "Number of facets counted by me " << cont << '\n';
std::cout << "The generated points are: " << std::endl;
for (int i = 0; i < nr; i++) {
std::cout << points[i].x() << " " << points[i].y() << " " <<
points[i].z() << std::endl;
}
points.clear();
return 0;
}
int main() {
// CGAL::Timer time;
//
// time.start();
cout << "Creating point cloud" << endl;
simu.read();
create();
if(simu.create_points()) {
// set_alpha_circle( Tp , 2);
// set_alpha_under_cos( Tp ) ;
cout << "Creating velocity field " << endl;
set_fields_TG( Tm ) ;
//set_fields_cos( Tm ) ;
cout << "Numbering particles " << endl;
number(Tp);
number(Tm);
}
int Nb=sqrt( simu.no_of_particles() + 1e-12);
// Set up fft, and calculate initial velocities:
move_info( Tm );
move_info( Tp );
CH_FFT fft( LL , Nb );
load_fields_on_fft( Tm , fft );
FT dt=simu.dt();
FT mu=simu.mu();
fft.all_fields_NS( dt * mu );
fft.draw( "phi", 0, fft.field_f() );
fft.draw( "press", 0, fft.field_p() );
fft.draw( "vel_x", 0, fft.field_vel_x() );
fft.draw( "vel_y", 0, fft.field_vel_y() );
load_fields_from_fft( fft, Tm );
// every step
areas(Tp);
quad_coeffs(Tp , simu.FEMp() ); volumes(Tp, simu.FEMp() );
// just once!
linear algebra(Tm);
areas(Tm);
quad_coeffs(Tm , simu.FEMm() ); volumes(Tm, simu.FEMm() );
cout << "Setting up diff ops " << endl;
// TODO: Are these two needed at all?
// if(simu.create_points()) {
// nabla(Tm);
// TODO, they is, too clear why
Delta(Tm);
// }
const std::string mesh_file("mesh.dat");
const std::string particle_file("particles.dat");
// // step 0 draw.-
// draw(Tm, mesh_file , true);
// draw(Tp, particle_file , true);
cout << "Assigning velocities to particles " << endl;
#if defined FULL_FULL
{
Delta(Tp);
linear algebra_p(Tp);
from_mesh_full_v( Tm , Tp , algebra_p , kind::U);
}
#elif defined FULL_LUMPED
from_mesh_lumped_v( Tm , Tp , kind::U);
#elif defined FLIP
from_mesh_v(Tm , Tp , kind::U);
#else
from_mesh_v(Tm , Tp , kind::U);
#endif
// #if defined FULL_FULL
// {
// Delta(Tp);
// linear algebra_p(Tp);
// from_mesh_full( Tm , Tp , algebra_p,kind::ALPHA);
// }
// #elif defined FULL_LUMPED
// from_mesh_lumped( Tm , Tp , kind::ALPHA);
// #elif defined FLIP
// from_mesh(Tm , Tp , kind::ALPHA);
// #else
// from_mesh(Tm , Tp , kind::ALPHA);
// #endif
cout << "Moving info" << endl;
move_info( Tm );
move_info( Tp );
draw(Tm, mesh_file , true);
draw(Tp, particle_file , true);
// return 1;
simu.advance_time();
simu.next_step();
// bool first_iter=true;
CGAL::Timer time;
time.start();
std::ofstream log_file;
log_file.open("main.log");
bool is_overdamped = ( simu.mu() > 1 ) ; // high or low Re
for(;
simu.current_step() <= simu.Nsteps();
simu.next_step()) {
cout
<< "Step " << simu.current_step()
<< " . Time " << simu.time()
<< " ; t step " << simu.dt()
<< endl;
FT dt=simu.dt();
FT dt2 = dt / 2.0 ;
int iter=0;
FT displ=1e10;
FT min_displ=1e10;
int min_iter=0;
const int max_iter=8; //10;
const FT max_displ= 1e-8; // < 0 : disable
// leapfrog, special first step.-
// if(simu.current_step() == 1) dt2 *= 0.5;
// dt2 *= 0.5;
move_info(Tm);
move_info(Tp);
// iter loop
for( ; ; iter++) {
// comment for no move.-
cout << "Moving half step " << endl;
FT d0;
displ = move( Tp , dt2 , d0 );
areas(Tp);
quad_coeffs(Tp , simu.FEMp() ); volumes(Tp, simu.FEMp() );
cout
<< "Iter " << iter
<< " , moved avg " << d0 << " to half point, "
<< displ << " from previous"
<< endl;
if( displ < min_displ) {
min_displ=displ;
min_iter=iter;
}
if( (displ < max_displ) && (iter !=0) ) {
cout << "Convergence in " << iter << " iterations " << endl;
break;
}
if( iter == max_iter-1 ) {
cout << "Exceeded " << iter-1 << " iterations " << endl;
break;
}
cout << "Proj advected U0 velocities onto mesh " << endl;
#if defined FULL
onto_mesh_full_v(Tp,Tm,algebra,kind::UOLD);
#elif defined FLIP
flip_volumes (Tp , Tm , simu.FEMm() );
onto_mesh_flip_v(Tp,Tm,simu.FEMm(),kind::UOLD);
#else
onto_mesh_delta_v(Tp,Tm,kind::UOLD);
#endif
load_fields_on_fft( Tm , fft );
FT b = mu * dt2;
fft.all_fields_NS( b );
// fft.evolve( b );
load_fields_from_fft( fft , Tm );
// Search "FLIPincr" in CH_FFT.cpp to change accordingly!
// EITHER:
// FLIP idea: project only increments
cout << "Proj Delta U from mesh onto particles" << endl;
#if defined FULL_FULL
{
Delta(Tp);
linear algebra_p(Tp);
from_mesh_full_v(Tm, Tp, algebra_p , kind::DELTAU);
}
#elif defined FULL_LUMPED
from_mesh_lumped_v(Tm, Tp, kind::DELTAU);
#elif defined FLIP
from_mesh_v(Tm, Tp, kind::DELTAU);
#else
from_mesh_v(Tm, Tp, kind::DELTAU);
#endif
incr_v( Tp , kind::UOLD , kind::DELTAU , kind::U );
// OR:
// project the whole velocity
// cout << "Proj U from mesh onto particles" << endl;
//
//#if defined FULL_FULL
// {
// Delta(Tp);
// linear algebra_p(Tp);
// from_mesh_full_v(Tm, Tp, algebra_p , kind::U);
// }
//#elif defined FULL_LUMPED
// from_mesh_lumped_v(Tm, Tp, kind::U);
//#elif defined FLIP
// from_mesh_v(Tm, Tp, kind::U);
//#else
// from_mesh_v(Tm, Tp, kind::U);
//#endif
// // substract spurious overall movement.-
// zero_mean_v( Tm , kind::FORCE);
} // iter loop
cout << "Moving whole step: relative ";
FT d0;
displ=move( Tp , dt , d0 );
cout
<< displ << " from half point, "
<< d0 << " from previous point"
<< endl;
// comment for no move.-
update_half_velocity( Tp , is_overdamped );
update_half_alpha( Tp );
areas(Tp);
quad_coeffs(Tp , simu.FEMp() ); volumes(Tp, simu.FEMp() );
// this, for the looks basically .-
cout << "Proj U_t+1 , alpha_t+1 onto mesh " << endl;
#if defined FULL
onto_mesh_full_v(Tp,Tm,algebra,kind::U);
onto_mesh_full (Tp,Tm,algebra,kind::ALPHA);
#elif defined FLIP
flip_volumes(Tp , Tm , simu.FEMm() );
onto_mesh_flip_v(Tp,Tm,simu.FEMm(),kind::U);
onto_mesh_flip (Tp,Tm,simu.FEMm(),kind::ALPHA);
#else
onto_mesh_delta_v(Tp,Tm,kind::U);
onto_mesh_delta (Tp,Tm,kind::ALPHA);
#endif
move_info( Tm );
move_info( Tp );
if(simu.current_step()%simu.every()==0) {
draw(Tm, mesh_file , true);
draw(Tp, particle_file , true);
fft.histogram( "phi", simu.current_step() , fft.field_fq() );
}
log_file
<< simu.current_step() << " "
<< simu.time() << " " ;
// integrals( Tp , log_file); log_file << " ";
// fidelity( Tp , log_file ); log_file << endl;
simu.advance_time();
} // time loop
time.stop();
log_file.close();
cout << "Total runtime: " << time.time() << endl;
return 0;
}
void operator()() const
{
//-------------------------------------------------------
// Data generation : get 4 nearly coplanar points
//-------------------------------------------------------
Point_creator creator;
FT little(1e-10);
FT tiny(1e-25);
Point p1 = creator(little,1,tiny);
Point p2 = creator(1,little,0);
Point p3 = creator(-1*little,1,0);
Point p4 = creator(1,-1*little,0);
Point p5 = creator(0,0,1);
Point p6 = creator(0,1,0);
std::cerr << "Using points: p1[" << p1 << "]\tp2[" << p2
<< "]\tp3[" << p3 << "]\tp4[" << p4 << "]\tp5[" << p5
<< "]\tp6[" << p6 << "]\n";
//-------------------------------------------------------
// Test correctness
//-------------------------------------------------------
typename Gt::Construct_weighted_circumcenter_3 circumcenter =
Gt().construct_weighted_circumcenter_3_object();
Point center = circumcenter(p1,p2);
std::cerr << "\tcircumcenter(p1,p2)=[" << center << "]\n";
center = circumcenter(p1,p3,p6);
std::cerr << "\tcircumcenter(p1,p3,p6)=[" << center << "]\n";
center = circumcenter(p1,p2,p5);
std::cerr << "\tcircumcenter(p1,p3,p5)=[" << center << "]\n";
// Use positive orientation
center = circumcenter(p2,p3,p4,p1);
std::cerr << "\tcircumcenter(p2,p3,p4,p1)=[" << center << "]\n";
center = circumcenter(p1,p3,p2,p5);
std::cerr << "\tcircumcenter(p1,p3,p2,p5)=[" << center << "]\n";
//-------------------------------------------------------
// Test speed
//-------------------------------------------------------
std::cerr << "Test speed: compute loops of: 999*c(p1,p3,p2,p5) "
<< "and 1*c(p2,p3,p4,p1)\n";
CGAL::Timer timer;
timer.start();
int nb_loop = 0;
while ( timer.time() < 0.5 )
{
// Compute 1000 fast queries
for ( int i = 0 ; i < 999 ; ++i)
circumcenter(p1,p3,p2,p5);
// Compute 1 exact query
circumcenter(p2,p3,p4,p1);
++nb_loop;
}
timer.stop();
std::cerr << "\t" << nb_loop*1000/timer.time()
<< " circumcenter computation / second\n";
std::cerr << "Test speed: compute loops of: 999*c(p2,p3,p4,p1) "
<< "and 1*c(p1,p3,p2,p5)\n";
timer.reset();
timer.start();
nb_loop = 0;
while ( timer.time() < 0.5 )
{
// Compute 1 exact queries
for ( int i = 0 ; i < 999 ; ++i)
circumcenter(p2,p3,p4,p1);
// Compute 1 fast query
circumcenter(p1,p3,p2,p5);
++nb_loop;
}
timer.stop();
std::cerr << "\t" << nb_loop*1000/timer.time()
<< " circumcenter computation / second\n";
}
int main(int argc, char* argv[])
{
std::cerr.precision(17);
std::ifstream points_file(argv[2]);
std::vector<Point> points;
std::copy(std::istream_iterator<Point>(points_file),
std::istream_iterator<Point>(),
std::back_inserter(points));
int gridsize = 10;
if(argc>3){
gridsize = boost::lexical_cast<int>(argv[3]);
}
std::cerr << "gridsize = " << gridsize << std::endl;
int nb_points=points.size();
std::vector<bool> ray_res(nb_points);
std::vector<bool> grid_res(nb_points);
//using ray
{
Polyhedron polyhedron;
std::ifstream polyhedron_file(argv[1]);
polyhedron_file >> polyhedron;
std::cerr << "|V| = " << polyhedron.size_of_vertices() << std::endl;
CGAL::Timer timer;
timer.start();
CGAL::Point_inside_polyhedron_3<Polyhedron,K> inside_with_ray(polyhedron,0);
timer.stop();
std::cerr <<"Using ray"<< std::endl;
std::cerr << " Preprocessing took " << timer.time() << " sec." << std::endl;
timer.reset();
int n_inside = 0;
timer.start();
for(int k=0;k<nb_points;++k){
ray_res[k]=inside_with_ray(points[k]);
if(ray_res[k]){
++n_inside;
}
}
timer.stop();
std::cerr << " " << n_inside << " points inside " << std::endl;
std::cerr << " " << points.size() - n_inside << " points outside " << std::endl;
std::cerr << " Queries took " << timer.time() << " sec." << std::endl;
}
//using grid
{
Polyhedron polyhedron;
std::ifstream polyhedron_file(argv[1]);
polyhedron_file >> polyhedron;
std::cerr << "|V| = " << polyhedron.size_of_vertices() << std::endl;
CGAL::Timer timer;
timer.start();
CGAL::Point_inside_polyhedron_3<Polyhedron,K> inside_with_grid(polyhedron, gridsize);
timer.stop();
std::cerr <<"Using grid"<< std::endl;
std::cerr << " Preprocessing took " << timer.time() << " sec." << std::endl;
timer.reset();
if(argc>5){
random_points(argv[4],inside_with_grid.bbox() ,boost::lexical_cast<int>(argv[5]) );
}
int n_inside = 0;
timer.start();
for(int k=0;k<nb_points;++k){
grid_res[k]=inside_with_grid(points[k]);
if(grid_res[k]){
++n_inside;
}
}
timer.stop();
std::cerr << " " << n_inside << " points inside " << std::endl;
std::cerr << " " << points.size() - n_inside << " points outside " << std::endl;
std::cerr << " Queries took " << timer.time() << " sec." << std::endl;
}
for(int k=0;k<nb_points;++k){
if(ray_res[k]!=grid_res[k]){
std::cerr << "WARNING: Result is different for point " << k << std::endl;
}
}
//using original code
{
Polyhedron polyhedron;
std::ifstream polyhedron_file(argv[1]);
polyhedron_file >> polyhedron;
std::cerr << "|V| = " << polyhedron.size_of_vertices() << std::endl;
std::cerr <<"Using ray (original code)"<< std::endl;
CGAL::Point_inside_polyhedron_3<Polyhedron,K> inside_with_ray(polyhedron,0);
CGAL::Timer timer;
int n_inside = 0;
timer.start();
for(int k=0;k<nb_points;++k)
if(inside_with_ray(points[k],true)) ++n_inside;
timer.stop();
std::cerr << " " << n_inside << " points inside " << std::endl;
std::cerr << " " << points.size() - n_inside << " points outside " << std::endl;
std::cerr << " Queries took " << timer.time() << " sec." << std::endl;
}
return 0;
}
/**
* Executes one custom timestep
* @param averageEdgeLength The function to compute the average edge length for a given vertex
* @param getOffsetPoint Computes the new location of the given point
* @return The results of running the timestep
*/
stepResults StoneWeatherer::doOneCustomStep( double ( *averageEdgeLength )( const Vertex_handle & v ), Point( *getOffsetPoint )( const Point & p, const VertexData & d, const StoneWeatherer * caller ) ) {
CGAL::Timer timestamp;
stepResults result;
result.secondsTotal = 0.0;
timestamp.start();
timestamp.reset();
/**
* Maps circumcenters to where they really came from
*/
map<Point,Point> pointMap;
// Generate the correct-resolution offset points
vector<Point> newPoints;
int n;
int i;
int j;
Vertex_handle vhi;
Vertex_handle vhj;
double dist2;
Point a;
Point b;
Point c;
VertexData d;
// Put in midPoints of edges as needed, and flag redundant vertices
for ( Cell_iterator it = newDT->finite_cells_begin(); it != newDT->finite_cells_end(); ++it ) {
if ( it->info() != AIR ) {
for ( n = 0; n < 4; ++n ) {
if ( it->neighbor( n )->info() != it->info() || newDT->is_infinite( it->neighbor( n ) ) ) {
for ( i = 1; i < 4; ++i ) {
Vertex_handle vhi = it->vertex( n ^ i );
for ( j = i + 1; j < 4; ++j ) {
Vertex_handle vhj = it->vertex( n ^ j );
// Only check each edge once...
if ( vhi < vhj ) {
dist2 = ( vhi->point() - vhj->point() ).squared_length();
if ( dist2 > maxSquareDistance( averageEdgeLength, vhi, vhj ) ) {
// Don't split non-live edges
a = vhi->point();
b = vhj->point();
if ( !live( a.x(), a.y(), a.z() ) && !live( b.x(), b.y(), b.z() ) ) {
continue;
}
// Split edge
a = CGAL::ORIGIN + ( ( a - CGAL::ORIGIN ) + ( b - CGAL::ORIGIN ) ) * 0.5;
d = VertexData::midPoint( vhi->info(), vhj->info() );
//// If the vertex is shared by both objects, split it
//if ( ( d.flag & ROCK ) && ( d.flag & MORE_ROCK ) ) {
// VertexData d1;
// VertexData d2;
// splitVertexData( d, d1, d2 );
//
// Point a1 = jitterPoint( a );
// Point a2 = jitterPoint( a );
//
// c = getOffsetPoint( a1, d1, this );
// newPoints.push_back( c );
// pointMap.insert( pair<Point,Point>( c, a1 ) );
// c = getOffsetPoint( a2, d2, this );
// newPoints.push_back( c );
// pointMap.insert( pair<Point,Point>( c, a2 ) );
//}
//else {
c = getOffsetPoint( a, d, this );
newPoints.push_back( c );
pointMap.insert( pair<Point,Point>( c, a ) );
//}
}
else if ( vhi->info().kill != TOO_CLOSE && dist2 < minSquareDistance( averageEdgeLength, vhi, vhj ) ) {
// The higher-address endpoint
vhj->info().kill = TOO_CLOSE;
}
}
}
}
}
}
}
}
double bound[ 3 ][ 2 ] = {
{ 1.0e30, -1.0e30 },
{ 1.0e30, -1.0e30 },
{ 1.0e30, -1.0e30 }
};
// Put in all the border vertices
for ( Vertex_iterator it = newDT->finite_vertices_begin(); it != newDT->finite_vertices_end(); ++it ) {
if ( it->point().x() < bound[ 0 ][ 0 ] ) {
bound[ 0 ][ 0 ] = it->point().x();
}
else if ( it->point().x() > bound[ 0 ][ 1 ] ) {
bound[ 0 ][ 1 ] = it->point().x();
}
if ( it->point().y() < bound[ 1 ][ 0 ] ) {
bound[ 1 ][ 0 ] = it->point().y();
}
else if ( it->point().y() > bound[ 1 ][ 1 ] ) {
bound[ 1 ][ 1 ] = it->point().y();
}
if ( it->point().z() < bound[ 2 ][ 0 ] ) {
bound[ 2 ][ 0 ] = it->point().z();
}
else if ( it->point().z() > bound[ 2 ][ 1 ] ) {
bound[ 2 ][ 1 ] = it->point().z();
}
if ( !live( it->point().x(), it->point().y(), it->point().z() ) ) {
newPoints.push_back( it->point() );
pointMap.insert( pair<Point,Point>( it->point(), it->point() ) );
}
else if ( it->info().kill == BORDER ) {
VertexData d = it->info();
Point a = it->point();
Point c;
//// If the vertex is shared by both objects, split it
//if ( ( d.flag & ROCK ) && ( d.flag & MORE_ROCK ) ) {
// VertexData d1;
// VertexData d2;
// splitVertexData( d, d1, d2 );
//
// Point a1 = jitterPoint( a );
// Point a2 = jitterPoint( a );
//
// c = getOffsetPoint( a1, d1, this );
// newPoints.push_back( c );
// pointMap.insert( pair<Point,Point>( c, a1 ) );
// c = getOffsetPoint( a2, d2, this );
// newPoints.push_back( c );
// pointMap.insert( pair<Point,Point>( c, a2 ) );
//}
//else {
c = getOffsetPoint( a, d, this );
newPoints.push_back( c );
pointMap.insert( pair<Point,Point>( c, a ) );
//}
}
}
result.secondsTotal += ( result.secondsMotion = timestamp.time() );
timestamp.reset();
// Create the new mesh
swapDT();
newDT->clear();
newDT->insert( newPoints.begin(), newPoints.end() );
result.secondsTotal += ( result.secondsCGAL = timestamp.time() );
//secondsTotal += result.secondsCGAL;
//secondsCGAL += result.secondsCGAL;
timestamp.reset();
// Update the inside-outside flags of new tetrahedrons
setContentFlags( result.midPoint, pointMap );
result.midPoint[ 0 ] = ( bound[ 0 ][ 0 ] + bound[ 0 ][ 1 ] ) * 0.5;
result.midPoint[ 1 ] = ( bound[ 1 ][ 0 ] + bound[ 1 ][ 1 ] ) * 0.5;
result.midPoint[ 2 ] = ( bound[ 2 ][ 0 ] + bound[ 2 ][ 1 ] ) * 0.5;
result.secondsTotal += ( result.secondsLabeling = timestamp.time() );
//secondsTotal += result.secondsLabeling;
//secondsLabeling += result.secondsLabeling;
timestamp.reset();
// Update vertex information
setVertexInfo();
result.secondsTotal += ( result.secondsAnalysis = timestamp.time() );
timestamp.reset();
timestamp.stop();
result.numVertices = newDT->number_of_vertices();
result.numTetrahedrons = newDT->number_of_cells();
cumulativeResults.secondsTotal += result.secondsTotal;
cumulativeResults.secondsMotion += result.secondsMotion;
cumulativeResults.secondsCGAL += result.secondsCGAL;
cumulativeResults.secondsLabeling += result.secondsLabeling;
cumulativeResults.secondsAnalysis += result.secondsAnalysis;
return result;
}
std::list<MeshData> voronoiShatter(MeshData &meshData, std::list<KDPoint> points, bool useDelaunay, double bCriteria, double sCriteria)
{
CGAL::Timer timer;
timer.start();
std::list<MeshData> resultMeshdata;
Delaunay T(points.begin(), points.end());
std::cout << "T.number_of_vertices:" << T.number_of_vertices() << std::endl;
std::cout << "T.number_of_edges:" << T.number_of_finite_edges() << std::endl;
std::cout << "T.is_valid:" << T.is_valid() << std::endl;
int countNumberVertices = 0; //Just to count
Delaunay::Finite_vertices_iterator vit;
for (vit = T.finite_vertices_begin(); vit != T.finite_vertices_end(); ++vit)
{
DVertex_handle vh = vit;
std::list<Triangle> cutMeshTriangles = meshData.first;
std::list<TriangleInfo> cutInfo = meshData.second;
std::list<DEdge> segs;
T.finite_incident_edges(vh, std::back_inserter(segs));
std::cout << " (" << countNumberVertices++ << ") num edges: " << segs.size() << std::endl;
std::list<DEdge>::iterator segsIter;
for(segsIter=segs.begin(); segsIter!= segs.end(); ++segsIter)
{
DEdge edg = *segsIter;
DSegment_3 segment = T.segment(edg);
KDVector vect = segment.to_vector();
KDPoint p1 = segment.source();
KDPoint p2 = segment.target();
//KDPoint mp( (p1.x() + p2.x())/2.0, (p1.y() + p2.y())/2.0, (p1.z() + p2.z())/2.0);
//Plane planeCutter_voronoi(PointCGAL(mp.x(), mp.y(), mp.z()), Vector(-vect.x(), -vect.y(), -vect.z()));
//TODO: potrebbe esserci un errore a causa dei punti non esatti p1 e p2
PointCGAL mp( (p1.x() + p2.x())/2.0, (p1.y() + p2.y())/2.0, (p1.z() + p2.z())/2.0);
Plane planeCutter_voronoi(mp, Vector(-vect.x(), -vect.y(), -vect.z()));
MeshData cutData = cutMesh(cutMeshTriangles, planeCutter_voronoi, cutInfo, useDelaunay, bCriteria, sCriteria);
cutMeshTriangles = cutData.first;
cutInfo = cutData.second;
//std::cout << " temp mesh size: " << cutMeshTriangles.size() << std::endl;
//TODO: change TriangleInfo adding:
// int meshId, meshIdAdjacent
// and populate these new two variable for the triangles into the cut plane;
// each mesh piece will have a different id;
// these two new variable could be used into the RejointMeshes algorithm instead of reportAdjacentIntersectionCallback:
// knowing this ids it is very easy remove the the triangles in shared cut surfaces
}
if (cutMeshTriangles.size() > 0)
{
resultMeshdata.push_back(MeshData(cutMeshTriangles, cutInfo));
}
else
{
std::cout << " Warning: Final Voronoi mesh size empty!!" << std::endl;
}
}
timer.stop();
std::cout << "Total voronoiShatter construction took " << timer.time() << " seconds, total cells:" << resultMeshdata.size() << std::endl;
return resultMeshdata;
}
int main() {
// CGAL::Timer time;
//
// time.start();
cout << "Creating point cloud" << endl;
simu.read();
create();
if(simu.create_points()) {
// set_alpha_circle( Tp , 2);
// set_alpha_under_cos( Tp ) ;
cout << "Creating alpha field " << endl;
set_alpha_random( Tm ) ;
//set_alpha_cos( Tm );
cout << "Numbering particles " << endl;
number(Tp);
number(Tm);
}
int Nb=sqrt( simu.no_of_particles() + 1e-12);
// Set up fft, and calculate initial velocities:
move_info( Tm );
CH_FFT fft( LL , Nb );
load_alpha_on_fft( Tm , fft );
fft.all_fields();
fft.draw( "phi", 0, fft.field_f() );
fft.draw( "mu", 0, fft.field_mu() );
fft.draw( "grad_mu_x", 0, fft.field_grad_mu_x() );
fft.draw( "grad_mu_y", 0, fft.field_grad_mu_y() );
fft.draw( "force_x", 0, fft.field_force_x() );
fft.draw( "force_y", 0, fft.field_force_y() );
fft.draw( "vel_x", 0, fft.field_vel_x() );
fft.draw( "vel_y", 0, fft.field_vel_y() );
load_fields_from_fft( fft, Tm );
// every step
areas(Tp);
quad_coeffs(Tp , simu.FEMp() ); volumes(Tp, simu.FEMp() );
// just once!
linear algebra(Tm);
areas(Tm);
quad_coeffs(Tm , simu.FEMm() ); volumes(Tm, simu.FEMm() );
cout << "Setting up diff ops " << endl;
// TODO: Are these two needed at all?
// if(simu.create_points()) {
// nabla(Tm);
// TODO, they is, too clear why
Delta(Tm);
// }
const std::string mesh_file("mesh.dat");
const std::string particle_file("particles.dat");
// // step 0 draw.-
// draw(Tm, mesh_file , true);
// draw(Tp, particle_file , true);
cout << "Assigning alpha to particles " << endl;
#if defined FULL_FULL
{
Delta(Tp);
linear algebra_p(Tp);
from_mesh_full( Tm , Tp , algebra_p,kind::ALPHA);
}
#elif defined FULL_LUMPED
from_mesh_lumped( Tm , Tp , kind::ALPHA);
#elif defined FLIP
from_mesh(Tm , Tp , kind::ALPHA);
#else
from_mesh(Tm , Tp , kind::ALPHA);
#endif
// #if defined FULL_FULL
// {
// Delta(Tp);
// linear algebra_p(Tp);
// from_mesh_full( Tm , Tp , algebra_p,kind::ALPHA);
// }
// #elif defined FULL_LUMPED
// from_mesh_lumped( Tm , Tp , kind::ALPHA);
// #elif defined FLIP
// from_mesh(Tm , Tp , kind::ALPHA);
// #else
// from_mesh(Tm , Tp , kind::ALPHA);
// #endif
cout << "Moving info" << endl;
move_info( Tm );
move_info( Tp );
draw(Tm, mesh_file , true);
draw(Tp, particle_file , true);
// return 1;
simu.advance_time();
simu.next_step();
// bool first_iter=true;
CGAL::Timer time;
time.start();
std::ofstream log_file;
log_file.open("main.log");
bool is_overdamped = ( simu.mu() > 1 ) ; // high or low Re
for(;
simu.current_step() <= simu.Nsteps();
simu.next_step()) {
cout
<< "Step " << simu.current_step()
<< " . Time " << simu.time()
<< " ; t step " << simu.dt()
<< endl;
FT dt=simu.dt();
FT dt2 = dt / 2.0 ;
int iter=0;
FT displ=1e10;
FT min_displ=1e10;
int min_iter=0;
const int max_iter=5; //10;
const FT max_displ= 1e-8; // < 0 : disable
// leapfrog, special first step.-
// if(simu.current_step() == 1) dt2 *= 0.5;
// dt2 *= 0.5;
move_info(Tm);
move_info(Tp);
// iter loop
for( ; iter<max_iter ; iter++) {
// comment for no move.-
displ = move( Tp , dt2 );
cout << "Iter " << iter << " , moved avg " << displ << " to half point" << endl;
if( displ < min_displ) {
min_displ=displ;
min_iter=iter;
}
if( (displ < max_displ) && (iter !=0) ) break;
areas(Tp);
quad_coeffs(Tp , simu.FEMp() ); volumes(Tp, simu.FEMp() );
cout << "Proj U0, alpha0 onto mesh " << endl;
#if defined FULL
onto_mesh_full (Tp,Tm,algebra,kind::ALPHA);
#elif defined FLIP
flip_volumes(Tp , Tm , simu.FEMm() );
onto_mesh_flip (Tp,Tm,simu.FEMm(),kind::ALPHA);
#else
onto_mesh_delta (Tp,Tm,kind::ALPHA);
#endif
load_alpha_on_fft( Tm , fft );
fft.all_fields();
FT b = Db*dt2;
fft.evolve( b );
load_fields_from_fft( fft, Tm );
cout << "Proj U, alpha from mesh " << endl;
#if defined FULL_FULL
{
Delta(Tp);
linear algebra_p(Tp);
from_mesh_full_v(Tm, Tp, algebra_p , kind::U);
from_mesh_full( Tm , Tp , algebra_p,kind::ALPHA);
}
#elif defined FULL_LUMPED
from_mesh_lumped( Tm , Tp , kind::ALPHA);
from_mesh_lumped_v(Tm, Tp, kind::U);
#elif defined FLIP
from_mesh(Tm , Tp , kind::ALPHA);
from_mesh_v(Tm, Tp, kind::U);
#else
from_mesh(Tm , Tp , kind::ALPHA);
from_mesh_v(Tm, Tp, kind::U);
#endif
// // substract spurious overall movement.-
// zero_mean_v( Tm , kind::FORCE);
} // iter loop
// comment for no move.-
displ=move( Tp , dt );
update_half_velocity( Tp , false );
// comment for no move.-
// update_half_velocity( Tp , is_overdamped );
update_half_alpha( Tp );
areas(Tp);
quad_coeffs(Tp , simu.FEMp() ); volumes(Tp, simu.FEMp() );
// this, for the looks basically .-
cout << "Proj U_t+1 , alpha_t+1 onto mesh " << endl;
#if defined FULL
onto_mesh_full_v(Tp,Tm,algebra,kind::U);
onto_mesh_full (Tp,Tm,algebra,kind::ALPHA);
#elif defined FLIP
flip_volumes(Tp , Tm , simu.FEMm() );
onto_mesh_flip_v(Tp,Tm,simu.FEMm(),kind::U);
onto_mesh_flip (Tp,Tm,simu.FEMm(),kind::ALPHA);
#else
onto_mesh_delta_v(Tp,Tm,kind::U);
onto_mesh_delta (Tp,Tm,kind::ALPHA);
#endif
if(simu.current_step()%simu.every()==0) {
draw(Tm, mesh_file , true);
draw(Tp, particle_file , true);
fft.histogram( "phi", simu.current_step() , fft.field_fq() );
}
log_file
<< simu.current_step() << " "
<< simu.time() << " " ;
// integrals( Tp , log_file); log_file << " ";
// fidelity( Tp , log_file ); log_file << endl;
simu.advance_time();
} // time loop
time.stop();
log_file.close();
cout << "Total runtime: " << time.time() << endl;
return 0;
}