bos #24596 [CEA] New MeshGems license

Allow EDF URL style

Debug under Windows + some minor corrections.

memory leaks

same fix as in SignCAD()

bos #24596 [CEA] New MeshGems license

  Care of python plugins

typo

fix new license in MGCleaner

src/DriverGMF/DriverGMF_Read.cxx

@@ -537,3 +537,37 @@ Driver_Mesh::Status DriverGMF_Read::storeBadNodeIds(const char* gmfKwd, int elem
   }
   return DRS_OK;
 }
+
+//================================================================================
+/*!
+ * \brief Return number of mesh entities in a file
+ */
+//================================================================================
+
+bool DriverGMF_Read::GetMeshInfo(smIdType & nbNodes,
+                                 smIdType & nbEdges,
+                                 smIdType & nbFaces,
+                                 smIdType & nbVols)
+{
+  nbNodes = nbEdges = nbFaces = nbVols = 0;
+
+  Kernel_Utils::Localizer loc;
+
+  int dim, version;
+  int meshID = GmfOpenMesh( myFile.c_str(), GmfRead, &version, &dim );
+  if ( !meshID )
+    return false;
+
+  DriverGMF::MeshCloser aMeshCloser( meshID ); // An object closing GMF mesh at destruction
+
+  nbNodes =   GmfStatKwd(meshID, GmfVertices       );
+  nbEdges =   GmfStatKwd(meshID, GmfEdges          );
+  nbFaces = ( GmfStatKwd(meshID, GmfTriangles      ) +
+              GmfStatKwd(meshID, GmfQuadrilaterals ));
+  nbVols  = ( GmfStatKwd(meshID, GmfTetrahedra     ) +
+              GmfStatKwd(meshID, GmfPyramids       ) +
+              GmfStatKwd(meshID, GmfHexahedra      ) +
+              GmfStatKwd(meshID, GmfPrisms         ));
+
+  return true;
+}

src/DriverGMF/DriverGMF_Read.hxx

@@ -57,6 +57,11 @@ public:
 
   virtual Status Perform();
 
+  bool GetMeshInfo(smIdType & nbVertex,
+                   smIdType & nbEdge,
+                   smIdType & nbFace,
+                   smIdType & nbVol);
+
  private:
 
   Status storeBadNodeIds(const char* gmfKwd, int elemNb, int nb, ...);

src/SMESH/MG_ADAPT.cxx

@@ -19,8 +19,11 @@
 
 #include "MG_ADAPT.hxx"
 
-#include "SMESH_File.hxx"
+#include <DriverGMF_Read.hxx>
-#include "SMESH_Comment.hxx"
+#include <SMESH_Comment.hxx>
+#include <SMESH_File.hxx>
+#include <SMESH_MGLicenseKeyGen.hxx>
+#include <SMESH_TypeDefs.hxx>
 
 #include <MEDFileData.hxx>
 #include <MEDFileField.hxx>
@@ -1014,8 +1017,26 @@ std::string MgAdapt::getCommandToRun()
   {
     cmd+= " --verbose "+ ToComment(verbosityLevel);
   }
-    //~}
+  // get license key
-//~cmd+= " >"
+  {
+    smIdType nbVertex, nbEdge, nbFace, nbVol;
+    DriverGMF_Read gmfReader;
+    gmfReader.SetFile( meshIn );
+    gmfReader.GetMeshInfo( nbVertex, nbEdge, nbFace, nbVol );
+
+    std::string errorTxt;
+    std::string key = SMESHUtils_MGLicenseKeyGen::GetKey( meshIn,
+                                                          FromSmIdType<int>( nbVertex ),
+                                                          FromSmIdType<int>( nbEdge ),
+                                                          FromSmIdType<int>( nbFace ),
+                                                          FromSmIdType<int>( nbVol ),
+                                                          errorTxt );
+    if ( key.empty() )
+      return ToComment( "Problem with library SalomeMeshGemsKeyGenerator: " + errorTxt );
+
+    cmd += " --key " + key;
+  }
+
 #ifdef WIN32
   cmd += " < NUL";
 #endif

src/SMESHUtils/CMakeLists.txt

@@ -61,6 +61,7 @@ SET(SMESHUtils_HEADERS
   SMESH_ControlPnt.hxx
   SMESH_Delaunay.hxx
   SMESH_Indexer.hxx
+  SMESH_MGLicenseKeyGen.hxx
   )
 
 # --- sources ---
