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;
}
