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=3afdb9f1f87ad9e92f2c3b5edc571cd7fbd230e4;hp=b822651b7ee853da1a91cc152f911fc9fba7eb3a;hb=b22e182dd1a2c30be324b21074158390d00714b3;hpb=63a442b2c3cbc5e2155d83e86dfdb77d6961fab3 diff --git a/src/SMESH_I/SMESH_Gen_i.cxx b/src/SMESH_I/SMESH_Gen_i.cxx index b822651b7..3afdb9f1f 100644 --- a/src/SMESH_I/SMESH_Gen_i.cxx +++ b/src/SMESH_I/SMESH_Gen_i.cxx @@ -1,4 +1,4 @@ -// Copyright (C) 2007-2014 CEA/DEN, EDF R&D, OPEN CASCADE +// Copyright (C) 2007-2015 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 @@ -467,23 +467,23 @@ SMESH::SMESH_Hypothesis_ptr SMESH_Gen_i::createHypothesis(const char* theHypName SMESH_Hypothesis_i* myHypothesis_i = 0; SMESH::SMESH_Hypothesis_var hypothesis_i; std::string aPlatformLibName; - typedef GenericHypothesisCreator_i* (*GetHypothesisCreator)(const char* ); - GenericHypothesisCreator_i* aCreator = getHypothesisCreator(theHypName, theLibName, aPlatformLibName); - // 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.c_str()); // for persistency assurance - - if (!myHypothesis_i) - return hypothesis_i._retn(); - - // 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 + 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(); } @@ -747,7 +747,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 ) @@ -2345,10 +2345,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, @@ -2368,10 +2369,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, @@ -2390,17 +2391,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 @@ -2408,302 +2407,246 @@ 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 ( int 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 ) ? 1 : -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() > 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 (int iG = 0; iG < aListOfGroups->length(); iG++) + { + aGroup = aListOfGroups[iG]; + aGroupType = aGroup->GetType(); + aGroupName = aGroup->GetName(); + + // 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( aGroupName, aGroupType )); + if ( anIter == aGroupsMap.end() ) { + // add a new group in the mesh + aNewGroup = aNewImpl->CreateGroup( aGroupType, aGroupName ); + // add elements into new group + aNewGroup->Add( anNewIDs ); + + aListOfNewGroups.push_back(aNewGroup); + aGroupsMap.insert(make_pair( make_pair(aGroupName, 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); + aNewGroup->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); } - }//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 << "["; + aPythonDump << aNewMesh << " = " << this << "." + << ( theCommonGroups ? "ConcatenateWithGroups" : "Concatenate" ) + << "(["; for ( int i = 0; i < theMeshesArray.length(); i++) { if (i > 0) aPythonDump << ", "; aPythonDump << theMeshesArray[i]; @@ -2727,6 +2670,7 @@ SMESH_Gen_i::ConcatenateCommon(const SMESH::mesh_array& theMeshesArray, if (aNewMeshDS) aNewMeshDS->Modified(); + return aNewMesh._retn(); } @@ -2776,6 +2720,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 @@ -2847,30 +2792,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: - if ( toKeepIDs ) - newElem = editor.GetMeshDS()-> - AddPolyhedralVolumeWithID( nodes, - static_cast(elem)->GetQuantities(), - ID); - else - newElem = editor.GetMeshDS()-> - AddPolyhedralVolume( nodes, - static_cast(elem)->GetQuantities()); - 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() ) @@ -4112,6 +4039,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(); @@ -4754,6 +4682,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 ); } } @@ -4800,11 +4729,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(); @@ -4863,6 +4787,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(); @@ -5179,8 +5110,7 @@ CORBA::Boolean SMESH_Gen_i::IsApplicable ( const char* theAlgoType, if (aCreator) { TopoDS_Shape shape = GeomObjectToShape( theGeomObject ); - if ( !shape.IsNull() ) - return aCreator->IsApplicable( shape, toCheckAll ); + return shape.IsNull() || aCreator->IsApplicable( shape, toCheckAll ); } else { @@ -5188,6 +5118,10 @@ CORBA::Boolean SMESH_Gen_i::IsApplicable ( const char* theAlgoType, } SMESH_CATCH( SMESH::doNothing ); + +#ifdef _DEBUG_ + cout << "SMESH_Gen_i::IsApplicable(): exception in " << ( theAlgoType ? theAlgoType : "") << endl; +#endif return true; }