Merge remote-tracking branch 'origin/master' into V9_dev

src/Controls/SMESH_Controls.cxx

@@ -4287,6 +4287,7 @@ void ElementsOnShape::SetShape (const TopoDS_Shape&       theShape,
 
   if ( shapeChanges )
   {
+    // find most complex shapes
     TopTools_IndexedMapOfShape shapesMap;
     TopAbs_ShapeEnum shapeTypes[4] = { TopAbs_SOLID, TopAbs_FACE, TopAbs_EDGE, TopAbs_VERTEX };
     TopExp_Explorer sub;
@@ -4329,10 +4330,18 @@ void ElementsOnShape::clearClassifiers()
 
 bool ElementsOnShape::IsSatisfy( long elemId )
 {
+  if ( myClassifiers.empty() )
+    return false;
+
   const SMDS_Mesh* mesh = myMeshModifTracer.GetMesh();
-  const SMDS_MeshElement* elem =
+  if ( myType == SMDSAbs_Node )
-    ( myType == SMDSAbs_Node ? mesh->FindNode( elemId ) : mesh->FindElement( elemId ));
+    return IsSatisfy( mesh->FindNode( elemId ));
-  if ( !elem || myClassifiers.empty() )
+  return IsSatisfy( mesh->FindElement( elemId ));
+}
+
+bool ElementsOnShape::IsSatisfy (const SMDS_MeshElement* elem)
+{
+  if ( !elem )
     return false;
 
   bool isSatisfy = myAllNodesFlag, isNodeOut;
@@ -4396,6 +4405,60 @@ bool ElementsOnShape::IsSatisfy( long elemId )
   return isSatisfy;
 }
 
+bool ElementsOnShape::IsSatisfy (const SMDS_MeshNode* node,
+                                 TopoDS_Shape*        okShape)
+{
+  if ( !node )
+    return false;
+
+  if ( !myOctree && myClassifiers.size() > 5 )
+  {
+    myWorkClassifiers.resize( myClassifiers.size() );
+    for ( size_t i = 0; i < myClassifiers.size(); ++i )
+      myWorkClassifiers[ i ] = & myClassifiers[ i ];
+    myOctree = new OctreeClassifier( myWorkClassifiers );
+  }
+
+  bool isNodeOut = true;
+
+  if ( okShape || !getNodeIsOut( node, isNodeOut ))
+  {
+    SMESH_NodeXYZ aPnt = node;
+    if ( myOctree )
+    {
+      myWorkClassifiers.clear();
+      myOctree->GetClassifiersAtPoint( aPnt, myWorkClassifiers );
+
+      for ( size_t i = 0; i < myWorkClassifiers.size(); ++i )
+        myWorkClassifiers[i]->SetChecked( false );
+
+      for ( size_t i = 0; i < myWorkClassifiers.size(); ++i )
+        if ( !myWorkClassifiers[i]->IsChecked() &&
+             !myWorkClassifiers[i]->IsOut( aPnt ))
+        {
+          isNodeOut = false;
+          if ( okShape )
+            *okShape = myWorkClassifiers[i]->Shape();
+          break;
+        }
+    }
+    else
+    {
+      for ( size_t i = 0; i < myClassifiers.size(); ++i )
+        if ( !myClassifiers[i].IsOut( aPnt ))
+        {
+          isNodeOut = false;
+          if ( okShape )
+            *okShape = myWorkClassifiers[i]->Shape();
+          break;
+        }
+    }
+    setNodeIsOut( node, isNodeOut );
+  }
+
+  return !isNodeOut;
+}
+
 void ElementsOnShape::Classifier::Init( const TopoDS_Shape& theShape,
                                         double              theTol,
                                         const Bnd_B3d*      theBox )

src/Controls/SMESH_ControlsDef.hxx

@@ -902,6 +902,8 @@ namespace SMESH{
       bool    GetAllNodes() const { return myAllNodesFlag; }
       void    SetShape (const TopoDS_Shape& theShape,
                         const SMDSAbs_ElementType theType);
+      bool    IsSatisfy (const SMDS_MeshElement* elem);
+      bool    IsSatisfy (const SMDS_MeshNode* node, TopoDS_Shape* okShape=0);
 
     private:
 

src/SMESH_SWIG_WITHIHM/libSMESH_Swig.cxx

@@ -50,6 +50,7 @@
 #include <SalomeApp_Application.h>
 #include <LightApp_SelectionMgr.h>
 #include <SVTK_RenderWindowInteractor.h>
+#include <VTKViewer_Algorithm.h>
 
 // OCCT includes
 #include <TopAbs.hxx>
@@ -63,6 +64,10 @@
 #include CORBA_SERVER_HEADER(SMESH_Gen)
 #include CORBA_SERVER_HEADER(SMESH_Hypothesis)
 
+// VTK includes
+#include <vtkActorCollection.h>
+#include <vtkRenderer.h>
+
 static CORBA::ORB_var anORB;
 
 namespace
@@ -870,17 +875,18 @@ public:
   {}
   virtual void Execute()
   {
-    SMESHGUI* aSMESHGUI = SMESHGUI::GetSMESHGUI();
-    if( !aSMESHGUI ) 
-      return;
     
-    LightApp_SelectionMgr* selMgr = SMESH::GetSelectionMgr( aSMESHGUI );
+    LightApp_SelectionMgr* selMgr = 0;
+    SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
+    if( anApp )
+      selMgr = dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
+
     if( !selMgr )
       return;
     
     selMgr->clearFilters();
 
-    SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( aSMESHGUI );
+    SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow();
     if(!aViewWindow)
       return;
 
@@ -938,26 +944,106 @@ void SMESH_Swig::select( const char* id, int id1, bool append ) {
 class TGetSelectionModeEvent : public SALOME_Event
 {
 public:
-  typedef int TResult;
+  typedef SelectionMode TResult;
   TResult myResult;
-  TGetSelectionModeEvent() : myResult( -1 ) {}
+  TGetSelectionModeEvent() : myResult( Undefined ) {}
   virtual void Execute()
   {
-    SMESHGUI* aSMESHGUI = SMESHGUI::GetSMESHGUI();
+    SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( );
-    if( !aSMESHGUI ) 
-      return;
-
-    SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( aSMESHGUI );
     if(!aViewWindow)
       return;
     
-    myResult = aViewWindow->SelectionMode();
+    myResult = (SelectionMode) aViewWindow->SelectionMode();
   }
 };
 
 /*!
   \brief Get selection mode of the active VTK View window.
 */
-int SMESH_Swig::getSelectionMode() {
+SelectionMode SMESH_Swig::getSelectionMode() {
   return ProcessEvent( new TGetSelectionModeEvent() );
 }
+
+
+/*!
+ * Event to set selection mode
+*/
+class TSetSelectionModeEvent : public SALOME_Event
+{
+  SelectionMode mySelectionMode;
+
+public:
+
+  TSetSelectionModeEvent(const SelectionMode selectionMode) :
+    mySelectionMode(selectionMode) 
+  {}
+
+  virtual void Execute()
+  {
+    SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow();
+    if(!aViewWindow)
+      return;
+
+    Selection_Mode prevMode = aViewWindow->SelectionMode();
+    bool changePointRepresentation = ( prevMode == NodeSelection && mySelectionMode != Node ) ||
+      (prevMode != NodeSelection && mySelectionMode == Node);
+      
+    if( changePointRepresentation ) {
+      vtkRenderer *aRenderer = aViewWindow->getRenderer();
+      VTK::ActorCollectionCopy aCopy(aRenderer->GetActors());
+      vtkActorCollection *aCollection = aCopy.GetActors();
+      aCollection->InitTraversal();
+      while(vtkActor *anAct = aCollection->GetNextActor()){
+	if(SMESH_Actor *anActor = dynamic_cast<SMESH_Actor*>(anAct)){
+	  if(anActor->GetVisibility()){
+	    anActor->SetPointRepresentation(mySelectionMode == Node);
+	  }
+	}
+      }
+    }
+    aViewWindow->SetSelectionMode(mySelectionMode);
+  }
+};
+
+void SMESH_Swig::setSelectionMode(SelectionMode selectionMode){
+  ProcessVoidEvent( new TSetSelectionModeEvent( selectionMode ) ); 
+}
+
+class TGetSelectedEvent : public SALOME_Event
+{
+public:
+  typedef std::vector<int> TResult;
+  TResult myResult;
+  const char* myId;
+  
+  TGetSelectedEvent( const char* id) : 
+    myResult( std::vector<int>() ),
+    myId(id)
+  {}
+  
+  virtual void Execute()
+  {
+    SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow();
+    if( !aViewWindow )
+      return;
+
+    SVTK_Selector* aSelector  = aViewWindow->GetSelector();    
+    if( !aSelector )
+      return;
+
+    SMESH_Actor* anActor = SMESH::FindActorByEntry( myId );
+    
+    if ( !anActor || !anActor->hasIO() )
+      return;
+
+    TColStd_IndexedMapOfInteger aMapIndex;
+    aSelector->GetIndex(anActor->getIO(),aMapIndex);
+
+    for( int i = 1; i <= aMapIndex.Extent(); i++ )
+      myResult.push_back( aMapIndex( i ) );
+  }
+};
+
+std::vector<int> SMESH_Swig::getSelected( const char* Mesh_Entry ) {
+  return ProcessEvent( new TGetSelectedEvent(Mesh_Entry) );
+}

src/SMESH_SWIG_WITHIHM/libSMESH_Swig.h

@@ -45,8 +45,9 @@
 
 #include <SVTK_Selection.h>
 
-enum
+typedef enum
   {
+    Undefined  = -1,
     Node       = NodeSelection,
     Cell       = CellSelection,
     EdgeOfCell = EdgeOfCellSelection,
@@ -56,7 +57,7 @@ enum
     Actor      = ActorSelection,
     Elem0D     = Elem0DSelection,
     Ball       = BallSelection
-  };
+  } SelectionMode;
 
 typedef struct
 {
@@ -128,8 +129,11 @@ public:
   actorAspect                GetActorAspect(const char* Mesh_Entry, int viewId = 0 );
   void                       SetActorAspect( const actorAspect& actorPres, const char* Mesh_Entry, int viewId = 0  );
 
+  void setSelectionMode( SelectionMode selectionMode );
+  std::vector<int> getSelected( const char* Mesh_Entry );
+
   // --------------------- for the test purposes -----------------------
-  int  getSelectionMode();
+  SelectionMode getSelectionMode();
   void select( const char *id, std::vector<int> ids, bool append = false );
   void select( const char *id, int id1, bool append = false );
 

src/SMESH_SWIG_WITHIHM/libSMESH_Swig.i

@@ -55,9 +55,10 @@ namespace std {
 
 
 /* Selection mode enumeration (corresponds to constants from the SALOME_Selection.h) */
-enum
+enum SelectionMode
   {
-    Node,
+    Undefined = -1,
+    Node = 0,
     Cell,
     EdgeOfCell,
     Edge,
@@ -131,8 +132,11 @@ class SMESH_Swig
   actorAspect GetActorAspect(const char* Mesh_Entry, int viewId = 0 );
   void SetActorAspect( const actorAspect& actorPres, const char* Mesh_Entry, int viewId = 0 );
 
+  void setSelectionMode( SelectionMode selectionMode);
+  std::vector<int> getSelected( const char* Mesh_Entry );
+
   // --------------------- for the test purposes -----------------------
-  int  getSelectionMode();
+  SelectionMode  getSelectionMode();
   void select( const char *id, std::vector<int> ids, bool append = false );
   void select( const char *id, int id1, bool append = false );
 

src/StdMeshers/StdMeshers_Import_1D2D.cxx

@@ -34,6 +34,7 @@
 #include "SMESHDS_Group.hxx"
 #include "SMESHDS_Mesh.hxx"
 #include "SMESH_Comment.hxx"
+#include "SMESH_ControlsDef.hxx"
 #include "SMESH_Gen.hxx"
 #include "SMESH_Group.hxx"
 #include "SMESH_Mesh.hxx"
@@ -269,12 +270,25 @@ bool StdMeshers_Import_1D2D::Compute(SMESH_Mesh & theMesh, const TopoDS_Shape &
   map<TLink, int>::iterator link2Nb;
   double minGroupTol = Precision::Infinite();
 
+  SMESH::Controls::ElementsOnShape onEdgeClassifier;
+  if ( helper.HasSeam() )
+  {
+    TopoDS_Compound edgesCompound;
+    BRep_Builder    builder;
+    builder.MakeCompound( edgesCompound );
+    for ( size_t iE = 0; iE < edges.size(); ++iE )
+      builder.Add( edgesCompound, edges[ iE ]);
+    onEdgeClassifier.SetShape( edgesCompound, SMDSAbs_Node );
+  }
+
   // =========================
   // Import faces from groups
   // =========================
 
   StdMeshers_Import_1D::TNodeNodeMap* n2n;
   StdMeshers_Import_1D::TElemElemMap* e2e;
+  StdMeshers_Import_1D::TNodeNodeMap::iterator n2nIt;
+  pair< StdMeshers_Import_1D::TNodeNodeMap::iterator, bool > it_isnew;
   vector<TopAbs_State>         nodeState;
   vector<const SMDS_MeshNode*> newNodes; // of a face
   set   <const SMDS_MeshNode*> bndNodes; // nodes classified ON
@@ -297,8 +311,8 @@ bool StdMeshers_Import_1D2D::Compute(SMESH_Mesh & theMesh, const TopoDS_Shape &
     //                             S.VResolution( 0.1 * groupTol ));
     const double clsfTol = BRep_Tool::Tolerance( geomFace );
 
-    StdMeshers_Import_1D::TNodeNodeMap::iterator n2nIt;
+    if ( helper.HasSeam() )
-    pair< StdMeshers_Import_1D::TNodeNodeMap::iterator, bool > it_isnew;
+      onEdgeClassifier.SetMesh( srcMesh->GetMeshDS() );
 
     SMDS_ElemIteratorPtr srcElems = srcGroup->GetElements();
     while ( srcElems->more() ) // loop on group contents
@@ -356,11 +370,21 @@ bool StdMeshers_Import_1D2D::Compute(SMESH_Mesh & theMesh, const TopoDS_Shape &
           gp_XY uv( Precision::Infinite(), 0 );
           isOut = ( !helper.CheckNodeUV( geomFace, *node, uv, groupTol, /*force=*/true ) ||
                     bndBox2d.IsOut( uv ));
+          //int iCoo;
           if ( !isOut && !isIn ) // classify
           {
             classifier.Perform( geomFace, uv, clsfTol );
             nodeState[i] = classifier.State();
             isOut = ( nodeState[i] == TopAbs_OUT );
+            if ( isOut && helper.IsOnSeam( uv ) && onEdgeClassifier.IsSatisfy( (*node)->GetID() ))
+            {
+              // uv.SetCoord( iCoo, helper.GetOtherParam( uv.Coord( iCoo )));
+              // classifier.Perform( geomFace, uv, clsfTol );
+              // nodeState[i] = classifier.State();
+              // isOut = ( nodeState[i] == TopAbs_OUT );
+              nodeState[i] = TopAbs_ON;
+              isOut = false;
+            }
           }
           if ( !isOut ) // create a new node
           {
@@ -374,13 +398,14 @@ bool StdMeshers_Import_1D2D::Compute(SMESH_Mesh & theMesh, const TopoDS_Shape &
             }
             if ( nodeState[i] == TopAbs_ON )
               bndNodes.insert( *node );
-            else
+            else if ( nodeState[i] != TopAbs_UNKNOWN )
               isNodeIn[ newNode->GetID() ] = isIn = true;
           }
         }
         if ( !(newNodes[i] = newNode ) || isOut )
           break;
-      }
+
+      } // loop on face nodes
 
       if ( !newNodes.back() )
         continue; // not all nodes of the face lie on theShape
@@ -491,23 +516,32 @@ bool StdMeshers_Import_1D2D::Compute(SMESH_Mesh & theMesh, const TopoDS_Shape &
           medium = newNodes[i+nbCorners];
         link2Nb = linkCount.insert( make_pair( TLink( n1, n2, medium ), 0)).first;
         ++link2Nb->second;
-        // if ( link2Nb->second == 1 )
-        // {
-        //   // measure link length
-        //   double len2 = SMESH_TNodeXYZ( n1 ).SquareDistance( n2 );
-        //   if ( len2 < minGroupTol )
-        //     minGroupTol = len2;
-        // }
-      }
       }
+    } // loop on group contents
+
     // Remove OUT nodes from n2n map
     for ( n2nIt = n2n->begin(); n2nIt != n2n->end(); )
       if ( !n2nIt->second )
         n2n->erase( n2nIt++ );
       else
         ++n2nIt;
-  }
 
+  } // loop on src groups
+
+  // remove free nodes created on EDGEs
+  {
+    set<const SMDS_MeshNode*>::iterator node = bndNodes.begin();
+    for ( ; node != bndNodes.end(); ++node )
+    {
+      n2nIt = n2n->find( *node );
+      const SMDS_MeshNode* newNode = n2nIt->second;
+      if ( newNode && newNode->NbInverseElements() == 0 )
+      {
+        tgtMesh->RemoveFreeNode( newNode, 0, false );
+        n2n->erase( n2nIt );
+      }
+    }
+  }
 
   // ==========================================================
   // Put nodes on geom edges and create edges on them;