@@ -84,6 +85,7 @@ SET(SMESHUtils_SOURCES
   SMESH_Offset.cxx
   SMESH_Slot.cxx
   SMESH_PolyLine.cxx
+  SMESH_MGLicenseKeyGen.cxx
   )
 
 # --- rules ---

src/SMESHUtils/SMESH_MGLicenseKeyGen.cxx

@@ -0,0 +1,516 @@
+// Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+// File      : SMESHUtils_MGLicenseKeyGen.cxx
+// Created   : Sat Jul 31 18:54:16 2021
+// Author    : Edward AGAPOV (OCC)
+
+#include "SMESH_MGLicenseKeyGen.hxx"
+
+#include "SMESH_Comment.hxx"
+#include "SMESH_File.hxx"
+#include "SMESH_TryCatch.hxx"
+
+#include <Basics_DirUtils.hxx>
+#include <Basics_Utils.hxx>
+
+#include <regex>
+#include <cstdlib> // getenv, system
+
+#include <boost/filesystem.hpp>
+namespace boofs = boost::filesystem;
+
+#ifdef WIN32
+
+#  include <windows.h>
+#  include <process.h>
+
+#  define LibHandle HMODULE
+#  define LoadLib( name ) LoadLibrary( name )
+#  define GetProc GetProcAddress
+#  define UnLoadLib( handle ) FreeLibrary( handle );
+
+#else // WIN32
+
+#  include <dlfcn.h>
+
+#  define LibHandle void*
+#  define LoadLib( name ) dlopen( name, RTLD_LAZY | RTLD_LOCAL )
+#  define GetProc dlsym
+#  define UnLoadLib( handle ) dlclose( handle );
+
+#endif // WIN32
+
+// to retrieve description of exception caught by SMESH_TRY
+#undef SMESH_CAUGHT
+#define SMESH_CAUGHT error =
+
+
+namespace
+{
+  static LibHandle theLibraryHandle = nullptr; //!< handle of a loaded library
+
+  const char* theEnvVar = "SALOME_MG_KEYGEN_LIB_PATH"; /* var specifies either full file name
+                                                          of libSalomeMeshGemsKeyGenerator or
+                                                          URL to download the library from */
+
+  const char* theTmpEnvVar = "SALOME_TMP_DIR"; // directory to download the library to
+
+  //-----------------------------------------------------------------------------------
+  /*!
+   * \brief Remove library file at destruction in case if it was downloaded from server
+   */
+  //-----------------------------------------------------------------------------------
+
+  struct LibraryFile
+  {
+    std::string _name; // full file name
+    bool        _isURL;
+
+    LibraryFile(): _isURL( false ) {}
+
+    ~LibraryFile()
+    {
+      if ( _isURL )
+      {
+        if ( theLibraryHandle )
+        {
+          UnLoadLib( theLibraryHandle );
+          theLibraryHandle = nullptr;
+        }
+
+        std::string tmpDir; // tmp dir that should not be removed
+        if ( const char* libPath = getenv( theTmpEnvVar ))
+        {
+          tmpDir = libPath;
+          while (( !tmpDir.empty() ) &&
+                 ( tmpDir.back() == '/' || tmpDir.back() == '\\' ))
+            tmpDir.pop_back();
+        }
+
+        while ( SMESH_File( _name ).remove() )
+        {
+          size_t length = _name.size();
+          _name = boofs::path( _name ).parent_path().string(); // goto parent directory
+          if ( _name.size() == length )
+            break; // no more parents
+
+          if ( _name == tmpDir )
+            break; // don't remove tmp dir
+
+          if ( !Kernel_Utils::IsEmptyDir( _name ))
+            break;
+        }
+      }
+    }
+  };
+
+
+  //================================================================================
+  /*!
+   * \brief Retrieve description of the last error
+   *  \param [out] error - return the description
+   *  \return bool - true if the description found
+   */
+  //================================================================================
+
+  bool getLastError( std::string& error )
+  {
+#ifndef WIN32
+
+    if ( const char* text = dlerror() )
+    {
+      error = text;
+      return true;
+    }
+    return false;
+
+#else
+
+    DWORD dw = GetLastError();
+    void* cstr;
+    DWORD msgLen = FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
+                                 NULL,
+                                 dw,
+                                 MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
+                                 (LPTSTR) &cstr,
+                                 0,
+                                 NULL
+                                 );
+    if ( msgLen > 0 ) {
+#  if defined( UNICODE )
+      error = Kernel_Utils::encode_s((wchar_t*)cstr);
+#  else
+      error = (char*)cstr;
+#  endif
+      LocalFree(cstr);
+    }
+
+    return (bool)msgLen;
+
+#endif
+  }
+
+  //================================================================================
+  /*!
+   * \brief Adjust file extension according to the platform
+   */
+  //================================================================================
+
+  bool setExtension( std::string& fileName, std::string& error )
+  {
+    if ( fileName.empty() )
+    {
+      error = "Library file name is empty";
+      return false;
+    }
+#if defined(WIN32)
+    std::string ext = ".dll";
+#elif defined(__APPLE__)
+    std::string ext = ".dylib";
+#else
+    std::string ext = ".so";
+#endif
+
+    fileName = fileName.substr( 0, fileName.find_last_of('.')) + ext;
+    return true;
+  }
+
+  //================================================================================
+  /*!
+   * \brief Check if library file name looks like an URL
+   *  \param [in,out] libraryFile - holds file name and returns result in _isURL member field
+   *  \return bool - true if the file name looks like an URL
+   */
+  //================================================================================
+
+  bool isURL( LibraryFile & libraryFile )
+  {
+    {// round1
+      enum { SCHEME = 2, AUTHORITY = 4, PATH = 5 }; // sub-strings
+      std::regex urlRegex ( R"(^(([^:\/?#]+):)?(//([^\/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?)",
+                            std::regex::extended );
+      std::smatch matchResult;
+
+      libraryFile._isURL = false;
+      if ( std::regex_match( libraryFile._name, matchResult, urlRegex ))
+        libraryFile._isURL = ( !matchResult.str( SCHEME    ).empty() &&
+                              !matchResult.str( AUTHORITY ).empty() &&
+                              !matchResult.str( PATH      ).empty() );
+    }
+    if(libraryFile._isURL)
+      return true;
+    {// round2
+      enum { HOST = 2, PORT = 3, PATH = 4 }; // sub-strings
+      std::regex urlRegex ( R"(^(([^:\/?#]+):)?([^/]+)?(/[^#]*))",
+                            std::regex::extended );
+      std::smatch matchResult;
+
+      libraryFile._isURL = false;
+      if ( std::regex_match( libraryFile._name, matchResult, urlRegex ))
+        libraryFile._isURL = ( !matchResult.str( HOST ).empty() &&
+                              !matchResult.str( PORT ).empty() &&
+                              !matchResult.str( PATH ).empty() );
+    }
+    return libraryFile._isURL;
+  }
+
+  //================================================================================
+  /*!
+   * \brief Download libraryFile._name URL to SALOME_TMP_DIR
+   *  \param [in,out] libraryFile - holds the URL and returns name of a downloaded file
+   *  \param [out] error - return error description
+   *  \return bool - is a success
+   */
+  //================================================================================
+
+  bool downloadLib( LibraryFile& libraryFile, std::string & error )
+  {
+    // check if can write into SALOME_TMP_DIR
+
+    std::string tmpDir = Kernel_Utils::GetTmpDirByEnv( theTmpEnvVar );
+    if ( tmpDir.empty() ||
+         !Kernel_Utils::IsExists( tmpDir ))
+    {
+      error = "Can't download " + libraryFile._name + " as SALOME_TMP_DIR is not correctly set";
+      return false;
+    }
+    if ( !Kernel_Utils::IsWritable( tmpDir ))
+    {
+      error = "Can't download " + libraryFile._name + " as '" + tmpDir + "' is not writable. "
+        "Check SALOME_TMP_DIR environment variable";
+      return false;
+    }
+
+    // Download
+
+    std::string url = libraryFile._name;
+
+#ifdef WIN32
+
+    std::string outFile = tmpDir + "MeshGemsKeyGenerator.dll";
+
+    // use wget (== Invoke-WebRequest) PowerShell command available since Windows 7
+    std::string psCmd = "wget -Uri " + url + " -OutFile " + outFile;
+    std::string   cmd = "powershell.exe " + psCmd;
+
+#else
+
+    std::string outFile = tmpDir + "libMeshGemsKeyGenerator.so";
+
+    std::string cmd = "wget " + url + " -O " + outFile;
+
+#endif
+
+    if ( Kernel_Utils::IsExists( outFile )) // remove existing file
+    {
+      SMESH_File lib( outFile, /*open=*/false );
+      if ( !lib.remove() )
+      {
+        error = lib.error();
+        return false;
+      }
+    }
+
+    system( cmd.c_str() ); // download
+
+    SMESH_File resultFile( outFile, /*open=*/false );
+    bool ok = ( resultFile.exists() && resultFile.size() > 0 );
+
+    if ( ok )
+      libraryFile._name = outFile;
+    else
+      error = "Can't download file " + url;
+
+    return ok;
+  }
+
+  //================================================================================
+  /*!
+   * \brief Load libMeshGemsKeyGenerator.so
+   *  \param [out] error - return error description
+   *  \param [out] libraryFile - return library file name and _isURL flag
+   *  \return bool - is a success
+   */
+  //================================================================================
+
+  bool loadLibrary( std::string& error, LibraryFile& libraryFile )
+  {
+    if ( theLibraryHandle )
+      return true;
+
+    const char* libPath = getenv( theEnvVar );
+    if ( !libPath )
+    {
+      error = SMESH_Comment( "Environment variable ") <<  theEnvVar << " is not set";
+      return false;
+    }
+
+    libraryFile._name = libPath;
+    // if ( !setExtension( libraryFile._name, error )) // is it necessary?
+    //   return false;
+
+    if ( isURL( libraryFile ))
+    {
+      if ( !downloadLib( libraryFile, error ))
+      {
+        // try to fix extension
+        std::string url = libraryFile._name;
+        if ( !setExtension( libraryFile._name, error ))
+          return false;
+        if ( url == libraryFile._name )
+          return false; // extension not changed
+
+        if ( !downloadLib( libraryFile, error ))
+          return false;
+      }
+    }
+
+#if defined( WIN32 ) && defined( UNICODE )
+    std::wstring encodePath = Kernel_Utils::utf8_decode_s( libraryFile._name );
+    const wchar_t*     path = encodePath.c_str();
+#else
+    const char*        path = libraryFile._name.c_str();
+#endif
+
+    theLibraryHandle = LoadLib( path );
+    if ( !theLibraryHandle )
+    {
+      if ( ! getLastError( error ))
+        error = "Can't load library '" + libraryFile._name + "'";
+    }
+
+    return theLibraryHandle;
+  }
+
+} // anonymous namespace
+
+
+namespace SMESHUtils_MGLicenseKeyGen // API implementation
+{
+  //================================================================================
+  /*!
+   * \brief Sign a CAD
+   *  \param [in] meshgems_cad - pointer to a MG CAD object (meshgems_cad_t)
+   *  \param [out] error - return error description
+   *  \return bool - is a success
+   */
+  //================================================================================
+
+  bool SignCAD( void* meshgems_cad, std::string& error )
+  {
+    LibraryFile libraryFile;
+    if ( !loadLibrary( error, libraryFile ))
+      return false;
+
+    bool ok = false;
+    typedef bool (*SignFun)(void* );
+    SignFun signFun = (SignFun) GetProc( theLibraryHandle, "SignCAD" );
+    if ( !signFun )
+    {
+      if ( ! getLastError( error ))
+        error = SMESH_Comment( "Can't find symbol 'SignCAD' in '") << getenv( theEnvVar ) << "'";
+    }
+    else
+    {
+      SMESH_TRY;
+
+      ok = signFun( meshgems_cad );
+
+      SMESH_CATCH( SMESH::returnError );
+
+      if ( !error.empty() )
+        ok = false;
+      else if ( !ok )
+        error = "SignCAD() failed (located in '" + libraryFile._name + "')";
+    }
+    return ok;
+  }
+
+  //================================================================================
+  /*!
+   * \brief Sign a mesh
+   *  \param [in] meshgems_mesh - pointer to a MG mesh (meshgems_mesh_t)
+   *  \param [out] error - return error description
+   *  \return bool - is a success
+   */
+  //================================================================================
+
+  bool SignMesh( void* meshgems_mesh, std::string& error )
+  {
+    LibraryFile libraryFile;
+    if ( !loadLibrary( error, libraryFile ))
+      return false;
+
+    bool ok = false;
+    typedef bool (*SignFun)(void* );
+    SignFun signFun = (SignFun) GetProc( theLibraryHandle, "SignMesh" );
+    if ( !signFun )
+    {
+      if ( ! getLastError( error ))
+        error = SMESH_Comment( "Can't find symbol 'SignMesh' in '") << getenv( theEnvVar ) << "'";
+    }
+    else
+    {
+      SMESH_TRY;
+
+      ok = signFun( meshgems_mesh );
+
+      SMESH_CATCH( SMESH::returnError );
+
+      if ( !error.empty() )
+        ok = false;
+      else if ( !ok )
+        error = "SignMesh() failed (located in '" + libraryFile._name + "')";
+    }
+    return ok;
+  }
+
+  //================================================================================
+  /*!
+   * \brief Return a license key to pass as argument to a MG mesher executable
+   *  \param [in] gmfFile - path to an input mesh file
+   *  \param [in] nb* - nb of entities in the input mesh
+   *  \param [out] error - return error description
+   *  \return std::string - the key
+   */
+  //================================================================================
+
+  std::string GetKey(const std::string& gmfFile,
+                     int                nbVertex,
+                     int                nbEdge,
+                     int                nbFace,
+                     int                nbVol,
+                     std::string&       error)
+  {
+    std::string key;
+    LibraryFile libraryFile;
+    if ( !loadLibrary( error, libraryFile ))
+      return key;
+
+    typedef std::string (*GetKeyFun)(std::string const &, int, int, int, int );
+    GetKeyFun keyFun = (GetKeyFun) GetProc( theLibraryHandle, "GetKey" );
+    if ( !keyFun )
+    {
+      if ( ! getLastError( error ))
+        error = SMESH_Comment( "Can't find symbol 'GetKey' in '") << getenv( theEnvVar ) << "'";
+    }
+    else
+    {
+      key = keyFun( gmfFile, nbVertex, nbEdge, nbFace, nbVol );
+    }
+    if ( key.empty() )
+      error = "GetKey() failed (located in '" + libraryFile._name + "')";
+
+    return key;
+  }
+
+  //================================================================================
+  /*!
+   * \brief Return false if libMeshGemsKeyGenerator.so is not functional
+   *  \param [out] error - return error description
+   *  \return bool - is a success
+   */
+  //================================================================================
+
+  bool CheckKeyGenLibrary( std::string& error )
+  {
+    return !GetKey("",4,0,2,0,error ).empty();
+  }
+
+  //================================================================================
+  /*!
+   * \brief Return KeyGenerator library name
+   */
+  //================================================================================
+
+  std::string GetLibraryName()
+  {
+    std::string libName, error;
+    if ( const char* libPath = getenv( theEnvVar ))
+    {
+      libName = Kernel_Utils::GetBaseName( libPath );
+    }
+    else
+    {
+      libName = "libSalomeMeshGemsKeyGenerator";
+    }
+    setExtension( libName, error );
+    return libName;
+  }
+}

