0022124: [CEA 763] Projection 1D does not work with Netgen 1D2D

Move struct AlgoData from SMESH_Gen.cxx to struct SMESH_Algo::Features

src/SMESH/SMESH_Algo.cxx

@@ -49,6 +49,7 @@
 #include <GCPnts_AbscissaPoint.hxx>
 #include <GeomAdaptor_Curve.hxx>
 #include <Geom_Surface.hxx>
+#include <LDOMParser.hxx>
 #include <TopExp.hxx>
 #include <TopExp_Explorer.hxx>
 #include <TopLoc_Location.hxx>
@@ -73,6 +74,98 @@
 
 using namespace std;
 
+//================================================================================
+/*!
+ * \brief Returns \a true if two algorithms (described by \a this and the given
+ *        algo data) are compatible by their output and input types of elements.
+ */
+//================================================================================
+
+bool SMESH_Algo::Features::IsCompatible( const SMESH_Algo::Features& algo2 ) const
+{
+  if ( _dim > algo2._dim ) return algo2.IsCompatible( *this );
+  // algo2 is of highter dimension
+  if ( _outElemTypes.empty() || algo2._inElemTypes.empty() )
+    return false;
+  bool compatible = true;
+  set<SMDSAbs_GeometryType>::const_iterator myOutType = _outElemTypes.begin();
+  for ( ; myOutType != _outElemTypes.end() && compatible; ++myOutType )
+    compatible = algo2._inElemTypes.count( *myOutType );
+  return compatible;
+}
+
+//================================================================================
+/*!
+ * \brief Return Data of the algorithm
+ */
+//================================================================================
+
+const SMESH_Algo::Features& SMESH_Algo::GetFeatures( const std::string& algoType )
+{
+  static map< string, SMESH_Algo::Features > theFeaturesByName;
+  if ( theFeaturesByName.empty() )
+  {
+    // Read Plugin.xml files
+    vector< string > xmlPaths = SMESH_Gen::GetPluginXMLPaths();
+    LDOMParser xmlParser;
+    for ( size_t iXML = 0; iXML < xmlPaths.size(); ++iXML )
+    {
+      bool error = xmlParser.parse( xmlPaths[iXML].c_str() );
+      if ( error )
+      {
+        TCollection_AsciiString data;
+        INFOS( xmlParser.GetError(data) );
+        continue;
+      }
+      // <algorithm type="Regular_1D"
+      //            ...
+      //            input="EDGE"
+      //            output="QUAD,TRIA">
+      //
+      LDOM_Document xmlDoc = xmlParser.getDocument();
+      LDOM_NodeList algoNodeList = xmlDoc.getElementsByTagName( "algorithm" );
+      for ( int i = 0; i < algoNodeList.getLength(); ++i )
+      {
+        LDOM_Node     algoNode           = algoNodeList.item( i );
+        LDOM_Element& algoElem           = (LDOM_Element&) algoNode;
+        TCollection_AsciiString algoType = algoElem.getAttribute("type");
+        TCollection_AsciiString input    = algoElem.getAttribute("input");
+        TCollection_AsciiString output   = algoElem.getAttribute("output");
+        TCollection_AsciiString dim      = algoElem.getAttribute("dim");
+        TCollection_AsciiString label    = algoElem.getAttribute("label-id");
+        if ( algoType.IsEmpty() ) continue;
+
+        Features & data = theFeaturesByName[ algoType.ToCString() ];
+        data._dim   = dim.IntegerValue();
+        data._label = label.ToCString();
+        for ( int isInput = 0; isInput < 2; ++isInput )
+        {
+          TCollection_AsciiString&   typeStr = isInput ? input : output;
+          set<SMDSAbs_GeometryType>& typeSet = isInput ? data._inElemTypes : data._outElemTypes;
+          int beg = 1, end;
+          while ( beg <= typeStr.Length() )
+          {
+            while ( beg < typeStr.Length() && !isalpha( typeStr.Value( beg ) ))
+              ++beg;
+            end = beg;
+            while ( end < typeStr.Length() && isalpha( typeStr.Value( end + 1 ) ))
+              ++end;
+            if ( end > beg )
+            {
+              TCollection_AsciiString typeName = typeStr.SubString( beg, end );
+              if      ( typeName == "EDGE" ) typeSet.insert( SMDSGeom_EDGE );
+              else if ( typeName == "TRIA" ) typeSet.insert( SMDSGeom_TRIANGLE );
+              else if ( typeName == "QUAD" ) typeSet.insert( SMDSGeom_QUADRANGLE );
+            }
+            beg = end + 1;
+          }
+        }
+      }
+    }
+  }
+  return theFeaturesByName[ algoType ];
+}
+
 //=============================================================================
 /*!
  *  

src/SMESH/SMESH_Algo.hxx

@@ -30,9 +30,10 @@
 
 #include "SMESH_SMESH.hxx"
 
-#include "SMESH_Hypothesis.hxx"
+#include "SMDSAbs_ElementType.hxx"
-#include "SMESH_ComputeError.hxx"
 #include "SMESH_Comment.hxx"
+#include "SMESH_ComputeError.hxx"
+#include "SMESH_Hypothesis.hxx"
 
 #include <TopoDS_Shape.hxx>
 #include <TopoDS_Edge.hxx>
@@ -42,6 +43,7 @@
 #include <vector>
 #include <list>
 #include <map>
+#include <set>
 
 class SMDS_MeshNode;
 class SMESHDS_Mesh;
@@ -60,6 +62,7 @@ class gp_XYZ;
 typedef std::map< SMESH_subMesh*, std::vector<int> >           MapShapeNbElems;
 typedef std::map< SMESH_subMesh*, std::vector<int> >::iterator MapShapeNbElemsItr;
 
+// ==================================================================================
 /*!
  * \brief Root of all algorithms
  *
@@ -69,9 +72,33 @@ typedef std::map< SMESH_subMesh*, std::vector<int> >::iterator MapShapeNbElemsIt
  *  - methods related to dependencies between sub-meshes imposed by the algorith
  *  - static utilities, like EdgeLength()
  */
