X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FExchangePlugin%2FExchangePlugin_ExportFeature.cpp;h=688ffc03b289b9903822431dba9871bcc3c1ea33;hb=b6cb9a5e9ecc1c5dae69d686fa73a8afec92d04f;hp=14311b75c0b5c98e0f209c5a0af4ddb09e862cbb;hpb=20ead226b1355fcf49d396036e6527b2ac043cb0;p=modules%2Fshaper.git diff --git a/src/ExchangePlugin/ExchangePlugin_ExportFeature.cpp b/src/ExchangePlugin/ExchangePlugin_ExportFeature.cpp index 14311b75c..688ffc03b 100644 --- a/src/ExchangePlugin/ExchangePlugin_ExportFeature.cpp +++ b/src/ExchangePlugin/ExchangePlugin_ExportFeature.cpp @@ -1,8 +1,21 @@ -// Copyright (C) 2014-20xx CEA/DEN, EDF R&D - -// File: ExchangePlugin_ExportFeature.cpp -// Created: May 14, 2015 -// Author: Sergey POKHODENKO +// Copyright (C) 2014-2019 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 +// #include @@ -28,16 +41,26 @@ #include #include +#include +#include +#include #include #include #include #include +#include #include +#include #include #include +#include + +#include #include +#include #include +#include #include @@ -55,18 +78,27 @@ ExchangePlugin_ExportFeature::~ExchangePlugin_ExportFeature() */ void ExchangePlugin_ExportFeature::initAttributes() { - data()->addAttribute(ExchangePlugin_ExportFeature::EXPORT_TYPE_ID(), ModelAPI_AttributeString::typeId()); - data()->addAttribute(ExchangePlugin_ExportFeature::FILE_PATH_ID(), ModelAPI_AttributeString::typeId()); - data()->addAttribute(ExchangePlugin_ExportFeature::XAO_FILE_PATH_ID(), ModelAPI_AttributeString::typeId()); - data()->addAttribute(ExchangePlugin_ExportFeature::FILE_FORMAT_ID(), ModelAPI_AttributeString::typeId()); - data()->addAttribute(ExchangePlugin_ExportFeature::SELECTION_LIST_ID(), ModelAPI_AttributeSelectionList::typeId()); - data()->addAttribute(ExchangePlugin_ExportFeature::XAO_AUTHOR_ID(), ModelAPI_AttributeString::typeId()); - data()->addAttribute(ExchangePlugin_ExportFeature::XAO_GEOMETRY_NAME_ID(), ModelAPI_AttributeString::typeId()); - - //ModelAPI_Session::get()->validators()->registerNotObligatory(getKind(), ExchangePlugin_ExportFeature::SELECTION_LIST_ID()); - ModelAPI_Session::get()->validators()->registerNotObligatory(getKind(), ExchangePlugin_ExportFeature::XAO_FILE_PATH_ID()); - ModelAPI_Session::get()->validators()->registerNotObligatory(getKind(), ExchangePlugin_ExportFeature::XAO_AUTHOR_ID()); - ModelAPI_Session::get()->validators()->registerNotObligatory(getKind(), ExchangePlugin_ExportFeature::XAO_GEOMETRY_NAME_ID()); + data()->addAttribute(ExchangePlugin_ExportFeature::EXPORT_TYPE_ID(), + ModelAPI_AttributeString::typeId()); + data()->addAttribute(ExchangePlugin_ExportFeature::FILE_PATH_ID(), + ModelAPI_AttributeString::typeId()); + data()->addAttribute(ExchangePlugin_ExportFeature::XAO_FILE_PATH_ID(), + ModelAPI_AttributeString::typeId()); + data()->addAttribute(ExchangePlugin_ExportFeature::FILE_FORMAT_ID(), + ModelAPI_AttributeString::typeId()); + data()->addAttribute(ExchangePlugin_ExportFeature::SELECTION_LIST_ID(), + ModelAPI_AttributeSelectionList::typeId()); + data()->addAttribute(ExchangePlugin_ExportFeature::XAO_AUTHOR_ID(), + ModelAPI_AttributeString::typeId()); + data()->addAttribute(ExchangePlugin_ExportFeature::XAO_GEOMETRY_NAME_ID(), + ModelAPI_AttributeString::typeId()); + + ModelAPI_Session::get()->validators()->registerNotObligatory(getKind(), + ExchangePlugin_ExportFeature::XAO_FILE_PATH_ID()); + ModelAPI_Session::get()->validators()->registerNotObligatory(getKind(), + ExchangePlugin_ExportFeature::XAO_AUTHOR_ID()); + ModelAPI_Session::get()->validators()->registerNotObligatory(getKind(), + ExchangePlugin_ExportFeature::XAO_GEOMETRY_NAME_ID()); } void ExchangePlugin_ExportFeature::attributeChanged(const std::string& theID) @@ -161,6 +193,81 @@ void ExchangePlugin_ExportFeature::exportFile(const std::string& theFileName, } } +/// Returns XAO string by the value from the table +static std::string valToString(const ModelAPI_AttributeTables::Value& theVal, + const ModelAPI_AttributeTables::ValueType& theType) { + std::ostringstream aStr; // the resulting string value + switch(theType) { + case ModelAPI_AttributeTables::BOOLEAN: + aStr<<(theVal.myBool ? "true" : "false"); + break; + case ModelAPI_AttributeTables::INTEGER: + aStr<& theResults, + std::set& theCashedResults) +{ + // collect all results into a cashed set + if (theCashedResults.empty()) { + std::list aResults; + std::list::const_iterator aRes = theResults.cbegin(); + for(; aRes != theResults.cend(); aRes++) { + if (theCashedResults.count(*aRes)) + continue; + else + theCashedResults.insert(*aRes); + if ((*aRes)->groupName() == ModelAPI_ResultBody::group()) { + ResultBodyPtr aResBody = std::dynamic_pointer_cast(*aRes); + std::list aResults; + ModelAPI_Tools::allSubs(aResBody, aResults, false); + for(std::list::iterator aR = aResults.begin(); aR != aResults.end(); aR++) { + theCashedResults.insert(std::dynamic_pointer_cast(*aR)); + } + } else if ((*aRes)->groupName() == ModelAPI_ResultPart::group()) { // all results of the part + ResultPartPtr aResPart = std::dynamic_pointer_cast(*aRes); + DocumentPtr aPartDoc = aResPart->partDoc(); + if (!aPartDoc.get() || !aPartDoc->isOpened()) { // document is not accessible + return false; + } + int aBodyCount = aPartDoc->size(ModelAPI_ResultBody::group()); + for (int aBodyIndex = 0; aBodyIndex < aBodyCount; ++aBodyIndex) { + ResultBodyPtr aResBody = + std::dynamic_pointer_cast( + aPartDoc->object(ModelAPI_ResultBody::group(), aBodyIndex)); + if (aResBody.get()) { + theCashedResults.insert(aResBody); + std::list aResults; + ModelAPI_Tools::allSubs(aResBody, aResults, false); + for(std::list::iterator aR = aResults.begin(); aR != aResults.end(); aR++) { + theCashedResults.insert(std::dynamic_pointer_cast(*aR)); + } + } + } + } + } + } + // if context is in results, return true + for(int a = 0; a < theSelection->size(); a++) { + AttributeSelectionPtr anAttr = theSelection->value(a); + ResultBodyPtr aSelected= std::dynamic_pointer_cast(anAttr->context()); + if (aSelected.get() && theCashedResults.count(aSelected)) + return true; + } + return false; +} + void ExchangePlugin_ExportFeature::exportXAO(const std::string& theFileName) { try { @@ -175,15 +282,53 @@ void ExchangePlugin_ExportFeature::exportXAO(const std::string& theFileName) // make shape for export from all results std::list aShapes; - int aBodyCount = document()->size(ModelAPI_ResultBody::group()); - for (int aBodyIndex = 0; aBodyIndex < aBodyCount; ++aBodyIndex) { - ResultBodyPtr aResultBody = - std::dynamic_pointer_cast( - document()->object(ModelAPI_ResultBody::group(), aBodyIndex)); - if (!aResultBody.get()) - continue; - aShapes.push_back(aResultBody->shape()); + std::list aResults; + std::list aDocuments; /// documents of Parts selected and used in export + + AttributeSelectionListPtr aSelection = selectionList(SELECTION_LIST_ID()); + bool aIsSelection = aSelection->isInitialized() && aSelection->size() > 0; + if (aIsSelection) { // a mode for export to geom result by result + for(int a = 0; a < aSelection->size(); a++) { + AttributeSelectionPtr anAttr = aSelection->value(a); + ResultPtr aBodyContext = + std::dynamic_pointer_cast(anAttr->context()); + if (aBodyContext.get() && !aBodyContext->isDisabled() && aBodyContext->shape().get()) { + aResults.push_back(aBodyContext); + GeomShapePtr aShape = anAttr->value(); + if (!aShape.get()) + aShape = aBodyContext->shape(); + aShapes.push_back(aShape); + if (aBodyContext->groupName() == ModelAPI_ResultPart::group()) { + ResultPartPtr aResPart = std::dynamic_pointer_cast(aBodyContext); + DocumentPtr aPartDoc = aResPart->partDoc(); + if (!aPartDoc.get() || !aPartDoc->isOpened()) { // document is not accessible + std::string msg = "Can not export XAO for not loaded part"; + Events_InfoMessage("ExportFeature", msg, this).send(); + return; + } else { + aDocuments.push_back(aPartDoc); + } + } + } + } + } else { + int aBodyCount = document()->size(ModelAPI_ResultBody::group()); + for (int aBodyIndex = 0; aBodyIndex < aBodyCount; ++aBodyIndex) { + ResultBodyPtr aResultBody = + std::dynamic_pointer_cast( + document()->object(ModelAPI_ResultBody::group(), aBodyIndex)); + if (!aResultBody.get()) + continue; + aShapes.push_back(aResultBody->shape()); + aResults.push_back(aResultBody); + } + } + if (aShapes.empty()) { + setError("No shapes to export"); + return; } + + GeomShapePtr aShape = (aShapes.size() == 1) ? *aShapes.begin() : GeomAlgoAPI_CompoundBuilder::compound(aShapes); @@ -196,45 +341,178 @@ void ExchangePlugin_ExportFeature::exportXAO(const std::string& theFileName) } // geometry name - std::string aGeometryName = string(ExchangePlugin_ExportFeature::XAO_GEOMETRY_NAME_ID())->value(); - aXao.getGeometry()->setName(aGeometryName); - - // groups - - int aGroupCount = document()->size(ModelAPI_ResultGroup::group()); - for (int aGroupIndex = 0; aGroupIndex < aGroupCount; ++aGroupIndex) { - ResultGroupPtr aResultGroup = - std::dynamic_pointer_cast( - document()->object(ModelAPI_ResultGroup::group(), aGroupIndex)); - - FeaturePtr aGroupFeature = document()->feature(aResultGroup); - - AttributeSelectionListPtr aSelectionList = - aGroupFeature->selectionList("group_list"); - - // conversion of dimension - std::string aSelectionType = aSelectionList->selectionType(); - std::string aDimensionString = ExchangePlugin_Tools::selectionType2xaoDimension(aSelectionType); - XAO::Dimension aGroupDimension = XAO::XaoUtils::stringToDimension(aDimensionString); - - XAO::Group* aXaoGroup = aXao.addGroup(aGroupDimension, - aResultGroup->data()->name()); + if (aGeometryName.empty() && aResults.size() == 1) { + // get the name from the first result + ResultPtr aResultBody = *aResults.begin(); + aGeometryName = aResultBody->data()->name(); + } - for (int aSelectionIndex = 0; aSelectionIndex < aSelectionList->size(); ++aSelectionIndex) { - AttributeSelectionPtr aSelection = aSelectionList->value(aSelectionIndex); + aXao.getGeometry()->setName(aGeometryName); - // complex conversion of reference id to element index - int aReferenceID = aSelection->Id(); - std::string aReferenceString = XAO::XaoUtils::intToString(aReferenceID); - int anElementID = aXao.getGeometry()->getElementIndexByReference(aGroupDimension, aReferenceString); + std::set allResultsCashed; // cash to speed up searching in all results selected + + // iterate all documents used + if (aDocuments.empty()) + aDocuments.push_back(document()); + std::list::iterator aDoc = aDocuments.begin(); + for(; aDoc != aDocuments.end(); aDoc++) { + // groups + int aGroupCount = (*aDoc)->size(ModelAPI_ResultGroup::group()); + for (int aGroupIndex = 0; aGroupIndex < aGroupCount; ++aGroupIndex) { + ResultGroupPtr aResultGroup = std::dynamic_pointer_cast( + (*aDoc)->object(ModelAPI_ResultGroup::group(), aGroupIndex)); + + FeaturePtr aGroupFeature = (*aDoc)->feature(aResultGroup); + + AttributeSelectionListPtr aSelectionList = + aGroupFeature->selectionList("group_list"); + if (!isInResults(aSelectionList, aResults, allResultsCashed))// skip group not used in result + continue; + + // conversion of dimension + std::string aSelectionType = aSelectionList->selectionType(); + std::string aDimensionString = + ExchangePlugin_Tools::selectionType2xaoDimension(aSelectionType); + XAO::Dimension aGroupDimension = XAO::XaoUtils::stringToDimension(aDimensionString); + + XAO::Group* aXaoGroup = aXao.addGroup(aGroupDimension, + aResultGroup->data()->name()); + + try { + for (int aSelectionIndex = 0; aSelectionIndex < aSelectionList->size(); ++aSelectionIndex){ + AttributeSelectionPtr aSelection = aSelectionList->value(aSelectionIndex); + + // complex conversion of reference id to element index + // gives bad id in case the selection is done from python script + // => using GeomAlgoAPI_CompoundBuilder::id instead + // int aReferenceID_old = aSelection->Id(); + + int aReferenceID = GeomAlgoAPI_CompoundBuilder::id(aShape, aSelection->value()); + + if (aReferenceID == 0) // selected value does not found in the exported shape + continue; + + std::string aReferenceString = XAO::XaoUtils::intToString(aReferenceID); + int anElementID = + aXao.getGeometry()->getElementIndexByReference(aGroupDimension, aReferenceString); + + aXaoGroup->add(anElementID); + } + } catch (XAO::XAO_Exception& e) { + // LCOV_EXCL_START + std::string msg = "An error occurred while exporting group " + + aResultGroup->data()->name(); + msg += ".\n"; + msg += e.what(); + msg += "\n"; + msg += "=> skipping this group from XAO export."; + Events_InfoMessage("ExportFeature", msg, this).send(); + aXao.removeGroup(aXaoGroup); + // LCOV_EXCL_STOP + } + } - aXaoGroup->add(anElementID); + // fields + int aFieldCount = (*aDoc)->size(ModelAPI_ResultField::group()); + for (int aFieldIndex = 0; aFieldIndex < aFieldCount; ++aFieldIndex) { + ResultFieldPtr aResultField = std::dynamic_pointer_cast( + (*aDoc)->object(ModelAPI_ResultField::group(), aFieldIndex)); + + FeaturePtr aFieldFeature = (*aDoc)->feature(aResultField); + + AttributeSelectionListPtr aSelectionList = + aFieldFeature->selectionList("selected"); + std::string aSelectionType = aSelectionList->selectionType(); + bool isWholePart = aSelectionType == "part"; + // skip field not used in results + if (!isWholePart && !isInResults(aSelectionList, aResults, allResultsCashed)) + continue; + + // conversion of dimension + std::string aDimensionString = + ExchangePlugin_Tools::selectionType2xaoDimension(aSelectionType); + XAO::Dimension aFieldDimension = XAO::XaoUtils::stringToDimension(aDimensionString); + // get tables and their type + std::shared_ptr aTables = aFieldFeature->tables("values"); + std::string aTypeString = ExchangePlugin_Tools::valuesType2xaoType(aTables->type()); + XAO::Type aFieldType = XAO::XaoUtils::stringToFieldType(aTypeString); + + XAO::Field* aXaoField = aXao.addField(aFieldType, aFieldDimension, aTables->columns(), + aResultField->data()->name()); + + + try { + // set components names + AttributeStringArrayPtr aComponents = aFieldFeature->stringArray("components_names"); + for(int aComp = 0; aComp < aComponents->size(); aComp++) { + std::string aName = aComponents->value(aComp); + aXaoField->setComponentName(aComp, aName); + } + + AttributeIntArrayPtr aStamps = aFieldFeature->intArray("stamps"); + for (int aStepIndex = 0; aStepIndex < aTables->tables(); aStepIndex++) { + XAO::Step* aStep = aXaoField->addNewStep(aStepIndex); + aStep->setStep(aStepIndex); + int aStampIndex = aStamps->value(aStepIndex); + aStep->setStamp(aStampIndex); + int aNumElements = isWholePart ? aXaoField->countElements() : aTables->rows(); + int aNumComps = aTables->columns(); + std::set aFilledIDs; // to fill the rest by defaults + // omit default values first row + for(int aRow = isWholePart ? 0 : 1; aRow < aNumElements; aRow++) { + for(int aCol = 0; aCol < aNumComps; aCol++) { + int anElementID = 0; + if (!isWholePart) { + // element index actually is the ID of the selection + AttributeSelectionPtr aSelection = aSelectionList->value(aRow - 1); + int aReferenceID = GeomAlgoAPI_CompoundBuilder::id(aShape, aSelection->value()); + if (aReferenceID == 0) // selected value does not found in the exported shape + continue; + + std::string aReferenceString = XAO::XaoUtils::intToString(aReferenceID); + anElementID = aXao.getGeometry()-> + getElementIndexByReference(aFieldDimension, aReferenceString); + } + + ModelAPI_AttributeTables::Value aVal = aTables->value( + isWholePart ? 0 : aRow, aCol, aStepIndex); + std::string aStrVal = valToString(aVal, aTables->type()); + aStep->setStringValue(isWholePart ? aRow : anElementID, aCol, aStrVal); + aFilledIDs.insert(anElementID); + } + } + if (!isWholePart) { // fill the rest values by default ones + XAO::GeometricElementList::iterator allElem = + aXao.getGeometry()->begin(aFieldDimension); + for(; allElem != aXao.getGeometry()->end(aFieldDimension); allElem++) { + if (aFilledIDs.find(allElem->first) != aFilledIDs.end()) + continue; + for(int aCol = 0; aCol < aNumComps; aCol++) { + // default value + ModelAPI_AttributeTables::Value aVal = aTables->value(0, aCol, aStepIndex); + std::string aStrVal = valToString(aVal, aTables->type()); + aStep->setStringValue(allElem->first, aCol, aStrVal); + } + } + } + } + } catch (XAO::XAO_Exception& e) { + // LCOV_EXCL_START + std::string msg = "An error occurred while exporting field " + + aResultField->data()->name(); + msg += ".\n"; + msg += e.what(); + msg += "\n"; + msg += "=> skipping this field from XAO export."; + Events_InfoMessage("ExportFeature", msg, this).send(); + aXao.removeField(aXaoField); + // LCOV_EXCL_STOP + } } } // exporting - XAOExport(theFileName, &aXao, anError); if (!anError.empty()) { @@ -242,9 +520,40 @@ void ExchangePlugin_ExportFeature::exportXAO(const std::string& theFileName) return; } +// LCOV_EXCL_START } catch (XAO::XAO_Exception& e) { std::string anError = e.what(); - setError("An error occurred while importing " + theFileName + ": " + anError); + setError("An error occurred while exporting " + theFileName + ": " + anError); return; } +// LCOV_EXCL_STOP +} + +bool ExchangePlugin_ExportFeature::isMacro() const +{ + if (!data().get() || !data()->isValid()) + return false; + ExchangePlugin_ExportFeature* aThis = ((ExchangePlugin_ExportFeature*)(this)); + AttributeStringPtr aFormatAttr = aThis->string(FILE_FORMAT_ID()); + if (!aFormatAttr.get()) + return false; + std::string aFormat = aFormatAttr->value(); + + if (aFormat.empty()) { // get default format for the extension + AttributeStringPtr aFilePathAttr = aThis->string(FILE_PATH_ID()); + std::string aFilePath = aFilePathAttr->value(); + if (!aFilePath.empty()) { + std::string anExtension = GeomAlgoAPI_Tools::File_Tools::extension(aFilePath); + if (anExtension == "XAO") { + aFormat = "XAO"; + } + } + } + + if (aFormat == "XAO") { // on export to GEOm the selection attribute is filled - this is + // an exceptional case where export to XAO feature must be kept + AttributeSelectionListPtr aList = aThis->selectionList(SELECTION_LIST_ID()); + return !aList->isInitialized() || aList->size() == 0; + } + return true; }