src/SMESHUtils/SMESH_MGLicenseKeyGen.hxx

@@ -0,0 +1,52 @@
+// Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+// File      : SMESH_MGLicenseKeyGen.hxx
+// Created   : Sat Jul 31 18:41:04 2021
+// Author    : Edward AGAPOV (OCC)
+
+#ifndef __SMESHUtils_MGLicenseKeyGen_HXX__
+#define __SMESHUtils_MGLicenseKeyGen_HXX__
+
+#include "SMESH_Utils.hxx"
+
+#include <string>
+
+/*!
+ * \brief Manage loading libSalomeMeshGemsKeyGenerator.[so|dll] and sing MeshGems CAD or mesh
+ */
+
+namespace SMESHUtils_MGLicenseKeyGen
+{
+  SMESHUtils_EXPORT bool        SignCAD( void* meshgems_cad, std::string& error );
+
+  SMESHUtils_EXPORT bool        SignMesh( void* meshgems_mesh, std::string& error );
+
+  SMESHUtils_EXPORT std::string GetKey(const std::string& gmfFile,
+                                       int                nbVertex,
+                                       int                nbEdge,
+                                       int                nbFace,
+                                       int                nbVol,
+                                       std::string&       error);
+
+  SMESHUtils_EXPORT bool        CheckKeyGenLibrary( std::string& error );
+
+  SMESHUtils_EXPORT std::string GetLibraryName();
+}
+
+#endif

