static double _relocateVertex(GFace *gf, MVertex *ver,
const std::vector<MElement *> <, double tol)
{
if(ver->onWhat()->dim() != 2) return 2.0;
SPoint2 p1(0, 0);
SPoint2 p2;
if(ver->getParameter(0, p2[0])) {
ver->getParameter(1, p2[1]);
}
else {
return _relocateVertex2(gf, ver, lt, tol);
}
std::size_t counter = 0;
for(std::size_t i = 0; i < lt.size(); i++) {
for(std::size_t j = 0; j < lt[i]->getNumVertices(); j++) {
MVertex *v = lt[i]->getVertex(j);
SPoint2 pp;
reparamMeshVertexOnFace(v, gf, pp);
counter++;
if(v->onWhat()->dim() == 1) {
GEdge *ge = dynamic_cast<GEdge *>(v->onWhat());
// do not take any chance
if(ge->isSeam(gf)) return 2.0;
}
p1 += pp;
}
}
p1 *= 1. / (double)counter;
double worst;
double xi = Maximize_Quality_Golden_Section(ver, gf, p1, p2, lt, tol, worst);
// if (xi != 0) printf("xi = %g\n",xi);
SPoint2 p = p1 * (1 - xi) + p2 * xi;
GPoint pp = gf->point(p);
if(!pp.succeeded()) return 2.0;
ver->x() = pp.x();
ver->y() = pp.y();
ver->z() = pp.z();
ver->setParameter(0, pp.u());
ver->setParameter(1, pp.v());
return worst;
}
void Filler2D::pointInsertion2D(GFace* gf, vector<MVertex*> &packed,
vector<SMetric3> &metrics)
{
// NB/ do not use the mesh in GFace, use the one in backgroundMesh2D!
// if(debug) cout << " ------------------ OLD -------------------" << endl;
// stringstream ssa;
//// ssa << "oldbgm_angles_" << gf->tag() << ".pos";
//// backgroundMesh::current()->print(ssa.str(),gf,1);
// ssa << "oldbgm_sizes_" << gf->tag() << ".pos";
// backgroundMesh::current()->print(ssa.str(),gf,0);
//
//
//
//
// if(debug) cout << " ------------------ NEW -------------------" << endl;
// backgroundMesh2D *bgm2 = dynamic_cast<backgroundMesh2D*>(BGMManager::get(gf));
// stringstream ss2;
// ss2 << "basebg_sizefield_" << gf->tag() << ".pos";
// bgm2->exportSizeField(ss2.str());
//
//
//
// return;
//
BGMManager::set_use_cross_field(true);
const bool goNonLinear = true;
const bool debug=false;
const bool export_stuff=true;
if (debug) cout << "ENTERING POINTINSERTION2D" << endl;
double a;
// acquire background mesh
if(debug) cout << "pointInsertion2D: recover BGM" << endl;
a=Cpu();
frameFieldBackgroundMesh2D *bgm =
dynamic_cast<frameFieldBackgroundMesh2D*>(BGMManager::get(gf));
time_bgm_and_smoothing += (Cpu() - a);
if (!bgm){
Msg::Error("BGM dynamic cast failed in filler2D::pointInsertion2D");
return;
}
// export BGM size field
if(export_stuff){
cout << "pointInsertion2D: export size field " << endl;
stringstream ss;
ss << "bg2D_sizefield_" << gf->tag() << ".pos";
bgm->exportSizeField(ss.str());
cout << "pointInsertion2D : export crossfield " << endl;
stringstream sscf;
sscf << "bg2D_crossfield_" << gf->tag() << ".pos";
bgm->exportCrossField(sscf.str());
cout << "pointInsertion2D : export smoothness " << endl;
stringstream sss;
sss << "bg2D_smoothness_" << gf->tag() << ".pos";
bgm->exportSmoothness(sss.str());
}
// point insertion algorithm:
a=Cpu();
// for debug check...
int priority_counter=0;
map<MVertex*,int> vert_priority;
// get all the boundary vertices
if(debug) cout << "pointInsertion2D : get bnd vertices " << endl;
set<MVertex*> bnd_vertices = bgm->get_vertices_of_maximum_dim(1);
// put boundary vertices in a fifo queue
set<smoothness_point_pair, compareSurfacePointWithExclusionRegionPtr_Smoothness> fifo;
vector<surfacePointWithExclusionRegion*> vertices;
// initiate the rtree
if(debug) cout << "pointInsertion2D : initiate RTree " << endl;
RTree<surfacePointWithExclusionRegion*,double,2,double> rtree;
SMetric3 metricField(1.0);
SPoint2 newp[4][NUMDIR];
set<MVertex*>::iterator it = bnd_vertices.begin() ;
for (; it != bnd_vertices.end() ; ++it){
SPoint2 midpoint;
computeFourNeighbors(bgm,*it, midpoint, goNonLinear, newp, metricField);
surfacePointWithExclusionRegion *sp = new surfacePointWithExclusionRegion
(*it, newp, midpoint,metricField);
smoothness_point_pair mp;
mp.ptr = sp;
mp.rank=(1.-bgm->get_smoothness(midpoint[0],midpoint[1]));
fifo.insert(mp);
vertices.push_back(sp);
double _min[2],_max[2];
sp->minmax(_min,_max);
rtree.Insert(_min,_max,sp);
}
// ---------- main loop -----------------
while(!fifo.empty()){
if(debug) cout << " -------- fifo.size() = " << fifo.size() << endl;
int count_nbaddedpt = 0;
surfacePointWithExclusionRegion * parent = (*fifo.begin()).ptr;
fifo.erase(fifo.begin());
for (int dir=0;dir<NUMDIR;dir++){
for (int i=0;i<4;i++){
if (!inExclusionZone (parent->_p[i][dir], rtree, vertices) ){
GPoint gp = gf->point(parent->_p[i][dir]);
MFaceVertex *v = new MFaceVertex(gp.x(),gp.y(),gp.z(),gf,gp.u(),gp.v());
SPoint2 midpoint;
computeFourNeighbors(bgm,v, midpoint, goNonLinear, newp, metricField);
surfacePointWithExclusionRegion *sp = new surfacePointWithExclusionRegion
(v, newp, midpoint, metricField, parent);
smoothness_point_pair mp;mp.ptr = sp;mp.rank=(1.-bgm->get_smoothness(gp.u(),gp.v()));
if (debug) vert_priority[v] = priority_counter++;
fifo.insert(mp);
vertices.push_back(sp);
double _min[2],_max[2];
sp->minmax(_min,_max);
rtree.Insert(_min,_max,sp);
if (debug){
cout << " adding node (" << sp->_v->x() << "," << sp->_v->y()
<< "," << sp->_v->z() << ")" << endl;
cout << " ----------------------------- sub --- fifo.size() = "
<< fifo.size() << endl;
}
count_nbaddedpt++;
}
}
}
if(debug) cout << "////////// nbre of added point: " << count_nbaddedpt << endl;
}
time_insertion += (Cpu() - a);
if (debug){
stringstream ss;
ss << "priority_" << gf->tag() << ".pos";
print_nodal_info(ss.str().c_str(),vert_priority);
ss.clear();
}
// add the vertices as additional vertices in the
// surface mesh
char ccc[256]; sprintf(ccc,"points%d.pos",gf->tag());
FILE *f = Fopen(ccc,"w");
if(f){
fprintf(f,"View \"\"{\n");
for (unsigned int i=0;i<vertices.size();i++){
vertices[i]->print(f,i);
if(vertices[i]->_v->onWhat() == gf) {
packed.push_back(vertices[i]->_v);
metrics.push_back(vertices[i]->_meshMetric);
SPoint2 midpoint;
reparamMeshVertexOnFace(vertices[i]->_v, gf, midpoint);
}
delete vertices[i];
}
fprintf(f,"};");
fclose(f);
}
}
