#16662 EDF - ExportMED : too long (bis)

  Compute precise bounding box for BSpline faces

+ Fix compilation warnings

diff --git a/src/Controls/SMESH_Controls.cxx b/src/Controls/SMESH_Controls.cxx
index 69f3adaa693843ec53e8f5a16b0b36a8863715ec..a6fa8eead63326fec7116eb71a35ca58fb24c728 100644 (file)
--- a/src/Controls/SMESH_Controls.cxx
+++ b/src/Controls/SMESH_Controls.cxx
@@ -4272,6 +4272,8 @@ struct ElementsOnShape::OctreeClassifier : public SMESH_Octree
                     std::vector< ElementsOnShape::Classifier >&       cls );
   void GetClassifiersAtPoint( const gp_XYZ& p,
                               std::vector< ElementsOnShape::Classifier* >& classifiers );
+  size_t GetSize();
+
 protected:
   OctreeClassifier() {}
   SMESH_Octree* newChild() const { return new OctreeClassifier; }
@@ -4297,6 +4299,21 @@ ElementsOnShape::~ElementsOnShape()
 
 Predicate* ElementsOnShape::clone() const
 {
+  size_t size = sizeof( *this );
+  if ( myOctree )
+    size += myOctree->GetSize();
+  if ( !myClassifiers.empty() )
+    size += sizeof( myClassifiers[0] ) * myClassifiers.size();
+  if ( !myWorkClassifiers.empty() )
+    size += sizeof( myWorkClassifiers[0] ) * myWorkClassifiers.size();
+  if ( size > 1e+9 ) // 1G
+  {
+#ifdef _DEBUG_
+    std::cout << "Avoid ElementsOnShape::clone(), too large: " << size << " bytes " << std::endl;
+#endif
+    return 0;
+  }
+
   ElementsOnShape* cln = new ElementsOnShape();
   cln->SetAllNodes ( myAllNodesFlag );
   cln->SetTolerance( myToler );
@@ -4453,6 +4470,8 @@ bool ElementsOnShape::IsSatisfy (const SMDS_MeshElement* elem)
     for ( size_t i = 0; i < myClassifiers.size(); ++i )
       myWorkClassifiers[ i ] = & myClassifiers[ i ];
     myOctree = new OctreeClassifier( myWorkClassifiers );
+
+    SMESHUtils::FreeVector( myWorkClassifiers );
   }
 
   for ( int i = 0, nb = elem->NbNodes(); i < nb  && (isSatisfy == myAllNodesFlag); ++i )
