X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FModelHighAPI%2FModelHighAPI_Dumper.cpp;h=20e8ff20f36c221f489705c00c7b8ca20b1eb388;hb=6b615b773dd6e6901cd246ecb55003a9941e2365;hp=73f87251a0619a423a880b5a3fff0893277c84f0;hpb=6bf7d56801cd3ef5253adf2c9a38c5f226c2c2e4;p=modules%2Fshaper.git diff --git a/src/ModelHighAPI/ModelHighAPI_Dumper.cpp b/src/ModelHighAPI/ModelHighAPI_Dumper.cpp index 73f87251a..20e8ff20f 100644 --- a/src/ModelHighAPI/ModelHighAPI_Dumper.cpp +++ b/src/ModelHighAPI/ModelHighAPI_Dumper.cpp @@ -1,10 +1,23 @@ -// Copyright (C) 2016-20xx CEA/DEN, EDF R&D --> +// Copyright (C) 2014-2017 CEA/DEN, EDF R&D +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// See http://www.salome-platform.org/ or +// email : webmaster.salome@opencascade.com +// -// File: ModelHighAPI_Dumper.cpp -// Created: 1 August 2016 -// Author: Artem ZHIDKOV - -//-------------------------------------------------------------------------------------- #include "ModelHighAPI_Dumper.h" #include @@ -33,11 +46,13 @@ #include #include #include +#include #include #include #include #include #include +#include #include @@ -81,6 +96,9 @@ void ModelHighAPI_Dumper::clear(bool bufferOnly) myFeatureCount.clear(); while (!myEntitiesStack.empty()) myEntitiesStack.pop(); + + myPostponed.clear(); + myDumpPostponedInProgress = false; } } @@ -110,14 +128,26 @@ const std::string& ModelHighAPI_Dumper::name(const EntityPtr& theEntity, return aFound->second.myCurrentName; // entity is not found, store it - std::string aName; + std::string aName, aKind; bool isDefaultName = false; + bool isSaveNotDumped = theSaveNotDumped; std::ostringstream aDefaultName; FeaturePtr aFeature = std::dynamic_pointer_cast(theEntity); if (aFeature) { aName = aFeature->name(); - const std::string& aKind = aFeature->getKind(); - DocumentPtr aDoc = aFeature->document(); + aKind = aFeature->getKind(); + } else { + FolderPtr aFolder = std::dynamic_pointer_cast(theEntity); + if (aFolder) { + aName = aFolder->data()->name(); + aKind = ModelAPI_Folder::ID(); + isSaveNotDumped = false; + } + } + + ObjectPtr anObject = std::dynamic_pointer_cast(theEntity); + if (anObject) { + DocumentPtr aDoc = anObject->document(); int& aNbFeatures = myFeatureCount[aDoc][aKind]; aNbFeatures += 1; @@ -150,7 +180,7 @@ const std::string& ModelHighAPI_Dumper::name(const EntityPtr& theEntity, } myNames[theEntity] = EntityName(aDefaultName.str(), aName, isDefaultName); - if (theSaveNotDumped) + if (isSaveNotDumped) myNotDumpedEntities.insert(theEntity); // store names of results @@ -178,29 +208,17 @@ const std::string& ModelHighAPI_Dumper::parentName(const FeaturePtr& theEntity) void ModelHighAPI_Dumper::saveResultNames(const FeaturePtr& theFeature) { // Default name of the feature - const std::string& aKind = theFeature->getKind(); - DocumentPtr aDoc = theFeature->document(); - int aNbFeatures = myFeatureCount[aDoc][aKind]; - std::ostringstream aNameStream; - aNameStream << aKind << "_" << aNbFeatures; - std::string aFeatureName = aNameStream.str(); + bool isFeatureDefaultName = myNames[theFeature].myIsDefault; // Save only names of results which is not correspond to default feature name const std::list& aResults = theFeature->results(); std::list::const_iterator aResIt = aResults.begin(); - for (int i = 1; aResIt != aResults.end(); ++aResIt, ++i) { - bool isUserDefined = true; + for (int i = 0; aResIt != aResults.end(); ++aResIt, ++i) { + std::pair aName = ModelAPI_Tools::getDefaultName(*aResIt, i); + std::string aDefaultName = aName.first; std::string aResName = (*aResIt)->data()->name(); - size_t anIndex = aResName.find(aFeatureName); - if (anIndex == 0) { - std::string aSuffix = aResName.substr(aFeatureName.length()); - if (aSuffix.empty() && i == 1) // first result may not constain index in the name - isUserDefined = false; - else { - if (aSuffix[0] == '_' && std::stoi(aSuffix.substr(1)) == i) - isUserDefined = false; - } - } + + bool isUserDefined = !(isFeatureDefaultName && aDefaultName == aResName); myNames[*aResIt] = EntityName(aResName, (isUserDefined ? aResName : std::string()), !isUserDefined); @@ -210,22 +228,14 @@ void ModelHighAPI_Dumper::saveResultNames(const FeaturePtr& theFeature) if (aCompSolid) { int aNbSubs = aCompSolid->numberOfSubs(); for (int j = 0; j < aNbSubs; ++j) { - isUserDefined = true; ResultPtr aSub = aCompSolid->subResult(j); std::string aSubName = aSub->data()->name(); - size_t anIndex = aSubName.find(aResName); - if (anIndex == 0) { - std::string aSuffix = aSubName.substr(aResName.length()); - if (aSuffix.empty() && aNbSubs == 1) // first result may not constain index in the name - isUserDefined = false; - else { - if (aSuffix[0] == '_' && std::stoi(aSuffix.substr(1)) == j + 1) - isUserDefined = false; - } - } + aName = ModelAPI_Tools::getDefaultName(aSub, j); + aDefaultName = aName.first; + bool isUserDefinedSubName = isUserDefined || aDefaultName != aSubName; myNames[aSub] = EntityName(aSubName, - (isUserDefined ? aSubName : std::string()), !isUserDefined); + (isUserDefinedSubName ? aSubName : std::string()), !isUserDefinedSubName); } } } @@ -246,19 +256,33 @@ bool ModelHighAPI_Dumper::process(const std::shared_ptr& theD bool ModelHighAPI_Dumper::process(const std::shared_ptr& theDoc) { bool isOk = true; - std::list aFeatures = theDoc->allFeatures(); - std::list::const_iterator aFeatIt = aFeatures.begin(); + std::list anObjects = theDoc->allObjects(); + std::list::const_iterator anObjIt = anObjects.begin(); // firstly, dump all parameters - for (; aFeatIt != aFeatures.end(); ++ aFeatIt) - dumpParameter(*aFeatIt); + for (; anObjIt != anObjects.end(); ++ anObjIt) { + FeaturePtr aFeature = std::dynamic_pointer_cast(*anObjIt); + if (aFeature) + dumpParameter(aFeature); + } // dump all other features - for (aFeatIt = aFeatures.begin(); aFeatIt != aFeatures.end(); ++aFeatIt) { - CompositeFeaturePtr aCompFeat = std::dynamic_pointer_cast(*aFeatIt); + for (anObjIt = anObjects.begin(); anObjIt != anObjects.end(); ++anObjIt) { + CompositeFeaturePtr aCompFeat = std::dynamic_pointer_cast(*anObjIt); if (aCompFeat) // iteratively process composite features isOk = process(aCompFeat) && isOk; - else if (!isDumped(*aFeatIt)) // dump common feature - dumpFeature(*aFeatIt); + else if (!isDumped(EntityPtr(*anObjIt))) { + // dump folder + FolderPtr aFolder = std::dynamic_pointer_cast(*anObjIt); + if (aFolder) + dumpFolder(aFolder); + else { + FeaturePtr aFeature = std::dynamic_pointer_cast(*anObjIt); + if (aFeature) // dump common feature + dumpFeature(aFeature); + } + } } + // dump folders if any + dumpPostponed(true); return isOk; } @@ -268,7 +292,7 @@ bool ModelHighAPI_Dumper::process(const std::shared_ptrnumberOfSubs(); for (int anIndex = 0; anIndex < aNbSubs; ++anIndex) { FeaturePtr aFeature = theComposite->subFeature(anIndex); - if (isDumped(aFeature)) + if (isDumped(EntityPtr(aFeature))) continue; isSubDumped = true; @@ -343,9 +369,48 @@ bool ModelHighAPI_Dumper::processSubs( // dump "setName" for composite feature if (isDumpSetName) dumpEntitySetName(); + // dump folders if any + dumpPostponed(true); return isOk; } +void ModelHighAPI_Dumper::postpone(const EntityPtr& theEntity) +{ + // keep the name + name(theEntity, false); + myPostponed.push_back(theEntity); +} + +void ModelHighAPI_Dumper::dumpPostponed(bool theDumpFolders) +{ + if (myDumpPostponedInProgress) + return; + + myDumpPostponedInProgress = true; + // make a copy of postponed entities, because the list will be updated + // if some features are not able to be dumped + std::list aPostponedCopy = myPostponed; + myPostponed.clear(); + + // iterate over postponed entities and try to dump them + std::list::const_iterator anIt = aPostponedCopy.begin(); + for (; anIt != aPostponedCopy.end(); ++anIt) { + FolderPtr aFolder = std::dynamic_pointer_cast(*anIt); + if (aFolder) { + if (theDumpFolders) + dumpFolder(aFolder); + else + myPostponed.push_back(*anIt); + } + else { + FeaturePtr aFeature = std::dynamic_pointer_cast(*anIt); + if (aFeature) + dumpFeature(aFeature); + } + } + myDumpPostponedInProgress = false; +} + void ModelHighAPI_Dumper::dumpSubFeatureNameAndColor(const std::string theSubFeatureGet, const FeaturePtr& theSubFeature) { @@ -461,6 +526,15 @@ void ModelHighAPI_Dumper::dumpEntitySetName() myDumpBuffer << ".setDeflection(" << aDeflectionAttr->value() << ")" << std::endl; } } + // set result transparency + if (!isDefaultTransparency(*aResIt)) { + AttributeDoublePtr aTransparencyAttr = + (*aResIt)->data()->real(ModelAPI_Result::TRANSPARENCY_ID()); + if(aTransparencyAttr.get() && aTransparencyAttr->isInitialized()) { + *this << *aResIt; + myDumpBuffer << ".setTransparency(" << aTransparencyAttr->value() << ")" << std::endl; + } + } } myNames[aLastDumped.myEntity].myIsDumped = true; @@ -471,7 +545,30 @@ bool ModelHighAPI_Dumper::isDumped(const EntityPtr& theEntity) const { EntityNameMap::const_iterator aFound = myNames.find(theEntity); FeaturePtr aFeature = std::dynamic_pointer_cast(theEntity); - return aFound != myNames.end() || myFeaturesToSkip.find(aFeature) != myFeaturesToSkip.end(); + return (aFound != myNames.end() && aFound->second.myIsDumped) || + myFeaturesToSkip.find(aFeature) != myFeaturesToSkip.end(); +} + +bool ModelHighAPI_Dumper::isDumped(const AttributeRefAttrPtr& theRefAttr) const +{ + FeaturePtr aFeature; + if (theRefAttr->isObject()) + aFeature = ModelAPI_Feature::feature(theRefAttr->object()); + else + aFeature = ModelAPI_Feature::feature(theRefAttr->attr()->owner()); + return aFeature && isDumped(EntityPtr(aFeature)); +} + +bool ModelHighAPI_Dumper::isDumped(const AttributeRefListPtr& theRefList) const +{ + std::list aRefs = theRefList->list(); + std::list::iterator anIt = aRefs.begin(); + for (; anIt != aRefs.end(); ++anIt) { + FeaturePtr aFeature = ModelAPI_Feature::feature(*anIt); + if (aFeature && !isDumped(EntityPtr(aFeature))) + return false; + } + return true; } bool ModelHighAPI_Dumper::isDefaultColor(const ResultPtr& theResult) const @@ -521,6 +618,15 @@ bool ModelHighAPI_Dumper::isDefaultDeflection(const ResultPtr& theResult) const return fabs(aCurrent - aDefault) < 1.e-12; } +bool ModelHighAPI_Dumper::isDefaultTransparency(const ResultPtr& theResult) const +{ + AttributeDoublePtr anAttribute = theResult->data()->real(ModelAPI_Result::TRANSPARENCY_ID()); + if(!anAttribute || !anAttribute->isInitialized()) { + return true; + } + return fabs(anAttribute->value()) < 1.e-12; +} + ModelHighAPI_Dumper& ModelHighAPI_Dumper::operator<<(const char theChar) { myDumpBuffer << theChar; @@ -649,6 +755,12 @@ ModelHighAPI_Dumper& ModelHighAPI_Dumper::operator<<( return *this; } +ModelHighAPI_Dumper& ModelHighAPI_Dumper::operator<<(const FolderPtr& theFolder) +{ + myDumpBuffer << name(theFolder); + return *this; +} + ModelHighAPI_Dumper& ModelHighAPI_Dumper::operator<<(const FeaturePtr& theEntity) { myDumpBuffer << name(theEntity); @@ -661,7 +773,7 @@ ModelHighAPI_Dumper& ModelHighAPI_Dumper::operator<<(const FeaturePtr& theEntity std::list::const_iterator aResIt = aResults.begin(); for (; aResIt != aResults.end(); ++aResIt) { if (!myNames[*aResIt].myIsDefault || !isDefaultColor(*aResIt) || - !isDefaultDeflection(*aResIt)) + !isDefaultDeflection(*aResIt) || !isDefaultTransparency(*aResIt)) aResultsWithNameOrColor.push_back(*aResIt); ResultCompSolidPtr aCompSolid = @@ -671,7 +783,7 @@ ModelHighAPI_Dumper& ModelHighAPI_Dumper::operator<<(const FeaturePtr& theEntity for (int i = 0; i < aNbSubs; ++i) { ResultPtr aCurRes = aCompSolid->subResult(i); if (!myNames[aCurRes].myIsDefault || !isDefaultColor(aCurRes) || - !isDefaultDeflection(aCurRes)) + !isDefaultDeflection(aCurRes) || !isDefaultTransparency(aCurRes)) aResultsWithNameOrColor.push_back(aCurRes); } } @@ -874,7 +986,9 @@ ModelHighAPI_Dumper& ModelHighAPI_Dumper::operator<<( AttributeSelectionPtr anAttribute = theAttrSelList->value(anIndex); aShape = anAttribute->value(); if(!aShape.get()) { - aShape = anAttribute->context()->shape(); + ResultPtr aContext = anAttribute->context(); + if (aContext.get()) + aShape = aContext->shape(); } if(!aShape.get()) { @@ -933,7 +1047,7 @@ ModelHighAPI_Dumper& operator<<(ModelHighAPI_Dumper& theDumper, isCopy = aCopyAttr.get() && aCopyAttr->value(); } } - } while (isCopy); + } while (isCopy && !theDumper.myEntitiesStack.empty()); } // store all not-dumped entities first @@ -950,6 +1064,20 @@ ModelHighAPI_Dumper& operator<<(ModelHighAPI_Dumper& theDumper, else { FeaturePtr aFeature = std::dynamic_pointer_cast(*anIt); theDumper.dumpFeature(aFeature, true); + // dump the Projection feature which produces this "Copy" entity + AttributeBooleanPtr aCopyAttr = aFeature->boolean("Copy"); + if (aCopyAttr.get() && aCopyAttr->value()) + { + const std::set& aRefs = aFeature->data()->refsToMe(); + std::set::iterator aRefIt = aRefs.begin(); + for (; aRefIt != aRefs.end(); ++aRefIt) + if ((*aRefIt)->id() == "ProjectedFeature") + { // process projection only + FeaturePtr anOwner = ModelAPI_Feature::feature((*aRefIt)->owner()); + if (anOwner && !theDumper.isDumped(EntityPtr(anOwner))) + theDumper.dumpFeature(anOwner, true); + } + } } } @@ -960,5 +1088,8 @@ ModelHighAPI_Dumper& operator<<(ModelHighAPI_Dumper& theDumper, // then store currently dumped string theDumper.myFullDump << aBufCopy; + // now, store all postponed features + theDumper.dumpPostponed(); + return theDumper; }