GEdgeSigned nextOne(GEdgeSigned *thisOne, std::list<GEdge*> &wire)
{
if(!thisOne){
GEdge *ge = *(wire.begin());
wire.erase(wire.begin());
return GEdgeSigned(1, ge);
}
GVertex *gv = thisOne->getEndVertex();
std::list<GEdge*> possibleChoices;
std::list<GEdge*>::iterator it = wire.begin();
std::list<GEdge*>::iterator ite = wire.end();
while(it != ite){
GEdge *ge = *it;
GVertex *v1 = ge->getBeginVertex();
GVertex *v2 = ge->getEndVertex();
if(v1 == gv || v2 == gv) possibleChoices.push_back(ge);
++it;
}
it = possibleChoices.begin();
ite = possibleChoices.end();
while(it != ite){
GEdge *ge = *it;
if(countInList(possibleChoices, ge) == 2){
wire.erase(std::remove_if(wire.begin(), wire.end(),
std::bind2nd(std::equal_to<GEdge*>(), ge)),
wire.end());
wire.push_back(ge);
GVertex *v1 = ge->getBeginVertex();
GVertex *v2 = ge->getEndVertex();
if(v1 == gv) return GEdgeSigned(1, ge);
if(v2 == gv) return GEdgeSigned(-1, ge);
Msg::Error("Something wrong in edge loop 1");
thisOne->print();
}
++it;
}
it = possibleChoices.begin();
ite = possibleChoices.end();
while(it != ite){
GEdge *ge = *it;
if(ge != thisOne->ge){
wire.erase(std::remove_if(wire.begin(),wire.end(),
std::bind2nd(std::equal_to<GEdge*>(), ge)),
wire.end());
GVertex *v1 = ge->getBeginVertex();
GVertex *v2 = ge->getEndVertex();
if(v1 == gv) return GEdgeSigned(1, ge);
if(v2 == gv) return GEdgeSigned(-1, ge);
Msg::Error("Something wrong in edge loop 2");
thisOne->print();
}
++it;
}
// should never end up here
return GEdgeSigned(0, 0);
}
// compute the mesh size at a given vertex due to prescribed sizes at
// mesh vertices
static double LC_MVertex_PNTS(GEntity *ge, double U, double V)
{
switch(ge->dim()){
case 0:
{
GVertex *gv = (GVertex *)ge;
double lc = gv->prescribedMeshSizeAtVertex();
// FIXME we might want to remove this to make all lc treatment consistent
if(lc >= MAX_LC) return CTX::instance()->lc / 10.;
return lc;
}
case 1:
{
GEdge *ged = (GEdge *)ge;
GVertex *v1 = ged->getBeginVertex();
GVertex *v2 = ged->getEndVertex();
if (v1 && v2){
Range<double> range = ged->parBounds(0);
double a = (U - range.low()) / (range.high() - range.low());
double lc = (1 - a) * v1->prescribedMeshSizeAtVertex() +
(a) * v2->prescribedMeshSizeAtVertex() ;
// FIXME we might want to remove this to make all lc treatment consistent
if(lc >= MAX_LC) return CTX::instance()->lc / 10.;
return lc;
}
else
return MAX_LC;
}
default:
return MAX_LC;
}
}
void GEdgeCompound::orderEdges()
{
std::vector<GEdge*> _c ;
std::list<GEdge*> edges ;
for (unsigned int i = 0; i < _compound.size(); i++){
edges.push_back(_compound[i]);
}
// find a lonely edge
std::map<GVertex*, GEdge*> tempv;
for (std::list<GEdge*>::iterator it = edges.begin() ; it != edges.end() ; ++it){
GVertex *v1 = (*it)->getBeginVertex();
GVertex *v2 = (*it)->getEndVertex();
if(!v1 || !v2){
Msg::Error("Compounds don't support curves without two bounding vertices");
return;
}
std::map<GVertex*, GEdge*>::iterator it1 = tempv.find(v1);
if (it1 == tempv.end()) {
tempv.insert(std::make_pair(v1, *it));
}
else tempv.erase(it1);
std::map<GVertex*, GEdge*>::iterator it2 = tempv.find(v2);
if (it2 == tempv.end()){
tempv.insert(std::make_pair(v2, *it));
}
else tempv.erase(it2);
}
// find the first GEdge and erase it from the list edges
GEdge *firstEdge;
if (tempv.size() == 2){ // non periodic
firstEdge = (tempv.begin())->second;
for (std::list<GEdge*>::iterator it = edges.begin() ; it != edges.end() ; ++it){
if (*it == firstEdge){
edges.erase(it);
break;
}
}
}
else if (tempv.size() == 0){ // periodic
firstEdge = *(edges.begin());
edges.erase(edges.begin());
}
else{
Msg::Error("EdgeCompound %d is wrong (it has %d end points)", tag(), tempv.size());
return;
}
// loop over all segments to order segments and store it in the list _c
_c.push_back(firstEdge);
_orientation.push_back(1);
GVertex *first = _c[0]->getBeginVertex();
GVertex *last = _c[0]->getEndVertex();
while (first != last){
if (edges.empty())break;
bool found = false;
for (std::list<GEdge*>::iterator it = edges.begin() ; it != edges.end() ; ++it){
GEdge *e = *it;
std::list<GEdge*>::iterator itp;
if (e->getBeginVertex() == last){
_c.push_back(e);
itp = it;
it++;
edges.erase(itp);
_orientation.push_back(1);
last = e->getEndVertex();
found = true;
break;
}
else if (e->getEndVertex() == last){
_c.push_back(e);
itp = it;
it++;
edges.erase(itp);
_orientation.push_back(0);
last = e->getBeginVertex();
found = true;
break;
}
}
if (!found){
if (_c.size() == 1 && _orientation[0]){
GVertex *temp = first;
first = last;
last = temp;
_orientation[0] = 0;
}
else {
Msg::Error("Compound Edge %d is wrong", tag());
return;
}
}
}
//edges is now a list of ordered GEdges
_compound = _c;
// special case reverse orientation
if (_compound.size() < 2) return;
if (_orientation[0] && _compound[0]->getEndVertex() != _compound[1]->getEndVertex()
&& _compound[0]->getEndVertex() != _compound[1]->getBeginVertex()){
for (unsigned int i = 0; i < _compound.size(); i++){
_orientation[i] = !_orientation[i] ;
}
}
}
gmshFace::gmshFace(GModel *m, Surface *face)
: GFace(m, face->Num), s(face), isSphere(false), radius(0.)
{
resetMeshAttributes();
// edgeCounterparts = s->edgeCounterparts;
// affineTransform = s->affineTransform;
std::vector<GEdge*> eds;
std::vector<int> nums;
for(int i = 0; i < List_Nbr(s->Generatrices); i++){
Curve *c;
List_Read(s->Generatrices, i, &c);
GEdge *e = m->getEdgeByTag(abs(c->Num));
if(e){
eds.push_back(e);
nums.push_back(c->Num);
}
else
Msg::Error("Unknown curve %d", c->Num);
}
for(int i = 0; i < List_Nbr(s->GeneratricesByTag); i++){
int j;
List_Read(s->GeneratricesByTag, i, &j);
GEdge *e = m->getEdgeByTag(abs(j));
if(e){
eds.push_back(e);
nums.push_back(j);
}
else
Msg::Error("Unknown curve %d", j);
}
std::list<GEdge*> l_wire;
GVertex *first = 0;
for(unsigned int i = 0; i < eds.size(); i++){
GEdge *e = eds[i];
int num = nums[i];
GVertex *start = (num > 0) ? e->getBeginVertex() : e->getEndVertex();
GVertex *next = (num > 0) ? e->getEndVertex() : e->getBeginVertex();
if (!first) first = start;
l_wire.push_back(e);
if (next == first){
edgeLoops.push_back(GEdgeLoop(l_wire));
l_wire.clear();
first = 0;
}
l_edges.push_back(e);
e->addFace(this);
l_dirs.push_back((num > 0) ? 1 : -1);
if (List_Nbr(s->Generatrices) == 2){
e->meshAttributes.minimumMeshSegments =
std::max(e->meshAttributes.minimumMeshSegments, 2);
}
}
// always compute and store the mean plane for plane surfaces (using
// the bounding vertices)
if(s->Typ == MSH_SURF_PLAN) computeMeanPlane();
if(s->EmbeddedCurves){
for(int i = 0; i < List_Nbr(s->EmbeddedCurves); i++){
Curve *c;
List_Read(s->EmbeddedCurves, i, &c);
GEdge *e = m->getEdgeByTag(abs(c->Num));
if(e)
addEmbeddedEdge(e);
else
Msg::Error("Unknown curve %d", c->Num);
}
}
if(s->EmbeddedPoints){
for(int i = 0; i < List_Nbr(s->EmbeddedPoints); i++){
Vertex *v;
List_Read(s->EmbeddedPoints, i, &v);
GVertex *gv = m->getVertexByTag(v->Num);
if(gv)
embedded_vertices.push_back(gv);
else
Msg::Error("Unknown point %d", v->Num);
}
}
isSphere = iSRuledSurfaceASphere(s, center, radius);
}