src/SMESH_SWIG/CMakeLists.txt

@@ -25,6 +25,8 @@ include_directories(
   ${PROJECT_SOURCE_DIR}/src/SMDS
   ${PROJECT_SOURCE_DIR}/src/SMESH
   ${PROJECT_SOURCE_DIR}/src/SMESH_I
+  ${PROJECT_SOURCE_DIR}/src/Driver
+  ${PROJECT_SOURCE_DIR}/src/DriverGMF
   ${CMAKE_CURRENT_SOURCE_DIR}
   ${PROJECT_BINARY_DIR}/idl
 )
@@ -123,7 +125,7 @@ IF(${CMAKE_VERSION} VERSION_LESS "3.8.0")
 ELSE()
   SWIG_ADD_LIBRARY(SMeshHelper LANGUAGE python SOURCES ${SMeshHelper_SOURCES})
 ENDIF()
-SWIG_LINK_LIBRARIES(SMeshHelper ${PYTHON_LIBRARIES} ${PLATFORM_LIBS} SMESHEngine )
+SWIG_LINK_LIBRARIES(SMeshHelper ${PYTHON_LIBRARIES} ${PLATFORM_LIBS} SMESHEngine MeshDriverGMF )
 SWIG_CHECK_GENERATION(SMeshHelper)
 IF(WIN32)
   SET_TARGET_PROPERTIES(_SMeshHelper PROPERTIES DEBUG_OUTPUT_NAME _SMeshHelper_d)

