#include "MED_Factory.hxx"
#include "SMDS_EdgePosition.hxx"
#include "SMDS_FacePosition.hxx"
-#include "SMDS_PolyhedralVolumeOfNodes.hxx"
#include "SMDS_SetIterator.hxx"
#include "SMDS_SpacePosition.hxx"
#include "SMDS_VertexPosition.hxx"
#include "SMESH_PreMeshInfo.hxx"
#include "SMESH_PythonDump.hxx"
#include "SMESH_ControlsDef.hxx"
+
+// to pass CORBA exception through SMESH_TRY
+#define SMY_OWN_CATCH catch( SALOME::SALOME_Exception& se ) { throw se; }
#include "SMESH_TryCatch.hxx" // to include after OCC headers!
#include CORBA_SERVER_HEADER(SMESH_Group)
#include CORBA_SERVER_HEADER(SMESH_MeshEditor)
+#include <GEOMImpl_Types.hxx>
#include <GEOM_Client.hxx>
#include <Basics_Utils.hxx>
#include <sstream>
#include <cstdio>
#include <cstdlib>
+#include <memory>
using namespace std;
using SMESH::TPythonDump;
PortableServer::Servant aServant = GetPOA()->reference_to_servant( theObject );
return aServant;
}
- catch (...) {
+ catch (PortableServer::POA::ObjectNotActive &ex)
+ {
+ INFOS("GetServant: ObjectNotActive");
+ return NULL;
+ }
+ catch (PortableServer::POA::WrongAdapter &ex)
+ {
+ INFOS("GetServant: WrongAdapter: OK when several servants used to build several mesh in parallel...");
+ return NULL;
+ }
+ catch (PortableServer::POA::WrongPolicy &ex)
+ {
+ INFOS("GetServant: WrongPolicy");
+ return NULL;
+ }
+ catch (...)
+ {
INFOS( "GetServant - Unknown exception was caught!!!" );
return NULL;
}
{
// load plugin library
if(MYDEBUG) MESSAGE("Loading server meshers plugin library ...");
- LibHandle libHandle = LoadLib( aPlatformLibName.c_str() );
+#ifdef WIN32
+#ifdef UNICODE
+ const wchar_t* path = Kernel_Utils::decode_s(aPlatformLibName);
+#else
+ const char* path = aPlatformLibName.c_str();
+#endif
+#else
+ const char* path = aPlatformLibName.c_str();
+#endif
+ LibHandle libHandle = LoadLib( path );
+#if defined(WIN32) && defined(UNICODE)
+ delete path;
+#endif
if (!libHandle)
{
// report any error, if occurred
else {
errStruct.algoName = error->myAlgo->GetName();
}
- errStruct.hasBadMesh = !error->myBadElements.empty();
+ errStruct.hasBadMesh = error->HasBadElems();
}
}
error_array->length( nbErr );
{
// compute error
SMESH_ComputeErrorPtr error = sm->GetComputeError();
- if ( error && !error->myBadElements.empty())
+ if ( error && error->HasBadElems() )
{
typedef map<const SMDS_MeshElement*, int > TNode2LocalIDMap;
typedef TNode2LocalIDMap::iterator TNodeLocalID;
list< TNodeLocalID > connectivity;
int i, nbElements = 0, nbConnNodes = 0;
- list<const SMDS_MeshElement*>::iterator elemIt = error->myBadElements.begin();
- list<const SMDS_MeshElement*>::iterator elemEnd = error->myBadElements.end();
+ const list<const SMDS_MeshElement*>& badElems =
+ static_cast<SMESH_BadInputElements*>( error.get() )->myBadElements;
+ list<const SMDS_MeshElement*>::const_iterator elemIt = badElems.begin();
+ list<const SMDS_MeshElement*>::const_iterator elemEnd = badElems.end();
for ( ; elemIt != elemEnd; ++elemIt, ++nbElements )
{
SMDS_ElemIteratorPtr nIt = (*elemIt)->nodesIterator();
}
// fill element types
result->elementTypes.length( nbElements );
- for ( i = 0, elemIt = error->myBadElements.begin(); i <nbElements; ++i, ++elemIt )
+ for ( i = 0, elemIt = badElems.begin(); i <nbElements; ++i, ++elemIt )
{
const SMDS_MeshElement* elem = *elemIt;
result->elementTypes[i].SMDS_ElementType = (SMESH::ElementType) elem->GetType();
try {
// get mesh servant
- SMESH_Mesh_i* meshServant = dynamic_cast<SMESH_Mesh_i*>( GetServant( theMesh ).in() );
+ SMESH_Mesh_i* meshServant = SMESH::DownCast<SMESH_Mesh_i*>( theMesh );
ASSERT( meshServant );
if ( meshServant ) {
meshServant->Load();
- // NPAL16168: "geometrical group edition from a submesh don't modifiy mesh computation"
+ // NPAL16168: "geometrical group edition from a submesh don't modify mesh computation"
meshServant->CheckGeomModif();
// get local TopoDS_Shape
TopoDS_Shape myLocShape;
bool ok = myGen.Compute( myLocMesh, myLocShape, how );
meshServant->CreateGroupServants(); // algos can create groups (issue 0020918)
myLocMesh.GetMeshDS()->Modified();
+ UpdateIcons( theMesh );
+ if ( ok )
+ HighLightInvalid( theMesh, /*isInvalid=*/false );
return ok;
}
}
meshServant->Load();
ASSERT( meshServant );
if ( meshServant ) {
- // NPAL16168: "geometrical group edition from a submesh don't modifiy mesh computation"
+ // NPAL16168: "geometrical group edition from a submesh don't modify mesh computation"
meshServant->CheckGeomModif();
// get local TopoDS_Shape
TopoDS_Shape myLocShape;
ASSERT( meshServant );
if ( meshServant ) {
meshServant->Load();
- // NPAL16168: "geometrical group edition from a submesh don't modifiy mesh computation"
+ // NPAL16168: "geometrical group edition from a submesh don't modify mesh computation"
meshServant->CheckGeomModif();
// get local TopoDS_Shape
TopoDS_Shape myLocShape;
CORBA::Boolean theCommonGroups)
throw ( SALOME::SALOME_Exception )
{
- typedef list<SMESH::SMESH_Group_var> TListOfNewGroups;
- typedef map< pair<string, SMESH::ElementType>, TListOfNewGroups > TGroupsMap;
-
- TPythonDump* pPythonDump = new TPythonDump;
- TPythonDump& aPythonDump = *pPythonDump; // prevent dump of called methods
+ std::unique_ptr< TPythonDump > pPythonDump( new TPythonDump );
+ TPythonDump& pythonDump = *pPythonDump; // prevent dump of called methods
// create mesh
- SMESH::SMESH_Mesh_var aNewMesh = CreateEmptyMesh();
-
- if ( aNewMesh->_is_nil() )
- return aNewMesh._retn();
+ SMESH::SMESH_Mesh_var newMesh = CreateEmptyMesh();
+ SMESH_Mesh_i* newImpl = SMESH::DownCast<SMESH_Mesh_i*>( newMesh );
+ if ( !newImpl ) return newMesh._retn();
- SMESH_Mesh_i* aNewImpl = SMESH::DownCast<SMESH_Mesh_i*>( aNewMesh );
- if ( !aNewImpl )
- return aNewMesh._retn();
+ ::SMESH_Mesh& locMesh = newImpl->GetImpl();
+ SMESHDS_Mesh* newMeshDS = locMesh.GetMeshDS();
- ::SMESH_Mesh& aLocMesh = aNewImpl->GetImpl();
- SMESHDS_Mesh* aNewMeshDS = aLocMesh.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;
- TGroupsMap aGroupsMap;
- TListOfNewGroups aListOfNewGroups;
- ::SMESH_MeshEditor aNewEditor(&aLocMesh);
- SMESH::ListOfGroups_var aListOfGroups;
-
- ::SMESH_MeshEditor::ElemFeatures elemType;
- std::vector<const SMDS_MeshNode*> aNodesArray;
+ ::SMESH_MeshEditor newEditor( &locMesh );
+ ::SMESH_MeshEditor::ElemFeatures elemType;
// loop on sub-meshes
- for ( CORBA::ULong i = 0; i < theMeshesArray.length(); i++)
+ 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<SMESH_Mesh_i*>( anInitMesh );
- if ( !anInitImpl ) continue;
- anInitImpl->Load();
-
- //::SMESH_Mesh& aInitLocMesh = anInitImpl->GetImpl();
- //SMESHDS_Mesh* anInitMeshDS = aInitLocMesh.GetMeshDS();
+ SMESH::SMESH_Mesh_var initMesh = theMeshesArray[i]->GetMesh();
+ SMESH_Mesh_i* initImpl = SMESH::DownCast<SMESH_Mesh_i*>( initMesh );
+ if ( !initImpl ) continue;
+ initImpl->Load();
+
+ // assure that IDs increments 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 = aNewMesh->GetNbElementsByType();
+ SMESH::long_array_var prevState = newMesh->GetNbElementsByType();
+
+ // copy nodes
- typedef std::map<const SMDS_MeshElement*, const SMDS_MeshElement*, TIDCompare > TEEMap;
- TEEMap elemsMap, nodesMap;
+ 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() );
+ }
- // 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;
+ // copy elements
- while ( itElems->more() )
+ std::vector< const SMDS_MeshElement* > newElems( initMeshDS->NbElements() + 1, 0 );
+ elemIt = initImpl->GetElements( theMeshesArray[i], SMESH::ALL );
+ while ( elemIt->more() )
{
- anElem = itElems->next();
- anElemNbNodes = anElem->NbNodes();
- aNodesArray.resize( anElemNbNodes );
+ const SMDS_MeshElement* elem = elemIt->next();
+ elemType.myNodes.resize( elem->NbNodes() );
- // loop on nodes of an element
- SMDS_ElemIteratorPtr itNodes = anElem->nodesIterator();
+ SMDS_NodeIteratorPtr itNodes = elem->nodeIterator();
for ( int k = 0; itNodes->more(); k++)
{
- aNode = static_cast<const SMDS_MeshNode*>( 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<const SMDS_MeshNode*>( n2nnIt->second );
- }
- aNodesArray[k] = aNewNode;
+ 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
- if ( anElem->GetType() == SMDSAbs_Node )
- aNewElem = 0;
- else
- aNewElem =
- aNewEditor.AddElement( aNodesArray, elemType.Init( anElem, /*basicOnly=*/false ));
-
- if ( aNewElem )
- elemsMap.insert( make_pair( anElem, aNewElem ));
-
- } //elems loop
-
- aNewEditor.ClearLastCreated(); // forget the history
+ 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 aNewGroup;
- SMESH::ElementType aGroupType;
+ SMESH::SMESH_Group_var newGroup;
+ SMESH::ElementType groupType;
if ( theCommonGroups )
{
- SMESH::long_array_var curState = aNewMesh->GetNbElementsByType();
+ // 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( aGroupType = SMESH::NODE;
- aGroupType < SMESH::NB_ELEMENT_TYPES;
- aGroupType = (SMESH::ElementType)( aGroupType + 1 ))
+ for( groupType = SMESH::NODE;
+ groupType < SMESH::NB_ELEMENT_TYPES;
+ groupType = (SMESH::ElementType)( groupType + 1 ))
{
- if ( curState[ aGroupType ] <= prevState[ aGroupType ])
- continue;
+ if ( curState[ groupType ] <= prevState[ groupType ])
+ continue; // no elements of groupType added from the i-th mesh
// 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]=0;
- }
- string groupName = "Gr";
- SALOMEDS::SObject_wrap aMeshSObj = ObjectToSObject( theMeshesArray[i] );
- if ( aMeshSObj ) {
- CORBA::String_var name = aMeshSObj->GetName();
+ std::string groupName = "Gr";
+ SALOMEDS::SObject_wrap meshSO = ObjectToSObject( theMeshesArray[i] );
+ if ( meshSO ) {
+ CORBA::String_var name = meshSO->GetName();
groupName += name;
}
groupName += "_";
- groupName += typeNames[ aGroupType ];
+ groupName += typeNames[ groupType ];
// 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<SMESH_Group_i*>( aNewGroup ))
+ 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() ))
{
- TEEMap::iterator e2neIt = e2neMap.begin();
- for ( ; e2neIt != e2neMap.end(); ++e2neIt )
+ for ( size_t j = 0; j < elemVec.size(); ++j )
{
- aNewElem = e2neIt->second;
- if ( aNewElem->GetType() == grpDS->GetType() )
- {
- grpDS->Add( aNewElem );
-
- if ( prevState[ aGroupType ]++ >= curState[ aGroupType ] )
- break;
- }
+ if ( elemVec[j] && elemVec[j]->GetType() == grpDS->GetType() )
+ grpDS->Add( elemVec[j] );
}
}
}
- aListOfNewGroups.clear();
- aListOfNewGroups.push_back(aNewGroup);
- aGroupsMap.insert(make_pair( make_pair(groupName, aGroupType), aListOfNewGroups ));
+ listOfNewGroups.clear();
+ listOfNewGroups.push_back( newGroup );
+ groupsMap.insert( std::make_pair( TNameAndType( groupName, groupType ),
+ listOfNewGroups ));
}
}
- if ( SMESH_Mesh_i* anSrcImpl = SMESH::DownCast<SMESH_Mesh_i*>( theMeshesArray[i] ))
+ if ( SMESH_Mesh_i* initImpl = SMESH::DownCast<SMESH_Mesh_i*>( 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 ));
- }
- }
- }
-
// copy groups
- SMESH::SMESH_GroupBase_ptr aGroup;
- CORBA::String_var aGroupName;
- SMESH::long_array_var anNewIDs = new SMESH::long_array();
+ 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
- aListOfGroups = anSrcImpl->GetGroups();
- for ( CORBA::ULong iG = 0; iG < aListOfGroups->length(); iG++ )
+ SMESH::ListOfGroups_var listOfGroups = initImpl->GetGroups();
+ for ( CORBA::ULong iG = 0; iG < listOfGroups->length(); iG++ )
{
- aGroup = aListOfGroups[iG];
- aGroupType = aGroup->GetType();
- aGroupName = aGroup->GetName();
- string aName = aGroupName.in();
+ group = listOfGroups[iG];
+ groupType = group->GetType();
+ groupName = group->GetName();
+ std::string name = groupName.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;
+ 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() )
{
- anElem = itGrElems->next();
- TEEMap::iterator e2neIt = e2neMap.find( anElem );
- if ( e2neIt != e2neMap.end() )
- anNewIDs[ iElem++ ] = e2neIt->second->GetID();
+ const SMDS_MeshElement* elem = itGrElems->next();
+ const SMDS_MeshElement* newElem = elemVec[ elem->GetID() ];
+ if ( newElem )
+ newIDs[ nbElems++ ] = newElem->GetID();
}
- anNewIDs->length( iElem );
+ newIDs->length( nbElems );
- // 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() ) {
+ // 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
- aNewGroup = aNewImpl->CreateGroup( aGroupType, aGroupName.in() );
- // add elements into new group
- aNewGroup->Add( anNewIDs );
+ newGroup = newImpl->CreateGroup( groupType, groupName.in() );
+ newGroup->Add( newIDs );
- aListOfNewGroups.push_back(aNewGroup);
- aGroupsMap.insert(make_pair( make_pair(aName, aGroupType), aListOfNewGroups ));
+ listOfNewGroups.push_back( newGroup );
+ groupsMap.insert( std::make_pair( nameAndType, listOfNewGroups ));
}
-
- else if ( theUniteIdenticalGroups ) {
+ else if ( theUniteIdenticalGroups )
+ {
// unite identical groups
TListOfNewGroups& aNewGroups = anIter->second;
- aNewGroups.front()->Add( anNewIDs );
+ aNewGroups.front()->Add( newIDs );
}
-
- else {
+ else
+ {
// rename identical groups
- aNewGroup = aNewImpl->CreateGroup(aGroupType, aGroupName.in());
- aNewGroup->Add( anNewIDs );
+ newGroup = newImpl->CreateGroup( groupType, groupName );
+ newGroup->Add( newIDs );
- TListOfNewGroups& aNewGroups = anIter->second;
- string aNewGroupName;
- if (aNewGroups.size() == 1) {
- aNewGroupName = aName + "_1";
- aNewGroups.front()->SetName(aNewGroupName.c_str());
+ TListOfNewGroups& newGroups = anIter->second;
+ std::string newGroupName;
+ if ( newGroups.size() == 1 )
+ {
+ newGroupName = name + "_1";
+ newGroups.front()->SetName( newGroupName.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);
+ newGroupName = name + "_" + SMESH_Comment( newGroups.size() + 1 );
+ newGroup->SetName( newGroupName.c_str() );
+ newGroups.push_back( newGroup );
}
- } //groups loop
+ } // loop on groups
} // if an IDSource is a mesh
} //meshes loop
- if (theMergeNodesAndElements) // merge nodes
+ if ( theMergeNodesAndElements ) // merge nodes
{
- TIDSortedNodeSet aMeshNodes; // no input nodes
- SMESH_MeshEditor::TListOfListOfNodes aGroupsOfNodes;
- aNewEditor.FindCoincidentNodes( aMeshNodes, theMergeTolerance, aGroupsOfNodes,
- /*SeparateCornersAndMedium=*/ false );
- aNewEditor.MergeNodes( aGroupsOfNodes );
+ TIDSortedNodeSet meshNodes; // no input nodes == treat all
+ SMESH_MeshEditor::TListOfListOfNodes groupsOfNodes;
+ newEditor.FindCoincidentNodes( meshNodes, theMergeTolerance, groupsOfNodes,
+ /*SeparateCornersAndMedium=*/ false );
+ newEditor.MergeNodes( groupsOfNodes );
// merge elements
- aNewEditor.MergeEqualElements();
+ newEditor.MergeEqualElements();
}
// Update Python script
- aPythonDump << aNewMesh << " = " << this << "."
- << ( theCommonGroups ? "ConcatenateWithGroups" : "Concatenate" )
- << "([";
- for ( CORBA::ULong i = 0; i < theMeshesArray.length(); i++) {
- if (i > 0) aPythonDump << ", ";
- aPythonDump << theMeshesArray[i];
- }
- aPythonDump << "], ";
- aPythonDump << theUniteIdenticalGroups << ", "
- << theMergeNodesAndElements << ", "
- << TVar( theMergeTolerance ) << ")";
+ pythonDump << newMesh << " = " << this
+ << "." << ( theCommonGroups ? "ConcatenateWithGroups" : "Concatenate" ) << "("
+ << theMeshesArray << ", "
+ << theUniteIdenticalGroups << ", "
+ << theMergeNodesAndElements << ", "
+ << TVar( theMergeTolerance ) << ")";
- delete pPythonDump; // enable python dump from GetGroups()
+ pPythonDump.reset(); // enable python dump from GetGroups()
// 0020577: EDF 1164 SMESH: Bad dump of concatenate with create common groups
- if ( !aNewMesh->_is_nil() )
+ if ( !newMesh->_is_nil() )
{
- SMESH::ListOfGroups_var groups = aNewMesh->GetGroups();
+ SMESH::ListOfGroups_var groups = newMesh->GetGroups();
}
// IPAL21468 Change icon of compound because it need not be computed.
- SALOMEDS::SObject_wrap aMeshSObj = ObjectToSObject( aNewMesh );
- SetPixMap( aMeshSObj, "ICON_SMESH_TREE_MESH" );
+ SALOMEDS::SObject_wrap meshSO = ObjectToSObject( newMesh );
+ SetPixMap( meshSO, "ICON_SMESH_TREE_MESH" );
- if (aNewMeshDS)
- aNewMeshDS->Modified();
+ newMeshDS->Modified();
- return aNewMesh._retn();
+ return newMesh._retn();
}
//================================================================================
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
<< toCopyGroups << ", "
<< toKeepIDs << ")";
- delete pyDump; pyDump = 0; // allow dump in GetGroups()
+ 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;
+
+ //================================================================================
+ /*!
+ * \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
+
+ 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() )));
+
+ SALOMEDS::Study_var study = myGen_i->getStudyServant();
+ GEOM::GEOM_Gen_var geomGen = myGen_i->GetGeomEngine();
+ GEOM::GEOM_IShapesOperations_wrap op = geomGen->GetIShapesOperations();
+ GEOM::ListOfGO_var subShapes = op->GetExistingSubObjects( mainShapeNew,
+ /*groupsOnly=*/false );
+ for ( CORBA::ULong i = 0; i < subShapes->length(); ++i )
+ {
+ newSO = myGen_i->ObjectToSObject( subShapes[ i ]);
+ SALOMEDS::ChildIterator_wrap anIter = study->NewChildIterator( newSO );
+ for ( ; anIter->More(); anIter->Next() )
+ {
+ SALOMEDS::SObject_wrap so = anIter->Value();
+ if ( so->ReferencedObject( oldSO.inout() ))
+ {
+ oldEntry = oldSO->GetID();
+ newEntry = newSO->GetID();
+ myOld2NewEntryMap.insert( std::make_pair( std::string( oldEntry.in() ),
+ std::string( newEntry.in() )));
+ }
+ }
+ }
+ }
+
+ //================================================================================
+ /*!
+ * \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();
+
+ // try to find by entry
+ 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() )
+ {
+ // 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.empty() )
+ {
+ try
+ {
+ 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();
+ GEOM::GEOM_IShapesOperations_wrap op = geomGen->GetIShapesOperations();
+ try
+ {
+ myGIPMap = op->GetInPlaceMap( mainShapeNew, mainShapeOld );
+ }
+ catch( ... )
+ {
+ myGIPMap = new GEOM::ListOfListOfLong();
+ }
+ }
+ }
+
+ //================================================================================
+ /*!
+ * \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
+ * preceeding 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;
+}
+
//================================================================================
/*!
* \brief Get version of MED format being used.
/*!
* SMESH_Gen_i::CheckCompatibility
*
- * Check compatibility of file with MED format being used.
+ * Check compatibility of file with MED format being used, read only.
*/
//================================================================================
CORBA::Boolean SMESH_Gen_i::CheckCompatibility(const char* theFileName)
return MED::CheckCompatibility( theFileName );
}
+//================================================================================
+/*!
+ * SMESH_Gen_i::CheckWriteCompatibility
+ *
+ * Check compatibility of file with MED format being used, for append on write.
+ */
+//================================================================================
+CORBA::Boolean SMESH_Gen_i::CheckWriteCompatibility(const char* theFileName)
+{
+ return MED::CheckCompatibility( theFileName, true );
+}
+
//================================================================================
/*!
* SMESH_Gen_i::GetMeshNames
//================================================================================
SMESH::string_array* SMESH_Gen_i::GetMeshNames(const char* theFileName)
{
+ //MESSAGE("GetMeshNames " << theFileName);
SMESH::string_array_var aResult = new SMESH::string_array();
MED::PWrapper aMed = MED::CrWrapperR( theFileName );
MED::TErr anErr;
MED::TInt aNbMeshes = aMed->GetNbMeshes( &anErr );
+ //MESSAGE("---" << aNbMeshes);
if( anErr >= 0 ) {
aResult->length( aNbMeshes );
for( MED::TInt i = 0; i < aNbMeshes; i++ ) {
myMesh->Load(); // load from study file if not yet done
TPythonDump pd; // not to dump GetGroups()
SMESH::ListOfGroups_var groups = myMesh->GetGroups();
- pd << ""; // to avoid optimizing pd out
for ( CORBA::ULong i = 0; i < groups->length(); ++i )
{
SMESH_GroupBase_i* grImpl = SMESH::DownCast<SMESH_GroupBase_i*>( groups[i]);
if ( !myHyp->_is_nil() ) {
SMESH_Hypothesis_i* myImpl = dynamic_cast<SMESH_Hypothesis_i*>( GetServant( myHyp ).in() );
if ( myImpl ) {
- string hypname = string( myHyp->GetName() );
- string libname = string( myHyp->GetLibName() );
+ CORBA::String_var hn = myHyp->GetName(), ln = myHyp->GetLibName();
+ std::string hypname = hn.in();
+ std::string libname = ln.in();
// BUG SWP13062
// Needs for save crossplatform libname, i.e. parth of name ( ".dll" for
// WIN32 and ".so" for X-system) must be deleted
// PAL17753 (Regression: missing hypothesis in restored study)
// "lib" also should be removed from the beginning
//if( libname_len > 3 )
- //libname.resize( libname_len - 3 );
+ //libname.resize( libname_len - 3 );
if( libname_len > 6 )
libname = libname.substr( 3, libname_len - 3 - 3 );
#endif
- CORBA::String_var objStr = GetORB()->object_to_string( anObject );
- int id = myStudyContext->findId( string( objStr.in() ) );
- string hypdata = string( myImpl->SaveTo() );
+ CORBA::String_var objStr = GetORB()->object_to_string( anObject );
+ CORBA::String_var hypdata = myImpl->SaveTo();
+ int id = myStudyContext->findId( string( objStr.in() ));
// for each hypothesis create HDF group basing on its id
char hypGrpName[30];
aDataset->WriteOnDisk( ( char* )( libname.c_str() ) );
aDataset->CloseOnDisk();
// --> persistent data of hypothesis
- aSize[ 0 ] = hypdata.length() + 1;
+ aSize[ 0 ] = strlen( hypdata.in() ) + 1;
aDataset = new HDFdataset( "Data", aGroup, HDF_STRING, aSize, 1 );
aDataset->CreateOnDisk();
- aDataset->WriteOnDisk( ( char* )( hypdata.c_str() ) );
+ aDataset->WriteOnDisk( ( char* )( hypdata.in() ) );
aDataset->CloseOnDisk();
// close hypothesis HDF group
aGroup->CloseOnDisk();
if ( !myHyp->_is_nil() ) {
SMESH_Hypothesis_i* myImpl = dynamic_cast<SMESH_Hypothesis_i*>( GetServant( myHyp ).in() );
if ( myImpl ) {
- string hypname = string( myHyp->GetName() );
- string libname = string( myHyp->GetLibName() );
+ CORBA::String_var hn = myHyp->GetName(), ln = myHyp->GetLibName();
+ std::string hypname = hn.in();
+ std::string libname = ln.in();
// BUG SWP13062
// Needs for save crossplatform libname, i.e. parth of name ( ".dll" for
// WIN32 and ".so" for X-system) must be deleted
// PAL17753 (Regression: missing hypothesis in restored study)
// "lib" also should be removed from the beginning
//if( libname_len > 3 )
- //libname.resize( libname_len - 3 );
+ //libname.resize( libname_len - 3 );
if( libname_len > 6 )
libname = libname.substr( 3, libname_len - 3 - 3 );
#endif
- CORBA::String_var objStr = GetORB()->object_to_string( anObject );
- int id = myStudyContext->findId( string( objStr.in() ) );
- string hypdata = string( myImpl->SaveTo() );
+ CORBA::String_var objStr = GetORB()->object_to_string( anObject );
+ CORBA::String_var hypdata = myImpl->SaveTo();
+ int id = myStudyContext->findId( string( objStr.in() ) );
// for each algorithm create HDF group basing on its id
char hypGrpName[30];
aDataset->WriteOnDisk( ( char* )( libname.c_str() ) );
aDataset->CloseOnDisk();
// --> persistent data of algorithm
- aSize[0] = hypdata.length() + 1;
+ aSize[0] = strlen( hypdata.in() ) + 1;
aDataset = new HDFdataset( "Data", aGroup, HDF_STRING, aSize, 1 );
aDataset->CreateOnDisk();
- aDataset->WriteOnDisk( ( char* )( hypdata.c_str() ) );
+ aDataset->WriteOnDisk( ( char* )( hypdata.in() ));
aDataset->CloseOnDisk();
// close algorithm HDF group
aGroup->CloseOnDisk();
SALOMEDS::SObject_wrap myShape;
bool ok = myRef->ReferencedObject( myShape.inout() );
if ( ok ) {
- shapeRefFound = (! CORBA::is_nil( myShape->GetObject() ));
- string myRefOnObject = myShape->GetID();
- if ( shapeRefFound && myRefOnObject.length() > 0 ) {
- aSize[ 0 ] = myRefOnObject.length() + 1;
+ CORBA::Object_var shapeObj = myShape->GetObject();
+ shapeRefFound = (! CORBA::is_nil( shapeObj ));
+ CORBA::String_var myRefOnObject = myShape->GetID();
+ if ( shapeRefFound && myRefOnObject.in()[0] ) {
+ aSize[ 0 ] = strlen( myRefOnObject.in() ) + 1;
aDataset = new HDFdataset( "Ref on shape", aTopGroup, HDF_STRING, aSize, 1 );
aDataset->CreateOnDisk();
- aDataset->WriteOnDisk( ( char* )( myRefOnObject.c_str() ) );
+ aDataset->WriteOnDisk( ( char* )( myRefOnObject.in() ) );
aDataset->CloseOnDisk();
}
}
}
+ // Store file info
+ std::string info = myImpl->FileInfoToString();
+ if ( !info.empty() )
+ {
+ aSize[ 0 ] = info.size();
+ aDataset = new HDFdataset( "file info", aTopGroup, HDF_STRING, aSize, 1 );
+ aDataset->CreateOnDisk();
+ aDataset->WriteOnDisk( (char*) info.data() );
+ aDataset->CloseOnDisk();
+ }
+
// write applied hypotheses if exist
SALOMEDS::SObject_wrap myHypBranch;
found = gotBranch->FindSubObject( GetRefOnAppliedHypothesisTag(), myHypBranch.inout() );
- if ( found && !shapeRefFound && hasShape) { // remove applied hyps
+ if ( found && !shapeRefFound && hasShape ) { // remove applied hyps
aStudy->NewBuilder()->RemoveObjectWithChildren( myHypBranch );
}
if ( found && (shapeRefFound || !hasShape) ) {
// For each group, create a dataset named "Group <group_persistent_id>"
// and store the group's user name into it
- const char* grpName = aGrpBaseDS->GetStoreName();
- char* aUserName = myGroupImpl->GetName();
+ const char* grpName = aGrpBaseDS->GetStoreName();
+ CORBA::String_var aUserName = myGroupImpl->GetName();
aSize[ 0 ] = strlen( aUserName ) + 1;
aDataset = new HDFdataset( grpName, aGroup, HDF_STRING, aSize, 1 );
mySubRef->ReferencedObject( myShape.inout() ) &&
!CORBA::is_nil( myShape->GetObject() ))
{
- string myRefOnObject = myShape->GetID();
- if ( myRefOnObject.length() > 0 ) {
+ CORBA::String_var myRefOnObject = myShape->GetID();
+ if ( myRefOnObject.in()[0] ) {
char aRefName[ 30 ];
sprintf( aRefName, "Ref on shape %d", anId);
- aSize[ 0 ] = myRefOnObject.length() + 1;
+ aSize[ 0 ] = strlen( myRefOnObject.in() ) + 1;
aDataset = new HDFdataset(aRefName, aGroup, HDF_STRING, aSize, 1);
aDataset->CreateOnDisk();
- aDataset->WriteOnDisk( ( char* )( myRefOnObject.c_str() ) );
+ aDataset->WriteOnDisk( ( char* )( myRefOnObject.in() ));
aDataset->CloseOnDisk();
}
}
// Position
const SMDS_PositionPtr pos = node->GetPosition();
if ( onFace ) { // on FACE
- const SMDS_FacePosition* fPos =
- dynamic_cast<const SMDS_FacePosition*>( pos );
+ SMDS_FacePositionPtr fPos = pos;
if ( fPos ) {
aUPos[ iNode ] = fPos->GetUParameter();
aVPos[ iNode ] = fPos->GetVParameter();
nbNodes--;
}
else { // on EDGE
- const SMDS_EdgePosition* ePos =
- dynamic_cast<const SMDS_EdgePosition*>( pos );
+ SMDS_EdgePositionPtr ePos = pos;
if ( ePos ) {
aUPos[ iNode ] = ePos->GetUParameter();
iNode++;
const char* theURL,
bool isMultiFile )
{
- if (!myStudyContext)
+ //if (!myStudyContext)
UpdateStudy();
SALOMEDS::Study_var aStudy = getStudyServant();
/* if( !theComponent->_is_nil() )
myNewMeshImpl->GetImpl().GetMeshDS()->SetPersistentId( *meshPersistentId );
delete [] meshPersistentId;
}
+
+ // Restore file info
+ if ( aTopGroup->ExistInternalObject( "file info" ))
+ {
+ aDataset = new HDFdataset( "file info", aTopGroup );
+ aDataset->OpenOnDisk();
+ size = aDataset->GetSize();
+ std::string info( size, ' ');
+ aDataset->ReadFromDisk( (char*) info.data() );
+ aDataset->CloseOnDisk();
+ myNewMeshImpl->FileInfoFromString( info );
+ }
}
}
} // reading MESHes
myStudyContext->mapOldToNew( subid, newSubId );
}
}
+ delete [] refFromFile;
}
if ( aSubMesh->_is_nil() )
myNewMeshImpl->addHypothesis( aSubShapeObject, anHyp );
}
}
+ delete [] refFromFile;
}
}
// close "applied algorithms" HDF group
myNewMeshImpl->addHypothesis( aSubShapeObject, anHyp );
}
}
+ delete [] refFromFile;
}
}
// close "APPLIED HYPOTHESES" hdf group
aShape = GeomObjectToShape( aShapeObject );
}
}
+ delete [] refFromFile;
}
// Try to read a filter of SMESH_GroupOnFilter
SMESH::Filter_var filter;
predicate = SMESH_GroupOnFilter_i::GetPredicate( filter );
filters.push_back( filter );
}
+ delete [] persistStr;
}
// Create group servant
SMESH::ElementType type = (SMESH::ElementType)(ii - GetNodeGroupsTag() + 1);
SMESH::SMESH_GroupBase_var aNewGroup = SMESH::SMESH_GroupBase::_duplicate
( myNewMeshImpl->createGroup( type, nameFromFile, aShape, predicate ) );
+ delete [] nameFromFile;
// Obtain a SMESHDS_Group object
if ( aNewGroup->_is_nil() )
continue;
aDataset->CloseOnDisk();
Quantity_Color aColor( anRGB[0], anRGB[1], anRGB[2], Quantity_TOC_RGB );
aGroupBaseDS->SetColor( aColor );
+ delete [] anRGB;
}
}
}
}
// read Sub-Mesh ORDER if any
- if( aTopGroup->ExistInternalObject( "Mesh Order" ) ) {
+ if ( aTopGroup->ExistInternalObject( "Mesh Order" )) {
aDataset = new HDFdataset( "Mesh Order", aTopGroup );
aDataset->OpenOnDisk();
size = aDataset->GetSize();
anOrderIds.back().push_back(smIDs[ i ]);
myNewMeshImpl->GetImpl().SetMeshOrder( anOrderIds );
+ delete [] smIDs;
}
} // loop on meshes
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::Close" );
// Clear study contexts data
- delete myStudyContext;
- myStudyContext = 0;
+ myStudyContext->Clear();
// remove the tmp files meshes are loaded from
SMESH_PreMeshInfo::RemoveStudyFiles_TMP_METHOD( theComponent );
+ // Clean trace of API methods calls
+ CleanPythonTrace();
+
return;
}