src/HexoticPlugin/HexoticPlugin_Hexotic.cxx

   1 // Copyright (C) 2007-2015  CEA/DEN, EDF R&D
   2 //
   3 // This library is free software; you can redistribute it and/or
   4 // modify it under the terms of the GNU Lesser General Public
   5 // License as published by the Free Software Foundation; either
   6 // version 2.1 of the License, or (at your option) any later version.
   7 //
   8 // This library is distributed in the hope that it will be useful,
   9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 // Lesser General Public License for more details.
  12 //
  13 // You should have received a copy of the GNU Lesser General Public
  14 // License along with this library; if not, write to the Free Software
  15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16 //
  17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  18 //
  19
  20 // ---
  21 // File   : HexoticPlugin_Hexotic.cxx
  22 // Author : Lioka RAZAFINDRAZAKA (CEA)
  23 // ---
  24 //
  25 #include "HexoticPlugin_Hexotic.hxx"
  26 #include "HexoticPlugin_Hypothesis.hxx"
  27
  28 #include "utilities.h"
  29
  30 #ifndef WIN32
  31 #include <sys/sysinfo.h>
  32 #else
  33 #include <errno.h>
  34 #include <process.h>
  35 #endif
  36
  37 #ifdef _DEBUG_
  38 #define DUMP(txt) \
  39 //  cout << txt
  40 #else
  41 #define DUMP(txt)
  42 #endif
  43
  44 #include <SMESHDS_Mesh.hxx>
  45 #include <SMESHDS_GroupBase.hxx>
  46 #include <SMESH_ComputeError.hxx>
  47 #include <SMESH_File.hxx>
  48 #include <SMESH_Gen.hxx>
  49 #include <SMESH_HypoFilter.hxx>
  50 #include <SMESH_MesherHelper.hxx>
  51 #include <SMESH_subMesh.hxx>
  52
  53 #include <list>
  54 #include <cstdlib>
  55 #include <iostream>
  56
  57 #include <Standard_ProgramError.hxx>
  58
  59 #include <BRep_Tool.hxx>
  60 #include <BRepBndLib.hxx>
  61 #include <BRepClass3d_SolidClassifier.hxx>
  62 #include <BRepBuilderAPI_MakeVertex.hxx>
  63 #include <BRepExtrema_DistShapeShape.hxx>
  64 #include <OSD_File.hxx>
  65 #include <Precision.hxx>
  66 #include <TopExp_Explorer.hxx>
  67 #include <TopTools_MapOfShape.hxx>
  68 #include <TopoDS.hxx>
  69 #include <gp_Pnt.hxx>
  70 #include <gp_Lin.hxx>
  71 #include <GCPnts_UniformAbscissa.hxx>
  72 #include <IntCurvesFace_Intersector.hxx>
  73 #include <BRepMesh_IncrementalMesh.hxx>
  74 #include <Poly_Triangulation.hxx>
  75 #include <gp_Ax3.hxx>
  76 #include <GeomAdaptor_Curve.hxx>
  77
  78 #include <Basics_Utils.hxx>
  79 #include "GEOMImpl_Types.hxx"
  80 #include "GEOM_wrap.hxx"
  81
  82 static void removeFile( const TCollection_AsciiString& fileName )
  83 {
  84   try {
  85     OSD_File( fileName ).Remove();
  86   }
  87   catch ( Standard_ProgramError ) {
  88     MESSAGE("Can't remove file: " << fileName.ToCString() << " ; file does not exist or permission denied");
  89   }
  90 }
  91
  92 //=============================================================================
  93 /*!
  94  *
  95  */
  96 //=============================================================================
  97
  98 HexoticPlugin_Hexotic::HexoticPlugin_Hexotic(int hypId, int studyId, SMESH_Gen* gen)
  99   : SMESH_3D_Algo(hypId, studyId, gen)
 100 {
 101   MESSAGE("HexoticPlugin_Hexotic::HexoticPlugin_Hexotic");
 102   _name = "MG-Hexa";
 103   _shapeType = (1 << TopAbs_SHELL) | (1 << TopAbs_SOLID);// 1 bit /shape type
 104 //   _onlyUnaryInput = false;
 105   _requireShape = false;
 106   _iShape=0;
 107   _nbShape=0;
 108   _hexoticFilesKept=false;
 109   _compatibleHypothesis.push_back( HexoticPlugin_Hypothesis::GetHypType() );
 110 #ifdef WITH_BLSURFPLUGIN
 111   _blsurfHypo = NULL;
 112 #endif
 113   _compute_canceled = false;
 114
 115   // Copy of what is done in BLSURFPLugin TODO : share the code
 116   smeshGen_i = SMESH_Gen_i::GetSMESHGen();
 117   CORBA::Object_var anObject = smeshGen_i->GetNS()->Resolve("/myStudyManager");
 118   SALOMEDS::StudyManager_var aStudyMgr = SALOMEDS::StudyManager::_narrow(anObject);
 119
 120   myStudy = NULL;
 121   myStudy = aStudyMgr->GetStudyByID(_studyId);
 122   if (myStudy)
 123     MESSAGE("myStudy->StudyId() = " << myStudy->StudyId());
 124 }
 125
 126 //=============================================================================
 127 /*!
 128  *
 129  */
 130 //=============================================================================
 131
 132 HexoticPlugin_Hexotic::~HexoticPlugin_Hexotic()
 133 {
 134   MESSAGE("HexoticPlugin_Hexotic::~HexoticPlugin_Hexotic");
 135 }
 136
 137
 138 #ifdef WITH_BLSURFPLUGIN
 139 bool HexoticPlugin_Hexotic::CheckBLSURFHypothesis( SMESH_Mesh&         aMesh,
 140                                                    const TopoDS_Shape& aShape )
 141 {
 142   // MESSAGE("HexoticPlugin_Hexotic::CheckBLSURFHypothesis");
 143   _blsurfHypo = NULL;
 144
 145   std::list<const SMESHDS_Hypothesis*>::const_iterator itl;
 146   const SMESHDS_Hypothesis* theHyp;
 147
 148   // If a BLSURF hypothesis is applied, get it
 149   SMESH_HypoFilter blsurfFilter;
 150   blsurfFilter.Init( blsurfFilter.HasName( BLSURFPlugin_Hypothesis::GetHypType() ));
 151   std::list<const SMESHDS_Hypothesis *> appliedHyps;
 152   aMesh.GetHypotheses( aShape, blsurfFilter, appliedHyps, false );
 153
 154   if ( appliedHyps.size() > 0 ) {
 155     itl = appliedHyps.begin();
 156     theHyp = (*itl); // use only the first hypothesis
 157     std::string hypName = theHyp->GetName();
 158     if (hypName == BLSURFPlugin_Hypothesis::GetHypType()) {
 159       _blsurfHypo = static_cast<const BLSURFPlugin_Hypothesis*> (theHyp);
 160       ASSERT(_blsurfHypo);
 161       return true;
 162     }
 163   }
 164   return false;
 165 }
 166 #endif
 167
 168 //=============================================================================
 169 /*!
 170  *
 171  */
 172 //=============================================================================
 173
 174 bool HexoticPlugin_Hexotic::CheckHypothesis( SMESH_Mesh&                          aMesh,
 175                                              const TopoDS_Shape&                  aShape,
 176                                              SMESH_Hypothesis::Hypothesis_Status& aStatus )
 177 {
 178   // MESSAGE("HexoticPlugin_Hexotic::CheckHypothesis");
 179   _hypothesis = NULL;
 180
 181   std::list<const SMESHDS_Hypothesis*>::const_iterator itl;
 182   const SMESHDS_Hypothesis* theHyp;
 183
 184   const std::list<const SMESHDS_Hypothesis*>& hyps = GetUsedHypothesis(aMesh, aShape, false);
 185   int nbHyp = hyps.size();
 186   if (!nbHyp) {
 187     aStatus = SMESH_Hypothesis::HYP_OK;
 188     return true;  // can work with no hypothesis
 189   }
 190
 191   itl = hyps.begin();
 192   theHyp = (*itl); // use only the first hypothesis
 193
 194   std::string hypName = theHyp->GetName();
 195   if (hypName == HexoticPlugin_Hypothesis::GetHypType() ) {
 196     _hypothesis = static_cast<const HexoticPlugin_Hypothesis*> (theHyp);
 197     ASSERT(_hypothesis);
 198     aStatus = SMESH_Hypothesis::HYP_OK;
 199   }
 200   else
 201     aStatus = SMESH_Hypothesis::HYP_INCOMPATIBLE;
 202
 203 #ifdef WITH_BLSURFPLUGIN
 204   CheckBLSURFHypothesis(aMesh, aShape);
 205 #endif
 206
 207   return aStatus == SMESH_Hypothesis::HYP_OK;
 208 }
 209
 210 //=======================================================================
 211 //function : findShape
 212 //purpose  :
 213 //=======================================================================
 214
 215 static TopoDS_Shape findShape(SMDS_MeshNode**     t_Node,
 216                               TopoDS_Shape        aShape,
 217                               const TopoDS_Shape* t_Shape,
 218                               double**            t_Box,
 219                               const int           nShape)
 220 {
 221   double pntCoor[3];
 222   int iShape, nbNode = 8;
 223
 224   for ( int i=0; i<3; i++ ) {
 225     pntCoor[i] = 0;
 226     for ( int j=0; j<nbNode; j++ ) {
 227       if ( i == 0) pntCoor[i] += t_Node[j]->X();
 228       if ( i == 1) pntCoor[i] += t_Node[j]->Y();
 229       if ( i == 2) pntCoor[i] += t_Node[j]->Z();
 230     }
 231     pntCoor[i] /= nbNode;
 232   }
 233   gp_Pnt aPnt(pntCoor[0], pntCoor[1], pntCoor[2]);
 234
 235   if ( aShape.IsNull() ) aShape = t_Shape[0];
 236   BRepClass3d_SolidClassifier SC (aShape, aPnt, Precision::Confusion());
 237   if ( !(SC.State() == TopAbs_IN) ) {
 238     aShape.Nullify();
 239     for (iShape = 0; iShape < nShape && aShape.IsNull(); iShape++) {
 240       if ( !( pntCoor[0] < t_Box[iShape][0] || t_Box[iShape][1] < pntCoor[0] ||
 241               pntCoor[1] < t_Box[iShape][2] || t_Box[iShape][3] < pntCoor[1] ||
 242               pntCoor[2] < t_Box[iShape][4] || t_Box[iShape][5] < pntCoor[2]) ) {
 243         BRepClass3d_SolidClassifier SC (t_Shape[iShape], aPnt, Precision::Confusion());
 244         if (SC.State() == TopAbs_IN)
 245           aShape = t_Shape[iShape];
 246       }
 247     }
 248   }
 249   return aShape;
 250 }
 251
 252 //=======================================================================
 253 //function : findEdge
 254 //purpose  :
 255 //=======================================================================
 256
 257 static int findEdge(const SMDS_MeshNode* aNode,
 258                     const SMESHDS_Mesh*  aMesh,
 259                     const int            nEdge,
 260                     const TopoDS_Shape*  t_Edge) {
 261
 262   TopoDS_Shape aPntShape, foundEdge;
 263   TopoDS_Vertex aVertex;
 264   gp_Pnt aPnt( aNode->X(), aNode->Y(), aNode->Z() );
 265
 266   int foundInd, ind;
 267   double nearest = RealLast(), *t_Dist;
 268   double epsilon = Precision::Confusion();
 269
 270   t_Dist = new double[ nEdge ];
 271   aPntShape = BRepBuilderAPI_MakeVertex( aPnt ).Shape();
 272   aVertex   = TopoDS::Vertex( aPntShape );
 273
 274   for ( ind=0; ind < nEdge; ind++ ) {
 275     BRepExtrema_DistShapeShape aDistance ( aVertex, t_Edge[ind] );
 276     t_Dist[ind] = aDistance.Value();
 277     if ( t_Dist[ind] < nearest ) {
 278       nearest   = t_Dist[ind];
 279       foundEdge = t_Edge[ind];
 280       foundInd  = ind;
 281       if ( nearest < epsilon )
 282         ind = nEdge;
 283     }
 284   }
 285
 286   delete [] t_Dist;
 287   return aMesh->ShapeToIndex( foundEdge );
 288 }
 289
 290 //=======================================================================
 291 //function : getNbShape
 292 //purpose  :
 293 //=======================================================================
 294
 295 static int getNbShape(std::string aFile, std::string aString, int defaultValue=0) {
 296   int number = defaultValue;
 297   std::string aLine;
 298   std::ifstream file(aFile.c_str());
 299   while ( !file.eof() ) {
 300     getline( file, aLine);
 301     if ( aLine == aString ) {
 302       getline( file, aLine);
 303       std::istringstream stringFlux( aLine );
 304       stringFlux >> number;
 305       number = ( number + defaultValue + std::abs(number - defaultValue) ) / 2;
 306       break;
 307     }
 308   }
 309   file.close();
 310   return number;
 311 }
 312
 313 //=======================================================================
 314 //function : countShape
 315 //purpose  :
 316 //=======================================================================
 317
 318 template < class Mesh, class Shape >
 319 static int countShape( Mesh* mesh, Shape shape ) {
 320   TopExp_Explorer expShape ( mesh->ShapeToMesh(), shape );
 321   TopTools_MapOfShape mapShape;
 322   int nbShape = 0;
 323   for ( ; expShape.More(); expShape.Next() ) {
 324     if (mapShape.Add(expShape.Current())) {
 325       nbShape++;
 326     }
 327   }
 328   return nbShape;
 329 }
 330
 331 //=======================================================================
 332 //function : getShape
 333 //purpose  :
 334 //=======================================================================
 335
 336 template < class Mesh, class Shape, class Tab >
 337 void getShape(Mesh* mesh, Shape shape, Tab *t_Shape) {
 338   TopExp_Explorer expShape ( mesh->ShapeToMesh(), shape );
 339   TopTools_MapOfShape mapShape;
 340   for ( int i=0; expShape.More(); expShape.Next() ) {
 341     if (mapShape.Add(expShape.Current())) {
 342       t_Shape[i] = expShape.Current();
 343       i++;
 344     }
 345   }
 346   return;
 347 }
 348
 349 //=======================================================================
 350 //function : printWarning
 351 //purpose  :
 352 //=======================================================================
 353
 354 static void printWarning(const int nbExpected, std::string aString, const int nbFound) {
 355   cout << std::endl;
 356   cout << "WARNING : " << nbExpected << " " << aString << " expected, MG-Hexa has found " << nbFound << std::endl;
 357   cout << "=======" << std::endl;
 358   cout << std::endl;
 359   return;
 360 }
 361
 362 //=======================================================================
 363 //function : removeHexoticFiles
 364 //purpose  :
 365 //=======================================================================
 366
 367 static void removeHexoticFiles(TCollection_AsciiString file_In, TCollection_AsciiString file_Out) {
 368   removeFile( file_In );
 369   removeFile( file_Out );
 370 }
 371
 372 //=======================================================================
 373 //function : splitQuads
 374 //purpose  : splits all quadrangles into triangles
 375 //=======================================================================
 376
 377 static void splitQuads(SMESH_Mesh& aMesh)
 378 {
 379   SMESH_MeshEditor spliter( &aMesh );
 380
 381   TIDSortedElemSet elems;
 382   SMDS_ElemIteratorPtr eIt = aMesh.GetMeshDS()->elementsIterator();
 383   while( eIt->more() )
 384     elems.insert( elems.end(), eIt->next() );
 385
 386   spliter.QuadToTri ( elems, /*the13Diag=*/true);
 387 }
 388
 389 //=======================================================================
 390 //function : readResult
 391 //purpose  : Read GMF file in case of a mesh with geometry
 392 //=======================================================================
 393
 394 static bool readResult(std::string         theFile,
 395                        HexoticPlugin_Hexotic*  theAlgo,
 396                        SMESHDS_Mesh*       theMesh,
 397                        const int           nbShape,
 398                        const TopoDS_Shape* tabShape,
 399                        double**            tabBox)
 400 {
 401   // ---------------------------------
 402   // Optimisation of the plugin ...
 403   // Retrieve the correspondance edge --> shape
 404   // (which is very costly) only when user
 405   // has defined at least one group of edges
 406   // which should be rare for a 3d mesh !
 407   // ---------------------------------
 408
 409   bool retrieve_edges = false;
 410   const std::set<SMESHDS_GroupBase*>& aGroups = theMesh->GetGroups();
 411   set<SMESHDS_GroupBase*>::const_iterator GrIt = aGroups.begin();
 412   for (; GrIt != aGroups.end(); GrIt++)
 413     {
 414       SMESHDS_GroupBase* aGrp = *GrIt;
 415       if ( !aGrp )
 416         continue;
 417       if ( aGrp->GetType() == SMDSAbs_Edge )
 418         {
 419           retrieve_edges = true;
 420           break;
 421         }
 422     }
 423
 424   // ---------------------------------
 425   // Read generated elements and nodes
 426   // ---------------------------------
 427
 428   TopoDS_Shape aShape;
 429   TopoDS_Vertex aVertex;
 430   std::string token;
 431   int EndOfFile = 0, nbElem = 0, nField = 9, nbRef = 0;
 432   int aHexoticNodeID = 0, shapeID, hexoticShapeID;
 433   const int IdShapeRef = 2;
 434   int *tabID, *tabRef, *nodeAssigne;
 435   bool *tabDummy, hasDummy = false;
 436   double epsilon = Precision::Confusion();
 437   std::map <std::string,int> mapField;
 438   SMDS_MeshNode** HexoticNode;
 439   TopoDS_Shape *tabCorner, *tabEdge;
 440
 441   const int nbDomains = countShape( theMesh, TopAbs_SHELL );
 442   const int holeID = -1;
 443
 444   // tabID    = new int[nbShape];
 445   tabID    = new int[nbDomains];
 446   tabRef   = new int[nField];
 447   tabDummy = new bool[nField];
 448
 449   for (int i=0; i<nbDomains; i++)
 450     tabID[i] = 0;
 451   if ( nbDomains == 1 )
 452     tabID[0] = theMesh->ShapeToIndex( tabShape[0] );
 453
 454   mapField["MeshVersionFormatted"] = 0; tabRef[0] = 0; tabDummy[0] = false;
 455   mapField["Dimension"]            = 1; tabRef[1] = 0; tabDummy[1] = false;
 456   mapField["Vertices"]             = 2; tabRef[2] = 3; tabDummy[2] = true;
 457   mapField["Corners"]              = 3; tabRef[3] = 1; tabDummy[3] = false;
 458   mapField["Edges"]                = 4; tabRef[4] = 2; tabDummy[4] = true;
 459   mapField["Ridges"]               = 5; tabRef[5] = 1; tabDummy[5] = false;
 460   mapField["Quadrilaterals"]       = 6; tabRef[6] = 4; tabDummy[6] = true;
 461   mapField["Hexahedra"]            = 7; tabRef[7] = 8; tabDummy[7] = true;
 462   mapField["End"]                  = 8; tabRef[8] = 0; tabDummy[0] = false;
 463
 464   SMDS_NodeIteratorPtr itOnHexoticInputNode = theMesh->nodesIterator();
 465   while ( itOnHexoticInputNode->more() )
 466     theMesh->RemoveNode( itOnHexoticInputNode->next() );
 467
 468   int nbVertices   = getNbShape(theFile, "Vertices");
 469   int nbCorners    = getNbShape(theFile, "Corners", countShape( theMesh, TopAbs_VERTEX ));
 470   int nbShapeEdge  = countShape( theMesh, TopAbs_EDGE );
 471
 472   tabCorner   = new TopoDS_Shape[ nbCorners ];
 473   tabEdge     = new TopoDS_Shape[ nbShapeEdge ];
 474   nodeAssigne = new int[ nbVertices + 1 ];
 475   HexoticNode = new SMDS_MeshNode*[ nbVertices + 1 ];
 476
 477   getShape(theMesh, TopAbs_VERTEX, tabCorner);
 478   getShape(theMesh, TopAbs_EDGE,   tabEdge);
 479
 480   MESSAGE("Read " << theFile << " file");
 481   std::ifstream fileRes(theFile.c_str());
 482   ASSERT(fileRes);
 483
 484   while ( EndOfFile == 0  ) {
 485     int dummy;
 486     fileRes >> token;
 487
 488     if (mapField.count(token)) {
 489       nField   = mapField[token];
 490       nbRef    = tabRef[nField];
 491       hasDummy = tabDummy[nField];
 492     }
 493     else {
 494       nField = -1;
 495       nbRef = 0;
 496     }
 497
 498     nbElem = 0;
 499     if ( nField < (mapField.size() - 1) && nField >= 0 )
 500       fileRes >> nbElem;
 501
 502     switch (nField) {
 503       case 0: { // "MeshVersionFormatted"
 504         MESSAGE(token << " " << nbElem);
 505         break;
 506       }
 507       case 1: { // "Dimension"
 508         MESSAGE("Mesh dimension " << nbElem << "D");
 509         break;
 510       }
 511       case 2: { // "Vertices"
 512         MESSAGE("Read " << nbElem << " " << token);
 513         int aHexoticID;
 514         double *coord;
 515         SMDS_MeshNode * aHexoticNode;
 516
 517         coord = new double[nbRef];
 518         for ( int iElem = 0; iElem < nbElem; iElem++ ) {
 519           if(theAlgo->computeCanceled())
 520             {
 521               return false;
 522             }
 523           aHexoticID = iElem + 1;
 524           for ( int iCoord = 0; iCoord < 3; iCoord++ )
 525             fileRes >> coord[ iCoord ];
 526           fileRes >> dummy;
 527           aHexoticNode = theMesh->AddNode(coord[0], coord[1], coord[2]);
 528           HexoticNode[ aHexoticID ] = aHexoticNode;
 529           nodeAssigne[ aHexoticID ] = 0;
 530         }
 531         delete [] coord;
 532         break;
 533       }
 534       case 3: // "Corners"
 535       case 4: // "Edges"
 536       case 5: // "Ridges"
 537       case 6: // "Quadrilaterals"
 538       case 7: { // "Hexahedra"
 539         MESSAGE("Read " << nbElem << " " << token);
 540         SMDS_MeshNode** node;
 541         int nodeDim, *nodeID;
 542         SMDS_MeshElement * aHexoticElement = 0;
 543
 544         node   = new SMDS_MeshNode*[ nbRef ];
 545         nodeID = new int[ nbRef ];
 546         for ( int iElem = 0; iElem < nbElem; iElem++ ) {
 547           if(theAlgo->computeCanceled())
 548             {
 549               return false;
 550             }
 551           for ( int iRef = 0; iRef < nbRef; iRef++ ) {
 552             fileRes >> aHexoticNodeID;                          // read nbRef aHexoticNodeID
 553             node[ iRef ]   = HexoticNode[ aHexoticNodeID ];
 554             nodeID[ iRef ] = aHexoticNodeID;
 555           }
 556           if ( hasDummy )
 557             fileRes >> dummy;
 558           switch (nField) {
 559             case 3: { // "Corners"
 560               nodeDim = 1;
 561               gp_Pnt HexoticPnt ( node[0]->X(), node[0]->Y(), node[0]->Z() );
 562               for ( int i=0; i<nbElem; i++ ) {
 563                 aVertex = TopoDS::Vertex( tabCorner[i] );
 564                 gp_Pnt aPnt = BRep_Tool::Pnt( aVertex );
 565                 if ( aPnt.Distance( HexoticPnt ) < epsilon )
 566                   break;
 567               }
 568               break;
 569             }
 570             case 4: { // "Edges"
 571               nodeDim = 2;
 572               aHexoticElement = theMesh->AddEdge( node[0], node[1] );
 573               int iNode = 1;
 574               if ( nodeAssigne[ nodeID[0] ] == 0 || nodeAssigne[ nodeID[0] ] == 2 )
 575                 iNode = 0;
 576               if(retrieve_edges)
 577                 shapeID = findEdge( node[iNode], theMesh, nbShapeEdge, tabEdge );
 578               else
 579                 shapeID = 0;
 580               break;
 581             }
 582             case 5: { // "Ridges"
 583               break;
 584             }
 585             case 6: { // "Quadrilaterals"
 586               nodeDim = 3;
 587               aHexoticElement = theMesh->AddFace( node[0], node[1], node[2], node[3] );
 588               shapeID = dummy;
 589               break;
 590             }
 591             case 7: { // "Hexahedra"
 592               nodeDim = 4;
 593               if ( nbDomains > 1 ) {
 594                 hexoticShapeID = dummy - IdShapeRef;
 595                 if ( tabID[ hexoticShapeID ] == 0 ) {
 596                   aShape = findShape(node, aShape, tabShape, tabBox, nbShape);
 597                   shapeID = aShape.IsNull() ? holeID : theMesh->ShapeToIndex( aShape );
 598                   tabID[ hexoticShapeID ] = shapeID;
 599                 }
 600                 else
 601                   shapeID = tabID[ hexoticShapeID ];
 602                 if ( iElem == (nbElem - 1) ) {
 603                   int shapeAssociated = 0;
 604                   for ( int i=0; i<nbDomains; i++ ) {
 605                     if (tabID[i] > 0 )
 606                       shapeAssociated += 1;
 607                   }
 608                   if ( shapeAssociated != nbShape )
 609                     printWarning(nbShape, "domains", shapeAssociated);
 610                 }
 611               }
 612               else {
 613                 shapeID = tabID[0];
 614               }
 615               if ( shapeID != holeID )
 616                 aHexoticElement = theMesh->AddVolume( node[0], node[3], node[2], node[1], node[4], node[7], node[6], node[5] );
 617               break;
 618             }
 619           } // switch (nField)
 620
 621           if ( token != "Ridges" && ( shapeID > 0 || token == "Corners")) {
 622             for ( int i=0; i<nbRef; i++ ) {
 623               if ( nodeAssigne[ nodeID[i] ] == 0 ) {
 624                 if      ( token == "Corners" )        theMesh->SetNodeOnVertex( node[0], aVertex );
 625                 else if ( token == "Edges" )          theMesh->SetNodeOnEdge( node[i], shapeID );
 626                 else if ( token == "Quadrilaterals" ) theMesh->SetNodeOnFace( node[i], shapeID );
 627                 else if ( token == "Hexahedra" )      theMesh->SetNodeInVolume( node[i], shapeID );
 628                 nodeAssigne[ nodeID[i] ] = nodeDim;
 629               }
 630             }
 631             if ( token != "Corners" && aHexoticElement )
 632               theMesh->SetMeshElementOnShape( aHexoticElement, shapeID );
 633           }
 634         }
 635         delete [] node;
 636         delete [] nodeID;
 637         break;
 638       }
 639       case 8: { // "End"
 640         EndOfFile = 1;
 641         MESSAGE("End of " << theFile << " file");
 642         break;
 643       }
 644       default: {
 645         MESSAGE("Unknown Token: " << token);
 646       }
 647     }
 648   }
 649   cout << std::endl;
 650
 651   // remove nodes in holes
 652   if ( nbDomains > 1 )
 653   {
 654     SMESHDS_SubMesh* subMesh;
 655     for ( int i = 1; i <= nbVertices; ++i )
 656       if ( HexoticNode[i]->NbInverseElements() == 0 )
 657       {
 658         subMesh =  HexoticNode[i]->getshapeId() > 0 ? theMesh->MeshElements(HexoticNode[i]->getshapeId() ) : 0;
 659         theMesh->RemoveFreeNode( HexoticNode[i], subMesh, /*fromGroups=*/false );
 660       }
 661   }
 662   delete [] tabID;
 663   delete [] tabRef;
 664   delete [] tabDummy;
 665   delete [] tabCorner;
 666   delete [] tabEdge;
 667   delete [] nodeAssigne;
 668   delete [] HexoticNode;
 669   return true;
 670 }
 671
 672
 673 //=======================================================================
 674 //function : readResult
 675 //purpose  : Read GMF file in case of a mesh w/o geometry
 676 //=======================================================================
 677
 678 static bool readResult(std::string theFile,
 679                        HexoticPlugin_Hexotic*  theAlgo,
 680                        SMESH_MesherHelper* theHelper)
 681 {
 682   SMESHDS_Mesh* theMesh = theHelper->GetMeshDS();
 683
 684   // ---------------------------------
 685   // Read generated elements and nodes
 686   // ---------------------------------
 687
 688   std::string token;
 689   const int nbField = 9;
 690   int nField, EndOfFile = 0, nbElem = 0, nbRef = 0;
 691   int aHexoticNodeID = 0, shapeID;
 692   int tabRef[nbField], *nodeAssigne;
 693   bool tabDummy[nbField], hasDummy = false;
 694   std::map <std::string,int> mapField;
 695   SMDS_MeshNode** HexoticNode;
 696
 697   mapField["MeshVersionFormatted"] = 0; tabRef[0] = 0; tabDummy[0] = false;
 698   mapField["Dimension"]            = 1; tabRef[1] = 0; tabDummy[1] = false;
 699   mapField["Vertices"]             = 2; tabRef[2] = 3; tabDummy[2] = true;
 700   mapField["Corners"]              = 3; tabRef[3] = 1; tabDummy[3] = false;
 701   mapField["Edges"]                = 4; tabRef[4] = 2; tabDummy[4] = true;
 702   mapField["Ridges"]               = 5; tabRef[5] = 1; tabDummy[5] = false;
 703   mapField["Quadrilaterals"]       = 6; tabRef[6] = 4; tabDummy[6] = true;
 704   mapField["Hexahedra"]            = 7; tabRef[7] = 8; tabDummy[7] = true;
 705   mapField["End"]                  = 8; tabRef[8] = 0; tabDummy[8] = false;
 706
 707   {
 708     // theMesh->Clear(); -- this does not remove imported mesh
 709     SMDS_ElemIteratorPtr eIt = theMesh->elementsIterator();
 710     while( eIt->more() )
 711       theMesh->RemoveFreeElement( eIt->next(), /*sm=*/0 );
 712     SMDS_NodeIteratorPtr nIt = theMesh->nodesIterator();
 713     while ( nIt->more() )
 714       theMesh->RemoveFreeNode( nIt->next(), /*sm=*/0 );
 715   }
 716
 717   int nbVertices = getNbShape(theFile, "Vertices");
 718   HexoticNode = new SMDS_MeshNode*[ nbVertices + 1 ];
 719   nodeAssigne = new int[ nbVertices + 1 ];
 720
 721   MESSAGE("Read " << theFile << " file");
 722   std::ifstream fileRes(theFile.c_str());
 723   ASSERT(fileRes);
 724
 725   while ( !EndOfFile  )
 726   {
 727     int dummy;
 728     fileRes >> token;
 729
 730     if (mapField.count(token)) {
 731       nField   = mapField[token];
 732       nbRef    = tabRef[nField];
 733       hasDummy = tabDummy[nField];
 734     }
 735     else {
 736       nField = -1;
 737       nbRef = 0;
 738     }
 739
 740     nbElem = 0;
 741     if ( nField < (mapField.size() - 1) && nField >= 0 )
 742       fileRes >> nbElem;
 743
 744     switch (nField) {
 745     case 0: { // "MeshVersionFormatted"
 746       MESSAGE(token << " " << nbElem);
 747       break;
 748     }
 749     case 1: { // "Dimension"
 750       MESSAGE("Mesh dimension " << nbElem << "D");
 751       break;
 752     }
 753     case 2: { // "Vertices"
 754       MESSAGE("Read " << nbElem << " " << token);
 755       int aHexoticID;
 756       double coord[3];
 757       SMDS_MeshNode * aHexoticNode;
 758
 759       for ( int iElem = 0; iElem < nbElem; iElem++ ) {
 760         if(theAlgo->computeCanceled())
 761           {
 762             return false;
 763           }
 764         aHexoticID = iElem + 1;
 765         for ( int iCoord = 0; iCoord < 3; iCoord++ )
 766           fileRes >> coord[ iCoord ];
 767         fileRes >> dummy;
 768         aHexoticNode = theMesh->AddNode(coord[0], coord[1], coord[2]);
 769         HexoticNode[ aHexoticID ] = aHexoticNode;
 770         nodeAssigne[ aHexoticID ] = 0;
 771       }
 772       break;
 773     }
 774     case 3: // "Corners"
 775     case 4: // "Edges"
 776     case 5: // "Ridges"
 777     case 6: // "Quadrilaterals"
 778     case 7: { // "Hexahedra"
 779       MESSAGE("Read " << nbElem << " " << token);
 780       std::vector< SMDS_MeshNode* > node( nbRef );
 781       std::vector< int >          nodeID( nbRef );
 782
 783       for ( int iElem = 0; iElem < nbElem; iElem++ )
 784       {
 785         if(theAlgo->computeCanceled())
 786           {
 787             return false;
 788           }
 789         for ( int iRef = 0; iRef < nbRef; iRef++ )
 790         {
 791           fileRes >> aHexoticNodeID;                          // read nbRef aHexoticNodeID
 792           node  [ iRef ] = HexoticNode[ aHexoticNodeID ];
 793           nodeID[ iRef ] = aHexoticNodeID;
 794         }
 795         if ( hasDummy )
 796           fileRes >> dummy;
 797         switch (nField)
 798         {
 799         case 4: // "Edges"
 800           theHelper->AddEdge( node[0], node[1] ); break;
 801         case 6:  // "Quadrilaterals"
 802           theMesh->AddFace( node[0], node[1], node[2], node[3] ); break;
 803         case 7: // "Hexahedra"
 804           theHelper->AddVolume( node[0], node[3], node[2], node[1],
 805                                 node[4], node[7], node[6], node[5] ); break;
 806         default: continue;
 807         }
 808         if ( nField == 6 )
 809           for ( int iRef = 0; iRef < nbRef; iRef++ )
 810             nodeAssigne[ nodeID[ iRef ]] = 1;
 811       }
 812       break;
 813     }
 814     case 8: { // "End"
 815       EndOfFile = 1;
 816       MESSAGE("End of " << theFile << " file");
 817       break;
 818     }
 819     default: {
 820       MESSAGE("Unknown Token: " << token);
 821     }
 822     }
 823   }
 824   cout << std::endl;
 825
 826   shapeID = theHelper->GetSubShapeID();
 827   for ( int i = 0; i < nbVertices; ++i )
 828     if ( !nodeAssigne[ i+1 ])
 829       theMesh->SetNodeInVolume( HexoticNode[ i+1 ], shapeID );
 830
 831   delete [] HexoticNode;
 832   delete [] nodeAssigne;
 833   return true;
 834 }
 835
 836 //=============================================================================
 837 /*!
 838  * Pass parameters to MG-Hexa
 839  */
 840 //=============================================================================
 841
 842 void HexoticPlugin_Hexotic::SetParameters(const HexoticPlugin_Hypothesis* hyp) {
 843
 844   MESSAGE("HexoticPlugin_Hexotic::SetParameters");
 845   if (hyp) {
 846     _hexesMinLevel = hyp->GetHexesMinLevel();
 847     _hexesMaxLevel = hyp->GetHexesMaxLevel();
 848     _hexesMinSize = hyp->GetMinSize();
 849     _hexesMaxSize = hyp->GetMaxSize();
 850     _hexoticIgnoreRidges = hyp->GetHexoticIgnoreRidges();
 851     _hexoticInvalidElements = hyp->GetHexoticInvalidElements();
 852     _hexoticSharpAngleThreshold = hyp->GetHexoticSharpAngleThreshold();
 853     _hexoticNbProc = hyp->GetHexoticNbProc();
 854     _hexoticWorkingDirectory = hyp->GetHexoticWorkingDirectory();
 855     _hexoticVerbosity = hyp->GetHexoticVerbosity();
 856     _hexoticMaxMemory = hyp->GetHexoticMaxMemory();
 857     _hexoticSdMode = hyp->GetHexoticSdMode();
 858     _textOptions = hyp->GetTextOptions();
 859     _sizeMaps = hyp->GetSizeMaps();
 860     _nbLayers = hyp->GetNbLayers();
 861     _firstLayerSize = hyp->GetFirstLayerSize();
 862     _direction = hyp->GetDirection();
 863     _growth = hyp->GetGrowth();
 864     _facesWithLayers = hyp->GetFacesWithLayers();
 865     _imprintedFaces = hyp->GetImprintedFaces();
 866   }
 867   else {
 868     cout << std::endl;
 869     cout << "WARNING : The MG-Hexa default parameters are taken into account" << std::endl;
 870     cout << "=======" << std::endl;
 871     _hexesMinLevel = hyp->GetDefaultHexesMinLevel();
 872     _hexesMaxLevel = hyp->GetDefaultHexesMaxLevel();
 873     _hexesMinSize = hyp->GetDefaultMinSize();
 874     _hexesMaxSize = hyp->GetDefaultMaxSize();
 875     _hexoticIgnoreRidges = hyp->GetDefaultHexoticIgnoreRidges();
 876     _hexoticInvalidElements = hyp->GetDefaultHexoticInvalidElements();
 877     _hexoticSharpAngleThreshold = hyp->GetDefaultHexoticSharpAngleThreshold();
 878     _hexoticNbProc = hyp->GetDefaultHexoticNbProc();
 879     _hexoticWorkingDirectory = hyp->GetDefaultHexoticWorkingDirectory();
 880     _hexoticVerbosity = hyp->GetDefaultHexoticVerbosity();
 881     _hexoticMaxMemory = hyp->GetDefaultHexoticMaxMemory();
 882     _hexoticSdMode = hyp->GetDefaultHexoticSdMode();
 883     _textOptions = hyp->GetDefaultTextOptions();
 884     _sizeMaps = hyp->GetDefaultHexoticSizeMaps();
 885     _nbLayers = hyp->GetDefaultNbLayers();
 886     _firstLayerSize = hyp->GetDefaultFirstLayerSize();
 887     _direction = hyp->GetDefaultDirection();
 888     _growth = hyp->GetDefaultGrowth();
 889     _facesWithLayers = hyp->GetDefaultFacesWithLayers();
 890     _imprintedFaces = hyp->GetDefaultImprintedFaces();
 891   }
 892 }
 893
 894 //=======================================================================
 895 //function : getTmpDir
 896 //purpose  :
 897 //=======================================================================
 898
 899 static TCollection_AsciiString getTmpDir()
 900 {
 901   TCollection_AsciiString aTmpDir;
 902
 903   char *Tmp_dir = getenv("SALOME_TMP_DIR");
 904 #ifdef WIN32
 905   if(Tmp_dir == NULL) {
 906     Tmp_dir = getenv("TEMP");
 907     if( Tmp_dir== NULL )
 908       Tmp_dir = getenv("TMP");
 909   }
 910 #endif
 911
 912   if(Tmp_dir != NULL) {
 913     aTmpDir = Tmp_dir;
 914 #ifdef WIN32
 915     if(aTmpDir.Value(aTmpDir.Length()) != '\\') aTmpDir+='\\';
 916 #else
 917     if(aTmpDir.Value(aTmpDir.Length()) != '/') aTmpDir+='/';
 918 #endif
 919   }
 920   else {
 921 #ifdef WIN32
 922     aTmpDir = TCollection_AsciiString("C:\\");
 923 #else
 924     aTmpDir = TCollection_AsciiString("/tmp/");
 925 #endif
 926   }
 927   return aTmpDir;
 928 }
 929
 930 //=======================================================================
 931 //function : getSuffix
 932 //purpose  : Returns a suffix that will be unique for the current process
 933 //=======================================================================
 934
 935 static TCollection_AsciiString getSuffix()
 936 {
 937   TCollection_AsciiString aSuffix = "";
 938   aSuffix += "_";
 939 #ifndef WIN32
 940   aSuffix += getenv("USER");
 941 #else
 942   aSuffix += getenv("USERNAME");
 943 #endif
 944   aSuffix += "_";
 945   aSuffix += Kernel_Utils::GetHostname().c_str();
 946   aSuffix += "_";
 947 #ifndef WIN32
 948   aSuffix += getpid();
 949 #else
 950   aSuffix += _getpid();
 951 #endif
 952
 953   return aSuffix;
 954 }
 955
 956 //================================================================================
 957 /*!
 958  * \brief Returns a command to run MG-Hexa mesher
 959  */
 960 //================================================================================
 961
 962 std::string HexoticPlugin_Hexotic::getHexoticCommand(const TCollection_AsciiString& Hexotic_In,
 963                                                      const TCollection_AsciiString& Hexotic_Out,
 964                                                      const TCollection_AsciiString& Hexotic_SizeMap_Prefix) const
 965 {
 966   cout << std::endl;
 967   cout << "MG-Hexa execution..." << std::endl;
 968   cout << _name << " parameters :" << std::endl;
 969   cout << "    " << _name << " Verbosity = " << _hexoticVerbosity << std::endl;
 970   cout << "    " << _name << " Max Memory = " << _hexoticMaxMemory << std::endl;
 971   cout << "    " << _name << " Segments Min Level = " << _hexesMinLevel << std::endl;
 972   cout << "    " << _name << " Segments Max Level = " << _hexesMaxLevel << std::endl;
 973   cout << "    " << _name << " Segments Min Size = " << _hexesMinSize << std::endl;
 974   cout << "    " << _name << " Segments Max Size = " << _hexesMaxSize << std::endl;
 975   cout << "    " << "MG-Hexa can ignore ridges : " << (_hexoticIgnoreRidges ? "yes":"no") << std::endl;
 976   cout << "    " << "MG-Hexa authorize invalide elements : " << ( _hexoticInvalidElements ? "yes":"no") << std::endl;
 977   cout << "    " << _name << " Sharp angle threshold = " << _hexoticSharpAngleThreshold << " degrees" << std::endl;
 978   cout << "    " << _name << " Number of threads = " << _hexoticNbProc << std::endl;
 979   cout << "    " << _name << " Working directory = \"" << _hexoticWorkingDirectory << "\"" << std::endl;
 980   cout << "    " << _name << " Sub. Dom mode = " << _hexoticSdMode << std::endl;
 981   cout << "    " << _name << " Text options = \"" << _textOptions << "\"" << std::endl;
 982   cout << "    " << _name << " Number of layers = " << _nbLayers << std::endl;
 983   cout << "    " << _name << " Size of the first layer  = " << _firstLayerSize << std::endl;
 984   cout << "    " << _name << " Direction of the layers = " << ( _direction ? "Inward" : "Outward" ) << std::endl;
 985   cout << "    " << _name << " Growth = " << _growth << std::endl;
 986   if (!_facesWithLayers.empty()) {
 987     cout << "    " << _name << " Faces with layers = ";
 988     for (int i = 0; i < _facesWithLayers.size(); i++)
 989     {
 990       cout << _facesWithLayers.at(i);
 991       if ((i + 1) != _facesWithLayers.size())
 992         cout << ", ";
 993     }
 994     cout << std::endl;
 995   }
 996   if (!_imprintedFaces.empty()) {
 997     cout << "    " << _name << " Imprinted faces = ";
 998     for (int i = 0; i < _imprintedFaces.size(); i++)
 999     {
1000       cout << _imprintedFaces.at(i);
1001       if ((i + 1) != _imprintedFaces.size())
1002         cout << ", ";
1003     }
1004     cout << std::endl;
1005   }
1006
1007   TCollection_AsciiString run_Hexotic( "mg-hexa.exe" );
1008
1009   TCollection_AsciiString minl = " --min_level ", maxl = " --max_level ", angle = " --ridge_angle ";
1010   TCollection_AsciiString mins = " --min_size ", maxs = " --max_size ";
1011   TCollection_AsciiString in   = " --in ",   out  = " --out ";
1012   TCollection_AsciiString sizeMap = " --read_sizemap ";
1013   TCollection_AsciiString ignoreRidges = " --compute_ridges no ", invalideElements = " --allow_invalid_elements yes ";
1014   TCollection_AsciiString subdom = " --components ";
1015 #ifndef WIN32
1016   TCollection_AsciiString proc = " --max_number_of_threads ";
1017 #endif
1018   TCollection_AsciiString verb = " --verbose ";
1019   TCollection_AsciiString maxmem = " --max_memory ";
1020
1021   TCollection_AsciiString comNbLayers = " --number_of_boundary_layers ";
1022   TCollection_AsciiString comFirstLayerSize = " --height_of_the_first_layer ";
1023   TCollection_AsciiString comDirection = " --boundary_layers_subdomain_direction ";
1024   TCollection_AsciiString comGrowth = " --boundary_layers_geometric_progression ";
1025   TCollection_AsciiString comFacesWithLayers = " --boundary_layers_surface_ids ";
1026   TCollection_AsciiString comImptintedFaces = " --imprinted_surface_ids ";
1027
1028   TCollection_AsciiString minLevel, maxLevel, minSize, maxSize, sharpAngle, mode, nbproc, verbosity, maxMemory,
1029                           textOptions, nbLayers, firstLayerSize, direction, growth, facesWithLayers, imprintedFaces;
1030   minLevel = _hexesMinLevel;
1031   maxLevel = _hexesMaxLevel;
1032   minSize = _hexesMinSize;
1033   maxSize = _hexesMaxSize;
1034   sharpAngle = _hexoticSharpAngleThreshold;
1035   // Mode translation for mg-tetra 1.1
1036   switch ( _hexoticSdMode )
1037   {
1038     case 1:
1039       mode = "outside_skin_only";
1040       break;
1041     case 2:
1042       mode = "outside_components";
1043       break;
1044     case 3:
1045       mode = "all";
1046       break;
1047     case 4:
1048       mode = "all --manifold_geometry no";
1049       break;
1050   }
1051   nbproc = _hexoticNbProc;
1052   verbosity = _hexoticVerbosity;
1053   maxMemory = _hexoticMaxMemory;
1054   textOptions = (" " + _textOptions + " ").c_str();
1055   nbLayers = _nbLayers;
1056   firstLayerSize = _firstLayerSize;
1057   direction = _direction ? "1" : "-1";
1058   growth = _growth;
1059   for (int i = 0; i < _facesWithLayers.size(); i++)
1060   {
1061     facesWithLayers += _facesWithLayers[i];
1062     if ((i + 1) != _facesWithLayers.size())
1063       facesWithLayers += ",";
1064   }
1065   for (int i = 0; i < _imprintedFaces.size(); i++)
1066   {
1067     imprintedFaces += _imprintedFaces[i];
1068     if ((i + 1) != _imprintedFaces.size())
1069       imprintedFaces += ",";
1070   }
1071
1072   if (_hexoticIgnoreRidges)
1073     run_Hexotic +=  ignoreRidges;
1074
1075   if (_hexoticInvalidElements)
1076     run_Hexotic +=  invalideElements;
1077
1078   if (_hexesMinSize > 0)
1079     run_Hexotic +=  mins + minSize;
1080
1081   if (_hexesMaxSize > 0)
1082     run_Hexotic +=  maxs + maxSize;
1083
1084   if (_hexesMinLevel > 0)
1085     run_Hexotic +=  minl + minLevel;
1086
1087   if (_hexesMaxLevel > 0)
1088     run_Hexotic +=  maxl + maxLevel;
1089
1090   if (_hexoticSharpAngleThreshold > 0)
1091     run_Hexotic +=  angle + sharpAngle;
1092
1093   if (_sizeMaps.begin() != _sizeMaps.end())
1094     run_Hexotic += sizeMap + Hexotic_SizeMap_Prefix;
1095
1096   if (_nbLayers       > 0 &&
1097       _firstLayerSize > 0 &&
1098       _growth         > 0 &&
1099       !_facesWithLayers.empty())
1100   {
1101     run_Hexotic += comNbLayers + nbLayers;
1102     run_Hexotic += comFirstLayerSize + firstLayerSize;
1103     run_Hexotic += comDirection + direction;
1104     run_Hexotic += comGrowth + growth;
1105     run_Hexotic += comFacesWithLayers + facesWithLayers;
1106     if (!_imprintedFaces.empty())
1107       run_Hexotic += comImptintedFaces + imprintedFaces;
1108   }
1109   run_Hexotic += in + Hexotic_In + out + Hexotic_Out;
1110   run_Hexotic += subdom + mode;
1111 #ifndef WIN32
1112   run_Hexotic += proc + nbproc;
1113 #endif
1114   run_Hexotic += verb + verbosity;
1115   run_Hexotic += maxmem + maxMemory;
1116
1117   if (!_textOptions.empty())
1118     run_Hexotic += textOptions;
1119
1120   return run_Hexotic.ToCString();
1121 }
1122
1123 // TODO : this is a duplication of some code found in BLSURFPlugin_BLSURF find a proper
1124 // way to share it
1125 TopoDS_Shape HexoticPlugin_Hexotic::entryToShape(std::string entry)
1126 {
1127   MESSAGE("HexoticPlugin_Hexotic::entryToShape "<<entry );
1128   GEOM::GEOM_Object_var aGeomObj;
1129   TopoDS_Shape S = TopoDS_Shape();
1130   SALOMEDS::SObject_var aSObj = myStudy->FindObjectID( entry.c_str() );
1131   if (!aSObj->_is_nil()) {
1132     CORBA::Object_var obj = aSObj->GetObject();
1133     aGeomObj = GEOM::GEOM_Object::_narrow(obj);
1134     aSObj->UnRegister();
1135   }
1136   if ( !aGeomObj->_is_nil() )
1137     S = smeshGen_i->GeomObjectToShape( aGeomObj.in() );
1138   return S;
1139 }
1140
1141 //================================================================================
1142 /*!
1143  * \brief Produces a .mesh file with the size maps informations to give to Hexotic
1144  */
1145 //================================================================================
1146 std::vector<std::string> HexoticPlugin_Hexotic::writeSizeMapFile( std::string sizeMapPrefix )
1147 {
1148   HexoticPlugin_Hypothesis::THexoticSizeMaps::iterator it ;
1149
1150   // The GMF driver will be used to write the size map file
1151   DriverGMF_Write aWriter;
1152   aWriter.SetSizeMapPrefix( sizeMapPrefix );
1153
1154   std::vector<Control_Pnt> points;
1155   // Iterate on the size maps
1156   for (it=_sizeMaps.begin(); it!=_sizeMaps.end(); it++)
1157   {
1158     // Step 1 : Get the GEOM object entry and the size
1159     // from the _sizeMaps infos
1160     std::string anEntry = it->first;
1161     double aLocalSize = it->second;
1162     TopoDS_Shape aShape = entryToShape( anEntry );
1163
1164     // Step 2 : Create the points
1165     createControlPoints( aShape, aLocalSize, points );
1166   }
1167   // Write the .mesh size map file
1168   aWriter.PerformSizeMap(points);
1169   return aWriter.GetSizeMapFiles();
1170 }
1171
1172 //================================================================================
1173 /*!
1174  * \brief Fills a vector of points from which a size map input file can be written
1175  */
1176 //================================================================================
1177 void HexoticPlugin_Hexotic::createControlPoints( const TopoDS_Shape& aShape,
1178                                                  const double& theSize,
1179                                                  std::vector<Control_Pnt>& thePoints )
1180 {
1181   if ( aShape.ShapeType() == TopAbs_VERTEX )
1182   {
1183     gp_Pnt aPnt = BRep_Tool::Pnt( TopoDS::Vertex(aShape) );
1184     Control_Pnt aControl_Pnt( aPnt, theSize );
1185     thePoints.push_back( aControl_Pnt );
1186   }
1187   if ( aShape.ShapeType() == TopAbs_EDGE )
1188   {
1189     createPointsSampleFromEdge( aShape, theSize, thePoints );
1190   }
1191   else if ( aShape.ShapeType() == TopAbs_WIRE )
1192   {
1193     TopExp_Explorer Ex;
1194     for (Ex.Init(aShape,TopAbs_EDGE); Ex.More(); Ex.Next())
1195     {
1196       createPointsSampleFromEdge( Ex.Current(), theSize, thePoints );
1197     }
1198   }
1199   else if ( aShape.ShapeType() ==  TopAbs_FACE )
1200   {
1201     createPointsSampleFromFace( aShape, theSize, thePoints );
1202   }
1203   else if ( aShape.ShapeType() ==  TopAbs_SOLID )
1204   {
1205     createPointsSampleFromSolid( aShape, theSize, thePoints );
1206   }
1207   else if ( aShape.ShapeType() == TopAbs_COMPOUND )
1208   {
1209     TopoDS_Iterator it( aShape );
1210     for(; it.More(); it.Next())
1211     {
1212       createControlPoints( it.Value(), theSize, thePoints );
1213     }
1214   }
1215 }
1216
1217 //================================================================================
1218 /*!
1219  * \brief Fills a vector of points with point samples approximately
1220  * \brief spaced with a given size
1221  */
1222 //================================================================================
1223 void HexoticPlugin_Hexotic::createPointsSampleFromEdge( const TopoDS_Shape& aShape,
1224                                                         const double& theSize,
1225                                                         std::vector<Control_Pnt>& thePoints )
1226 {
1227   double step = theSize;
1228   double first, last;
1229   Handle( Geom_Curve ) aCurve = BRep_Tool::Curve( TopoDS::Edge( aShape ), first, last );
1230   GeomAdaptor_Curve C ( aCurve );
1231   GCPnts_UniformAbscissa DiscretisationAlgo(C, step , first, last, Precision::Confusion());
1232   int nbPoints = DiscretisationAlgo.NbPoints();
1233
1234   for ( int i = 1; i <= nbPoints; i++ )
1235   {
1236     double param = DiscretisationAlgo.Parameter( i );
1237     Control_Pnt aPnt;
1238     aCurve->D0( param, aPnt );
1239     aPnt.SetSize(theSize);
1240     thePoints.push_back( aPnt );
1241   }
1242 }
1243
1244 //================================================================================
1245 /*!
1246  * \brief Fills a vector of points with point samples approximately
1247  * \brief spaced with a given size
1248  */
1249 //================================================================================
1250 void HexoticPlugin_Hexotic::createPointsSampleFromFace( const TopoDS_Shape& aShape,
1251                                                         const double& theSize,
1252                                                         std::vector<Control_Pnt>& thePoints )
1253 {
1254   BRepMesh_IncrementalMesh M(aShape, 0.01, Standard_True);
1255   TopLoc_Location aLocation;
1256   TopoDS_Face aFace = TopoDS::Face(aShape);
1257
1258   // Triangulate the face
1259   Handle(Poly_Triangulation) aTri = BRep_Tool::Triangulation (aFace, aLocation);
1260
1261   // Get the transformation associated to the face location
1262   gp_Trsf aTrsf = aLocation.Transformation();
1263
1264   // Get triangles
1265   int nbTriangles = aTri->NbTriangles();
1266   Poly_Array1OfTriangle triangles(1,nbTriangles);
1267   triangles=aTri->Triangles();
1268
1269   // GetNodes
1270   int nbNodes = aTri->NbNodes();
1271   TColgp_Array1OfPnt nodes(1,nbNodes);
1272   nodes = aTri->Nodes();
1273
1274   // Iterate on triangles and subdivide them
1275   for(int i=1; i<=nbTriangles; i++)
1276   {
1277      Poly_Triangle aTriangle = triangles.Value(i);
1278      gp_Pnt p1 = nodes.Value(aTriangle.Value(1));
1279      gp_Pnt p2 = nodes.Value(aTriangle.Value(2));
1280      gp_Pnt p3 = nodes.Value(aTriangle.Value(3));
1281
1282      p1.Transform(aTrsf);
1283      p2.Transform(aTrsf);
1284      p3.Transform(aTrsf);
1285
1286      subdivideTriangle(p1, p2, p3, theSize, thePoints);
1287   }
1288 }
1289
1290 //================================================================================
1291 /*!
1292  * \brief Fills a vector of points with point samples approximately
1293  * \brief spaced with a given size
1294  */
1295 //================================================================================
1296 void HexoticPlugin_Hexotic::createPointsSampleFromSolid( const TopoDS_Shape& aShape,
1297                                                          const double& theSize,
1298                                                          std::vector<Control_Pnt>& thePoints )
1299 {
1300   // Compute the bounding box
1301   double Xmin, Ymin, Zmin, Xmax, Ymax, Zmax;
1302   Bnd_Box B;
1303   BRepBndLib::Add(aShape, B);
1304   B.Get(Xmin, Ymin, Zmin, Xmax, Ymax, Zmax);
1305
1306   // Create the points
1307   double step = theSize;
1308
1309   for ( double x=Xmin; x-Xmax<Precision::Confusion(); x=x+step )
1310   {
1311     for ( double y=Ymin; y-Ymax<Precision::Confusion(); y=y+step )
1312     {
1313       // Step1 : generate the Zmin -> Zmax line
1314       gp_Pnt startPnt(x, y, Zmin);
1315       gp_Pnt endPnt(x, y, Zmax);
1316       gp_Vec aVec(startPnt, endPnt);
1317       gp_Lin aLine(startPnt, aVec);
1318       double endParam = Zmax - Zmin;
1319
1320       // Step2 : for each face of aShape:
1321       std::set<double> intersections;
1322       std::set<double>::iterator it = intersections.begin();
1323
1324       TopExp_Explorer Ex;
1325       for (Ex.Init(aShape,TopAbs_FACE); Ex.More(); Ex.Next())
1326       {
1327         // check if there is an intersection
1328         IntCurvesFace_Intersector anIntersector(TopoDS::Face(Ex.Current()), Precision::Confusion());
1329         anIntersector.Perform(aLine, 0, endParam);
1330
1331         // get the intersection's parameter and store it
1332         int nbPoints = anIntersector.NbPnt();
1333         for(int i = 0 ; i < nbPoints ; i++ )
1334         {
1335           it = intersections.insert( it, anIntersector.WParameter(i+1) );
1336         }
1337       }
1338       // Step3 : go through the line chunk by chunk
1339       if ( intersections.begin() != intersections.end() )
1340       {
1341         std::set<double>::iterator intersectionsIterator=intersections.begin();
1342         double first = *intersectionsIterator;
1343         intersectionsIterator++;
1344         bool innerPoints = true;
1345         for ( ; intersectionsIterator!=intersections.end() ; intersectionsIterator++ )
1346         {
1347           double second = *intersectionsIterator;
1348           if ( innerPoints )
1349           {
1350             // If the last chunk was outside of the shape or this is the first chunk
1351             // add the points in the range [first, second] to the points vector
1352             double localStep = (second -first) / ceil( (second - first) / step );
1353             for ( double z = Zmin + first; z < Zmin + second; z = z + localStep )
1354             {
1355               thePoints.push_back(Control_Pnt( x, y, z, theSize ));
1356             }
1357             thePoints.push_back(Control_Pnt( x, y, Zmin + second, theSize ));
1358           }
1359           first = second;
1360           innerPoints = !innerPoints;
1361         }
1362       }
1363     }
1364   }
1365 }
1366
1367 //================================================================================
1368 /*!
1369  * \brief Subdivides a triangle until it reaches a certain size (recursive function)
1370  */
1371 //================================================================================
1372 void HexoticPlugin_Hexotic::subdivideTriangle( const gp_Pnt& p1,
1373                                                const gp_Pnt& p2,
1374                                                const gp_Pnt& p3,
1375                                                const double& theSize,
1376                                                std::vector<Control_Pnt>& thePoints)
1377 {
1378   // Size threshold to stop subdividing
1379   // This value ensures that two control points are distant no more than 2*theSize
1380   // as shown below
1381   //
1382   // The greater distance D of the mass center M to each Edge is 1/3 * Median
1383   // and Median < sqrt(3/4) * a  where a is the greater side (by using Apollonius' thorem).
1384   // So D < 1/3 * sqrt(3/4) * a and if a < sqrt(3) * S then D < S/2
1385   // and the distance between two mass centers of two neighbouring triangles
1386   // sharing an edge is < 2 * 1/2 * S = S
1387   // If the traingles share a Vertex and no Edge the distance of the mass centers
1388   // to the Vertices is 2*D < S so the mass centers are distant of less than 2*S
1389
1390   double threshold = sqrt( 3. ) * theSize;
1391
1392   if ( (p1.Distance(p2) > threshold ||
1393         p2.Distance(p3) > threshold ||
1394         p3.Distance(p1) > threshold))
1395   {
1396     std::vector<gp_Pnt> midPoints = computePointsForSplitting(p1, p2, p3);
1397
1398     subdivideTriangle( midPoints[0], midPoints[1], midPoints[2], theSize, thePoints );
1399     subdivideTriangle( midPoints[0], p2, midPoints[1], theSize, thePoints );
1400     subdivideTriangle( midPoints[2], midPoints[1], p3, theSize, thePoints );
1401     subdivideTriangle( p1, midPoints[0], midPoints[2], theSize, thePoints );
1402   }
1403   else
1404   {
1405     double x = (p1.X() + p2.X() + p3.X()) / 3 ;
1406     double y = (p1.Y() + p2.Y() + p3.Y()) / 3 ;
1407     double z = (p1.Z() + p2.Z() + p3.Z()) / 3 ;
1408
1409     Control_Pnt massCenter( x ,y ,z, theSize );
1410     thePoints.push_back( massCenter );
1411   }
1412 }
1413
1414 //================================================================================
1415 /*!
1416  * \brief Returns the appropriate points for splitting a triangle
1417  * \brief the tangency points of the incircle are used in order to have mostly
1418  * \brief well-shaped sub-triangles
1419  */
1420 //================================================================================
1421 std::vector<gp_Pnt> HexoticPlugin_Hexotic::computePointsForSplitting( const gp_Pnt& p1,
1422                                                                       const gp_Pnt& p2,
1423                                                                       const gp_Pnt& p3 )
1424 {
1425   std::vector<gp_Pnt> midPoints;
1426   //Change coordinates
1427   gp_Trsf Trsf_1;            // Identity transformation
1428   gp_Ax3 reference_system(gp::Origin(), gp::DZ(), gp::DX());   // OXY
1429
1430   gp_Vec Vx(p1, p3);
1431   gp_Vec Vaux(p1, p2);
1432   gp_Dir Dx(Vx);
1433   gp_Dir Daux(Vaux);
1434   gp_Dir Dz = Dx.Crossed(Daux);
1435   gp_Ax3 current_system(p1, Dz, Dx);
1436
1437   Trsf_1.SetTransformation( reference_system, current_system );
1438
1439   gp_Pnt A = p1.Transformed(Trsf_1);
1440   gp_Pnt B = p2.Transformed(Trsf_1);
1441   gp_Pnt C = p3.Transformed(Trsf_1);
1442
1443   double a =  B.Distance(C) ;
1444   double b =  A.Distance(C) ;
1445   double c =  B.Distance(A) ;
1446
1447   // Incenter coordinates
1448   // see http://mathworld.wolfram.com/Incenter.html
1449   double Xi = ( b*B.X() + c*C.X() ) / ( a + b + c );
1450   double Yi = ( b*B.Y() ) / ( a + b + c );
1451   gp_Pnt Center(Xi, Yi, 0);
1452
1453   // Calculate the tangency points of the incircle
1454   gp_Pnt T1 = tangencyPoint( A, B, Center);
1455   gp_Pnt T2 = tangencyPoint( B, C, Center);
1456   gp_Pnt T3 = tangencyPoint( C, A, Center);
1457
1458   gp_Pnt p1_2 = T1.Transformed(Trsf_1.Inverted());
1459   gp_Pnt p2_3 = T2.Transformed(Trsf_1.Inverted());
1460   gp_Pnt p3_1 = T3.Transformed(Trsf_1.Inverted());
1461
1462   midPoints.push_back(p1_2);
1463   midPoints.push_back(p2_3);
1464   midPoints.push_back(p3_1);
1465
1466   return midPoints;
1467 }
1468
1469 //================================================================================
1470 /*!
1471  * \brief Computes the tangency points of the circle of center Center with
1472  * \brief the straight line (p1 p2)
1473  */
1474 //================================================================================
1475 gp_Pnt HexoticPlugin_Hexotic::tangencyPoint(const gp_Pnt& p1,
1476                                             const gp_Pnt& p2,
1477                                             const gp_Pnt& Center)
1478 {
1479   double Xt = 0;
1480   double Yt = 0;
1481
1482   // The tangency point is the intersection of the straight line (p1 p2)
1483   // and the straight line (Center T) which is orthogonal to (p1 p2)
1484   if ( fabs(p1.X() - p2.X()) <= Precision::Confusion() )
1485   {
1486     Xt=p1.X();     // T is on (p1 p2)
1487     Yt=Center.Y(); // (Center T) is orthogonal to (p1 p2)
1488   }
1489   else if ( fabs(p1.Y() - p2.Y()) <= Precision::Confusion() )
1490   {
1491     Yt=p1.Y();     // T is on (p1 p2)
1492     Xt=Center.X(); // (Center T) is orthogonal to (p1 p2)
1493   }
1494   else
1495   {
1496     // First straight line coefficients (equation y=a*x+b)
1497     double a = (p2.Y() - p1.Y()) / (p2.X() - p1.X())  ;
1498     double b = p1.Y() - a*p1.X();         // p1 is on this straight line
1499
1500     // Second straight line coefficients (equation y=c*x+d)
1501     double c = -1 / a;                    // The 2 lines are orthogonal
1502     double d = Center.Y() - c*Center.X(); // Center is on this straight line
1503
1504     Xt = (d - b) / (a - c);
1505     Yt = a*Xt + b;
1506   }
1507
1508   return gp_Pnt( Xt, Yt, 0 );
1509 }
1510
1511 //=============================================================================
1512 /*!
1513  * Here we are going to use the MG-Hexa mesher
1514  */
1515 //=============================================================================
1516
1517 bool HexoticPlugin_Hexotic::Compute(SMESH_Mesh&          aMesh,
1518                                     const TopoDS_Shape& aShape)
1519 {
1520   _compute_canceled = false;
1521   bool Ok = true;
1522   SMESHDS_Mesh* meshDS = aMesh.GetMeshDS();
1523   TCollection_AsciiString hexahedraMessage;
1524
1525   if (_iShape == 0 && _nbShape == 0) {
1526     _nbShape = countShape( meshDS, TopAbs_SOLID );  // we count the number of shapes
1527   }
1528
1529   // to prevent from displaying error message after computing,
1530   // SetIsAlwaysComputed( true ) to empty sub-meshes
1531   vector< SMESH_subMesh* > subMeshesAlwaysComp;
1532   for ( int i = 0; i < _nbShape; ++i )
1533     if ( SMESH_subMesh* sm = aMesh.GetSubMeshContaining( aShape ))
1534     {
1535       SMESH_subMeshIteratorPtr smIt = sm->getDependsOnIterator(/*includeSelf=*/true,
1536                                                                /*complexShapeFirst=*/false);
1537       while ( smIt->more() )
1538       {
1539         sm = smIt->next();
1540         if ( !sm->IsMeshComputed() )
1541         {
1542           sm->SetIsAlwaysComputed( true );
1543           subMeshesAlwaysComp.push_back( sm );
1544         }
1545       }
1546     }
1547
1548   _iShape++;
1549
1550   if (_iShape == _nbShape ) {
1551
1552     // create bounding box for each shape of the compound
1553
1554     int iShape = 0;
1555     TopoDS_Shape *tabShape;
1556     double **tabBox;
1557
1558     tabShape = new TopoDS_Shape[_nbShape];
1559     tabBox   = new double*[_nbShape];
1560     for (int i=0; i<_nbShape; i++)
1561       tabBox[i] = new double[6];
1562     double Xmin, Ymin, Zmin, Xmax, Ymax, Zmax;
1563
1564     TopExp_Explorer expBox (meshDS->ShapeToMesh(), TopAbs_SOLID);
1565     for (; expBox.More(); expBox.Next()) {
1566       tabShape[iShape] = expBox.Current();
1567       Bnd_Box BoundingBox;
1568       BRepBndLib::Add(expBox.Current(), BoundingBox);
1569       BoundingBox.Get(Xmin, Ymin, Zmin, Xmax, Ymax, Zmax);
1570       tabBox[iShape][0] = Xmin; tabBox[iShape][1] = Xmax;
1571       tabBox[iShape][2] = Ymin; tabBox[iShape][3] = Ymax;
1572       tabBox[iShape][4] = Zmin; tabBox[iShape][5] = Zmax;
1573       iShape++;
1574     }
1575
1576     SetParameters(_hypothesis);
1577
1578 //     TCollection_AsciiString aTmpDir = getTmpDir();
1579     TCollection_AsciiString aTmpDir = _hexoticWorkingDirectory.c_str();
1580 #ifdef WIN32
1581     if ( aTmpDir.Value(aTmpDir.Length()) != '\\' ) aTmpDir += '\\';
1582 #else
1583     if ( aTmpDir.Value(aTmpDir.Length()) != '/' ) aTmpDir += '/';
1584 #endif
1585     TCollection_AsciiString Hexotic_In(""), Hexotic_Out, Hexotic_SizeMap_Prefix;
1586     TCollection_AsciiString modeFile_In( "chmod 666 " ), modeFile_Out( "chmod 666 " );    TCollection_AsciiString aLogFileName = aTmpDir + "Hexotic"+getSuffix()+".log";    // log
1587
1588     std::map <int,int> aSmdsToHexoticIdMap;
1589     std::map <int,const SMDS_MeshNode*> aHexoticIdToNodeMap;
1590
1591     Hexotic_Out = aTmpDir + "Hexotic"+getSuffix()+"_Out.mesh";
1592 #ifdef WITH_BLSURFPLUGIN
1593     bool defaultInputFile = true;
1594     if (_blsurfHypo && !_blsurfHypo->GetQuadAllowed()) {
1595       Hexotic_In = _blsurfHypo->GetGMFFile().c_str();
1596       if ( !Hexotic_In.IsEmpty() &&
1597            SMESH_File( _blsurfHypo->GetGMFFile() ).exists() )
1598         defaultInputFile = false;
1599     }
1600     if (defaultInputFile) {
1601 #endif
1602       Hexotic_In  = aTmpDir + "Hexotic"+getSuffix()+"_In.mesh";
1603       removeHexoticFiles(Hexotic_In, Hexotic_Out);
1604       splitQuads(aMesh); // quadrangles are no longer acceptable as input
1605       cout << std::endl;
1606       cout << "Creating MG-Hexa input mesh file : " << Hexotic_In << std::endl;
1607       aMesh.ExportGMF(Hexotic_In.ToCString(), meshDS, true);
1608 #ifdef WITH_BLSURFPLUGIN
1609     }
1610     else {
1611       removeFile( Hexotic_Out );
1612     }
1613 #endif
1614
1615     Hexotic_SizeMap_Prefix = aTmpDir + "Hexotic_SizeMap" + getSuffix();
1616     std::vector<std::string> sizeMapFiles = writeSizeMapFile( Hexotic_SizeMap_Prefix.ToCString() );
1617
1618     std::string run_Hexotic = getHexoticCommand(Hexotic_In, Hexotic_Out, Hexotic_SizeMap_Prefix);
1619     run_Hexotic += std::string(" 1> ") + aLogFileName.ToCString();  // dump into file
1620
1621     cout << std::endl;
1622     cout << "MG-Hexa command : " << run_Hexotic << std::endl;
1623
1624 #ifndef WIN32
1625     modeFile_In += Hexotic_In;
1626     system( modeFile_In.ToCString() );
1627 #endif
1628     aSmdsToHexoticIdMap.clear();
1629     aHexoticIdToNodeMap.clear();
1630
1631     MESSAGE("HexoticPlugin_Hexotic::Compute");
1632
1633     int status = system( run_Hexotic.data() );
1634
1635     // --------------
1636     // read a result
1637     // --------------
1638
1639     std::ifstream fileRes( Hexotic_Out.ToCString() );
1640 #ifndef WIN32
1641     modeFile_Out += Hexotic_Out;
1642     system( modeFile_Out.ToCString() );
1643 #endif
1644     if ( ! fileRes.fail() ) {
1645       Ok = readResult( Hexotic_Out.ToCString(),
1646                        this,
1647                        meshDS, _nbShape, tabShape, tabBox );
1648       if(Ok) {
1649 /*********************
1650 // TODO: Detect and remove elements in holes in case of sd mode = 4
1651       // Remove previous nodes and elements
1652       SMDS_ElemIteratorPtr itElement = meshDS->elementsIterator();
1653       SMDS_NodeIteratorPtr itNode = meshDS->nodesIterator();
1654
1655       while ( itElement->more() )
1656         meshDS->RemoveElement( itElement->next() );
1657       while ( itNode->more() )
1658         meshDS->RemoveNode( itNode->next() );
1659
1660       SMESH_ComputeErrorPtr myError = aMesh.GMFToMesh(Hexotic_Out.ToCString());
1661       if (myError)
1662 */
1663         hexahedraMessage = "success";
1664         #ifndef _DEBUG_
1665         removeFile(Hexotic_Out);
1666         removeFile(Hexotic_In);
1667         removeFile(aLogFileName);
1668         for( int i=0; i<sizeMapFiles.size(); i++)
1669         {
1670           removeFile( TCollection_AsciiString( sizeMapFiles[i].c_str() ) );
1671         }
1672         #endif
1673       }
1674       else {
1675         hexahedraMessage = "failed";
1676       }
1677     }
1678     else {
1679       hexahedraMessage = "failed";
1680       cout << "Problem with MG-Hexa output file " << Hexotic_Out.ToCString() << std::endl;
1681       Ok = false;
1682       // analyse log file
1683       SMESH_File logFile( aLogFileName.ToCString() );
1684       if ( !logFile.eof() )
1685       {
1686         char msgLic[] = " Dlim ";
1687         const char* fileBeg = logFile.getPos(), *fileEnd = fileBeg + logFile.size();
1688         if ( std::search( fileBeg, fileEnd, msgLic, msgLic+strlen(msgLic)) != fileEnd )
1689           error("Licence problems.");
1690       }
1691 #ifndef WIN32
1692       if ( status > 0 && WEXITSTATUS(status) == 127 )
1693         error("mg-hexa.exe: command not found");
1694 #else
1695       int err = errno;
1696       if ( status == 0 && err == ENOENT ) {
1697         error("mg-hexa.exe: command not found");
1698       }
1699 #endif
1700     }
1701     cout << "Hexahedra meshing " << hexahedraMessage << std::endl;
1702     cout << std::endl;
1703
1704     // restore "always computed" flag of sub-meshes (0022127)
1705     for  ( size_t iSM = 0; iSM < subMeshesAlwaysComp.size(); ++iSM )
1706       subMeshesAlwaysComp[ iSM ]->SetIsAlwaysComputed( false );
1707
1708     delete [] tabShape;
1709     for (int i=0; i<_nbShape; i++)
1710       delete [] tabBox[i];
1711     delete [] tabBox;
1712     _nbShape = 0;
1713     _iShape  = 0;
1714   }
1715   if(_compute_canceled)
1716     return error(SMESH_Comment("interruption initiated by user"));
1717   return Ok;
1718 }
1719
1720 //=============================================================================
1721 /*!
1722  * \brief Computes mesh without geometry
1723  *  \param aMesh - the mesh
1724  *  \param aHelper - helper that must be used for adding elements to \aaMesh
1725  *  \retval bool - is a success
1726  *
1727  * The method is called if ( !aMesh->HasShapeToMesh() )
1728  */
1729 //=============================================================================
1730
1731 bool HexoticPlugin_Hexotic::Compute(SMESH_Mesh & aMesh, SMESH_MesherHelper* aHelper)
1732 {
1733   _compute_canceled = false;
1734 /*
1735   SMESH_ComputeErrorPtr myError = SMESH_ComputeError::New();
1736 */
1737   bool Ok = true;
1738   TCollection_AsciiString hexahedraMessage;
1739
1740   SetParameters(_hypothesis);
1741
1742   TCollection_AsciiString aTmpDir = _hexoticWorkingDirectory.c_str();//getTmpDir();
1743   TCollection_AsciiString Hexotic_In, Hexotic_Out, Hexotic_SizeMap_Prefix;
1744   TCollection_AsciiString modeFile_In( "chmod 666 " ), modeFile_Out( "chmod 666 " );
1745   TCollection_AsciiString aLogFileName = aTmpDir + "Hexotic"+getSuffix()+".log";    // log
1746
1747   std::map <int,int> aSmdsToHexoticIdMap;
1748   std::map <int,const SMDS_MeshNode*> aHexoticIdToNodeMap;
1749
1750   Hexotic_In  = aTmpDir + "Hexotic"+getSuffix()+"_In.mesh";
1751   Hexotic_Out = aTmpDir + "Hexotic"+getSuffix()+"_Out.mesh";
1752   Hexotic_SizeMap_Prefix = aTmpDir + "Hexotic_SizeMap";
1753
1754
1755   std::vector<std::string> sizeMapFiles = writeSizeMapFile( Hexotic_SizeMap_Prefix.ToCString() );
1756
1757   std::string run_Hexotic = getHexoticCommand(Hexotic_In, Hexotic_Out, Hexotic_SizeMap_Prefix);
1758   run_Hexotic += std::string(" 1> ") + aLogFileName.ToCString();  // dump into file
1759
1760   removeHexoticFiles(Hexotic_In, Hexotic_Out);
1761
1762   splitQuads(aMesh); // quadrangles are no longer acceptable as input
1763
1764   cout << std::endl;
1765   cout << "Creating MG-Hexa input mesh file : " << Hexotic_In << std::endl;
1766   aMesh.ExportGMF(Hexotic_In.ToCString(), aHelper->GetMeshDS());
1767 #ifndef WIN32
1768   modeFile_In += Hexotic_In;
1769   system( modeFile_In.ToCString() );
1770 #endif
1771   aSmdsToHexoticIdMap.clear();
1772   aHexoticIdToNodeMap.clear();
1773
1774   MESSAGE("HexoticPlugin_Hexotic::Compute");
1775
1776   cout << std::endl;
1777   cout << "MG-Hexa command : " << run_Hexotic << std::endl;
1778   system( run_Hexotic.data() );
1779
1780   // --------------
1781   // read a result
1782   // --------------
1783
1784   std::ifstream fileRes( Hexotic_Out.ToCString() );
1785   modeFile_Out += Hexotic_Out;
1786   system( modeFile_Out.ToCString() );
1787   if ( ! fileRes.fail() ) {
1788     Ok = readResult( Hexotic_Out.ToCString(),
1789                      this,
1790                      aHelper );
1791     if(Ok)
1792 /*
1793     // Remove previous nodes and elements
1794     SMDS_ElemIteratorPtr itElement = aHelper->GetMeshDS()->elementsIterator();
1795     SMDS_NodeIteratorPtr itNode = aHelper->GetMeshDS()->nodesIterator();
1796
1797     while ( itElement->more() )
1798       aHelper->GetMeshDS()->RemoveElement( itElement->next() );
1799     while ( itNode->more() )
1800       aHelper->GetMeshDS()->RemoveNode( itNode->next() );
1801
1802     // Import GMF mesh
1803     myError = aMesh.GMFToMesh(Hexotic_Out.ToCString());
1804
1805     itElement = aHelper->GetMeshDS()->elementsIterator();
1806     itNode = aHelper->GetMeshDS()->nodesIterator();
1807
1808     // Assign nodes and elements to the pseudo shape
1809     while ( itNode->more() )
1810       aHelper->GetMeshDS()->SetNodeInVolume(itNode->next(), 1);
1811     while ( itElement->more() )
1812       aHelper->GetMeshDS()->SetMeshElementOnShape(itElement->next(), 1);
1813
1814     if(myError->IsOK())
1815 */
1816       hexahedraMessage = "success";
1817     else
1818       hexahedraMessage = "failed";
1819   }
1820   else {
1821 /*
1822     myError->myName = COMPERR_EXCEPTION;
1823 */
1824     hexahedraMessage = "failed";
1825     cout << "Problem with MG-Hexa output file " << Hexotic_Out << std::endl;
1826     // analyse log file
1827     SMESH_File logFile( aLogFileName.ToCString() );
1828     if ( !logFile.eof() )
1829     {
1830       char msgLic[] = " Dlim ";
1831       const char* fileBeg = logFile.getPos(), *fileEnd = fileBeg + logFile.size();
1832       if ( std::search( fileBeg, fileEnd, msgLic, msgLic+strlen(msgLic)) != fileEnd )
1833         return error("Licence problems.");
1834     }
1835     return error(SMESH_Comment("Problem with MG-Hexa output file ")<<Hexotic_Out);
1836   }
1837   cout << "Hexahedra meshing " << hexahedraMessage << std::endl;
1838   cout << std::endl;
1839
1840   if(_compute_canceled)
1841     return error(SMESH_Comment("interruption initiated by user"));
1842   removeFile(Hexotic_Out);
1843   removeFile(Hexotic_In);
1844   removeFile(aLogFileName);
1845   for( int i=0; i<sizeMapFiles.size(); i++)
1846   {
1847     removeFile( TCollection_AsciiString(sizeMapFiles[i].c_str()) );
1848   }
1849   return Ok;
1850 /*
1851   return myError->IsOK();
1852 */
1853 }
1854
1855 //=============================================================================
1856 /*!
1857  *
1858  */
1859 //=============================================================================
1860
1861 bool HexoticPlugin_Hexotic::Evaluate(SMESH_Mesh& aMesh,
1862                                      const TopoDS_Shape& aShape,
1863                                      MapShapeNbElems& aResMap)
1864 {
1865   std::vector<int> aResVec(SMDSEntity_Last);
1866   for(int i=SMDSEntity_Node; i<SMDSEntity_Last; i++) aResVec[i] = 0;
1867   SMESH_subMesh * sm = aMesh.GetSubMesh(aShape);
1868   aResMap.insert(std::make_pair(sm,aResVec));
1869
1870   SMESH_ComputeErrorPtr& smError = sm->GetComputeError();
1871   smError.reset( new SMESH_ComputeError(COMPERR_ALGO_FAILED,"Evaluation is not implemented",this));
1872
1873   return true;
1874 }
1875
1876 void HexoticPlugin_Hexotic::CancelCompute()
1877 {
1878   _compute_canceled = true;
1879 #ifdef WIN32
1880 #else
1881   TCollection_AsciiString aTmpDir = _hexoticWorkingDirectory.c_str(); //getTmpDir();
1882   TCollection_AsciiString Hexotic_In = aTmpDir + "Hexotic_In.mesh";
1883   TCollection_AsciiString cmd = TCollection_AsciiString("ps ux | grep ") + Hexotic_In;
1884   cmd += TCollection_AsciiString(" | grep -v grep | awk '{print $2}' | xargs kill -9 > /dev/null 2>&1");
1885   system( cmd.ToCString() );
1886 #endif
1887 }