src/SMESH_SWIG/SMeshHelper.cxx

@@ -25,9 +25,35 @@
 
 #include <cstring>
 
+#include <DriverGMF_Read.hxx>
+#include <SMESH_MGLicenseKeyGen.hxx>
+
+
 std::string BuildSMESHInstanceInternal()
 {
   Engines::EngineComponent_var zeRef = RetrieveSMESHInstance();
   CORBA::String_var ior = KERNEL::getORB()->object_to_string(zeRef);
   return std::string(ior.in());
 }
+
+std::string GetMGLicenseKeyImpl(const char* gmfFile)
+{
+  smIdType nbVertex, nbEdge, nbFace, nbVol;
+  DriverGMF_Read gmfReader;
+  gmfReader.SetFile( gmfFile );
+  gmfReader.GetMeshInfo( nbVertex, nbEdge, nbFace, nbVol );
+
+  std::string errorTxt;
+  std::string key = SMESHUtils_MGLicenseKeyGen::GetKey( gmfFile,
+                                                        FromSmIdType<int>( nbVertex ),
+                                                        FromSmIdType<int>( nbEdge ),
+                                                        FromSmIdType<int>( nbFace ),
+                                                        FromSmIdType<int>( nbVol ),
+                                                        errorTxt );
+  if ( !errorTxt.empty() )
+  {
+    std::cerr << "Error: Pb with MeshGems license: " << errorTxt << std::endl;
+    key = "<" + errorTxt + ">";
+  }
+  return key;
+}

