added automatic computation of transfinite corners

Geo/GFace.cpp

@@ -146,6 +146,45 @@ std::list<GVertex*> GFace::vertices() const
   return ret;
 }
 
+std::vector<std::pair<GEdge*, int> > GFace::sortedEdges() const
+{
+  std::vector<std::pair<GEdge*, int> > sorted;
+
+  if(l_dirs.size() == l_edges.size()){
+    std::vector<std::pair<GEdge*, int> > tmp;
+    std::list<GEdge*>::const_iterator ite = l_edges.begin();
+    std::list<int>::const_iterator itd = l_dirs.begin();
+    while(ite != l_edges.end()){
+      tmp.push_back(std::pair<GEdge*, int>(*ite, *itd));
+      ite++; itd++;
+    }
+    if(tmp.size()){
+      sorted.push_back(tmp.front());
+      tmp.erase(tmp.begin());
+      int check = 0;
+      while(sorted.size() < l_edges.size()){
+        if(++check > l_edges.size()){
+          Msg::Warning("Aborting sorted edge computation");
+          break;
+        }
+        GVertex *v1 = (sorted.back().second > 0) ? sorted.back().first->getEndVertex() : 
+          sorted.back().first->getBeginVertex();
+        for(std::vector<std::pair<GEdge*, int> >::iterator it = tmp.begin(); 
+            it != tmp.end(); it++){
+          GVertex *v2 = (it->second > 0) ? it->first->getBeginVertex() :
+            it->first->getEndVertex();
+          if(v1 == v2){
+            sorted.push_back(*it);
+            tmp.erase(it);
+            break;
+          }
+        }
+      }
+    }
+  }
+  return sorted;
+}
+
 void GFace::setVisibility(char val, bool recursive)
 {
   GEntity::setVisibility(val);

Geo/GFace.h

@@ -73,6 +73,9 @@ class GFace : public GEntity
   // edges that bound the face
   virtual std::list<GEdge*> edges() const { return l_edges; }
 
+  // edges that bound the face, sorted in a loop, with orientation
+  virtual std::vector<std::pair<GEdge*, int> > sortedEdges() const;
+
   // edges that are embedded in the face
   virtual std::list<GEdge*> embeddedEdges() const { return embedded_edges; }
 

Mesh/meshGFaceTransfinite.cpp

@@ -43,19 +43,33 @@ int MeshTransfiniteSurface(GFace *gf)
 
   Msg::StatusBar(2, true, "Meshing surface %d (transfinite)", gf->tag());
 
-  std::vector<MVertex*> corners, d_vertices;
-  std::vector<int> indices;
+  std::vector<MVertex*> corners;
 
+  if(gf->meshAttributes.corners.size()){
+    // corners have been specified explicitly
     for(unsigned int i = 0; i < gf->meshAttributes.corners.size(); i++)
       corners.push_back(gf->meshAttributes.corners[i]->mesh_vertices[0]);
-
-  computeEdgeLoops(gf, d_vertices, indices);
+  }
+  else{
+    // try to find the corners automatically
+    std::vector<std::pair<GEdge*, int> > bnd = gf->sortedEdges();
+    for(unsigned int i = 0; i < bnd.size(); i++)
+      if(bnd[i].second > 0)
+        corners.push_back(bnd[i].first->getBeginVertex()->mesh_vertices[0]);
+      else
+        corners.push_back(bnd[i].first->getEndVertex()->mesh_vertices[0]);
+  }
 
   if(corners.size () != 3 && corners.size () != 4){
     Msg::Error("Surface %d is transfinite but has %d corners",
 	       gf->tag(), corners.size());
     return 0;
   }
+
+  std::vector<MVertex*> d_vertices;
+  std::vector<int> indices;
+  computeEdgeLoops(gf, d_vertices, indices);
+
   if(indices.size () != 2){
     Msg::Error("Surface %d is transfinite but has %d holes",
 	       gf->tag(), indices.size() - 2);

Parser/Gmsh.y

@@ -109,7 +109,8 @@ void FixRelativePath(const char *in, char *out);
 %type <l> FExpr_Multi ListOfDouble RecursiveListOfDouble
 %type <l> RecursiveListOfListOfDouble 
 %type <l> ListOfColor RecursiveListOfColor 
-%type <l> ListOfShapes Transform Extrude MultipleShape RuledSurfaceOptions
+%type <l> ListOfShapes Transform Extrude MultipleShape 
+%type <l> TransfiniteCorners RuledSurfaceOptions
 %type <s> Shape
 
 // Operators (with ascending priority): cf. C language
@@ -2453,6 +2454,15 @@ TransfiniteArrangement :
     }
 ;
 
+TransfiniteCorners :
+   {
+     $$ = List_Create(1, 1, sizeof(double));
+   }
+ | tAFFECT ListOfDouble
+   {
+     $$ = $2;
+   }
+
 RecombineAngle : 
     {
       $$ = 45;
@@ -2493,49 +2503,53 @@ Transfinite :
       }
       List_Delete($3);
     }
