void R_s_k_2::draw_relocation() { for (Finite_vertices_iterator v = m_dt.finite_vertices_begin(); v != m_dt.finite_vertices_end(); ++v) { Vertex_handle vertex = v; if (vertex->pinned()) continue; const Point& pv = vertex->point(); v->relocated() = compute_relocation(vertex); Vector move(0.0, 0.0); Edge_circulator ecirc = m_dt.incident_edges(vertex); Edge_circulator eend = ecirc; CGAL_For_all(ecirc, eend) { Edge edge = *ecirc; if (m_dt.source_vertex(edge) != vertex) edge = m_dt.twin_edge(edge); Vector grad(0.0, 0.0); if (m_dt.get_plan(edge) == 0) grad = compute_gradient_for_plan0(edge); else grad = compute_gradient_for_plan1(edge); move = move + grad; viewer->glLineWidth(2.0f); viewer->glColor3f(1.0f, 1.0f, 0.0f); draw_edge_with_arrow(pv, pv-grad); } viewer->glLineWidth(1.0f); viewer->glColor3f(1.0f, 0.0f, 0.0f); draw_edge_with_arrow(pv, pv-move); }
void rt_display_result(RT &dt, Density density, MassMap mass) { #if (DEBUG_AURENHAMMER >= 2) typedef typename RT::Finite_vertices_iterator Finite_vertices_iterator; size_t i = 0; for (Finite_vertices_iterator it = dt.finite_vertices_begin(); it != dt.finite_vertices_end(); ++it, ++i) { std::cerr << "vertex " << (i+1) << ": mass = " << OT::mass(dt, it, density) << " (target_mass = " << mass[it->point().point()] << ")," << " weight = " << it->point().weight() << "\n"; } #endif }
Foam::boundBox Foam::cellShapeControlMesh::bounds() const { DynamicList<Foam::point> pts(number_of_vertices()); for ( Finite_vertices_iterator vit = finite_vertices_begin(); vit != finite_vertices_end(); ++vit ) { if (vit->real()) { pts.append(topoint(vit->point())); } } boundBox bb(pts); return bb; }
void Foam::cellShapeControlMesh::distribute ( const backgroundMeshDecomposition& decomposition ) { DynamicList<Foam::point> points(number_of_vertices()); DynamicList<scalar> sizes(number_of_vertices()); DynamicList<tensor> alignments(number_of_vertices()); DynamicList<Vb> farPts(8); for ( Finite_vertices_iterator vit = finite_vertices_begin(); vit != finite_vertices_end(); ++vit ) { if (vit->real()) { points.append(topoint(vit->point())); sizes.append(vit->targetCellSize()); alignments.append(vit->alignment()); } else if (vit->farPoint()) { farPts.append ( Vb ( vit->point(), -1, Vb::vtFar, Pstream::myProcNo() ) ); farPts.last().targetCellSize() = vit->targetCellSize(); farPts.last().alignment() = vit->alignment(); } } autoPtr<mapDistribute> mapDist = DistributedDelaunayMesh<CellSizeDelaunay>::distribute ( decomposition, points ); mapDist().distribute(sizes); mapDist().distribute(alignments); // Reset the entire tessellation DelaunayMesh<CellSizeDelaunay>::reset(); // Internal points have to be inserted first DynamicList<Vb> verticesToInsert(points.size()); forAll(farPts, ptI) { verticesToInsert.append(farPts[ptI]); }
Foam::cellShapeControlMesh::cellShapeControlMesh(const Time& runTime) : DistributedDelaunayMesh<CellSizeDelaunay> ( runTime, meshSubDir ), runTime_(runTime), defaultCellSize_(0.0) { if (this->vertexCount()) { fvMesh mesh ( IOobject ( meshSubDir, runTime.timeName(), runTime, IOobject::READ_IF_PRESENT, IOobject::NO_WRITE ) ); if (mesh.nPoints() == this->vertexCount()) { pointScalarField sizes ( IOobject ( "sizes", runTime.timeName(), meshSubDir, runTime, IOobject::READ_IF_PRESENT, IOobject::NO_WRITE, false ), pointMesh::New(mesh) ); triadIOField alignments ( IOobject ( "alignments", mesh.time().timeName(), meshSubDir, mesh.time(), IOobject::READ_IF_PRESENT, IOobject::AUTO_WRITE, false ) ); if ( sizes.size() == this->vertexCount() && alignments.size() == this->vertexCount() ) { for ( Finite_vertices_iterator vit = finite_vertices_begin(); vit != finite_vertices_end(); ++vit ) { vit->targetCellSize() = sizes[vit->index()]; vit->alignment() = alignments[vit->index()]; } } else { FatalErrorInFunction << "Cell size point field is not the same size as the " << "mesh." << abort(FatalError); } } } }
int main (int, char**) { CGAL::Timer t; t.start(); Iso_cuboid iso_cuboid(-0.5, -0.5, -0.5, 0.5, 0.5, 0.5); P3RT3 p3rt3(iso_cuboid); std::ifstream input_stream("data/p3rt3_point_set__s7_n800"); std::vector<Weighted_point> points_for_p3rt3; points_for_p3rt3.reserve(800); while(points_for_p3rt3.size() != 800) { Weighted_point p; input_stream >> p; points_for_p3rt3.push_back(p); } p3rt3.insert(points_for_p3rt3.begin(), points_for_p3rt3.end(), true /*large point set*/); std::cout << "--- built periodic regular triangulation" << std::endl; // Non-periodic RT3 rt3; int id = 0; for(int l=0; l<800; ++l) { for(int i=-1; i<2; i++) { for(int j=-1; j<2; j++) { for(int k=-1; k<2; k++) { Vertex_handle v = rt3.insert( p3rt3.geom_traits().construct_weighted_point_3_object()( points_for_p3rt3[l], Offset(i, j, k))); if(v != Vertex_handle()) v->info() = std::make_pair(id /*unique id*/, (i==0 && j==0 && k==0) /*canonical instance?*/); } } } id++; } std::cout << "--- built regular triangulation" << std::endl; // std::ofstream out_p3rt3("out_p3rt3.off"); // std::ofstream out_rt3("out_rt3.off"); // CGAL::write_triangulation_to_off(out_p3rt3, p3rt3); // CGAL::export_triangulation_3_to_off(out_rt3, rt3); // --------------------------------------------------------------------------- // compare vertices std::set<int> unique_vertices_from_rt3; Finite_vertices_iterator vit = rt3.finite_vertices_begin(); for(; vit!=rt3.finite_vertices_end(); ++vit) { if(vit->info().second) // is in the canonical instance unique_vertices_from_rt3.insert(vit->info().first); } std::cout << unique_vertices_from_rt3.size() << " unique vertices (rt3)" << std::endl; std::cout << p3rt3.number_of_vertices() << " unique vertices (p3rt3)" << std::endl; CGAL_assertion(unique_vertices_from_rt3.size() == p3rt3.number_of_vertices()); // compare cells std::set<std::set<int> > unique_cells_from_rt3; Finite_cells_iterator cit = rt3.finite_cells_begin(); for(; cit!=rt3.finite_cells_end(); ++cit) { std::set<int> cell; bool has_a_point_in_canonical_domain = false; for(int i=0; i<4; i++) { Vertex_handle v = cit->vertex(i); cell.insert(v->info().first); if(v->info().second) has_a_point_in_canonical_domain = true; } if(has_a_point_in_canonical_domain) unique_cells_from_rt3.insert(cell); } std::cout << unique_cells_from_rt3.size() << " unique cells (rt3)" << std::endl; std::cout << p3rt3.number_of_cells() << " unique cells (p3rt3)" << std::endl; CGAL_assertion(unique_cells_from_rt3.size() == p3rt3.number_of_cells()); std::cout << t.time() << " sec." << std::endl; std::cout << "EXIT SUCCESS" << std::endl; return EXIT_SUCCESS; }