Transform: translate comments in consSmooth

benoit128 · benoit128 · commit 3d467079054b · 2026-03-23T09:38:54.000+01:00
diff --git a/Cassiopee/Post/Post/Post.py b/Cassiopee/Post/Post/Post.py
@@ -387,7 +387,6 @@ def computeVariables(array, varname,
     else:
         return post.computeVariables(array, varname, gamma, rgp, s0, betas, Cs, mus, Ts)
 
-
 def computeVariables2(array, varname,
                       gamma=1.4, rgp=287.053, s0=0., betas=1.458e-6,
                       Cs=110.4, mus=1.76e-5, Ts=273.15):
diff --git a/Cassiopee/Transform/Transform/PyTree.py b/Cassiopee/Transform/Transform/PyTree.py
@@ -206,13 +206,13 @@ def _smooth(t, eps=0.5, niter=4, type=0, fixedConstraints=[],
     C.setFields(coordsp, t, 'nodes', writeDim=False)
     return None
 
-def consSmooth(t, sweeps, retour=0, pas=1):
+def consSmooth(t, sweeps, twoWays=False, step=1):
     """Conservative smoothing."""
-    return C.TZGC3(t, 'nodes', False, Transform.consSmooth, sweeps, retour, pas)
+    return C.TZGC3(t, 'nodes', False, Transform.consSmooth, sweeps, twoWays, step)
 
-def _consSmooth(t, sweeps, retour=0, pas=1):
+def _consSmooth(t, sweeps, twoWays=False, step=1):
     """Conservative smoothing."""
-    return C._TZGC3(t, 'nodes', False, Transform.consSmooth, sweeps, retour, pas)
+    return C._TZGC3(t, 'nodes', False, Transform.consSmooth, sweeps, twoWays, step)
 
 def deform(t, vector=['dx','dy','dz']):
     """Deform surface by moving surface of the vector (dx, dy, dz).
diff --git a/Cassiopee/Transform/Transform/Transform.py b/Cassiopee/Transform/Transform/Transform.py
@@ -416,13 +416,13 @@ def smooth(a, eps=0.5, niter=4, type=0, fixedConstraints=[],
         return transform.smooth(a, eps, niter, type, fixedConstraint,
                                 projConstraint, delta, point, radius)
 
-def consSmooth(a, sweeps, retour=0, pas=1):
+def consSmooth(a, sweeps, twoWays=False, step=1):
     """Conservative smoothing."""
     if isinstance(a[0], list):
         for i in a:
-            transform.consSmooth(i, sweeps, retour, pas)
+            transform.consSmooth(i, sweeps, twoWays, step)
     else:
-        return transform.consSmooth(a, sweeps, retour, pas)
+        return transform.consSmooth(a, sweeps, twoWays, step)
     return None
 
 def projectAllDirs(arrays, surfaces, vect=['nx','ny','nz'], oriented=0):
diff --git a/Cassiopee/Transform/Transform/consSmooth.cpp b/Cassiopee/Transform/Transform/consSmooth.cpp
@@ -22,7 +22,7 @@ using namespace K_FLD;
 using namespace K_SEARCH;
 
 //=============================================================================
-/* Déclarations et Fonctions */
+/* Local functions */
 //=============================================================================
 
 inline bool isSamePoint(E_Float p1x, E_Float p1y, E_Float p1z, E_Float p2x, E_Float p2y, E_Float p2z) 
@@ -32,21 +32,21 @@ inline bool isSamePoint(E_Float p1x, E_Float p1y, E_Float p1z, E_Float p2x, E_Fl
 
 // ============================================================================
 /* Conservative smoothing (Kuprat)*/
-// IN: array  : maillage (structuré i-array ou non-structuré 1D dans le plan (x,y))
-// IN: sweeps : nombre de passes de lissage
-// IN: retour : 0 = lissage aller seulement, 1 = lissage aller + retour (default à 0, donne un lissage assymétrique) 
-// IN: pas    : incrément de parcours (1, 2 ou 3) mis à 1 par default
-// OUT: tableau lissé (même connectivité, coordonnées modifiées, type conservé)
+// IN: array: mesh (Structured i-array ou unstructured 1D in the (x,y) plane)
+// IN: sweeps: number of smoothing sweeps
+// IN: twoWays: 0 = one way smoothing, 1 = one way and back (default 0, may lead to assymetry) 
+// IN: step: way step (1, 2 ou 3) default 1
+// OUT: smoothed mesh (same as input)
 // ============================================================================
 PyObject* K_TRANSFORM::consSmooth(PyObject* self, PyObject* args)
 {
   PyObject* array;
 
   E_Int sweeps = 1;
-  E_Int pas = 2;
-  E_Int retour = 1;
+  E_Int step = 2;
+  E_Int twoWays = 1;
   
-  if (!PYPARSETUPLE_(args, O_ III_, &array, &sweeps,  &retour, &pas))
+  if (!PYPARSETUPLE_(args, O_ III_, &array, &sweeps,  &twoWays, &step))
   {
     return NULL;
   }
@@ -78,14 +78,14 @@ PyObject* K_TRANSFORM::consSmooth(PyObject* self, PyObject* args)
   }
   posx++; posy++; posz++;
 
-  if (retour != 0 && retour != 1)
+  if (twoWays != 0 && twoWays != 1)
   {
     PyErr_SetString(PyExc_TypeError,
-                    "consSmooth: int retour is invalid.");
+                    "consSmooth: int twoWays is invalid.");
     return NULL;
   }
 
-  if (pas < 1 && pas > 3)
+  if (step < 1 && step > 3)
   {
     PyErr_SetString(PyExc_TypeError,
                     "consSmooth: int step is invalid.");
@@ -97,7 +97,7 @@ PyObject* K_TRANSFORM::consSmooth(PyObject* self, PyObject* args)
   FldArrayF* fo;
   FldArrayI* cno = NULL;
 
-  if (res == 1) // structure
+  if (res == 1) // structured
   {
     tpl = K_ARRAY::buildArray3(*f, varString, im, jm, km, f->getApi());
     K_ARRAY::getFromArray3(tpl, fo);
@@ -113,9 +113,9 @@ PyObject* K_TRANSFORM::consSmooth(PyObject* self, PyObject* args)
     E_Int idx2;
     E_Int idx3;
 
-    // Ouvert ou fermé ?
+    // open or closed ?
     E_Float dx = x[1]-x[0], dy = y[1]-y[0], dz = z[1]-z[0];
-    E_Float refL = std::sqrt(dx*dx + dy*dy + dz*dz); // longueur du 1er segment
+    E_Float refL = std::sqrt(dx*dx + dy*dy + dz*dz); // length of first segment
 
     E_Float distBouts = std::sqrt((x[0]-x[npts-1])*(x[0]-x[npts-1]) + (y[0]-y[npts-1])*(y[0]-y[npts-1]) + (z[0]-z[npts-1])*(z[0]-z[npts-1]));
 
@@ -127,16 +127,16 @@ PyObject* K_TRANSFORM::consSmooth(PyObject* self, PyObject* args)
     for (E_Int k = 0; k < sweeps; k++)
     {
 
-      for (E_Int j = 0; j < retour + 1; j++)
+      for (E_Int j = 0; j < twoWays + 1; j++)
       {
         
-        for (E_Int i = start; i < end; i = i + pas)
+        for (E_Int i = start; i < end; i = i + step)
         {
           
           if (ouvert == 0)
 
           {
-            // Cyclique, toujours dans [0, nUnique-1]
+            // Cycle, always in [0, nUnique-1]
             idx0 = (j == 0) ? i % nUnique : (nUnique - i % nUnique) % nUnique;
             idx1 = (j == 0) ? (i + 1) % nUnique : (nUnique - ((i + 1)   % nUnique)) % nUnique;
             idx2 = (j == 0) ? (i + 2) % nUnique : (nUnique - ((i + 2)   % nUnique)) % nUnique;
@@ -150,26 +150,26 @@ PyObject* K_TRANSFORM::consSmooth(PyObject* self, PyObject* args)
             idx3 = (j == 0) ? (i + 3)  : (nUnique-1) - (i + 3) ;
           }
 
-          /* On récupère les coordonnées des points i, i+1, i+2, i+3 */
+          /* Get points i, i+1, i+2, i+3 */
           E_Float xi = x[idx0]; E_Float yi = y[idx0]; E_Float zi = z[idx0]; 
           E_Float xip1 = x[idx1]; E_Float yip1 = y[idx1]; E_Float zip1 = z[idx1]; 
           E_Float xip2 = x[idx2]; E_Float yip2 = y[idx2]; E_Float zip2 = z[idx2]; 
           E_Float xip3 = x[idx3]; E_Float yip3 = y[idx3]; E_Float zip3 = z[idx3];
 
-          /* On calcule les différences de points qui nous interessent (i+3 - i), (i+2 - i) et (i+1 - i) */
+          /* Compute deltas (i+3 - i), (i+2 - i) et (i+1 - i) */
           E_Float dv1x = xip1 - xi; E_Float dv1y = yip1 - yi; E_Float dv1z = zip1 - zi; /* xi+1 - xi */
           E_Float dv2x = xip2 - xi; E_Float dv2y = yip2 - yi; E_Float dv2z = zip2 - zi; /* xi+2 - xi */
           E_Float dv3x = xip3 - xi; E_Float dv3y = yip3 - yi; E_Float dv3z = zip3 - zi; /* xi+3 - xi */
 
-          /* On définit uNormal = unit normal to baseline (i+3;i) */
+          /* Set uNormal = unit normal to baseline (i+3;i) */
           E_Float normeDv3 = (dv3x * dv3x) + (dv3y * dv3y) + (dv3z * dv3z); /*  ||{xi+3-xi}**||² = ||xi+3-xi||² */
           
           if (normeDv3 < 1e-12) continue;
           E_Float divNorme = 1.0 / normeDv3 ;/*  1 / ||xi+3-xi||² */
 
           E_Float uNormalx = divNorme * (-dv3y); E_Float uNormaly = divNorme * (dv3x); E_Float uNormalz = 0;  /* {xi+3-xi}** / ||xi+3-xi||² */
 
-          /* Calcul de l'aire signée */
+          /* Compute signed area */
           E_Float aire = 0.5 * (dv3x * dv2y - dv3y * dv2x) + \
                         0.5 * (dv2x * dv1y - dv2y * dv1x) ;
 
@@ -190,12 +190,11 @@ PyObject* K_TRANSFORM::consSmooth(PyObject* self, PyObject* args)
       z[nUnique] = z[0];
     }
 
-    RELEASESHAREDS(tpl, fo); // Libération Structurée
+    RELEASESHAREDS(tpl, fo); // free memory
   
   }
-  else if (res == 2) // non structuré
-  {
-     
+  else if (res == 2) // unstructured
+  {  
     tpl = K_ARRAY::buildArray3(f->getNfld(), varString,
                                f->getSize(), cn->getSize(),
                                eltType, false, f->getApi());
@@ -225,13 +224,13 @@ PyObject* K_TRANSFORM::consSmooth(PyObject* self, PyObject* args)
     std::vector< std::vector<E_Int> > nodeAdj(npts);// vertex/elt adjacents
     K_CONNECT::connectEV2VE(*cn, nodeAdj);
   
-    // Ouvert ou fermé ?? determine les noeuds frontières
+    // Open or closed, find boundary nodes
     E_Int n1 = -1; E_Int n2 = -1;
     E_Int ouvert = 0;
 
-    for(E_Int p = 0; p < npts; p++) 
+    for (E_Int p = 0; p < npts; p++) 
     {
-      if((E_Int)nodeAdj[p].size() == 1) 
+      if ((E_Int)nodeAdj[p].size() == 1) 
       {
         if (n1 == -1) n1 = p;
         else n2 = p;
@@ -242,46 +241,46 @@ PyObject* K_TRANSFORM::consSmooth(PyObject* self, PyObject* args)
     {
       if (isSamePoint(x[n1], y[n1], z[n1], x[n2], y[n2], z[n2])) 
       {
-        //CAS 2 : Maillage topologiquement OUVERT, mais geometriquement FERME. On soude alors virtuellement 
+        // CASE 2: mesh is topologically OPEN, but geometrically CLOSED. 
         ouvert = 0;
-        printf("Géométrie fermé avec point doublons : %d et %d\n", n1, n2);
+        printf("INFO: consmooth: closed geometry with double points: %d and %d.\n", n1, n2);
       }
-      else  // CAS 3 : Vraie courbe OUVERTE (Les extremites vont rester fixes)
+      else  // CASE 3: mesh is OPEN (extremities will stay fixed)
       {
         ouvert = 1;
-        printf("Géométrie ouverte : frontières %d et %d\n", n1, n2);
+        printf("INFO: consmooth: open geometry: fixed nodes %d and %d.\n", n1, n2);
       }
     }
 
-    // On crée une chaine ordonnée de noeuds
+    // Create a chained of ordered nodes
     std::vector<E_Int> bar;
     
     E_Int firstNode = (ouvert == 1) ? n1
-                    : (n1 != -1) ? n1 // CAS 2 : fermé avec doublon, on part du premier doublon
-                    : ((*cn)(0, 1) - 1); //CAS 1 : fermé pur, on part de n'importe quel noeud 
+                    : (n1 != -1) ? n1 // CASE 2: start from first double point
+                    : ((*cn)(0, 1) - 1); // CASE 1: closed, start from any node 
     E_Int cur = firstNode, prev = -1;
     bar.push_back(cur);
 
     while (true)
     {
       E_Int next = -1;
       
-      for (E_Int elt : nodeAdj[cur])  // elt = indice d'élément
+      for (E_Int elt : nodeAdj[cur])  // elt = element index
       {
         E_Int nA = (*cn)(elt, 1) - 1;
         E_Int nB = (*cn)(elt, 2) - 1;
-        E_Int neighbor = (nA == cur) ? nB : nA; // le voisin = l'autre nœud du segment
+        E_Int neighbor = (nA == cur) ? nB : nA; // neighbour is the other node of element
         if (neighbor != prev) { next = neighbor; break; }
       }
 
-      if (next == -1) break;                              // CAS 3 : nœud avec 1 seul voisin atteint = fin d'une chaîne ouverte
-      if (ouvert == 0 && next == firstNode) break;        // CAS 1 : retour au départ
-      if (ouvert == 0 && n1 != -1 && next == n2) break;   // CAS 2 : on ne garde pas le doublon
+      if (next == -1) break;                              // CASE 3: node with only one node reached = end of open chain
+      if (ouvert == 0 && next == firstNode) break;        // CASE 1: return to start
+      if (ouvert == 0 && n1 != -1 && next == n2) break;   // CASE 2: we dont keep double point
       
       bar.push_back(next);
       prev = cur;
       cur  = next;
-      if (ouvert == 1 && cur == n2) break; // on a atteint l'autre extrémité ouverte
+      if (ouvert == 1 && cur == n2) break; // we reach the end of opened curve
     }
 
     E_Int nUnique = (E_Int)bar.size();
@@ -291,29 +290,29 @@ PyObject* K_TRANSFORM::consSmooth(PyObject* self, PyObject* args)
   
     for (E_Int k = 0; k < sweeps; k++)
     {
-      for (E_Int j = 0; j < retour + 1; j++)
+      for (E_Int j = 0; j < twoWays + 1; j++)
       {
-        for (E_Int i = start; i < end; i += pas)
+        for (E_Int i = start; i < end; i += step)
         {
-          E_Int c0, c1, c2, c3; // indices dans le bar
+          E_Int c0, c1, c2, c3; // indices in BAR
           if (ouvert == 0)
           {
-            // CAS fermé
+            // Closed case
             c0 = (j == 0) ? i % nUnique : (nUnique - i % nUnique) % nUnique;
             c1 = (j == 0) ? (i + 1) % nUnique : (nUnique - ((i + 1)   % nUnique)) % nUnique;
             c2 = (j == 0) ? (i + 2) % nUnique : (nUnique - ((i + 2)   % nUnique)) % nUnique;
             c3 = (j == 0) ? (i + 3) % nUnique : (nUnique - ((i + 3)   % nUnique)) % nUnique;
           }
           else
           {
-            // CAS ouvert : 
+            // Open case
             c0 = (j == 0) ? i : (nUnique - 1) - i;
             c1 = (j == 0) ? (i + 1) : (nUnique - 1) - (i + 1);
             c2 = (j == 0) ? (i + 2) : (nUnique - 1) - (i + 2);
             c3 = (j == 0) ? (i + 3) : (nUnique - 1) - (i + 3);
           }
 
-          // indices réels des nœuds
+          // Nodes indices
           E_Int idx0 = bar[c0];
           E_Int idx1 = bar[c1];
           E_Int idx2 = bar[c2];
@@ -324,20 +323,20 @@ PyObject* K_TRANSFORM::consSmooth(PyObject* self, PyObject* args)
           E_Float xip2 = x[idx2]; E_Float yip2 = y[idx2]; E_Float zip2 = z[idx2]; 
           E_Float xip3 = x[idx3]; E_Float yip3 = y[idx3]; E_Float zip3 = z[idx3];
 
-          /* On calcule les différences de points qui nous interessent (i+3 - i), (i+2 - i) et (i+1 - i) */
+          /* Compute deltas (i+3 - i), (i+2 - i) et (i+1 - i) */
           E_Float dv1x = xip1 - xi; E_Float dv1y = yip1 - yi; E_Float dv1z = zip1 - zi; /* xi+1 - xi */
           E_Float dv2x = xip2 - xi; E_Float dv2y = yip2 - yi; E_Float dv2z = zip2 - zi; /* xi+2 - xi */
           E_Float dv3x = xip3 - xi; E_Float dv3y = yip3 - yi; E_Float dv3z = zip3 - zi; /* xi+3 - xi */
 
-          /* On définit uNormal = unit normal to baseline (i+3;i) */
+          /* Set uNormal = unit normal to baseline (i+3;i) */
           E_Float normeDv3 = (dv3x * dv3x) + (dv3y * dv3y) + (dv3z * dv3z); /*  ||{xi+3-xi}**||² = ||xi+3-xi||² */
           
           if (normeDv3 < 1e-12) continue;
           E_Float divNorme = 1.0 / normeDv3 ;/*  1 / ||xi+3-xi||² */
 
           E_Float uNormalx = divNorme * (-dv3y); E_Float uNormaly = divNorme * (dv3x); E_Float uNormalz = 0;  /* {xi+3-xi}** / ||xi+3-xi||² */
 
-          /* Calcul de l'aire signée */
+          /* Compute signed area */
           E_Float aire = 0.5 * (dv3x * dv2y - dv3y * dv2x) + \
                         0.5 * (dv2x * dv1y - dv2y * dv1x) ;
 
@@ -346,8 +345,6 @@ PyObject* K_TRANSFORM::consSmooth(PyObject* self, PyObject* args)
           x[idx1] = 2.0/3.0 * xi + 1.0 /3.0 * xip3 + h * uNormalx; y[idx1] = 2.0/3.0 * yi + 1.0 /3.0 * yip3 + h * uNormaly; z[idx1] = 2.0/3.0 * zi + 1.0 /3.0 * zip3 + h * uNormalz;
           x[idx2] = 1.0/3.0 * xi + 2.0 /3.0 * xip3 + h * uNormalx; y[idx2] = 1.0/3.0 * yi + 2.0 /3.0 * yip3 + h * uNormaly; z[idx2] = 1.0/3.0 * zi + 2.0 /3.0 * zip3 + h * uNormalz;
           
-          
-
         }
       }
     }
@@ -359,7 +356,7 @@ PyObject* K_TRANSFORM::consSmooth(PyObject* self, PyObject* args)
       z[n2] = z[n1];
     }
 
-    RELEASESHAREDU(tpl, fo, cno); // Libération Non-Structurée
+    RELEASESHAREDU(tpl, fo, cno); // free memory
   }
 
   RELEASESHAREDB(res, array, f, cn); 
diff --git a/Cassiopee/Transform/test/consSmooth.py b/Cassiopee/Transform/test/consSmooth.py
@@ -10,6 +10,6 @@
 l4 = D.line((1.,0.,0.), (0.,0.,0.), N=5)
 
 a = T.join([l1,l2,l3,l4])
-b = T.consSmooth(a,sweeps)
+b = T.consSmooth(a, sweeps)
 
 C.convertArrays2File([a,b], "out.plt")
diff --git a/Cassiopee/Transform/test/consSmoothPT.py b/Cassiopee/Transform/test/consSmoothPT.py
@@ -11,7 +11,7 @@
 l4 = D.line((1.,0.,0.), (0.,0.,0.), N=5)
 
 a = T.join([l1,l2,l3,l4]); I.setName(a, 'carreOriginal')
-b = T.consSmooth(a,sweeps); I.setName(b, 'carreLisse')
+b = T.consSmooth(a, sweeps); I.setName(b, 'carreLisse')
 
 t = C.newPyTree(['Base',a,b])
-C.convertPyTree2File(t, "out.cgns")
+C.convertPyTree2File(t, "out.cgns")
diff --git a/Cassiopee/Transform/test/consSmoothPT_t1.py b/Cassiopee/Transform/test/consSmoothPT_t1.py
@@ -12,20 +12,20 @@
 
 # standard array1 tests on closed curve
 a = T.join([l1,l2,l3,l4])
-a = T.consSmooth(a,sweeps)
+a = T.consSmooth(a, sweeps)
 test.testT(a, 1)
 
 # standard array1 tests on open curve
 b = T.join([l1,l2,l3])
-b = T.consSmooth(b,sweeps)
+b = T.consSmooth(b, sweeps)
 test.testT(b, 2)
 
 # standard bar1D tests on closed curve
 c = C.convertArray2Tetra(a)
-c = T.consSmooth(c,sweeps)
-test.testA([c], 3)
+c = T.consSmooth(c, sweeps)
+test.testT(c, 3)
 
 # standard bar1D tests on open curve
 d = C.convertArray2Tetra(b)
-d = T.consSmooth(d,sweeps)
-test.testA([d], 4)
+d = T.consSmooth(d, sweeps)
+test.testT(d, 4)
diff --git a/Cassiopee/Transform/test/consSmooth_t1.py b/Cassiopee/Transform/test/consSmooth_t1.py