src/SMESH_SWIG/SMeshHelper.h

@@ -22,3 +22,5 @@
 #include <string>
 
 std::string BuildSMESHInstanceInternal();
+
+std::string GetMGLicenseKeyImpl(const char* gmfFile);

src/SMESH_SWIG/SMeshHelper.i

@@ -31,4 +31,9 @@
   {
     return BuildSMESHInstanceInternal();
   }
+
+  std::string GetMGLicenseKey(const char* gmfFile)
+  {
+    return GetMGLicenseKeyImpl( gmfFile );
+  }
 }

src/Tools/MGCleanerPlug/MGCleanerMonPlugDialog.py

@@ -525,18 +525,6 @@ class MGCleanerMonPlugDialog(Ui_MGCleanerPlugDialog,QWidget):
 
   def PrepareLigneCommande(self):
     """
-    #use doc examples of mg-cleaner:
-    ls -al /data/tmplgls/salome/prerequis/install/COMMON_64/MeshGems-1.0/bin
-    source /data/tmplgls/salome/prerequis/install/LICENSE/dlim8.var.sh
-    export PATH=/data/tmplgls/salome/prerequis/install/COMMON_64/MeshGems-1.0/bin/Linux_64:$PATH
-    cp -r /data/tmplgls/salome/prerequis/install/COMMON_64/MeshGems-1.0/examples .
-    cd examples
-    mg-cleaner.exe --help
-    mg-cleaner.exe --in case7.mesh --out case7-test.mesh --check
-    mg-cleaner.exe case7.mesh case7-fix.mesh --fix
-    mg-cleaner.exe --in Porsche.mesh --out Porsche-test.mesh --check
-    mg-cleaner.exe --in Porsche.mesh --out Porschefix.mesh --fix
-    mg-cleaner.exe --in Porsche.mesh --out PorscheNewfix.mesh --fix --resolution_length 0.03
     """
     
     #self.commande="mg-cleaner.exe --in " + self.fichierIn + " --out " + self.fichierOut + " --fix2pass" 