@@ -4624,6 +4643,16 @@ void ElementsOnShape::Classifier::Init( const TopoDS_Shape& theShape,
     {
       Bnd_Box box;
       BRepBndLib::Add( myShape, box );
+      if ( myShape.ShapeType() == TopAbs_FACE )
+      {
+        BRepAdaptor_Surface SA( TopoDS::Face( myShape ), /*useBoundaries=*/false );
+        if ( SA.GetType() == GeomAbs_BSplineSurface )
+        {
+          box.SetVoid();
+          BRepBndLib::AddOptimal( myShape, box,
+                                  /*useTriangulation=*/true, /*useShapeTolerance=*/true );
+        }
+      }
       myBox.Clear();
       myBox.Add( box.CornerMin() );
       myBox.Add( box.CornerMax() );
@@ -4643,19 +4672,19 @@ ElementsOnShape::Classifier::~Classifier()
   delete mySolidClfr; mySolidClfr = 0;
 }
 
-bool ElementsOnShape::Classifier::isOutOfSolid (const gp_Pnt& p)
+bool ElementsOnShape::Classifier::isOutOfSolid( const gp_Pnt& p )
 {
   if ( isOutOfBox( p )) return true;
   mySolidClfr->Perform( p, myTol );
   return ( mySolidClfr->State() != TopAbs_IN && mySolidClfr->State() != TopAbs_ON );
 }
 
-bool ElementsOnShape::Classifier::isOutOfBox (const gp_Pnt& p)
+bool ElementsOnShape::Classifier::isOutOfBox( const gp_Pnt& p )
 {
   return myBox.IsOut( p.XYZ() );
 }
 
-bool ElementsOnShape::Classifier::isOutOfFace  (const gp_Pnt& p)
+bool ElementsOnShape::Classifier::isOutOfFace( const gp_Pnt& p )
 {
   if ( isOutOfBox( p )) return true;
   myProjFace.Perform( p );
@@ -4672,19 +4701,19 @@ bool ElementsOnShape::Classifier::isOutOfFace  (const gp_Pnt& p)
   return true;
 }
 
-bool ElementsOnShape::Classifier::isOutOfEdge  (const gp_Pnt& p)
+bool ElementsOnShape::Classifier::isOutOfEdge( const gp_Pnt& p )
 {
   if ( isOutOfBox( p )) return true;
   myProjEdge.Perform( p );
   return ! ( myProjEdge.NbPoints() > 0 && myProjEdge.LowerDistance() <= myTol );
 }
 
-bool ElementsOnShape::Classifier::isOutOfVertex(const gp_Pnt& p)
+bool ElementsOnShape::Classifier::isOutOfVertex( const gp_Pnt& p )
 {
   return ( myVertexXYZ.Distance( p ) > myTol );
 }
 
-bool ElementsOnShape::Classifier::isBox (const TopoDS_Shape& theShape)
+bool ElementsOnShape::Classifier::isBox(const TopoDS_Shape& theShape )
 {
   TopTools_IndexedMapOfShape vMap;
   TopExp::MapShapes( theShape, TopAbs_VERTEX, vMap );
@@ -4766,6 +4795,19 @@ OctreeClassifier::GetClassifiersAtPoint( const gp_XYZ& point,
   }
 }
 
+size_t ElementsOnShape::OctreeClassifier::GetSize()
+{
+  size_t res = sizeof( *this );
+  if ( !myClassifiers.empty() )
+    res += sizeof( myClassifiers[0] ) * myClassifiers.size();
+
+  if ( !isLeaf() )
+    for (int i = 0; i < nbChildren(); i++)
+      res += ((OctreeClassifier*) myChildren[i])->GetSize();
+
+  return res;
+}
+
 void ElementsOnShape::OctreeClassifier::buildChildrenData()
 {
   // distribute myClassifiers among myChildren
@@ -4840,8 +4882,13 @@ BelongToGeom::BelongToGeom()
 
 Predicate* BelongToGeom::clone() const
 {
-  BelongToGeom* cln = new BelongToGeom( *this );
-  cln->myElementsOnShapePtr.reset( static_cast<ElementsOnShape*>( myElementsOnShapePtr->clone() ));
+  BelongToGeom* cln = 0;
+  if ( myElementsOnShapePtr )
+    if ( ElementsOnShape* eos = static_cast<ElementsOnShape*>( myElementsOnShapePtr->clone() ))
+    {
+      cln = new BelongToGeom( *this );
+      cln->myElementsOnShapePtr.reset( eos );
+    }
   return cln;
 }
 
@@ -5011,8 +5058,13 @@ LyingOnGeom::LyingOnGeom()
 
 Predicate* LyingOnGeom::clone() const
 {
-  LyingOnGeom* cln = new LyingOnGeom( *this );
-  cln->myElementsOnShapePtr.reset( static_cast<ElementsOnShape*>( myElementsOnShapePtr->clone() ));
+  LyingOnGeom* cln = 0;
+  if ( myElementsOnShapePtr )
+    if ( ElementsOnShape* eos = static_cast<ElementsOnShape*>( myElementsOnShapePtr->clone() ))
+    {
+      cln = new LyingOnGeom( *this );
+      cln->myElementsOnShapePtr.reset( eos );
+    }
   return cln;
 }
 

diff --git a/src/MEDWrapper/MED_Factory.cxx b/src/MEDWrapper/MED_Factory.cxx
index 3c504b3547cfbe768572fc1898a99ed71c342359..6f5103994a6b5077e5e640fbd913ed794ca1d690 100644 (file)
--- a/src/MEDWrapper/MED_Factory.cxx
+++ b/src/MEDWrapper/MED_Factory.cxx
@@ -92,18 +92,18 @@ namespace MED
   {
 #ifdef WIN32
 #ifdef UNICODE
-       int size_needed = MultiByteToWideChar(CP_UTF8, 0, fileName.c_str(), strlen(fileName.c_str()), NULL, 0);
-       wchar_t* path = new wchar_t[size_needed + 1];
-       MultiByteToWideChar(CP_UTF8, 0, fileName.c_str(), strlen(fileName.c_str()), path, size_needed);
-       path[size_needed] = '\0';
+    int size_needed = MultiByteToWideChar(CP_UTF8, 0, fileName.c_str(), strlen(fileName.c_str()), NULL, 0);
+    wchar_t* path = new wchar_t[size_needed + 1];
+    MultiByteToWideChar(CP_UTF8, 0, fileName.c_str(), strlen(fileName.c_str()), path, size_needed);
+    path[size_needed] = '\0';
 #else
-       cosnt char* path = xmlPath.c_str();
+    cosnt char* path = xmlPath.c_str();
 #endif
-       bool res = (GetFileAttributes(path) != INVALID_FILE_ATTRIBUTES);
+    bool res = (GetFileAttributes(path) != INVALID_FILE_ATTRIBUTES);
 #ifdef UNICODE
-       delete path;
+    delete path;
 #endif
-       return res;
+    return res;
 #else
     return (access(fileName.c_str(), F_OK) == 0);
 #endif
@@ -148,7 +148,7 @@ namespace MED
               ok = true;
             else {
               int medVersion = 10*major + minor;
-              for (int ii=0; ii < sizeof(medVersionsOK)/sizeof(int); ii++)
+              for (size_t ii=0; ii < sizeof(medVersionsOK)/sizeof(int); ii++)
                 if (medVersionsOK[ii] == medVersion) {
                   ok =true;
                   break;
@@ -205,39 +205,39 @@ namespace MED
   {
     bool isCreated = false;
     if (!CheckCompatibility(fileName, true))
-      {
-        remove(fileName.c_str());
-        isCreated = true;
-      }
+    {
+      remove(fileName.c_str());
+      isCreated = true;
+    }
     int minor = -1;
     if (isCreated)
+    {
+      med_int wantedMajor = MED_MAJOR_NUM;
+      med_int wantedMinor = MED_MINOR_NUM;
+      if (theVersion > 0)
       {
-        med_int wantedMajor = MED_MAJOR_NUM;
-        med_int wantedMinor = MED_MINOR_NUM;
-        if (theVersion > 0)
-          {
-            wantedMajor = theVersion/10;
-            wantedMinor = theVersion%10;
-          }
-        if (wantedMajor == MED_MAJOR_NUM) // the med file will be actually created
-          {
-            if (wantedMinor < MED_MINOR_NUM)
-              minor = wantedMinor;
-          }
-        else                              // an empty existing med file of the right version will be used for append
+        wantedMajor = theVersion/10;
+        wantedMinor = theVersion%10;
+      }
+      if (wantedMajor == MED_MAJOR_NUM) // the med file will be actually created
+      {
+        if (wantedMinor < MED_MINOR_NUM)
+          minor = wantedMinor;
+      }
+      else                              // an empty existing med file of the right version will be used for append
+      {
+        int medVersionsOK[] = MED_VERSIONS_APPEND_COMPATIBLE;
+        bool isVersionOK = false;
+        for (size_t ii=0; ii < sizeof(medVersionsOK)/sizeof(int); ii++)
+          if (medVersionsOK[ii] == theVersion)
           {
-            int medVersionsOK[] = MED_VERSIONS_APPEND_COMPATIBLE;
-            bool isVersionOK = false;
-            for (int ii=0; ii < sizeof(medVersionsOK)/sizeof(int); ii++)
-              if (medVersionsOK[ii] == theVersion)
-                {
-                  isVersionOK =true;
-                  break;
-                }
-            if (isVersionOK)              // copy an empty existing med file of the right version, for append
-              CreateEmptyMEDFile(fileName, theVersion);
+            isVersionOK =true;
+            break;
           }
+        if (isVersionOK)              // copy an empty existing med file of the right version, for append
+          CreateEmptyMEDFile(fileName, theVersion);
       }
+    }
     return new MED::TWrapper(fileName, minor);
   }
 }

diff --git a/src/MEDWrapper/MED_Wrapper.cxx b/src/MEDWrapper/MED_Wrapper.cxx
index 2f12e7cc81131fa60bc5004a4f013cdb9171825d..117ab89f6da8532fff99c42bb6aa5e74e437abf7 100644 (file)
--- a/src/MEDWrapper/MED_Wrapper.cxx
+++ b/src/MEDWrapper/MED_Wrapper.cxx
@@ -188,8 +188,8 @@ namespace MED
   //---------------------------------------------------------------
   TWrapper
   ::TWrapper(const std::string& theFileName, TInt theMinor):
-    myMinor(theMinor),
-    myFile(new TFile(theFileName, theMinor))
+    myFile(new TFile(theFileName, theMinor)),
+    myMinor(theMinor)
   {
     TErr aRet;
     myFile->Open(eLECTURE_ECRITURE, &aRet);

diff --git a/src/SMESHUtils/SMESH_File.cxx b/src/SMESHUtils/SMESH_File.cxx
index e4431ac9a3e92ee71cdebfb00bf6fc1b164696ea..888de195691438d7f5023a69b1787abe82193731 100644 (file)
--- a/src/SMESHUtils/SMESH_File.cxx
+++ b/src/SMESHUtils/SMESH_File.cxx
@@ -82,10 +82,10 @@ bool SMESH_File::open()
   {
 #ifdef WIN32
 #ifdef UNICODE
-         std::wstring aName = Kernel_Utils::utf8_decode_s(_name);
-         const wchar_t* name = aName.c_str();
+    std::wstring  aName = Kernel_Utils::utf8_decode_s(_name);
+    const wchar_t* name = aName.c_str();
 #else
-         char* name = name.data();
+    char* name = _name.data();
 #endif
     _file = CreateFile(name, GENERIC_READ, FILE_SHARE_READ,
                        NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
@@ -321,12 +321,12 @@ bool SMESH_File::openForWriting()
 {
 #ifdef WIN32
 #ifdef UNICODE
-       std::wstring aName = Kernel_Utils::utf8_decode_s(_name);
-       const wchar_t* name = aName.c_str();
+  std::wstring  aName = Kernel_Utils::utf8_decode_s(_name);
+  const wchar_t* name = aName.c_str();
 #else
-       char* name = name.data();
+  char* name = _name.data();
 #endif
-  _file = CreateFile( name,          // name of the write
+  _file = CreateFile( name,                   // name of the write
                       GENERIC_WRITE,          // open for writing
                       0,                      // do not share
                       NULL,                   // default security