+ // fill in the tree structure
+ GEOMUtils::TreeModel tree;
+
+ std::string entry;
+ for ( CORBA::ULong i = 0; i < theObjectEntries.length(); i++ ) {
+ // process objects one-by-one
+ entry = theObjectEntries[i].in();
+ GEOM::GEOM_BaseObject_var anObj = GetObject(entry.c_str() );
+ if ( anObj->_is_nil() )
+ continue;
+ std::map< std::string, std::set<std::string> > passedEntries;
+ GEOMUtils::LevelsList upLevelList;
+ // get objects from which current one depends on recursively
+ getUpwardDependency( anObj, upLevelList, passedEntries );
+ GEOMUtils::LevelsList downLevelList;
+ // get objects that depends on current one recursively
+ getDownwardDependency( anObj, downLevelList, passedEntries );
+ tree.insert( std::pair<std::string, std::pair<GEOMUtils::LevelsList,GEOMUtils::LevelsList> >(entry, std::pair<GEOMUtils::LevelsList,GEOMUtils::LevelsList>( upLevelList, downLevelList ) ) );
+ }
+
+ // translation the tree into string
+ std::string treeStr;
+ GEOMUtils::ConvertTreeToString( tree, treeStr );
+
+ // put string into stream
+ char* aBuffer = (char*)CORBA::string_dup(treeStr.c_str());
+ int aBufferSize = strlen((char*)aBuffer);
+
+ CORBA::Octet* anOctetBuf = (CORBA::Octet*)aBuffer;
+
+ SALOMEDS::TMPFile_var aStream = new SALOMEDS::TMPFile(aBufferSize, aBufferSize, anOctetBuf, 1);
+
+ return aStream._retn();
+}
+
+//=======================================================================
+// function : getUpwardDependency
+// purpose : Collects the entries of objects on that the given one depends
+//=======================================================================
+void GEOM_Gen_i::getUpwardDependency( GEOM::GEOM_BaseObject_ptr gbo,
+ GEOMUtils::LevelsList &upLevelList,
+ std::map< std::string, std::set<std::string> > &passedEntries,
+ int level ) {
+ std::string aGboEntry = gbo->GetEntry();
+ GEOMUtils::NodeLinks anEntries;
+ GEOMUtils::LevelInfo aLevelMap;
+ if ( level > 0 ) {
+ if ( level-1 >= (int)upLevelList.size() ) {
+ // create a new map
+ upLevelList.push_back( aLevelMap );
+ } else {
+ // get the existent map
+ aLevelMap = upLevelList.at(level-1);
+ if ( aLevelMap.count( aGboEntry ) > 0 ) {
+ anEntries = aLevelMap[ aGboEntry ];
+ }
+ }
+ }
+ // get objects on that the current one depends
+ GEOM::ListOfGBO_var depList = gbo->GetDependency();
+ std::string aDepEntry;
+ for( CORBA::ULong j = 0; j < depList->length(); j++ ) {
+ if ( depList[j]->_is_nil() )
+ continue;
+ aDepEntry = depList[j]->GetEntry();
+ if ( passedEntries.count( aGboEntry ) > 0 &&
+ passedEntries[aGboEntry].count( aDepEntry ) > 0 ) {
+ //avoid checking the passed objects
+ continue;
+ }
+ passedEntries[aGboEntry].insert( aDepEntry );
+ if ( level > 0 ) {
+ anEntries.push_back( aDepEntry );
+ }
+ // get dependencies recursively
+ getUpwardDependency(depList[j], upLevelList, passedEntries, level+1);
+ }
+ if ( level > 0 ) {
+ aLevelMap.insert( std::pair<std::string, GEOMUtils::NodeLinks>(aGboEntry, anEntries) );
+ upLevelList[level-1] = aLevelMap;
+ }
+}
+
+//=======================================================================
+// function : getDownwardDependency
+// purpose : Collects the entries of objects that depends on the given one
+//=======================================================================
+void GEOM_Gen_i::getDownwardDependency( GEOM::GEOM_BaseObject_ptr gbo,
+ GEOMUtils::LevelsList &downLevelList,
+ std::map< std::string, std::set<std::string> > &passedEntries,
+ int level ) {
+ std::string aGboEntry = gbo->GetEntry();
+ Handle(TDocStd_Document) aDoc = GEOM_Engine::GetEngine()->GetDocument();
+ Handle(TDataStd_TreeNode) aNode, aRoot;
+ Handle(::GEOM_Function) aFunction;
+ if (aDoc->Main().FindAttribute(GEOM_Function::GetFunctionTreeID(), aRoot)) {
+ // go through the whole OCAF tree
+ TDataStd_ChildNodeIterator Itr( aRoot );
+ for (; Itr.More(); Itr.Next()) {
+ aNode = Itr.Value();
+ aFunction = GEOM_Function::GetFunction(aNode->Label());
+ if (aFunction.IsNull()) {
+ continue;
+ }
+ TDF_Label aLabel = aFunction->GetOwnerEntry();
+ if(aLabel.IsNull()) continue;
+ TCollection_AsciiString anEntry;
+ TDF_Tool::Entry(aLabel, anEntry);
+ GEOM::GEOM_BaseObject_var geomObj = GetObject(anEntry.ToCString() );
+ if( CORBA::is_nil( geomObj ) )
+ continue;
+ // get dependencies for current object in the tree
+ GEOM::ListOfGBO_var depList = geomObj->GetDependency();
+ if( depList->length() == 0 )
+ continue;
+ std::string aGoEntry = geomObj->GetEntry();
+ // go through dependencies of current object to check whether it depends on the given object
+ for( CORBA::ULong i = 0; i < depList->length(); i++ ) {
+ if ( depList[i]->_is_nil() )
+ continue;
+ if ( depList[i]->_is_equivalent( gbo ) ) {
+ // yes, the current object depends on the given object
+ if ( passedEntries.count( aGoEntry ) > 0 &&
+ passedEntries[aGoEntry].count( aGboEntry ) > 0 ) {
+ //avoid checking the passed objects
+ continue;
+ }
+ passedEntries[aGoEntry].insert( aGboEntry );
+ GEOMUtils::NodeLinks anEntries;
+ GEOMUtils::LevelInfo aLevelMap;
+ anEntries.push_back( aGboEntry );
+ if ( level >= (int)downLevelList.size() ) {
+ downLevelList.push_back( aLevelMap );
+ } else {
+ aLevelMap = downLevelList.at(level);
+ if ( aLevelMap.count( aGoEntry ) > 0 ) {
+ anEntries = aLevelMap[ aGoEntry ];
+ }
+ }
+ aLevelMap.insert( std::pair<std::string, GEOMUtils::NodeLinks>(aGoEntry, anEntries) );
+ downLevelList[level] = aLevelMap;
+ // get dependencies of the current object recursively
+ getDownwardDependency(geomObj, downLevelList, passedEntries, level+1);
+ break;
+ }
+ }
+ }
+ }
+}
+
+//==============================================================================
+// function : GetEntriesToReduceStudy
+// purpose : Fills 3 lists that is used to clean study of redundant objects
+//==============================================================================
+void GEOM_Gen_i::GetEntriesToReduceStudy(GEOM::string_array& theSelectedEntries,
+ GEOM::string_array& theParentEntries,
+ GEOM::string_array& theSubEntries,
+ GEOM::string_array& theOtherEntries)
+{
+ std::set<std::string> aSelected, aParents, aChildren, anOthers;
+ for ( CORBA::ULong i = 0; i < theSelectedEntries.length(); i++ ) {
+ aSelected.insert( CORBA::string_dup( theSelectedEntries[i] ) );
+ }
+
+ Handle(TDocStd_Document) aDoc = GEOM_Engine::GetEngine()->GetDocument();
+ Handle(TDataStd_TreeNode) aNode, aRoot;
+ Handle(::GEOM_Function) aFunction;
+ if (aDoc->Main().FindAttribute(GEOM_Function::GetFunctionTreeID(), aRoot)) {
+ // go through the whole OCAF tree
+ TDF_Label aLabel;
+ std::string anEntry;
+ TCollection_AsciiString anAsciiEntry;
+ TDataStd_ChildNodeIterator Itr( aRoot );
+ for (; Itr.More(); Itr.Next()) {
+ aNode = Itr.Value();
+ aFunction = GEOM_Function::GetFunction(aNode->Label());
+ if (aFunction.IsNull()) {
+ continue;
+ }
+ aLabel = aFunction->GetOwnerEntry();
+ if(aLabel.IsNull())
+ continue;
+ TDF_Tool::Entry(aLabel, anAsciiEntry);
+ anEntry = anAsciiEntry.ToCString();
+ GEOM::GEOM_BaseObject_var geomObj = GetObject(anEntry.c_str() );
+ if( CORBA::is_nil( geomObj ) )
+ continue;
+
+ if ( aSelected.count( anEntry ) > 0 &&
+ aParents.count( anEntry ) == 0 ) {
+ includeParentDependencies( geomObj, aSelected, aParents, aChildren, anOthers );
+ } else if ( aParents.count( anEntry ) == 0 &&
+ aChildren.count( anEntry ) == 0 ) {
+ anOthers.insert( geomObj->GetEntry() );
+ }
+ }
+
+ std::set<std::string>::iterator it;
+ std::set<std::string>::iterator foundIt;
+ TCollection_AsciiString stringIOR;
+ GEOM::GEOM_Object_var geomObj;
+
+ // filling list of sub-objects
+ for ( it = aSelected.begin(); it != aSelected.end(); ++it ) {
+ includeSubObjects( *it, aSelected, aParents, aChildren, anOthers );
+ }
+
+ // if some selected object is not a main shape,
+ // we move it's main shapes into 'selected' list,
+ // because they could not be modified anyhow.
+ std::set<std::string> aToBeInSelected;
+ for ( it = aSelected.begin(); it != aSelected.end(); ++it ) {
+ Handle(::GEOM_BaseObject) handle_object = _impl->GetObject((*it).c_str(), false);
+ if ( handle_object.IsNull() )
+ continue;
+
+ stringIOR = handle_object->GetIOR();
+ if ( stringIOR.Length() < 1 )
+ continue;
+
+ geomObj = GetIORFromString( stringIOR.ToCString() );
+ while ( !geomObj->IsMainShape() ) {
+ geomObj = geomObj->GetMainShape();
+ anEntry = geomObj->GetEntry();
+
+ foundIt = aParents.find( anEntry );
+ if ( foundIt != aParents.end() )
+ aParents.erase( foundIt );
+
+ foundIt = aChildren.find( anEntry );
+ if ( foundIt != aChildren.end() )
+ aChildren.erase( foundIt );
+
+ foundIt = anOthers.find( anEntry );
+ if ( foundIt != anOthers.end() )
+ anOthers.erase( foundIt );
+
+ aToBeInSelected.insert( anEntry );
+ }
+ }
+ aSelected.insert( aToBeInSelected.begin(), aToBeInSelected.end() );
+
+ // fill the CORBA arrays with values from sets
+ int i;
+ theSelectedEntries.length( aSelected.size() );
+ for ( i = 0, it = aSelected.begin(); it != aSelected.end(); ++it, i++ )
+ theSelectedEntries[i] = CORBA::string_dup( (*it).c_str() );
+ theParentEntries.length( aParents.size() );
+ for ( i = 0, it = aParents.begin(); it != aParents.end(); ++it, i++ )
+ theParentEntries[i] = CORBA::string_dup( (*it).c_str() );
+ theSubEntries.length( aChildren.size() );
+ for ( i = 0, it = aChildren.begin(); it != aChildren.end(); ++it, i++ )
+ theSubEntries[i] = CORBA::string_dup( (*it).c_str() );
+ theOtherEntries.length( anOthers.size() );
+ for ( i = 0, it = anOthers.begin(); it != anOthers.end(); ++it, i++ )
+ theOtherEntries[i] = CORBA::string_dup( (*it).c_str() );
+ }
+}
+
+//==============================================================================
+// function : includeParentDependencies
+// purpose :
+//==============================================================================
+void GEOM_Gen_i::includeParentDependencies(GEOM::GEOM_BaseObject_ptr geomObj,
+ std::set<std::string>& aSelected,
+ std::set<std::string>& aParents,
+ std::set<std::string>& aChildren,
+ std::set<std::string>& anOthers)
+{
+ std::string anEntry = geomObj->GetEntry();
+ if ( aSelected.count( anEntry ) == 0 ) {
+ aParents.insert( anEntry );
+ std::set<std::string>::iterator it;
+ it = aChildren.find( anEntry );
+ if ( it != aChildren.end() )
+ aChildren.erase( it );
+ it = anOthers.find( anEntry );
+ if ( it != anOthers.end() )
+ anOthers.erase( it );
+ }
+ // get dependencies for current object in the tree
+ GEOM::ListOfGBO_var depList = geomObj->GetDependency();
+ if( depList->length() == 0 )
+ return;
+ // go through dependencies of current object to check whether it depends on the given object
+ std::string aDepEntry;
+ for( CORBA::ULong i = 0; i < depList->length(); i++ ) {
+ aDepEntry = depList[i]->GetEntry();
+ if ( depList[i]->_is_nil() ||
+ aDepEntry == anEntry || // skip self-depending
+ aSelected.count( aDepEntry ) > 0 || // skip selected objects
+ aParents.count( aDepEntry ) > 0 // skip already processed objects
+ )
+ continue;
+ includeParentDependencies( depList[i], aSelected, aParents, aChildren, anOthers );