PAL13460 (PAL EDF 301 force the mesh to go through a point)

Provide usual access to data:
+  virtual int NbNodes() const;
+  const std::vector<int> & GetQuanities() const { return myQuantities; }
+  virtual const SMDS_MeshNode* GetNode(const int ind) const;
+  SMDS_ElemIteratorPtr uniqueNodesIterator() const;
+  SMDS_ElemIteratorPtr elementsIterator(SMDSAbs_ElementType type) const;

src/SMDS/SMDS_PolyhedralVolumeOfNodes.cxx

@@ -25,6 +25,8 @@
 
 #include "SMDS_PolyhedralVolumeOfNodes.hxx"
 #include "SMDS_MeshNode.hxx"
+#include "SMDS_SetIterator.hxx"
+#include "SMDS_VolumeTool.hxx"
 #include "utilities.h"
 
 #include <set>
@@ -36,8 +38,8 @@ using namespace std;
 //purpose  : Create a volume of many faces
 //=======================================================================
 SMDS_PolyhedralVolumeOfNodes::SMDS_PolyhedralVolumeOfNodes
-                                (std::vector<const SMDS_MeshNode *> nodes,
-                                 std::vector<int>                   quantities)
+                                (vector<const SMDS_MeshNode *> nodes,
+                                 vector<int>                   quantities)
 : SMDS_VolumeOfNodes(NULL, NULL, NULL, NULL)
 {
   ChangeNodes(nodes, quantities);
@@ -57,51 +59,36 @@ SMDSAbs_ElementType SMDS_PolyhedralVolumeOfNodes::GetType() const
 //function : ChangeNodes
 //purpose  : 
 //=======================================================================
-bool SMDS_PolyhedralVolumeOfNodes::ChangeNodes (std::vector<const SMDS_MeshNode *> nodes,
-                                                std::vector<int>                   quantities)
+bool SMDS_PolyhedralVolumeOfNodes::ChangeNodes (const vector<const SMDS_MeshNode *>& nodes,
+                                                const vector<int>&                   quantities)
 {
   myNodesByFaces = nodes;
   myQuantities = quantities;
 
-  // Init fields of parent class
-  int aNbNodes = 0;
-  std::set<const SMDS_MeshNode *> aSet;
-  int nodes_len = nodes.size();
-  for (int j = 0; j < nodes_len; j++) {
-    if (aSet.find(nodes[j]) == aSet.end()) {
-      aSet.insert(nodes[j]);
-      aNbNodes++;
-    }
-  }
-
-  int k = 0;
-#ifndef WNT
-  const SMDS_MeshNode* aNodes [aNbNodes];
-#else
-  const SMDS_MeshNode** aNodes = (const SMDS_MeshNode **)new SMDS_MeshNode*[aNbNodes];
-#endif
-  std::set<const SMDS_MeshNode *>::iterator anIter = aSet.begin();
-  for (; anIter != aSet.end(); anIter++, k++) {
-    aNodes[k] = *anIter;
-  }
+  // Init fields of parent class, it allows to get only unique nodes(?)
 
+  set<const SMDS_MeshNode *> aSet;
+  aSet.insert( nodes.begin(), nodes.end());
   //SMDS_VolumeOfNodes::ChangeNodes(aNodes, aNbNodes);
   delete [] myNodes;
-  //myNbNodes = nodes.size();
-  myNbNodes = aNbNodes;
+  myNbNodes = aSet.size();
   myNodes = new const SMDS_MeshNode* [myNbNodes];
-  for (int i = 0; i < myNbNodes; i++) {
-    //myNodes[i] = nodes[i];
-    myNodes[i] = aNodes[i];
-  }
-
-#ifdef WNT
-  delete [] aNodes;
-#endif
+  set<const SMDS_MeshNode *>::iterator anIter = aSet.begin();
+  for (int k=0; anIter != aSet.end(); anIter++, k++)
+    myNodes[k] = *anIter;
 
   return true;
 }
 
+//=======================================================================
+//function : NbEdges
+//purpose  : 
+//=======================================================================
+int SMDS_PolyhedralVolumeOfNodes::NbNodes() const
+{
+  return myNodesByFaces.size();
+}
+
 //=======================================================================
 //function : NbEdges
 //purpose  : 
@@ -188,3 +175,87 @@ bool SMDS_PolyhedralVolumeOfNodes::ChangeNodes (const SMDS_MeshNode* nodes[],
 {
   return false;
 }
+
+/// ===================================================================
+/*!
+ * \brief Iterator on node of volume
+ */
+/// ===================================================================
+
+struct _MyIterator:public SMDS_NodeVectorElemIterator
+{
+  _MyIterator(const vector<const SMDS_MeshNode *>& nodes):
+    SMDS_NodeVectorElemIterator( nodes.begin(), nodes.end()) {}
+};
+
+/// ===================================================================
+/*!
+ * \brief Iterator on faces or edges of volume
+ */
+/// ===================================================================
+
+class _MySubIterator : public SMDS_ElemIterator
+{
+  vector< const SMDS_MeshElement* > myElems;
+  int myIndex;
+public:
+  _MySubIterator(const SMDS_MeshVolume* vol, SMDSAbs_ElementType type):myIndex(0) {
+    SMDS_VolumeTool vTool(vol);
+    if (type == SMDSAbs_Face)
+      vTool.GetAllExistingFaces( myElems );
+    else
+      vTool.GetAllExistingFaces( myElems );
+  }
+  /// Return true if and only if there are other object in this iterator
+  virtual bool more() { return myIndex < myElems.size(); }
+
+  /// Return the current object and step to the next one
+  virtual const SMDS_MeshElement* next() { return myElems[ myIndex++ ]; }
+};
+
+//================================================================================
+/*!
+ * \brief Return Iterator of sub elements
+ */
+//================================================================================
+
+SMDS_ElemIteratorPtr SMDS_PolyhedralVolumeOfNodes::elementsIterator(SMDSAbs_ElementType type) const
+{
+  switch(type)
+  {
+  case SMDSAbs_Volume:
+    return SMDS_MeshElement::elementsIterator(SMDSAbs_Volume);
+  case SMDSAbs_Node:
+    return SMDS_ElemIteratorPtr(new _MyIterator(myNodesByFaces));
+  case SMDSAbs_Face:
+    return SMDS_ElemIteratorPtr(new _MySubIterator(this,SMDSAbs_Face));
+  case SMDSAbs_Edge:
+    return SMDS_ElemIteratorPtr(new _MySubIterator(this,SMDSAbs_Edge));
+  default:
+    MESSAGE("ERROR : Iterator not implemented");
+    return SMDS_ElemIteratorPtr((SMDS_ElemIterator*)NULL);
+  }
+}
+
+//================================================================================
+/*!
+ * \brief Return iterator on unique nodes
+ */
+//================================================================================
+
+SMDS_ElemIteratorPtr SMDS_PolyhedralVolumeOfNodes::uniqueNodesIterator() const
+{
+  return SMDS_ElemIteratorPtr
+    (new SMDS_NodeArrayElemIterator( myNodes, & myNodes[ myNbNodes ]));
+}
+
+//================================================================================
+/*!
+ * \brief Return node by its index
+ */
+//================================================================================
+
+const SMDS_MeshNode* SMDS_PolyhedralVolumeOfNodes::GetNode(const int ind) const
+{
+  return myNodesByFaces[ WrappedIndex( ind )];
+}

src/SMDS/SMDS_PolyhedralVolumeOfNodes.hxx

@@ -45,10 +45,10 @@ class SMDS_WNT_EXPORT SMDS_PolyhedralVolumeOfNodes:public SMDS_VolumeOfNodes
   virtual SMDSAbs_ElementType GetType() const;	
   virtual bool IsPoly() const { return true; };
 
-  bool ChangeNodes (std::vector<const SMDS_MeshNode *> nodes,
-                    std::vector<int>                   quantities);
+  bool ChangeNodes (const std::vector<const SMDS_MeshNode *> & nodes,
+                    const std::vector<int> &                   quantities);
 
-  //virtual int NbNodes() const;
+  virtual int NbNodes() const;
   virtual int NbEdges() const;
   virtual int NbFaces() const;
 
@@ -59,10 +59,22 @@ class SMDS_WNT_EXPORT SMDS_PolyhedralVolumeOfNodes:public SMDS_VolumeOfNodes
   // 1 <= face_ind <= NbFaces()
   // 1 <= node_ind <= NbFaceNodes()
 
+  const std::vector<int> & GetQuanities() const { return myQuantities; }
+
   virtual void Print (std::ostream & OS) const;
 
+  /*!
+   * \brief Return node by its index
+   */
+  virtual const SMDS_MeshNode* GetNode(const int ind) const;
+
+  /*!
+   * \brief Return iterator on unique nodes
+   */
+  SMDS_ElemIteratorPtr uniqueNodesIterator() const;
+
 protected:
-  //virtual SMDS_ElemIteratorPtr elementsIterator (SMDSAbs_ElementType type) const;
+  SMDS_ElemIteratorPtr elementsIterator(SMDSAbs_ElementType type) const;
 
  private:
   // usage disabled