-class SMESH_EXPORT SMESH_Algo:public SMESH_Hypothesis
+// ==================================================================================
+
+class SMESH_EXPORT SMESH_Algo : public SMESH_Hypothesis
 {
-public:
+ public:
+  //==================================================================================
+  /*!
+   * \brief Structure describing algorithm features
+   */
+  // --------------------------------------------------------------------------------
+  struct Features
+  {
+    int                            _dim;
+    std::set<SMDSAbs_GeometryType> _inElemTypes;  // acceptable types of input mesh element
+    std::set<SMDSAbs_GeometryType> _outElemTypes; // produced types of mesh elements
+    std::string                    _label;        // GUI type name
+
+    bool IsCompatible( const Features& algo2 ) const;
+  };
+  /*!
+   * \brief Returns a structure describing algorithm features
+   */
+  static const Features& GetFeatures( const std::string& algoType );
+  const Features&        GetFeatures() const { return GetFeatures( _name ); }
+
+ public:
+  //==================================================================================
   /*!
    * \brief Creates algorithm
     * \param hypId - algorithm ID

src/SMESH/SMESH_Gen.cxx

@@ -43,13 +43,12 @@
 #include "Utils_ExceptHandlers.hxx"
 
 #include <TopoDS_Iterator.hxx>
-#include <LDOMParser.hxx>
 
 #include "memoire.h"
 
 #ifdef WNT
   #include <windows.h>
-#endif
+#endif
 
 using namespace std;
 
@@ -998,100 +997,6 @@ std::vector< std::string > SMESH_Gen::GetPluginXMLPaths()
   return xmlPaths;
 }
 
-//=======================================================================
-namespace // Access to type of input and output of an algorithm
-//=======================================================================
-{
-  struct AlgoData
-  {
-    int                       _dim;
-    set<SMDSAbs_GeometryType> _inElemTypes; // acceptable types of input mesh element
-    set<SMDSAbs_GeometryType> _outElemTypes; // produced types of mesh elements
-
-    bool IsCompatible( const AlgoData& algo2 ) const
-    {
-      if ( _dim > algo2._dim ) return algo2.IsCompatible( *this );
-      // algo2 is of highter dimension
-      if ( _outElemTypes.empty() || algo2._inElemTypes.empty() )
-        return false;
-      bool compatible = true;
-      set<SMDSAbs_GeometryType>::const_iterator myOutType = _outElemTypes.begin();
-      for ( ; myOutType != _outElemTypes.end() && compatible; ++myOutType )
-        compatible = algo2._inElemTypes.count( *myOutType );
-      return compatible;
-    }
-  };
-
-  //================================================================================
-  /*!
-   * \brief Return AlgoData of the algorithm
-   */
-  //================================================================================
-
-  const AlgoData& getAlgoData( const SMESH_Algo* algo )
-  {
-    static map< string, AlgoData > theDataByName;
-    if ( theDataByName.empty() )
-    {
-      // Read Plugin.xml files
-      vector< string > xmlPaths = SMESH_Gen::GetPluginXMLPaths();
-      LDOMParser xmlParser;
-      for ( size_t iXML = 0; iXML < xmlPaths.size(); ++iXML )
-      {
-        bool error = xmlParser.parse( xmlPaths[iXML].c_str() );
-        if ( error )
-        {
-          TCollection_AsciiString data;
-          INFOS( xmlParser.GetError(data) );
-          continue;
-        }
-        // <algorithm type="Regular_1D"
-        //            ...
-        //            input="EDGE"
-        //            output="QUAD,TRIA">
-        //
-        LDOM_Document xmlDoc = xmlParser.getDocument();
-        LDOM_NodeList algoNodeList = xmlDoc.getElementsByTagName( "algorithm" );
-        for ( int i = 0; i < algoNodeList.getLength(); ++i )
-        {
-          LDOM_Node     algoNode           = algoNodeList.item( i );
-          LDOM_Element& algoElem           = (LDOM_Element&) algoNode;
-          TCollection_AsciiString algoType = algoElem.getAttribute("type");
-          TCollection_AsciiString input    = algoElem.getAttribute("input");
-          TCollection_AsciiString output   = algoElem.getAttribute("output");
-          TCollection_AsciiString dim      = algoElem.getAttribute("dim");
-          if ( algoType.IsEmpty() ) continue;
-          AlgoData & data                  = theDataByName[ algoType.ToCString() ];
-          data._dim = dim.IntegerValue();
-          for ( int isInput = 0; isInput < 2; ++isInput )
-          {
-            TCollection_AsciiString&   typeStr = isInput ? input : output;
-            set<SMDSAbs_GeometryType>& typeSet = isInput ? data._inElemTypes : data._outElemTypes;
-            int beg = 1, end;
-            while ( beg <= typeStr.Length() )
-            {
-              while ( beg < typeStr.Length() && !isalpha( typeStr.Value( beg ) ))
-                ++beg;
-              end = beg;
-              while ( end < typeStr.Length() && isalpha( typeStr.Value( end + 1 ) ))
-                ++end;
-              if ( end > beg )
-              {
-                TCollection_AsciiString typeName = typeStr.SubString( beg, end );
-                if      ( typeName == "EDGE" ) typeSet.insert( SMDSGeom_EDGE );
-                else if ( typeName == "TRIA" ) typeSet.insert( SMDSGeom_TRIANGLE );
-                else if ( typeName == "QUAD" ) typeSet.insert( SMDSGeom_QUADRANGLE );
-              }
-              beg = end + 1;
-            }
-          }
-        }
-      }
-    }
-    return theDataByName[ algo->GetName() ];
-  }
-}
-
 //=============================================================================
 /*!
  * Finds algo to mesh a shape. Optionally returns a shape the found algo is bound to
@@ -1105,6 +1010,8 @@ SMESH_Algo *SMESH_Gen::GetAlgo(SMESH_Mesh &         aMesh,
   SMESH_HypoFilter filter( SMESH_HypoFilter::IsAlgo() );
   filter.And( filter.IsApplicableTo( aShape ));
 
+  typedef SMESH_Algo::Features AlgoData;
+
   TopoDS_Shape assignedToShape;
   SMESH_Algo* algo =
     (SMESH_Algo*) aMesh.GetHypothesis( aShape, filter, true, &assignedToShape );
@@ -1144,10 +1051,10 @@ SMESH_Algo *SMESH_Gen::GetAlgo(SMESH_Mesh &         aMesh,
       // check compatibility of algos
       if ( algos3D.size() > 1 )
       {
-        const AlgoData& algoData    = getAlgoData( algo );
+        const AlgoData& algoData    = algo->SMESH_Algo::GetFeatures();
-        const AlgoData& algoData2   = getAlgoData( algo2 );
+        const AlgoData& algoData2   = algo2->SMESH_Algo::GetFeatures();
-        const AlgoData& algoData3d0 = getAlgoData( algos3D[0] );
+        const AlgoData& algoData3d0 = algos3D[0]->SMESH_Algo::GetFeatures();
-        const AlgoData& algoData3d1 = getAlgoData( algos3D[1] );
+        const AlgoData& algoData3d1 = algos3D[1]->SMESH_Algo::GetFeatures();
         if (( algoData2.IsCompatible( algoData3d0 ) &&
               algoData2.IsCompatible( algoData3d1 ))
             &&