X-Git-Url: http://git.salome-platform.org/gitweb/?p=modules%2Fsmesh.git;a=blobdiff_plain;f=src%2FSMESH_I%2FSMESH_Gen_i.cxx;h=9c8a983040e33fb4af1ab5cc62d98e55a1bb0a4e;hp=8fb303ad35ce421875c92c6f75190fc78a4ae206;hb=5d0b75d9d1a9935ec419e820e6dde45a665dd978;hpb=9a54694a0ab1e5cbc558a35c4606ceea4f7af2ef diff --git a/src/SMESH_I/SMESH_Gen_i.cxx b/src/SMESH_I/SMESH_Gen_i.cxx index 8fb303ad3..9c8a98304 100644 --- a/src/SMESH_I/SMESH_Gen_i.cxx +++ b/src/SMESH_I/SMESH_Gen_i.cxx @@ -1,4 +1,4 @@ -// Copyright (C) 2007-2012 CEA/DEN, EDF R&D, OPEN CASCADE +// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE // // Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS @@ -6,7 +6,7 @@ // 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. +// 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 @@ -44,22 +44,27 @@ #include #include #include +#include +#include +#include -#ifdef WNT + +#ifdef WIN32 #include #include #else #include + #include // for basename function #endif -#ifdef WNT +#ifdef WIN32 #define LibHandle HMODULE #define LoadLib( name ) LoadLibrary( name ) #define GetProc GetProcAddress #define UnLoadLib( handle ) FreeLibrary( handle ); #else #define LibHandle void* - #define LoadLib( name ) dlopen( name, RTLD_LAZY ) + #define LoadLib( name ) dlopen( name, RTLD_LAZY | RTLD_GLOBAL ) #define GetProc dlsym #define UnLoadLib( handle ) dlclose( handle ); #endif @@ -67,6 +72,12 @@ #include "SMESH_Gen_i.hxx" #include "SMESH_version.h" +#include "DriverMED_W_SMESHDS_Mesh.h" +#include "DriverMED_R_SMESHDS_Mesh.h" +#ifdef WITH_CGNS +#include "DriverCGNS_Read.hxx" +#endif +#include "MED_Factory.hxx" #include "SMDS_EdgePosition.hxx" #include "SMDS_FacePosition.hxx" #include "SMDS_PolyhedralVolumeOfNodes.hxx" @@ -87,21 +98,18 @@ #include "SMESH_Mesh_i.hxx" #include "SMESH_PreMeshInfo.hxx" #include "SMESH_PythonDump.hxx" +#include "SMESH_ControlsDef.hxx" +#include "SMESH_TryCatch.hxx" // to include after OCC headers! #include CORBA_SERVER_HEADER(SMESH_Group) #include CORBA_SERVER_HEADER(SMESH_Filter) #include CORBA_SERVER_HEADER(SMESH_MeshEditor) -#include "DriverMED_W_SMESHDS_Mesh.h" -#include "DriverMED_R_SMESHDS_Mesh.h" -#ifdef WITH_CGNS -#include "DriverCGNS_Read.hxx" -#endif -#include "memoire.h" #include #include +#include #include #include #include @@ -124,7 +132,7 @@ #include #include #include -#include +#include using namespace std; using SMESH::TPythonDump; @@ -261,7 +269,6 @@ GEOM::GEOM_Gen_var SMESH_Gen_i::GetGeomEngine() { SMESH_Gen_i::SMESH_Gen_i() { - INFOS( "SMESH_Gen_i::SMESH_Gen_i : default constructor" ); } //============================================================================= @@ -277,9 +284,8 @@ SMESH_Gen_i::SMESH_Gen_i( CORBA::ORB_ptr orb, PortableServer::ObjectId* contId, const char* instanceName, const char* interfaceName ) - : Engines_Component_i( orb, poa, contId, instanceName, interfaceName ) + : Engines_Component_i( orb, poa, contId, instanceName, interfaceName ) { - MESSAGE( "SMESH_Gen_i::SMESH_Gen_i : standard constructor" ); myOrb = CORBA::ORB::_duplicate(orb); myPoa = PortableServer::POA::_duplicate(poa); @@ -309,7 +315,7 @@ SMESH_Gen_i::SMESH_Gen_i( CORBA::ORB_ptr orb, CORBA::String_var str_host = session->getHostname(); CORBA::Long s_pid = session->getPID(); string my_host = Kernel_Utils::GetHostname(); -#ifdef WNT +#ifdef WIN32 long my_pid = (long)_getpid(); #else long my_pid = (long) getpid(); @@ -329,13 +335,18 @@ SMESH_Gen_i::SMESH_Gen_i( CORBA::ORB_ptr orb, SMESH_Gen_i::~SMESH_Gen_i() { - MESSAGE( "SMESH_Gen_i::~SMESH_Gen_i" ); - // delete hypothesis creators - map::iterator itHyp; + map::iterator itHyp, itHyp2; for (itHyp = myHypCreatorMap.begin(); itHyp != myHypCreatorMap.end(); itHyp++) { - delete (*itHyp).second; + // same creator can be mapped under different names + GenericHypothesisCreator_i* creator = (*itHyp).second; + if ( !creator ) + continue; + delete creator; + for (itHyp2 = itHyp; itHyp2 != myHypCreatorMap.end(); itHyp2++) + if ( creator == (*itHyp2).second ) + (*itHyp2).second = 0; } myHypCreatorMap.clear(); @@ -349,20 +360,20 @@ SMESH_Gen_i::~SMESH_Gen_i() if ( myShapeReader ) delete myShapeReader; } - //============================================================================= /*! - * SMESH_Gen_i::createHypothesis + * SMESH_Gen_i::getHypothesisCreator * - * Create hypothesis of given type + * Get hypothesis creator */ //============================================================================= -SMESH::SMESH_Hypothesis_ptr SMESH_Gen_i::createHypothesis(const char* theHypName, - const char* theLibName) - throw (SALOME::SALOME_Exception) +GenericHypothesisCreator_i* SMESH_Gen_i::getHypothesisCreator(const char* theHypName, + const char* theLibName, + std::string& thePlatformLibName) + throw (SALOME::SALOME_Exception) { + std::string aPlatformLibName; /* It's Need to tranlate lib name for WIN32 or X platform */ - char* aPlatformLibName = 0; if ( theLibName && theLibName[0] != '\0' ) { int libNameLen = strlen(theLibName); @@ -372,45 +383,34 @@ SMESH::SMESH_Hypothesis_ptr SMESH_Gen_i::createHypothesis(const char* theHypName !strcmp( theLibName+libNameLen-3, ".so" )) { //the old format -#ifdef WNT - aPlatformLibName = new char[libNameLen - 1]; - aPlatformLibName[0] = '\0'; - aPlatformLibName = strncat( aPlatformLibName, theLibName+3, libNameLen-6 ); - aPlatformLibName = strcat( aPlatformLibName, ".dll" ); - aPlatformLibName[libNameLen - 2] = '\0'; +#if defined(WIN32) + aPlatformLibName = std::string( theLibName+3, libNameLen-6 ) + ".dll"; +#elif defined(__APPLE__) + aPlatformLibName = std::string( theLibName, libNameLen-3 ) + ".dylib"; #else - aPlatformLibName = new char[ libNameLen + 1]; - aPlatformLibName[0] = '\0'; - aPlatformLibName = strcat( aPlatformLibName, theLibName ); - aPlatformLibName[libNameLen] = '\0'; + aPlatformLibName = theLibName; #endif } else { //try to use new format -#ifdef WNT - aPlatformLibName = new char[ libNameLen + 5 ]; - aPlatformLibName[0] = '\0'; - aPlatformLibName = strcat( aPlatformLibName, theLibName ); - aPlatformLibName = strcat( aPlatformLibName, ".dll" ); +#if defined(WIN32) + aPlatformLibName = theLibName; + aPlatformLibName += ".dll"; +#elif defined(__APPLE__) + aPlatformLibName = std::string( "lib" ) + std::string( theLibName ) + ".dylib"; #else - aPlatformLibName = new char[ libNameLen + 7 ]; - aPlatformLibName[0] = '\0'; - aPlatformLibName = strcat( aPlatformLibName, "lib" ); - aPlatformLibName = strcat( aPlatformLibName, theLibName ); - aPlatformLibName = strcat( aPlatformLibName, ".so" ); + aPlatformLibName = std::string( "lib" ) + std::string( theLibName ) + ".so"; #endif } } - + thePlatformLibName = aPlatformLibName; Unexpect aCatch(SALOME_SalomeException); - if(MYDEBUG) MESSAGE( "Create Hypothesis <" << theHypName << "> from " << aPlatformLibName/*theLibName*/); - - // create a new hypothesis object servant - SMESH_Hypothesis_i* myHypothesis_i = 0; - SMESH::SMESH_Hypothesis_var hypothesis_i; + if(MYDEBUG) MESSAGE( "Create Hypothesis <" << theHypName << "> from " << aPlatformLibName); + typedef GenericHypothesisCreator_i* (*GetHypothesisCreator)(const char* ); + GenericHypothesisCreator_i* aCreator; try { // check, if creator for this hypothesis type already exists @@ -418,11 +418,11 @@ SMESH::SMESH_Hypothesis_ptr SMESH_Gen_i::createHypothesis(const char* theHypName { // load plugin library if(MYDEBUG) MESSAGE("Loading server meshers plugin library ..."); - LibHandle libHandle = LoadLib( aPlatformLibName/*theLibName*/ ); + LibHandle libHandle = LoadLib( aPlatformLibName.c_str() ); if (!libHandle) { // report any error, if occured -#ifndef WNT +#ifndef WIN32 const char* anError = dlerror(); throw(SALOME_Exception(anError)); #else @@ -432,7 +432,6 @@ SMESH::SMESH_Hypothesis_ptr SMESH_Gen_i::createHypothesis(const char* theHypName // get method, returning hypothesis creator if(MYDEBUG) MESSAGE("Find GetHypothesisCreator() method ..."); - typedef GenericHypothesisCreator_i* (*GetHypothesisCreator)(const char* theHypName); GetHypothesisCreator procHandle = (GetHypothesisCreator)GetProc( libHandle, "GetHypothesisCreator" ); if (!procHandle) @@ -443,38 +442,57 @@ SMESH::SMESH_Hypothesis_ptr SMESH_Gen_i::createHypothesis(const char* theHypName // get hypothesis creator if(MYDEBUG) MESSAGE("Get Hypothesis Creator for " << theHypName); - GenericHypothesisCreator_i* aCreator = procHandle(theHypName); + aCreator = procHandle(theHypName); if (!aCreator) { throw(SALOME_Exception(LOCALIZED("no such a hypothesis in this plugin"))); } - // map hypothesis creator to a hypothesis name myHypCreatorMap[string(theHypName)] = aCreator; + return aCreator; + } + else + { + return myHypCreatorMap[string(theHypName)]; } - - // create a new hypothesis object, store its ref. in studyContext - if(MYDEBUG) MESSAGE("Create Hypothesis " << theHypName); - myHypothesis_i = - myHypCreatorMap[string(theHypName)]->Create(myPoa, GetCurrentStudyID(), &myGen); - myHypothesis_i->SetLibName(aPlatformLibName/*theLibName*/); // for persistency assurance } catch (SALOME_Exception& S_ex) { THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM); } + return aCreator; +} - if ( aPlatformLibName ) - delete[] aPlatformLibName; - - if (!myHypothesis_i) - return hypothesis_i._retn(); - - // activate the CORBA servant of hypothesis - hypothesis_i = SMESH::SMESH_Hypothesis::_narrow( myHypothesis_i->_this() ); - int nextId = RegisterObject( hypothesis_i ); - if(MYDEBUG) MESSAGE( "Add hypo to map with id = "<< nextId ); +//============================================================================= +/*! + * SMESH_Gen_i::createHypothesis + * + * Create hypothesis of given type + */ +//============================================================================= +SMESH::SMESH_Hypothesis_ptr SMESH_Gen_i::createHypothesis(const char* theHypName, + const char* theLibName) +{ + SMESH_Hypothesis_i* myHypothesis_i = 0; + SMESH::SMESH_Hypothesis_var hypothesis_i; + std::string aPlatformLibName; + GenericHypothesisCreator_i* aCreator = + getHypothesisCreator(theHypName, theLibName, aPlatformLibName); + // create a new hypothesis object, store its ref. in studyContext + myHypothesis_i = aCreator->Create(myPoa, GetCurrentStudyID(), &myGen); + if (myHypothesis_i) + { + myHypothesis_i->SetLibName( aPlatformLibName.c_str() ); // for persistency assurance + CORBA::String_var hypName = myHypothesis_i->GetName(); + myHypCreatorMap[ hypName.in() ] = aCreator; + + // activate the CORBA servant of hypothesis + hypothesis_i = myHypothesis_i->_this(); + int nextId = RegisterObject( hypothesis_i ); + if(MYDEBUG) { MESSAGE( "Add hypo to map with id = "<< nextId ); } + else { nextId = 0; } // avoid "unused variable" warning in release mode + } return hypothesis_i._retn(); } @@ -486,7 +504,7 @@ SMESH::SMESH_Hypothesis_ptr SMESH_Gen_i::createHypothesis(const char* theHypName */ //============================================================================= SMESH::SMESH_Mesh_ptr SMESH_Gen_i::createMesh() - throw ( SALOME::SALOME_Exception ) + throw ( SALOME::SALOME_Exception ) { Unexpect aCatch(SALOME_SalomeException); if(MYDEBUG) MESSAGE( "SMESH_Gen_i::createMesh" ); @@ -496,13 +514,14 @@ SMESH::SMESH_Mesh_ptr SMESH_Gen_i::createMesh() // create a new mesh object servant, store it in a map in study context SMESH_Mesh_i* meshServant = new SMESH_Mesh_i( GetPOA(), this, GetCurrentStudyID() ); // create a new mesh object - MESSAGE("myIsEmbeddedMode " << myIsEmbeddedMode); + if(MYDEBUG) MESSAGE("myIsEmbeddedMode " << myIsEmbeddedMode); meshServant->SetImpl( myGen.CreateMesh( GetCurrentStudyID(), myIsEmbeddedMode )); // activate the CORBA servant of Mesh SMESH::SMESH_Mesh_var mesh = SMESH::SMESH_Mesh::_narrow( meshServant->_this() ); int nextId = RegisterObject( mesh ); - if(MYDEBUG) MESSAGE( "Add mesh to map with id = "<< nextId); + if(MYDEBUG) { MESSAGE( "Add mesh to map with id = "<< nextId); } + else { nextId = 0; } // avoid "unused variable" warning in release mode return mesh._retn(); } catch (SALOME_Exception& S_ex) { @@ -554,7 +573,6 @@ void SMESH_Gen_i::SetGeomEngine( GEOM::GEOM_Gen_ptr geomcompo ) void SMESH_Gen_i::SetEmbeddedMode( CORBA::Boolean theMode ) { myIsEmbeddedMode = theMode; - MESSAGE("myIsEmbeddedMode " << myIsEmbeddedMode); if ( !myIsEmbeddedMode ) { //PAL10867: disable signals catching with "noexcepthandler" option @@ -630,7 +648,7 @@ void SMESH_Gen_i::setCurrentStudy( SALOMEDS::Study_ptr theStudy, SALOMEDS::SObject_wrap so = anIter->Value(); CORBA::Object_var ior = SObjectToObject( so ); if ( SMESH_Mesh_i* mesh = SMESH::DownCast( ior )) - mesh->CheckGeomGroupModif(); + mesh->CheckGeomModif(); } } } @@ -648,6 +666,8 @@ void SMESH_Gen_i::setCurrentStudy( SALOMEDS::Study_ptr theStudy, SALOMEDS::Study_ptr SMESH_Gen_i::GetCurrentStudy() { if(MYDEBUG) MESSAGE( "SMESH_Gen_i::GetCurrentStudy: study Id = " << GetCurrentStudyID() ); + if ( GetCurrentStudyID() < 0 ) + return SALOMEDS::Study::_nil(); return SALOMEDS::Study::_duplicate( myCurrentStudy ); } @@ -661,7 +681,7 @@ SALOMEDS::Study_ptr SMESH_Gen_i::GetCurrentStudy() StudyContext* SMESH_Gen_i::GetCurrentStudyContext() { if ( !CORBA::is_nil( myCurrentStudy ) && - myStudyContextMap.find( GetCurrentStudyID() ) != myStudyContextMap.end() ) + myStudyContextMap.find( GetCurrentStudyID() ) != myStudyContextMap.end() ) return myStudyContextMap[ myCurrentStudy->StudyId() ]; else return 0; @@ -677,7 +697,7 @@ StudyContext* SMESH_Gen_i::GetCurrentStudyContext() SMESH::SMESH_Hypothesis_ptr SMESH_Gen_i::CreateHypothesis( const char* theHypName, const char* theLibName ) - throw ( SALOME::SALOME_Exception ) + throw ( SALOME::SALOME_Exception ) { Unexpect aCatch(SALOME_SalomeException); // Create hypothesis/algorithm @@ -735,7 +755,7 @@ SMESH_Gen_i::GetHypothesisParameterValues (const char* theHypType, return SMESH::SMESH_Hypothesis::_nil(); ::SMESH_Mesh* mesh = meshServant ? &meshServant->GetImpl() : (::SMESH_Mesh*)0; - // create a temporary hypothesis to know its dimention + // create a temporary hypothesis to know its dimension SMESH::SMESH_Hypothesis_var tmpHyp = this->createHypothesis( theHypType, theLibName ); SMESH_Hypothesis_i* hypServant = SMESH::DownCast( tmpHyp ); if ( !hypServant ) @@ -791,6 +811,104 @@ SMESH_Gen_i::GetHypothesisParameterValues (const char* theHypType, return SMESH::SMESH_Hypothesis::_nil(); } +//============================================================================= +/*! + * Returns \c True if a hypothesis is assigned to a sole sub-mesh in a current Study + * \param [in] theHyp - the hypothesis of interest + * \param [out] theMesh - the sole mesh using \a theHyp + * \param [out] theShape - the sole geometry \a theHyp is assigned to + * \return boolean - \c True if \a theMesh and \a theShape are sole using \a theHyp + * + * If two meshes on same shape have theHyp assigned to the same sub-shape, they are + * considered as SAME sub-mesh => result is \c true. + * This method ids used to initialize SMESHGUI_GenericHypothesisCreator with + * a shape to which an hyp being edited is assigned. + */ +//============================================================================= + +CORBA::Boolean SMESH_Gen_i::GetSoleSubMeshUsingHyp( SMESH::SMESH_Hypothesis_ptr theHyp, + SMESH::SMESH_Mesh_out theMesh, + GEOM::GEOM_Object_out theShape) +{ + if ( GetCurrentStudyID() < 0 || CORBA::is_nil( theHyp )) + return false; + + // get Mesh component SO + CORBA::String_var compDataType = ComponentDataType(); + SALOMEDS::SComponent_wrap comp = myCurrentStudy->FindComponent( compDataType.in() ); + if ( CORBA::is_nil( comp )) + return false; + + // look for child SO of meshes + SMESH::SMESH_Mesh_var foundMesh; + TopoDS_Shape foundShape; + bool isSole = true; + SALOMEDS::ChildIterator_wrap meshIter = myCurrentStudy->NewChildIterator( comp ); + for ( ; meshIter->More() && isSole; meshIter->Next() ) + { + SALOMEDS::SObject_wrap curSO = meshIter->Value(); + CORBA::Object_var obj = SObjectToObject( curSO ); + SMESH_Mesh_i* mesh_i = SMESH::DownCast< SMESH_Mesh_i* >( obj ); + if ( ! mesh_i ) + continue; + + // look for a sole shape where theHyp is assigned + bool isHypFound = false; + const ShapeToHypothesis & s2hyps = mesh_i->GetImpl().GetMeshDS()->GetHypotheses(); + ShapeToHypothesis::Iterator s2hypsIt( s2hyps ); + for ( ; s2hypsIt.More() && isSole; s2hypsIt.Next() ) + { + const THypList& hyps = s2hypsIt.Value(); + THypList::const_iterator h = hyps.begin(); + for ( ; h != hyps.end(); ++h ) + if ( (*h)->GetID() == theHyp->GetId() ) + break; + if ( h != hyps.end()) // theHyp found + { + isHypFound = true; + if ( ! foundShape.IsNull() && + ! foundShape.IsSame( s2hypsIt.Key() )) // not a sole sub-shape + { + foundShape.Nullify(); + isSole = false; + break; + } + foundShape = s2hypsIt.Key(); + } + } // loop on assigned hyps + + if ( isHypFound && !foundShape.IsNull() ) // a mesh using theHyp is found + { + if ( !foundMesh->_is_nil() ) // not a sole mesh + { + if ( !foundMesh->HasShapeToMesh() || + !mesh_i ->HasShapeToMesh() ) + { + isSole = ( foundMesh->HasShapeToMesh() == mesh_i->HasShapeToMesh() ); + } + else + { + GEOM::GEOM_Object_var s1 = mesh_i ->GetShapeToMesh(); + GEOM::GEOM_Object_var s2 = foundMesh->GetShapeToMesh(); + isSole = s1->IsSame( s2 ); + } + } + foundMesh = SMESH::SMESH_Mesh::_narrow( obj ); + } + + } // loop on meshes + + if ( isSole && + ! foundMesh->_is_nil() && + ! foundShape.IsNull() ) + { + theMesh = foundMesh._retn(); + theShape = ShapeToGeomObject( foundShape ); + return ( !theMesh->_is_nil() && !theShape->_is_nil() ); + } + return false; +} + //============================================================================= /*! * Sets number of segments per diagonal of boundary box of geometry by which @@ -830,7 +948,7 @@ void SMESH_Gen_i::SetOption(const char* name, const char* value) { if ( name && value && strlen( value ) > 0 ) { - string msgToGUI; + string msgToGUI; if ( strcmp(name, "historical_python_dump") == 0 ) { myIsHistoricalPythonDump = ( value[0] == '1' || toupper(value[0]) == 'T' ); // 1 || true @@ -843,6 +961,34 @@ void SMESH_Gen_i::SetOption(const char* name, const char* value) msgToGUI = "preferences/SMESH/forget_mesh_on_hyp_modif/"; msgToGUI += myToForgetMeshDataOnHypModif ? "true" : "false"; } + else if ( strcmp(name, "default_grp_color") == 0 ) + { + vector color; + string str = value; + // color must be presented as a string of following form: + if ( str.at(0) == '#' && str.length() == 7 ) { // hexadecimal color ("#ffaa00", for example) + str = str.substr(1); + for ( size_t i = 0; i < str.length()/2; i++ ) + if ( str.at(i*2) >= '0' && str.at(i*2) <= 'f' && str.at(i*2+1) >= '0' && str.at(i*2+1) <= 'f' ) + color.push_back( strtol( str.substr( i*2, 2 ).c_str(), NULL, 16 ) ); + } + else if ( value ) { // rgb color ("255,170,0", for example) + string tempValue( value ); + char* colorValue = strtok( &tempValue[0], "," ); + while ( colorValue != NULL ) { + int c_value = atoi( colorValue ); + if ( c_value >= 0 && c_value <= 255 ) + color.push_back( c_value ); + colorValue = strtok( NULL, "," ); + } + } + if ( color.size() == 3 ) { // color must have three valid component + SMESHDS_GroupBase::SetDefaultColor( Quantity_Color( color[0]/255., color[1]/255., color[2]/255., Quantity_TOC_RGB ) ); + myDefaultGroupColor = value; + msgToGUI = "preferences/SMESH/default_grp_color/"; + msgToGUI += value; + } + } // update preferences in case if SetOption() is invoked from python console if ( !msgToGUI.empty() ) @@ -873,6 +1019,10 @@ char* SMESH_Gen_i::GetOption(const char* name) { return CORBA::string_dup( myToForgetMeshDataOnHypModif ? "true" : "false" ); } + if ( strcmp(name, "default_grp_color") == 0 ) + { + return CORBA::string_dup( myDefaultGroupColor.c_str() ); + } } return CORBA::string_dup( "" ); } @@ -943,6 +1093,29 @@ SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CreateEmptyMesh() return mesh._retn(); } +namespace +{ + //================================================================================ + /*! + * \brief Throws an exception in case if the file can't be read + */ + //================================================================================ + + void checkFileReadable( const char* theFileName ) throw ( SALOME::SALOME_Exception ) + { + SMESH_File f ( theFileName ); + if ( !f ) + { + if ( !f.error().empty() ) + THROW_SALOME_CORBA_EXCEPTION( f.error().c_str(), SALOME::BAD_PARAM); + + THROW_SALOME_CORBA_EXCEPTION + (( SMESH_Comment("Can't open for reading the file ") << theFileName ).c_str(), + SALOME::BAD_PARAM ); + } + } +} + //============================================================================= /*! * SMESH_Gen_i::CreateMeshFromUNV @@ -955,7 +1128,8 @@ SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CreateMeshesFromUNV( const char* theFileName throw ( SALOME::SALOME_Exception ) { Unexpect aCatch(SALOME_SalomeException); - if(MYDEBUG) MESSAGE( "SMESH_Gen_i::CreateMeshesFromUNV" ); + + checkFileReadable( theFileName ); SMESH::SMESH_Mesh_var aMesh = createMesh(); string aFileName; @@ -1000,7 +1174,7 @@ SMESH::mesh_array* SMESH_Gen_i::CreateMeshesFromMEDorSAUV( const char* theFileNa _splitpath( theFileNameForPython, NULL, NULL, bname, NULL ); string aFileName = bname; #else - string aFileName = basename( theFileNameForPython ); + string aFileName = basename( const_cast(theFileNameForPython) ); #endif // Retrieve mesh names from the file DriverMED_R_SMESHDS_Mesh myReader; @@ -1018,13 +1192,18 @@ SMESH::mesh_array* SMESH_Gen_i::CreateMeshesFromMEDorSAUV( const char* theFileNa aPythonDump << "(["; if (theStatus == SMESH::DRS_OK) { - SALOMEDS::StudyBuilder_var aStudyBuilder = myCurrentStudy->NewBuilder(); - aStudyBuilder->NewCommand(); // There is a transaction + SALOMEDS::StudyBuilder_var aStudyBuilder; + if ( GetCurrentStudyID() > -1 ) + { + aStudyBuilder = myCurrentStudy->NewBuilder(); + aStudyBuilder->NewCommand(); // There is a transaction + } aResult->length( aNames.size() ); int i = 0; // Iterate through all meshes and create mesh objects - for ( list::iterator it = aNames.begin(); it != aNames.end(); it++ ) { + for ( list::iterator it = aNames.begin(); it != aNames.end(); it++ ) + { // Python Dump if (i > 0) aPythonDump << ", "; @@ -1038,11 +1217,11 @@ SMESH::mesh_array* SMESH_Gen_i::CreateMeshesFromMEDorSAUV( const char* theFileNa // - as names of meshes are stored in MED file, we use them for data publishing // - as mesh name is not stored in UNV file, we use file name as name of mesh when publishing data aSO = PublishMesh( myCurrentStudy, mesh.in(), ( theFileName == theFileNameForPython ) ? (*it).c_str() : aFileName.c_str() ); + + // Python Dump if ( !aSO->_is_nil() ) { - // Python Dump aPythonDump << aSO; } else { - // Python Dump aPythonDump << "mesh_" << i; } @@ -1057,14 +1236,15 @@ SMESH::mesh_array* SMESH_Gen_i::CreateMeshesFromMEDorSAUV( const char* theFileNa aResult[i++] = SMESH::SMESH_Mesh::_duplicate( mesh ); meshServant->GetImpl().GetMeshDS()->Modified(); } - aStudyBuilder->CommitCommand(); + if ( !aStudyBuilder->_is_nil() ) + aStudyBuilder->CommitCommand(); } // Update Python script aPythonDump << "], status) = " << this << "." << theCommandNameForPython << "(r'" << theFileNameForPython << "')"; } // Dump creation of groups - for ( int i = 0; i < aResult->length(); ++i ) + for ( CORBA::ULong i = 0; i < aResult->length(); ++i ) SMESH::ListOfGroups_var groups = aResult[ i ]->GetGroups(); return aResult._retn(); @@ -1072,10 +1252,11 @@ SMESH::mesh_array* SMESH_Gen_i::CreateMeshesFromMEDorSAUV( const char* theFileNa SMESH::mesh_array* SMESH_Gen_i::CreateMeshesFromMED( const char* theFileName, SMESH::DriverMED_ReadStatus& theStatus) - throw ( SALOME::SALOME_Exception ) + throw ( SALOME::SALOME_Exception ) { Unexpect aCatch(SALOME_SalomeException); - if(MYDEBUG) MESSAGE( "SMESH_Gen_i::CreateMeshFromMED" ); + checkFileReadable( theFileName ); + SMESH::mesh_array* result = CreateMeshesFromMEDorSAUV(theFileName, theStatus, "CreateMeshesFromMED", theFileName); return result; } @@ -1093,12 +1274,13 @@ SMESH::mesh_array* SMESH_Gen_i::CreateMeshesFromSAUV( const char* theFileName, throw ( SALOME::SALOME_Exception ) { Unexpect aCatch(SALOME_SalomeException); - if(MYDEBUG) MESSAGE( "SMESH_Gen_i::CreateMeshFromSAUV" ); + checkFileReadable( theFileName ); + std::string sauvfilename(theFileName); std::string medfilename(theFileName); medfilename += ".med"; std::string cmd; -#ifdef WNT +#ifdef WIN32 cmd = "%PYTHONBIN% "; #else cmd = "python "; @@ -1108,7 +1290,7 @@ SMESH::mesh_array* SMESH_Gen_i::CreateMeshesFromSAUV( const char* theFileName, cmd += "\""; system(cmd.c_str()); SMESH::mesh_array* result = CreateMeshesFromMEDorSAUV(medfilename.c_str(), theStatus, "CreateMeshesFromSAUV", sauvfilename.c_str()); -#ifdef WNT +#ifdef WIN32 cmd = "%PYTHONBIN% "; #else cmd = "python "; @@ -1132,7 +1314,7 @@ SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CreateMeshesFromSTL( const char* theFileName throw ( SALOME::SALOME_Exception ) { Unexpect aCatch(SALOME_SalomeException); - if(MYDEBUG) MESSAGE( "SMESH_Gen_i::CreateMeshesFromSTL" ); + checkFileReadable( theFileName ); SMESH::SMESH_Mesh_var aMesh = createMesh(); //string aFileName; @@ -1141,7 +1323,7 @@ SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CreateMeshesFromSTL( const char* theFileName _splitpath( theFileName, NULL, NULL, bname, NULL ); string aFileName = bname; #else - string aFileName = basename( theFileName ); + string aFileName = basename( const_cast(theFileName) ); #endif // publish mesh in the study if ( CanPublishInStudy( aMesh ) ) { @@ -1174,6 +1356,7 @@ SMESH::mesh_array* SMESH_Gen_i::CreateMeshesFromCGNS( const char* theFileName, throw ( SALOME::SALOME_Exception ) { Unexpect aCatch(SALOME_SalomeException); + checkFileReadable( theFileName ); SMESH::mesh_array_var aResult = new SMESH::mesh_array(); @@ -1239,7 +1422,7 @@ SMESH::mesh_array* SMESH_Gen_i::CreateMeshesFromCGNS( const char* theFileName, aPythonDump << "], status) = " << this << ".CreateMeshesFromCGNS(r'" << theFileName << "')"; } // Dump creation of groups - for ( int i = 0; i < aResult->length(); ++i ) + for ( CORBA::ULong i = 0; i < aResult->length(); ++i ) SMESH::ListOfGroups_var groups = aResult[ i ]->GetGroups(); #else THROW_SALOME_CORBA_EXCEPTION("CGNS library is unavailable", SALOME::INTERNAL_ERROR); @@ -1261,6 +1444,7 @@ SMESH_Gen_i::CreateMeshesFromGMF( const char* theFileName, throw ( SALOME::SALOME_Exception ) { Unexpect aCatch(SALOME_SalomeException); + checkFileReadable( theFileName ); SMESH::SMESH_Mesh_var aMesh = createMesh(); #ifdef WIN32 @@ -1268,7 +1452,7 @@ SMESH_Gen_i::CreateMeshesFromGMF( const char* theFileName, _splitpath( theFileName, NULL, NULL, bname, NULL ); string aFileName = bname; #else - string aFileName = basename( theFileName ); + string aFileName = basename( const_cast(theFileName) ); #endif // publish mesh in the study if ( CanPublishInStudy( aMesh ) ) { @@ -1414,8 +1598,11 @@ SMESH::compute_error_array* SMESH_Gen_i::GetComputeErrors( SMESH::SMESH_Mesh_ptr // if ( sm->GetSubShape().ShapeType() == TopAbs_VERTEX ) // break; SMESH_ComputeErrorPtr error = sm->GetComputeError(); - if ( error && !error->IsOK() && error->myAlgo ) + if ( error && !error->IsOK() ) { + if ( !( error->myAlgo ) && + !( error->myAlgo = sm->GetAlgo() )) + continue; SMESH::ComputeError & errStruct = error_array[ nbErr++ ]; errStruct.code = -( error->myName < 0 ? error->myName + 1: error->myName ); // -1 -> 0 errStruct.comment = error->myComment.c_str(); @@ -1441,7 +1628,6 @@ SMESH::compute_error_array* SMESH_Gen_i::GetComputeErrors( SMESH::SMESH_Mesh_ptr return error_array._retn(); } -// //================================================================================ /*! * \brief Return mesh elements preventing computation of a subshape @@ -1527,6 +1713,40 @@ SMESH_Gen_i::GetBadInputElements( SMESH::SMESH_Mesh_ptr theMesh, return result._retn(); } +//================================================================================ +/*! + * \brief Create a group of elements preventing computation of a sub-shape + */ +//================================================================================ + +SMESH::ListOfGroups* +SMESH_Gen_i::MakeGroupsOfBadInputElements( SMESH::SMESH_Mesh_ptr theMesh, + CORBA::Short theSubShapeID, + const char* theGroupName ) + throw ( SALOME::SALOME_Exception ) +{ + Unexpect aCatch(SALOME_SalomeException); + + SMESH::ListOfGroups_var groups; + + if ( CORBA::is_nil( theMesh ) ) + THROW_SALOME_CORBA_EXCEPTION( "bad Mesh reference",SALOME::BAD_PARAM ); + + try { + if ( SMESH_Mesh_i* meshServant = SMESH::DownCast( theMesh )) + { + groups = meshServant->MakeGroupsOfBadInputElements( theSubShapeID, theGroupName ); + TPythonDump() << groups << " = " << this + << ".MakeGroupsOfBadInputElements( " + << theMesh << ", " << theSubShapeID << ", '" << theGroupName << "' )"; + } + } + catch ( SALOME_Exception& S_ex ) { + INFOS( "catch exception "<< S_ex.what() ); + } + return groups._retn(); +} + //================================================================================ /*! * \brief Returns errors of hypotheses definintion @@ -1597,9 +1817,10 @@ SMESH::algo_error_array* SMESH_Gen_i::GetAlgoState( SMESH::SMESH_Mesh_ptr theMes */ //============================================================================= -SMESH::long_array* SMESH_Gen_i::GetSubShapesId( GEOM::GEOM_Object_ptr theMainShapeObject, - const SMESH::object_array& theListOfSubShapeObject ) - throw ( SALOME::SALOME_Exception ) +SMESH::long_array* +SMESH_Gen_i::GetSubShapesId( GEOM::GEOM_Object_ptr theMainShapeObject, + const SMESH::object_array& theListOfSubShapeObject ) + throw ( SALOME::SALOME_Exception ) { Unexpect aCatch(SALOME_SalomeException); if(MYDEBUG) MESSAGE( "SMESH_Gen_i::GetSubShapesId" ); @@ -1608,58 +1829,57 @@ SMESH::long_array* SMESH_Gen_i::GetSubShapesId( GEOM::GEOM_Object_ptr theMainSha set setId; if ( CORBA::is_nil( theMainShapeObject ) ) - THROW_SALOME_CORBA_EXCEPTION( "bad shape object reference", - SALOME::BAD_PARAM ); + THROW_SALOME_CORBA_EXCEPTION( "bad shape object reference", SALOME::BAD_PARAM ); try - { - TopoDS_Shape myMainShape = GeomObjectToShape(theMainShapeObject); - TopTools_IndexedMapOfShape myIndexToShape; - TopExp::MapShapes(myMainShape,myIndexToShape); + { + TopoDS_Shape myMainShape = GeomObjectToShape(theMainShapeObject); + TopTools_IndexedMapOfShape myIndexToShape; + TopExp::MapShapes(myMainShape,myIndexToShape); - for ( int i = 0; i < theListOfSubShapeObject.length(); i++ ) - { - GEOM::GEOM_Object_var aShapeObject - = GEOM::GEOM_Object::_narrow(theListOfSubShapeObject[i]); - if ( CORBA::is_nil( aShapeObject ) ) - THROW_SALOME_CORBA_EXCEPTION ("bad shape object reference", \ - SALOME::BAD_PARAM ); - - TopoDS_Shape locShape = GeomObjectToShape(aShapeObject); - for (TopExp_Explorer exp(locShape,TopAbs_FACE); exp.More(); exp.Next()) - { - const TopoDS_Face& F = TopoDS::Face(exp.Current()); - setId.insert(myIndexToShape.FindIndex(F)); - if(MYDEBUG) SCRUTE(myIndexToShape.FindIndex(F)); - } - for (TopExp_Explorer exp(locShape,TopAbs_EDGE); exp.More(); exp.Next()) - { - const TopoDS_Edge& E = TopoDS::Edge(exp.Current()); - setId.insert(myIndexToShape.FindIndex(E)); - if(MYDEBUG) SCRUTE(myIndexToShape.FindIndex(E)); - } - for (TopExp_Explorer exp(locShape,TopAbs_VERTEX); exp.More(); exp.Next()) - { - const TopoDS_Vertex& V = TopoDS::Vertex(exp.Current()); - setId.insert(myIndexToShape.FindIndex(V)); - if(MYDEBUG) SCRUTE(myIndexToShape.FindIndex(V)); - } - } - shapesId->length(setId.size()); - set::iterator iind; - int i=0; - for (iind = setId.begin(); iind != setId.end(); iind++) - { - if(MYDEBUG) SCRUTE((*iind)); - shapesId[i] = (*iind); - if(MYDEBUG) SCRUTE(shapesId[i]); - i++; - } + for ( CORBA::ULong i = 0; i < theListOfSubShapeObject.length(); i++ ) + { + GEOM::GEOM_Object_var aShapeObject + = GEOM::GEOM_Object::_narrow(theListOfSubShapeObject[i]); + if ( CORBA::is_nil( aShapeObject ) ) + THROW_SALOME_CORBA_EXCEPTION ("bad shape object reference", \ + SALOME::BAD_PARAM ); + + TopoDS_Shape locShape = GeomObjectToShape(aShapeObject); + for (TopExp_Explorer exp(locShape,TopAbs_FACE); exp.More(); exp.Next()) + { + const TopoDS_Face& F = TopoDS::Face(exp.Current()); + setId.insert(myIndexToShape.FindIndex(F)); + if(MYDEBUG) SCRUTE(myIndexToShape.FindIndex(F)); + } + for (TopExp_Explorer exp(locShape,TopAbs_EDGE); exp.More(); exp.Next()) + { + const TopoDS_Edge& E = TopoDS::Edge(exp.Current()); + setId.insert(myIndexToShape.FindIndex(E)); + if(MYDEBUG) SCRUTE(myIndexToShape.FindIndex(E)); + } + for (TopExp_Explorer exp(locShape,TopAbs_VERTEX); exp.More(); exp.Next()) + { + const TopoDS_Vertex& V = TopoDS::Vertex(exp.Current()); + setId.insert(myIndexToShape.FindIndex(V)); + if(MYDEBUG) SCRUTE(myIndexToShape.FindIndex(V)); + } } - catch (SALOME_Exception& S_ex) + shapesId->length(setId.size()); + set::iterator iind; + int i=0; + for (iind = setId.begin(); iind != setId.end(); iind++) { - THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM); + if(MYDEBUG) SCRUTE((*iind)); + shapesId[i] = (*iind); + if(MYDEBUG) SCRUTE(shapesId[i]); + i++; } + } + catch (SALOME_Exception& S_ex) + { + THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM); + } return shapesId._retn(); } @@ -1676,7 +1896,7 @@ CORBA::Boolean SMESH_Gen_i::Compute( SMESH::SMESH_Mesh_ptr theMesh, GEOM::GEOM_Object_ptr theShapeObject ) throw ( SALOME::SALOME_Exception ) { - MEMOSTAT; + //MEMOSTAT; Unexpect aCatch(SALOME_SalomeException); if(MYDEBUG) MESSAGE( "SMESH_Gen_i::Compute" ); @@ -1695,11 +1915,11 @@ CORBA::Boolean SMESH_Gen_i::Compute( SMESH::SMESH_Mesh_ptr theMesh, try { // get mesh servant SMESH_Mesh_i* meshServant = dynamic_cast( GetServant( theMesh ).in() ); - meshServant->Load(); ASSERT( meshServant ); if ( meshServant ) { + meshServant->Load(); // NPAL16168: "geometrical group edition from a submesh don't modifiy mesh computation" - meshServant->CheckGeomGroupModif(); + meshServant->CheckGeomModif(); // get local TopoDS_Shape TopoDS_Shape myLocShape; if(theMesh->HasShapeToMesh()) @@ -1708,10 +1928,11 @@ CORBA::Boolean SMESH_Gen_i::Compute( SMESH::SMESH_Mesh_ptr theMesh, myLocShape = SMESH_Mesh::PseudoShape(); // call implementation compute ::SMESH_Mesh& myLocMesh = meshServant->GetImpl(); -#ifdef WITH_SMESH_CANCEL_COMPUTE - myGen.PrepareCompute( myLocMesh, myLocShape); -#endif - bool ok = myGen.Compute( myLocMesh, myLocShape); + myGen.PrepareCompute( myLocMesh, myLocShape ); + int how = ::SMESH_Gen::COMPACT_MESH; + if ( myLocShape != myLocMesh.GetShapeToMesh() ) // compute a sub-mesh + how |= ::SMESH_Gen::SHAPE_ONLY; + bool ok = myGen.Compute( myLocMesh, myLocShape, how ); meshServant->CreateGroupServants(); // algos can create groups (issue 0020918) myLocMesh.GetMeshDS()->Modified(); return ok; @@ -1740,7 +1961,6 @@ CORBA::Boolean SMESH_Gen_i::Compute( SMESH::SMESH_Mesh_ptr theMesh, void SMESH_Gen_i::CancelCompute( SMESH::SMESH_Mesh_ptr theMesh, GEOM::GEOM_Object_ptr theShapeObject ) { -#ifdef WITH_SMESH_CANCEL_COMPUTE SMESH_Mesh_i* meshServant = dynamic_cast( GetServant( theMesh ).in() ); ::SMESH_Mesh& myLocMesh = meshServant->GetImpl(); TopoDS_Shape myLocShape; @@ -1749,7 +1969,6 @@ void SMESH_Gen_i::CancelCompute( SMESH::SMESH_Mesh_ptr theMesh, else myLocShape = SMESH_Mesh::PseudoShape(); myGen.CancelCompute( myLocMesh, myLocShape); -#endif } //============================================================================= @@ -1785,7 +2004,7 @@ SMESH::MeshPreviewStruct* SMESH_Gen_i::Precompute( SMESH::SMESH_Mesh_ptr theMesh ASSERT( meshServant ); if ( meshServant ) { // NPAL16168: "geometrical group edition from a submesh don't modifiy mesh computation" - meshServant->CheckGeomGroupModif(); + meshServant->CheckGeomModif(); // get local TopoDS_Shape TopoDS_Shape myLocShape; if(theMesh->HasShapeToMesh()) @@ -1797,7 +2016,7 @@ SMESH::MeshPreviewStruct* SMESH_Gen_i::Precompute( SMESH::SMESH_Mesh_ptr theMesh ::SMESH_Mesh& myLocMesh = meshServant->GetImpl(); TSetOfInt shapeIds; ::MeshDimension aDim = (MeshDimension)theDimension; - if ( myGen.Compute( myLocMesh, myLocShape, false, aDim, &shapeIds ) ) + if ( myGen.Compute( myLocMesh, myLocShape, ::SMESH_Gen::COMPACT_MESH, aDim, &shapeIds ) ) { int nbShapeId = shapeIds.size(); theShapesId.length( nbShapeId ); @@ -1980,8 +2199,9 @@ SMESH::long_array* SMESH_Gen_i::Evaluate(SMESH::SMESH_Mesh_ptr theMesh, SMESH_Mesh_i* meshServant = dynamic_cast( GetServant( theMesh ).in() ); ASSERT( meshServant ); if ( meshServant ) { + meshServant->Load(); // NPAL16168: "geometrical group edition from a submesh don't modifiy mesh computation" - meshServant->CheckGeomGroupModif(); + meshServant->CheckGeomModif(); // get local TopoDS_Shape TopoDS_Shape myLocShape; if(theMesh->HasShapeToMesh()) @@ -1995,13 +2215,13 @@ SMESH::long_array* SMESH_Gen_i::Evaluate(SMESH::SMESH_Mesh_ptr theMesh, MapShapeNbElemsItr anIt = aResMap.begin(); for(; anIt!=aResMap.end(); anIt++) { const vector& aVec = (*anIt).second; - for(i = SMESH::Entity_Node; i < aVec.size(); i++) { + for ( i = SMESH::Entity_Node; i < (int)aVec.size(); i++ ) { int nbElem = aVec[i]; if ( nbElem < 0 ) // algo failed, check that it has reported a message { - SMESH_subMesh* sm = anIt->first; + SMESH_subMesh* sm = anIt->first; SMESH_ComputeErrorPtr& error = sm->GetComputeError(); - const SMESH_Algo* algo = myGen.GetAlgo( myLocMesh, sm->GetSubShape()); + const SMESH_Algo* algo = sm->GetAlgo(); if ( (algo && !error.get()) || error->IsOK() ) error.reset( new SMESH_ComputeError( COMPERR_ALGO_FAILED,"Failed to evaluate",algo)); } @@ -2176,10 +2396,11 @@ SMESH_Gen_i::FindGeometryByMeshElement( SMESH::SMESH_Mesh_ptr theMesh, */ //================================================================================ -SMESH::SMESH_Mesh_ptr SMESH_Gen_i::Concatenate(const SMESH::mesh_array& theMeshesArray, - CORBA::Boolean theUniteIdenticalGroups, - CORBA::Boolean theMergeNodesAndElements, - CORBA::Double theMergeTolerance) +SMESH::SMESH_Mesh_ptr +SMESH_Gen_i::Concatenate(const SMESH::ListOfIDSources& theMeshesArray, + CORBA::Boolean theUniteIdenticalGroups, + CORBA::Boolean theMergeNodesAndElements, + CORBA::Double theMergeTolerance) throw ( SALOME::SALOME_Exception ) { return ConcatenateCommon(theMeshesArray, @@ -2199,10 +2420,10 @@ SMESH::SMESH_Mesh_ptr SMESH_Gen_i::Concatenate(const SMESH::mesh_array& theMeshe //================================================================================ SMESH::SMESH_Mesh_ptr -SMESH_Gen_i::ConcatenateWithGroups(const SMESH::mesh_array& theMeshesArray, - CORBA::Boolean theUniteIdenticalGroups, - CORBA::Boolean theMergeNodesAndElements, - CORBA::Double theMergeTolerance) +SMESH_Gen_i::ConcatenateWithGroups(const SMESH::ListOfIDSources& theMeshesArray, + CORBA::Boolean theUniteIdenticalGroups, + CORBA::Boolean theMergeNodesAndElements, + CORBA::Double theMergeTolerance) throw ( SALOME::SALOME_Exception ) { return ConcatenateCommon(theMeshesArray, @@ -2221,17 +2442,15 @@ SMESH_Gen_i::ConcatenateWithGroups(const SMESH::mesh_array& theMeshesArray, //================================================================================ SMESH::SMESH_Mesh_ptr -SMESH_Gen_i::ConcatenateCommon(const SMESH::mesh_array& theMeshesArray, - CORBA::Boolean theUniteIdenticalGroups, - CORBA::Boolean theMergeNodesAndElements, - CORBA::Double theMergeTolerance, - CORBA::Boolean theCommonGroups) +SMESH_Gen_i::ConcatenateCommon(const SMESH::ListOfIDSources& theMeshesArray, + CORBA::Boolean theUniteIdenticalGroups, + CORBA::Boolean theMergeNodesAndElements, + CORBA::Double theMergeTolerance, + CORBA::Boolean theCommonGroups) throw ( SALOME::SALOME_Exception ) { - typedef map TIDsMap; typedef list TListOfNewGroups; typedef map< pair, TListOfNewGroups > TGroupsMap; - typedef std::set TGroups; TPythonDump* pPythonDump = new TPythonDump; TPythonDump& aPythonDump = *pPythonDump; // prevent dump of called methods @@ -2239,303 +2458,248 @@ SMESH_Gen_i::ConcatenateCommon(const SMESH::mesh_array& theMeshesArray, // create mesh SMESH::SMESH_Mesh_var aNewMesh = CreateEmptyMesh(); - SMESHDS_Mesh* aNewMeshDS = 0; - if ( !aNewMesh->_is_nil() ) { - SMESH_Mesh_i* aNewImpl = dynamic_cast( GetServant( aNewMesh ).in() ); - if ( aNewImpl ) { - ::SMESH_Mesh& aLocMesh = aNewImpl->GetImpl(); - aNewMeshDS = aLocMesh.GetMeshDS(); - - TGroupsMap aGroupsMap; - TListOfNewGroups aListOfNewGroups; - SMESH_MeshEditor aNewEditor = ::SMESH_MeshEditor(&aLocMesh); - SMESH::ListOfGroups_var aListOfGroups = new SMESH::ListOfGroups(); - - // loop on meshes - for ( int i = 0; i < theMeshesArray.length(); i++) { - SMESH::SMESH_Mesh_var anInitMesh = theMeshesArray[i]; - if ( !anInitMesh->_is_nil() ) { - SMESH_Mesh_i* anInitImpl = dynamic_cast( GetServant( anInitMesh ).in() ); - if ( anInitImpl ) { - ::SMESH_Mesh& aInitLocMesh = anInitImpl->GetImpl(); - aInitLocMesh.Load(); - SMESHDS_Mesh* anInitMeshDS = aInitLocMesh.GetMeshDS(); - - TIDsMap nodesMap; - TIDsMap elemsMap; - - // loop on elements of mesh - SMDS_ElemIteratorPtr itElems = anInitMeshDS->elementsIterator(); - const SMDS_MeshElement* anElem = 0; - const SMDS_MeshElement* aNewElem = 0; - int anElemNbNodes = 0; - - int anNbNodes = 0; - int anNbEdges = 0; - int anNbFaces = 0; - int anNbVolumes = 0; - int aNbBalls = 0; - - SMESH::long_array_var anIDsNodes = new SMESH::long_array(); - SMESH::long_array_var anIDsEdges = new SMESH::long_array(); - SMESH::long_array_var anIDsFaces = new SMESH::long_array(); - SMESH::long_array_var anIDsVolumes = new SMESH::long_array(); - SMESH::long_array_var anIDsBalls = new SMESH::long_array(); - - if( theCommonGroups ) { - anIDsNodes->length( anInitMeshDS->NbNodes() ); - anIDsEdges->length( anInitMeshDS->NbEdges() ); - anIDsFaces->length( anInitMeshDS->NbFaces() ); - anIDsVolumes->length( anInitMeshDS->NbVolumes() ); - anIDsBalls->length( anInitMeshDS->NbBalls() ); - } + if ( aNewMesh->_is_nil() ) + return aNewMesh._retn(); - for ( int j = 0; itElems->more(); j++) { - anElem = itElems->next(); - SMDSAbs_ElementType anElemType = anElem->GetType(); - anElemNbNodes = anElem->NbNodes(); - std::vector aNodesArray (anElemNbNodes); - - // loop on nodes of element - const SMDS_MeshNode* aNode = 0; - const SMDS_MeshNode* aNewNode = 0; - SMDS_ElemIteratorPtr itNodes = anElem->nodesIterator(); - - for ( int k = 0; itNodes->more(); k++) { - aNode = static_cast(itNodes->next()); - if ( nodesMap.find(aNode->GetID()) == nodesMap.end() ) { - aNewNode = aNewMeshDS->AddNode(aNode->X(), aNode->Y(), aNode->Z()); - nodesMap.insert( make_pair(aNode->GetID(), aNewNode->GetID()) ); - if( theCommonGroups ) - anIDsNodes[anNbNodes++] = aNewNode->GetID(); - } - else - aNewNode = aNewMeshDS->FindNode( nodesMap.find(aNode->GetID())->second ); - aNodesArray[k] = aNewNode; - }//nodes loop - - // creates a corresponding element on existent nodes in new mesh - switch ( anElem->GetEntityType() ) { - case SMDSEntity_Polyhedra: - if ( const SMDS_VtkVolume* aVolume = - dynamic_cast (anElem)) - { - aNewElem = aNewMeshDS->AddPolyhedralVolume(aNodesArray, - aVolume->GetQuantities()); - elemsMap.insert(make_pair(anElem->GetID(), aNewElem->GetID())); - if( theCommonGroups ) - anIDsVolumes[anNbVolumes++] = aNewElem->GetID(); - } - break; - case SMDSEntity_Ball: - if ( const SMDS_BallElement* aBall = - dynamic_cast (anElem)) - { - aNewElem = aNewEditor.AddElement(aNodesArray, SMDSAbs_Ball, - /*isPoly=*/false, /*id=*/0, - aBall->GetDiameter() ); - elemsMap.insert(make_pair(anElem->GetID(), aNewElem->GetID())); - if( theCommonGroups ) - anIDsBalls[aNbBalls++] = aNewElem->GetID(); - } - break; - default: - { - aNewElem = aNewEditor.AddElement(aNodesArray, - anElemType, - anElem->IsPoly()); - elemsMap.insert(make_pair(anElem->GetID(), aNewElem->GetID())); - if( theCommonGroups ) { - if( anElemType == SMDSAbs_Edge ) - anIDsEdges[anNbEdges++] = aNewElem->GetID(); - else if( anElemType == SMDSAbs_Face ) - anIDsFaces[anNbFaces++] = aNewElem->GetID(); - else if( anElemType == SMDSAbs_Volume ) - anIDsVolumes[anNbVolumes++] = aNewElem->GetID(); - } - } - } - } //elems loop + SMESH_Mesh_i* aNewImpl = SMESH::DownCast( aNewMesh ); + if ( !aNewImpl ) + return aNewMesh._retn(); - // copy orphan nodes - SMDS_NodeIteratorPtr itNodes = anInitMeshDS->nodesIterator(); - while ( itNodes->more() ) - { - const SMDS_MeshNode* aNode = itNodes->next(); - if ( aNode->NbInverseElements() == 0 ) - { - const SMDS_MeshNode* aNewNode = - aNewMeshDS->AddNode(aNode->X(), aNode->Y(), aNode->Z()); - nodesMap.insert( make_pair(aNode->GetID(), aNewNode->GetID()) ); - if( theCommonGroups ) - anIDsNodes[anNbNodes++] = aNewNode->GetID(); - } - } + ::SMESH_Mesh& aLocMesh = aNewImpl->GetImpl(); + SMESHDS_Mesh* aNewMeshDS = aLocMesh.GetMeshDS(); + TGroupsMap aGroupsMap; + TListOfNewGroups aListOfNewGroups; + ::SMESH_MeshEditor aNewEditor(&aLocMesh); + SMESH::ListOfGroups_var aListOfGroups; - aListOfGroups = anInitImpl->GetGroups(); - SMESH::SMESH_GroupBase_ptr aGroup; + ::SMESH_MeshEditor::ElemFeatures elemType; + std::vector aNodesArray; - // loop on groups of mesh - SMESH::long_array_var anInitIDs = new SMESH::long_array(); - SMESH::long_array_var anNewIDs = new SMESH::long_array(); - SMESH::SMESH_Group_var aNewGroup; + // loop on sub-meshes + for ( CORBA::ULong i = 0; i < theMeshesArray.length(); i++) + { + if ( CORBA::is_nil( theMeshesArray[i] )) continue; + SMESH::SMESH_Mesh_var anInitMesh = theMeshesArray[i]->GetMesh(); + if ( anInitMesh->_is_nil() ) continue; + SMESH_Mesh_i* anInitImpl = SMESH::DownCast( anInitMesh ); + if ( !anInitImpl ) continue; + anInitImpl->Load(); + + //::SMESH_Mesh& aInitLocMesh = anInitImpl->GetImpl(); + //SMESHDS_Mesh* anInitMeshDS = aInitLocMesh.GetMeshDS(); + + // remember nb of elements before filling in + SMESH::long_array_var prevState = aNewMesh->GetNbElementsByType(); + + typedef std::map TEEMap; + TEEMap elemsMap, nodesMap; + + // loop on elements of a sub-mesh + SMDS_ElemIteratorPtr itElems = anInitImpl->GetElements( theMeshesArray[i], SMESH::ALL ); + const SMDS_MeshElement* anElem; + const SMDS_MeshElement* aNewElem; + const SMDS_MeshNode* aNode; + const SMDS_MeshNode* aNewNode; + int anElemNbNodes; + + while ( itElems->more() ) + { + anElem = itElems->next(); + anElemNbNodes = anElem->NbNodes(); + aNodesArray.resize( anElemNbNodes ); - SMESH::ElementType aGroupType; - CORBA::String_var aGroupName; - if ( theCommonGroups ) { - for(aGroupType=SMESH::NODE;aGroupType<=SMESH::BALL;aGroupType=(SMESH::ElementType)(aGroupType+1)) { - string str = "Gr"; - SALOMEDS::SObject_wrap aMeshSObj = ObjectToSObject( myCurrentStudy, anInitMesh ); - if(aMeshSObj) - str += aMeshSObj->GetName(); - str += "_"; + // loop on nodes of an element + SMDS_ElemIteratorPtr itNodes = anElem->nodesIterator(); + for ( int k = 0; itNodes->more(); k++) + { + aNode = static_cast( itNodes->next() ); + TEEMap::iterator n2nnIt = nodesMap.find( aNode ); + if ( n2nnIt == nodesMap.end() ) + { + aNewNode = aNewMeshDS->AddNode(aNode->X(), aNode->Y(), aNode->Z()); + nodesMap.insert( make_pair( aNode, aNewNode )); + } + else + { + aNewNode = static_cast( n2nnIt->second ); + } + aNodesArray[k] = aNewNode; + } - int anLen = 0; + // creates a corresponding element on existent nodes in new mesh + if ( anElem->GetType() == SMDSAbs_Node ) + aNewElem = 0; + else + aNewElem = + aNewEditor.AddElement( aNodesArray, elemType.Init( anElem, /*basicOnly=*/false )); - switch(aGroupType) { - case SMESH::NODE: - str += "Nodes"; - anIDsNodes->length(anNbNodes); - anLen = anNbNodes; - break; - case SMESH::EDGE: - str += "Edges"; - anIDsEdges->length(anNbEdges); - anLen = anNbEdges; - break; - case SMESH::FACE: - str += "Faces"; - anIDsFaces->length(anNbFaces); - anLen = anNbFaces; - break; - case SMESH::VOLUME: - str += "Volumes"; - anIDsVolumes->length(anNbVolumes); - anLen = anNbVolumes; - break; - case SMESH::BALL: - str += "Balls"; - anIDsBalls->length(aNbBalls); - anLen = aNbBalls; - break; - default: - break; - } + if ( aNewElem ) + elemsMap.insert( make_pair( anElem, aNewElem )); - if(anLen) { - aGroupName = str.c_str(); + } //elems loop - // add a new group in the mesh - aNewGroup = aNewImpl->CreateGroup(aGroupType, aGroupName); + aNewEditor.ClearLastCreated(); // forget the history - switch(aGroupType) { - case SMESH::NODE: - aNewGroup->Add( anIDsNodes ); - break; - case SMESH::EDGE: - aNewGroup->Add( anIDsEdges ); - break; - case SMESH::FACE: - aNewGroup->Add( anIDsFaces ); - break; - case SMESH::VOLUME: - aNewGroup->Add( anIDsVolumes ); - break; - case SMESH::BALL: - aNewGroup->Add( anIDsBalls ); - break; - default: - break; - } - aListOfNewGroups.clear(); - aListOfNewGroups.push_back(aNewGroup); - aGroupsMap.insert(make_pair( make_pair(aGroupName, aGroupType), aListOfNewGroups )); - } + // create groups of just added elements + SMESH::SMESH_Group_var aNewGroup; + SMESH::ElementType aGroupType; + if ( theCommonGroups ) + { + SMESH::long_array_var curState = aNewMesh->GetNbElementsByType(); + + for( aGroupType = SMESH::NODE; + aGroupType < SMESH::NB_ELEMENT_TYPES; + aGroupType = (SMESH::ElementType)( aGroupType + 1 )) + { + if ( curState[ aGroupType ] <= prevState[ aGroupType ]) + continue; + + // make a group name + const char* typeNames[] = { "All","Nodes","Edges","Faces","Volumes","0DElems","Balls" }; + { // check of typeNames: compilation failure mains that NB_ELEMENT_TYPES changed: + const int nbNames = sizeof(typeNames) / sizeof(const char*); + int _assert[( nbNames == SMESH::NB_ELEMENT_TYPES ) ? 2 : -1 ]; _assert[0]=_assert[1]; + } + string groupName = "Gr"; + SALOMEDS::SObject_wrap aMeshSObj = ObjectToSObject( myCurrentStudy, theMeshesArray[i] ); + if ( aMeshSObj ) { + CORBA::String_var name = aMeshSObj->GetName(); + groupName += name; + } + groupName += "_"; + groupName += typeNames[ aGroupType ]; + + // make and fill a group + TEEMap & e2neMap = ( aGroupType == SMESH::NODE ) ? nodesMap : elemsMap; + aNewGroup = aNewImpl->CreateGroup( aGroupType, groupName.c_str() ); + if ( SMESH_Group_i* grp_i = SMESH::DownCast( aNewGroup )) + { + if ( SMESHDS_Group* grpDS = dynamic_cast( grp_i->GetGroupDS() )) + { + TEEMap::iterator e2neIt = e2neMap.begin(); + for ( ; e2neIt != e2neMap.end(); ++e2neIt ) + { + aNewElem = e2neIt->second; + if ( aNewElem->GetType() == grpDS->GetType() ) + { + grpDS->Add( aNewElem ); + + if ( prevState[ aGroupType ]++ >= curState[ aGroupType ] ) + break; } } + } + } + aListOfNewGroups.clear(); + aListOfNewGroups.push_back(aNewGroup); + aGroupsMap.insert(make_pair( make_pair(groupName, aGroupType), aListOfNewGroups )); + } + } - // check that current group name and type don't have identical ones in union mesh - for (int iG = 0; iG < aListOfGroups->length(); iG++) { - aGroup = aListOfGroups[iG]; - aListOfNewGroups.clear(); - aGroupType = aGroup->GetType(); - aGroupName = aGroup->GetName(); - - TGroupsMap::iterator anIter = aGroupsMap.find(make_pair(aGroupName, aGroupType)); - - // convert a list of IDs - anInitIDs = aGroup->GetListOfID(); - anNewIDs->length(anInitIDs->length()); - if ( aGroupType == SMESH::NODE ) - for (int j = 0; j < anInitIDs->length(); j++) { - anNewIDs[j] = nodesMap.find(anInitIDs[j])->second; - } - else - for (int j = 0; j < anInitIDs->length(); j++) { - anNewIDs[j] = elemsMap.find(anInitIDs[j])->second; - } + if ( SMESH_Mesh_i* anSrcImpl = SMESH::DownCast( theMeshesArray[i] )) + { + // copy orphan nodes + if ( anSrcImpl->NbNodes() > (int)nodesMap.size() ) + { + SMDS_ElemIteratorPtr itNodes = anInitImpl->GetElements( theMeshesArray[i], SMESH::NODE ); + while ( itNodes->more() ) + { + const SMDS_MeshNode* aNode = static_cast< const SMDS_MeshNode* >( itNodes->next() ); + if ( aNode->NbInverseElements() == 0 ) + { + aNewNode = aNewMeshDS->AddNode(aNode->X(), aNode->Y(), aNode->Z()); + nodesMap.insert( make_pair( aNode, aNewNode )); + } + } + } - // check that current group name and type don't have identical ones in union mesh - if ( anIter == aGroupsMap.end() ) { - // add a new group in the mesh - aNewGroup = aNewImpl->CreateGroup(aGroupType, aGroupName); - // add elements into new group - aNewGroup->Add( anNewIDs ); + // copy groups - aListOfNewGroups.push_back(aNewGroup); - aGroupsMap.insert(make_pair( make_pair(aGroupName, aGroupType), aListOfNewGroups )); - } + SMESH::SMESH_GroupBase_ptr aGroup; + CORBA::String_var aGroupName; + SMESH::long_array_var anNewIDs = new SMESH::long_array(); - else if ( theUniteIdenticalGroups ) { - // unite identical groups - TListOfNewGroups& aNewGroups = anIter->second; - aNewGroups.front()->Add( anNewIDs ); - } + // loop on groups of a source mesh + aListOfGroups = anSrcImpl->GetGroups(); + for ( CORBA::ULong iG = 0; iG < aListOfGroups->length(); iG++ ) + { + aGroup = aListOfGroups[iG]; + aGroupType = aGroup->GetType(); + aGroupName = aGroup->GetName(); + string aName = aGroupName.in(); + + // convert a list of IDs + anNewIDs->length( aGroup->Size() ); + TEEMap & e2neMap = ( aGroupType == SMESH::NODE ) ? nodesMap : elemsMap; + SMDS_ElemIteratorPtr itGrElems = anSrcImpl->GetElements( aGroup, SMESH::ALL ); + int iElem = 0; + while ( itGrElems->more() ) + { + anElem = itGrElems->next(); + TEEMap::iterator e2neIt = e2neMap.find( anElem ); + if ( e2neIt != e2neMap.end() ) + anNewIDs[ iElem++ ] = e2neIt->second->GetID(); + } + anNewIDs->length( iElem ); + + // check a current group name and type don't have identical ones in final mesh + aListOfNewGroups.clear(); + TGroupsMap::iterator anIter = aGroupsMap.find( make_pair( aName, aGroupType )); + if ( anIter == aGroupsMap.end() ) { + // add a new group in the mesh + aNewGroup = aNewImpl->CreateGroup( aGroupType, aGroupName.in() ); + // add elements into new group + aNewGroup->Add( anNewIDs ); + + aListOfNewGroups.push_back(aNewGroup); + aGroupsMap.insert(make_pair( make_pair(aName, aGroupType), aListOfNewGroups )); + } - else { - // rename identical groups - aNewGroup = aNewImpl->CreateGroup(aGroupType, aGroupName); - aNewGroup->Add( anNewIDs ); + else if ( theUniteIdenticalGroups ) { + // unite identical groups + TListOfNewGroups& aNewGroups = anIter->second; + aNewGroups.front()->Add( anNewIDs ); + } - TListOfNewGroups& aNewGroups = anIter->second; - string aNewGroupName; - if (aNewGroups.size() == 1) { - aNewGroupName = string(aGroupName) + "_1"; - aNewGroups.front()->SetName(aNewGroupName.c_str()); - } - char aGroupNum[128]; - sprintf(aGroupNum, "%u", aNewGroups.size()+1); - aNewGroupName = string(aGroupName) + "_" + string(aGroupNum); - aNewGroup->SetName(aNewGroupName.c_str()); - aNewGroups.push_back(aNewGroup); - } - }//groups loop + else { + // rename identical groups + aNewGroup = aNewImpl->CreateGroup(aGroupType, aGroupName.in()); + aNewGroup->Add( anNewIDs ); + + TListOfNewGroups& aNewGroups = anIter->second; + string aNewGroupName; + if (aNewGroups.size() == 1) { + aNewGroupName = aName + "_1"; + aNewGroups.front()->SetName(aNewGroupName.c_str()); } + char aGroupNum[128]; + sprintf(aGroupNum, "%u", (unsigned int)aNewGroups.size()+1); + aNewGroupName = aName + "_" + string(aGroupNum); + aNewGroup->SetName(aNewGroupName.c_str()); + aNewGroups.push_back(aNewGroup); } - }//meshes loop - - if (theMergeNodesAndElements) { - // merge nodes - TIDSortedNodeSet aMeshNodes; // no input nodes - SMESH_MeshEditor::TListOfListOfNodes aGroupsOfNodes; - aNewEditor.FindCoincidentNodes( aMeshNodes, theMergeTolerance, aGroupsOfNodes ); - aNewEditor.MergeNodes( aGroupsOfNodes ); - // merge elements - aNewEditor.MergeEqualElements(); - } - } + } //groups loop + } // if an IDSource is a mesh + } //meshes loop + + if (theMergeNodesAndElements) // merge nodes + { + TIDSortedNodeSet aMeshNodes; // no input nodes + SMESH_MeshEditor::TListOfListOfNodes aGroupsOfNodes; + aNewEditor.FindCoincidentNodes( aMeshNodes, theMergeTolerance, aGroupsOfNodes, + /*SeparateCornersAndMedium=*/ false ); + aNewEditor.MergeNodes( aGroupsOfNodes ); + // merge elements + aNewEditor.MergeEqualElements(); } // Update Python script - aPythonDump << aNewMesh << " = " << this; - if( !theCommonGroups ) - aPythonDump << ".Concatenate("; - else - aPythonDump << ".ConcatenateWithGroups("; - aPythonDump << "["; - for ( int i = 0; i < theMeshesArray.length(); i++) { + aPythonDump << aNewMesh << " = " << this << "." + << ( theCommonGroups ? "ConcatenateWithGroups" : "Concatenate" ) + << "(["; + for ( CORBA::ULong i = 0; i < theMeshesArray.length(); i++) { if (i > 0) aPythonDump << ", "; aPythonDump << theMeshesArray[i]; } @@ -2558,6 +2722,7 @@ SMESH_Gen_i::ConcatenateCommon(const SMESH::mesh_array& theMeshesArray, if (aNewMeshDS) aNewMeshDS->Modified(); + return aNewMesh._retn(); } @@ -2607,6 +2772,7 @@ SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CopyMesh(SMESH::SMESH_IDSource_ptr meshPart, } SMESHDS_Mesh* newMeshDS = newMesh_i->GetImpl().GetMeshDS(); ::SMESH_MeshEditor editor( &newMesh_i->GetImpl() ); + ::SMESH_MeshEditor::ElemFeatures elemType; // 3. Get elements to copy @@ -2615,6 +2781,7 @@ SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CopyMesh(SMESH::SMESH_IDSource_ptr meshPart, SMESH::array_of_ElementType_var srcElemTypes = meshPart->GetTypes(); if ( SMESH::DownCast( meshPart )) { + srcMesh_i->Load(); srcElemIt = srcMeshDS->elementsIterator(); srcNodeIt = srcMeshDS->nodesIterator(); } @@ -2623,13 +2790,13 @@ SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CopyMesh(SMESH::SMESH_IDSource_ptr meshPart, SMESH::long_array_var ids = meshPart->GetIDs(); if ( srcElemTypes->length() == 1 && srcElemTypes[0] == SMESH::NODE ) // group of nodes { - for (int i=0; i < ids->length(); i++) + for ( CORBA::ULong i=0; i < ids->length(); i++ ) if ( const SMDS_MeshElement * elem = srcMeshDS->FindNode( ids[i] )) srcElems.insert( elem ); } else { - for (int i=0; i < ids->length(); i++) + for ( CORBA::ULong i = 0; i < ids->length(); i++ ) if ( const SMDS_MeshElement * elem = srcMeshDS->FindElement( ids[i] )) srcElems.insert( elem ); } @@ -2677,25 +2844,12 @@ SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CopyMesh(SMESH::SMESH_IDSource_ptr meshPart, // add elements if ( elem->GetType() != SMDSAbs_Node ) { - int ID = toKeepIDs ? elem->GetID() : 0; - const SMDS_MeshElement * newElem; - switch ( elem->GetEntityType() ) { - case SMDSEntity_Polyhedra: - newElem = editor.GetMeshDS()-> - AddPolyhedralVolumeWithID( nodes, - static_cast(elem)->GetQuantities(), - ID); - break; - case SMDSEntity_Ball: - newElem = editor.AddElement( nodes, SMDSAbs_Ball, false, ID, - static_cast(elem)->GetDiameter()); - break; - default: - newElem = editor.AddElement( nodes,elem->GetType(),elem->IsPoly(),ID); + elemType.Init( elem, /*basicOnly=*/false ); + if ( toKeepIDs ) elemType.SetID( elem->GetID() ); + const SMDS_MeshElement * newElem = editor.AddElement( nodes, elemType ); if ( toCopyGroups && !toKeepIDs ) e2eMapByType[ elem->GetType() ].insert( make_pair( elem, newElem )); - } } } // while ( srcElemIt->more() ) @@ -2855,13 +3009,10 @@ SALOMEDS::TMPFile* SMESH_Gen_i::Save( SALOMEDS::SComponent_ptr theComponent, const char* theURL, bool isMultiFile ) { - INFOS( "SMESH_Gen_i::Save" ); - // ASSERT( theComponent->GetStudy()->StudyId() == myCurrentStudy->StudyId() ) // san -- in case differs from theComponent's study, // use that of the component - if ( myCurrentStudy->_is_nil() || - theComponent->GetStudy()->StudyId() != myCurrentStudy->StudyId() ) + if ( theComponent->GetStudy()->StudyId() != GetCurrentStudyID() ) SetCurrentStudy( theComponent->GetStudy() ); // Store study contents as a set of python commands @@ -2904,7 +3055,7 @@ SALOMEDS::TMPFile* SMESH_Gen_i::Save( SALOMEDS::SComponent_ptr theComponent, //Remove the files if they exist: BugID: 11225 -#ifndef WNT /* unix functionality */ +#ifndef WIN32 /* unix functionality */ TCollection_AsciiString cmd("rm -f \""); #else /* windows */ TCollection_AsciiString cmd("del /F \""); @@ -2936,7 +3087,7 @@ SALOMEDS::TMPFile* SMESH_Gen_i::Save( SALOMEDS::SComponent_ptr theComponent, TPythonDump pd; // not to dump GetGroups() SMESH::ListOfGroups_var groups = myMesh->GetGroups(); pd << ""; // to avoid optimizing pd out - for ( int i = 0; i < groups->length(); ++i ) + for ( CORBA::ULong i = 0; i < groups->length(); ++i ) { SMESH_GroupBase_i* grImpl = SMESH::DownCast( groups[i]); if ( grImpl ) @@ -2985,9 +3136,9 @@ SALOMEDS::TMPFile* SMESH_Gen_i::Save( SALOMEDS::SComponent_ptr theComponent, string libname = string( myHyp->GetLibName() ); // BUG SWP13062 // Needs for save crossplatform libname, i.e. parth of name ( ".dll" for - // WNT and ".so" for X-system) must be deleted + // WIN32 and ".so" for X-system) must be deleted int libname_len = libname.length(); -#ifdef WNT +#ifdef WIN32 if( libname_len > 4 ) libname.resize( libname_len - 4 ); #else @@ -3054,9 +3205,9 @@ SALOMEDS::TMPFile* SMESH_Gen_i::Save( SALOMEDS::SComponent_ptr theComponent, string libname = string( myHyp->GetLibName() ); // BUG SWP13062 // Needs for save crossplatform libname, i.e. parth of name ( ".dll" for - // WNT and ".so" for X-system) must be deleted + // WIN32 and ".so" for X-system) must be deleted int libname_len = libname.length(); -#ifdef WNT +#ifdef WIN32 if( libname_len > 4 ) libname.resize( libname_len - 4 ); #else @@ -3582,7 +3733,7 @@ SALOMEDS::TMPFile* SMESH_Gen_i::Save( SALOMEDS::SComponent_ptr theComponent, myWriter.AddGroup( aGeomGrp ); } } - else if ( SMESH_GroupOnFilter_i* aFilterGrp_i = + else if ( SMESH_GroupOnFilter_i* aFilterGrp_i = dynamic_cast( myGroupImpl )) { std::string str = aFilterGrp_i->FilterToString(); @@ -3613,7 +3764,8 @@ SALOMEDS::TMPFile* SMESH_Gen_i::Save( SALOMEDS::SComponent_ptr theComponent, myLocMesh.ShapeToMesh( nullShape ); // remove shape referring data } - if ( !mySMESHDSMesh->SubMeshes().empty() ) + SMESHDS_SubMeshIteratorPtr smIt = mySMESHDSMesh->SubMeshes(); + if ( smIt->more() ) { // Store submeshes // ---------------- @@ -3623,64 +3775,25 @@ SALOMEDS::TMPFile* SMESH_Gen_i::Save( SALOMEDS::SComponent_ptr theComponent, // each element belongs to one or none submesh, // so for each node/element, we store a submesh ID - // Make maps of submesh IDs of elements sorted by element IDs - typedef int TElemID; - typedef int TSubMID; - map< TElemID, TSubMID > eId2smId, nId2smId; - map< TElemID, TSubMID >::iterator hint; // insertion to map is done before hint - const map& aSubMeshes = mySMESHDSMesh->SubMeshes(); - map::const_iterator itSubM ( aSubMeshes.begin() ); - SMDS_NodeIteratorPtr itNode; - SMDS_ElemIteratorPtr itElem; - for ( itSubM = aSubMeshes.begin(); itSubM != aSubMeshes.end() ; itSubM++ ) - { - TSubMID aSubMeID = itSubM->first; - SMESHDS_SubMesh* aSubMesh = itSubM->second; - if ( aSubMesh->IsComplexSubmesh() ) - continue; // submesh containing other submeshs - // nodes - hint = nId2smId.begin(); // optimize insertion basing on increasing order of elem Ids in submesh - for ( itNode = aSubMesh->GetNodes(); itNode->more(); ++hint) - hint = nId2smId.insert( hint, make_pair( itNode->next()->GetID(), aSubMeID )); - // elements - hint = eId2smId.begin(); - for ( itElem = aSubMesh->GetElements(); itElem->more(); ++hint) - hint = eId2smId.insert( hint, make_pair( itElem->next()->GetID(), aSubMeID )); - } - - // Care of elements that are not on submeshes - if ( mySMESHDSMesh->NbNodes() != nId2smId.size() ) { - for ( itNode = mySMESHDSMesh->nodesIterator(); itNode->more(); ) - /* --- stl_map.h says : */ - /* A %map relies on unique keys and thus a %pair is only inserted if its */ - /* first element (the key) is not already present in the %map. */ - nId2smId.insert( make_pair( itNode->next()->GetID(), 0 )); - } - int nbElems = mySMESHDSMesh->NbEdges() + mySMESHDSMesh->NbFaces() + mySMESHDSMesh->NbVolumes(); - if ( nbElems != eId2smId.size() ) { - for ( itElem = mySMESHDSMesh->elementsIterator(); itElem->more(); ) - eId2smId.insert( make_pair( itElem->next()->GetID(), 0 )); - } - // Store submesh IDs for ( int isNode = 0; isNode < 2; ++isNode ) { - map< TElemID, TSubMID >& id2smId = isNode ? nId2smId : eId2smId; - if ( id2smId.empty() ) continue; - map< TElemID, TSubMID >::const_iterator id_smId = id2smId.begin(); - // make and fill array of submesh IDs - int* smIDs = new int [ id2smId.size() ]; - for ( int i = 0; id_smId != id2smId.end(); ++id_smId, ++i ) - smIDs[ i ] = id_smId->second; + SMDS_ElemIteratorPtr eIt = + mySMESHDSMesh->elementsIterator( isNode ? SMDSAbs_Node : SMDSAbs_All ); + int nbElems = isNode ? mySMESHDSMesh->NbNodes() : mySMESHDSMesh->GetMeshInfo().NbElements(); + if ( nbElems < 1 ) + continue; + std::vector smIDs; smIDs.reserve( nbElems ); + while ( eIt->more() ) + if ( const SMDS_MeshElement* e = eIt->next()) + smIDs.push_back( e->getshapeId() ); // write HDF group - aSize[ 0 ] = id2smId.size(); + aSize[ 0 ] = nbElems; string aDSName( isNode ? "Node Submeshes" : "Element Submeshes"); aDataset = new HDFdataset( (char*)aDSName.c_str(), aGroup, HDF_INT32, aSize, 1 ); aDataset->CreateOnDisk(); - aDataset->WriteOnDisk( smIDs ); + aDataset->WriteOnDisk( & smIDs[0] ); aDataset->CloseOnDisk(); - // - delete[] smIDs; } aGroup->CloseOnDisk(); @@ -3703,15 +3816,15 @@ SALOMEDS::TMPFile* SMESH_Gen_i::Save( SALOMEDS::SComponent_ptr theComponent, int nbEdgeNodes = 0, nbFaceNodes = 0; list aEdgeSM, aFaceSM; // loop on SMESHDS_SubMesh'es - for ( itSubM = aSubMeshes.begin(); itSubM != aSubMeshes.end() ; itSubM++ ) + while ( smIt->more() ) { - SMESHDS_SubMesh* aSubMesh = (*itSubM).second; + SMESHDS_SubMesh* aSubMesh = const_cast< SMESHDS_SubMesh* >( smIt->next() ); if ( aSubMesh->IsComplexSubmesh() ) continue; // submesh containing other submeshs int nbNodes = aSubMesh->NbNodes(); if ( nbNodes == 0 ) continue; - int aShapeID = (*itSubM).first; + int aShapeID = aSubMesh->GetID(); if ( aShapeID < 1 || aShapeID > mySMESHDSMesh->MaxShapeIndex() ) continue; int aShapeType = mySMESHDSMesh->IndexToShape( aShapeID ).ShapeType(); @@ -3837,7 +3950,6 @@ SALOMEDS::TMPFile* SMESH_Gen_i::Save( SALOMEDS::SComponent_ptr theComponent, if ( !isMultiFile ) SALOMEDS_Tool::RemoveTemporaryFiles( tmpDir.ToCString(), aFileSeq.in(), true ); - INFOS( "SMESH_Gen_i::Save() completed" ); return aStreamFile._retn(); } @@ -3904,10 +4016,7 @@ bool SMESH_Gen_i::Load( SALOMEDS::SComponent_ptr theComponent, const char* theURL, bool isMultiFile ) { - INFOS( "SMESH_Gen_i::Load" ); - - if ( myCurrentStudy->_is_nil() || - theComponent->GetStudy()->StudyId() != myCurrentStudy->StudyId() ) + if ( theComponent->GetStudy()->StudyId() != GetCurrentStudyID() ) SetCurrentStudy( theComponent->GetStudy() ); /* if( !theComponent->_is_nil() ) @@ -3921,24 +4030,20 @@ bool SMESH_Gen_i::Load( SALOMEDS::SComponent_ptr theComponent, // Get temporary files location TCollection_AsciiString tmpDir = - isMultiFile ? TCollection_AsciiString( ( char* )theURL ) : ( char* )SALOMEDS_Tool::GetTmpDir().c_str(); - - INFOS( "THE URL++++++++++++++" ); - INFOS( theURL ); - INFOS( "THE TMP PATH+++++++++" ); - INFOS( tmpDir ); + ( char* )( isMultiFile ? theURL : SALOMEDS_Tool::GetTmpDir().c_str() ); // Convert the stream into sequence of files to process SALOMEDS::ListOfFileNames_var aFileSeq = SALOMEDS_Tool::PutStreamToFiles( theStream, tmpDir.ToCString(), isMultiFile ); TCollection_AsciiString aStudyName( "" ); - if ( isMultiFile ) - aStudyName = ( (char*)SALOMEDS_Tool::GetNameFromPath( myCurrentStudy->URL() ).c_str() ); - + if ( isMultiFile ) { + CORBA::String_var url = myCurrentStudy->URL(); + aStudyName = (char*)SALOMEDS_Tool::GetNameFromPath( url.in() ).c_str(); + } // Set names of temporary files - TCollection_AsciiString filename = tmpDir + aStudyName + TCollection_AsciiString( "_SMESH.hdf" ); - TCollection_AsciiString meshfile = tmpDir + aStudyName + TCollection_AsciiString( "_SMESH_Mesh.med" ); + TCollection_AsciiString filename = tmpDir + aStudyName + "_SMESH.hdf"; + TCollection_AsciiString meshfile = tmpDir + aStudyName + "_SMESH_Mesh.med"; int size; HDFfile* aFile; @@ -3976,6 +4081,7 @@ bool SMESH_Gen_i::Load( SALOMEDS::SComponent_ptr theComponent, list< pair< SMESH_Hypothesis_i*, string > > hypDataList; list< pair< SMESH_Mesh_i*, HDFgroup* > > meshGroupList; + list< SMESH::Filter_var > filters; // get total number of top-level groups int aNbGroups = aFile->nInternalObjects(); @@ -4394,21 +4500,21 @@ bool SMESH_Gen_i::Load( SALOMEDS::SComponent_ptr theComponent, // --> try to find SUB-MESHES containers for each type of submesh for ( int j = GetSubMeshOnVertexTag(); j <= GetSubMeshOnCompoundTag(); j++ ) { - char name_meshgroup[ 30 ]; + const char* name_meshgroup = 0; if ( j == GetSubMeshOnVertexTag() ) - strcpy( name_meshgroup, "SubMeshes On Vertex" ); + name_meshgroup = "SubMeshes On Vertex"; else if ( j == GetSubMeshOnEdgeTag() ) - strcpy( name_meshgroup, "SubMeshes On Edge" ); + name_meshgroup = "SubMeshes On Edge"; else if ( j == GetSubMeshOnWireTag() ) - strcpy( name_meshgroup, "SubMeshes On Wire" ); + name_meshgroup = "SubMeshes On Wire"; else if ( j == GetSubMeshOnFaceTag() ) - strcpy( name_meshgroup, "SubMeshes On Face" ); + name_meshgroup = "SubMeshes On Face"; else if ( j == GetSubMeshOnShellTag() ) - strcpy( name_meshgroup, "SubMeshes On Shell" ); + name_meshgroup = "SubMeshes On Shell"; else if ( j == GetSubMeshOnSolidTag() ) - strcpy( name_meshgroup, "SubMeshes On Solid" ); + name_meshgroup = "SubMeshes On Solid"; else if ( j == GetSubMeshOnCompoundTag() ) - strcpy( name_meshgroup, "SubMeshes On Compound" ); + name_meshgroup = "SubMeshes On Compound"; // try to get submeshes container HDF group if ( aTopGroup->ExistInternalObject( name_meshgroup ) ) { @@ -4422,9 +4528,9 @@ bool SMESH_Gen_i::Load( SALOMEDS::SComponent_ptr theComponent, // identify submesh char name_submeshgroup[ HDF_NAME_MAX_LEN+1 ]; aGroup->InternalObjectIndentify( k, name_submeshgroup ); - if ( string( name_submeshgroup ).substr( 0, 7 ) == string( "SubMesh" ) ) { + if ( strncmp( name_submeshgroup, "SubMesh", 7 ) == 0 ) { // --> get submesh id - int subid = atoi( string( name_submeshgroup ).substr( 7 ).c_str() ); + int subid = atoi( name_submeshgroup + 7 ); if ( subid <= 0 ) continue; // open submesh HDF group @@ -4474,7 +4580,7 @@ bool SMESH_Gen_i::Load( SALOMEDS::SComponent_ptr theComponent, char name_dataset[ HDF_NAME_MAX_LEN+1 ]; aSubSubGroup->InternalObjectIndentify( l, name_dataset ); // check if it is an algorithm - if ( string( name_dataset ).substr( 0, 4 ) == string( "Algo" ) ) { + if ( strncmp( name_dataset, "Algo", 4 ) == 0 ) { aDataset = new HDFdataset( name_dataset, aSubSubGroup ); aDataset->OpenOnDisk(); size = aDataset->GetSize(); @@ -4618,6 +4724,7 @@ bool SMESH_Gen_i::Load( SALOMEDS::SComponent_ptr theComponent, if ( strlen( persistStr ) > 0 ) { filter = SMESH_GroupOnFilter_i::StringToFilter( persistStr ); predicate = SMESH_GroupOnFilter_i::GetPredicate( filter ); + filters.push_back( filter ); } } @@ -4639,8 +4746,10 @@ bool SMESH_Gen_i::Load( SALOMEDS::SComponent_ptr theComponent, if ( SMESH_GroupOnFilter_i* aFilterGroup = dynamic_cast< SMESH_GroupOnFilter_i*>( aGroupImpl )) + { aFilterGroup->SetFilter( filter ); - + filter->UnRegister(); + } SMESHDS_GroupBase* aGroupBaseDS = aGroupImpl->GetGroupDS(); if ( !aGroupBaseDS ) continue; @@ -4662,11 +4771,6 @@ bool SMESH_Gen_i::Load( SALOMEDS::SComponent_ptr theComponent, Quantity_Color aColor( anRGB[0], anRGB[1], anRGB[2], Quantity_TOC_RGB ); aGroupBaseDS->SetColor( aColor ); } - - // Fill group with contents from MED file - // SMESHDS_Group* aGrp = dynamic_cast( aGroupBaseDS ); - // if ( aGrp ) - // myReader.GetGroup( aGrp ); } } aGroup->CloseOnDisk(); @@ -4725,6 +4829,13 @@ bool SMESH_Gen_i::Load( SALOMEDS::SComponent_ptr theComponent, ComputeStateEngine (SMESH_subMesh::SUBMESH_RESTORED); } + // let filters detect dependency on mesh groups via FT_BelongToMeshGroup predicate (22877) + list< SMESH::Filter_var >::iterator f = filters.begin(); + for ( ; f != filters.end(); ++f ) + if ( SMESH::Filter_i * fi = SMESH::DownCast< SMESH::Filter_i*>( *f )) + fi->FindBaseObjects(); + + // close mesh group if(aTopGroup) aTopGroup->CloseOnDisk(); @@ -4754,7 +4865,19 @@ bool SMESH_Gen_i::Load( SALOMEDS::SComponent_ptr theComponent, } pd << ""; // prevent optimizing pd out - INFOS( "SMESH_Gen_i::Load completed" ); + // creation of tree nodes for all data objects in the study + // to support tree representation customization and drag-n-drop: + SALOMEDS::Study_var study = theComponent->GetStudy(); + SALOMEDS::UseCaseBuilder_wrap useCaseBuilder = study->GetUseCaseBuilder(); + if ( !useCaseBuilder->IsUseCaseNode( theComponent ) ) { + useCaseBuilder->SetRootCurrent(); + useCaseBuilder->Append( theComponent ); // component object is added as the top level item + SALOMEDS::ChildIterator_wrap it = study->NewChildIterator( theComponent ); + for (it->InitEx(true); it->More(); it->Next()) { + useCaseBuilder->AppendTo( it->Value()->GetFather(), it->Value() ); + } + } + return true; } @@ -4784,7 +4907,7 @@ bool SMESH_Gen_i::LoadASCII( SALOMEDS::SComponent_ptr theComponent, _CORBA_Octet* buffer = new _CORBA_Octet[real_size]; char tmp[3]; tmp[2]='\0'; - int c = -1; + unsigned int c = -1; for ( int i = 0; i < real_size; i++ ) { memcpy( &(tmp[0]), &(theStream[i*3+1]), 2 ); @@ -4961,6 +5084,274 @@ char* SMESH_Gen_i::getVersion() #endif } +//================================================================================= +// function : Move() +// purpose : Moves objects to the specified position. +// Is used in the drag-n-drop functionality. +//================================================================================= +void SMESH_Gen_i::Move( const SMESH::sobject_list& what, + SALOMEDS::SObject_ptr where, + CORBA::Long row ) +{ + if ( CORBA::is_nil( where ) ) return; + + SALOMEDS::Study_var study = where->GetStudy(); + SALOMEDS::StudyBuilder_var studyBuilder = study->NewBuilder(); + SALOMEDS::UseCaseBuilder_var useCaseBuilder = study->GetUseCaseBuilder(); + SALOMEDS::SComponent_var father = where->GetFatherComponent(); + std::string dataType = father->ComponentDataType(); + if ( dataType != "SMESH" ) return; // not a SMESH component + + SALOMEDS::SObject_var objAfter; + if ( row >= 0 && useCaseBuilder->HasChildren( where ) ) { + // insert at given row -> find insertion position + SALOMEDS::UseCaseIterator_var useCaseIt = useCaseBuilder->GetUseCaseIterator( where ); + int i; + for ( i = 0; i < row && useCaseIt->More(); i++, useCaseIt->Next() ); + if ( i == row && useCaseIt->More() ) { + objAfter = useCaseIt->Value(); + } + } + + for ( CORBA::ULong i = 0; i < what.length(); i++ ) { + SALOMEDS::SObject_var sobj = what[i]; + if ( CORBA::is_nil( sobj ) ) continue; // skip bad object + // insert the object to the use case tree + if ( !CORBA::is_nil( objAfter ) ) + useCaseBuilder->InsertBefore( sobj, objAfter ); // insert at given row + else + useCaseBuilder->AppendTo( where, sobj ); // append to the end of list + } +} +//================================================================================ +/*! + * \brief Returns true if algorithm can be used to mesh a given geometry + * \param [in] theAlgoType - the algorithm type + * \param [in] theLibName - a name of the Plug-in library implementing the algorithm + * \param [in] theGeomObject - the geometry to mesh + * \param [in] toCheckAll - if \c True, returns \c True if all shapes are meshable, + * else, returns \c True if at least one shape is meshable + * \return CORBA::Boolean - can or can't + */ +//================================================================================ + +CORBA::Boolean SMESH_Gen_i::IsApplicable ( const char* theAlgoType, + const char* theLibName, + GEOM::GEOM_Object_ptr theGeomObject, + CORBA::Boolean toCheckAll) +{ + SMESH_TRY; + + std::string aPlatformLibName; + typedef GenericHypothesisCreator_i* (*GetHypothesisCreator)(const char*); + GenericHypothesisCreator_i* aCreator = + getHypothesisCreator(theAlgoType, theLibName, aPlatformLibName); + if (aCreator) + { + TopoDS_Shape shape = GeomObjectToShape( theGeomObject ); + return shape.IsNull() || aCreator->IsApplicable( shape, toCheckAll ); + } + else + { + return false; + } + + SMESH_CATCH( SMESH::doNothing ); + +#ifdef _DEBUG_ + cout << "SMESH_Gen_i::IsApplicable(): exception in " << ( theAlgoType ? theAlgoType : "") << endl; +#endif + return true; +} + +//================================================================================= +// function : GetInsideSphere +// purpose : Collect indices of elements, which are located inside the sphere +//================================================================================= +SMESH::long_array* SMESH_Gen_i::GetInsideSphere( SMESH::SMESH_IDSource_ptr meshPart, + SMESH::ElementType theElemType, + CORBA::Double theX, + CORBA::Double theY, + CORBA::Double theZ, + CORBA::Double theR) +{ + SMESH::long_array_var aResult = new SMESH::long_array(); + if ( meshPart->_is_nil() ) + return aResult._retn(); + + // 1. Create geometrical object + gp_Pnt aP( theX, theY, theZ ); + TopoDS_Shape aShape = BRepPrimAPI_MakeSphere( aP, theR ).Shape(); + + std::vector lst =_GetInside(meshPart, theElemType, aShape); + + if ( lst.size() > 0 ) { + aResult->length( lst.size() ); + for ( size_t i = 0; i < lst.size(); i++ ) { + aResult[i] = lst[i]; + } + } + return aResult._retn(); +} + +SMESH::long_array* SMESH_Gen_i::GetInsideBox( SMESH::SMESH_IDSource_ptr meshPart, + SMESH::ElementType theElemType, + CORBA::Double theX1, + CORBA::Double theY1, + CORBA::Double theZ1, + CORBA::Double theX2, + CORBA::Double theY2, + CORBA::Double theZ2) { + SMESH::long_array_var aResult = new SMESH::long_array(); + if( meshPart->_is_nil() ) + return aResult._retn(); + + TopoDS_Shape aShape = BRepPrimAPI_MakeBox( gp_Pnt( theX1, theY1, theZ1 ), gp_Pnt( theX2, theY2, theZ2 ) ).Shape(); + + std::vector lst =_GetInside(meshPart, theElemType, aShape); + + if( lst.size() > 0 ) { + aResult->length( lst.size() ); + for ( size_t i = 0; i < lst.size(); i++ ) { + aResult[i] = lst[i]; + } + } + return aResult._retn(); +} + +SMESH::long_array* SMESH_Gen_i::GetInsideCylinder( SMESH::SMESH_IDSource_ptr meshPart, + SMESH::ElementType theElemType, + CORBA::Double theX, + CORBA::Double theY, + CORBA::Double theZ, + CORBA::Double theDX, + CORBA::Double theDY, + CORBA::Double theDZ, + CORBA::Double theH, + CORBA::Double theR ){ + SMESH::long_array_var aResult = new SMESH::long_array(); + if( meshPart->_is_nil() ) + return aResult._retn(); + + gp_Pnt aP( theX, theY, theZ ); + gp_Vec aV( theDX, theDY, theDZ ); + gp_Ax2 anAxes (aP, aV); + + TopoDS_Shape aShape = BRepPrimAPI_MakeCylinder(anAxes, theR, Abs(theH)).Shape(); + + std::vector lst =_GetInside(meshPart, theElemType, aShape); + + if( lst.size() > 0 ) { + aResult->length( lst.size() ); + for ( size_t i = 0; i < lst.size(); i++ ) { + aResult[i] = lst[i]; + } + } + return aResult._retn(); +} + +SMESH::long_array* SMESH_Gen_i::GetInside( SMESH::SMESH_IDSource_ptr meshPart, + SMESH::ElementType theElemType, + GEOM::GEOM_Object_ptr theGeom, + CORBA::Double theTolerance ) { + SMESH::long_array_var aResult = new SMESH::long_array(); + if( meshPart->_is_nil() || theGeom->_is_nil() ) + return aResult._retn(); + + TopoDS_Shape aShape = GeomObjectToShape( theGeom ); + + std::vector lst =_GetInside(meshPart, theElemType, aShape, &theTolerance); + + if( lst.size() > 0 ) { + aResult->length( lst.size() ); + for ( size_t i = 0; i < lst.size(); i++ ) { + aResult[i] = lst[i]; + } + } + return aResult._retn(); +} + + + +std::vector SMESH_Gen_i::_GetInside( SMESH::SMESH_IDSource_ptr meshPart, + SMESH::ElementType theElemType, + TopoDS_Shape& aShape, + double* theTolerance) { + + std::vector res; + SMESH::SMESH_Mesh_var mesh = meshPart->GetMesh(); + + if ( mesh->_is_nil() ) + return res; + + SMESH_Mesh_i* anImpl = dynamic_cast( GetServant( mesh ).in() ); + if ( !anImpl ) + return res; + + const SMDS_Mesh* meshDS = anImpl->GetImpl().GetMeshDS(); + + if ( !meshDS ) + return res; + + SMDSAbs_ElementType aType = SMDSAbs_ElementType(theElemType); + SMESH::Controls::ElementsOnShape* anElementsOnShape = new SMESH::Controls::ElementsOnShape(); + anElementsOnShape->SetAllNodes( true ); + anElementsOnShape->SetMesh( meshDS ); + anElementsOnShape->SetShape( aShape, aType ); + + if(theTolerance) + anElementsOnShape->SetTolerance(*theTolerance); + + SMESH::SMESH_Mesh_var msource = SMESH::SMESH_Mesh::_narrow(meshPart); + if ( !msource->_is_nil() ) { // Mesh case + SMDS_ElemIteratorPtr elemIt = meshDS->elementsIterator( aType ); + if ( elemIt ) { + while ( elemIt->more() ) { + const SMDS_MeshElement* anElem = elemIt->next(); + long anId = anElem->GetID(); + if ( anElementsOnShape->IsSatisfy( anId ) ) + res.push_back( anId ); + } + } + } + SMESH::SMESH_Group_var gsource = SMESH::SMESH_Group::_narrow(meshPart); + if ( !gsource->_is_nil() ) { + if(theElemType == SMESH::NODE) { + SMESH::long_array_var nodes = gsource->GetNodeIDs(); + for ( CORBA::ULong i = 0; i < nodes->length(); ++i ) { + if ( const SMDS_MeshNode* node = meshDS->FindNode( nodes[i] )) { + long anId = node->GetID(); + if ( anElementsOnShape->IsSatisfy( anId ) ) + res.push_back( anId ); + } + } + } else if (gsource->GetType() == theElemType || theElemType == SMESH::ALL ) { + SMESH::long_array_var elems = gsource->GetListOfID(); + for ( CORBA::ULong i = 0; i < elems->length(); ++i ) { + if ( const SMDS_MeshElement* elem = meshDS->FindElement( elems[i] )) { + long anId = elem->GetID(); + if ( anElementsOnShape->IsSatisfy( anId ) ) + res.push_back( anId ); + } + } + } + } + SMESH::SMESH_subMesh_var smsource = SMESH::SMESH_subMesh::_narrow(meshPart); + if ( !smsource->_is_nil() ) { + SMESH::long_array_var elems = smsource->GetElementsByType( theElemType ); + for ( CORBA::ULong i = 0; i < elems->length(); ++i ) { + const SMDS_MeshElement* elem = ( theElemType == SMESH::NODE ) ? meshDS->FindNode( elems[i] ) : meshDS->FindElement( elems[i] ); + if (elem) { + long anId = elem->GetID(); + if ( anElementsOnShape->IsSatisfy( anId ) ) + res.push_back( anId ); + } + } + } + return res; +} + + //============================================================================= /*! * SMESHEngine_factory