+ return GEOM::GEOM_Object::_nil();
+}
+
+//================================================================================
+/*!
+ * SMESH_Gen_i::Concatenate
+ *
+ * Concatenate the given meshes into one mesh
+ */
+//================================================================================
+
+SMESH::SMESH_Mesh_ptr
+SMESH_Gen_i::Concatenate(const SMESH::ListOfIDSources& theMeshesArray,
+ CORBA::Boolean theUniteIdenticalGroups,
+ CORBA::Boolean theMergeNodesAndElements,
+ CORBA::Double theMergeTolerance,
+ SMESH::SMESH_Mesh_ptr theMeshToAppendTo)
+ throw ( SALOME::SALOME_Exception )
+{
+ return ConcatenateCommon(theMeshesArray,
+ theUniteIdenticalGroups,
+ theMergeNodesAndElements,
+ theMergeTolerance,
+ false,
+ theMeshToAppendTo);
+}
+
+//================================================================================
+/*!
+ * SMESH_Gen_i::ConcatenateWithGroups
+ *
+ * Concatenate the given meshes into one mesh
+ * Create the groups of all elements from initial meshes
+ */
+//================================================================================
+
+SMESH::SMESH_Mesh_ptr
+SMESH_Gen_i::ConcatenateWithGroups(const SMESH::ListOfIDSources& theMeshesArray,
+ CORBA::Boolean theUniteIdenticalGroups,
+ CORBA::Boolean theMergeNodesAndElements,
+ CORBA::Double theMergeTolerance,
+ SMESH::SMESH_Mesh_ptr theMeshToAppendTo)
+ throw ( SALOME::SALOME_Exception )
+{
+ return ConcatenateCommon(theMeshesArray,
+ theUniteIdenticalGroups,
+ theMergeNodesAndElements,
+ theMergeTolerance,
+ true,
+ theMeshToAppendTo);
+}
+
+//================================================================================
+/*!
+ * SMESH_Gen_i::ConcatenateCommon
+ *
+ * Concatenate the given meshes into one mesh
+ */
+//================================================================================
+
+SMESH::SMESH_Mesh_ptr
+SMESH_Gen_i::ConcatenateCommon(const SMESH::ListOfIDSources& theMeshesArray,
+ CORBA::Boolean theUniteIdenticalGroups,
+ CORBA::Boolean theMergeNodesAndElements,
+ CORBA::Double theMergeTolerance,
+ CORBA::Boolean theCommonGroups,
+ SMESH::SMESH_Mesh_ptr theMeshToAppendTo)
+ throw ( SALOME::SALOME_Exception )
+{
+ std::unique_ptr< TPythonDump > pPythonDump( new TPythonDump );
+ TPythonDump& pythonDump = *pPythonDump; // prevent dump of called methods
+
+ // create mesh if theMeshToAppendTo not provided
+ SMESH::SMESH_Mesh_var newMesh;
+ if ( CORBA::is_nil( theMeshToAppendTo ))
+ newMesh = CreateEmptyMesh();
+ else
+ newMesh = SMESH::SMESH_Mesh::_duplicate( theMeshToAppendTo );
+ SMESH_Mesh_i* newImpl = SMESH::DownCast<SMESH_Mesh_i*>( newMesh );
+ if ( !newImpl ) return newMesh._retn();
+ newImpl->Load();
+
+ ::SMESH_Mesh& locMesh = newImpl->GetImpl();
+ SMESHDS_Mesh* newMeshDS = locMesh.GetMeshDS();
+
+ typedef std::list<SMESH::SMESH_Group_var> TListOfNewGroups;
+ typedef std::pair<string, SMESH::ElementType > TNameAndType;
+ typedef std::map< TNameAndType, TListOfNewGroups > TGroupsMap;
+ TGroupsMap groupsMap;
+ TListOfNewGroups listOfNewGroups;
+
+ if ( !CORBA::is_nil( theMeshToAppendTo ))
+ {
+ // fill groupsMap with existing groups
+ SMESH::ListOfGroups_var groups = theMeshToAppendTo->GetGroups();
+ for ( CORBA::ULong i = 0; i < groups->length(); ++i )
+ {
+ SMESH::SMESH_Group_var group = SMESH::SMESH_Group::_narrow( groups[ i ]);
+ if ( !group->_is_nil() )
+ {
+ CORBA::String_var name = group->GetName();
+ SMESH::ElementType type = group->GetType();
+ groupsMap[ TNameAndType( name.in(), type ) ].push_back( group );
+ }
+ }
+ }
+
+ ::SMESH_MeshEditor newEditor( &locMesh );
+ ::SMESH_MeshEditor::ElemFeatures elemType;
+
+ // loop on sub-meshes
+ for ( CORBA::ULong i = 0; i < theMeshesArray.length(); i++ )
+ {
+ if ( CORBA::is_nil( theMeshesArray[i] )) continue;
+ SMESH::SMESH_Mesh_var initMesh = theMeshesArray[i]->GetMesh();
+ SMESH_Mesh_i* initImpl = SMESH::DownCast<SMESH_Mesh_i*>( initMesh );
+ if ( !initImpl ) continue;
+ if ( initMesh->_is_equivalent( theMeshToAppendTo ))
+ continue;
+ initImpl->Load();
+
+ // assure that IDs increment by one during iteration
+ ::SMESH_Mesh& initLocMesh = initImpl->GetImpl();
+ SMESHDS_Mesh* initMeshDS = initLocMesh.GetMeshDS();
+ if ( initMeshDS->MaxNodeID() > initMeshDS->NbNodes() ||
+ initMeshDS->MaxElementID() > initMeshDS->NbElements() )
+ {
+ initMeshDS->Modified();
+ initMeshDS->CompactMesh();
+ }
+
+ // remember nb of elements before filling in
+ SMESH::long_array_var prevState = newMesh->GetNbElementsByType();
+
+ // copy nodes
+
+ std::vector< const SMDS_MeshElement* > newNodes( initMeshDS->NbNodes() + 1, 0 );
+ SMDS_ElemIteratorPtr elemIt = initImpl->GetElements( theMeshesArray[i], SMESH::NODE );
+ while ( elemIt->more() )
+ {
+ SMESH_NodeXYZ node = elemIt->next();
+ newNodes[ node->GetID() ] = newMeshDS->AddNode( node.X(), node.Y(), node.Z() );
+ }
+
+ // copy elements
+
+ SMESH::array_of_ElementType_var srcElemTypes = theMeshesArray[i]->GetTypes();
+ if ( srcElemTypes->length() == 1 && srcElemTypes[0] == SMESH::NODE ) // group of nodes
+ continue;
+ std::vector< const SMDS_MeshElement* > newElems( initMeshDS->NbElements() + 1, 0 );
+ elemIt = initImpl->GetElements( theMeshesArray[i], SMESH::ALL );
+ while ( elemIt->more() )
+ {
+ const SMDS_MeshElement* elem = elemIt->next();
+ elemType.myNodes.resize( elem->NbNodes() );
+
+ SMDS_NodeIteratorPtr itNodes = elem->nodeIterator();
+ for ( int k = 0; itNodes->more(); k++)
+ {
+ const SMDS_MeshNode* node = itNodes->next();
+ elemType.myNodes[ k ] = static_cast< const SMDS_MeshNode*> ( newNodes[ node->GetID() ]);
+ }
+
+ // creates a corresponding element on existent nodes in new mesh
+ newElems[ elem->GetID() ] =
+ newEditor.AddElement( elemType.myNodes, elemType.Init( elem, /*basicOnly=*/false ));
+ }
+ newEditor.ClearLastCreated(); // forget the history
+
+
+ // create groups of just added elements
+ SMESH::SMESH_Group_var newGroup;
+ SMESH::ElementType groupType;
+ if ( theCommonGroups )
+ {
+ // type names
+ 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]=0;
+ }
+
+ SMESH::long_array_var curState = newMesh->GetNbElementsByType();
+
+ for( groupType = SMESH::NODE;
+ groupType < SMESH::NB_ELEMENT_TYPES;
+ groupType = (SMESH::ElementType)( groupType + 1 ))
+ {
+ if ( curState[ groupType ] <= prevState[ groupType ])
+ continue; // no elements of groupType added from the i-th mesh
+
+ // make a group name
+ std::string groupName = "Gr";
+ SALOMEDS::SObject_wrap meshSO = ObjectToSObject( theMeshesArray[i] );
+ if ( meshSO ) {
+ CORBA::String_var name = meshSO->GetName();
+ groupName += name;
+ }
+ groupName += "_";
+ groupName += typeNames[ groupType ];
+
+ // make and fill a group
+ newGroup = newImpl->CreateGroup( groupType, groupName.c_str() );
+ std::vector< const SMDS_MeshElement* > & elemVec =
+ ( groupType == SMESH::NODE ) ? newNodes : newElems;
+ if ( SMESH_Group_i* grp_i = SMESH::DownCast<SMESH_Group_i*>( newGroup ))
+ {
+ if ( SMESHDS_Group* grpDS = dynamic_cast<SMESHDS_Group*>( grp_i->GetGroupDS() ))
+ {
+ for ( size_t j = 0; j < elemVec.size(); ++j )
+ {
+ if ( elemVec[j] && elemVec[j]->GetType() == grpDS->GetType() )
+ grpDS->Add( elemVec[j] );
+ }
+ }
+ }
+ listOfNewGroups.clear();
+ listOfNewGroups.push_back( newGroup );
+ groupsMap.insert( std::make_pair( TNameAndType( groupName, groupType ),
+ listOfNewGroups ));
+ }
+ }
+
+ if ( SMESH_Mesh_i* initImpl = SMESH::DownCast<SMESH_Mesh_i*>( theMeshesArray[i] ))
+ {
+ // copy groups
+
+ SMESH::SMESH_GroupBase_ptr group;
+ CORBA::String_var groupName;
+ SMESH::long_array_var newIDs = new SMESH::long_array();
+
+ // loop on groups of a source mesh
+ SMESH::ListOfGroups_var listOfGroups = initImpl->GetGroups();
+ for ( CORBA::ULong iG = 0; iG < listOfGroups->length(); iG++ )
+ {
+ group = listOfGroups[iG];
+ groupType = group->GetType();
+ groupName = group->GetName();
+ std::string name = groupName.in();
+
+ // convert a list of IDs
+ newIDs->length( group->Size() );
+ std::vector< const SMDS_MeshElement* > & elemVec =
+ ( groupType == SMESH::NODE ) ? newNodes : newElems;
+ SMDS_ElemIteratorPtr itGrElems = initImpl->GetElements( group, SMESH::ALL );
+ int nbElems = 0;
+ while ( itGrElems->more() )
+ {
+ const SMDS_MeshElement* elem = itGrElems->next();
+ const SMDS_MeshElement* newElem = elemVec[ elem->GetID() ];
+ if ( newElem )
+ newIDs[ nbElems++ ] = newElem->GetID();
+ }
+ newIDs->length( nbElems );
+
+ // check that a current group name and type don't have identical ones in final mesh
+ listOfNewGroups.clear();
+ TNameAndType nameAndType( name, groupType );
+ TGroupsMap::iterator anIter = groupsMap.find( nameAndType );
+ if ( anIter == groupsMap.end() )
+ {
+ // add a new group in the mesh
+ newGroup = newImpl->CreateGroup( groupType, groupName.in() );
+ newGroup->Add( newIDs );
+
+ listOfNewGroups.push_back( newGroup );
+ groupsMap.insert( std::make_pair( nameAndType, listOfNewGroups ));
+ }
+ else if ( theUniteIdenticalGroups )
+ {
+ // unite identical groups
+ TListOfNewGroups& aNewGroups = anIter->second;
+ aNewGroups.front()->Add( newIDs );
+ }
+ else
+ {
+ // rename identical groups
+ newGroup = newImpl->CreateGroup( groupType, groupName );
+ newGroup->Add( newIDs );
+
+ TListOfNewGroups& newGroups = anIter->second;
+ std::string newGroupName;
+ if ( newGroups.size() == 1 )
+ {
+ newGroupName = name + "_1";
+ newGroups.front()->SetName( newGroupName.c_str() );
+ }
+ newGroupName = name + "_" + SMESH_Comment( newGroups.size() + 1 );
+ newGroup->SetName( newGroupName.c_str() );
+ newGroups.push_back( newGroup );
+ }
+ } // loop on groups
+ } // if an IDSource is a mesh
+ } //meshes loop
+
+ if ( theMergeNodesAndElements ) // merge nodes
+ {
+ TIDSortedNodeSet meshNodes; // no input nodes == treat all
+ SMESH_MeshEditor::TListOfListOfNodes groupsOfNodes;
+ newEditor.FindCoincidentNodes( meshNodes, theMergeTolerance, groupsOfNodes,
+ /*SeparateCornersAndMedium=*/ false );
+ newEditor.MergeNodes( groupsOfNodes );
+ // merge elements
+ newEditor.MergeEqualElements();
+ }
+
+ // Update Python script
+ pythonDump << newMesh << " = " << this
+ << "." << ( theCommonGroups ? "ConcatenateWithGroups" : "Concatenate" ) << "( "
+ << theMeshesArray << ", "
+ << theUniteIdenticalGroups << ", "
+ << theMergeNodesAndElements << ", "
+ << TVar( theMergeTolerance ) << ", "
+ << theMeshToAppendTo << " )";
+
+ pPythonDump.reset(); // enable python dump from GetGroups()
+
+ // 0020577: EDF 1164 SMESH: Bad dump of concatenate with create common groups
+ if ( !newMesh->_is_nil() )
+ {
+ SMESH::ListOfGroups_var groups = newMesh->GetGroups();
+ }
+
+ // IPAL21468 Change icon of compound because it need not be computed.
+ SALOMEDS::SObject_wrap meshSO = ObjectToSObject( newMesh );
+ SetPixMap( meshSO, "ICON_SMESH_TREE_MESH" );
+
+ newMeshDS->Modified();
+
+ return newMesh._retn();
+}
+
+//================================================================================
+/*!
+ * \brief Create a mesh by copying a part of another mesh
+ * \param meshPart - a part of mesh to copy
+ * \param toCopyGroups - to create in the new mesh groups
+ * the copied elements belongs to
+ * \param toKeepIDs - to preserve IDs of the copied elements or not
+ * \retval SMESH::SMESH_Mesh_ptr - the new mesh
+ */
+//================================================================================
+
+SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CopyMesh(SMESH::SMESH_IDSource_ptr meshPart,
+ const char* meshName,
+ CORBA::Boolean toCopyGroups,
+ CORBA::Boolean toKeepIDs)
+ throw ( SALOME::SALOME_Exception )
+{
+ Unexpect aCatch(SALOME_SalomeException);
+
+ TPythonDump* pyDump = new TPythonDump; // prevent dump from CreateMesh()
+ std::unique_ptr<TPythonDump> pyDumpDeleter( pyDump );
+
+ // 1. Get source mesh
+
+ if ( CORBA::is_nil( meshPart ))
+ THROW_SALOME_CORBA_EXCEPTION( "bad IDSource", SALOME::BAD_PARAM );
+
+ SMESH::SMESH_Mesh_var srcMesh = meshPart->GetMesh();
+ SMESH_Mesh_i* srcMesh_i = SMESH::DownCast<SMESH_Mesh_i*>( srcMesh );
+ if ( !srcMesh_i )
+ THROW_SALOME_CORBA_EXCEPTION( "bad mesh of IDSource", SALOME::BAD_PARAM );
+
+ SMESHDS_Mesh* srcMeshDS = srcMesh_i->GetImpl().GetMeshDS();
+
+ // 2. Make a new mesh
+
+ SMESH::SMESH_Mesh_var newMesh = CreateMesh(GEOM::GEOM_Object::_nil());
+ SMESH_Mesh_i* newMesh_i = SMESH::DownCast<SMESH_Mesh_i*>( newMesh );
+ if ( !newMesh_i )
+ THROW_SALOME_CORBA_EXCEPTION( "can't create a mesh", SALOME::INTERNAL_ERROR );
+ SALOMEDS::SObject_wrap meshSO = ObjectToSObject( newMesh );
+ if ( !meshSO->_is_nil() )
+ {
+ SetName( meshSO, meshName, "Mesh" );
+ SetPixMap( meshSO, "ICON_SMESH_TREE_MESH_IMPORTED");
+ }
+ SMESHDS_Mesh* newMeshDS = newMesh_i->GetImpl().GetMeshDS();
+ ::SMESH_MeshEditor editor( &newMesh_i->GetImpl() );
+ ::SMESH_MeshEditor::ElemFeatures elemType;
+
+ // 3. Get elements to copy
+
+ SMDS_ElemIteratorPtr srcElemIt; SMDS_NodeIteratorPtr srcNodeIt;
+ TIDSortedElemSet srcElems;
+ SMESH::array_of_ElementType_var srcElemTypes = meshPart->GetTypes();
+ if ( SMESH::DownCast<SMESH_Mesh_i*>( meshPart ))
+ {
+ srcMesh_i->Load();
+ srcElemIt = srcMeshDS->elementsIterator();
+ srcNodeIt = srcMeshDS->nodesIterator();
+ }
+ else
+ {
+ SMESH::long_array_var ids = meshPart->GetIDs();
+ if ( srcElemTypes->length() == 1 && srcElemTypes[0] == SMESH::NODE ) // group of nodes
+ {
+ for ( CORBA::ULong i=0; i < ids->length(); i++ )
+ if ( const SMDS_MeshElement * elem = srcMeshDS->FindNode( ids[i] ))
+ srcElems.insert( elem );
+ }
+ else
+ {
+ for ( CORBA::ULong i = 0; i < ids->length(); i++ )
+ if ( const SMDS_MeshElement * elem = srcMeshDS->FindElement( ids[i] ))
+ srcElems.insert( elem );
+ }
+ if ( srcElems.empty() )
+ return newMesh._retn();
+
+ typedef SMDS_SetIterator< SMDS_pElement, TIDSortedElemSet::const_iterator > ElIter;
+ srcElemIt = SMDS_ElemIteratorPtr( new ElIter( srcElems.begin(), srcElems.end() ));
+ }
+
+ // 4. Copy elements
+
+ typedef map<SMDS_pElement, SMDS_pElement, TIDCompare> TE2EMap;
+ TE2EMap e2eMapByType[ SMDSAbs_NbElementTypes ];
+ TE2EMap& n2nMap = e2eMapByType[ SMDSAbs_Node ];
+ int iN;
+ const SMDS_MeshNode *nSrc, *nTgt;
+ vector< const SMDS_MeshNode* > nodes;
+ while ( srcElemIt->more() )
+ {
+ const SMDS_MeshElement * elem = srcElemIt->next();
+ // find / add nodes
+ nodes.resize( elem->NbNodes());
+ SMDS_ElemIteratorPtr nIt = elem->nodesIterator();
+ if ( toKeepIDs ) {
+ for ( iN = 0; nIt->more(); ++iN )
+ {
+ nSrc = static_cast<const SMDS_MeshNode*>( nIt->next() );
+ nTgt = newMeshDS->FindNode( nSrc->GetID());
+ if ( !nTgt )
+ nTgt = newMeshDS->AddNodeWithID( nSrc->X(), nSrc->Y(), nSrc->Z(), nSrc->GetID());
+ nodes[ iN ] = nTgt;
+ }
+ }
+ else {
+ for ( iN = 0; nIt->more(); ++iN )
+ {
+ nSrc = static_cast<const SMDS_MeshNode*>( nIt->next() );
+ TE2EMap::iterator n2n = n2nMap.insert( make_pair( nSrc, SMDS_pNode(0) )).first;
+ if ( !n2n->second )
+ n2n->second = newMeshDS->AddNode( nSrc->X(), nSrc->Y(), nSrc->Z() );
+ nodes[ iN ] = (const SMDS_MeshNode*) n2n->second;
+ }
+ }
+ // add elements
+ if ( elem->GetType() != SMDSAbs_Node )
+ {
+ 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() )
+
+ // 4(b). Copy free nodes
+
+ if ( srcNodeIt && srcMeshDS->NbNodes() != newMeshDS->NbNodes() )
+ {
+ while ( srcNodeIt->more() )
+ {
+ nSrc = srcNodeIt->next();
+ if ( nSrc->NbInverseElements() == 0 )
+ {
+ if ( toKeepIDs )
+ nTgt = newMeshDS->AddNodeWithID( nSrc->X(), nSrc->Y(), nSrc->Z(), nSrc->GetID());
+ else
+ n2nMap[ nSrc ] = newMeshDS->AddNode( nSrc->X(), nSrc->Y(), nSrc->Z() );
+ }
+ }
+ }
+
+ // 5. Copy groups
+
+ int nbNewGroups = 0;
+ if ( toCopyGroups )
+ {
+ SMESH_Mesh::GroupIteratorPtr gIt = srcMesh_i->GetImpl().GetGroups();
+ while ( gIt->more() )
+ {
+ SMESH_Group* group = gIt->next();
+ const SMESHDS_GroupBase* groupDS = group->GetGroupDS();
+
+ // Check group type. We copy nodal groups containing nodes of copied element
+ SMDSAbs_ElementType groupType = groupDS->GetType();
+ if ( groupType != SMDSAbs_Node &&
+ newMeshDS->GetMeshInfo().NbElements( groupType ) == 0 )
+ continue; // group type differs from types of meshPart
+
+ // Find copied elements in the group
+ vector< const SMDS_MeshElement* > groupElems;
+ SMDS_ElemIteratorPtr eIt = groupDS->GetElements();
+ if ( toKeepIDs )
+ {
+ const SMDS_MeshElement* foundElem;
+ if ( groupType == SMDSAbs_Node )
+ {
+ while ( eIt->more() )
+ if (( foundElem = newMeshDS->FindNode( eIt->next()->GetID() )))
+ groupElems.push_back( foundElem );
+ }
+ else
+ {
+ while ( eIt->more() )
+ if (( foundElem = newMeshDS->FindElement( eIt->next()->GetID() )))
+ groupElems.push_back( foundElem );
+ }
+ }
+ else
+ {
+ TE2EMap & e2eMap = e2eMapByType[ groupDS->GetType() ];
+ if ( e2eMap.empty() ) continue;
+ int minID = e2eMap.begin()->first->GetID();
+ int maxID = e2eMap.rbegin()->first->GetID();
+ TE2EMap::iterator e2e;
+ while ( eIt->more() && groupElems.size() < e2eMap.size())
+ {
+ const SMDS_MeshElement* e = eIt->next();
+ if ( e->GetID() < minID || e->GetID() > maxID ) continue;
+ if ((e2e = e2eMap.find( e )) != e2eMap.end())
+ groupElems.push_back( e2e->second );
+ }
+ }
+ // Make a new group
+ if ( !groupElems.empty() )
+ {
+ SMESH::SMESH_Group_var newGroupObj =
+ newMesh->CreateGroup( SMESH::ElementType(groupType), group->GetName() );
+ if ( SMESH_GroupBase_i* newGroup_i = SMESH::DownCast<SMESH_GroupBase_i*>( newGroupObj))
+ {
+ SMESHDS_GroupBase * newGroupDS = newGroup_i->GetGroupDS();
+ SMDS_MeshGroup& smdsGroup = ((SMESHDS_Group*)newGroupDS)->SMDSGroup();
+ for ( unsigned i = 0; i < groupElems.size(); ++i )
+ smdsGroup.Add( groupElems[i] );
+
+ nbNewGroups++;
+ }
+ }
+ }
+ }
+
+ newMeshDS->Modified();
+
+ *pyDump << newMesh << " = " << this
+ << ".CopyMesh( " << meshPart << ", "
+ << "'" << meshName << "', "
+ << toCopyGroups << ", "
+ << toKeepIDs << ")";
+
+ pyDumpDeleter.reset(); // allow dump in GetGroups()
+
+ if ( nbNewGroups > 0 ) // dump created groups
+ SMESH::ListOfGroups_var groups = newMesh->GetGroups();
+
+ return newMesh._retn();
+}
+
+
+namespace // utils for CopyMeshWithGeom()
+{
+ typedef std::map< std::string, std::string > TStr2StrMap;
+ typedef std::map< std::string, std::set< std::string > > TStr2StrSetMap;
+ typedef std::map< std::set<int>, int > TIdSet2IndexMap;
+ typedef std::map< std::string, int > TName2IndexMap;
+
+ //================================================================================
+ /*!
+ * \brief Return a new sub-shape corresponding to an old one
+ */
+ //================================================================================
+
+ struct ShapeMapper
+ {
+ SMESH_Mesh_i* mySrcMesh_i;
+ SMESH_Mesh_i* myNewMesh_i;
+ SMESH_Gen_i* myGen_i;
+ bool myToPublish;
+ bool myIsSameGeom;
+
+ TStr2StrMap myOld2NewEntryMap; // map of study entries
+
+ GEOM::ListOfGO_var mySubshapes; // sub-shapes existing in the new geometry
+ TIdSet2IndexMap myIds2SubshapeIndex; // to find an existing sub-shape
+ TName2IndexMap myName2SubshapeIndex; // to find an existing sub-shape by name
+
+ bool myGIPMapDone;
+ GEOM::ListOfListOfLong_var myGIPMap; // filled by GetInPlaceMap()
+
+ // not directly relating to shape search
+ TStr2StrSetMap myInvalidMap; // blame shape -> invalid objects
+
+ //================================================================================
+ /*!
+ * \brief Constructor
+ */
+ ShapeMapper( SMESH_Mesh_i* srcMesh_i,
+ SMESH_Mesh_i* newMesh_i,
+ SMESH_Gen_i* smeshGen_i )
+ : mySrcMesh_i( srcMesh_i ),
+ myNewMesh_i( newMesh_i ),
+ myGen_i ( smeshGen_i ),
+ myToPublish( smeshGen_i->IsEnablePublish() ),
+ myGIPMapDone( false )
+ {
+ // retrieve from the study shape mapping made thanks to
+ // "Set presentation parameters and sub-shapes from arguments" option
+
+ GEOM::GEOM_Object_var mainShapeNew = myNewMesh_i->GetShapeToMesh();
+ GEOM::GEOM_Object_var mainShapeOld = mySrcMesh_i->GetShapeToMesh();
+ SALOMEDS::SObject_wrap oldSO = myGen_i->ObjectToSObject( mainShapeOld );
+ SALOMEDS::SObject_wrap newSO = myGen_i->ObjectToSObject( mainShapeNew );
+ if ( newSO->_is_nil() )
+ {
+ myToPublish = false;
+ return;
+ }
+ if (( myIsSameGeom = mainShapeNew->_is_equivalent( mainShapeOld )))
+ return;
+ CORBA::String_var oldEntry = oldSO->GetID();
+ CORBA::String_var newEntry = newSO->GetID();
+ myOld2NewEntryMap.insert( std::make_pair( std::string( oldEntry.in() ),
+ std::string( newEntry.in() )));
+ std::string newMainEntry = newEntry.in();
+
+ SALOMEDS::Study_var study = myGen_i->getStudyServant();
+ GEOM::GEOM_Gen_var geomGen = myGen_i->GetGeomEngine( mainShapeNew );
+ GEOM::GEOM_IShapesOperations_wrap op = geomGen->GetIShapesOperations();
+ mySubshapes = op->GetExistingSubObjects( mainShapeNew,
+ /*groupsOnly=*/false );
+ for ( CORBA::ULong i = 0; i < mySubshapes->length(); ++i )
+ {
+ newSO = myGen_i->ObjectToSObject( mySubshapes[ i ]);
+ SALOMEDS::ChildIterator_wrap anIter = study->NewChildIterator( newSO );
+ bool refFound = false;
+ for ( ; anIter->More(); anIter->Next() )
+ {
+ SALOMEDS::SObject_wrap so = anIter->Value();
+ if ( so->ReferencedObject( oldSO.inout() ))
+ {
+ oldEntry = oldSO->GetID();
+ newEntry = newSO->GetID();
+ if (( refFound = ( newMainEntry != oldEntry.in() )))
+ myOld2NewEntryMap.insert( std::make_pair( std::string( oldEntry.in() ),
+ std::string( newEntry.in() )));
+ }
+ }
+ if ( !refFound )
+ {
+ GEOM::GEOM_Object_var father = mySubshapes[ i ]->GetMainShape();
+ if ( father->_is_equivalent( mainShapeNew ))
+ {
+ GEOM::ListOfLong_var ids = mySubshapes[ i ]->GetSubShapeIndices();
+ std::set< int > idSet( &ids[0] , &ids[0] + ids->length() );
+ myIds2SubshapeIndex.insert( std::make_pair( idSet, i ));
+ CORBA::String_var name = newSO->GetName();
+ if ( name.in()[0] )
+ myName2SubshapeIndex.insert( std::make_pair( name.in(), i ));
+ }
+ }
+ }
+ }
+
+ //================================================================================
+ /*!
+ * \brief Find a new sub-shape corresponding to an old one
+ */
+ GEOM::GEOM_Object_ptr FindNew( GEOM::GEOM_Object_ptr oldShape )
+ {
+ if ( myIsSameGeom )
+ return GEOM::GEOM_Object::_duplicate( oldShape );
+
+ GEOM::GEOM_Object_var newShape;
+
+ if ( CORBA::is_nil( oldShape ))
+ return newShape._retn();
+
+ if ( !isChildOfOld( oldShape ))
+ return GEOM::GEOM_Object::_duplicate( oldShape ); // shape independent of the old shape
+
+ GEOM::GEOM_Object_var mainShapeNew = myNewMesh_i->GetShapeToMesh();
+ GEOM::GEOM_Gen_var geomGen = myGen_i->GetGeomEngine( mainShapeNew );
+
+ // try to find by entry or name
+ if ( myToPublish )
+ {
+ CORBA::String_var oldEntry = oldShape->GetStudyEntry();
+ TStr2StrMap::iterator o2nID = myOld2NewEntryMap.find( oldEntry.in() );
+ if ( o2nID != myOld2NewEntryMap.end() )
+ {
+ newShape = getShapeByEntry( o2nID->second );
+ }
+ if ( newShape->_is_nil() )
+ {
+ CORBA::String_var name = oldShape->GetName();
+ TName2IndexMap::iterator n2ind = myName2SubshapeIndex.find( name.in() );
+ if ( n2ind != myName2SubshapeIndex.end() )
+ {
+ newShape = GEOM::GEOM_Object::_duplicate( mySubshapes[ n2ind->second ]);
+ GEOM::ListOfLong_var oldIndices = oldShape->GetSubShapeIndices();
+ GEOM::ListOfLong_var newIndices = newShape->GetSubShapeIndices();
+ if ( oldIndices->length() == 0 ||
+ newIndices->length() == 0 ||
+ getShapeType( myNewMesh_i, newIndices[0] ) !=
+ getShapeType( mySrcMesh_i, oldIndices[0] ))
+ newShape = GEOM::GEOM_Object::_nil();
+ }
+ }
+ }
+
+ if ( newShape->_is_nil() )
+ {
+ // try to construct a new sub-shape using myGIPMap
+ buildGIPMap();
+ std::vector< int > newIndices;
+ GEOM::ListOfLong_var oldIndices = oldShape->GetSubShapeIndices();
+ for ( CORBA::ULong i = 0; i < oldIndices->length(); ++i )
+ {
+ findNewIDs( oldIndices[i], newIndices );
+ }
+ if ( newIndices.size() < oldIndices->length() ) // issue #17096
+ {
+ newIndices.clear();
+ newShape = getInPlace( oldShape );
+ }
+ if ( !newIndices.empty() && newShape->_is_nil() )
+ {
+ // search for a sub-shape with same ids
+ std::set< int > idSet( newIndices.begin(), newIndices.end() );
+ TIdSet2IndexMap::iterator ids2ind = myIds2SubshapeIndex.find( idSet );
+ if ( ids2ind != myIds2SubshapeIndex.end() ) {
+ newShape = GEOM::GEOM_Object::_duplicate( mySubshapes[ ids2ind->second ]);
+ }
+ if ( newShape->_is_nil() )
+ try
+ {
+ // create a new shape
+ if ( newIndices.size() > 1 || oldShape->GetType() == GEOM_GROUP )
+ {
+ int groupType = getShapeType( myNewMesh_i, newIndices[0] );
+
+ GEOM::GEOM_IGroupOperations_wrap grOp = geomGen->GetIGroupOperations();
+ newShape = grOp->CreateGroup( mainShapeNew, groupType );
+
+ GEOM::ListOfLong_var newIndicesList = new GEOM::ListOfLong();
+ newIndicesList->length( newIndices.size() );
+ for ( size_t i = 0; i < newIndices.size(); ++i )
+ newIndicesList[ i ] = newIndices[ i ];
+ grOp->UnionIDs( newShape, newIndicesList );
+ }
+ else
+ {
+ GEOM::GEOM_IShapesOperations_wrap shOp = geomGen->GetIShapesOperations();
+ newShape = shOp->GetSubShape( mainShapeNew, newIndices[0] );
+ }
+ }
+ catch (...)
+ {
+ }
+ }
+ }
+
+ if ( !newShape->_is_nil() && myToPublish )
+ {
+ CORBA::String_var oldEntry, newEntry = newShape->GetStudyEntry();
+ if ( !newEntry.in() || !newEntry.in()[0] )
+ {
+ CORBA::String_var name = oldShape->GetName();
+ SALOMEDS::SObject_wrap so = geomGen->AddInStudy( newShape, name, mainShapeNew );
+ newEntry = newShape->GetStudyEntry();
+ oldEntry = oldShape->GetStudyEntry();
+ myOld2NewEntryMap.insert( std::make_pair( std::string( oldEntry.in() ),
+ std::string( newEntry.in() )));
+ }
+ }
+
+ return newShape._retn();
+ }
+
+ //================================================================================
+ /*!
+ * \brief Return a study entry of a new shape by study entry of the old one
+ */
+ std::string FindNew( const std::string & oldEntry )
+ {
+ if ( myIsSameGeom )
+ return oldEntry;
+
+ TStr2StrMap::iterator o2nID = myOld2NewEntryMap.find( oldEntry );
+ if ( o2nID != myOld2NewEntryMap.end() )
+ return o2nID->second;
+
+ GEOM::GEOM_Object_var oldShape = getShapeByEntry( oldEntry );
+ if ( oldShape->_is_nil() || !isChildOfOld( oldShape ))
+ return oldEntry;
+
+ GEOM::GEOM_Object_ptr newShape = FindNew( oldShape );
+ if ( newShape->_is_nil() )
+ return std::string();
+
+ CORBA::String_var newEntry = newShape->GetStudyEntry();
+ return newEntry.in();
+ }
+
+ //================================================================================
+ /*!
+ * \brief Return a sub-shape ID of a new shape by a sub-shape ID of the old one.
+ * Return zero if not found or there are more than one new ID
+ */
+ int FindNew( int oldID )
+ {
+ if ( myIsSameGeom )
+ return oldID;
+
+ buildGIPMap();
+
+ int newID = 0;
+
+ if ( 0 < oldID && oldID < (int)myGIPMap->length() )
+ {
+ if ( myGIPMap[ oldID ].length() == 1 )
+ {
+ newID = myGIPMap[ oldID ][ 0 ];
+ }
+ else if ( myGIPMap[ oldID ].length() > 1 &&
+ getShapeType( mySrcMesh_i, oldID ) == TopAbs_VERTEX )
+ {
+ // select a meshed VERTEX
+ SMESH_subMesh* newSM;
+ for ( CORBA::ULong i = 0; i < myGIPMap[ oldID ].length() && !newID; ++i )
+ if (( newSM = myNewMesh_i->GetImpl().GetSubMeshContaining( myGIPMap[ oldID ][ i ] )) &&
+ ( !newSM->IsEmpty() ))
+ newID = myGIPMap[ oldID ][ i ];
+ }
+ }
+ return newID;
+ }
+
+ //================================================================================
+ /*!
+ * \brief Return a sub-shape ID of a new shape by an old sub-mesh.
+ * Return zero if the old shape is not kept as is in the new shape.
+ */
+ int FindNewNotChanged( SMESH_subMesh* oldSM )
+ {
+ if ( myIsSameGeom )
+ return oldSM->GetId();
+
+ int newID = FindNew( oldSM->GetId() );
+ if ( !newID )
+ return 0;
+
+ SMESH_subMesh* newSM = myNewMesh_i->GetImpl().GetSubMeshContaining( newID );
+ if ( !newSM )
+ return 0;
+
+ // consider a sub-shape as not changed if all its sub-shapes are mapped into
+ // one new sub-shape of the same type.
+
+ if ( oldSM->DependsOn().size() !=
+ newSM->DependsOn().size() )
+ return 0;
+
+ SMESH_subMeshIteratorPtr srcSMIt = oldSM->getDependsOnIterator( /*includeSelf=*/true );
+ while ( srcSMIt->more() )
+ {
+ oldSM = srcSMIt->next();
+ int newSubID = FindNew( oldSM->GetId() );
+ if ( getShapeType( myNewMesh_i, newSubID ) !=
+ getShapeType( mySrcMesh_i, oldSM->GetId() ))
+ return 0;
+ }
+ return newID;
+ }
+
+ //================================================================================
+ /*!
+ * \brief Return shape by study entry
+ */
+ GEOM::GEOM_Object_ptr getShapeByEntry( const std::string & entry )
+ {
+ GEOM::GEOM_Object_var shape;
+ SALOMEDS::SObject_wrap so = myGen_i->getStudyServant()->FindObjectID( entry.c_str() );
+ if ( !so->_is_nil() )
+ {
+ CORBA::Object_var obj = so->GetObject();
+ shape = GEOM::GEOM_Object::_narrow( obj );
+ }
+ return shape._retn();
+ }
+
+ //================================================================================
+ /*!
+ * \brief Fill myGIPMap by calling GetInPlaceMap()
+ */
+ void buildGIPMap()
+ {
+ if ( !myGIPMapDone )
+ {
+ myGIPMapDone = true;
+
+ GEOM::GEOM_Object_var mainShapeNew = myNewMesh_i->GetShapeToMesh();
+ GEOM::GEOM_Object_var mainShapeOld = mySrcMesh_i->GetShapeToMesh();
+ GEOM::GEOM_Gen_var geomGen = myGen_i->GetGeomEngine( mainShapeNew );
+ GEOM::GEOM_IShapesOperations_wrap op = geomGen->GetIShapesOperations();
+ try
+ {
+ myGIPMap = op->GetInPlaceMap( mainShapeNew, mainShapeOld );
+ }
+ catch( ... )
+ {
+ myGIPMap = new GEOM::ListOfListOfLong();
+ }
+ }
+ }
+
+ //================================================================================
+ /*!
+ * \brief Get new sub-shape by calling GetInPlace()
+ */
+ GEOM::GEOM_Object_ptr getInPlace( GEOM::GEOM_Object_ptr oldShape )
+ {
+ GEOM::GEOM_Object_var newShape;
+
+ GEOM::GEOM_Object_var mainShapeNew = myNewMesh_i->GetShapeToMesh();
+ GEOM::GEOM_Gen_var geomGen = myGen_i->GetGeomEngine( mainShapeNew );
+ GEOM::GEOM_IShapesOperations_wrap op = geomGen->GetIShapesOperations();
+ try
+ {
+ newShape = op->GetInPlace( mainShapeNew, oldShape );
+ }
+ catch( ... )
+ {
+ }
+ return newShape._retn();
+ }
+
+ //================================================================================
+ /*!
+ * \brief Find a new sub-shape indices by an old one in myGIPMap. Return
+ * number of found IDs
+ */
+ int findNewIDs( int oldID, std::vector< int >& newIDs )
+ {
+ size_t prevNbIDs = newIDs.size();
+
+ if ( 0 < oldID && oldID < (int) myGIPMap->length() )
+ {
+ for ( CORBA::ULong i = 0; i < myGIPMap[ oldID ].length(); ++i )
+ newIDs.push_back( myGIPMap[ oldID ][ i ]);
+ }
+ return newIDs.size() - prevNbIDs;
+ }
+
+ //================================================================================
+ /*!
+ * \brief Check if an object relates to the old shape
+ */
+ bool isChildOfOld( GEOM::GEOM_Object_ptr oldShape )
+ {
+ if ( CORBA::is_nil( oldShape ))
+ return false;
+ GEOM::GEOM_Object_var mainShapeOld1 = mySrcMesh_i->GetShapeToMesh();
+ GEOM::GEOM_Object_var mainShapeOld2 = oldShape->GetMainShape();
+ return ( mainShapeOld1->_is_equivalent( mainShapeOld2 ) ||
+ mainShapeOld1->_is_equivalent( oldShape ));
+ }
+
+ //================================================================================
+ /*!
+ * \brief Return shape type by shape ID
+ */
+ TopAbs_ShapeEnum getShapeType( SMESH_Mesh_i* mesh_i, int shapeID )
+ {
+ SMESHDS_Mesh* meshDS = mesh_i->GetImpl().GetMeshDS();
+ const TopoDS_Shape& shape = meshDS->IndexToShape( shapeID );
+ return shape.IsNull() ? TopAbs_SHAPE : shape.ShapeType();
+ }
+
+ //================================================================================
+ /*!
+ * \brief Store a source sub-shape for which a counterpart not found and
+ * a smesh object invalid due to that
+ */
+ void AddInvalid( GEOM::GEOM_Object_var srcShape,
+ SALOMEDS::SObject_wrap smeshSO )
+ {
+ CORBA::String_var geomEntry = srcShape->GetStudyEntry();
+ if ( geomEntry.in()[0] && !smeshSO->_is_nil() )
+ {
+ CORBA::String_var smeshEntry = smeshSO->GetID();
+ myInvalidMap[ geomEntry.in() ].insert( smeshEntry.in() );
+ }
+ }
+
+ //================================================================================
+ /*!
+ * \brief Store a source sub-shape for which a counterpart not found and
+ * a smesh object invalid due to that
+ */
+ void AddInvalid( std::string geomEntry,
+ SALOMEDS::SObject_wrap smeshSO )
+ {
+ if ( !geomEntry.empty() )
+ {
+ CORBA::String_var smeshEntry = smeshSO->GetID();
+ myInvalidMap[ geomEntry ].insert( smeshEntry.in() );
+ }
+ }
+
+ //================================================================================
+ /*!
+ * \brief Store a source sub-shape for which a counterpart not found and
+ * a smesh object invalid due to that
+ */
+ void AddInvalid( int oldGeomID,
+ SALOMEDS::SObject_wrap smeshSO )
+ {
+ int shapeType = getShapeType( mySrcMesh_i, oldGeomID );
+ if ( shapeType < 0 || shapeType > TopAbs_SHAPE )
+ return;
+
+ const char* typeName[] = { "COMPOUND","COMPSOLID","SOLID","SHELL",
+ "FACE","WIRE","EDGE","VERTEX","SHAPE" };
+
+ SMESH_Comment geomName( typeName[ shapeType ]);
+ geomName << " #" << oldGeomID;
+
+ CORBA::String_var smeshEntry = smeshSO->GetID();
+ myInvalidMap[ geomName ].insert( smeshEntry.in() );
+ }
+
+ //================================================================================
+ /*!
+ * \brief Return entries of a source sub-shape for which a counterpart not found and
+ * of smesh objects invalid due to that
+ */
+ void GetInvalid( SMESH::string_array_out & theInvalidEntries,
+ std::vector< SALOMEDS::SObject_wrap > & theInvalidMeshSObjects)
+ {
+ int nbSO = 0;
+ TStr2StrSetMap::iterator entry2entrySet = myInvalidMap.begin();
+ for ( ; entry2entrySet != myInvalidMap.end(); ++entry2entrySet )
+ {
+ nbSO += 1 + entry2entrySet->second.size();
+ }
+ int iSO = theInvalidMeshSObjects.size(), iEntry = 0;
+ theInvalidEntries->length ( nbSO );
+ theInvalidMeshSObjects.resize( theInvalidMeshSObjects.size() + nbSO - myInvalidMap.size() );
+
+ entry2entrySet = myInvalidMap.begin();
+ for ( ; entry2entrySet != myInvalidMap.end(); ++entry2entrySet )
+ {
+ theInvalidEntries[ iEntry++ ] = entry2entrySet->first.c_str();
+
+ std::set< std::string > & entrySet = entry2entrySet->second;
+ std::set< std::string >::iterator entry = entrySet.begin();
+ for ( ; entry != entrySet.end(); ++entry )
+ {
+ theInvalidEntries[ iEntry++ ] = entry->c_str();
+
+ SALOMEDS::SObject_wrap so = myGen_i->getStudyServant()->FindObjectID( entry->c_str() );
+ if ( !so->_is_nil() )
+ theInvalidMeshSObjects[ iSO++ ] = so;
+ }
+ }
+ }
+
+ }; // struct ShapeMapper
+
+ //================================================================================
+ /*!
+ * \brief Append an item to a CORBA sequence
+ */
+ template < class CORBA_seq, class ITEM >
+ void append( CORBA_seq& seq, ITEM item )
+ {
+ if ( !CORBA::is_nil( item ))
+ {
+ seq->length( 1 + seq->length() );
+ seq[ seq->length() - 1 ] = item;
+ }
+ }
+} // namespace // utils for CopyMeshWithGeom()
+
+//================================================================================
+/*!
+ * \brief Create a mesh by copying definitions of another mesh to a given geometry
+ * \param [in] sourceMesh - a mesh to copy
+ * \param [in] newGeometry - a new geometry
+ * \param [in] toCopyGroups - to create groups in the new mesh
+ * \param [in] toReuseHypotheses - if True, existing hypothesis will be used by the new mesh,
+ * otherwise new hypotheses with the same parameters will be created for the new mesh.
+ * \param [in] toCopyElements - to copy mesh elements of same sub-shapes of the two geometries
+ * \param [out] newMesh - return a new mesh
+ * \param [out] newGroups - return new groups
+ * \param [out] newSubmeshes - return new sub-meshes
+ * \param [out] newHypotheses - return new algorithms and hypotheses
+ * \param [out] invalidEntries - return study entries of objects whose
+ * counterparts are not found in the newGeometry, followed by entries
+ * of mesh sub-objects that are invalid because they depend on a not found
+ * preceding sub-shape
+ * \return CORBA::Boolean - is a success
+ */
+//================================================================================
+
+CORBA::Boolean SMESH_Gen_i::CopyMeshWithGeom( SMESH::SMESH_Mesh_ptr theSourceMesh,
+ GEOM::GEOM_Object_ptr theNewGeometry,
+ const char* theMeshName,
+ CORBA::Boolean theToCopyGroups,
+ CORBA::Boolean theToReuseHypotheses,
+ CORBA::Boolean theToCopyElements,
+ SMESH::SMESH_Mesh_out theNewMesh,
+ SMESH::ListOfGroups_out theNewGroups,
+ SMESH::submesh_array_out theNewSubmeshes,
+ SMESH::ListOfHypothesis_out theNewHypotheses,
+ SMESH::string_array_out theInvalidEntries)
+throw ( SALOME::SALOME_Exception )
+{
+ if ( CORBA::is_nil( theSourceMesh ) ||
+ CORBA::is_nil( theNewGeometry ))
+ THROW_SALOME_CORBA_EXCEPTION( "NULL arguments", SALOME::BAD_PARAM );
+
+ if ( !theSourceMesh->HasShapeToMesh() )
+ THROW_SALOME_CORBA_EXCEPTION( "Source mesh not on geometry", SALOME::BAD_PARAM );
+
+ bool ok = true;
+ SMESH_TRY;
+
+ TPythonDump pyDump; // prevent dump from CreateMesh()
+
+ theNewMesh = CreateMesh( theNewGeometry );
+ theNewGroups = new SMESH::ListOfGroups();
+ theNewSubmeshes = new SMESH::submesh_array();
+ theNewHypotheses = new SMESH::ListOfHypothesis();
+ theInvalidEntries = new SMESH::string_array();
+
+ std::vector< SALOMEDS::SObject_wrap > invalidSObjects;
+
+ GEOM::GEOM_Object_var srcGeom = theSourceMesh->GetShapeToMesh();
+ GEOM::GEOM_Object_var geom, newGeom;
+ SALOMEDS::SObject_wrap so;
+
+ SMESH_Mesh_i* srcMesh_i = SMESH::DownCast<SMESH_Mesh_i*>( theSourceMesh );
+ SMESH_Mesh_i* newMesh_i = SMESH::DownCast<SMESH_Mesh_i*>( theNewMesh );
+ srcMesh_i->Load();
+
+ ShapeMapper shapeMapper( srcMesh_i, newMesh_i, this );
+
+ // treat hypotheses of mesh and sub-meshes
+ SMESH::submesh_array_var smList = theSourceMesh->GetSubMeshes();
+ for ( CORBA::ULong iSM = 0; iSM <= smList->length(); ++iSM )
+ {
+ bool isSubMesh = ( iSM < smList->length() );
+ if ( isSubMesh )
+ {
+ // create a new sub-mesh
+ SMESH::SMESH_subMesh_var newSM;
+ geom = smList[iSM]->GetSubShape();
+ so = ObjectToSObject( smList[iSM] );
+ CORBA::String_var name;
+ if ( !so->_is_nil() )
+ name = so->GetName();
+ newGeom = shapeMapper.FindNew( geom );
+ if ( newGeom->_is_nil() )
+ {
+ newSM = createInvalidSubMesh( theNewMesh, geom, name.in() );
+ shapeMapper.AddInvalid( geom, ObjectToSObject( newSM ));
+ ok = false;
+ }
+ else
+ {
+ newSM = theNewMesh->GetSubMesh( newGeom, name.in() );
+ }
+ append( theNewSubmeshes, newSM );
+
+ if ( newGeom->_is_nil() )
+ continue; // don't assign hypotheses
+ }
+ else
+ {
+ newGeom = GEOM::GEOM_Object::_duplicate( theNewGeometry );
+ geom = srcGeom;
+ so = ObjectToSObject( theNewMesh );
+ SetName( so, theMeshName, "Mesh" );
+ }
+
+ // assign hypotheses
+ SMESH::ListOfHypothesis_var hypList = theSourceMesh->GetHypothesisList( geom );
+ for ( CORBA::ULong iHyp = 0; iHyp < hypList->length(); ++iHyp )
+ {
+ SMESH::SMESH_Hypothesis_var hyp = hypList[ iHyp ];
+ SMESH_Hypothesis_i* hyp_i = SMESH::DownCast< SMESH_Hypothesis_i* >( hyp );
+
+ // get geometry hyp depends on
+ std::vector< std::string > entryArray;
+ std::vector< int > subIDArray;
+ bool dependsOnGeom = hyp_i->getObjectsDependOn( entryArray, subIDArray );
+
+ if ( !theToReuseHypotheses || dependsOnGeom )
+ {
+ // create a new hypothesis
+ CORBA::String_var type = hyp->GetName();
+ CORBA::String_var lib = hyp->GetLibName();
+ CORBA::String_var data = hyp_i->SaveTo();
+ if ( data.in()[0] )
+ {
+ hyp = CreateHypothesis( type, lib );
+ hyp_i = SMESH::DownCast< SMESH_Hypothesis_i* >( hyp );
+ hyp_i->LoadFrom( data.in() );
+ append( theNewHypotheses, hyp );
+ }
+ }
+
+ // update geometry hyp depends on
+ if ( dependsOnGeom )
+ {
+ for ( size_t iGeo = 0; iGeo < entryArray.size(); ++iGeo )
+ {
+ if ( !entryArray[ iGeo ].empty() )
+ {
+ std::string newEntry = shapeMapper.FindNew( entryArray[ iGeo ]);
+ if ( newEntry.empty() )
+ {
+ ok = false;
+ shapeMapper.AddInvalid( entryArray[ iGeo ], ObjectToSObject( hyp ));
+ shapeMapper.AddInvalid( entryArray[ iGeo ], so ); // sub-mesh
+ }
+ entryArray[ iGeo ] = newEntry;
+ }
+ }
+ for ( size_t iGeo = 0; iGeo < subIDArray.size(); ++iGeo )
+ {
+ if ( subIDArray[ iGeo ] > 0 )
+ {
+ int newID = shapeMapper.FindNew( subIDArray[ iGeo ]);
+ if ( newID < 1 )
+ {
+ ok = false;
+ shapeMapper.AddInvalid( subIDArray[ iGeo ], ObjectToSObject( hyp ));
+ shapeMapper.AddInvalid( subIDArray[ iGeo ], so ); // sub-mesh
+ }
+ subIDArray[ iGeo ] = newID;
+ }
+ }
+ if ( !hyp_i->setObjectsDependOn( entryArray, subIDArray ))
+ ok = false;
+ }
+
+ CORBA::String_var errorText;
+ theNewMesh->AddHypothesis( newGeom, hyp, errorText.out() );
+ if ( errorText.in()[0] )
+ ok = false;
+
+ } // loop on hypotheses
+ } // loop on sub-meshes and mesh
+
+
+ // copy mesh elements, keeping IDs
+ SMESHDS_Mesh* newMeshDS = newMesh_i->GetImpl().GetMeshDS();
+ if ( theToCopyElements && theSourceMesh->NbNodes() > 0 )
+ {
+ ::SMESH_MeshEditor editor( &newMesh_i->GetImpl() );
+ ::SMESH_MeshEditor::ElemFeatures elemData;
+
+ SMESH_subMesh* srcMainSM = srcMesh_i->GetImpl().GetSubMeshContaining( 1 );
+ SMESH_subMeshIteratorPtr srcSMIt = srcMainSM->getDependsOnIterator( /*includeSelf=*/true,
+ /*vertexLast=*/false);
+ while ( srcSMIt->more() )
+ {
+ SMESH_subMesh* srcSM = srcSMIt->next();
+ if ( srcSM->IsEmpty() )
+ continue; // not yet computed
+ int newID = shapeMapper.FindNewNotChanged( srcSM );
+ if ( newID < 1 )
+ continue;
+
+ SMESHDS_SubMesh* srcSMDS = srcSM->GetSubMeshDS();
+ SMDS_NodeIteratorPtr nIt = srcSMDS->GetNodes();
+ while ( nIt->more() )
+ {
+ SMESH_NodeXYZ node( nIt->next() );
+ const SMDS_MeshNode* newNode = newMeshDS->AddNodeWithID( node.X(), node.Y(), node.Z(),
+ node->GetID() );
+ const SMDS_PositionPtr pos = node->GetPosition();
+ const double* uv = pos->GetParameters();
+ switch ( pos->GetTypeOfPosition() )
+ {
+ case SMDS_TOP_3DSPACE: newMeshDS->SetNodeInVolume( newNode, newID ); break;
+ case SMDS_TOP_FACE: newMeshDS->SetNodeOnFace ( newNode, newID, uv[0], uv[1] ); break;
+ case SMDS_TOP_EDGE: newMeshDS->SetNodeOnEdge ( newNode, newID, uv[0] ); break;
+ case SMDS_TOP_VERTEX: newMeshDS->SetNodeOnVertex( newNode, newID ); break;
+ default: ;
+ }
+ }
+ SMDS_ElemIteratorPtr eIt = srcSMDS->GetElements();
+ while( eIt->more() )
+ {
+ const SMDS_MeshElement* e = eIt->next();
+ elemData.Init( e, /*basicOnly=*/false );
+ elemData.SetID( e->GetID() );
+ elemData.myNodes.resize( e->NbNodes() );
+ SMDS_NodeIteratorPtr nnIt = e->nodeIterator();
+ size_t iN;
+ for ( iN = 0; nnIt->more(); ++iN )
+ {
+ const SMDS_MeshNode* srcNode = nnIt->next();
+ elemData.myNodes[ iN ] = newMeshDS->FindNode( srcNode->GetID() );
+ if ( !elemData.myNodes[ iN ])
+ break;
+ }
+ if ( iN == elemData.myNodes.size() )
+ if ( const SMDS_MeshElement * newElem = editor.AddElement( elemData.myNodes, elemData ))
+ newMeshDS->SetMeshElementOnShape( newElem, newID );
+ }
+ if ( SMESH_subMesh* newSM = newMesh_i->GetImpl().GetSubMeshContaining( newID ))
+ newSM->ComputeStateEngine( SMESH_subMesh::CHECK_COMPUTE_STATE );
+ }
+
+ newMeshDS->Modified();
+ }
+
+
+ // treat groups
+
+ TStr2StrMap old2newGroupMap;
+
+ SALOME::GenericObj_wrap< SMESH::FilterManager > filterMgr = CreateFilterManager();
+
+ SMESH::ListOfGroups_var groups = theSourceMesh->GetGroups();
+ CORBA::ULong nbGroups = theToCopyGroups ? groups->length() : 0, nbAddedGroups = 0;
+ for ( CORBA::ULong i = 0; i < nbGroups + nbAddedGroups; ++i )
+ {
+ SMESH::SMESH_Group_var stdlGroup = SMESH::SMESH_Group::_narrow ( groups[ i ]);
+ SMESH::SMESH_GroupOnGeom_var geomGroup = SMESH::SMESH_GroupOnGeom::_narrow ( groups[ i ]);
+ SMESH::SMESH_GroupOnFilter_var fltrGroup = SMESH::SMESH_GroupOnFilter::_narrow( groups[ i ]);
+
+ CORBA::String_var name = groups[ i ]->GetName();
+ SMESH::ElementType elemType = groups[ i ]->GetType();
+
+ SMESH::SMESH_GroupBase_var newGroup;
+
+ if ( !stdlGroup->_is_nil() )
+ {
+ if ( newMeshDS->GetMeshInfo().NbElements( SMDSAbs_ElementType( elemType )) > 0 )
+ {
+ SMESH::long_array_var elemIDs = stdlGroup->GetIDs();
+ const bool isElem = ( elemType != SMESH::NODE );
+ CORBA::ULong iE = 0;
+ for ( ; iE < elemIDs->length(); ++iE ) // check if any element has been copied
+ if ( newMeshDS->GetElementType( elemIDs[ iE ], isElem ) != SMDSAbs_All )
+ break;
+ if ( iE < elemIDs->length() )
+ {
+ stdlGroup = theNewMesh->CreateGroup( elemType, name );
+ stdlGroup->Add( elemIDs );
+ newGroup = SMESH::SMESH_GroupBase::_narrow( stdlGroup );
+ }
+ }
+ }
+ else if ( !geomGroup->_is_nil() )
+ {
+ GEOM::GEOM_Object_var geom = geomGroup->GetShape();
+ GEOM::GEOM_Object_var newGeom = shapeMapper.FindNew( geom );
+ if ( newGeom->_is_nil() )
+ {
+ newGroup = theNewMesh->CreateGroup( elemType, name ); // just to notify the user
+ shapeMapper.AddInvalid( geom, ObjectToSObject( newGroup ));
+ ok = false;
+ }
+ else
+ {
+ newGroup = theNewMesh->CreateGroupFromGEOM( elemType, name, newGeom );
+ }
+ }
+ else if ( !fltrGroup->_is_nil() )
+ {
+ // replace geometry in a filter
+ SMESH::Filter_var filter = fltrGroup->GetFilter();
+ SMESH::Filter::Criteria_var criteria;
+ filter->GetCriteria( criteria.out() );
+
+ bool isMissingGroup = false;
+ std::vector< std::string > badEntries;
+
+ for ( CORBA::ULong iCr = 0; iCr < criteria->length(); ++iCr )
+ {
+ const char* thresholdID = criteria[ iCr ].ThresholdID.in();
+ switch ( criteria[ iCr ].Type )
+ {
+ case SMESH::FT_BelongToMeshGroup:
+ {
+ SALOME::GenericObj_wrap< SMESH::BelongToMeshGroup > btgg = filterMgr->CreateBelongToMeshGroup();
+ btgg->SetGroupID( thresholdID );
+ SMESH::SMESH_GroupBase_ptr refGroup = btgg->GetGroup();
+ SALOMEDS::SObject_wrap refGroupSO = ObjectToSObject( refGroup );
+ if ( refGroupSO->_is_nil() )
+ break;
+ CORBA::String_var refID = refGroupSO->GetID();
+ TStr2StrMap::iterator o2nID = old2newGroupMap.find( refID.in() );
+ if ( o2nID == old2newGroupMap.end() )
+ {
+ isMissingGroup = true; // corresponding new group not yet created
+ break;
+ }
+ criteria[ iCr ].ThresholdID = o2nID->second.c_str();
+
+ if ( o2nID->second.empty() ) // new referred group is invalid
+ badEntries.push_back( refID.in() );
+ break;
+ }
+ case SMESH::FT_BelongToGeom:
+ case SMESH::FT_BelongToPlane:
+ case SMESH::FT_BelongToCylinder:
+ case SMESH::FT_BelongToGenSurface:
+ case SMESH::FT_LyingOnGeom:
+ {
+ std::string newID = shapeMapper.FindNew( thresholdID );
+ criteria[ iCr ].ThresholdID = newID.c_str();
+ if ( newID.empty() )
+ badEntries.push_back( thresholdID );
+ break;
+ }
+ case SMESH::FT_ConnectedElements:
+ {
+ if ( thresholdID && thresholdID[0] )
+ {
+ std::string newID = shapeMapper.FindNew( thresholdID );
+ criteria[ iCr ].ThresholdID = newID.c_str();
+ if ( newID.empty() )
+ badEntries.push_back( thresholdID );
+ }
+ break;
+ }
+ default:;
+ }
+ } // loop on criteria
+
+ if ( isMissingGroup && i < nbGroups )
+ {
+ // to treat the group again
+ append( groups, SMESH::SMESH_GroupBase::_duplicate( groups[ i ]));
+ ++nbAddedGroups;
+ continue;
+ }
+ SMESH::Filter_var newFilter = filterMgr->CreateFilter();
+ newFilter->SetCriteria( criteria );
+
+ newGroup = theNewMesh->CreateGroupFromFilter( elemType, name, newFilter );
+ newFilter->UnRegister();
+
+ SALOMEDS::SObject_wrap newSO = ObjectToSObject( newGroup );
+ for ( size_t iEnt = 0; iEnt < badEntries.size(); ++iEnt )
+ shapeMapper.AddInvalid( badEntries[ iEnt ], newSO );
+
+ if ( isMissingGroup ) // all groups treated but a referred groups still not found
+ {
+ invalidSObjects.push_back( ObjectToSObject( newGroup ));
+ ok = false;
+ }
+ if ( !badEntries.empty() )
+ ok = false;
+
+ } // treat a group on filter
+
+ append( theNewGroups, newGroup );
+
+ // fill old2newGroupMap
+ SALOMEDS::SObject_wrap srcSO = ObjectToSObject( groups[i] );
+ SALOMEDS::SObject_wrap newSO = ObjectToSObject( newGroup );
+ if ( !srcSO->_is_nil() )
+ {
+ CORBA::String_var srcID, newID("");
+ srcID = srcSO->GetID();
+ if ( !newSO->_is_nil() )
+ newID = newSO->GetID();
+ old2newGroupMap.insert( std::make_pair( std::string( srcID.in() ),
+ std::string( newID.in() )));
+ }
+
+ if ( newGroup->_is_nil() )
+ ok = false;
+
+ } // loop on groups
+
+ newMeshDS->CompactMesh();
+
+ // set mesh name
+ if ( !theMeshName || !theMeshName[0] )
+ {
+ SALOMEDS::SObject_wrap soNew = ObjectToSObject( theNewMesh );
+ SALOMEDS::SObject_wrap soOld = ObjectToSObject( theSourceMesh );
+ CORBA::String_var oldName = soOld->GetName();
+ SetName( soNew, oldName.in(), "Mesh" );
+ }
+ // mark invalid objects
+ shapeMapper.GetInvalid( theInvalidEntries, invalidSObjects );
+
+ for ( size_t i = 0; i < invalidSObjects.size(); ++i )
+ highLightInvalid( invalidSObjects[i].in(), true );
+
+ pyDump << "ok, "
+ << theNewMesh << ", "
+ << theNewGroups << ", "
+ << *theNewSubmeshes.ptr() << ", "
+ << *theNewHypotheses.ptr() << ", "
+ << "invalidEntries = " << this << ".CopyMeshWithGeom( "
+ << theSourceMesh << ", "
+ << theNewGeometry << ", "
+ << "'" << theMeshName << "', "
+ << theToCopyGroups << ", "
+ << theToReuseHypotheses << ", "
+ << theToCopyElements << " )";
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+
+ return ok;