53225: Viscous Layers hyp: problem with selection of input/output faces

  (StdMeshersGUI_SubShapeSelectorWdg.cxx)

+ Remove useless MESSAGEs

diff --git a/src/OBJECT/SMESH_Actor.cxx b/src/OBJECT/SMESH_Actor.cxx
index 0ec7231037fdd3f3fb49ce39fed578ee98210ec1..af0a9ab7ac236ef1b43376201f6b609b2aac12a7 100644 (file)
--- a/src/OBJECT/SMESH_Actor.cxx
+++ b/src/OBJECT/SMESH_Actor.cxx
@@ -82,9 +82,7 @@
 #include "utilities.h"
 
 #ifdef _DEBUG_
 #include "utilities.h"
 
 #ifdef _DEBUG_

-static int MYDEBUG = 1;
-#else
-static int MYDEBUG = 1;
+static int MYDEBUG = 0;

 #endif
 
 static int aLineWidthInc = 2;
 #endif
 
 static int aLineWidthInc = 2;


@@ -799,8 +797,7 @@ SetControlMode(eControl theMode)
 
 void
 SMESH_ActorDef::
 
 void
 SMESH_ActorDef::

-SetControlMode(eControl theMode,
-               bool theCheckEntityMode)
+SetControlMode( eControl theMode, bool theCheckEntityMode )

 {
   vtkLookupTable* lookupTable = static_cast<vtkLookupTable*>(myScalarBarActor->GetLookupTable());
   bool isLogarithmic = lookupTable->GetScale() == VTK_SCALE_LOG10;
 {
   vtkLookupTable* lookupTable = static_cast<vtkLookupTable*>(myScalarBarActor->GetLookupTable());
   bool isLogarithmic = lookupTable->GetScale() == VTK_SCALE_LOG10;

diff --git a/src/OBJECT/SMESH_Object.cxx b/src/OBJECT/SMESH_Object.cxx
index 2997063e5ace9f902c3de26869090a20c0bf25c9..61b36a78c706f0b5270700ee4678bd80994a9b19 100644 (file)
--- a/src/OBJECT/SMESH_Object.cxx
+++ b/src/OBJECT/SMESH_Object.cxx
@@ -67,7 +67,7 @@ using namespace std;
 #endif
 
 #ifdef _DEBUG_
 #endif
 
 #ifdef _DEBUG_

-static int MYDEBUG = 1;
+static int MYDEBUG = 0;

 static int MYDEBUGWITHFILES = 0;//1;
 #else
 static int MYDEBUG = 0;
 static int MYDEBUGWITHFILES = 0;//1;
 #else
 static int MYDEBUG = 0;


@@ -133,7 +133,7 @@ static int MYDEBUGWITHFILES = 0;
 //=================================================================================
 SMESH_VisualObjDef::SMESH_VisualObjDef()
 {
 //=================================================================================
 SMESH_VisualObjDef::SMESH_VisualObjDef()
 {

-  MESSAGE("---------------------------------------------SMESH_VisualObjDef::SMESH_VisualObjDef");
+  if ( MYDEBUG ) MESSAGE("-------------------------------SMESH_VisualObjDef::SMESH_VisualObjDef");

   myGrid = vtkUnstructuredGrid::New();
   myLocalGrid = false;
   ClearEntitiesFlags();
   myGrid = vtkUnstructuredGrid::New();
   myLocalGrid = false;
   ClearEntitiesFlags();


@@ -141,9 +141,8 @@ SMESH_VisualObjDef::SMESH_VisualObjDef()
 }
 SMESH_VisualObjDef::~SMESH_VisualObjDef()
 {
 }
 SMESH_VisualObjDef::~SMESH_VisualObjDef()
 {

-  MESSAGE("---------------------------------------------SMESH_VisualObjDef::~SMESH_VisualObjDef");
-  //if ( MYDEBUG )
-    MESSAGE( "~SMESH_MeshObj - myGrid->GetReferenceCount() = " << myGrid->GetReferenceCount() );
+  if ( MYDEBUG ) MESSAGE("--------------------------------SMESH_VisualObjDef::~SMESH_VisualObjDef");
+  if ( MYDEBUG ) MESSAGE( "myGrid->GetReferenceCount() = " << myGrid->GetReferenceCount() );

   myGrid->Delete();
 }
 
   myGrid->Delete();
 }
 


@@ -248,7 +247,7 @@ void SMESH_VisualObjDef::createPoints( vtkPoints* thePoints )
 //=================================================================================
 void SMESH_VisualObjDef::buildPrs(bool buildGrid)
 {
 //=================================================================================
 void SMESH_VisualObjDef::buildPrs(bool buildGrid)
 {

-  MESSAGE("----------------------------------------------------------SMESH_VisualObjDef::buildPrs " << buildGrid);
+  if ( MYDEBUG ) MESSAGE("---------------------------SMESH_VisualObjDef::buildPrs " << buildGrid);

   if (buildGrid)
   {
     myLocalGrid = true;
   if (buildGrid)
   {
     myLocalGrid = true;


@@ -281,7 +280,7 @@ void SMESH_VisualObjDef::buildPrs(bool buildGrid)
     myLocalGrid = false;
     if (!GetMesh()->isCompacted())
     {
     myLocalGrid = false;
     if (!GetMesh()->isCompacted())
     {

-      MESSAGE("*** buildPrs ==> compactMesh!");
+      if ( MYDEBUG ) MESSAGE("*** buildPrs ==> compactMesh!");

       GetMesh()->compactMesh();
     }
     vtkUnstructuredGrid *theGrid = GetMesh()->getGrid();
       GetMesh()->compactMesh();
     }
     vtkUnstructuredGrid *theGrid = GetMesh()->getGrid();


@@ -697,9 +696,9 @@ SMESH_MeshObj::~SMESH_MeshObj()
 bool SMESH_MeshObj::Update( int theIsClear )
 {
   // Update SMDS_Mesh on client part
 bool SMESH_MeshObj::Update( int theIsClear )
 {
   // Update SMDS_Mesh on client part

-  MESSAGE("SMESH_MeshObj::Update " << this);
+  if ( MYDEBUG ) MESSAGE("SMESH_MeshObj::Update " << this);

   if ( myClient.Update(theIsClear) || GetUnstructuredGrid()->GetNumberOfPoints()==0) {
   if ( myClient.Update(theIsClear) || GetUnstructuredGrid()->GetNumberOfPoints()==0) {

-    MESSAGE("buildPrs");
+    if ( MYDEBUG ) MESSAGE("buildPrs");

     buildPrs();  // Fill unstructured grid
     return true;
   }
     buildPrs();  // Fill unstructured grid
     return true;
   }


@@ -708,7 +707,7 @@ bool SMESH_MeshObj::Update( int theIsClear )
 
 bool SMESH_MeshObj::NulData()
 {
 
 bool SMESH_MeshObj::NulData()
 {

-  MESSAGE ("SMESH_MeshObj::NulData() ==================================================================================");
+  if ( MYDEBUG ) MESSAGE ("SMESH_MeshObj::NulData() =============================================");

   if (!myEmptyGrid)
   {
     myEmptyGrid = SMDS_UnstructuredGrid::New();
   if (!myEmptyGrid)
   {
     myEmptyGrid = SMDS_UnstructuredGrid::New();


@@ -901,7 +900,7 @@ void SMESH_SubMeshObj::UpdateFunctor( const SMESH::Controls::FunctorPtr& theFunc
 //=================================================================================
 bool SMESH_SubMeshObj::Update( int theIsClear )
 {
 //=================================================================================
 bool SMESH_SubMeshObj::Update( int theIsClear )
 {

-  MESSAGE("SMESH_SubMeshObj::Update " << this)
+  if ( MYDEBUG ) MESSAGE("SMESH_SubMeshObj::Update " << this)

   bool changed = myMeshObj->Update( theIsClear );
   buildPrs(true);
   return changed;
   bool changed = myMeshObj->Update( theIsClear );
   buildPrs(true);
   return changed;

diff --git a/src/SMDS/SMDS_Mesh.cxx b/src/SMDS/SMDS_Mesh.cxx
index 578782ae08bd2f79961ff6b68310a5e2640633d2..6582e23f156cf269ea2239d2131d406fec87b328 100644 (file)
--- a/src/SMDS/SMDS_Mesh.cxx
+++ b/src/SMDS/SMDS_Mesh.cxx
@@ -525,7 +525,6 @@ SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(const SMDS_MeshEdge * e1,
   if ( !e1 || !e2 || !e3 ) return 0;
 
   if ( NbFaces() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
   if ( !e1 || !e2 || !e3 ) return 0;
 
   if ( NbFaces() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();

-  MESSAGE("AddFaceWithID" << ID);

 
   SMDS_MeshFace * face = new SMDS_FaceOfEdges(e1,e2,e3);
   adjustmyCellsCapacity(ID);
 
   SMDS_MeshFace * face = new SMDS_FaceOfEdges(e1,e2,e3);
   adjustmyCellsCapacity(ID);


@@ -552,7 +551,6 @@ SMDS_MeshFace* SMDS_Mesh::AddFace(const SMDS_MeshEdge * e1,
 {
   if (!hasConstructionEdges())
     return NULL;
 {
   if (!hasConstructionEdges())
     return NULL;

-     //MESSAGE("AddFaceWithID" );

  return AddFaceWithID(e1,e2,e3,e4, myElementIDFactory->GetFreeID());
 }
 
  return AddFaceWithID(e1,e2,e3,e4, myElementIDFactory->GetFreeID());
 }
 


@@ -568,7 +566,6 @@ SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(const SMDS_MeshEdge * e1,
 {
   if (!hasConstructionEdges())
     return NULL;
 {
   if (!hasConstructionEdges())
     return NULL;

-  MESSAGE("AddFaceWithID" << ID);

   if ( !e1 || !e2 || !e3 || !e4 ) return 0;
   if ( NbFaces() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
   SMDS_MeshFace * face = new SMDS_FaceOfEdges(e1,e2,e3,e4);
   if ( !e1 || !e2 || !e3 || !e4 ) return 0;
   if ( NbFaces() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
   SMDS_MeshFace * face = new SMDS_FaceOfEdges(e1,e2,e3,e4);


@@ -596,7 +593,6 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
                                       const SMDS_MeshNode * n4)
 {
   int ID = myElementIDFactory->GetFreeID();
                                       const SMDS_MeshNode * n4)
 {
   int ID = myElementIDFactory->GetFreeID();

-    //MESSAGE("AddVolumeWithID " << ID);

   SMDS_MeshVolume * v = SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, ID);
   if(v==NULL) myElementIDFactory->ReleaseID(ID);
   return v;
   SMDS_MeshVolume * v = SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, ID);
   if(v==NULL) myElementIDFactory->ReleaseID(ID);
   return v;


@@ -615,7 +611,6 @@ SMDS_MeshVolume * SMDS_Mesh::AddVolumeWithID(int idnode1,
                                              int idnode4,
                                              int ID)
 {
                                              int idnode4,
                                              int ID)
 {

-    //MESSAGE("AddVolumeWithID" << ID);

   SMDS_MeshNode *node1, *node2, *node3, *node4;
   node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1);
   node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2);
   SMDS_MeshNode *node1, *node2, *node3, *node4;
   node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1);
   node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2);


@@ -637,7 +632,6 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
                                             const SMDS_MeshNode * n4,
                                             int ID)
 {
                                             const SMDS_MeshNode * n4,
                                             int ID)
 {

-  //MESSAGE("AddVolumeWithID " << ID);

   SMDS_MeshVolume* volume = 0;
   if ( !n1 || !n2 || !n3 || !n4) return volume;
   if ( NbVolumes() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
   SMDS_MeshVolume* volume = 0;
   if ( !n1 || !n2 || !n3 || !n4) return volume;
   if ( NbVolumes() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();


@@ -652,7 +646,6 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
     myInfo.myNbTetras++;
   }
   else if(hasConstructionEdges()) {
     myInfo.myNbTetras++;
   }
   else if(hasConstructionEdges()) {

-    MESSAGE("Error : Not implemented");

     return NULL;
   }
   else {
     return NULL;
   }
   else {


@@ -697,7 +690,6 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
                                       const SMDS_MeshNode * n5)
 {
   int ID = myElementIDFactory->GetFreeID();
                                       const SMDS_MeshNode * n5)
 {
   int ID = myElementIDFactory->GetFreeID();

-    //MESSAGE("AddVolumeWithID " << ID);

   SMDS_MeshVolume * v = SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, ID);
   if(v==NULL) myElementIDFactory->ReleaseID(ID);
   return v;
   SMDS_MeshVolume * v = SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, ID);
   if(v==NULL) myElementIDFactory->ReleaseID(ID);
   return v;


@@ -718,7 +710,6 @@ SMDS_MeshVolume * SMDS_Mesh::AddVolumeWithID(int idnode1,
                                              int idnode5,
                                              int ID)
 {
                                              int idnode5,
                                              int ID)
 {

-    //MESSAGE("AddVolumeWithID " << ID);

   SMDS_MeshNode *node1, *node2, *node3, *node4, *node5;
   node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1);
   node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2);
   SMDS_MeshNode *node1, *node2, *node3, *node4, *node5;
   node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1);
   node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2);


@@ -743,7 +734,6 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
                                             const SMDS_MeshNode * n5,
                                             int ID)
 {
                                             const SMDS_MeshNode * n5,
                                             int ID)
 {

-  //MESSAGE("AddVolumeWithID " << ID);

   SMDS_MeshVolume* volume = 0;
   if ( !n1 || !n2 || !n3 || !n4 || !n5) return volume;
   if ( NbVolumes() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
   SMDS_MeshVolume* volume = 0;
   if ( !n1 || !n2 || !n3 || !n4 || !n5) return volume;
   if ( NbVolumes() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();


@@ -758,7 +748,6 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
     myInfo.myNbPyramids++;
   }
   else if(hasConstructionEdges()) {
     myInfo.myNbPyramids++;
   }
   else if(hasConstructionEdges()) {

-    MESSAGE("Error : Not implemented");

     return NULL;
   }
   else {
     return NULL;
   }
   else {


@@ -805,7 +794,6 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
                                       const SMDS_MeshNode * n6)
 {
   int ID = myElementIDFactory->GetFreeID();
                                       const SMDS_MeshNode * n6)
 {
   int ID = myElementIDFactory->GetFreeID();

-    //MESSAGE("AddVolumeWithID " << ID);

   SMDS_MeshVolume * v = SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, n6, ID);
   if(v==NULL) myElementIDFactory->ReleaseID(ID);
   return v;
   SMDS_MeshVolume * v = SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, n6, ID);
   if(v==NULL) myElementIDFactory->ReleaseID(ID);
   return v;


@@ -827,7 +815,6 @@ SMDS_MeshVolume * SMDS_Mesh::AddVolumeWithID(int idnode1,
                                              int idnode6,
                                              int ID)
 {
                                              int idnode6,
                                              int ID)
 {

-    //MESSAGE("AddVolumeWithID " << ID);

   SMDS_MeshNode *node1, *node2, *node3, *node4, *node5, *node6;
   node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1);
   node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2);
   SMDS_MeshNode *node1, *node2, *node3, *node4, *node5, *node6;
   node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1);
   node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2);


@@ -854,7 +841,6 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
                                             const SMDS_MeshNode * n6,
                                             int ID)
 {
                                             const SMDS_MeshNode * n6,
                                             int ID)
 {

-  //MESSAGE("AddVolumeWithID " << ID);

   SMDS_MeshVolume* volume = 0;
   if ( !n1 || !n2 || !n3 || !n4 || !n5 || !n6) return volume;
   if ( NbVolumes() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
   SMDS_MeshVolume* volume = 0;
   if ( !n1 || !n2 || !n3 || !n4 || !n5 || !n6) return volume;
   if ( NbVolumes() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();


@@ -870,7 +856,6 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
     myInfo.myNbPrisms++;
   }
   else if(hasConstructionEdges()) {
     myInfo.myNbPrisms++;
   }
   else if(hasConstructionEdges()) {

-    MESSAGE("Error : Not implemented");

     return NULL;
   }
   else {
     return NULL;
   }
   else {


@@ -994,11 +979,9 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
     return volume;
   if ( NbVolumes() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
   if(hasConstructionFaces()) {
     return volume;
   if ( NbVolumes() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
   if(hasConstructionFaces()) {

-    MESSAGE("Error : Not implemented");

     return NULL;
   }
   else if(hasConstructionEdges()) {
     return NULL;
   }
   else if(hasConstructionEdges()) {

-    MESSAGE("Error : Not implemented");

     return NULL;
   }
   else {
     return NULL;
   }
   else {


@@ -1074,7 +1057,6 @@ SMDS_MeshVolume * SMDS_Mesh::AddVolumeWithID(int idnode1,
                                              int idnode8,
                                              int ID)
 {
                                              int idnode8,
                                              int ID)
 {

-    //MESSAGE("AddVolumeWithID " << ID);

   SMDS_MeshNode *node1, *node2, *node3, *node4, *node5, *node6, *node7, *node8;
   node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1);
   node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2);
   SMDS_MeshNode *node1, *node2, *node3, *node4, *node5, *node6, *node7, *node8;
   node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1);
   node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2);


@@ -1108,7 +1090,6 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
                                             const SMDS_MeshNode * n8,
                                             int ID)
 {
                                             const SMDS_MeshNode * n8,
                                             int ID)
 {

-    //MESSAGE("AddVolumeWithID " << ID);

   SMDS_MeshVolume* volume = 0;
   if ( !n1 || !n2 || !n3 || !n4 || !n5 || !n6 || !n7 || !n8) return volume;
   if ( NbVolumes() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
   SMDS_MeshVolume* volume = 0;
   if ( !n1 || !n2 || !n3 || !n4 || !n5 || !n6 || !n7 || !n8) return volume;
   if ( NbVolumes() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();


@@ -1125,7 +1106,6 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
     myInfo.myNbHexas++;
   }
   else if(hasConstructionEdges()) {
     myInfo.myNbHexas++;
   }
   else if(hasConstructionEdges()) {

-    MESSAGE("Error : Not implemented");

     return NULL;
   }
   else {
     return NULL;
   }
   else {


@@ -1171,7 +1151,6 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshFace * f1,
                                       const SMDS_MeshFace * f3,
                                       const SMDS_MeshFace * f4)
 {
                                       const SMDS_MeshFace * f3,
                                       const SMDS_MeshFace * f4)
 {

-    //MESSAGE("AddVolumeWithID");

   if (!hasConstructionFaces())
     return NULL;
   return AddVolumeWithID(f1,f2,f3,f4, myElementIDFactory->GetFreeID());
   if (!hasConstructionFaces())
     return NULL;
   return AddVolumeWithID(f1,f2,f3,f4, myElementIDFactory->GetFreeID());


@@ -1189,7 +1168,6 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshFace * f1,
                                             const SMDS_MeshFace * f4,
                                             int ID)
 {
                                             const SMDS_MeshFace * f4,
                                             int ID)
 {

-  MESSAGE("AddVolumeWithID" << ID);

   if (!hasConstructionFaces())
     return NULL;
   if ( !f1 || !f2 || !f3 || !f4) return 0;
   if (!hasConstructionFaces())
     return NULL;
   if ( !f1 || !f2 || !f3 || !f4) return 0;


@@ -1218,7 +1196,6 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshFace * f1,
                                       const SMDS_MeshFace * f4,
                                       const SMDS_MeshFace * f5)
 {
                                       const SMDS_MeshFace * f4,
                                       const SMDS_MeshFace * f5)
 {

-     //MESSAGE("AddVolumeWithID");

  if (!hasConstructionFaces())
     return NULL;
   return AddVolumeWithID(f1,f2,f3,f4,f5, myElementIDFactory->GetFreeID());
  if (!hasConstructionFaces())
     return NULL;
   return AddVolumeWithID(f1,f2,f3,f4,f5, myElementIDFactory->GetFreeID());


@@ -1237,7 +1214,6 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshFace * f1,
                                             const SMDS_MeshFace * f5,
                                             int ID)
 {
                                             const SMDS_MeshFace * f5,
                                             int ID)
 {

-  MESSAGE("AddVolumeWithID" << ID);

   if (!hasConstructionFaces())
     return NULL;
   if ( !f1 || !f2 || !f3 || !f4 || !f5) return 0;
   if (!hasConstructionFaces())
     return NULL;
   if ( !f1 || !f2 || !f3 || !f4 || !f5) return 0;


@@ -1267,7 +1243,6 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshFace * f1,
                                       const SMDS_MeshFace * f5,
                                       const SMDS_MeshFace * f6)
 {
                                       const SMDS_MeshFace * f5,
                                       const SMDS_MeshFace * f6)
 {

-     //MESSAGE("AddVolumeWithID" );

  if (!hasConstructionFaces())
     return NULL;
   return AddVolumeWithID(f1,f2,f3,f4,f5,f6, myElementIDFactory->GetFreeID());
  if (!hasConstructionFaces())
     return NULL;
   return AddVolumeWithID(f1,f2,f3,f4,f5,f6, myElementIDFactory->GetFreeID());


@@ -1287,7 +1262,6 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshFace * f1,
                                             const SMDS_MeshFace * f6,
                                             int ID)
 {
                                             const SMDS_MeshFace * f6,
                                             int ID)
 {

-  MESSAGE("AddVolumeWithID" << ID);

   if (!hasConstructionFaces())
     return NULL;
   if ( !f1 || !f2 || !f3 || !f4 || !f5 || !f6) return 0;
   if (!hasConstructionFaces())
     return NULL;
   if ( !f1 || !f2 || !f3 || !f4 || !f5 || !f6) return 0;


@@ -1334,7 +1308,6 @@ SMDS_Mesh::AddPolygonalFaceWithID (const vector<const SMDS_MeshNode*> & nodes,
   if ( NbFaces() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
   if (hasConstructionEdges())
   {
   if ( NbFaces() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
   if (hasConstructionEdges())
   {

-    MESSAGE("Error : Not implemented");

     return NULL;
   }
   else
     return NULL;
   }
   else


@@ -1399,7 +1372,6 @@ SMDS_Mesh::AddQuadPolygonalFaceWithID (const vector<const SMDS_MeshNode*> & node
   if ( NbFaces() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
   if (hasConstructionEdges())
   {
   if ( NbFaces() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
   if (hasConstructionEdges())
   {

-    MESSAGE("Error : Not implemented");

     return NULL;
   }
   else
     return NULL;
   }
   else


@@ -1472,18 +1444,15 @@ SMDS_Mesh::AddPolyhedralVolumeWithID (const vector<const SMDS_MeshNode*>& nodes,
   if ( NbVolumes() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
   if (hasConstructionFaces())
   {
   if ( NbVolumes() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
   if (hasConstructionFaces())
   {

-    MESSAGE("Error : Not implemented");

     return NULL;
   }
   else if (hasConstructionEdges())
   {
     return NULL;
   }
   else if (hasConstructionEdges())
   {

-    MESSAGE("Error : Not implemented");

     return NULL;
   }
   else
   {
     //#ifdef VTK_HAVE_POLYHEDRON
     return NULL;
   }
   else
   {
     //#ifdef VTK_HAVE_POLYHEDRON

-    //MESSAGE("AddPolyhedralVolumeWithID vtk " << ID);

     myNodeIds.resize( nodes.size() );
     for ( size_t i = 0; i < nodes.size(); ++i )
       myNodeIds[i] = nodes[i]->getVtkId();
     myNodeIds.resize( nodes.size() );
     for ( size_t i = 0; i < nodes.size(); ++i )
       myNodeIds[i] = nodes[i]->getVtkId();


@@ -1498,7 +1467,6 @@ SMDS_Mesh::AddPolyhedralVolumeWithID (const vector<const SMDS_MeshNode*>& nodes,
     }
     volume = volvtk;
     //#else
     }
     volume = volvtk;
     //#else

-    //      MESSAGE("AddPolyhedralVolumeWithID smds " << ID);

     //      for ( int i = 0; i < nodes.size(); ++i )
     //      if ( !nodes[ i ] ) return 0;
     //      volume = new SMDS_PolyhedralVolumeOfNodes(nodes, quantities);
     //      for ( int i = 0; i < nodes.size(); ++i )
     //      if ( !nodes[ i ] ) return 0;
     //      volume = new SMDS_PolyhedralVolumeOfNodes(nodes, quantities);


@@ -1648,7 +1616,6 @@ SMDS_MeshFace* SMDS_Mesh::AddFaceFromVtkIdsWithID(const std::vector<vtkIdType>&
 ///////////////////////////////////////////////////////////////////////////////
 bool SMDS_Mesh::registerElement(int ID, SMDS_MeshElement* element)
 {
 ///////////////////////////////////////////////////////////////////////////////
 bool SMDS_Mesh::registerElement(int ID, SMDS_MeshElement* element)
 {

-  //MESSAGE("registerElement " << ID);

   if ((ID >=0) && (ID < (int)myCells.size()) && myCells[ID]) // --- already bound
   {
     MESSAGE(" ------------------ already bound "<< ID << " " << myCells[ID]->getVtkId());
   if ((ID >=0) && (ID < (int)myCells.size()) && myCells[ID]) // --- already bound
   {
     MESSAGE(" ------------------ already bound "<< ID << " " << myCells[ID]->getVtkId());


@@ -1666,7 +1633,6 @@ bool SMDS_Mesh::registerElement(int ID, SMDS_MeshElement* element)
 
   if (vtkId >= (int)myCellIdVtkToSmds.size()) // --- resize local vector
   {
 
   if (vtkId >= (int)myCellIdVtkToSmds.size()) // --- resize local vector
   {

-//     MESSAGE(" --------------------- resize myCellIdVtkToSmds " << vtkId << " --> " << vtkId + SMDS_Mesh::chunkSize);

     myCellIdVtkToSmds.resize(vtkId + SMDS_Mesh::chunkSize, -1);
   }
   myCellIdVtkToSmds[vtkId] = ID;
     myCellIdVtkToSmds.resize(vtkId + SMDS_Mesh::chunkSize, -1);
   }
   myCellIdVtkToSmds[vtkId] = ID;


@@ -1693,9 +1659,6 @@ const SMDS_MeshNode * SMDS_Mesh::FindNode(int ID) const
 {
   if (ID < 1 || ID >= (int)myNodes.size())
   {
 {
   if (ID < 1 || ID >= (int)myNodes.size())
   {

-//     MESSAGE("------------------------------------------------------------------------- ");
-//     MESSAGE("----------------------------------- bad ID " << ID << " " << myNodes.size());
-//     MESSAGE("------------------------------------------------------------------------- ");

     return 0;
   }
   return (const SMDS_MeshNode *)myNodes[ID];
     return 0;
   }
   return (const SMDS_MeshNode *)myNodes[ID];


@@ -1762,7 +1725,6 @@ SMDS_MeshFace * SMDS_Mesh::createTriangle(const SMDS_MeshNode * node1,
     face = facevtk;
     adjustmyCellsCapacity(ID);
     myCells[ID] = face;
     face = facevtk;
     adjustmyCellsCapacity(ID);
     myCells[ID] = face;

-    //MESSAGE("createTriangle " << ID << " " << face);

     myInfo.myNbTriangles++;
     return face;
   }
     myInfo.myNbTriangles++;
     return face;
   }


@@ -1782,7 +1744,6 @@ SMDS_MeshFace * SMDS_Mesh::createQuadrangle(const SMDS_MeshNode * node1,
   if ( NbFaces() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
   if(hasConstructionEdges())
   {
   if ( NbFaces() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
   if(hasConstructionEdges())
   {

-    //MESSAGE("createQuadrangle hasConstructionEdges "<< ID);

     SMDS_MeshEdge *edge1, *edge2, *edge3, *edge4;
     edge1=FindEdgeOrCreate(node1,node2);
     edge2=FindEdgeOrCreate(node2,node3);
     SMDS_MeshEdge *edge1, *edge2, *edge3, *edge4;
     edge1=FindEdgeOrCreate(node1,node2);
     edge2=FindEdgeOrCreate(node2,node3);


@@ -1827,7 +1788,6 @@ SMDS_MeshFace * SMDS_Mesh::createQuadrangle(const SMDS_MeshNode * node1,
 
 void SMDS_Mesh::RemoveNode(const SMDS_MeshNode * node)
 {
 
 void SMDS_Mesh::RemoveNode(const SMDS_MeshNode * node)
 {

-  MESSAGE("RemoveNode");

   RemoveElement(node, true);
 }
 
   RemoveElement(node, true);
 }
 


@@ -1837,7 +1797,6 @@ void SMDS_Mesh::RemoveNode(const SMDS_MeshNode * node)
 
 void SMDS_Mesh::Remove0DElement(const SMDS_Mesh0DElement * elem0d)
 {
 
 void SMDS_Mesh::Remove0DElement(const SMDS_Mesh0DElement * elem0d)
 {

-  MESSAGE("Remove0DElement");

   RemoveElement(elem0d,true);
 }
 
   RemoveElement(elem0d,true);
 }
 


@@ -1847,7 +1806,6 @@ void SMDS_Mesh::Remove0DElement(const SMDS_Mesh0DElement * elem0d)
 
 void SMDS_Mesh::RemoveEdge(const SMDS_MeshEdge * edge)
 {
 
 void SMDS_Mesh::RemoveEdge(const SMDS_MeshEdge * edge)
 {

-  MESSAGE("RemoveEdge");

   RemoveElement(edge,true);
 }
 
   RemoveElement(edge,true);
 }
 


@@ -1857,7 +1815,6 @@ void SMDS_Mesh::RemoveEdge(const SMDS_MeshEdge * edge)
 
 void SMDS_Mesh::RemoveFace(const SMDS_MeshFace * face)
 {
 
 void SMDS_Mesh::RemoveFace(const SMDS_MeshFace * face)
 {

-  MESSAGE("RemoveFace");

   RemoveElement(face, true);
 }
 
   RemoveElement(face, true);
 }
 


@@ -1867,7 +1824,6 @@ void SMDS_Mesh::RemoveFace(const SMDS_MeshFace * face)
 
 void SMDS_Mesh::RemoveVolume(const SMDS_MeshVolume * volume)
 {
 
 void SMDS_Mesh::RemoveVolume(const SMDS_MeshVolume * volume)
 {

-  MESSAGE("RemoveVolume");

   RemoveElement(volume, true);
 }
 
   RemoveElement(volume, true);
 }
 


@@ -1914,7 +1870,6 @@ bool SMDS_Mesh::ChangeElementNodes(const SMDS_MeshElement * element,
                                    const SMDS_MeshNode    * nodes[],
                                    const int                nbnodes)
 {
                                    const SMDS_MeshNode    * nodes[],
                                    const int                nbnodes)
 {

-  MESSAGE("SMDS_Mesh::ChangeElementNodes");

   // keep current nodes of elem
   set<const SMDS_MeshNode*> oldNodes( element->begin_nodes(), element->end_nodes() );
 
   // keep current nodes of elem
   set<const SMDS_MeshNode*> oldNodes( element->begin_nodes(), element->end_nodes() );
 


@@ -2428,11 +2383,6 @@ const SMDS_MeshElement* SMDS_Mesh::FindElement(int IDelem) const
 {
   if ( IDelem <= 0 || IDelem >= (int)myCells.size() )
   {
 {
   if ( IDelem <= 0 || IDelem >= (int)myCells.size() )
   {

-    MESSAGE("--------------------------------------------------------------------------------- ");
-    MESSAGE("----------------------------------- bad IDelem " << IDelem << " " << myCells.size());
-    MESSAGE("--------------------------------------------------------------------------------- ");
-    // TODO raise an exception
-    //assert(0);

     return 0;
   }
   return myCells[IDelem];
     return 0;
   }
   return myCells[IDelem];


@@ -2505,9 +2455,8 @@ const SMDS_MeshElement* SMDS_Mesh::FindElement (const vector<const SMDS_MeshNode
 
 void SMDS_Mesh::DumpNodes() const
 {
 
 void SMDS_Mesh::DumpNodes() const
 {

-        MESSAGE("dump nodes of mesh : ");
-        SMDS_NodeIteratorPtr itnode=nodesIterator();
-        while(itnode->more()) ; //MESSAGE(itnode->next());
+  SMDS_NodeIteratorPtr itnode=nodesIterator();
+  while(itnode->more()) ; //MESSAGE(itnode->next());

 }
 
 //=======================================================================
 }
 
 //=======================================================================


@@ -2516,7 +2465,6 @@ void SMDS_Mesh::DumpNodes() const
 //=======================================================================
 void SMDS_Mesh::Dump0DElements() const
 {
 //=======================================================================
 void SMDS_Mesh::Dump0DElements() const
 {

-  MESSAGE("dump 0D elements of mesh : ");

   SMDS_ElemIteratorPtr it0d = elementsIterator(SMDSAbs_0DElement);
   while(it0d->more()) ; //MESSAGE(it0d->next());
 }
   SMDS_ElemIteratorPtr it0d = elementsIterator(SMDSAbs_0DElement);
   while(it0d->more()) ; //MESSAGE(it0d->next());
 }


@@ -2528,9 +2476,8 @@ void SMDS_Mesh::Dump0DElements() const
 
 void SMDS_Mesh::DumpEdges() const
 {
 
 void SMDS_Mesh::DumpEdges() const
 {

-        MESSAGE("dump edges of mesh : ");
-        SMDS_EdgeIteratorPtr itedge=edgesIterator();
-        while(itedge->more()) ; //MESSAGE(itedge->next());
+  SMDS_EdgeIteratorPtr itedge=edgesIterator();
+  while(itedge->more()) ; //MESSAGE(itedge->next());

 }
 
 //=======================================================================
 }
 
 //=======================================================================


@@ -2540,9 +2487,8 @@ void SMDS_Mesh::DumpEdges() const
 
 void SMDS_Mesh::DumpFaces() const
 {
 
 void SMDS_Mesh::DumpFaces() const
 {

-        MESSAGE("dump faces of mesh : ");
-        SMDS_FaceIteratorPtr itface=facesIterator();
-        while(itface->more()) ; //MESSAGE(itface->next());
+  SMDS_FaceIteratorPtr itface=facesIterator();
+  while(itface->more()) ; //MESSAGE(itface->next());

 }
 
 //=======================================================================
 }
 
 //=======================================================================


@@ -2552,9 +2498,8 @@ void SMDS_Mesh::DumpFaces() const
 
 void SMDS_Mesh::DumpVolumes() const
 {
 
 void SMDS_Mesh::DumpVolumes() const
 {

-        MESSAGE("dump volumes of mesh : ");
-        SMDS_VolumeIteratorPtr itvol=volumesIterator();
-        while(itvol->more()) ; //MESSAGE(itvol->next());
+  SMDS_VolumeIteratorPtr itvol=volumesIterator();
+  while(itvol->more()) ; //MESSAGE(itvol->next());

 }
 
 //=======================================================================
 }
 
 //=======================================================================


@@ -2612,10 +2557,7 @@ void SMDS_Mesh::DebugStats() const
 ///////////////////////////////////////////////////////////////////////////////
 int SMDS_Mesh::NbNodes() const
 {
 ///////////////////////////////////////////////////////////////////////////////
 int SMDS_Mesh::NbNodes() const
 {

-        //MESSAGE(myGrid->GetNumberOfPoints());
-        //MESSAGE(myInfo.NbNodes());
-        //MESSAGE(myNodeMax);
-    return myInfo.NbNodes();
+  return myInfo.NbNodes();

 }
 
 ///////////////////////////////////////////////////////////////////////////////
 }
 
 ///////////////////////////////////////////////////////////////////////////////


@@ -2718,7 +2660,6 @@ SMDS_Mesh::~SMDS_Mesh()
 
 void SMDS_Mesh::Clear()
 {
 
 void SMDS_Mesh::Clear()
 {

-  MESSAGE("SMDS_Mesh::Clear");

   if (myParent!=NULL)
     {
     SMDS_ElemIteratorPtr eIt = elementsIterator();
   if (myParent!=NULL)
     {
     SMDS_ElemIteratorPtr eIt = elementsIterator();


@@ -3077,34 +3018,31 @@ static set<const SMDS_MeshElement*> * intersectionOfSets(
 ///////////////////////////////////////////////////////////////////////////////
 static set<const SMDS_MeshElement*> * getFinitElements(const SMDS_MeshElement * element)
 {
 ///////////////////////////////////////////////////////////////////////////////
 static set<const SMDS_MeshElement*> * getFinitElements(const SMDS_MeshElement * element)
 {

-        int numberOfSets=element->NbNodes();
-        set<const SMDS_MeshElement*> *initSet = new set<const SMDS_MeshElement*>[numberOfSets];
+  int numberOfSets=element->NbNodes();
+  set<const SMDS_MeshElement*> *initSet = new set<const SMDS_MeshElement*>[numberOfSets];

 
 

-        SMDS_ElemIteratorPtr itNodes=element->nodesIterator();
-
-        int i=0;
-        while(itNodes->more())
-        {
-          const SMDS_MeshElement* node = itNodes->next();
-          MYASSERT(node);
-                const SMDS_MeshNode * n=static_cast<const SMDS_MeshNode*>(node);
-                SMDS_ElemIteratorPtr itFe = n->GetInverseElementIterator();
+  SMDS_ElemIteratorPtr itNodes=element->nodesIterator();

 
 

-                //initSet[i]=set<const SMDS_MeshElement*>();
-                while(itFe->more())
-                {
-                  const SMDS_MeshElement* elem = itFe->next();
-                  MYASSERT(elem);
-                  initSet[i].insert(elem);
+  int i = 0;
+  while ( itNodes->more() )
+  {
+    const SMDS_MeshElement* node = itNodes->next();
+    MYASSERT(node);
+    const SMDS_MeshNode * n=static_cast<const SMDS_MeshNode*>(node);
+    SMDS_ElemIteratorPtr itFe = n->GetInverseElementIterator();

 
 

-                }
+    while ( itFe->more() )
+    {
+      const SMDS_MeshElement* elem = itFe->next();
+      MYASSERT(elem);
+      initSet[i].insert(elem);
+    }

 
 

-                i++;
-        }
-        set<const SMDS_MeshElement*> *retSet=intersectionOfSets(initSet, numberOfSets);
-//         MESSAGE("nb elems " << i << " intersection " << retSet->size());
-        delete [] initSet;
-        return retSet;
+    i++;
+  }
+  set<const SMDS_MeshElement*> *retSet = intersectionOfSets( initSet, numberOfSets );
+  delete [] initSet;
+  return retSet;

 }
 
 ///////////////////////////////////////////////////////////////////////////////
 }
 
 ///////////////////////////////////////////////////////////////////////////////


@@ -3401,11 +3339,9 @@ void SMDS_Mesh::RemoveFreeElement(const SMDS_MeshElement * elem)
 {
   int elemId = elem->GetID();
   int vtkId = elem->getVtkId();
 {
   int elemId = elem->GetID();
   int vtkId = elem->getVtkId();

-  //MESSAGE("RemoveFreeElement " << elemId);

   SMDSAbs_ElementType aType = elem->GetType();
   SMDS_MeshElement* todest = (SMDS_MeshElement*)(elem);
   if (aType == SMDSAbs_Node) {
   SMDSAbs_ElementType aType = elem->GetType();
   SMDS_MeshElement* todest = (SMDS_MeshElement*)(elem);
   if (aType == SMDSAbs_Node) {

-    //MESSAGE("Remove free node " << elemId);

     // only free node can be removed by this method
     const SMDS_MeshNode* n = static_cast<SMDS_MeshNode*>(todest);
     SMDS_ElemIteratorPtr itFe = n->GetInverseElementIterator();
     // only free node can be removed by this method
     const SMDS_MeshNode* n = static_cast<SMDS_MeshNode*>(todest);
     SMDS_ElemIteratorPtr itFe = n->GetInverseElementIterator();


@@ -3422,7 +3358,6 @@ void SMDS_Mesh::RemoveFreeElement(const SMDS_MeshElement * elem)
       // this methods is only for meshes without descendants
       return;
 
       // this methods is only for meshes without descendants
       return;
 

-    //MESSAGE("Remove free element " << elemId);

     // Remove element from <InverseElements> of its nodes
     SMDS_ElemIteratorPtr itn = elem->nodesIterator();
     while (itn->more()) {
     // Remove element from <InverseElements> of its nodes
     SMDS_ElemIteratorPtr itn = elem->nodesIterator();
     while (itn->more()) {


@@ -3538,7 +3473,6 @@ int SMDS_Mesh::MinElementID() const
 
 void SMDS_Mesh::Renumber (const bool isNodes, const int  startID, const int  deltaID)
 {
 
 void SMDS_Mesh::Renumber (const bool isNodes, const int  startID, const int  deltaID)
 {

-    MESSAGE("Renumber");

   if ( deltaID == 0 )
     return;
 
   if ( deltaID == 0 )
     return;
 


@@ -4709,17 +4643,14 @@ void SMDS_Mesh::incrementNodesCapacity(int nbNodes)
 //  MESSAGE(" ------------------- resize myCellIdSmdsToVtk " << val << " --> " << val + nbNodes);
 //  myCellIdSmdsToVtk.resize(val + nbNodes, -1); // fill new elements with -1
   int val = myNodes.size();
 //  MESSAGE(" ------------------- resize myCellIdSmdsToVtk " << val << " --> " << val + nbNodes);
 //  myCellIdSmdsToVtk.resize(val + nbNodes, -1); // fill new elements with -1
   int val = myNodes.size();

-  MESSAGE(" ------------------- resize myNodes " << val << " --> " << val + nbNodes);

   myNodes.resize(val +nbNodes, 0);
 }
 
 void SMDS_Mesh::incrementCellsCapacity(int nbCells)
 {
   int val = myCellIdVtkToSmds.size();
   myNodes.resize(val +nbNodes, 0);
 }
 
 void SMDS_Mesh::incrementCellsCapacity(int nbCells)
 {
   int val = myCellIdVtkToSmds.size();

-  MESSAGE(" ------------------- resize myCellIdVtkToSmds " << val << " --> " << val + nbCells);

   myCellIdVtkToSmds.resize(val + nbCells, -1); // fill new elements with -1
   val = myCells.size();
   myCellIdVtkToSmds.resize(val + nbCells, -1); // fill new elements with -1
   val = myCells.size();

-  MESSAGE(" ------------------- resize myCells " << val << " --> " << val + nbCells);

   myNodes.resize(val +nbCells, 0);
 }
 
   myNodes.resize(val +nbCells, 0);
 }
 


@@ -4730,48 +4661,45 @@ void SMDS_Mesh::adjustStructure()
 
 void SMDS_Mesh::dumpGrid(string ficdump)
 {
 
 void SMDS_Mesh::dumpGrid(string ficdump)
 {

-        MESSAGE("SMDS_Mesh::dumpGrid " << ficdump);
-//  vtkUnstructuredGridWriter* aWriter = vtkUnstructuredGridWriter::New();
-//  aWriter->SetFileName(ficdump.c_str());
-//  aWriter->SetInput(myGrid);
-//  if(myGrid->GetNumberOfCells())
-//  {
-//    aWriter->Write();
-//  }
-//  aWriter->Delete();
+  //  vtkUnstructuredGridWriter* aWriter = vtkUnstructuredGridWriter::New();
+  //  aWriter->SetFileName(ficdump.c_str());
+  //  aWriter->SetInput(myGrid);
+  //  if(myGrid->GetNumberOfCells())
+  //  {
+  //    aWriter->Write();
+  //  }
+  //  aWriter->Delete();

   ficdump = ficdump + "_connectivity";
   ofstream ficcon(ficdump.c_str(), ios::out);
   int nbPoints = myGrid->GetNumberOfPoints();
   ficcon << "-------------------------------- points " <<  nbPoints << endl;
   for (int i=0; i<nbPoints; i++)
   {
   ficdump = ficdump + "_connectivity";
   ofstream ficcon(ficdump.c_str(), ios::out);
   int nbPoints = myGrid->GetNumberOfPoints();
   ficcon << "-------------------------------- points " <<  nbPoints << endl;
   for (int i=0; i<nbPoints; i++)
   {

-        ficcon << i << " " << *(myGrid->GetPoint(i)) << " " << *(myGrid->GetPoint(i)+1) << " " << " " << *(myGrid->GetPoint(i)+2) << endl;
+    ficcon << i << " " << *(myGrid->GetPoint(i)) << " " << *(myGrid->GetPoint(i)+1) << " " << " " << *(myGrid->GetPoint(i)+2) << endl;

   }
   int nbCells = myGrid->GetNumberOfCells();
   ficcon << "-------------------------------- cells " <<  nbCells << endl;
   for (int i=0; i<nbCells; i++)
   {
   }
   int nbCells = myGrid->GetNumberOfCells();
   ficcon << "-------------------------------- cells " <<  nbCells << endl;
   for (int i=0; i<nbCells; i++)
   {

-//      MESSAGE(i << " " << myGrid->GetCell(i));
-//      MESSAGE("  " << myGrid->GetCell(i)->GetCellType());
-        ficcon << i << " - " << myGrid->GetCell(i)->GetCellType() << " -";
-        int nbptcell = myGrid->GetCell(i)->GetNumberOfPoints();
-        vtkIdList *listid = myGrid->GetCell(i)->GetPointIds();
-        for (int j=0; j<nbptcell; j++)
-        {
-                ficcon << " " <<  listid->GetId(j);
-        }
-        ficcon << endl;
+    ficcon << i << " - " << myGrid->GetCell(i)->GetCellType() << " -";
+    int nbptcell = myGrid->GetCell(i)->GetNumberOfPoints();
+    vtkIdList *listid = myGrid->GetCell(i)->GetPointIds();
+    for (int j=0; j<nbptcell; j++)
+    {
+      ficcon << " " <<  listid->GetId(j);
+    }
+    ficcon << endl;

   }
   ficcon << "-------------------------------- connectivity " <<  nbPoints << endl;
   }
   ficcon << "-------------------------------- connectivity " <<  nbPoints << endl;

-        vtkCellLinks *links = myGrid->GetCellLinks();
+  vtkCellLinks *links = myGrid->GetCellLinks();

   for (int i=0; i<nbPoints; i++)
   {
   for (int i=0; i<nbPoints; i++)
   {

-        int ncells = links->GetNcells(i);
-        vtkIdType *cells = links->GetCells(i);
-        ficcon << i << " - " << ncells << " -";
-        for (int j=0; j<ncells; j++)
-        {
-                ficcon << " " << cells[j];
+    int ncells = links->GetNcells(i);
+    vtkIdType *cells = links->GetCells(i);
+    ficcon << i << " - " << ncells << " -";
+    for (int j=0; j<ncells; j++)
+    {
+      ficcon << " " << cells[j];

         }
         ficcon << endl;
   }
         }
         ficcon << endl;
   }


@@ -4820,7 +4748,6 @@ double SMDS_Mesh::getMaxDim()
   if ((xmax - xmin) > dmax) dmax = xmax -xmin;
   if ((ymax - ymin) > dmax) dmax = ymax -ymin;
   if ((zmax - zmin) > dmax) dmax = zmax -zmin;
   if ((xmax - xmin) > dmax) dmax = xmax -xmin;
   if ((ymax - ymin) > dmax) dmax = ymax -ymin;
   if ((zmax - zmin) > dmax) dmax = zmax -zmin;

-  MESSAGE("getMaxDim " << dmax);

   return dmax;
 }
 
   return dmax;
 }
 


@@ -4828,11 +4755,10 @@ double SMDS_Mesh::getMaxDim()
 void SMDS_Mesh::Modified()
 {
   if (this->myModified)
 void SMDS_Mesh::Modified()
 {
   if (this->myModified)

-    {
-      this->myModifTime++;
-      MESSAGE("modified");
-      myModified = false;
-    }
+  {
+    this->myModifTime++;
+    myModified = false;
+  }

 }
 
 //! get last modification timeStamp
 }
 
 //! get last modification timeStamp


@@ -4844,10 +4770,9 @@ unsigned long SMDS_Mesh::GetMTime() const
 bool SMDS_Mesh::isCompacted()
 {
   if (this->myModifTime > this->myCompactTime)
 bool SMDS_Mesh::isCompacted()
 {
   if (this->myModifTime > this->myCompactTime)

-    {
-      MESSAGE(" *** isCompacted " << myCompactTime << " < " << myModifTime);
-      this->myCompactTime = this->myModifTime;
-      return false;
-    }
+  {
+    this->myCompactTime = this->myModifTime;
+    return false;
+  }

   return true;
 }
   return true;
 }

diff --git a/src/SMDS/SMDS_MeshIDFactory.cxx b/src/SMDS/SMDS_MeshIDFactory.cxx
index 20c90bda02d6dc96a342ab5af8cb2cc94cdd2ecd..74e5e401df8fe78adc9c8fc3cef9dcd840ae3439 100644 (file)
--- a/src/SMDS/SMDS_MeshIDFactory.cxx
+++ b/src/SMDS/SMDS_MeshIDFactory.cxx
@@ -42,25 +42,23 @@ SMDS_MeshIDFactory::SMDS_MeshIDFactory():myMaxID(0), myMesh(0)
 
 int SMDS_MeshIDFactory::GetFreeID()
 {
 
 int SMDS_MeshIDFactory::GetFreeID()
 {

-        int newid;
-        if (myPoolOfID.empty())
-        {
-            newid = ++myMaxID;
-            //MESSAGE("GetFreeID new " << newid);
-        }
-        else
-        {
-                set<int>::iterator i = myPoolOfID.begin();
-                newid = *i;//myPoolOfID.top();
-                myPoolOfID.erase( i );//myPoolOfID.pop();
-                //MESSAGE("GetFreeID pool " << newid);
-        }
-    return newid;
+  int newid;
+  if (myPoolOfID.empty())
+  {
+    newid = ++myMaxID;
+  }
+  else
+  {
+    set<int>::iterator i = myPoolOfID.begin();
+    newid = *i;//myPoolOfID.top();
+    myPoolOfID.erase( i );//myPoolOfID.pop();
+  }
+  return newid;

 }
 
 //=======================================================================
 //function : ReleaseID
 }
 
 //=======================================================================
 //function : ReleaseID

-//purpose  : 
+//purpose  :

 //=======================================================================
 void SMDS_MeshIDFactory::ReleaseID(int ID, int vtkId)
 {
 //=======================================================================
 void SMDS_MeshIDFactory::ReleaseID(int ID, int vtkId)
 {


@@ -91,24 +89,23 @@ void SMDS_MeshIDFactory::ReleaseID(int ID, int vtkId)
 
 void SMDS_MeshIDFactory::Clear()
 {
 
 void SMDS_MeshIDFactory::Clear()
 {

-        myMaxID = 0;
-        myPoolOfID.clear();
+  myMaxID = 0;
+  myPoolOfID.clear();

 }
 
 void SMDS_MeshIDFactory::SetMesh(SMDS_Mesh *mesh)
 {
 }
 
 void SMDS_MeshIDFactory::SetMesh(SMDS_Mesh *mesh)
 {

-        myMesh = mesh;
+  myMesh = mesh;

 }
 
 SMDS_Mesh* SMDS_MeshIDFactory::GetMesh()
 {
 }
 
 SMDS_Mesh* SMDS_MeshIDFactory::GetMesh()
 {

-        return myMesh;
+  return myMesh;

 }
 
 void SMDS_MeshIDFactory::emptyPool(int maxId)
 {
 }
 
 void SMDS_MeshIDFactory::emptyPool(int maxId)
 {

-        MESSAGE("SMDS_MeshIDFactory::emptyPool " << myMaxID << " --> " << maxId);
-        myMaxID = maxId;
-        myPoolOfID.clear();
+  myMaxID = maxId;
+  myPoolOfID.clear();

 }
 
 }
 

diff --git a/src/SMDS/SMDS_UnstructuredGrid.cxx b/src/SMDS/SMDS_UnstructuredGrid.cxx
index 5f8e73b191b2e2d46d04458c19f04e0feeb814b3..b3f743a4fec5ea4242f45c266a4dcb2a397f3a03 100644 (file)
--- a/src/SMDS/SMDS_UnstructuredGrid.cxx
+++ b/src/SMDS/SMDS_UnstructuredGrid.cxx
@@ -40,7 +40,6 @@ using namespace std;
 
 SMDS_CellLinks* SMDS_CellLinks::New()
 {
 
 SMDS_CellLinks* SMDS_CellLinks::New()
 {

-  MESSAGE("SMDS_CellLinks::New");

   return new SMDS_CellLinks();
 }
 
   return new SMDS_CellLinks();
 }
 


@@ -65,7 +64,6 @@ SMDS_CellLinks::~SMDS_CellLinks()
 
 SMDS_UnstructuredGrid* SMDS_UnstructuredGrid::New()
 {
 
 SMDS_UnstructuredGrid* SMDS_UnstructuredGrid::New()
 {

-  MESSAGE("SMDS_UnstructuredGrid::New");

   return new SMDS_UnstructuredGrid();
 }
 
   return new SMDS_UnstructuredGrid();
 }
 


@@ -85,27 +83,23 @@ SMDS_UnstructuredGrid::~SMDS_UnstructuredGrid()
 unsigned long SMDS_UnstructuredGrid::GetMTime()
 {
   unsigned long mtime = vtkUnstructuredGrid::GetMTime();
 unsigned long SMDS_UnstructuredGrid::GetMTime()
 {
   unsigned long mtime = vtkUnstructuredGrid::GetMTime();

-  MESSAGE("vtkUnstructuredGrid::GetMTime: " << mtime);

   return mtime;
 }
 // OUV_PORTING_VTK6: seems to be useless
 /*
 void SMDS_UnstructuredGrid::Update()
 {
   return mtime;
 }
 // OUV_PORTING_VTK6: seems to be useless
 /*
 void SMDS_UnstructuredGrid::Update()
 {

-  MESSAGE("SMDS_UnstructuredGrid::Update");

   return vtkUnstructuredGrid::Update();
 }
 
 void SMDS_UnstructuredGrid::UpdateInformation()
 {
   return vtkUnstructuredGrid::Update();
 }
 
 void SMDS_UnstructuredGrid::UpdateInformation()
 {

-  MESSAGE("SMDS_UnstructuredGrid::UpdateInformation");

   return vtkUnstructuredGrid::UpdateInformation();
 }
 */
 vtkPoints* SMDS_UnstructuredGrid::GetPoints()
 {
   // TODO erreur incomprehensible de la macro vtk GetPoints apparue avec la version paraview de fin aout 2010
   return vtkUnstructuredGrid::UpdateInformation();
 }
 */
 vtkPoints* SMDS_UnstructuredGrid::GetPoints()
 {
   // TODO erreur incomprehensible de la macro vtk GetPoints apparue avec la version paraview de fin aout 2010

-  //MESSAGE("*********************** SMDS_UnstructuredGrid::GetPoints " << this->Points << " " << vtkUnstructuredGrid::GetPoints());

   return this->Points;
 }
 
   return this->Points;
 }
 


@@ -116,7 +110,6 @@ int SMDS_UnstructuredGrid::InsertNextLinkedCell(int type, int npts, vtkIdType *p
     return vtkUnstructuredGrid::InsertNextLinkedCell(type, npts, pts);
 
   // --- type = VTK_POLYHEDRON
     return vtkUnstructuredGrid::InsertNextLinkedCell(type, npts, pts);
 
   // --- type = VTK_POLYHEDRON

-  //MESSAGE("InsertNextLinkedCell VTK_POLYHEDRON");

   int cellid = this->InsertNextCell(type, npts, pts);
 
   set<vtkIdType> setOfNodes;
   int cellid = this->InsertNextCell(type, npts, pts);
 
   set<vtkIdType> setOfNodes;


@@ -129,7 +122,6 @@ int SMDS_UnstructuredGrid::InsertNextLinkedCell(int type, int npts, vtkIdType *p
       i++;
       for (int k = 0; k < nbnodes; k++)
         {
       i++;
       for (int k = 0; k < nbnodes; k++)
         {

-          //MESSAGE(" cell " << cellid << " face " << nf << " node " << pts[i]);

           setOfNodes.insert(pts[i]);
           i++;
         }
           setOfNodes.insert(pts[i]);
           i++;
         }


@@ -138,7 +130,6 @@ int SMDS_UnstructuredGrid::InsertNextLinkedCell(int type, int npts, vtkIdType *p
   set<vtkIdType>::iterator it = setOfNodes.begin();
   for (; it != setOfNodes.end(); ++it)
     {
   set<vtkIdType>::iterator it = setOfNodes.begin();
   for (; it != setOfNodes.end(); ++it)
     {

-      //MESSAGE("reverse link for node " << *it << " cell " << cellid);

       this->Links->ResizeCellList(*it, 1);
       this->Links->AddCellReference(cellid, *it);
     }
       this->Links->ResizeCellList(*it, 1);
       this->Links->AddCellReference(cellid, *it);
     }


@@ -155,7 +146,7 @@ void SMDS_UnstructuredGrid::setSMDS_mesh(SMDS_Mesh *mesh)
 void SMDS_UnstructuredGrid::compactGrid(std::vector<int>& idNodesOldToNew, int newNodeSize,
                                         std::vector<int>& idCellsOldToNew, int newCellSize)
 {
 void SMDS_UnstructuredGrid::compactGrid(std::vector<int>& idNodesOldToNew, int newNodeSize,
                                         std::vector<int>& idCellsOldToNew, int newCellSize)
 {

-  MESSAGE("------------------------- SMDS_UnstructuredGrid::compactGrid " << newNodeSize << " " << newCellSize);//CHRONO(1);
+  //MESSAGE("------------------------- compactGrid " << newNodeSize << " " << newCellSize);//CHRONO(1);

   int alreadyCopied = 0;
 
   // --- if newNodeSize, create a new compacted vtkPoints
   int alreadyCopied = 0;
 
   // --- if newNodeSize, create a new compacted vtkPoints


@@ -165,7 +156,6 @@ void SMDS_UnstructuredGrid::compactGrid(std::vector<int>& idNodesOldToNew, int n
   newPoints->SetNumberOfPoints(newNodeSize);
   if (newNodeSize)
     {
   newPoints->SetNumberOfPoints(newNodeSize);
   if (newNodeSize)
     {

-      MESSAGE("-------------- compactGrid, newNodeSize " << newNodeSize);

       // rnv: to fix bug "21125: EDF 1233 SMESH: Degradation of precision in a test case for quadratic conversion"
       // using double type for storing coordinates of nodes instead float.
       int oldNodeSize = idNodesOldToNew.size();
       // rnv: to fix bug "21125: EDF 1233 SMESH: Degradation of precision in a test case for quadratic conversion"
       // using double type for storing coordinates of nodes instead float.
       int oldNodeSize = idNodesOldToNew.size();


@@ -194,7 +184,6 @@ void SMDS_UnstructuredGrid::compactGrid(std::vector<int>& idNodesOldToNew, int n
   newConnectivity->Initialize();
   int oldCellDataSize = this->Connectivity->GetData()->GetSize();
   newConnectivity->Allocate(oldCellDataSize);
   newConnectivity->Initialize();
   int oldCellDataSize = this->Connectivity->GetData()->GetSize();
   newConnectivity->Allocate(oldCellDataSize);

-  MESSAGE("oldCellSize="<< oldCellSize << " oldCellDataSize=" << oldCellDataSize);

 
   vtkUnsignedCharArray *newTypes = vtkUnsignedCharArray::New();
   newTypes->Initialize();
 
   vtkUnsignedCharArray *newTypes = vtkUnsignedCharArray::New();
   newTypes->Initialize();


@@ -230,11 +219,9 @@ void SMDS_UnstructuredGrid::compactGrid(std::vector<int>& idNodesOldToNew, int n
   newConnectivity->Squeeze();
 
   if (1/*newNodeSize*/)
   newConnectivity->Squeeze();
 
   if (1/*newNodeSize*/)

-    {
-      MESSAGE("------- newNodeSize, setPoints");
-      this->SetPoints(newPoints);
-      MESSAGE("NumberOfPoints: " << this->GetNumberOfPoints());
-    }
+  {
+    this->SetPoints(newPoints);
+  }

 
   if (vtkDoubleArray* diameters =
       vtkDoubleArray::SafeDownCast( vtkDataSet::CellData->GetScalars() )) // Balls
 
   if (vtkDoubleArray* diameters =
       vtkDoubleArray::SafeDownCast( vtkDataSet::CellData->GetScalars() )) // Balls


@@ -250,46 +237,46 @@ void SMDS_UnstructuredGrid::compactGrid(std::vector<int>& idNodesOldToNew, int n
   }
 
   if (this->FaceLocations)
   }
 
   if (this->FaceLocations)

+  {
+    vtkIdTypeArray *newFaceLocations = vtkIdTypeArray::New();
+    newFaceLocations->Initialize();
+    newFaceLocations->Allocate(newTypes->GetSize());
+    vtkIdTypeArray *newFaces = vtkIdTypeArray::New();
+    newFaces->Initialize();
+    newFaces->Allocate(this->Faces->GetSize());
+    for (int i = 0; i < oldCellSize; i++)

     {
     {

-      vtkIdTypeArray *newFaceLocations = vtkIdTypeArray::New();
-      newFaceLocations->Initialize();
-      newFaceLocations->Allocate(newTypes->GetSize());
-      vtkIdTypeArray *newFaces = vtkIdTypeArray::New();
-      newFaces->Initialize();
-      newFaces->Allocate(this->Faces->GetSize());
-      for (int i = 0; i < oldCellSize; i++)
+      if (this->Types->GetValue(i) == VTK_EMPTY_CELL)
+        continue;
+      int newCellId = idCellsOldToNew[i];
+      if (newTypes->GetValue(newCellId) == VTK_POLYHEDRON)
+      {
+        newFaceLocations->InsertNextValue(newFaces->GetMaxId()+1);
+        int oldFaceLoc = this->FaceLocations->GetValue(i);
+        int nCellFaces = this->Faces->GetValue(oldFaceLoc++);
+        newFaces->InsertNextValue(nCellFaces);
+        for (int n=0; n<nCellFaces; n++)

         {
         {

-          if (this->Types->GetValue(i) == VTK_EMPTY_CELL)
-            continue;
-          int newCellId = idCellsOldToNew[i];
-          if (newTypes->GetValue(newCellId) == VTK_POLYHEDRON)
-            {
-               newFaceLocations->InsertNextValue(newFaces->GetMaxId()+1);
-               int oldFaceLoc = this->FaceLocations->GetValue(i);
-               int nCellFaces = this->Faces->GetValue(oldFaceLoc++);
-               newFaces->InsertNextValue(nCellFaces);
-               for (int n=0; n<nCellFaces; n++)
-                 {
-                   int nptsInFace = this->Faces->GetValue(oldFaceLoc++);
-                   newFaces->InsertNextValue(nptsInFace);
-                   for (int k=0; k<nptsInFace; k++)
-                     {
-                       int oldpt = this->Faces->GetValue(oldFaceLoc++);
-                       newFaces->InsertNextValue(idNodesOldToNew[oldpt]);
-                     }
-                 }
-            }
-          else
-            {
-               newFaceLocations->InsertNextValue(-1);
-            }
+          int nptsInFace = this->Faces->GetValue(oldFaceLoc++);
+          newFaces->InsertNextValue(nptsInFace);
+          for (int k=0; k<nptsInFace; k++)
+          {
+            int oldpt = this->Faces->GetValue(oldFaceLoc++);
+            newFaces->InsertNextValue(idNodesOldToNew[oldpt]);
+          }

         }
         }

-      newFaceLocations->Squeeze();
-      newFaces->Squeeze();
-      this->SetCells(newTypes, newLocations, newConnectivity, newFaceLocations, newFaces);
-      newFaceLocations->Delete();
-      newFaces->Delete();
+      }
+      else
+      {
+        newFaceLocations->InsertNextValue(-1);
+      }

     }
     }

+    newFaceLocations->Squeeze();
+    newFaces->Squeeze();
+    this->SetCells(newTypes, newLocations, newConnectivity, newFaceLocations, newFaces);
+    newFaceLocations->Delete();
+    newFaces->Delete();
+  }

   else
   {
     this->SetCells(newTypes, newLocations, newConnectivity, FaceLocations, Faces);
   else
   {
     this->SetCells(newTypes, newLocations, newConnectivity, FaceLocations, Faces);


@@ -302,10 +289,12 @@ void SMDS_UnstructuredGrid::compactGrid(std::vector<int>& idNodesOldToNew, int n
   this->BuildLinks();
 }
 
   this->BuildLinks();
 }
 

-void SMDS_UnstructuredGrid::copyNodes(vtkPoints *newPoints, std::vector<int>& idNodesOldToNew, int& alreadyCopied,
-                                      int start, int end)
+void SMDS_UnstructuredGrid::copyNodes(vtkPoints *       newPoints,
+                                      std::vector<int>& idNodesOldToNew,
+                                      int&              alreadyCopied,
+                                      int               start,
+                                      int               end)

 {
 {

-  MESSAGE("copyNodes " << alreadyCopied << " " << start << " " << end << " size: " << end - start << " total: " << alreadyCopied + end - start);

   void *target = newPoints->GetVoidPointer(3 * alreadyCopied);
   void *source = this->Points->GetVoidPointer(3 * start);
   int nbPoints = end - start;
   void *target = newPoints->GetVoidPointer(3 * alreadyCopied);
   void *source = this->Points->GetVoidPointer(3 * start);
   int nbPoints = end - start;


@@ -327,7 +316,6 @@ void SMDS_UnstructuredGrid::copyBloc(vtkUnsignedCharArray *newTypes,
                                      int                   start,
                                      int                   end)
 {
                                      int                   start,
                                      int                   end)
 {

-  //MESSAGE("copyBloc " << alreadyCopied << " " << start << " " << end << " size: " << end - start << " total: " << alreadyCopied + end - start);

   for (int j = start; j < end; j++)
     {
       newTypes->SetValue(alreadyCopied, this->Types->GetValue(j));
   for (int j = start; j < end; j++)
     {
       newTypes->SetValue(alreadyCopied, this->Types->GetValue(j));


@@ -337,16 +325,13 @@ void SMDS_UnstructuredGrid::copyBloc(vtkUnsignedCharArray *newTypes,
       vtkIdType *oldPtsCell = 0;
       this->Connectivity->GetCell(oldLoc, nbpts, oldPtsCell);
       assert(nbpts < NBMAXNODESINCELL);
       vtkIdType *oldPtsCell = 0;
       this->Connectivity->GetCell(oldLoc, nbpts, oldPtsCell);
       assert(nbpts < NBMAXNODESINCELL);

-      //MESSAGE(j << " " << alreadyCopied << " " << (int)this->Types->GetValue(j) << " " << oldLoc << " " << nbpts );

       for (int l = 0; l < nbpts; l++)
         {
           int oldval = oldPtsCell[l];
           pointsCell[l] = idNodesOldToNew[oldval];
       for (int l = 0; l < nbpts; l++)
         {
           int oldval = oldPtsCell[l];
           pointsCell[l] = idNodesOldToNew[oldval];

-          //MESSAGE("   " << oldval << " " << pointsCell[l]);

         }
       /*int newcnt = */newConnectivity->InsertNextCell(nbpts, pointsCell);
       int newLoc = newConnectivity->GetInsertLocation(nbpts);
         }
       /*int newcnt = */newConnectivity->InsertNextCell(nbpts, pointsCell);
       int newLoc = newConnectivity->GetInsertLocation(nbpts);

-      //MESSAGE(newcnt << " " << newLoc);

       newLocations->SetValue(alreadyCopied, newLoc);
       alreadyCopied++;
     }
       newLocations->SetValue(alreadyCopied, newLoc);
       alreadyCopied++;
     }


@@ -356,8 +341,6 @@ int SMDS_UnstructuredGrid::CellIdToDownId(int vtkCellId)
 {
   if ((vtkCellId < 0) || (vtkCellId >= (int)_cellIdToDownId.size()))
   {
 {
   if ((vtkCellId < 0) || (vtkCellId >= (int)_cellIdToDownId.size()))
   {

-    //MESSAGE("SMDS_UnstructuredGrid::CellIdToDownId structure not up to date: vtkCellId="
-    //    << vtkCellId << " max="<< _cellIdToDownId.size());

     return -1;
   }
   return _cellIdToDownId[vtkCellId];
     return -1;
   }
   return _cellIdToDownId[vtkCellId];


@@ -1016,12 +999,13 @@ void SMDS_UnstructuredGrid::BuildLinks()
  * @param nodeDomains: map(original id --> map(domain --> duplicated node id))
  * @return ok if success.
  */
  * @param nodeDomains: map(original id --> map(domain --> duplicated node id))
  * @return ok if success.
  */

-SMDS_MeshCell* SMDS_UnstructuredGrid::extrudeVolumeFromFace(int vtkVolId,
-                                                  int domain1,
-                                                  int domain2,
-                                                  std::set<int>& originalNodes,
-                                                  std::map<int, std::map<int, int> >& nodeDomains,
-                                                  std::map<int, std::map<long, int> >& nodeQuadDomains)
+SMDS_MeshCell*
+SMDS_UnstructuredGrid::extrudeVolumeFromFace(int vtkVolId,
+                                             int domain1,
+                                             int domain2,
+                                             std::set<int>& originalNodes,
+                                             std::map<int, std::map<int, int> >& nodeDomains,
+                                             std::map<int, std::map<long, int> >& nodeQuadDomains)

 {
   //MESSAGE("extrudeVolumeFromFace " << vtkVolId);
   vector<vtkIdType> orderedOriginals;
 {
   //MESSAGE("extrudeVolumeFromFace " << vtkVolId);
   vector<vtkIdType> orderedOriginals;


@@ -1037,16 +1021,16 @@ SMDS_MeshCell* SMDS_UnstructuredGrid::extrudeVolumeFromFace(int vtkVolId,
   bool isQuadratic = false;
   switch (orderedOriginals.size())
   {
   bool isQuadratic = false;
   switch (orderedOriginals.size())
   {

-    case 3:
-      if (dim == 2)
-        isQuadratic = true;
-      break;
-    case 6:
-    case 8:
+  case 3:
+    if (dim == 2)

       isQuadratic = true;
       isQuadratic = true;

-      break;
-    default:
-      isQuadratic = false;
+    break;
+  case 6:
+  case 8:
+    isQuadratic = true;
+    break;
+  default:
+    isQuadratic = false;

       break;
   }
 
       break;
   }
 

diff --git a/src/SMESH/SMESH_Gen.cxx b/src/SMESH/SMESH_Gen.cxx
index 217806cd104384efec8584d6f93cdbc8eaabb823..84ffb381c138695efe739e5f4820f685fa80894b 100644 (file)
--- a/src/SMESH/SMESH_Gen.cxx
+++ b/src/SMESH/SMESH_Gen.cxx
@@ -64,12 +64,10 @@ using namespace std;
 
 SMESH_Gen::SMESH_Gen()
 {
 
 SMESH_Gen::SMESH_Gen()
 {

-  MESSAGE("SMESH_Gen::SMESH_Gen");

   _localId = 0;
   _hypId   = 0;
   _segmentation = _nbSegments = 10;
   SMDS_Mesh::_meshList.clear();
   _localId = 0;
   _hypId   = 0;
   _segmentation = _nbSegments = 10;
   SMDS_Mesh::_meshList.clear();

-  MESSAGE(SMDS_Mesh::_meshList.size());

   _compute_canceled = false;
   //vtkDebugLeaks::SetExitError(0);
 }
   _compute_canceled = false;
   //vtkDebugLeaks::SetExitError(0);
 }


@@ -82,7 +80,6 @@ SMESH_Gen::SMESH_Gen()
 
 SMESH_Gen::~SMESH_Gen()
 {
 
 SMESH_Gen::~SMESH_Gen()
 {

-  MESSAGE("SMESH_Gen::~SMESH_Gen");

   std::map < int, StudyContextStruct * >::iterator i_sc = _mapStudyContext.begin();
   for ( ; i_sc != _mapStudyContext.end(); ++i_sc )
   {
   std::map < int, StudyContextStruct * >::iterator i_sc = _mapStudyContext.begin();
   for ( ; i_sc != _mapStudyContext.end(); ++i_sc )
   {


@@ -102,7 +99,6 @@ SMESH_Mesh* SMESH_Gen::CreateMesh(int theStudyId, bool theIsEmbeddedMode)
   throw(SALOME_Exception)
 {
   Unexpect aCatch(SalomeException);
   throw(SALOME_Exception)
 {
   Unexpect aCatch(SalomeException);

-  MESSAGE("SMESH_Gen::CreateMesh");

 
   // Get studyContext, create it if it does'nt exist, with a SMESHDS_Document
   StudyContextStruct *aStudyContext = GetStudyContext(theStudyId);
 
   // Get studyContext, create it if it does'nt exist, with a SMESHDS_Document
   StudyContextStruct *aStudyContext = GetStudyContext(theStudyId);


@@ -131,7 +127,6 @@ bool SMESH_Gen::Compute(SMESH_Mesh &          aMesh,
                         const ::MeshDimension aDim /*=::MeshDim_3D*/,
                         TSetOfInt*            aShapesId /*=0*/)
 {
                         const ::MeshDimension aDim /*=::MeshDim_3D*/,
                         TSetOfInt*            aShapesId /*=0*/)
 {

-  MESSAGE("SMESH_Gen::Compute");

   MEMOSTAT;
 
   bool ret = true;
   MEMOSTAT;
 
   bool ret = true;


@@ -369,11 +364,10 @@ bool SMESH_Gen::Compute(SMESH_Mesh &          aMesh,
     ret = Compute( aMesh, aShape, aShapeOnly, /*anUpward=*/true, aDim, aShapesId );
   }
 
     ret = Compute( aMesh, aShape, aShapeOnly, /*anUpward=*/true, aDim, aShapesId );
   }
 

-  MESSAGE( "VSR - SMESH_Gen::Compute() finished, OK = " << ret);

   MEMOSTAT;
 
   SMESHDS_Mesh *myMesh = aMesh.GetMeshDS();
   MEMOSTAT;
 
   SMESHDS_Mesh *myMesh = aMesh.GetMeshDS();

-  MESSAGE("*** compactMesh after compute");
+  //MESSAGE("*** compactMesh after compute");

   myMesh->compactMesh();
 
   // fix quadratic mesh by bending iternal links near concave boundary
   myMesh->compactMesh();
 
   // fix quadratic mesh by bending iternal links near concave boundary


@@ -463,8 +457,6 @@ bool SMESH_Gen::Evaluate(SMESH_Mesh &          aMesh,
                          const bool            anUpward,
                          TSetOfInt*            aShapesId)
 {
                          const bool            anUpward,
                          TSetOfInt*            aShapesId)
 {

-  MESSAGE("SMESH_Gen::Evaluate");
-

   bool ret = true;
 
   SMESH_subMesh *sm = aMesh.GetSubMesh(aShape);
   bool ret = true;
 
   SMESH_subMesh *sm = aMesh.GetSubMesh(aShape);


@@ -707,8 +699,6 @@ static bool checkMissing(SMESH_Gen*                aGen,
   if ( aCheckedMap.count( aSubMesh ))
     return true;
 
   if ( aCheckedMap.count( aSubMesh ))
     return true;
 

-  //MESSAGE("=====checkMissing");
-

   int ret = true;
   SMESH_Algo* algo = 0;
 
   int ret = true;
   SMESH_Algo* algo = 0;
 


@@ -829,8 +819,6 @@ bool SMESH_Gen::GetAlgoState(SMESH_Mesh&               theMesh,
                              const TopoDS_Shape&       theShape,
                              list< TAlgoStateError > & theErrors)
 {
                              const TopoDS_Shape&       theShape,
                              list< TAlgoStateError > & theErrors)
 {

-  //MESSAGE("SMESH_Gen::CheckAlgoState");
-

   bool ret = true;
   bool hasAlgo = false;
 
   bool ret = true;
   bool hasAlgo = false;
 


@@ -908,8 +896,6 @@ bool SMESH_Gen::GetAlgoState(SMESH_Mesh&               theMesh,
   // well defined
   // ----------------------------------------------------------------
 
   // well defined
   // ----------------------------------------------------------------
 

-  //MESSAGE( "---info on missing hypothesis and find out if all needed algos are");
-

   // find max dim of global algo
   int aTopAlgoDim = 0;
   for (dim = 3; dim > 0; dim--)
   // find max dim of global algo
   int aTopAlgoDim = 0;
   for (dim = 3; dim > 0; dim--)

diff --git a/src/SMESH/SMESH_Hypothesis.cxx b/src/SMESH/SMESH_Hypothesis.cxx
index ac9ca2040cc7c3b2dcdbc9439a7e0ae02ba1dbb8..d51ae2a45cef0c9e50cc1e8eba60ac4a06133810 100644 (file)
--- a/src/SMESH/SMESH_Hypothesis.cxx
+++ b/src/SMESH/SMESH_Hypothesis.cxx
@@ -59,7 +59,6 @@ SMESH_Hypothesis::SMESH_Hypothesis(int hypId,
 
 SMESH_Hypothesis::~SMESH_Hypothesis()
 {
 
 SMESH_Hypothesis::~SMESH_Hypothesis()
 {

-  MESSAGE("SMESH_Hypothesis::~SMESH_Hypothesis");

   StudyContextStruct* myStudyContext = _gen->GetStudyContext(_studyId);
   myStudyContext->mapHypothesis[_hypId] = 0;
 }
   StudyContextStruct* myStudyContext = _gen->GetStudyContext(_studyId);
   myStudyContext->mapHypothesis[_hypId] = 0;
 }


@@ -115,8 +114,6 @@ int SMESH_Hypothesis::GetStudyId() const
 
 void SMESH_Hypothesis::NotifySubMeshesHypothesisModification()
 {
 
 void SMESH_Hypothesis::NotifySubMeshesHypothesisModification()
 {

-  MESSAGE("SMESH_Hypothesis::NotifySubMeshesHypothesisModification");
-

   // for all meshes in study
 
   StudyContextStruct* myStudyContext = _gen->GetStudyContext(_studyId);
   // for all meshes in study
 
   StudyContextStruct* myStudyContext = _gen->GetStudyContext(_studyId);

diff --git a/src/SMESH/SMESH_MeshEditor.cxx b/src/SMESH/SMESH_MeshEditor.cxx
index a37950e411a9a58af2f95936f903fcfbbc46bed2..82e091890f5537e77acabd1980eddef0ff1ec6c2 100644 (file)
--- a/src/SMESH/SMESH_MeshEditor.cxx
+++ b/src/SMESH/SMESH_MeshEditor.cxx
@@ -683,7 +683,6 @@ static bool getNodesFromTwoTria(const SMDS_MeshElement * theTria1,
 bool SMESH_MeshEditor::InverseDiag (const SMDS_MeshElement * theTria1,
                                     const SMDS_MeshElement * theTria2 )
 {
 bool SMESH_MeshEditor::InverseDiag (const SMDS_MeshElement * theTria1,
                                     const SMDS_MeshElement * theTria2 )
 {

-  MESSAGE("InverseDiag");

   myLastCreatedElems.Clear();
   myLastCreatedNodes.Clear();
 
   myLastCreatedElems.Clear();
   myLastCreatedNodes.Clear();
 


@@ -888,8 +887,6 @@ bool SMESH_MeshEditor::InverseDiag (const SMDS_MeshNode * theNode1,
   myLastCreatedElems.Clear();
   myLastCreatedNodes.Clear();
 
   myLastCreatedElems.Clear();
   myLastCreatedNodes.Clear();
 

-  MESSAGE( "::InverseDiag()" );
-

   const SMDS_MeshElement *tr1, *tr2;
   if ( !findTriangles( theNode1, theNode2, tr1, tr2 ))
     return false;
   const SMDS_MeshElement *tr1, *tr2;
   if ( !findTriangles( theNode1, theNode2, tr1, tr2 ))
     return false;


@@ -1011,8 +1008,6 @@ bool SMESH_MeshEditor::DeleteDiag (const SMDS_MeshNode * theNode1,
   myLastCreatedElems.Clear();
   myLastCreatedNodes.Clear();
 
   myLastCreatedElems.Clear();
   myLastCreatedNodes.Clear();
 

-  MESSAGE( "::DeleteDiag()" );
-

   const SMDS_MeshElement *tr1, *tr2;
   if ( !findTriangles( theNode1, theNode2, tr1, tr2 ))
     return false;
   const SMDS_MeshElement *tr1, *tr2;
   if ( !findTriangles( theNode1, theNode2, tr1, tr2 ))
     return false;


@@ -1105,7 +1100,6 @@ bool SMESH_MeshEditor::DeleteDiag (const SMDS_MeshNode * theNode1,
 
 bool SMESH_MeshEditor::Reorient (const SMDS_MeshElement * theElem)
 {
 
 bool SMESH_MeshEditor::Reorient (const SMDS_MeshElement * theElem)
 {

-  MESSAGE("Reorient");

   myLastCreatedElems.Clear();
   myLastCreatedNodes.Clear();
 
   myLastCreatedElems.Clear();
   myLastCreatedNodes.Clear();
 


@@ -2931,8 +2925,6 @@ bool SMESH_MeshEditor::QuadToTri (TIDSortedElemSet & theElems,
   myLastCreatedElems.Clear();
   myLastCreatedNodes.Clear();
 
   myLastCreatedElems.Clear();
   myLastCreatedNodes.Clear();
 

-  MESSAGE( "::QuadToTri()" );
-

   SMESHDS_Mesh * aMesh = GetMeshDS();
 
   Handle(Geom_Surface) surface;
   SMESHDS_Mesh * aMesh = GetMeshDS();
 
   Handle(Geom_Surface) surface;


@@ -3153,8 +3145,6 @@ bool SMESH_MeshEditor::TriToQuad (TIDSortedElemSet &                   theElems,
   myLastCreatedElems.Clear();
   myLastCreatedNodes.Clear();
 
   myLastCreatedElems.Clear();
   myLastCreatedNodes.Clear();
 

-  MESSAGE( "::TriToQuad()" );
-

   if ( !theCrit.get() )
     return false;
 
   if ( !theCrit.get() )
     return false;
 


@@ -3938,8 +3928,6 @@ void SMESH_MeshEditor::Smooth (TIDSortedElemSet &          theElems,
   myLastCreatedElems.Clear();
   myLastCreatedNodes.Clear();
 
   myLastCreatedElems.Clear();
   myLastCreatedNodes.Clear();
 

-  MESSAGE((theSmoothMethod==LAPLACIAN ? "LAPLACIAN" : "CENTROIDAL") << "--::Smooth()");
-

   if ( theTgtAspectRatio < 1.0 )
     theTgtAspectRatio = 1.0;
 
   if ( theTgtAspectRatio < 1.0 )
     theTgtAspectRatio = 1.0;
 


@@ -4476,7 +4464,6 @@ void SMESH_MeshEditor::sweepElement(const SMDS_MeshElement*               elem,
                                     const size_t                          nbSteps,
                                     SMESH_SequenceOfElemPtr&              srcElements)
 {
                                     const size_t                          nbSteps,
                                     SMESH_SequenceOfElemPtr&              srcElements)
 {

-  //MESSAGE("sweepElement " << nbSteps);

   SMESHDS_Mesh* aMesh = GetMeshDS();
 
   const int           nbNodes = elem->NbNodes();
   SMESHDS_Mesh* aMesh = GetMeshDS();
 
   const int           nbNodes = elem->NbNodes();


@@ -5368,7 +5355,6 @@ SMESH_MeshEditor::RotationSweep(TIDSortedElemSet   theElemSets[2],
   // source elements for each generated one
   SMESH_SequenceOfElemPtr srcElems, srcNodes;
 
   // source elements for each generated one
   SMESH_SequenceOfElemPtr srcElems, srcNodes;
 

-  MESSAGE( "RotationSweep()");

   gp_Trsf aTrsf;
   aTrsf.SetRotation( theAxis, theAngle );
   gp_Trsf aTrsf2;
   gp_Trsf aTrsf;
   aTrsf.SetRotation( theAxis, theAngle );
   gp_Trsf aTrsf2;


@@ -5939,7 +5925,6 @@ SMESH_MeshEditor::ExtrusionAlongTrack (TIDSortedElemSet     theElements[2],
                                        const gp_Pnt&        theRefPoint,
                                        const bool           theMakeGroups)
 {
                                        const gp_Pnt&        theRefPoint,
                                        const bool           theMakeGroups)
 {

-  MESSAGE("ExtrusionAlongTrack");

   myLastCreatedElems.Clear();
   myLastCreatedNodes.Clear();
 
   myLastCreatedElems.Clear();
   myLastCreatedNodes.Clear();
 


@@ -6732,37 +6717,29 @@ SMESH_MeshEditor::Transform (TIDSortedElemSet & theElems,
   string groupPostfix;
   switch ( theTrsf.Form() ) {
   case gp_PntMirror:
   string groupPostfix;
   switch ( theTrsf.Form() ) {
   case gp_PntMirror:

-    MESSAGE("gp_PntMirror");

     needReverse = true;
     groupPostfix = "mirrored";
     break;
   case gp_Ax1Mirror:
     needReverse = true;
     groupPostfix = "mirrored";
     break;
   case gp_Ax1Mirror:

-    MESSAGE("gp_Ax1Mirror");

     groupPostfix = "mirrored";
     break;
   case gp_Ax2Mirror:
     groupPostfix = "mirrored";
     break;
   case gp_Ax2Mirror:

-    MESSAGE("gp_Ax2Mirror");

     needReverse = true;
     groupPostfix = "mirrored";
     break;
   case gp_Rotation:
     needReverse = true;
     groupPostfix = "mirrored";
     break;
   case gp_Rotation:

-    MESSAGE("gp_Rotation");

     groupPostfix = "rotated";
     break;
   case gp_Translation:
     groupPostfix = "rotated";
     break;
   case gp_Translation:

-    MESSAGE("gp_Translation");

     groupPostfix = "translated";
     break;
   case gp_Scale:
     groupPostfix = "translated";
     break;
   case gp_Scale:

-    MESSAGE("gp_Scale");

     groupPostfix = "scaled";
     break;
   case gp_CompoundTrsf: // different scale by axis
     groupPostfix = "scaled";
     break;
   case gp_CompoundTrsf: // different scale by axis

-    MESSAGE("gp_CompoundTrsf");

     groupPostfix = "scaled";
     break;
   default:
     groupPostfix = "scaled";
     break;
   default:

-    MESSAGE("default");

     needReverse = false;
     groupPostfix = "transformed";
   }
     needReverse = false;
     groupPostfix = "transformed";
   }


@@ -7271,7 +7248,6 @@ int SMESH_MeshEditor::SimplifyFace (const vector<const SMDS_MeshNode *>& faceNod
 
 void SMESH_MeshEditor::MergeNodes (TListOfListOfNodes & theGroupsOfNodes)
 {
 
 void SMESH_MeshEditor::MergeNodes (TListOfListOfNodes & theGroupsOfNodes)
 {

-  MESSAGE("MergeNodes");

   myLastCreatedElems.Clear();
   myLastCreatedNodes.Clear();
 
   myLastCreatedElems.Clear();
   myLastCreatedNodes.Clear();
 


@@ -8120,7 +8096,6 @@ SMESH_MeshEditor::SewFreeBorder (const SMDS_MeshNode* theBordFirstNode,
   myLastCreatedElems.Clear();
   myLastCreatedNodes.Clear();
 
   myLastCreatedElems.Clear();
   myLastCreatedNodes.Clear();
 

-  MESSAGE("::SewFreeBorder()");

   Sew_Error aResult = SEW_OK;
 
   // ====================================
   Sew_Error aResult = SEW_OK;
 
   // ====================================


@@ -9757,7 +9732,6 @@ SMESH_MeshEditor::SewSideElements (TIDSortedElemSet&    theSide1,
   myLastCreatedElems.Clear();
   myLastCreatedNodes.Clear();
 
   myLastCreatedElems.Clear();
   myLastCreatedNodes.Clear();
 

-  MESSAGE ("::::SewSideElements()");

   if ( theSide1.size() != theSide2.size() )
     return SEW_DIFF_NB_OF_ELEMENTS;
 
   if ( theSide1.size() != theSide2.size() )
     return SEW_DIFF_NB_OF_ELEMENTS;
 


@@ -10538,7 +10512,6 @@ bool SMESH_MeshEditor::doubleNodes(SMESHDS_Mesh*           theMeshDS,
                                    TNodeNodeMap&           theNodeNodeMap,
                                    const bool              theIsDoubleElem )
 {
                                    TNodeNodeMap&           theNodeNodeMap,
                                    const bool              theIsDoubleElem )
 {

-  MESSAGE("doubleNodes");

   // iterate through element and duplicate them (by nodes duplication)
   bool res = false;
   std::vector<const SMDS_MeshNode*> newNodes;
   // iterate through element and duplicate them (by nodes duplication)
   bool res = false;
   std::vector<const SMDS_MeshNode*> newNodes;


@@ -10603,7 +10576,6 @@ bool SMESH_MeshEditor::doubleNodes(SMESHDS_Mesh*           theMeshDS,
 bool SMESH_MeshEditor::DoubleNodes( const std::list< int >& theListOfNodes,
                                     const std::list< int >& theListOfModifiedElems )
 {
 bool SMESH_MeshEditor::DoubleNodes( const std::list< int >& theListOfNodes,
                                     const std::list< int >& theListOfModifiedElems )
 {

-  MESSAGE("DoubleNodes");

   myLastCreatedElems.Clear();
   myLastCreatedNodes.Clear();
 
   myLastCreatedElems.Clear();
   myLastCreatedNodes.Clear();
 


@@ -10677,10 +10649,9 @@ bool SMESH_MeshEditor::DoubleNodes( const std::list< int >& theListOfNodes,
     const SMDS_MeshElement* anElem = anElemToNodesIter->first;
     vector<const SMDS_MeshNode*> aNodeArr = anElemToNodesIter->second;
     if ( anElem )
     const SMDS_MeshElement* anElem = anElemToNodesIter->first;
     vector<const SMDS_MeshNode*> aNodeArr = anElemToNodesIter->second;
     if ( anElem )

-      {
-      MESSAGE("ChangeElementNodes");
+    {

       aMeshDS->ChangeElementNodes( anElem, &aNodeArr[ 0 ], anElem->NbNodes() );
       aMeshDS->ChangeElementNodes( anElem, &aNodeArr[ 0 ], anElem->NbNodes() );

-      }
+    }

   }
 
   return true;
   }
 
   return true;


@@ -10788,7 +10759,6 @@ bool SMESH_MeshEditor::AffectedElemGroupsInRegion( const TIDSortedElemSet& theEl
         continue;
       gp_XYZ normal;
       SMESH_MeshAlgos::FaceNormal( anElem, normal, /*normalized=*/true );
         continue;
       gp_XYZ normal;
       SMESH_MeshAlgos::FaceNormal( anElem, normal, /*normalized=*/true );

-      MESSAGE("element " << ielem++ <<  " normal " << normal.X() << " " << normal.Y() << " " << normal.Z());

       std::set<const SMDS_MeshNode*> nodesElem;
       nodesElem.clear();
       SMDS_ElemIteratorPtr nodeItr = anElem->nodesIterator();
       std::set<const SMDS_MeshNode*> nodesElem;
       nodesElem.clear();
       SMDS_ElemIteratorPtr nodeItr = anElem->nodesIterator();


@@ -10800,7 +10770,6 @@ bool SMESH_MeshEditor::AffectedElemGroupsInRegion( const TIDSortedElemSet& theEl
       std::set<const SMDS_MeshNode*>::iterator nodit = nodesElem.begin();
       for (; nodit != nodesElem.end(); nodit++)
       {
       std::set<const SMDS_MeshNode*>::iterator nodit = nodesElem.begin();
       for (; nodit != nodesElem.end(); nodit++)
       {

-        MESSAGE("  noeud ");

         const SMDS_MeshNode* aNode = *nodit;
         if ( !aNode || theNodesNot.find(aNode) != theNodesNot.end() )
           continue;
         const SMDS_MeshNode* aNode = *nodit;
         if ( !aNode || theNodesNot.find(aNode) != theNodesNot.end() )
           continue;


@@ -10810,7 +10779,6 @@ bool SMESH_MeshEditor::AffectedElemGroupsInRegion( const TIDSortedElemSet& theEl
         SMDS_ElemIteratorPtr backElemItr = aNode->GetInverseElementIterator();
         while ( backElemItr->more() )
         {
         SMDS_ElemIteratorPtr backElemItr = aNode->GetInverseElementIterator();
         while ( backElemItr->more() )
         {

-          MESSAGE("    backelem ");

           const SMDS_MeshElement* curElem = backElemItr->next();
           if (alreadyCheckedElems.find(curElem) != alreadyCheckedElems.end())
             continue;
           const SMDS_MeshElement* curElem = backElemItr->next();
           if (alreadyCheckedElems.find(curElem) != alreadyCheckedElems.end())
             continue;


@@ -10832,10 +10800,8 @@ bool SMESH_MeshEditor::AffectedElemGroupsInRegion( const TIDSortedElemSet& theEl
           p.SetCoord( x/nb -aNode->X(),
                       y/nb -aNode->Y(),
                       z/nb -aNode->Z() );
           p.SetCoord( x/nb -aNode->X(),
                       y/nb -aNode->Y(),
                       z/nb -aNode->Z() );

-          MESSAGE("      check " << p.X() << " " << p.Y() << " " << p.Z());

           if (normal*p > 0)
           {
           if (normal*p > 0)
           {

-            MESSAGE("    --- inserted")

             theAffectedElems.insert( curElem );
           }
           else if (curElem->GetType() == SMDSAbs_Edge)
             theAffectedElems.insert( curElem );
           }
           else if (curElem->GetType() == SMDSAbs_Edge)


@@ -10861,7 +10827,6 @@ bool SMESH_MeshEditor::AffectedElemGroupsInRegion( const TIDSortedElemSet& theEl
       }
       if (onside)
       {
       }
       if (onside)
       {

-        MESSAGE("    --- edge onside inserted")

         theAffectedElems.insert(anEdge);
       }
     }
         theAffectedElems.insert(anEdge);
       }
     }


@@ -10886,21 +10851,18 @@ bool SMESH_MeshEditor::AffectedElemGroupsInRegion( const TIDSortedElemSet& theEl
     int ielem;
     for ( ielem = 1;  elemItr != theElems.end(); ++elemItr )
     {
     int ielem;
     for ( ielem = 1;  elemItr != theElems.end(); ++elemItr )
     {

-      MESSAGE("element " << ielem++);

       SMDS_MeshElement* anElem = (SMDS_MeshElement*)*elemItr;
       if (!anElem)
         continue;
       SMDS_ElemIteratorPtr nodeItr = anElem->nodesIterator();
       while ( nodeItr->more() )
       {
       SMDS_MeshElement* anElem = (SMDS_MeshElement*)*elemItr;
       if (!anElem)
         continue;
       SMDS_ElemIteratorPtr nodeItr = anElem->nodesIterator();
       while ( nodeItr->more() )
       {

-        MESSAGE("  noeud ");

         const SMDS_MeshNode* aNode = cast2Node(nodeItr->next());
         if ( !aNode || theNodesNot.find(aNode) != theNodesNot.end() )
           continue;
         SMDS_ElemIteratorPtr backElemItr = aNode->GetInverseElementIterator();
         while ( backElemItr->more() )
         {
         const SMDS_MeshNode* aNode = cast2Node(nodeItr->next());
         if ( !aNode || theNodesNot.find(aNode) != theNodesNot.end() )
           continue;
         SMDS_ElemIteratorPtr backElemItr = aNode->GetInverseElementIterator();
         while ( backElemItr->more() )
         {

-          MESSAGE("    backelem ");

           const SMDS_MeshElement* curElem = backElemItr->next();
           if ( curElem && theElems.find(curElem) == theElems.end() &&
               ( bsc3d.get() ?
           const SMDS_MeshElement* curElem = backElemItr->next();
           if ( curElem && theElems.find(curElem) == theElems.end() &&
               ( bsc3d.get() ?


@@ -10986,10 +10948,6 @@ bool SMESH_MeshEditor::DoubleNodesInRegion( const TIDSortedElemSet& theElems,
  */
 double SMESH_MeshEditor::OrientedAngle(const gp_Pnt& p0, const gp_Pnt& p1, const gp_Pnt& g1, const gp_Pnt& g2)
 {
  */
 double SMESH_MeshEditor::OrientedAngle(const gp_Pnt& p0, const gp_Pnt& p1, const gp_Pnt& g1, const gp_Pnt& g2)
 {

-//  MESSAGE("    p0: " << p0.X() << " " << p0.Y() << " " << p0.Z());
-//  MESSAGE("    p1: " << p1.X() << " " << p1.Y() << " " << p1.Z());
-//  MESSAGE("    g1: " << g1.X() << " " << g1.Y() << " " << g1.Z());
-//  MESSAGE("    g2: " << g2.X() << " " << g2.Y() << " " << g2.Z());

   gp_Vec vref(p0, p1);
   gp_Vec v1(p0, g1);
   gp_Vec v2(p0, g2);
   gp_Vec vref(p0, p1);
   gp_Vec v1(p0, g1);
   gp_Vec v2(p0, g2);

diff --git a/src/SMESH/memoire.h b/src/SMESH/memoire.h
index c742544080564135a6155349c2bf9cd2be527851..b153ac73d75b7fd3cdf5437ccc1256a021aab9cb 100644 (file)
--- a/src/SMESH/memoire.h
+++ b/src/SMESH/memoire.h
@@ -39,7 +39,7 @@ void memostat(const char* f, int l)
 }
 
 #if defined(_DEBUG_) || defined(_DEBUG)
 }
 
 #if defined(_DEBUG_) || defined(_DEBUG)

-#define MEMOSTAT memostat( __FILE__, __LINE__ )
+#define MEMOSTAT //memostat( __FILE__, __LINE__ )

 #else
 #define MEMOSTAT
 #endif
 #else
 #define MEMOSTAT
 #endif

diff --git a/src/SMESHClient/SMESH_Client.cxx b/src/SMESHClient/SMESH_Client.cxx
index a2a29c7bc38a02fa74f79506667f1ac770bf9966..c9c4fdc7f60569175f305433e685c0e75a2189aa 100644 (file)
--- a/src/SMESHClient/SMESH_Client.cxx
+++ b/src/SMESHClient/SMESH_Client.cxx
@@ -54,7 +54,7 @@
 #endif
 
 #ifdef _DEBUG_
 #endif
 
 #ifdef _DEBUG_

-static int MYDEBUG = 1;
+static int MYDEBUG = 0;

 #else
 static int MYDEBUG = 0;
 #endif
 #else
 static int MYDEBUG = 0;
 #endif


@@ -886,20 +886,22 @@ bool
 SMESH_Client::Update(bool theIsClear)
 {
   bool anIsModified = true;
 SMESH_Client::Update(bool theIsClear)
 {
   bool anIsModified = true;

-  if(mySMESHDSMesh){
-        MESSAGE("Update mySMESHDSMesh");
+  if(mySMESHDSMesh)
+  {
+    if ( MYDEBUG ) MESSAGE("Update mySMESHDSMesh");

     SMESHDS_Script* aScript = mySMESHDSMesh->GetScript();
     anIsModified = aScript->IsModified();
     aScript->SetModified(false);
     SMESHDS_Script* aScript = mySMESHDSMesh->GetScript();
     anIsModified = aScript->IsModified();
     aScript->SetModified(false);

-  }else{
-        MESSAGE("Update CORBA");
+  }
+  else
+  {
+    if ( MYDEBUG ) MESSAGE("Update CORBA");

     SMESH::log_array_var aSeq = myMeshServer->GetLog( theIsClear );
     CORBA::Long aLength = aSeq->length();
     anIsModified = aLength > 0;
     SMESH::log_array_var aSeq = myMeshServer->GetLog( theIsClear );
     CORBA::Long aLength = aSeq->length();
     anIsModified = aLength > 0;

-    if( MYDEBUG )
-      MESSAGE( "Update: length of the script is "<<aLength );
+    if ( MYDEBUG ) MESSAGE( "Update: length of the script is "<<aLength );

 
 

-    if(!anIsModified)
+    if ( !anIsModified )

       return false;
 
     // update client mesh structure by logged changes commands
       return false;
 
     // update client mesh structure by logged changes commands

diff --git a/src/SMESHDS/SMESHDS_Mesh.cxx b/src/SMESHDS/SMESHDS_Mesh.cxx
index 79713c80c27608b2ce2bf047421606ce6d9eab68..7c233db58e7c600d57822f4c449c121d2103fb61 100644 (file)
--- a/src/SMESHDS/SMESHDS_Mesh.cxx
+++ b/src/SMESHDS/SMESHDS_Mesh.cxx
@@ -220,7 +220,6 @@ bool SMESHDS_Mesh::ChangeElementNodes(const SMDS_MeshElement * elem,
                                       const SMDS_MeshNode    * nodes[],
                                       const int                nbnodes)
 {
                                       const SMDS_MeshNode    * nodes[],
                                       const int                nbnodes)
 {

-  //MESSAGE("SMESHDS_Mesh::ChangeElementNodes");

   if ( ! SMDS_Mesh::ChangeElementNodes( elem, nodes, nbnodes ))
     return false;
 
   if ( ! SMDS_Mesh::ChangeElementNodes( elem, nodes, nbnodes ))
     return false;
 


@@ -978,7 +977,6 @@ void SMESHDS_Mesh::RemoveFreeElement(const SMDS_MeshElement * elt,
                                      SMESHDS_SubMesh *        subMesh,
                                      bool                     fromGroups)
 {
                                      SMESHDS_SubMesh *        subMesh,
                                      bool                     fromGroups)
 {

-  //MESSAGE(" --------------------------------> SMESHDS_Mesh::RemoveFreeElement " << subMesh << " " << fromGroups);

   if (elt->GetType() == SMDSAbs_Node) {
     RemoveFreeNode( static_cast<const SMDS_MeshNode*>(elt), subMesh, fromGroups);
     return;
   if (elt->GetType() == SMDSAbs_Node) {
     RemoveFreeNode( static_cast<const SMDS_MeshNode*>(elt), subMesh, fromGroups);
     return;


@@ -1345,7 +1343,6 @@ int SMESHDS_Mesh::AddCompoundSubmesh(const TopoDS_Shape& S,
     bool all = ( type == TopAbs_SHAPE );
     if ( all ) // corresponding simple submesh may exist
       aMainIndex = -aMainIndex;
     bool all = ( type == TopAbs_SHAPE );
     if ( all ) // corresponding simple submesh may exist
       aMainIndex = -aMainIndex;

-    //MESSAGE("AddCompoundSubmesh index = " << aMainIndex );

     SMESHDS_SubMesh * aNewSub = NewSubMesh( aMainIndex );
     if ( !aNewSub->IsComplexSubmesh() ) // is empty
     {
     SMESHDS_SubMesh * aNewSub = NewSubMesh( aMainIndex );
     if ( !aNewSub->IsComplexSubmesh() ) // is empty
     {


@@ -2116,18 +2113,18 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
                                                const SMDS_MeshNode * n2,
                                                const SMDS_MeshNode * n3,
                                                const SMDS_MeshNode * n4,
                                                const SMDS_MeshNode * n2,
                                                const SMDS_MeshNode * n3,
                                                const SMDS_MeshNode * n4,

-                                               const SMDS_MeshNode * n5, 
-                                               const SMDS_MeshNode * n6, 
+                                               const SMDS_MeshNode * n5,
+                                               const SMDS_MeshNode * n6,

                                                const SMDS_MeshNode * n7,
                                                const SMDS_MeshNode * n7,

-                                               const SMDS_MeshNode * n8, 
+                                               const SMDS_MeshNode * n8,

                                                const SMDS_MeshNode * n12,
                                                const SMDS_MeshNode * n23,
                                                const SMDS_MeshNode * n34,
                                                const SMDS_MeshNode * n12,
                                                const SMDS_MeshNode * n23,
                                                const SMDS_MeshNode * n34,

-                                               const SMDS_MeshNode * n41, 
+                                               const SMDS_MeshNode * n41,

                                                const SMDS_MeshNode * n56,
                                                const SMDS_MeshNode * n67,
                                                const SMDS_MeshNode * n78,
                                                const SMDS_MeshNode * n56,
                                                const SMDS_MeshNode * n67,
                                                const SMDS_MeshNode * n78,

-                                               const SMDS_MeshNode * n85, 
+                                               const SMDS_MeshNode * n85,

                                                const SMDS_MeshNode * n15,
                                                const SMDS_MeshNode * n26,
                                                const SMDS_MeshNode * n37,
                                                const SMDS_MeshNode * n15,
                                                const SMDS_MeshNode * n26,
                                                const SMDS_MeshNode * n37,


@@ -2155,7 +2152,7 @@ void SMESHDS_Mesh::compactMesh()
   int newNodeSize = 0;
   int nbNodes = myNodes.size();
   int nbVtkNodes = myGrid->GetNumberOfPoints();
   int newNodeSize = 0;
   int nbNodes = myNodes.size();
   int nbVtkNodes = myGrid->GetNumberOfPoints();

-  MESSAGE("nbNodes=" << nbNodes << " nbVtkNodes=" << nbVtkNodes);
+  //MESSAGE("nbNodes=" << nbNodes << " nbVtkNodes=" << nbVtkNodes);

   int nbNodeTemp = nbVtkNodes;
   if (nbNodes > nbVtkNodes)
     nbNodeTemp = nbNodes;
   int nbNodeTemp = nbVtkNodes;
   if (nbNodes > nbVtkNodes)
     nbNodeTemp = nbNodes;


@@ -2164,22 +2161,22 @@ void SMESHDS_Mesh::compactMesh()
   idNodesOldToNew.resize(nbNodeTemp, -1); // all unused id will be -1
 
   for (int i = 0; i < nbNodes; i++)
   idNodesOldToNew.resize(nbNodeTemp, -1); // all unused id will be -1
 
   for (int i = 0; i < nbNodes; i++)

+  {
+    if (myNodes[i])

     {
     {

-      if (myNodes[i])
-        {
-          int vtkid = myNodes[i]->getVtkId();
-          idNodesOldToNew[vtkid] = i; // old vtkId --> old smdsId (valid smdsId are >= 0)
-          newNodeSize++;
-        }
+      int vtkid = myNodes[i]->getVtkId();
+      idNodesOldToNew[vtkid] = i; // old vtkId --> old smdsId (valid smdsId are >= 0)
+      newNodeSize++;

     }
     }

+  }

   bool areNodesModified = (newNodeSize < nbVtkNodes);
   bool areNodesModified = (newNodeSize < nbVtkNodes);

-  MESSAGE("------------------------- compactMesh Nodes Modified: " << areNodesModified);
+  //MESSAGE("------------------------- compactMesh Nodes Modified: " << areNodesModified);

   areNodesModified = true;
 
   int newCellSize = 0;
   int nbCells = myCells.size();
   int nbVtkCells = myGrid->GetNumberOfCells();
   areNodesModified = true;
 
   int newCellSize = 0;
   int nbCells = myCells.size();
   int nbVtkCells = myGrid->GetNumberOfCells();

-  MESSAGE("nbCells=" << nbCells << " nbVtkCells=" << nbVtkCells);
+  //MESSAGE("nbCells=" << nbCells << " nbVtkCells=" << nbVtkCells);

   int nbCellTemp = nbVtkCells;
   if (nbCells > nbVtkCells)
     nbCellTemp = nbCells;
   int nbCellTemp = nbVtkCells;
   if (nbCells > nbVtkCells)
     nbCellTemp = nbCells;


@@ -2188,15 +2185,15 @@ void SMESHDS_Mesh::compactMesh()
   idCellsOldToNew.resize(nbCellTemp, -1); // all unused id will be -1
 
   for (int i = 0; i < nbCells; i++)
   idCellsOldToNew.resize(nbCellTemp, -1); // all unused id will be -1
 
   for (int i = 0; i < nbCells; i++)

+  {
+    if (myCells[i])

     {
     {

-      if (myCells[i])
-        {
-//          //idCellsOldToNew[i] = myCellIdVtkToSmds[i]; // valid vtk indexes are > = 0
-//          int vtkid = myCells[i]->getVtkId();
-//          idCellsOldToNew[vtkid] = i; // old vtkId --> old smdsId (not used in input)
-          newCellSize++;
-        }
+      //          //idCellsOldToNew[i] = myCellIdVtkToSmds[i]; // valid vtk indexes are > = 0
+      //          int vtkid = myCells[i]->getVtkId();
+      //          idCellsOldToNew[vtkid] = i; // old vtkId --> old smdsId (not used in input)
+      newCellSize++;

     }
     }

+  }

   if (areNodesModified)
     myGrid->compactGrid(idNodesOldToNew, newNodeSize, idCellsOldToNew, newCellSize);
   else
   if (areNodesModified)
     myGrid->compactGrid(idNodesOldToNew, newNodeSize, idCellsOldToNew, newCellSize);
   else


@@ -2205,62 +2202,62 @@ void SMESHDS_Mesh::compactMesh()
   int nbVtkPts = myGrid->GetNumberOfPoints();
   nbVtkCells = myGrid->GetNumberOfCells();
   if (nbVtkPts != newNodeSize)
   int nbVtkPts = myGrid->GetNumberOfPoints();
   nbVtkCells = myGrid->GetNumberOfCells();
   if (nbVtkPts != newNodeSize)

-    {
-      MESSAGE("===> nbVtkPts != newNodeSize " << nbVtkPts << " " << newNodeSize);
-      if (nbVtkPts > newNodeSize) newNodeSize = nbVtkPts; // several points with same SMDS Id
-    }
+  {
+    MESSAGE("===> nbVtkPts != newNodeSize " << nbVtkPts << " " << newNodeSize);
+    if (nbVtkPts > newNodeSize) newNodeSize = nbVtkPts; // several points with same SMDS Id
+  }

   if (nbVtkCells != newCellSize)
   if (nbVtkCells != newCellSize)

-    {
-      MESSAGE("===> nbVtkCells != newCellSize " << nbVtkCells << " " << newCellSize);
-      if (nbVtkCells > newCellSize) newCellSize = nbVtkCells; // several cells with same SMDS Id
-    }
+  {
+    MESSAGE("===> nbVtkCells != newCellSize " << nbVtkCells << " " << newCellSize);
+    if (nbVtkCells > newCellSize) newCellSize = nbVtkCells; // several cells with same SMDS Id
+  }

 
   // --- SMDS_MeshNode and myNodes (id in SMDS and in VTK are the same), myNodeIdFactory
 
   if (areNodesModified)
 
   // --- SMDS_MeshNode and myNodes (id in SMDS and in VTK are the same), myNodeIdFactory
 
   if (areNodesModified)

+  {
+    //MESSAGE("-------------- modify myNodes");
+    SetOfNodes newNodes;
+    newNodes.resize(newNodeSize+1,0); // 0 not used, SMDS numbers 1..n
+    int newSmdsId = 0;
+    for (int i = 0; i < nbNodes; i++)

     {
     {

-      MESSAGE("-------------- modify myNodes");
-      SetOfNodes newNodes;
-      newNodes.resize(newNodeSize+1,0); // 0 not used, SMDS numbers 1..n
-      int newSmdsId = 0;
-      for (int i = 0; i < nbNodes; i++)
-        {
-          if (myNodes[i])
-            {
-              newSmdsId++; // SMDS id start to 1
-              int oldVtkId = myNodes[i]->getVtkId();
-              int newVtkId = idNodesOldToNew[oldVtkId];
-              //MESSAGE("myNodes["<< i << "] vtkId " << oldVtkId << " --> " << newVtkId);
-              myNodes[i]->setVtkId(newVtkId);
-              myNodes[i]->setId(newSmdsId);
-              newNodes[newSmdsId] = myNodes[i];
-              //MESSAGE("myNodes["<< i << "] --> newNodes[" << newSmdsId << "]");
-            }
-        }
-      myNodes.swap(newNodes);
-      this->myNodeIDFactory->emptyPool(newSmdsId); // newSmdsId = number of nodes
-      MESSAGE("myNodes.size " << myNodes.size());
+      if (myNodes[i])
+      {
+        newSmdsId++; // SMDS id start to 1
+        int oldVtkId = myNodes[i]->getVtkId();
+        int newVtkId = idNodesOldToNew[oldVtkId];
+        //MESSAGE("myNodes["<< i << "] vtkId " << oldVtkId << " --> " << newVtkId);
+        myNodes[i]->setVtkId(newVtkId);
+        myNodes[i]->setId(newSmdsId);
+        newNodes[newSmdsId] = myNodes[i];
+        //MESSAGE("myNodes["<< i << "] --> newNodes[" << newSmdsId << "]");
+      }

     }
     }

+    myNodes.swap(newNodes);
+    this->myNodeIDFactory->emptyPool(newSmdsId); // newSmdsId = number of nodes
+    //MESSAGE("myNodes.size " << myNodes.size());
+  }

 
   // --- SMDS_MeshCell, myCellIdVtkToSmds, myCellIdSmdsToVtk, myCells
 
   int vtkIndexSize = myCellIdVtkToSmds.size();
   int maxVtkId = -1;
   for (int oldVtkId = 0; oldVtkId < vtkIndexSize; oldVtkId++)
 
   // --- SMDS_MeshCell, myCellIdVtkToSmds, myCellIdSmdsToVtk, myCells
 
   int vtkIndexSize = myCellIdVtkToSmds.size();
   int maxVtkId = -1;
   for (int oldVtkId = 0; oldVtkId < vtkIndexSize; oldVtkId++)

+  {
+    int oldSmdsId = this->myCellIdVtkToSmds[oldVtkId];
+    if (oldSmdsId > 0)

     {
     {

-      int oldSmdsId = this->myCellIdVtkToSmds[oldVtkId];
-      if (oldSmdsId > 0)
-        {
-          int newVtkId = idCellsOldToNew[oldVtkId];
-          if (newVtkId > maxVtkId)
-            maxVtkId = newVtkId;
-          //MESSAGE("myCells["<< oldSmdsId << "] vtkId " << oldVtkId << " --> " << newVtkId);
-          myCells[oldSmdsId]->setVtkId(newVtkId);
-        }
+      int newVtkId = idCellsOldToNew[oldVtkId];
+      if (newVtkId > maxVtkId)
+        maxVtkId = newVtkId;
+      //MESSAGE("myCells["<< oldSmdsId << "] vtkId " << oldVtkId << " --> " << newVtkId);
+      myCells[oldSmdsId]->setVtkId(newVtkId);

     }
     }

-//  MESSAGE("myCells.size()=" << myCells.size()
-//          << " myCellIdSmdsToVtk.size()=" << myCellIdSmdsToVtk.size()
-//          << " myCellIdVtkToSmds.size()=" << myCellIdVtkToSmds.size() );
+  }
+  //  MESSAGE("myCells.size()=" << myCells.size()
+  //          << " myCellIdSmdsToVtk.size()=" << myCellIdSmdsToVtk.size()
+  //          << " myCellIdVtkToSmds.size()=" << myCellIdVtkToSmds.size() );

 
   SetOfCells newCells;
   //vector<int> newSmdsToVtk;
 
   SetOfCells newCells;
   //vector<int> newSmdsToVtk;


@@ -2292,8 +2289,7 @@ void SMESHDS_Mesh::compactMesh()
   myCells.swap(newCells);
   //myCellIdSmdsToVtk.swap(newSmdsToVtk);
   myCellIdVtkToSmds.swap(newVtkToSmds);
   myCells.swap(newCells);
   //myCellIdSmdsToVtk.swap(newSmdsToVtk);
   myCellIdVtkToSmds.swap(newVtkToSmds);

-  MESSAGE("myCells.size()=" << myCells.size()
-          << " myCellIdVtkToSmds.size()=" << myCellIdVtkToSmds.size() );
+  //MESSAGE("myCells.size()="<< myCells.size()<<" myCellIdVtkToSmds.size()="<<myCellIdVtkToSmds.size() );

   this->myElementIDFactory->emptyPool(newSmdsId);
 
   this->myScript->SetModified(true); // notify GUI client for buildPrs when update
   this->myElementIDFactory->emptyPool(newSmdsId);
 
   this->myScript->SetModified(true); // notify GUI client for buildPrs when update

diff --git a/src/SMESHGUI/SMESHGUI.cxx b/src/SMESHGUI/SMESHGUI.cxx
index 93b57979848335603cd9a6cbcd5f84f6a6cf85c0..fc3c33c04fe25b90746c4f17d0af9f809c6c9a6c 100644 (file)
--- a/src/SMESHGUI/SMESHGUI.cxx
+++ b/src/SMESHGUI/SMESHGUI.cxx
@@ -1649,19 +1649,17 @@ namespace
         if(!anIO.IsNull()){
           _PTR(SObject) SO = aStudy->FindObjectID( It.Value()->getEntry() );
           if ( SO ) {
         if(!anIO.IsNull()){
           _PTR(SObject) SO = aStudy->FindObjectID( It.Value()->getEntry() );
           if ( SO ) {

-            CORBA::Object_var          aObject  = SMESH::SObjectToObject( SO );
-            SMESH::SMESH_Mesh_var      aMesh    = SMESH::SMESH_Mesh::_narrow( aObject );
-            SMESH::SMESH_subMesh_var   aSubMesh = SMESH::SMESH_subMesh::_narrow( aObject );
-            SMESH::SMESH_GroupBase_var aGroup   = SMESH::SMESH_GroupBase::_narrow( aObject );
-            if ( !aMesh->_is_nil() || !aSubMesh->_is_nil() || !aGroup->_is_nil() ) {
-              if ( SMESH_Actor *anActor = SMESH::FindActorByEntry(anIO->getEntry()) ) {
-                anActor->SetControlMode(aControl);
-                anActor->GetScalarBarActor()->SetTitle( functorToString( anActor->GetFunctor() ).toLatin1().constData() );
+            CORBA::Object_var         aObject = SMESH::SObjectToObject( SO );
+            SMESH::SMESH_IDSource_var anIDSrc = SMESH::SMESH_IDSource::_narrow( aObject );
+            if ( !anIDSrc->_is_nil() ) {
+              if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( anIO->getEntry()) ) {
+                QString functorName = functorToString( anActor->GetFunctor() );
+                anActor->SetControlMode( aControl );
+                anActor->GetScalarBarActor()->SetTitle( functorName.toLatin1().constData() );

                 SMESH::RepaintCurrentView();
 #ifndef DISABLE_PLOT2DVIEWER
                 if ( anActor->GetPlot2Histogram() ) {
                   SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
                 SMESH::RepaintCurrentView();
 #ifndef DISABLE_PLOT2DVIEWER
                 if ( anActor->GetPlot2Histogram() ) {
                   SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();

-                  QString functorName = functorToString( anActor->GetFunctor() );

                   QString aHistogramName("%1 : %2");
                   aHistogramName = aHistogramName.arg( anIO->getName() ).arg( functorName );
                   aHistogram->setName( aHistogramName );
                   QString aHistogramName("%1 : %2");
                   aHistogramName = aHistogramName.arg( anIO->getName() ).arg( functorName );
                   aHistogram->setName( aHistogramName );


@@ -1956,7 +1954,7 @@ SalomeApp_Module( "SMESH" )
   {
     CORBA::Boolean anIsEmbeddedMode;
     myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
   {
     CORBA::Boolean anIsEmbeddedMode;
     myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);

-    MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
+    //MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);

 
     //  0019923: EDF 765 SMESH : default values of hypothesis
     SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
 
     //  0019923: EDF 765 SMESH : default values of hypothesis
     SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);


@@ -2596,6 +2594,7 @@ bool SMESHGUI::OnGUIEvent( int theCommandID )
   case SMESHOp::OpShow:
   case SMESHOp::OpShowOnly:
     {
   case SMESHOp::OpShow:
   case SMESHOp::OpShowOnly:
     {

+      SUIT_OverrideCursor wc;

       SMESH::EDisplaing anAction;
       switch (theCommandID) {
       case SMESHOp::OpHide:     anAction = SMESH::eErase; break;
       SMESH::EDisplaing anAction;
       switch (theCommandID) {
       case SMESHOp::OpHide:     anAction = SMESH::eErase; break;


@@ -2610,7 +2609,7 @@ bool SMESHGUI::OnGUIEvent( int theCommandID )
 
       if ( theCommandID==SMESHOp::OpShowOnly )
       {
 
       if ( theCommandID==SMESHOp::OpShowOnly )
       {

-        MESSAGE("anAction = SMESH::eDisplayOnly");
+        //MESSAGE("anAction = SMESH::eDisplayOnly");

         startOperation( myEraseAll );
       }
 
         startOperation( myEraseAll );
       }
 


@@ -2639,7 +2638,6 @@ bool SMESHGUI::OnGUIEvent( int theCommandID )
 
         // PAL13338 + PAL15161 -->
         if ( ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) && !checkLock(aStudy)) {
 
         // PAL13338 + PAL15161 -->
         if ( ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) && !checkLock(aStudy)) {

-          MESSAGE("anAction = SMESH::eDisplayOnly");

           SMESH::UpdateView();
           SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
         }
           SMESH::UpdateView();
           SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
         }


@@ -2650,7 +2648,6 @@ bool SMESHGUI::OnGUIEvent( int theCommandID )
       }
 
       if (anAction == SMESH::eErase) {
       }
 
       if (anAction == SMESH::eErase) {

-        MESSAGE("anAction == SMESH::eErase");

         SALOME_ListIO l1;
         aSel->setSelectedObjects( l1 );
       }
         SALOME_ListIO l1;
         aSel->setSelectedObjects( l1 );
       }


@@ -2670,9 +2667,7 @@ bool SMESHGUI::OnGUIEvent( int theCommandID )
         ( new SMESHGUI_NodesDlg( this ) )->show();
       }
       else {
         ( new SMESHGUI_NodesDlg( this ) )->show();
       }
       else {

-        SUIT_MessageBox::warning(desktop(),
-                                 tr("SMESH_WRN_WARNING"),
-                                 tr("SMESH_WRN_VIEWER_VTK"));
+        SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"),tr("SMESH_WRN_VIEWER_VTK"));

       }
       break;
     }
       }
       break;
     }


@@ -2706,8 +2701,7 @@ bool SMESHGUI::OnGUIEvent( int theCommandID )
     {
       if ( !vtkwnd )
       {
     {
       if ( !vtkwnd )
       {

-        SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
-                                  tr( "NOT_A_VTK_VIEWER" ) );
+        SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );

         break;
       }
 
         break;
       }
 


@@ -2737,8 +2731,7 @@ bool SMESHGUI::OnGUIEvent( int theCommandID )
     {
       if ( !vtkwnd )
       {
     {
       if ( !vtkwnd )
       {

-        SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
-                                  tr( "NOT_A_VTK_VIEWER" ) );
+        SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );

         break;
       }
 
         break;
       }
 


@@ -2767,8 +2760,7 @@ bool SMESHGUI::OnGUIEvent( int theCommandID )
         ( new SMESHGUI_SmoothingDlg( this ) )->show();
       }
       else {
         ( new SMESHGUI_SmoothingDlg( this ) )->show();
       }
       else {

-        SUIT_MessageBox::warning(desktop(),
-                                 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
+        SUIT_MessageBox::warning(desktop(), tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));

       }
       break;
     }
       }
       break;
     }


@@ -2779,8 +2771,7 @@ bool SMESHGUI::OnGUIEvent( int theCommandID )
         EmitSignalDeactivateDialog();
         ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
       } else {
         EmitSignalDeactivateDialog();
         ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
       } else {

-        SUIT_MessageBox::warning(desktop(),
-                                 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
+        SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));

       }
       break;
     }
       }
       break;
     }


@@ -2791,8 +2782,7 @@ bool SMESHGUI::OnGUIEvent( int theCommandID )
         EmitSignalDeactivateDialog();
         ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
       } else {
         EmitSignalDeactivateDialog();
         ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
       } else {

-        SUIT_MessageBox::warning(desktop(),
-                                 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
+        SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));

       }
       break;
     }
       }
       break;
     }


@@ -2804,8 +2794,7 @@ bool SMESHGUI::OnGUIEvent( int theCommandID )
         ( new SMESHGUI_RevolutionDlg( this ) )->show();
       }
       else {
         ( new SMESHGUI_RevolutionDlg( this ) )->show();
       }
       else {

-        SUIT_MessageBox::warning(desktop(),
-                                 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
+        SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));

       }
       break;
     }
       }
       break;
     }


@@ -2819,8 +2808,7 @@ bool SMESHGUI::OnGUIEvent( int theCommandID )
         ( new SMESHGUI_MeshPatternDlg( this ) )->show();
       }
       else {
         ( new SMESHGUI_MeshPatternDlg( this ) )->show();
       }
       else {

-        SUIT_MessageBox::warning(desktop(),
-                                 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
+        SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));

       }
       break;
     }
       }
       break;
     }


@@ -2837,8 +2825,7 @@ bool SMESHGUI::OnGUIEvent( int theCommandID )
     {
       if ( !vtkwnd )
       {
     {
       if ( !vtkwnd )
       {

-        SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
-                                  tr( "NOT_A_VTK_VIEWER" ) );
+        SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );

         break;
       }
 
         break;
       }
 


@@ -2865,8 +2852,7 @@ bool SMESHGUI::OnGUIEvent( int theCommandID )
     {
       if ( !vtkwnd )
       {
     {
       if ( !vtkwnd )
       {

-        SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
-                                  tr( "NOT_A_VTK_VIEWER" ) );
+        SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );

         break;
       }
 
         break;
       }
 


@@ -2943,8 +2929,7 @@ bool SMESHGUI::OnGUIEvent( int theCommandID )
     {
       if ( !vtkwnd )
       {
     {
       if ( !vtkwnd )
       {

-        SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
-                                  tr( "NOT_A_VTK_VIEWER" ) );
+        SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );

         break;
       }
 
         break;
       }
 


@@ -3000,8 +2985,7 @@ bool SMESHGUI::OnGUIEvent( int theCommandID )
     {
       if ( !vtkwnd )
       {
     {
       if ( !vtkwnd )
       {

-        SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
-                                  tr( "NOT_A_VTK_VIEWER" ) );
+        SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );

         break;
       }
 
         break;
       }
 


@@ -3041,8 +3025,7 @@ bool SMESHGUI::OnGUIEvent( int theCommandID )
     {
       if ( !vtkwnd )
       {
     {
       if ( !vtkwnd )
       {

-        SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
-                                  tr( "NOT_A_VTK_VIEWER" ) );
+        SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );

         break;
       }
 
         break;
       }
 


@@ -3080,8 +3063,7 @@ bool SMESHGUI::OnGUIEvent( int theCommandID )
     {
       if ( !vtkwnd )
       {
     {
       if ( !vtkwnd )
       {

-        SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
-                                  tr( "NOT_A_VTK_VIEWER" ) );
+        SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );

         break;
       }
 
         break;
       }
 


@@ -3223,8 +3205,7 @@ bool SMESHGUI::OnGUIEvent( int theCommandID )
         ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
       }
       else {
         ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
       }
       else {

-        SUIT_MessageBox::warning(desktop(),
-                                 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
+        SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));

       }
       break;
     }
       }
       break;
     }


@@ -3236,8 +3217,7 @@ bool SMESHGUI::OnGUIEvent( int theCommandID )
         ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
       }
       else {
         ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
       }
       else {

-        SUIT_MessageBox::warning(SMESHGUI::desktop(),
-                                 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
+        SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));

       }
       break;
     }
       }
       break;
     }

diff --git a/src/SMESHGUI/SMESHGUI_HypothesesUtils.cxx b/src/SMESHGUI/SMESHGUI_HypothesesUtils.cxx
index dce31dfb8b638b0256424f7a0f135ad173e84804..f93ec46ea2ed46544e744c00d50126c35230d751 100644 (file)
--- a/src/SMESHGUI/SMESHGUI_HypothesesUtils.cxx
+++ b/src/SMESHGUI/SMESHGUI_HypothesesUtils.cxx
@@ -378,7 +378,7 @@ namespace SMESH
       return false;
     if ( algoData->BasicHypos.contains( hypType ))
       return true;
       return false;
     if ( algoData->BasicHypos.contains( hypType ))
       return true;

-    if ( algoData->OptionalHypos.contains( hypType)) {
+    if ( algoData->OptionalHypos.contains( hypType )) {

       isAuxiliary = true;
       return true;
     }
       isAuxiliary = true;
       return true;
     }

diff --git a/src/SMESHGUI/SMESHGUI_VTKUtils.cxx b/src/SMESHGUI/SMESHGUI_VTKUtils.cxx
index db9df6c7179811af10ead3cfa57549ef851b103b..323c9c154e40869b1e41447bac63a9ee652b5815 100644 (file)
--- a/src/SMESHGUI/SMESHGUI_VTKUtils.cxx
+++ b/src/SMESHGUI/SMESHGUI_VTKUtils.cxx
@@ -854,7 +854,7 @@ namespace SMESH
 
   bool Update(const Handle(SALOME_InteractiveObject)& theIO, bool theDisplay)
   {
 
   bool Update(const Handle(SALOME_InteractiveObject)& theIO, bool theDisplay)
   {

-    MESSAGE("Update");
+    //MESSAGE("Update");

     _PTR(Study) aStudy = GetActiveStudyDocument();
     CORBA::Long anId = aStudy->StudyId();
     if ( TVisualObjPtr aVisualObj = SMESH::GetVisualObj(anId,theIO->getEntry())) {
     _PTR(Study) aStudy = GetActiveStudyDocument();
     CORBA::Long anId = aStudy->StudyId();
     if ( TVisualObjPtr aVisualObj = SMESH::GetVisualObj(anId,theIO->getEntry())) {


@@ -867,7 +867,7 @@ namespace SMESH
 
   bool UpdateNulData(const Handle(SALOME_InteractiveObject)& theIO, bool theDisplay)
   {
 
   bool UpdateNulData(const Handle(SALOME_InteractiveObject)& theIO, bool theDisplay)
   {

-    MESSAGE("UpdateNulData");
+    //MESSAGE("UpdateNulData");

     _PTR(Study) aStudy = GetActiveStudyDocument();
     CORBA::Long anId = aStudy->StudyId();
     if ( TVisualObjPtr aVisualObj = SMESH::GetVisualObj(anId,theIO->getEntry(), true)) {
     _PTR(Study) aStudy = GetActiveStudyDocument();
     CORBA::Long anId = aStudy->StudyId();
     if ( TVisualObjPtr aVisualObj = SMESH::GetVisualObj(anId,theIO->getEntry(), true)) {


@@ -878,7 +878,8 @@ namespace SMESH
     return false;
   }
 
     return false;
   }
 

-  void UpdateSelectionProp( SMESHGUI* theModule ) {
+  void UpdateSelectionProp( SMESHGUI* theModule )
+  {

     if( !theModule )
       return;
 
     if( !theModule )
       return;
 


@@ -905,25 +906,29 @@ namespace SMESH
       return;
     }
 
       return;
     }
 

-    QColor aHiColor = mgr->colorValue( "SMESH", "selection_object_color", Qt::white ),
-           aSelColor = mgr->colorValue( "SMESH", "selection_element_color", Qt::yellow ),
-           aPreColor = mgr->colorValue( "SMESH", "highlight_color", Qt::cyan );
+    QColor
+      aHiColor = mgr->colorValue( "SMESH", "selection_object_color", Qt::white ),
+      aSelColor = mgr->colorValue( "SMESH", "selection_element_color", Qt::yellow ),
+      aPreColor = mgr->colorValue( "SMESH", "highlight_color", Qt::cyan );

 
     int aElem0DSize = mgr->integerValue("SMESH", "elem0d_size", 5);
 
     int aElem0DSize = mgr->integerValue("SMESH", "elem0d_size", 5);

-   // int aBallSize   = mgr->integerValue("SMESH", "ball_elem_size", 5);
+    // int aBallSize   = mgr->integerValue("SMESH", "ball_elem_size", 5);

     int aLineWidth  = mgr->integerValue("SMESH", "element_width", 1);
     int maxSize = aElem0DSize;
     if (aElem0DSize > maxSize) maxSize = aElem0DSize;
     if (aLineWidth > maxSize) maxSize = aLineWidth;
     int aLineWidth  = mgr->integerValue("SMESH", "element_width", 1);
     int maxSize = aElem0DSize;
     if (aElem0DSize > maxSize) maxSize = aElem0DSize;
     if (aLineWidth > maxSize) maxSize = aLineWidth;

-  //  if (aBallSize > maxSize) maxSize = aBallSize;
+    //  if (aBallSize > maxSize) maxSize = aBallSize;

 
 

-    double SP1 = mgr->doubleValue( "SMESH", "selection_precision_node", 0.025 ),
-           SP2 = mgr->doubleValue( "SMESH", "selection_precision_element", 0.001 ),
-           SP3 = mgr->doubleValue( "SMESH", "selection_precision_object", 0.025 );
+    double
+      SP1 = mgr->doubleValue( "SMESH", "selection_precision_node", 0.025 ),
+      SP2 = mgr->doubleValue( "SMESH", "selection_precision_element", 0.001 ),
+      SP3 = mgr->doubleValue( "SMESH", "selection_precision_object", 0.025 );

 
 

-    for ( int i=0, n=views.count(); i<n; i++ ){
+    for ( int i=0, n=views.count(); i<n; i++ )
+    {

       // update VTK viewer properties
       // update VTK viewer properties

-      if(SVTK_ViewWindow* aVtkView = GetVtkViewWindow( views[i] )){
+      if ( SVTK_ViewWindow* aVtkView = GetVtkViewWindow( views[i] ))
+      {

         // mesh element selection
         aVtkView->SetSelectionProp(aSelColor.red()/255.,
                                    aSelColor.green()/255.,
         // mesh element selection
         aVtkView->SetSelectionProp(aSelColor.red()/255.,
                                    aSelColor.green()/255.,


@@ -940,8 +945,8 @@ namespace SMESH
         VTK::ActorCollectionCopy aCopy(aRenderer->GetActors());
         vtkActorCollection *aCollection = aCopy.GetActors();
         aCollection->InitTraversal();
         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)){
+        while ( vtkActor *anAct = aCollection->GetNextActor() ) {
+          if ( SMESH_Actor *anActor = dynamic_cast<SMESH_Actor*>(anAct) ) {

             anActor->SetHighlightColor(aHiColor.red()/255.,
                                        aHiColor.green()/255.,
                                        aHiColor.blue()/255.);
             anActor->SetHighlightColor(aHiColor.red()/255.,
                                        aHiColor.green()/255.,
                                        aHiColor.blue()/255.);


@@ -1076,8 +1081,9 @@ namespace SMESH
 
 
   //----------------------------------------------------------------------------
 
 
   //----------------------------------------------------------------------------

-  void SetPointRepresentation(bool theIsVisible){
-    if(SVTK_ViewWindow* aViewWindow = GetCurrentVtkView()){
+  void SetPointRepresentation(bool theIsVisible)
+  {
+    if ( SVTK_ViewWindow* aViewWindow = GetCurrentVtkView() ) {

       vtkRenderer *aRenderer = aViewWindow->getRenderer();
       VTK::ActorCollectionCopy aCopy(aRenderer->GetActors());
       vtkActorCollection *aCollection = aCopy.GetActors();
       vtkRenderer *aRenderer = aViewWindow->getRenderer();
       VTK::ActorCollectionCopy aCopy(aRenderer->GetActors());
       vtkActorCollection *aCollection = aCopy.GetActors();


@@ -1094,8 +1100,9 @@ namespace SMESH
   }
 
 
   }
 
 

-  void SetPickable(SMESH_Actor* theActor){
-    if(SVTK_ViewWindow* aWnd = GetCurrentVtkView()){
+  void SetPickable(SMESH_Actor* theActor)
+  {
+    if ( SVTK_ViewWindow* aWnd = GetCurrentVtkView() ) {

       int anIsAllPickable = (theActor == NULL);
       vtkRenderer *aRenderer = aWnd->getRenderer();
       VTK::ActorCollectionCopy aCopy(aRenderer->GetActors());
       int anIsAllPickable = (theActor == NULL);
       vtkRenderer *aRenderer = aWnd->getRenderer();
       VTK::ActorCollectionCopy aCopy(aRenderer->GetActors());


@@ -1116,9 +1123,9 @@ namespace SMESH
 
 
   //----------------------------------------------------------------------------
 
 
   //----------------------------------------------------------------------------

-  int GetNameOfSelectedNodes(SVTK_Selector* theSelector,
+  int GetNameOfSelectedNodes(SVTK_Selector*                          theSelector,

                              const Handle(SALOME_InteractiveObject)& theIO,
                              const Handle(SALOME_InteractiveObject)& theIO,

-                             QString& theName)
+                             QString&                                theName)

   {
     theName = "";
     TColStd_IndexedMapOfInteger aMapIndex;
   {
     theName = "";
     TColStd_IndexedMapOfInteger aMapIndex;


@@ -1204,7 +1211,8 @@ namespace SMESH
     return -1;
   }
 
     return -1;
   }
 

-  int GetNameOfSelectedNodes(LightApp_SelectionMgr *theMgr, QString& theName){
+  int GetNameOfSelectedNodes(LightApp_SelectionMgr *theMgr, QString& theName)
+  {

     theName = "";
     SALOME_ListIO selected; theMgr->selectedObjects( selected );
     if(selected.Extent() == 1){
     theName = "";
     SALOME_ListIO selected; theMgr->selectedObjects( selected );
     if(selected.Extent() == 1){


@@ -1215,9 +1223,9 @@ namespace SMESH
   }
 
 
   }
 
 

-  int GetNameOfSelectedElements(LightApp_SelectionMgr *theMgr,
+  int GetNameOfSelectedElements(LightApp_SelectionMgr *                 theMgr,

                                 const Handle(SALOME_InteractiveObject)& theIO,
                                 const Handle(SALOME_InteractiveObject)& theIO,

-                                QString& theName)
+                                QString&                                theName)

   {
     theName = "";
     if(theIO->hasEntry()){
   {
     theName = "";
     if(theIO->hasEntry()){


@@ -1342,13 +1350,13 @@ namespace SMESH
     }
 
     double aBoundPoints[8][3] = { {theBounds[0],theBounds[2],theBounds[4]},
     }
 
     double aBoundPoints[8][3] = { {theBounds[0],theBounds[2],theBounds[4]},

-                                                {theBounds[1],theBounds[2],theBounds[4]},
-                                                {theBounds[0],theBounds[3],theBounds[4]},
-                                                {theBounds[1],theBounds[3],theBounds[4]},
-                                                {theBounds[0],theBounds[2],theBounds[5]},
-                                                {theBounds[1],theBounds[2],theBounds[5]}, 
-                                                {theBounds[0],theBounds[3],theBounds[5]}, 
-                                                {theBounds[1],theBounds[3],theBounds[5]}};
+                                  {theBounds[1],theBounds[2],theBounds[4]},
+                                  {theBounds[0],theBounds[3],theBounds[4]},
+                                  {theBounds[1],theBounds[3],theBounds[4]},
+                                  {theBounds[0],theBounds[2],theBounds[5]},
+                                  {theBounds[1],theBounds[2],theBounds[5]},
+                                  {theBounds[0],theBounds[3],theBounds[5]},
+                                  {theBounds[1],theBounds[3],theBounds[5]}};

 
     int aMaxId = 0;
     theMaxBoundPrj = vtkMath::Dot(theDirection,aBoundPoints[aMaxId]);
 
     int aMaxId = 0;
     theMaxBoundPrj = vtkMath::Dot(theDirection,aBoundPoints[aMaxId]);


@@ -1445,8 +1453,9 @@ namespace SMESH
    */
   //================================================================================
 
    */
   //================================================================================
 

-  void ClearPlot2Viewers( SUIT_ViewWindow* theWindow ) {
-    if(SVTK_ViewWindow* aViewWindow = GetVtkViewWindow(theWindow)){
+  void ClearPlot2Viewers( SUIT_ViewWindow* theWindow )
+  {
+    if ( SVTK_ViewWindow* aViewWindow = GetVtkViewWindow(theWindow) ) {

       vtkRenderer *aRenderer = aViewWindow->getRenderer();
       VTK::ActorCollectionCopy aCopy(aRenderer->GetActors());
       vtkActorCollection *aCollection = aCopy.GetActors();
       vtkRenderer *aRenderer = aViewWindow->getRenderer();
       VTK::ActorCollectionCopy aCopy(aRenderer->GetActors());
       vtkActorCollection *aCollection = aCopy.GetActors();


@@ -1460,7 +1469,7 @@ namespace SMESH
       }
     }
   }
       }
     }
   }

-  
+

 #endif
 
 } // end of namespace SMESH
 #endif
 
 } // end of namespace SMESH

diff --git a/src/SMESHGUI/SMESHGUI_XmlHandler.cxx b/src/SMESHGUI/SMESHGUI_XmlHandler.cxx
index 6f6060216a7803f054dd449e7984c37d260288f9..ec8ed41cd99dca6d3d40378f5578de6d0ef4bf3d 100644 (file)
--- a/src/SMESHGUI/SMESHGUI_XmlHandler.cxx
+++ b/src/SMESHGUI/SMESHGUI_XmlHandler.cxx
@@ -104,7 +104,7 @@ bool SMESHGUI_XmlHandler::startElement (const QString&, const QString&,
       QString aResName = atts.value("resources");
       if (aResName != "")
       {
       QString aResName = atts.value("resources");
       if (aResName != "")
       {

-        MESSAGE("Loading Resources " << aResName.toLatin1().data());
+        //MESSAGE("Loading Resources " << aResName.toLatin1().data());

         SUIT_ResourceMgr* resMgr = SMESHGUI::resourceMgr();
         QString lang = resMgr->stringValue( resMgr->langSection(), "language", "en" );
         resMgr->loadTranslator( "resources", QString( "%1_msg_%2.qm" ).arg( aResName, lang ) );
         SUIT_ResourceMgr* resMgr = SMESHGUI::resourceMgr();
         QString lang = resMgr->stringValue( resMgr->langSection(), "language", "en" );
         resMgr->loadTranslator( "resources", QString( "%1_msg_%2.qm" ).arg( aResName, lang ) );

diff --git a/src/SMESH_I/SMESH_2D_Algo_i.cxx b/src/SMESH_I/SMESH_2D_Algo_i.cxx
index fb9235dca9e407b05a77e878a924bebe5a1d804c..04a9bf389d5192d944f3840608541dbf6790a755 100644 (file)
--- a/src/SMESH_I/SMESH_2D_Algo_i.cxx
+++ b/src/SMESH_I/SMESH_2D_Algo_i.cxx
@@ -45,7 +45,6 @@ SMESH_2D_Algo_i::SMESH_2D_Algo_i( PortableServer::POA_ptr thePOA )
        SMESH_Hypothesis_i( thePOA ), 
        SMESH_Algo_i( thePOA ) 
 {
        SMESH_Hypothesis_i( thePOA ), 
        SMESH_Algo_i( thePOA ) 
 {

-  MESSAGE( "SMESH_2D_Algo_i::SMESH_2D_Algo_i" );

 }
 
 //=============================================================================
 }
 
 //=============================================================================


@@ -58,7 +57,6 @@ SMESH_2D_Algo_i::SMESH_2D_Algo_i( PortableServer::POA_ptr thePOA )
 
 SMESH_2D_Algo_i::~SMESH_2D_Algo_i()
 {
 
 SMESH_2D_Algo_i::~SMESH_2D_Algo_i()
 {

-  MESSAGE( "SMESH_2D_Algo_i::~SMESH_2D_Algo_i" );

 }
 
 //================================================================================
 }
 
 //================================================================================

diff --git a/src/SMESH_I/SMESH_3D_Algo_i.cxx b/src/SMESH_I/SMESH_3D_Algo_i.cxx
index 7daba667ec69292d0719fd10bbd0505b6761898a..dfa30a628cef6deaa0c831c00780b9da0f903736 100644 (file)
--- a/src/SMESH_I/SMESH_3D_Algo_i.cxx
+++ b/src/SMESH_I/SMESH_3D_Algo_i.cxx
@@ -45,7 +45,6 @@ SMESH_3D_Algo_i::SMESH_3D_Algo_i( PortableServer::POA_ptr thePOA )
        SMESH_Hypothesis_i( thePOA ), 
        SMESH_Algo_i( thePOA )
 {
        SMESH_Hypothesis_i( thePOA ), 
        SMESH_Algo_i( thePOA )
 {

-  MESSAGE( "SMESH_3D_Algo_i::SMESH_3D_Algo_i" );

 }
 
 //=============================================================================
 }
 
 //=============================================================================


@@ -58,7 +57,6 @@ SMESH_3D_Algo_i::SMESH_3D_Algo_i( PortableServer::POA_ptr thePOA )
 
 SMESH_3D_Algo_i::~SMESH_3D_Algo_i()
 {
 
 SMESH_3D_Algo_i::~SMESH_3D_Algo_i()
 {

-  MESSAGE( "SMESH_3D_Algo_i::~SMESH_3D_Algo_i" );

 }
 
 //================================================================================
 }
 
 //================================================================================

diff --git a/src/SMESH_I/SMESH_Algo_i.cxx b/src/SMESH_I/SMESH_Algo_i.cxx
index c9cd4afc9ecfaff4a2aa0b8c561e5438c8c3f6d4..5c0f6bb80a765d6605a573f1fa4b40eb0031cf77 100644 (file)
--- a/src/SMESH_I/SMESH_Algo_i.cxx
+++ b/src/SMESH_I/SMESH_Algo_i.cxx
@@ -48,7 +48,6 @@ SMESH_Algo_i::SMESH_Algo_i( PortableServer::POA_ptr thePOA )
      : SALOME::GenericObj_i( thePOA ), 
        SMESH_Hypothesis_i( thePOA )
 {
      : SALOME::GenericObj_i( thePOA ), 
        SMESH_Hypothesis_i( thePOA )
 {

-  MESSAGE( "SMESH_Algo_i::SMESH_Algo_i" );

 }
 
 //=============================================================================
 }
 
 //=============================================================================


@@ -61,7 +60,6 @@ SMESH_Algo_i::SMESH_Algo_i( PortableServer::POA_ptr thePOA )
 
 SMESH_Algo_i::~SMESH_Algo_i()
 {
 
 SMESH_Algo_i::~SMESH_Algo_i()
 {

-  MESSAGE( "SMESH_Algo_i::~SMESH_Algo_i" );

 }
 
 //=============================================================================
 }
 
 //=============================================================================


@@ -74,7 +72,6 @@ SMESH_Algo_i::~SMESH_Algo_i()
 
 SMESH::ListOfHypothesisName* SMESH_Algo_i::GetCompatibleHypothesis()
 {
 
 SMESH::ListOfHypothesisName* SMESH_Algo_i::GetCompatibleHypothesis()
 {

-  MESSAGE( "SMESH_Algo_i::GetCompatibleHypothesis" );

   SMESH::ListOfHypothesisName_var listOfHypothesis = new SMESH::ListOfHypothesisName;
   const vector<string>& hypList = ( ( ::SMESH_Algo* )myBaseImpl )->GetCompatibleHypothesis();
   int nbHyp = hypList.size();
   SMESH::ListOfHypothesisName_var listOfHypothesis = new SMESH::ListOfHypothesisName;
   const vector<string>& hypList = ( ( ::SMESH_Algo* )myBaseImpl )->GetCompatibleHypothesis();
   int nbHyp = hypList.size();

diff --git a/src/SMESH_I/SMESH_Gen_i.cxx b/src/SMESH_I/SMESH_Gen_i.cxx
index 204466afefea833d8bb90b3bfd220ad675a54b84..32c05839a89fd24d07c29ac0d1f85fc14c6df4c9 100644 (file)
--- a/src/SMESH_I/SMESH_Gen_i.cxx
+++ b/src/SMESH_I/SMESH_Gen_i.cxx
@@ -285,7 +285,6 @@ SMESH_Gen_i::SMESH_Gen_i( CORBA::ORB_ptr            orb,
                           const char*               interfaceName )
   : Engines_Component_i( orb, poa, contId, instanceName, interfaceName )
 {
                           const char*               interfaceName )
   : Engines_Component_i( orb, poa, contId, instanceName, interfaceName )
 {

-  MESSAGE( "SMESH_Gen_i::SMESH_Gen_i : standard constructor" );

 
   myOrb = CORBA::ORB::_duplicate(orb);
   myPoa = PortableServer::POA::_duplicate(poa);
 
   myOrb = CORBA::ORB::_duplicate(orb);
   myPoa = PortableServer::POA::_duplicate(poa);


@@ -335,8 +334,6 @@ SMESH_Gen_i::SMESH_Gen_i( CORBA::ORB_ptr            orb,
 
 SMESH_Gen_i::~SMESH_Gen_i()
 {
 
 SMESH_Gen_i::~SMESH_Gen_i()
 {

-  MESSAGE( "SMESH_Gen_i::~SMESH_Gen_i" );
-

   // delete hypothesis creators
   map<string, GenericHypothesisCreator_i*>::iterator itHyp, itHyp2;
   for (itHyp = myHypCreatorMap.begin(); itHyp != myHypCreatorMap.end(); itHyp++)
   // delete hypothesis creators
   map<string, GenericHypothesisCreator_i*>::iterator itHyp, itHyp2;
   for (itHyp = myHypCreatorMap.begin(); itHyp != myHypCreatorMap.end(); itHyp++)


@@ -512,7 +509,7 @@ SMESH::SMESH_Mesh_ptr SMESH_Gen_i::createMesh()
     // create a new mesh object servant, store it in a map in study context
     SMESH_Mesh_i* meshServant = new SMESH_Mesh_i( GetPOA(), this, GetCurrentStudyID() );
     // create a new mesh object
     // create a new mesh object servant, store it in a map in study context
     SMESH_Mesh_i* meshServant = new SMESH_Mesh_i( GetPOA(), this, GetCurrentStudyID() );
     // create a new mesh object

-    MESSAGE("myIsEmbeddedMode " << myIsEmbeddedMode);
+    if(MYDEBUG) MESSAGE("myIsEmbeddedMode " << myIsEmbeddedMode);

     meshServant->SetImpl( myGen.CreateMesh( GetCurrentStudyID(), myIsEmbeddedMode ));
 
     // activate the CORBA servant of Mesh
     meshServant->SetImpl( myGen.CreateMesh( GetCurrentStudyID(), myIsEmbeddedMode ));
 
     // activate the CORBA servant of Mesh


@@ -571,7 +568,6 @@ void SMESH_Gen_i::SetGeomEngine( GEOM::GEOM_Gen_ptr geomcompo )
 void SMESH_Gen_i::SetEmbeddedMode( CORBA::Boolean theMode )
 {
   myIsEmbeddedMode = theMode;
 void SMESH_Gen_i::SetEmbeddedMode( CORBA::Boolean theMode )
 {
   myIsEmbeddedMode = theMode;

-  MESSAGE("myIsEmbeddedMode " << myIsEmbeddedMode);

 
   if ( !myIsEmbeddedMode ) {
     //PAL10867: disable signals catching with "noexcepthandler" option
 
   if ( !myIsEmbeddedMode ) {
     //PAL10867: disable signals catching with "noexcepthandler" option

diff --git a/src/SMESH_I/SMESH_Group_i.cxx b/src/SMESH_I/SMESH_Group_i.cxx
index cee8097de05e935035dacd017674d05b22b34584..84e405e9b4d2d3d579371a329998d20966a48bb7 100644 (file)
--- a/src/SMESH_I/SMESH_Group_i.cxx
+++ b/src/SMESH_I/SMESH_Group_i.cxx
@@ -72,7 +72,6 @@ SMESH_Group_i::SMESH_Group_i( PortableServer::POA_ptr thePOA,
   : SALOME::GenericObj_i( thePOA ),
     SMESH_GroupBase_i( thePOA, theMeshServant, theLocalID )
 {
   : SALOME::GenericObj_i( thePOA ),
     SMESH_GroupBase_i( thePOA, theMeshServant, theLocalID )
 {

-  //MESSAGE("SMESH_Group_i; this = "<<this );

 }
 
 SMESH_GroupOnGeom_i::SMESH_GroupOnGeom_i( PortableServer::POA_ptr thePOA,
 }
 
 SMESH_GroupOnGeom_i::SMESH_GroupOnGeom_i( PortableServer::POA_ptr thePOA,


@@ -81,7 +80,6 @@ SMESH_GroupOnGeom_i::SMESH_GroupOnGeom_i( PortableServer::POA_ptr thePOA,
   : SALOME::GenericObj_i( thePOA ),
     SMESH_GroupBase_i( thePOA, theMeshServant, theLocalID )
 {
   : SALOME::GenericObj_i( thePOA ),
     SMESH_GroupBase_i( thePOA, theMeshServant, theLocalID )
 {

-  //MESSAGE("SMESH_GroupOnGeom_i; this = "<<this );

 }
 
 SMESH_GroupOnFilter_i::SMESH_GroupOnFilter_i( PortableServer::POA_ptr thePOA,
 }
 
 SMESH_GroupOnFilter_i::SMESH_GroupOnFilter_i( PortableServer::POA_ptr thePOA,


@@ -90,7 +88,6 @@ SMESH_GroupOnFilter_i::SMESH_GroupOnFilter_i( PortableServer::POA_ptr thePOA,
   : SALOME::GenericObj_i( thePOA ),
     SMESH_GroupBase_i( thePOA, theMeshServant, theLocalID )
 {
   : SALOME::GenericObj_i( thePOA ),
     SMESH_GroupBase_i( thePOA, theMeshServant, theLocalID )
 {

-  //MESSAGE("SMESH_GroupOnGeom_i; this = "<<this );

 }
 
 //=============================================================================
 }
 
 //=============================================================================


@@ -176,7 +173,6 @@ char* SMESH_GroupBase_i::GetName()
   ::SMESH_Group* aGroup = GetSmeshGroup();
   if (aGroup)
     return CORBA::string_dup (aGroup->GetName());
   ::SMESH_Group* aGroup = GetSmeshGroup();
   if (aGroup)
     return CORBA::string_dup (aGroup->GetName());

-  MESSAGE("get name of a vague group");

   return CORBA::string_dup( "NO_NAME" );
 }
 
   return CORBA::string_dup( "NO_NAME" );
 }
 


@@ -203,7 +199,6 @@ SMESH::ElementType SMESH_GroupBase_i::GetType()
     }
     return aType;
   }
     }
     return aType;
   }

-  MESSAGE("get type of a vague group");

   return SMESH::ALL;
 }
 
   return SMESH::ALL;
 }
 


@@ -222,7 +217,6 @@ CORBA::Long SMESH_GroupBase_i::Size()
   SMESHDS_GroupBase* aGroupDS = GetGroupDS();
   if (aGroupDS)
     return aGroupDS->Extent();
   SMESHDS_GroupBase* aGroupDS = GetGroupDS();
   if (aGroupDS)
     return aGroupDS->Extent();

-  MESSAGE("get size of a vague group");

   return 0;
 }
 
   return 0;
 }
 


@@ -240,7 +234,6 @@ CORBA::Boolean SMESH_GroupBase_i::IsEmpty()
   SMESHDS_GroupBase* aGroupDS = GetGroupDS();
   if (aGroupDS)
     return aGroupDS->IsEmpty();
   SMESHDS_GroupBase* aGroupDS = GetGroupDS();
   if (aGroupDS)
     return aGroupDS->IsEmpty();

-  MESSAGE("checking IsEmpty of a vague group");

   return true;
 }
 
   return true;
 }
 


@@ -280,8 +273,6 @@ void SMESH_Group_i::Clear()
     return;
   }
   Modified(); // notify dependent Filter with FT_BelongToMeshGroup criterion
     return;
   }
   Modified(); // notify dependent Filter with FT_BelongToMeshGroup criterion

-
-  MESSAGE("attempt to clear a vague group");

 }
 
 //=============================================================================
 }
 
 //=============================================================================


@@ -298,7 +289,6 @@ CORBA::Boolean SMESH_GroupBase_i::Contains( CORBA::Long theID )
   SMESHDS_GroupBase* aGroupDS = GetGroupDS();
   if (aGroupDS)
     return aGroupDS->Contains(theID);
   SMESHDS_GroupBase* aGroupDS = GetGroupDS();
   if (aGroupDS)
     return aGroupDS->Contains(theID);

-  MESSAGE("attempt to check contents of a vague group");

   return false;
 }
 
   return false;
 }
 


@@ -631,7 +621,6 @@ SALOMEDS::Color SMESH_GroupBase_i::GetColor()
 
     return aColor;
   }
 
     return aColor;
   }

-  MESSAGE("get color of a group");

   return SALOMEDS::Color();
 }
 
   return SALOMEDS::Color();
 }
 


@@ -889,7 +878,6 @@ SMESH::long_array* SMESH_GroupOnFilter_i::GetListOfID()
     if ( 0 < aRes->length() && aRes->length() < 100 ) // for comfortable testing ;)
       std::sort( &aRes[0], &aRes[0] + aRes->length() );
   }
     if ( 0 < aRes->length() && aRes->length() < 100 ) // for comfortable testing ;)
       std::sort( &aRes[0], &aRes[0] + aRes->length() );
   }

-  MESSAGE("get list of IDs of a vague group");

   return aRes._retn();
 }
 
   return aRes._retn();
 }
 

diff --git a/src/SMESH_I/SMESH_Mesh_i.cxx b/src/SMESH_I/SMESH_Mesh_i.cxx
index 1390b2276a3b59a58c9ae6062688e5d2aa4c8ba5..625537a1c948fdc5b2e7fe243b979aef41e2d87d 100644 (file)
--- a/src/SMESH_I/SMESH_Mesh_i.cxx
+++ b/src/SMESH_I/SMESH_Mesh_i.cxx
@@ -108,7 +108,6 @@ SMESH_Mesh_i::SMESH_Mesh_i( PortableServer::POA_ptr thePOA,
                             CORBA::Long             studyId )
 : SALOME::GenericObj_i( thePOA )
 {
                             CORBA::Long             studyId )
 : SALOME::GenericObj_i( thePOA )
 {

-  MESSAGE("SMESH_Mesh_i");

   _impl          = NULL;
   _gen_i         = gen_i;
   _id            = _idGenerator++;
   _impl          = NULL;
   _gen_i         = gen_i;
   _id            = _idGenerator++;


@@ -127,8 +126,6 @@ SMESH_Mesh_i::SMESH_Mesh_i( PortableServer::POA_ptr thePOA,
 
 SMESH_Mesh_i::~SMESH_Mesh_i()
 {
 
 SMESH_Mesh_i::~SMESH_Mesh_i()
 {

-  MESSAGE("~SMESH_Mesh_i");
-

   // destroy groups
   map<int, SMESH::SMESH_GroupBase_ptr>::iterator itGr;
   for (itGr = _mapGroups.begin(); itGr != _mapGroups.end(); itGr++)
   // destroy groups
   map<int, SMESH::SMESH_GroupBase_ptr>::iterator itGr;
   for (itGr = _mapGroups.begin(); itGr != _mapGroups.end(); itGr++)


@@ -4265,8 +4262,7 @@ CORBA::LongLong SMESH_Mesh_i::GetMeshPtr()
     _preMeshInfo->FullLoadFromFile();
 
   CORBA::LongLong pointeur = CORBA::LongLong(_impl);
     _preMeshInfo->FullLoadFromFile();
 
   CORBA::LongLong pointeur = CORBA::LongLong(_impl);

-  if ( MYDEBUG )
-    MESSAGE("CORBA::LongLong SMESH_Mesh_i::GetMeshPtr() "<<pointeur);
+  if ( MYDEBUG ) MESSAGE("CORBA::LongLong SMESH_Mesh_i::GetMeshPtr() "<<pointeur);

   return pointeur;
 }
 
   return pointeur;
 }
 

diff --git a/src/StdMeshers/StdMeshers_Projection_2D.cxx b/src/StdMeshers/StdMeshers_Projection_2D.cxx
index c4375bac9c1a8c222681114520f69cca6dda863e..8617f2a1d0feae754e4066fa1b68903fcebf6ea9 100644 (file)
--- a/src/StdMeshers/StdMeshers_Projection_2D.cxx
+++ b/src/StdMeshers/StdMeshers_Projection_2D.cxx
@@ -1159,7 +1159,6 @@ bool StdMeshers_Projection_2D::Compute(SMESH_Mesh& theMesh, const TopoDS_Shape&
 {
   _src2tgtNodes.clear();
 
 {
   _src2tgtNodes.clear();
 

-  MESSAGE("Projection_2D Compute");

   if ( !_sourceHypo )
     return false;
 
   if ( !_sourceHypo )
     return false;
 


@@ -1257,7 +1256,7 @@ bool StdMeshers_Projection_2D::Compute(SMESH_Mesh& theMesh, const TopoDS_Shape&
   {
     // projection in case if the faces are similar in 2D space
     projDone = projectBy2DSimilarity( tgtFace, srcFace, tgtWires, srcWires,
   {
     // projection in case if the faces are similar in 2D space
     projDone = projectBy2DSimilarity( tgtFace, srcFace, tgtWires, srcWires,

-                                      shape2ShapeMap, _src2tgtNodes, is1DComputed);
+                                      shape2ShapeMap, _src2tgtNodes, is1DComputed );

   }
   if ( !projDone )
   {
   }
   if ( !projDone )
   {

diff --git a/src/StdMeshers/StdMeshers_Regular_1D.cxx b/src/StdMeshers/StdMeshers_Regular_1D.cxx
index 939ceafde7e8bc9cbe96a547577ba566f311c29a..7118e0a2160c9973c10c5ab2f747810daa275ada 100644 (file)
--- a/src/StdMeshers/StdMeshers_Regular_1D.cxx
+++ b/src/StdMeshers/StdMeshers_Regular_1D.cxx
@@ -72,15 +72,15 @@ using namespace StdMeshers;
 
 //=============================================================================
 /*!
 
 //=============================================================================
 /*!

- *  
+ *

  */
 //=============================================================================
 
  */
 //=============================================================================
 

-StdMeshers_Regular_1D::StdMeshers_Regular_1D(int hypId, int studyId,
+StdMeshers_Regular_1D::StdMeshers_Regular_1D(int         hypId,
+                                             int         studyId,

                                              SMESH_Gen * gen)
                                              SMESH_Gen * gen)

-  :SMESH_1D_Algo(hypId, studyId, gen)
+  :SMESH_1D_Algo( hypId, studyId, gen )

 {
 {

-  MESSAGE("StdMeshers_Regular_1D::StdMeshers_Regular_1D");

   _name = "Regular_1D";
   _shapeType = (1 << TopAbs_EDGE);
   _fpHyp = 0;
   _name = "Regular_1D";
   _shapeType = (1 << TopAbs_EDGE);
   _fpHyp = 0;


@@ -155,7 +155,7 @@ bool StdMeshers_Regular_1D::CheckHypothesis( SMESH_Mesh&         aMesh,
 
   string hypName = theHyp->GetName();
 
 
   string hypName = theHyp->GetName();
 

-  if (hypName == "LocalLength")
+  if ( hypName == "LocalLength" )

   {
     const StdMeshers_LocalLength * hyp =
       dynamic_cast <const StdMeshers_LocalLength * >(theHyp);
   {
     const StdMeshers_LocalLength * hyp =
       dynamic_cast <const StdMeshers_LocalLength * >(theHyp);


@@ -167,7 +167,7 @@ bool StdMeshers_Regular_1D::CheckHypothesis( SMESH_Mesh&         aMesh,
     aStatus = SMESH_Hypothesis::HYP_OK;
   }
 
     aStatus = SMESH_Hypothesis::HYP_OK;
   }
 

-  else if (hypName == "MaxLength")
+  else if ( hypName == "MaxLength" )

   {
     const StdMeshers_MaxLength * hyp =
       dynamic_cast <const StdMeshers_MaxLength * >(theHyp);
   {
     const StdMeshers_MaxLength * hyp =
       dynamic_cast <const StdMeshers_MaxLength * >(theHyp);


@@ -182,9 +182,8 @@ bool StdMeshers_Regular_1D::CheckHypothesis( SMESH_Mesh&         aMesh,
     aStatus = SMESH_Hypothesis::HYP_OK;
   }
 
     aStatus = SMESH_Hypothesis::HYP_OK;
   }
 

-  else if (hypName == "NumberOfSegments")
+  else if ( hypName == "NumberOfSegments" )

   {
   {

-       MESSAGE("CheckHypothesis: NumberOfSegments");

     const StdMeshers_NumberOfSegments * hyp =
       dynamic_cast <const StdMeshers_NumberOfSegments * >(theHyp);
     ASSERT(hyp);
     const StdMeshers_NumberOfSegments * hyp =
       dynamic_cast <const StdMeshers_NumberOfSegments * >(theHyp);
     ASSERT(hyp);


@@ -218,7 +217,7 @@ bool StdMeshers_Regular_1D::CheckHypothesis( SMESH_Mesh&         aMesh,
     aStatus = SMESH_Hypothesis::HYP_OK;
   }
 
     aStatus = SMESH_Hypothesis::HYP_OK;
   }
 

-  else if (hypName == "Arithmetic1D")
+  else if ( hypName == "Arithmetic1D" )

   {
     const StdMeshers_Arithmetic1D * hyp =
       dynamic_cast <const StdMeshers_Arithmetic1D * >(theHyp);
   {
     const StdMeshers_Arithmetic1D * hyp =
       dynamic_cast <const StdMeshers_Arithmetic1D * >(theHyp);


@@ -233,7 +232,7 @@ bool StdMeshers_Regular_1D::CheckHypothesis( SMESH_Mesh&         aMesh,
     aStatus = SMESH_Hypothesis::HYP_OK;
   }
 
     aStatus = SMESH_Hypothesis::HYP_OK;
   }
 

-  else if (hypName == "GeometricProgression")
+  else if ( hypName == "GeometricProgression" )

   {
     const StdMeshers_Geometric1D * hyp =
       dynamic_cast <const StdMeshers_Geometric1D * >(theHyp);
   {
     const StdMeshers_Geometric1D * hyp =
       dynamic_cast <const StdMeshers_Geometric1D * >(theHyp);


@@ -248,7 +247,7 @@ bool StdMeshers_Regular_1D::CheckHypothesis( SMESH_Mesh&         aMesh,
     aStatus = SMESH_Hypothesis::HYP_OK;
   }
 
     aStatus = SMESH_Hypothesis::HYP_OK;
   }
 

-  else if (hypName == "FixedPoints1D") {
+  else if ( hypName == "FixedPoints1D" ) {

     _fpHyp = dynamic_cast <const StdMeshers_FixedPoints1D*>(theHyp);
     ASSERT(_fpHyp);
     _hypType = FIXED_POINTS_1D;
     _fpHyp = dynamic_cast <const StdMeshers_FixedPoints1D*>(theHyp);
     ASSERT(_fpHyp);
     _hypType = FIXED_POINTS_1D;


@@ -258,7 +257,7 @@ bool StdMeshers_Regular_1D::CheckHypothesis( SMESH_Mesh&         aMesh,
     aStatus = SMESH_Hypothesis::HYP_OK;
   }
 
     aStatus = SMESH_Hypothesis::HYP_OK;
   }
 

-  else if (hypName == "StartEndLength")
+  else if ( hypName == "StartEndLength" )

   {
     const StdMeshers_StartEndLength * hyp =
       dynamic_cast <const StdMeshers_StartEndLength * >(theHyp);
   {
     const StdMeshers_StartEndLength * hyp =
       dynamic_cast <const StdMeshers_StartEndLength * >(theHyp);


@@ -273,7 +272,7 @@ bool StdMeshers_Regular_1D::CheckHypothesis( SMESH_Mesh&         aMesh,
     aStatus = SMESH_Hypothesis::HYP_OK;
   }
 
     aStatus = SMESH_Hypothesis::HYP_OK;
   }
 

-  else if (hypName == "Deflection1D")
+  else if ( hypName == "Deflection1D" )

   {
     const StdMeshers_Deflection1D * hyp =
       dynamic_cast <const StdMeshers_Deflection1D * >(theHyp);
   {
     const StdMeshers_Deflection1D * hyp =
       dynamic_cast <const StdMeshers_Deflection1D * >(theHyp);


@@ -284,7 +283,7 @@ bool StdMeshers_Regular_1D::CheckHypothesis( SMESH_Mesh&         aMesh,
     aStatus = SMESH_Hypothesis::HYP_OK;
   }
 
     aStatus = SMESH_Hypothesis::HYP_OK;
   }
 

-  else if (hypName == "AutomaticLength")
+  else if ( hypName == "AutomaticLength" )

   {
     StdMeshers_AutomaticLength * hyp = const_cast<StdMeshers_AutomaticLength *>
       (dynamic_cast <const StdMeshers_AutomaticLength * >(theHyp));
   {
     StdMeshers_AutomaticLength * hyp = const_cast<StdMeshers_AutomaticLength *>
       (dynamic_cast <const StdMeshers_AutomaticLength * >(theHyp));


@@ -294,7 +293,7 @@ bool StdMeshers_Regular_1D::CheckHypothesis( SMESH_Mesh&         aMesh,
     _hypType = MAX_LENGTH;
     aStatus = SMESH_Hypothesis::HYP_OK;
   }
     _hypType = MAX_LENGTH;
     aStatus = SMESH_Hypothesis::HYP_OK;
   }

-  else if (hypName == "Adaptive1D")
+  else if ( hypName == "Adaptive1D" )

   {
     _adaptiveHyp = dynamic_cast < const StdMeshers_Adaptive1D* >(theHyp);
     ASSERT(_adaptiveHyp);
   {
     _adaptiveHyp = dynamic_cast < const StdMeshers_Adaptive1D* >(theHyp);
     ASSERT(_adaptiveHyp);


@@ -352,13 +351,11 @@ static bool computeParamByFunc(Adaptor3d_Curve& C3d,
   // never do this way
   //OSD::SetSignal( true );
 
   // never do this way
   //OSD::SetSignal( true );
 

-  if (nbSeg <= 0)
+  if ( nbSeg <= 0 )

     return false;
 
     return false;
 

-  MESSAGE( "computeParamByFunc" );
-

   int nbPnt = 1 + nbSeg;
   int nbPnt = 1 + nbSeg;

-  vector<double> x(nbPnt, 0.);
+  vector<double> x( nbPnt, 0. );

 
   if ( !buildDistribution( func, 0.0, 1.0, nbSeg, x, 1E-4 ))
      return false;
 
   if ( !buildDistribution( func, 0.0, 1.0, nbSeg, x, 1E-4 ))
      return false;


@@ -375,7 +372,7 @@ static bool computeParamByFunc(Adaptor3d_Curve& C3d,
   for ( int i = 1; i < nbSeg; i++ )
   {
     double curvLength = length * (x[i] - x[i-1]) * sign;
   for ( int i = 1; i < nbSeg; i++ )
   {
     double curvLength = length * (x[i] - x[i-1]) * sign;

-    double tol         = Min( Precision::Confusion(), curvLength / 100. );
+    double tol        = Min( Precision::Confusion(), curvLength / 100. );

     GCPnts_AbscissaPoint Discret( tol, C3d, curvLength, prevU );
     if ( !Discret.IsDone() )
       return false;
     GCPnts_AbscissaPoint Discret( tol, C3d, curvLength, prevU );
     if ( !Discret.IsDone() )
       return false;


@@ -592,7 +589,6 @@ void StdMeshers_Regular_1D::redistributeNearVertices (SMESH_Mesh &          theM
       }
       if ( _hypType == NB_SEGMENTS )
       {
       }
       if ( _hypType == NB_SEGMENTS )
       {

-       MESSAGE("redistributeNearVertices NB_SEGMENTS");

         compensateError(0, vertexLength, f, l, theLength, theC3d, theParameters, true );
       }
       else if ( nPar <= 3 )
         compensateError(0, vertexLength, f, l, theLength, theC3d, theParameters, true );
       }
       else if ( nPar <= 3 )


@@ -667,7 +663,6 @@ bool StdMeshers_Regular_1D::computeInternalParameters(SMESH_Mesh &     theMesh,
                                                       const bool       theReverse,
                                                       bool             theConsiderPropagation)
 {
                                                       const bool       theReverse,
                                                       bool             theConsiderPropagation)
 {

-  MESSAGE("computeInternalParameters");

   theParams.clear();
 
   double f = theFirstU, l = theLastU;
   theParams.clear();
 
   double f = theFirstU, l = theLastU;


@@ -689,7 +684,6 @@ bool StdMeshers_Regular_1D::computeInternalParameters(SMESH_Mesh &     theMesh,
     if ( ! SMESH_Algo::GetSortedNodesOnEdge( theMesh.GetMeshDS(), mainEdge, _quadraticMesh,
                                              mainEdgeParamsOfNodes, SMDSAbs_Edge ))
       return error("Bad node parameters on the source edge of Propagation Of Distribution");
     if ( ! SMESH_Algo::GetSortedNodesOnEdge( theMesh.GetMeshDS(), mainEdge, _quadraticMesh,
                                              mainEdgeParamsOfNodes, SMDSAbs_Edge ))
       return error("Bad node parameters on the source edge of Propagation Of Distribution");

-    MESSAGE("mainEdgeParamsOfNodes.size(): " << mainEdgeParamsOfNodes.size());

     vector< double > segLen( mainEdgeParamsOfNodes.size() - 1 );
     double totalLen = 0;
     BRepAdaptor_Curve mainEdgeCurve( mainEdge );
     vector< double > segLen( mainEdgeParamsOfNodes.size() - 1 );
     double totalLen = 0;
     BRepAdaptor_Curve mainEdgeCurve( mainEdge );


@@ -731,8 +725,8 @@ bool StdMeshers_Regular_1D::computeInternalParameters(SMESH_Mesh &     theMesh,
   {
   case LOCAL_LENGTH:
   case MAX_LENGTH:
   {
   case LOCAL_LENGTH:
   case MAX_LENGTH:

-  case NB_SEGMENTS: {
-    MESSAGE("computeInternalParameters: LOCAL_LENGTH MAX_LENGTH NB_SEGMENTS");
+  case NB_SEGMENTS:
+  {

     double eltSize = 1;
     int nbSegments;
     if ( _hypType == MAX_LENGTH )
     double eltSize = 1;
     int nbSegments;
     if ( _hypType == MAX_LENGTH )


@@ -764,8 +758,7 @@ bool StdMeshers_Regular_1D::computeInternalParameters(SMESH_Mesh &     theMesh,
           }
           if (computed) {
             SMESHDS_SubMesh* smds = sm->GetSubMeshDS();
           }
           if (computed) {
             SMESHDS_SubMesh* smds = sm->GetSubMeshDS();

-            int nb_segments = smds->NbElements();
-            MESSAGE("nb_segments: "<<nb_segments);
+            int       nb_segments = smds->NbElements();

             if (nbseg - 1 <= nb_segments && nb_segments <= nbseg + 1) {
               isFound = true;
               nbseg = nb_segments;
             if (nbseg - 1 <= nb_segments && nb_segments <= nbseg + 1) {
               isFound = true;
               nbseg = nb_segments;


@@ -846,7 +839,6 @@ bool StdMeshers_Regular_1D::computeInternalParameters(SMESH_Mesh &     theMesh,
         break;
       case StdMeshers_NumberOfSegments::DT_Regular:
         eltSize = theLength / nbSegments;
         break;
       case StdMeshers_NumberOfSegments::DT_Regular:
         eltSize = theLength / nbSegments;

-        MESSAGE("eltSize = theLength / nbSegments " << eltSize << " = " << theLength << " / " << nbSegments );

         break;
       default:
         return false;
         break;
       default:
         return false;


@@ -860,7 +852,6 @@ bool StdMeshers_Regular_1D::computeInternalParameters(SMESH_Mesh &     theMesh,
     for ( int i = 2; i < NbPoints; i++ ) // skip 1st and last points
     {
       double param = Discret.Parameter(i);
     for ( int i = 2; i < NbPoints; i++ ) // skip 1st and last points
     {
       double param = Discret.Parameter(i);

-      MESSAGE("computeInternalParameters: theParams  " << i << " " <<  param);

       theParams.push_back( param );
     }
     compensateError( eltSize, eltSize, f, l, theLength, theC3d, theParams, true ); // for PAL9899
       theParams.push_back( param );
     }
     compensateError( eltSize, eltSize, f, l, theLength, theC3d, theParams, true ); // for PAL9899


@@ -899,18 +890,18 @@ bool StdMeshers_Regular_1D::computeInternalParameters(SMESH_Mesh &     theMesh,
     return true;
   }
 
     return true;
   }
 

-  case ARITHMETIC_1D: {
-
+  case ARITHMETIC_1D:
+  {

     // arithmetic progression: SUM(n) = ( an - a1 + q ) * ( a1 + an ) / ( 2 * q ) = theLength
 
     double a1 = _value[ BEG_LENGTH_IND ];
     double an = _value[ END_LENGTH_IND ];
     // arithmetic progression: SUM(n) = ( an - a1 + q ) * ( a1 + an ) / ( 2 * q ) = theLength
 
     double a1 = _value[ BEG_LENGTH_IND ];
     double an = _value[ END_LENGTH_IND ];

-    if ( 1.01*theLength < a1 + an)
+    if ( 1.01*theLength < a1 + an )

       return error ( SMESH_Comment("Invalid segment lengths (")<<a1<<" and "<<an<<") "<<
                      "for an edge of length "<<theLength);
 
       return error ( SMESH_Comment("Invalid segment lengths (")<<a1<<" and "<<an<<") "<<
                      "for an edge of length "<<theLength);
 

-    double  q = ( an - a1 ) / ( 2 *theLength/( a1 + an ) - 1 );
-    int n = int(fabs(q) > numeric_limits<double>::min() ? ( 1+( an-a1 )/q ) : ( 1+theLength/a1 ));
+    double q = ( an - a1 ) / ( 2 *theLength/( a1 + an ) - 1 );
+    int    n = int(fabs(q) > numeric_limits<double>::min() ? ( 1+( an-a1 )/q ) : ( 1+theLength/a1 ));

 
     double U1 = theReverse ? l : f;
     double Un = theReverse ? f : l;
 
     double U1 = theReverse ? l : f;
     double Un = theReverse ? f : l;


@@ -933,13 +924,13 @@ bool StdMeshers_Regular_1D::computeInternalParameters(SMESH_Mesh &     theMesh,
       eltSize += q;
     }
     compensateError( a1, an, U1, Un, theLength, theC3d, theParams );
       eltSize += q;
     }
     compensateError( a1, an, U1, Un, theLength, theC3d, theParams );

-    if (theReverse) theParams.reverse(); // NPAL18025
+    if ( theReverse ) theParams.reverse(); // NPAL18025

 
     return true;
   }
 
 
     return true;
   }
 

-  case GEOMETRIC_1D: {
-
+  case GEOMETRIC_1D:
+  {

     double a1 = _value[ BEG_LENGTH_IND ], an;
     double q  = _value[ END_LENGTH_IND ];
 
     double a1 = _value[ BEG_LENGTH_IND ], an;
     double q  = _value[ END_LENGTH_IND ];
 


@@ -983,7 +974,8 @@ bool StdMeshers_Regular_1D::computeInternalParameters(SMESH_Mesh &     theMesh,
     return true;
   }
 
     return true;
   }
 

-  case FIXED_POINTS_1D: {
+  case FIXED_POINTS_1D:
+  {

     const std::vector<double>& aPnts = _fpHyp->GetPoints();
     const std::vector<int>&   nbsegs = _fpHyp->GetNbSegments();
     TColStd_SequenceOfReal Params;
     const std::vector<double>& aPnts = _fpHyp->GetPoints();
     const std::vector<int>&   nbsegs = _fpHyp->GetNbSegments();
     TColStd_SequenceOfReal Params;


@@ -992,22 +984,22 @@ bool StdMeshers_Regular_1D::computeInternalParameters(SMESH_Mesh &     theMesh,
       if( aPnts[i]<0.0001 || aPnts[i]>0.9999 ) continue;
       int j=1;
       bool IsExist = false;
       if( aPnts[i]<0.0001 || aPnts[i]>0.9999 ) continue;
       int j=1;
       bool IsExist = false;

-      for(; j<=Params.Length(); j++) {
-        if( fabs(aPnts[i]-Params.Value(j)) < 1e-4 ) {
+      for ( ; j <= Params.Length(); j++ ) {
+        if ( Abs( aPnts[i] - Params.Value(j) ) < 1e-4 ) {

           IsExist = true;
           break;
         }
           IsExist = true;
           break;
         }

-        if( aPnts[i]<Params.Value(j) ) break;
+        if ( aPnts[i]<Params.Value(j) ) break;

       }
       }

-      if(!IsExist) Params.InsertBefore(j,aPnts[i]);
+      if ( !IsExist ) Params.InsertBefore( j, aPnts[i] );

     }
     double par2, par1, lp;
     par1 = f;
     }
     double par2, par1, lp;
     par1 = f;

-    lp = l;
+    lp   = l;

     double sign = 1.0;
     double sign = 1.0;

-    if(theReverse) {
+    if ( theReverse ) {

       par1 = l;
       par1 = l;

-      lp = f;
+      lp   = f;

       sign = -1.0;
     }
     double eltSize, segmentSize = 0.;
       sign = -1.0;
     }
     double eltSize, segmentSize = 0.;


@@ -1015,37 +1007,34 @@ bool StdMeshers_Regular_1D::computeInternalParameters(SMESH_Mesh &     theMesh,
     for ( int i = 0; i < Params.Length(); i++ )
     {
       int nbseg = ( i > (int)nbsegs.size()-1 ) ? nbsegs[0] : nbsegs[i];
     for ( int i = 0; i < Params.Length(); i++ )
     {
       int nbseg = ( i > (int)nbsegs.size()-1 ) ? nbsegs[0] : nbsegs[i];

-      segmentSize = Params.Value(i+1)*theLength - currAbscissa;
+      segmentSize = Params.Value( i+1 ) * theLength - currAbscissa;

       currAbscissa += segmentSize;
       currAbscissa += segmentSize;

-      GCPnts_AbscissaPoint APnt(theC3d, sign*segmentSize, par1);
-      if( !APnt.IsDone() )
+      GCPnts_AbscissaPoint APnt( theC3d, sign*segmentSize, par1 );
+      if ( !APnt.IsDone() )

         return error( "GCPnts_AbscissaPoint failed");
         return error( "GCPnts_AbscissaPoint failed");

-      par2 = APnt.Parameter();
+      par2    = APnt.Parameter();

       eltSize = segmentSize/nbseg;
       eltSize = segmentSize/nbseg;

-      GCPnts_UniformAbscissa Discret(theC3d, eltSize, par1, par2);
-      if(theReverse)
-        Discret.Initialize(theC3d, eltSize, par2, par1);
+      GCPnts_UniformAbscissa Discret( theC3d, eltSize, par1, par2 );
+      if ( theReverse )
+        Discret.Initialize( theC3d, eltSize, par2, par1 );

       else
       else

-        Discret.Initialize(theC3d, eltSize, par1, par2);
+        Discret.Initialize( theC3d, eltSize, par1, par2 );

       if ( !Discret.IsDone() )
         return error( "GCPnts_UniformAbscissa failed");
       int NbPoints = Discret.NbPoints();
       list<double> tmpParams;
       if ( !Discret.IsDone() )
         return error( "GCPnts_UniformAbscissa failed");
       int NbPoints = Discret.NbPoints();
       list<double> tmpParams;

-      for(int i=2; i<NbPoints; i++) {
+      for ( int i = 2; i < NbPoints; i++ ) {

         double param = Discret.Parameter(i);
         tmpParams.push_back( param );
       }
         double param = Discret.Parameter(i);
         tmpParams.push_back( param );
       }

-      if (theReverse) {
+      if ( theReverse ) {

         compensateError( eltSize, eltSize, par2, par1, segmentSize, theC3d, tmpParams );
         tmpParams.reverse();
       }
       else {
         compensateError( eltSize, eltSize, par1, par2, segmentSize, theC3d, tmpParams );
       }
         compensateError( eltSize, eltSize, par2, par1, segmentSize, theC3d, tmpParams );
         tmpParams.reverse();
       }
       else {
         compensateError( eltSize, eltSize, par1, par2, segmentSize, theC3d, tmpParams );
       }

-      list<double>::iterator itP = tmpParams.begin();
-      for(; itP != tmpParams.end(); itP++) {
-        theParams.push_back( *(itP) );
-      }
+      theParams.splice( theParams.end(), tmpParams );

       theParams.push_back( par2 );
 
       par1 = par2;
       theParams.push_back( par2 );
 
       par1 = par2;


@@ -1055,39 +1044,36 @@ bool StdMeshers_Regular_1D::computeInternalParameters(SMESH_Mesh &     theMesh,
     segmentSize = theLength - currAbscissa;
     eltSize = segmentSize/nbseg;
     GCPnts_UniformAbscissa Discret;
     segmentSize = theLength - currAbscissa;
     eltSize = segmentSize/nbseg;
     GCPnts_UniformAbscissa Discret;

-    if(theReverse)
-      Discret.Initialize(theC3d, eltSize, par1, lp);
+    if ( theReverse )
+      Discret.Initialize( theC3d, eltSize, par1, lp );

     else
     else

-      Discret.Initialize(theC3d, eltSize, lp, par1);
+      Discret.Initialize( theC3d, eltSize, lp, par1 );

     if ( !Discret.IsDone() )
       return error( "GCPnts_UniformAbscissa failed");
     int NbPoints = Discret.NbPoints();
     list<double> tmpParams;
     if ( !Discret.IsDone() )
       return error( "GCPnts_UniformAbscissa failed");
     int NbPoints = Discret.NbPoints();
     list<double> tmpParams;

-    for(int i=2; i<NbPoints; i++) {
+    for ( int i = 2; i < NbPoints; i++ ) {

       double param = Discret.Parameter(i);
       tmpParams.push_back( param );
     }
       double param = Discret.Parameter(i);
       tmpParams.push_back( param );
     }

-    if (theReverse) {
+    if ( theReverse ) {

       compensateError( eltSize, eltSize, lp, par1, segmentSize, theC3d, tmpParams );
       tmpParams.reverse();
     }
     else {
       compensateError( eltSize, eltSize, par1, lp, segmentSize, theC3d, tmpParams );
     }
       compensateError( eltSize, eltSize, lp, par1, segmentSize, theC3d, tmpParams );
       tmpParams.reverse();
     }
     else {
       compensateError( eltSize, eltSize, par1, lp, segmentSize, theC3d, tmpParams );
     }

-    list<double>::iterator itP = tmpParams.begin();
-    for(; itP != tmpParams.end(); itP++) {
-      theParams.push_back( *(itP) );
-    }
+    theParams.splice( theParams.end(), tmpParams );

 
 

-    if (theReverse) {
+    if ( theReverse )

       theParams.reverse(); // NPAL18025
       theParams.reverse(); // NPAL18025

-    }
+

     return true;
   }
 
     return true;
   }
 

-  case DEFLECTION: {
-
-    GCPnts_UniformDeflection Discret(theC3d, _value[ DEFLECTION_IND ], f, l, true);
+  case DEFLECTION:
+  {
+    GCPnts_UniformDeflection Discret( theC3d, _value[ DEFLECTION_IND ], f, l, true );

     if ( !Discret.IsDone() )
       return false;
 
     if ( !Discret.IsDone() )
       return false;
 


@@ -1114,7 +1100,6 @@ bool StdMeshers_Regular_1D::computeInternalParameters(SMESH_Mesh &     theMesh,
 
 bool StdMeshers_Regular_1D::Compute(SMESH_Mesh & theMesh, const TopoDS_Shape & theShape)
 {
 
 bool StdMeshers_Regular_1D::Compute(SMESH_Mesh & theMesh, const TopoDS_Shape & theShape)
 {

-  MESSAGE("Compute");

   if ( _hypType == NONE )
     return false;
 
   if ( _hypType == NONE )
     return false;
 


@@ -1214,7 +1199,6 @@ bool StdMeshers_Regular_1D::Compute(SMESH_Mesh & theMesh, const TopoDS_Shape & t
 
       //Add the Node in the DataStructure
       SMDS_MeshNode * node = meshDS->AddNode(P.X(), P.Y(), P.Z());
 
       //Add the Node in the DataStructure
       SMDS_MeshNode * node = meshDS->AddNode(P.X(), P.Y(), P.Z());

-      MESSAGE("meshDS->AddNode parameter " << param << " coords=" << "("<< P.X() <<", " << P.Y() << ", " << P.Z() << ")");

       meshDS->SetNodeOnEdge(node, shapeID, param);
 
       if(_quadraticMesh) {
       meshDS->SetNodeOnEdge(node, shapeID, param);
 
       if(_quadraticMesh) {


@@ -1249,8 +1233,6 @@ bool StdMeshers_Regular_1D::Compute(SMESH_Mesh & theMesh, const TopoDS_Shape & t
   }
   else
   {
   }
   else
   {

-    //MESSAGE("************* Degenerated edge! *****************");
-

     // Edge is a degenerated Edge : We put n = 5 points on the edge.
     const int NbPoints = 5;
     BRep_Tool::Range( E, f, l ); // PAL15185
     // Edge is a degenerated Edge : We put n = 5 points on the edge.
     const int NbPoints = 5;
     BRep_Tool::Range( E, f, l ); // PAL15185


@@ -1353,9 +1335,8 @@ bool StdMeshers_Regular_1D::Evaluate(SMESH_Mesh & theMesh,
     
   }
   else {
     
   }
   else {

-    //MESSAGE("************* Degenerated edge! *****************");

     // Edge is a degenerated Edge : We put n = 5 points on the edge.
     // Edge is a degenerated Edge : We put n = 5 points on the edge.

-    if(_quadraticMesh) {
+    if ( _quadraticMesh ) {

       aVec[SMDSEntity_Node] = 11;
       aVec[SMDSEntity_Quad_Edge] = 6;
     }
       aVec[SMDSEntity_Node] = 11;
       aVec[SMDSEntity_Quad_Edge] = 6;
     }

diff --git a/src/StdMeshersGUI/StdMeshersGUI_SubShapeSelectorWdg.cxx b/src/StdMeshersGUI/StdMeshersGUI_SubShapeSelectorWdg.cxx
index a5412668e93d32c8a423e64e75a4f01456532835..ef3dbe164e9a63ce5e6662033a80844cb8e463f0 100644 (file)
--- a/src/StdMeshersGUI/StdMeshersGUI_SubShapeSelectorWdg.cxx
+++ b/src/StdMeshersGUI/StdMeshersGUI_SubShapeSelectorWdg.cxx
@@ -418,12 +418,15 @@ void StdMeshersGUI_SubShapeSelectorWdg::onListSelectionChanged()
     return;
 
   //mySelectionMgr->clearSelected();
     return;
 
   //mySelectionMgr->clearSelected();

-  TColStd_MapOfInteger aIndexes;
+  myPreviewActor->HighlightAll( false );

   QList<QListWidgetItem*> selItems = myListWidget->selectedItems();
   QListWidgetItem* anItem;
   foreach(anItem, selItems)
     myPreviewActor->HighlightID( anItem->text().toInt() );
 
   QList<QListWidgetItem*> selItems = myListWidget->selectedItems();
   QListWidgetItem* anItem;
   foreach(anItem, selItems)
     myPreviewActor->HighlightID( anItem->text().toInt() );
 

+  if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI ))
+    aViewWindow->Repaint();
+

   // update remove button
   myRemoveButton->setEnabled( selItems.size() > 0 );
 
   // update remove button
   myRemoveButton->setEnabled( selItems.size() > 0 );
 

diff --git a/src/StdMeshers_I/StdMeshers_i.cxx b/src/StdMeshers_I/StdMeshers_i.cxx
index 2401d69ddf3e38a69b3d65dda06b222cb5391c99..b94ca0a0f31a8a05c606ed59ba34d57c50ca70bd 100644 (file)
--- a/src/StdMeshers_I/StdMeshers_i.cxx
+++ b/src/StdMeshers_I/StdMeshers_i.cxx
@@ -134,8 +134,6 @@ extern "C"
 STDMESHERS_I_EXPORT
   GenericHypothesisCreator_i* GetHypothesisCreator (const char* aHypName)
   {
 STDMESHERS_I_EXPORT
   GenericHypothesisCreator_i* GetHypothesisCreator (const char* aHypName)
   {

-    MESSAGE("Get HypothesisCreator for " << aHypName);
-

     GenericHypothesisCreator_i* aCreator = 0;
 
     // Hypotheses
     GenericHypothesisCreator_i* aCreator = 0;
 
     // Hypotheses