-// Copyright (C) 2014-2019 CEA/DEN, EDF R&D
+// Copyright (C) 2014-2022 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
#include <GeomAlgoAPI_CompoundBuilder.h>
#include <GeomAlgoAPI_IGESExport.h>
#include <GeomAlgoAPI_STEPExport.h>
+#include <GeomAlgoAPI_STLExport.h>
#include <GeomAlgoAPI_Tools.h>
#include <GeomAlgoAPI_XAOExport.h>
#include <GeomAPI_Shape.h>
#include <GeomAPI_ShapeExplorer.h>
+#include <GeomAPI_Trsf.h>
+
+#include <Locale_Convert.h>
#include <ModelAPI_AttributeSelectionList.h>
#include <ModelAPI_AttributeString.h>
#include <ModelAPI_AttributeStringArray.h>
#include <ModelAPI_AttributeIntArray.h>
#include <ModelAPI_AttributeTables.h>
+#include <ModelAPI_AttributeDouble.h>
#include <ModelAPI_Data.h>
#include <ModelAPI_Document.h>
#include <ModelAPI_Object.h>
ModelAPI_AttributeString::typeId());
data()->addAttribute(ExchangePlugin_ExportFeature::XAO_GEOMETRY_NAME_ID(),
ModelAPI_AttributeString::typeId());
+ data()->addAttribute(ExchangePlugin_ExportFeature::XAO_SELECTION_LIST_ID(),
+ ModelAPI_AttributeSelectionList::typeId());
+ data()->addAttribute(ExchangePlugin_ExportFeature::STL_FILE_PATH_ID(),
+ ModelAPI_AttributeString::typeId());
+ data()->addAttribute(ExchangePlugin_ExportFeature::STL_OBJECT_SELECTED(),
+ ModelAPI_AttributeSelection::typeId());
+ data()->addAttribute(ExchangePlugin_ExportFeature::STL_DEFLECTION_TYPE(),
+ ModelAPI_AttributeString::typeId());
+ data()->addAttribute(ExchangePlugin_ExportFeature::STL_RELATIVE(),
+ ModelAPI_AttributeDouble::typeId());
+
+ double defelection = Config_PropManager::real("Visualization", "body_deflection");
+ real(ExchangePlugin_ExportFeature::STL_RELATIVE())->setValue(defelection);
+
+ data()->addAttribute(ExchangePlugin_ExportFeature::STL_ABSOLUTE(),
+ ModelAPI_AttributeDouble::typeId());
+ data()->addAttribute(ExchangePlugin_ExportFeature::STL_FILE_TYPE(),
+ ModelAPI_AttributeString::typeId());
ModelAPI_Session::get()->validators()->registerNotObligatory(getKind(),
ExchangePlugin_ExportFeature::XAO_FILE_PATH_ID());
+ ModelAPI_Session::get()->validators()->registerNotObligatory(getKind(),
+ ExchangePlugin_ExportFeature::STL_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());
+ ModelAPI_Session::get()->validators()->registerNotObligatory(getKind(),
+ ExchangePlugin_ExportFeature::XAO_SELECTION_LIST_ID());
+
+ // to support previous version of document, move the selection list
+ // if the type of export operation is XAO
+ AttributeStringPtr aTypeAttr = string(EXPORT_TYPE_ID());
+ if (aTypeAttr->isInitialized() && aTypeAttr->value() == "XAO") {
+ bool aWasBlocked = data()->blockSendAttributeUpdated(true, false);
+ AttributeSelectionListPtr aSelList = selectionList(SELECTION_LIST_ID());
+ AttributeSelectionListPtr aXAOSelList = selectionList(XAO_SELECTION_LIST_ID());
+ if (aSelList->size() > 0 && aXAOSelList->size() == 0)
+ aSelList->copyTo(aXAOSelList);
+ aSelList->clear();
+ data()->blockSendAttributeUpdated(aWasBlocked, false);
+ }
}
void ExchangePlugin_ExportFeature::attributeChanged(const std::string& theID)
string(ExchangePlugin_ExportFeature::FILE_PATH_ID())->setValue(
string(ExchangePlugin_ExportFeature::XAO_FILE_PATH_ID())->value());
}
+ else if (theID == STL_FILE_PATH_ID()) {
+ string(ExchangePlugin_ExportFeature::FILE_PATH_ID())->setValue(
+ string(ExchangePlugin_ExportFeature::STL_FILE_PATH_ID())->value());
+ }
}
/*
if (aFormatName == "XAO") {
exportXAO(theFileName);
return;
+ }else if (aFormatName == "STL") {
+ exportSTL(theFileName);
+ return;
}
// make shape for export from selected shapes
AttributeSelectionListPtr aSelectionListAttr =
this->selectionList(ExchangePlugin_ExportFeature::SELECTION_LIST_ID());
std::list<GeomShapePtr> aShapes;
+ std::list<ResultPtr> aContexts;
for (int i = 0, aSize = aSelectionListAttr->size(); i < aSize; ++i) {
AttributeSelectionPtr anAttrSelection = aSelectionListAttr->value(i);
+
+ /// do not export pictures
+ ResultPtr aBodyContext =
+ std::dynamic_pointer_cast<ModelAPI_Result>(anAttrSelection->context());
+ if (aBodyContext.get() && aBodyContext->hasTexture())
+ continue;
+
std::shared_ptr<GeomAPI_Shape> aCurShape = anAttrSelection->value();
if (aCurShape.get() == NULL)
aCurShape = anAttrSelection->context()->shape();
if (aCurShape.get() != NULL)
+ {
aShapes.push_back(aCurShape);
+ aContexts.push_back(anAttrSelection->context());
+ }
}
// Store compound if we have more than one shape.
if (aFormatName == "BREP") {
aResult = BREPExport(theFileName, aFormatName, aShape, anError);
} else if (aFormatName == "STEP") {
- aResult = STEPExport(theFileName, aFormatName, aShape, anError);
+ aResult = STEPExport(theFileName, aShapes, aContexts, anError);
} else if (aFormatName.substr(0, 4) == "IGES") {
aResult = IGESExport(theFileName, aFormatName, aShape, anError);
} else {
anError = "Unsupported format: " + aFormatName;
}
- if (!anError.empty()) {
+ if (!aResult || !anError.empty()) {
setError("An error occurred while exporting " + theFileName + ": " + anError);
return;
}
return aStr.str();
}
-/// Returns true if something in selection is presented in the results list
-static bool isInResults(AttributeSelectionListPtr theSelection,
- const std::list<ResultPtr>& theResults,
- std::set<ResultPtr>& theCashedResults)
+void ExchangePlugin_ExportFeature::exportSTL(const std::string& theFileName)
{
- // collect all results into a cashed set
- if (theCashedResults.empty()) {
- std::list<ResultPtr> aResults;
- std::list<ResultPtr>::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<ModelAPI_ResultBody>(*aRes);
- std::list<ResultPtr> aResults;
- ModelAPI_Tools::allSubs(aResBody, aResults, false);
- for(std::list<ResultPtr>::iterator aR = aResults.begin(); aR != aResults.end(); aR++) {
- theCashedResults.insert(std::dynamic_pointer_cast<ModelAPI_ResultBody>(*aR));
- }
- } else if ((*aRes)->groupName() == ModelAPI_ResultPart::group()) { // all results of the part
- ResultPartPtr aResPart = std::dynamic_pointer_cast<ModelAPI_ResultPart>(*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<ModelAPI_ResultBody>(
- aPartDoc->object(ModelAPI_ResultBody::group(), aBodyIndex));
- if (aResBody.get()) {
- theCashedResults.insert(aResBody);
- std::list<ResultPtr> aResults;
- ModelAPI_Tools::allSubs(aResBody, aResults, false);
- for(std::list<ResultPtr>::iterator aR = aResults.begin(); aR != aResults.end(); aR++) {
- theCashedResults.insert(std::dynamic_pointer_cast<ModelAPI_ResultBody>(*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<ModelAPI_ResultBody>(anAttr->context());
- if (aSelected.get() && theCashedResults.count(aSelected))
- return true;
+ // Get shape.
+ AttributeSelectionPtr aSelection = selection(STL_OBJECT_SELECTED());
+ GeomShapePtr aShape = aSelection->value();
+ if (!aShape.get()) {
+ aShape = aSelection->context()->shape();
}
- return false;
-}
-/// Returns all sub-shapes of the given shape in theResult
-static void allSubShapes(const GeomShapePtr theShape, GeomAPI_Shape::ShapeType theType,
- std::list<GeomShapePtr>& theResult)
-{
- if (theShape->shapeType() == theType) {
- theResult.push_back(theShape);
+ // Get relative value and percent flag.
+ double aValue;
+ bool anIsRelative = false;
+ bool anIsASCII = false;
+
+ if (string(STL_DEFLECTION_TYPE())->value() == STL_DEFLECTION_TYPE_RELATIVE()) {
+ aValue = real(STL_RELATIVE())->value();
+ anIsRelative = true;
} else {
- GeomAPI_DataMapOfShapeShape aUnique; // to keep only unique shapes
- for(GeomAPI_ShapeExplorer anExp(theShape, theType); anExp.more(); anExp.next()) {
- if (aUnique.bind(anExp.current(), anExp.current()))
- theResult.push_back(anExp.current());
- }
+ aValue = real(STL_ABSOLUTE())->value();
+ }
+
+ if (string(STL_FILE_TYPE())->value() == STL_FILE_TYPE_ASCII()) {
+ anIsASCII = true;
+ }
+ // Perform the export
+ std::string anError;
+ bool aResult = false;
+
+ aResult = STLExport(theFileName,
+ aShape,
+ aValue,
+ anIsRelative,
+ anIsASCII,
+ anError);
+
+ if (!aResult || !anError.empty()) {
+ setError("An error occurred while exporting " + theFileName + ": " + anError);
+ return;
}
}
+
void ExchangePlugin_ExportFeature::exportXAO(const std::string& theFileName)
{
try {
std::list<GeomShapePtr> aShapes;
std::list<ResultPtr> aResults;
std::list<DocumentPtr> aDocuments; /// documents of Parts selected and used in export
+ std::map<DocumentPtr, GeomTrsfPtr> aDocTrsf; /// translation of the part
- AttributeSelectionListPtr aSelection = selectionList(SELECTION_LIST_ID());
+ bool anExCludedIsImage = false;
+ AttributeSelectionListPtr aSelection = selectionList(XAO_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++) {
+ for (int a = 0; a < aSelection->size(); a++) {
AttributeSelectionPtr anAttr = aSelection->value(a);
ResultPtr aBodyContext =
std::dynamic_pointer_cast<ModelAPI_Result>(anAttr->context());
if (aBodyContext.get() && !aBodyContext->isDisabled() && aBodyContext->shape().get()) {
+ /// do not export pictures
+ if (aBodyContext->hasTexture()){
+ anExCludedIsImage = true;
+ continue;
+ }
aResults.push_back(aBodyContext);
GeomShapePtr aShape = anAttr->value();
if (!aShape.get())
return;
} else {
aDocuments.push_back(aPartDoc);
+ aDocTrsf[aPartDoc] = aResPart->summaryTrsf();
}
}
}
}
}
if (aShapes.empty()) {
- setError("No shapes to export");
+ if(!anExCludedIsImage)
+ setError("No shapes to export");
return;
}
if (aGeometryName.empty() && aResults.size() == 1) {
// get the name from the first result
ResultPtr aResultBody = *aResults.begin();
- aGeometryName = aResultBody->data()->name();
+ aGeometryName = Locale::Convert::toString(aResultBody->data()->name());
}
aXao.getGeometry()->setName(aGeometryName);
for (int aGroupIndex = 0; aGroupIndex < aGroupCount; ++aGroupIndex) {
ResultGroupPtr aResultGroup = std::dynamic_pointer_cast<ModelAPI_ResultGroup>(
(*aDoc)->object(ModelAPI_ResultGroup::group(), aGroupIndex));
+ if (!aResultGroup.get() || !aResultGroup->shape().get())
+ continue;
FeaturePtr aGroupFeature = (*aDoc)->feature(aResultGroup);
AttributeSelectionListPtr aSelectionList =
aGroupFeature->selectionList("group_list");
- if (!isInResults(aSelectionList, aResults, allResultsCashed))// skip group not used in result
+ if (!ModelAPI_Tools::isInResults(aSelectionList,
+ aResults,
+ allResultsCashed))// skip group not used in result
continue;
// conversion of dimension
XAO::Dimension aGroupDimension = XAO::XaoUtils::stringToDimension(aDimensionString);
XAO::Group* aXaoGroup = aXao.addGroup(aGroupDimension,
- aResultGroup->data()->name());
+ Locale::Convert::toString(aResultGroup->data()->name()));
try {
- for (int aSelectionIndex = 0; aSelectionIndex < aSelectionList->size(); ++aSelectionIndex){
- AttributeSelectionPtr aSelection = aSelectionList->value(aSelectionIndex);
- GeomShapePtr aSelShape = aSelection->value();
- if (!aSelShape.get() && aSelection->context().get()) {
- aSelShape = aSelection->context()->shape();
- }
-
- std::list<GeomShapePtr> allSubs;
- allSubShapes(aSelShape, aSelType, allSubs);
-
- std::list<GeomShapePtr>::iterator anIter = allSubs.begin();
- for(; anIter != allSubs.end(); anIter++) {
- int aReferenceID = GeomAlgoAPI_CompoundBuilder::id(aShape, *anIter);
- 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);
- }
+ GeomAPI_ShapeExplorer aGroupResExplorer(aResultGroup->shape(), aSelType);
+ for(; aGroupResExplorer.more(); aGroupResExplorer.next()) {
+ GeomShapePtr aGroupShape = aGroupResExplorer.current();
+ if (aDocTrsf.find(*aDoc) != aDocTrsf.end())
+ aGroupShape->move(aDocTrsf[*aDoc]);
+ int aReferenceID = GeomAlgoAPI_CompoundBuilder::id(aShape, aGroupShape);
+ 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();
+ Locale::Convert::toString(aResultGroup->data()->name());
msg += ".\n";
msg += e.what();
msg += "\n";
std::string aSelectionType = aSelectionList->selectionType();
bool isWholePart = aSelectionType == "part";
// skip field not used in results
- if (!isWholePart && !isInResults(aSelectionList, aResults, allResultsCashed))
+ if (!isWholePart &&
+ !ModelAPI_Tools::isInResults(aSelectionList, aResults, allResultsCashed))
continue;
// conversion of dimension
XAO::Type aFieldType = XAO::XaoUtils::stringToFieldType(aTypeString);
XAO::Field* aXaoField = aXao.addField(aFieldType, aFieldDimension, aTables->columns(),
- aResultField->data()->name());
+ Locale::Convert::toString(aResultField->data()->name()));
try {
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());
+ AttributeSelectionPtr aSel = aSelectionList->value(aRow - 1);
+ int aReferenceID = GeomAlgoAPI_CompoundBuilder::id(aShape, aSel->value());
if (aReferenceID == 0) // selected value does not found in the exported shape
continue;
} catch (XAO::XAO_Exception& e) {
// LCOV_EXCL_START
std::string msg = "An error occurred while exporting field " +
- aResultField->data()->name();
+ Locale::Convert::toString(aResultField->data()->name());
msg += ".\n";
msg += e.what();
msg += "\n";
}
}
- if (aFormat == "XAO") { // on export to GEOm the selection attribute is filled - this is
+ 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());
+ AttributeSelectionListPtr aList = aThis->selectionList(XAO_SELECTION_LIST_ID());
return !aList->isInitialized() || aList->size() == 0;
}
return true;