-  | tTransfinite tSurface '{' FExpr '}' tAFFECT ListOfDouble TransfiniteArrangement tEND
+  | tTransfinite tSurface ListOfDouble TransfiniteCorners TransfiniteArrangement tEND
     {
-      int k = List_Nbr($7);
-      if(k != 3 && k != 4){
-        yymsg(0, "Wrong definition of Transfinite Surface %d: "
-              "%d points instead of 3 or 4" , (int)$4, k);
+      int k = List_Nbr($4);
+      if(k != 0 && k != 3 && k != 4){
+        yymsg(0, "Wrong definition of Transfinite Surface: 0, 3 or 4 points needed");
       }
       else{
-        Surface *s = FindSurface((int)$4);
+        for(int i = 0; i < List_Nbr($3); i++){
+          double d;
+          List_Read($3, i, &d);
+          Surface *s = FindSurface((int)d);
           if(s){
             s->Method = MESH_TRANSFINITE;
-          s->Recombine_Dir = $8;
+            s->Recombine_Dir = $5;
             List_Reset(s->TrsfPoints);
-	  for(int i = 0; i < k; i++){
-	    double d;
-	    List_Read($7, i, &d);
-	    Vertex *v = FindPoint((int)fabs(d));
+            for(int j = 0; j < k; j++){
+              double p;
+              List_Read($4, j, &p);
+              Vertex *v = FindPoint((int)fabs(p));
               if(v)
                 List_Add(s->TrsfPoints, &v);
               else
-	      yymsg(0, "Unknown point %d", (int)fabs(d));
+                yymsg(0, "Unknown point %d", (int)fabs(p));
             }
           }
           else{
-	  GFace *gf = GModel::current()->getFaceByTag((int)$4);
+            GFace *gf = GModel::current()->getFaceByTag((int)d);
             if(gf){
               gf->meshAttributes.Method = MESH_TRANSFINITE;
-            gf->meshAttributes.transfiniteArrangement = $8;
-            for(int i = 0; i < k; i++){
-              double d;
-              List_Read($7, i, &d);
-              GVertex *gv = GModel::current()->getVertexByTag((int)fabs(d));
+              gf->meshAttributes.transfiniteArrangement = $5;
+              for(int j = 0; j < k; j++){
+                double p;
+                List_Read($4, j, &p);
+                GVertex *gv = GModel::current()->getVertexByTag((int)fabs(p));
                 if(gv)
                   gf->meshAttributes.corners.push_back(gv);
                 else
-                yymsg(0, "Unknown point %d", (int)fabs(d));
+                  yymsg(0, "Unknown point %d", (int)fabs(p));
               }
             }
             else
-	    yymsg(0, "Unknown surface %d", (int)$4);
+              yymsg(0, "Unknown surface %d", (int)d);
           }
         }
-      List_Delete($7);
+      }
+      List_Delete($3);
+      List_Delete($4);
     }
   | tElliptic tSurface '{' FExpr '}' tAFFECT ListOfDouble tEND
     {

benchmarks/step/tank.geo

-Merge "tank.brep";
+Merge "benchmarks/step/tank.brep";
 
 n = 2;
 
@@ -27,51 +27,13 @@ Transfinite Line {20} = n3;
 
 Transfinite Line {25, 53, 39} = 2*(n1-1) + 4*(n2-1) + (n3-1) + 1;
 
-Transfinite Surface {19} = {21,20,36,35};
+// automatic corners:
+Transfinite Surface {1:6, 8:10, 12:13, 15:20, 23:33, 35:48};
+
+// manual corners:
 Transfinite Surface {7} = {18,19,20,21};
-Transfinite Surface {2} = {1,5,6,2};
-Transfinite Surface {6} = {2,6,13,7};
-Transfinite Surface {13} = {7,13,14,11};
-Transfinite Surface {8} = {11,14,1,5};
-Transfinite Surface {1} = {1,2,3,4};
-Transfinite Surface {3} = {2,7,8,3};
-Transfinite Surface {9} = {7,11,12,8};
-Transfinite Surface {5} = {12,11,1,4};
-Transfinite Surface {16} = {17,16,29,30};
-Transfinite Surface {15} = {29,16,15,28};
-Transfinite Surface {27} = {28,15,27,39};
-Transfinite Surface {26} = {39,27,30,17};
-Transfinite Surface {29} = {30,29,41,42};
-Transfinite Surface {28} = {29,28,40,41};
-Transfinite Surface {40} = {28,39,51,40};
-Transfinite Surface {39} = {39,30,42,51};
-Transfinite Surface {17} = {18,31,32,19};
-Transfinite Surface {18} = {20,19,34,33};
-Transfinite Surface {31} = {19,32,45,34};
-Transfinite Surface {32} = {36,20,33,46};
-Transfinite Surface {24} = {33,34,26,25};
-Transfinite Surface {36} = {46,33,25,37};
-Transfinite Surface {23} = {25,21,35,37};
-Transfinite Surface {25} = {31,18,26,38};
-Transfinite Surface {37} = {26,34,45,38};
 Transfinite Surface {14} = {21,25,26,18};
-Transfinite Surface {38} = {31,38,50,43};
-Transfinite Surface {30} = {31,32,44,43};
-Transfinite Surface {43} = {32,44,55,45};
-Transfinite Surface {46} = {50,38,45,55};
-Transfinite Surface {33} = {35,36,47,48};
-Transfinite Surface {35} = {35,48,49,37};
-Transfinite Surface {44} = {36,47,56,46};
-Transfinite Surface {45} = {46,56,49,37};
-Transfinite Surface {41} = {40,53,52,41};
-Transfinite Surface {42} = {41,42,54,52};
-Transfinite Surface {48} = {53,40,51,57};
-Transfinite Surface {47} = {57,54,42,51};
-Transfinite Surface {12} = {4,9,24,12};
-Transfinite Surface {20} = {24,12,8,22};
-Transfinite Surface {4} = {4,9,10,3};
-Transfinite Surface {10} = {10,3,22,8};
-
-Recombine Surface{1:52};
 
 Mesh.Smoothing = 10;
+
+Recombine Surface{1:52};

doc/texinfo/gmsh.texi

@@ -2092,9 +2092,10 @@ line.
 Selects the surface @var{expression} to be meshed with the 2D
 transfinite algorithm. The @var{expression-list} should contain the
 identification numbers of three or four points on the boundary of the
-surface, defining the corners of the transfinite interpolation. The
-optional argument specifies the way the triangles are oriented when the
-mesh is not recombined.
+surface, defining the corners of the transfinite interpolation. If no
+identfication numbers are given, the transfinite algorithm will try to
+find the corners automatically. The optional argument specifies the way
+the triangles are oriented when the mesh is not recombined.
 
 @item Transfinite Volume @{ @var{expression} @} = @{ @var{expression-list} @};
 Selects a five- or six-face volume @var{expression} to be meshed with