@@ -577,6 +565,11 @@ class MGCleanerMonPlugDialog(Ui_MGCleanerPlugDialog,QWidget):
     if not self.CB_ComputedOverlapDistance.isChecked(): #computed default
       self.commande+=" --overlap_distance " + self.SP_toStr(self.SP_OverlapDistance)
     self.commande+=" --overlap_angle " + str(self.SP_OverlapAngle.value())
+
+    import SMeshHelper
+    key = SMeshHelper.GetMGLicenseKey( self.fichierIn )
+    self.commande+=' --key ' + key
+
     if verbose: print(("INFO: MGCCleaner command:\n  %s" % self.commande))
     return True
 

src/Tools/MGCleanerPlug/MGCleanerMonViewText.py

@@ -35,11 +35,6 @@ from MGCleanerViewText_ui import Ui_ViewExe
 
 verbose = True
 
-force = os.getenv("FORCE_DISTENE_LICENSE_FILE")
-if force != None:
-    os.environ["DISTENE_LICENSE_FILE"] = force
-    os.environ["DLIM8VAR"] = "NOTHING"
-
 class MGCleanerMonViewText(Ui_ViewExe, QDialog):
     """
     Classe permettant la visualisation de texte

src/Tools/MGCleanerPlug/MGCleanerplug_plugin.py

@@ -31,15 +31,6 @@ def MGCleanerLct(context):
   import tempfile
   from qtsalome import QFileDialog, QMessageBox
   
-  #prior test to avoid unnecessary user GUI work with ending crash
-  try :
-      os.environ['DISTENE_LICENSE_FILE']
-  except:
-      QMessageBox.warning(None, "Products", """\
-Distene's product MeshGem Cleaner is not installed.
-required environment variable:
-DISTENE_LICENSE_FILE='.../dlim8.var.sh'""")
-      return
   import MGCleanerMonPlugDialog
   window = MGCleanerMonPlugDialog.getDialog()
   window.show()

src/Tools/YamsPlug/monViewText.py

@@ -34,11 +34,6 @@ from ViewText_ui import Ui_ViewExe
 
 verbose = True
 
-force = os.getenv("FORCE_DISTENE_LICENSE_FILE")
-if force != None:
-    os.environ["DISTENE_LICENSE_FILE"] = force
-    os.environ["DLIM8VAR"] = "NOTHING"
-
 class MonViewText(Ui_ViewExe, QDialog):
     """
     Classe permettant la visualisation de texte

src/Tools/YamsPlug/monYamsPlugDialog.py

@@ -546,6 +546,10 @@ class MonYamsPlugDialog(Ui_YamsPlugDialog,QWidget):
     self.commande+=' --in "'  + self.fichierIn +'"'
     self.commande+=' --out "' + self.fichierOut +'"'
 
+    import SMeshHelper
+    key = SMeshHelper.GetMGLicenseKey( self.fichierIn )
+    self.commande+=' --key ' + key
+    
     print(self.commande)
     return True
 

src/Tools/YamsPlug/yamsplug_plugin.py

@@ -31,15 +31,6 @@ def YamsLct(context):
   import tempfile
   from qtsalome import QFileDialog, QMessageBox
   
-  #prior test to avoid unnecessary user GUI work with ending crash
-  try :
-      os.environ['DISTENE_LICENSE_FILE']
-  except:
-      QMessageBox.warning(None,"Products","""\
-Distene's product MeshGem SurfOpt is not installed.
-required environment variable:
-DISTENE_LICENSE_FILE='.../dlim8.var.sh'""")
-      return
   import monYamsPlugDialog
   window = monYamsPlugDialog.getDialog()
   window.show()