-// 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<mailto:webmaster.salome@opencascade.com>
+//
-// File: ModelHighAPI_Dumper.cpp
-// Created: 1 August 2016
-// Author: Artem ZHIDKOV
-
-//--------------------------------------------------------------------------------------
#include "ModelHighAPI_Dumper.h"
#include <Config_PropManager.h>
#include <ModelAPI_Document.h>
#include <ModelAPI_Entity.h>
#include <ModelAPI_Feature.h>
+#include <ModelAPI_Folder.h>
#include <ModelAPI_Result.h>
#include <ModelAPI_ResultBody.h>
#include <ModelAPI_ResultCompSolid.h>
#include <ModelAPI_ResultConstruction.h>
#include <ModelAPI_ResultPart.h>
+#include <ModelAPI_Tools.h>
#include <PartSetPlugin_Part.h>
myFeatureCount.clear();
while (!myEntitiesStack.empty())
myEntitiesStack.pop();
+
+ myPostponed.clear();
+ myDumpPostponedInProgress = false;
}
}
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<ModelAPI_Feature>(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<ModelAPI_Folder>(theEntity);
+ if (aFolder) {
+ aName = aFolder->data()->name();
+ aKind = ModelAPI_Folder::ID();
+ isSaveNotDumped = false;
+ }
+ }
+
+ ObjectPtr anObject = std::dynamic_pointer_cast<ModelAPI_Object>(theEntity);
+ if (anObject) {
+ DocumentPtr aDoc = anObject->document();
int& aNbFeatures = myFeatureCount[aDoc][aKind];
aNbFeatures += 1;
}
myNames[theEntity] = EntityName(aDefaultName.str(), aName, isDefaultName);
- if (theSaveNotDumped)
+ if (isSaveNotDumped)
myNotDumpedEntities.insert(theEntity);
// store names of results
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<ResultPtr>& aResults = theFeature->results();
std::list<ResultPtr>::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<std::string, bool> 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);
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);
}
}
}
bool ModelHighAPI_Dumper::process(const std::shared_ptr<ModelAPI_Document>& theDoc)
{
bool isOk = true;
- std::list<FeaturePtr> aFeatures = theDoc->allFeatures();
- std::list<FeaturePtr>::const_iterator aFeatIt = aFeatures.begin();
+ std::list<ObjectPtr> anObjects = theDoc->allObjects();
+ std::list<ObjectPtr>::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<ModelAPI_Feature>(*anObjIt);
+ if (aFeature)
+ dumpParameter(aFeature);
+ }
// dump all other features
- for (aFeatIt = aFeatures.begin(); aFeatIt != aFeatures.end(); ++aFeatIt) {
- CompositeFeaturePtr aCompFeat = std::dynamic_pointer_cast<ModelAPI_CompositeFeature>(*aFeatIt);
+ for (anObjIt = anObjects.begin(); anObjIt != anObjects.end(); ++anObjIt) {
+ CompositeFeaturePtr aCompFeat = std::dynamic_pointer_cast<ModelAPI_CompositeFeature>(*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<ModelAPI_Folder>(*anObjIt);
+ if (aFolder)
+ dumpFolder(aFolder);
+ else {
+ FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(*anObjIt);
+ if (aFeature) // dump common feature
+ dumpFeature(aFeature);
+ }
+ }
}
return isOk;
}
// increase composite features stack
++gCompositeStackDepth;
// dump composite itself
- if (!isDumped(theComposite) || isForce)
+ if (!isDumped(EntityPtr(theComposite)) || isForce)
dumpFeature(FeaturePtr(theComposite), isForce);
// sub-part is processed independently, because it provides separate document
int aNbSubs = theComposite->numberOfSubs();
for (int anIndex = 0; anIndex < aNbSubs; ++anIndex) {
FeaturePtr aFeature = theComposite->subFeature(anIndex);
- if (isDumped(aFeature))
+ if (isDumped(EntityPtr(aFeature)))
continue;
isSubDumped = true;
// dump "setName" for composite feature
if (isDumpSetName)
dumpEntitySetName();
+ // dump folders if any
+ dumpPostponed();
return isOk;
}
+void ModelHighAPI_Dumper::postpone(const EntityPtr& theEntity)
+{
+ // keep the name
+ name(theEntity, false);
+ myPostponed.push_back(theEntity);
+}
+
+void ModelHighAPI_Dumper::dumpPostponed()
+{
+ 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<EntityPtr> aPostponedCopy = myPostponed;
+ myPostponed.clear();
+
+ // iterate over postponed entities and try to dump them
+ std::list<EntityPtr>::const_iterator anIt = aPostponedCopy.begin();
+ for (; anIt != aPostponedCopy.end(); ++anIt) {
+ FolderPtr aFolder = std::dynamic_pointer_cast<ModelAPI_Folder>(*anIt);
+ if (aFolder)
+ dumpFolder(aFolder);
+ else {
+ FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(*anIt);
+ if (aFeature)
+ dumpFeature(aFeature);
+ }
+ }
+ myDumpPostponedInProgress = false;
+}
+
void ModelHighAPI_Dumper::dumpSubFeatureNameAndColor(const std::string theSubFeatureGet,
const FeaturePtr& theSubFeature)
{
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;
{
EntityNameMap::const_iterator aFound = myNames.find(theEntity);
FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(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<ObjectPtr> aRefs = theRefList->list();
+ std::list<ObjectPtr>::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
}
}
if (isConstruction)
- aDefault = Config_PropManager::real("Visualization", "construction_deflection",
- ModelAPI_ResultConstruction::DEFAULT_DEFLECTION());
+ aDefault = Config_PropManager::real("Visualization", "construction_deflection");
else
- aDefault = Config_PropManager::real("Visualization", "body_deflection",
- ModelAPI_ResultBody::DEFAULT_DEFLECTION());
+ aDefault = Config_PropManager::real("Visualization", "body_deflection");
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;
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);
std::list<ResultPtr>::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 =
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);
}
}
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()) {
isCopy = aCopyAttr.get() && aCopyAttr->value();
}
}
- } while (isCopy);
+ } while (isCopy && !theDumper.myEntitiesStack.empty());
}
// store all not-dumped entities first
else {
FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(*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<AttributePtr>& aRefs = aFeature->data()->refsToMe();
+ std::set<AttributePtr>::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);
+ }
+ }
}
}
// then store currently dumped string
theDumper.myFullDump << aBufCopy;
+ // now, store all postponed features
+ theDumper.dumpPostponed();
+
return theDumper;
}
