Config_FeatureReader::Config_FeatureReader(const std::string& theXmlFile,
const std::string& theLibraryName,
+ const std::string& theDocSection,
const char* theEventGenerated)
: Config_XMLReader(theXmlFile),
myLibraryName(theLibraryName),
+ myLibraryDocSection(theDocSection),
myEventGenerated(theEventGenerated ? theEventGenerated : Config_FeatureMessage::GUI_EVENT()),
myIsProcessWidgets(theEventGenerated != NULL)
{
outFeatureMessage->setInternal(isInternal);
std::string aHelpFile = getProperty(theFeatureNode, HELP_FILE);
- if (!aHelpFile.empty())
- outFeatureMessage->setHelpFileName(myLibraryName + "/" + aHelpFile);
+ if (!aHelpFile.empty()) {
+ aHelpFile =
+ (myLibraryDocSection.empty() ? myLibraryName : myLibraryDocSection) + "/" + aHelpFile;
+ outFeatureMessage->setHelpFileName(aHelpFile);
+ }
bool isHideFaces = getBooleanAttribute(theFeatureNode, HIDEFACES_PANEL, false);
outFeatureMessage->setHideFacesPanel(isHideFaces);
/// Constructor
Config_FeatureReader(const std::string& theXmlFile,
const std::string& theLibraryName,
+ const std::string& theDocSection = std::string(),
const char* theEventGenerated = 0);
virtual ~Config_FeatureReader();
/// Returns list of all features defined in reader's file
private:
std::string myLibraryName;
+ std::string myLibraryDocSection;
std::list<std::string> myFeatures;
/// event generated on feature data sending, by default it is Config_FeatureMessage::GUI_EVENT()
MAYBE_UNUSED const static char* PLUGIN_SCRIPT = "script";
MAYBE_UNUSED const static char* PLUGIN_DEPENDENCY = "dependency";
MAYBE_UNUSED const static char* PLUGIN_USES = "uses";
+MAYBE_UNUSED const static char* PLUGIN_DOCSECTION = "docsection";
+MAYBE_UNUSED const static char* PLUGIN_LICENSE = "license";
/*
* Hardcoded xml entities of dataModel.xml
return myFeaturesInFiles;
}
+const std::map<std::string, std::string>& Config_ModuleReader::proprietaryFeatures() const
+{
+ return myProprietaryFeatures;
+}
+
+const std::set<std::string>& Config_ModuleReader::proprietaryPlugins() const
+{
+ return myProprietaryPlugins;
+}
+
const std::set<std::string>& Config_ModuleReader::modulePluginFiles() const
{
return myPluginFiles;
void Config_ModuleReader::addFeature(const std::string& theFeatureName,
const std::string& thePluginConfig)
{
+ if (myProprietaryFeatures.count(theFeatureName)) {
+ myProprietaryFeatures.erase(theFeatureName);
+ }
+
if (myFeaturesInFiles.count(theFeatureName)) {
std::string anErrorMsg = "Can not register feature '%1' in plugin '%2'."
" There is a feature with the same ID.";
myFeaturesInFiles[theFeatureName] = thePluginConfig;
}
+void Config_ModuleReader::addFeatureRequireLicense(const std::string& theFeatureName,
+ const std::string& thePluginConfig)
+{
+ if (myFeaturesInFiles.count(theFeatureName) ||
+ myProprietaryFeatures.count(theFeatureName)) {
+ std::string anErrorMsg = "Can not register feature '%1' in plugin '%2'."
+ " There is a feature with the same ID.";
+ Events_InfoMessage("Config_ModuleReader", anErrorMsg)
+ .arg(theFeatureName).arg(thePluginConfig).send();
+ return;
+ }
+
+ myProprietaryFeatures[theFeatureName] = thePluginConfig;
+}
+
void Config_ModuleReader::processNode(xmlNodePtr theNode)
{
if (isNode(theNode, NODE_PLUGIN, NULL)) {
std::string aPluginLibrary = getProperty(theNode, PLUGIN_LIBRARY);
std::string aPluginScript = getProperty(theNode, PLUGIN_SCRIPT);
std::string aPluginName = addPlugin(aPluginLibrary, aPluginScript, aPluginConf);
+ std::string aPluginDocSection = getProperty(theNode, PLUGIN_DOCSECTION);
std::string aUsesPlugin = getProperty(theNode, PLUGIN_USES);
if (!aUsesPlugin.empty()) { // send information about the plugin dependencies
std::shared_ptr<Config_PluginMessage> aMess(new Config_PluginMessage(
Events_Loop::loop()->send(aMess);
}
- std::list<std::string> aFeatures = importPlugin(aPluginName, aPluginConf);
+ std::string aLicense = getProperty(theNode, PLUGIN_LICENSE);
+ std::transform(aLicense.begin(), aLicense.end(), aLicense.begin(), ::tolower);
+ bool isLicensed = aLicense == "true";
+ if (isLicensed)
+ myProprietaryPlugins.insert(aPluginName);
+
+ std::list<std::string> aFeatures = importPlugin(aPluginName, aPluginConf, aPluginDocSection);
std::list<std::string>::iterator it = aFeatures.begin();
for (; it != aFeatures.end(); it++) {
- addFeature(*it, aPluginConf);
+ if (isLicensed)
+ addFeatureRequireLicense(*it, aPluginConf);
+ else
+ addFeature(*it, aPluginConf);
}
}
}
}
std::list<std::string> Config_ModuleReader::importPlugin(const std::string& thePluginLibrary,
- const std::string& thePluginXmlConf)
+ const std::string& thePluginXmlConf,
+ const std::string& thePluginDocSection)
{
if (thePluginXmlConf.empty()) { //probably a third party library
loadLibrary(thePluginLibrary);
Config_FeatureReader aReader = Config_FeatureReader(thePluginXmlConf,
thePluginLibrary,
+ thePluginDocSection,
myEventGenerated);
aReader.readAll();
return aReader.features();
/// Returns map that describes which file contains a feature
/// (the feature is key, the file is value)
CONFIG_EXPORT const std::map<std::string, std::string>& featuresInFiles() const;
+ /// Returns map containing features, which have licensed.
+ /// The valid license should be confirmed first
+ /// (the feature is key, the file is value)
+ CONFIG_EXPORT const std::map<std::string, std::string>& proprietaryFeatures() const;
+ /// Returns proprietary plugins
+ CONFIG_EXPORT const std::set<std::string>& proprietaryPlugins() const;
/// Returns list of module's xml files
CONFIG_EXPORT const std::set<std::string>& modulePluginFiles() const;
/// Returns module name: an xml attribute from the root of the plugins.xml:
bool hasRequiredModules(xmlNodePtr aNode) const;
/// reads info about plugin's features from plugin xml description
std::list<std::string> importPlugin(const std::string& thePluginLibrary,
- const std::string& thePluginFile);
+ const std::string& thePluginFile,
+ const std::string& thePluginDocSection);
/// stores information about plugin in the internal cache
std::string addPlugin(const std::string& aPluginLibrary,
const std::string& aPluginScript,
/// Save feature in myFeaturesInFiles.
/// Generates an error if the feature name is already registered.
void addFeature(const std::string& theFeatureName, const std::string& thePluginConfig);
+ /// Save feature in myFeaturesRequireLicense.
+ /// Generates an error if the feature name is already registered.
+ void addFeatureRequireLicense(const std::string& theFeatureName,
+ const std::string& thePluginConfig);
private:
std::map<std::string, std::string> myFeaturesInFiles; ///< a feature name is key, a file is value
+ /// list of features, which need a license, and their config files
+ std::map<std::string, std::string> myProprietaryFeatures;
std::set<std::string> myPluginFiles; ///< a feature name is key, a file is value
/// a plugin name is key, a plugin type is value
static std::map<std::string, PluginType> myPluginTypes;
static std::set<std::string> myDependencyModules; ///< set of loaded modules
const char* myEventGenerated; ///< gives ability to send Feature_Messages to various listeners
+
+ std::set<std::string> myProprietaryPlugins; ///< list of plugins protected by license
};
#endif /* CONFIG_XMLMODULEREADER_H_ */
for aResIndex in range(self.Part.size(aResultType)):
anObject = self.Part.object(aResultType, aResIndex)
aResult = model.objectToResult(anObject)
- # do nt export picture
- if aResult.hasTextureFile() is True:
+ # do not export picture
+ if aResult.hasTexture() is True:
continue
if not aResult is None:
if (not aResult.shape() or aResult.shape().isNull()) and isPart:
aResObject = aPartDoc.object(model.ModelAPI_ResultBody_group(), aResId)
aRes = model.objectToResult(aResObject)
#do not export images
- if aRes.hasTextureFile() is True:
+ if aRes.hasTexture() is True:
continue
aResFeatureId = str(aPartDoc.feature(aRes).data().featureId())
if aResFeatureId in aFeaturesIndices:
#
INCLUDE(Common)
+INCLUDE(UseQtExt)
SET(PROJECT_HEADERS
ExchangeAPI.h
ModelAPI
ModelHighAPI
GeomAlgoAPI
+ ${QT_LIBRARIES}
)
INCLUDE_DIRECTORIES(
${PROJECT_SOURCE_DIR}/src/ModelAPI
${PROJECT_SOURCE_DIR}/src/ModelHighAPI
${PROJECT_SOURCE_DIR}/src/GeomAlgoAPI
+ ${QT_INCLUDES}
)
# Plugin headers dependency
${PROJECT_SOURCE_DIR}/src/ExchangePlugin
)
+# additional preprocessor / compiler flags
+ADD_DEFINITIONS(${QT_DEFINITIONS})
+
#TODO(spo): is ${OpenCASCADE_DEFINITIONS} necessary?
ADD_DEFINITIONS(-DEXCHANGEAPI_EXPORTS ${OpenCASCADE_DEFINITIONS})
ADD_LIBRARY(ExchangeAPI SHARED ${PROJECT_SOURCES} ${PROJECT_HEADERS})
#include <ModelHighAPI_Tools.h>
//--------------------------------------------------------------------------------------
#include <ModelAPI_AttributeStringArray.h>
+#include <ModelAPI_AttributeImage.h>
#include <ModelAPI_Session.h>
#include <ModelAPI_Tools.h>
#include <GeomAlgoAPI_Tools.h>
//--------------------------------------------------------------------------------------
#include <algorithm>
+//--------------------------------------------------------------------------------------
+#include <QPixmap>
+#include <QDir>
+#include <QFile>
+#include <QFileInfo>
ExchangeAPI_Import::ExchangeAPI_Import(
const std::shared_ptr<ModelAPI_Feature> & theFeature)
std::string aPartName = theDumper.name(aBase->document());
std::string aFilePath =
- aBase->string(ExchangePlugin_Import_ImageFeature::FILE_PATH_ID())->value();
+ aBase->string(ExchangePlugin_Import_ImageFeature::FILE_PATH_ID())->value();
+
+ // store image into a new file near the dumped python script
+ ResultPtr aResult = aBase->firstResult();
+ std::string aNewImageDir = theDumper.getDumpDir();
+ if (aResult.get() && aResult->hasTexture()) {
+ // get image data
+ int aWidth, aHeight;
+ std::string aFormat;
+ std::list<unsigned char> aByteList;
+ AttributeImagePtr anImageAttr =
+ aResult->data()->image(ModelAPI_ResultBody::IMAGE_ID());
+ anImageAttr->texture(aWidth, aHeight, aByteList, aFormat);
+
+ // convert image data to QPixmap
+ uchar* arr = new uchar[aByteList.size()];
+ std::copy(aByteList.begin(), aByteList.end(), arr);
+ QImage image (arr, aWidth, aHeight, QImage::Format_ARGB32);
+ QPixmap pixmap = QPixmap::fromImage( image );
+
+ // get new file name
+ std::wstring aName = aBase->name();
+ std::string anImageName (aName.begin(), aName.end());
+ std::string aNewImageFile = anImageName + "." + aFormat;
+ QFileInfo aNewFileInfo (QDir(aNewImageDir.c_str()), aNewImageFile.c_str());
+ for (int ii = 1; QFile::exists(aNewFileInfo.absoluteFilePath()); ii++) {
+ // construct the new file name by adding the unique number
+ aNewImageFile = anImageName + "_" + std::to_string(ii) + "." + aFormat;
+ aNewFileInfo.setFile(QDir(aNewImageDir.c_str()), aNewImageFile.c_str());
+ }
+
+ // write image to a new file
+ if (pixmap.save(aNewFileInfo.absoluteFilePath())) {
+ // to dump new file name
+ aFilePath = aNewFileInfo.absoluteFilePath().toStdString();
+ }
+ delete [] arr;
+ }
theDumper << aBase << " = model.addImportImage(" << aPartName << ", \""
<< aFilePath << "\")" << std::endl;
INCLUDE(Common)
INCLUDE(UnitTest)
+INCLUDE(UseQtExt)
INCLUDE_DIRECTORIES(${PROJECT_SOURCE_DIR}/src/Events
${PROJECT_SOURCE_DIR}/src/Config
${PROJECT_SOURCE_DIR}/src/ConstructionPlugin
${PROJECT_SOURCE_DIR}/src/PartSetPlugin
${OpenCASCADE_INCLUDE_DIR}
+ ${QT_INCLUDES}
)
+# additional preprocessor / compiler flags
+ADD_DEFINITIONS(${QT_DEFINITIONS})
+
SET(PROJECT_HEADERS
ExchangePlugin.h
ExchangePlugin_Plugin.h
GeomAlgoAPI
GeomValidators
XAOShaper
+ ${QT_LIBRARIES}
)
# default dump approaches (will be set if not initialized)
#include <ModelAPI_Document.h>
#include <ModelAPI_Session.h>
#include <ModelAPI_ResultPart.h>
+#include <ModelAPI_Validator.h>
#include <ModelHighAPI_Dumper.h>
#include <Config_ModuleReader.h>
+#include <GeomAlgoAPI_Tools.h>
+
#ifdef EXCHANGEPLUGIN_DUMP_NAMING
static const bool THE_DUMP_NAMING = true;
#else
data()->addAttribute(EXPORT_VARIABLES_ID(), ModelAPI_AttributeBoolean::typeId());
+ data()->addAttribute(DUMP_DIR_ID(), ModelAPI_AttributeString::typeId());
+
// default values
boolean(TOPOLOGICAL_NAMING_DUMP_ID())->setValue(THE_DUMP_NAMING);
boolean(GEOMETRIC_DUMP_ID())->setValue(THE_DUMP_GEO);
boolean(WEAK_NAMING_DUMP_ID())->setValue(THE_DUMP_WEAK);
boolean(EXPORT_VARIABLES_ID())->setValue(false);
+
+ ModelAPI_Session::get()->validators()->registerNotObligatory(getKind(), DUMP_DIR_ID());
}
void ExchangePlugin_Dump::execute()
aDumper->addCustomStorage(aWeakNamingStorage);
}
+ // pass dump directory to the dumper
+ AttributeStringPtr aDumpDirAttr =
+ this->string(ExchangePlugin_Dump::DUMP_DIR_ID());
+ std::string aDumpDir;
+ if (aDumpDirAttr.get() && !aDumpDirAttr->isInitialized())
+ aDumpDir = GeomAlgoAPI_Tools::File_Tools::path(theFileName);
+ aDumper->setDumpDir(aDumpDir);
+
if (!aDumper->process(aDoc, theFileName)) {
setError("An error occurred while dumping to " + theFileName);
} else {
static const std::string MY_DUMP_ID("Dump");
return MY_DUMP_ID;
}
+ /// attribute name of true dumping directory
+ inline static const std::string& DUMP_DIR_ID()
+ {
+ static const std::string MY_DUMP_DIR_ID("dump_dir");
+ return MY_DUMP_DIR_ID;
+ }
/// attribute name of file path
inline static const std::string& FILE_PATH_ID()
{
/// do not export pictures
ResultPtr aBodyContext =
std::dynamic_pointer_cast<ModelAPI_Result>(anAttrSelection->context());
- if(aBodyContext->hasTextureFile())
+ if (aBodyContext->hasTexture())
continue;
std::shared_ptr<GeomAPI_Shape> aCurShape = anAttrSelection->value();
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->hasTextureFile()){
+ if (aBodyContext->hasTexture()){
anExCludedIsImage = true;
continue;
}
#include <ModelAPI_Session.h>
#include <ModelAPI_ResultPart.h>
#include <ModelAPI_Tools.h>
+#include <ModelAPI_Validator.h>
static const std::wstring THE_NEW_PART_STR(L"New Part");
data()->addAttribute(STEP_MATERIALS_ID(), ModelAPI_AttributeBoolean::typeId());
data()->addAttribute(STEP_COLORS_ID(), ModelAPI_AttributeBoolean::typeId());
data()->addAttribute(STEP_SCALE_INTER_UNITS_ID(), ModelAPI_AttributeBoolean::typeId());
+
+#ifndef HAVE_SALOME
+ ModelAPI_Session::get()->validators()->registerNotObligatory(
+ getKind(), ExchangePlugin_Import::IMPORT_TYPE_ID());
+ ModelAPI_Session::get()->validators()->registerNotObligatory(
+ getKind(), ExchangePlugin_Import::STEP_FILE_PATH_ID());
+ ModelAPI_Session::get()->validators()->registerNotObligatory(
+ getKind(), ExchangePlugin_Import::STEP_TARGET_PART_ID());
+ ModelAPI_Session::get()->validators()->registerNotObligatory(
+ getKind(), ExchangePlugin_Import::STEP_TARGET_PARTS_LIST_ID());
+ ModelAPI_Session::get()->validators()->registerNotObligatory(
+ getKind(), ExchangePlugin_Import::STEP_MATERIALS_ID());
+ ModelAPI_Session::get()->validators()->registerNotObligatory(
+ getKind(), ExchangePlugin_Import::STEP_COLORS_ID());
+ ModelAPI_Session::get()->validators()->registerNotObligatory(
+ getKind(), ExchangePlugin_Import::STEP_SCALE_INTER_UNITS_ID());
+#endif
}
/*
void ExchangePlugin_Import_Image::execute()
{
- AttributeStringPtr aFilePathAttr = string(ExchangePlugin_ImportBase::FILE_PATH_ID());
+ AttributeStringPtr aFilePathAttr = string(ExchangePlugin_ImportBase::FILE_PATH_ID());
std::string aFilePath = aFilePathAttr->value();
if (aFilePath.empty()) {
setError("File path is empty.");
#include <ModelAPI_AttributeString.h>
#include <ModelAPI_AttributeStringArray.h>
#include <ModelAPI_AttributeIntArray.h>
+#include <ModelAPI_AttributeImage.h>
#include <ModelAPI_AttributeTables.h>
#include <ModelAPI_AttributeBoolean.h>
#include <ModelAPI_AttributeInteger.h>
#include <ExchangePlugin_Tools.h>
+#include <QPixmap>
/*
* Request for initialization of data model of the feature: adding all attributes
void ExchangePlugin_Import_ImageFeature::importFile(const std::string& theFileName)
{
-
std::string anExtension = GeomAlgoAPI_Tools::File_Tools::extension(theFileName);
- std::string theTextureFileName = "";
- // Perform the import
std::string anError;
- std::shared_ptr<GeomAPI_Shape> aGeomShape;
- if (anExtension == "PNG" || anExtension == "GIF" ||
- anExtension == "TIFF" || anExtension == "JPE" ||
- anExtension == "JPG" || anExtension == "JPEG" ||
- anExtension == "BMP"|| anExtension == "PPM"
- ) {
- aGeomShape = ImageImport(theFileName, anError);
- if(anError == "")
- theTextureFileName = theFileName;
- } else {
- anError = "Unsupported format: " + anExtension;
- }
- // Check if shape is valid
- if (!anError.empty()) {
- setError("An error occurred while importing " + theFileName + ": " + anError);
- return;
- }
+ if (anExtension == "PNG" || anExtension == "GIF" ||
+ anExtension == "TIFF" || anExtension == "JPE" ||
+ anExtension == "JPEG" || anExtension == "JPG" ||
+ anExtension == "BMP" || anExtension == "PPM"
+ ) {
+ // Perform the import
+ QPixmap px (theFileName.c_str());
+ int aWidth = px.width();
+ int aHeight = px.height();
+ if (aWidth < 1 || aHeight < 1) {
+ setError("An error occurred while importing " + theFileName + ": invalid image");
+ return;
+ }
- // Pass the results into the model
- std::string anObjectName = GeomAlgoAPI_Tools::File_Tools::name(theFileName);
- data()->setName(Locale::Convert::toWString(anObjectName));
+ std::shared_ptr<GeomAPI_Shape> aGeomShape = ImageImport(aWidth, aHeight, anError);
+
+ // Check if shape is valid
+ if (!anError.empty()) {
+ setError("An error occurred while importing " + theFileName + ": " + anError);
+ return;
+ }
+
+ // Pass the results into the model
+ std::string anObjectName = GeomAlgoAPI_Tools::File_Tools::name(theFileName);
+ data()->setName(Locale::Convert::toWString(anObjectName));
+
+ auto resultBody = createResultBody(aGeomShape);
- auto resultBody = createResultBody(aGeomShape);
- resultBody->setTextureFile(theTextureFileName);
- setResult(resultBody);
+ // Store image in result body attribute
+ AttributeImagePtr anImageAttr = resultBody->data()->image(ModelAPI_ResultBody::IMAGE_ID());
+ if (anImageAttr.get() != NULL) {
+ QImage aQImage = px.toImage();
+ const uchar* aImageBytes = aQImage.bits();
+ std::list<unsigned char> aByteArray (aImageBytes, aImageBytes + aQImage.sizeInBytes());
+ anImageAttr->setTexture(aWidth, aHeight, aByteArray, anExtension);
+ }
+
+ setResult(resultBody);
+ }
+ else {
+ anError = "Unsupported format: " + anExtension;
+ setError("An error occurred while importing " + theFileName + ": " + anError);
+ }
}
assert(abs(dx-400) <= tol)
assert(abs(dy-258.5) <= tol)
assert(abs(dz-0) <= tol)
+assert(ImportImage_1.result().resultSubShapePair()[0].hasTexture())
+assert(Translation_1.result().resultSubShapePair()[0].hasTexture())
+assert(Scale_1.result().resultSubShapePair()[0].hasTexture())
#=============================================================================
# Change the image :
assert(abs(dx-448) <= tol)
assert(abs(dy-296.8) <= tol)
assert(abs(dz-0) <= tol)
+assert(ImportImage_1.result().resultSubShapePair()[0].hasTexture())
+assert(Translation_1.result().resultSubShapePair()[0].hasTexture())
+assert(Scale_1.result().resultSubShapePair()[0].hasTexture())
+assert(model.checkPythonDump())
# Close SALOME GUI
import salome_utils
assert(abs(dx-400) <= tol)
assert(abs(dy-258.5) <= tol)
assert(abs(dz-0) <= tol)
+assert(ImportImage_1.result().resultSubShapePair()[0].hasTexture())
+assert(Translation_1.result().resultSubShapePair()[0].hasTexture())
+assert(Scale_1.result().resultSubShapePair()[0].hasTexture())
#=============================================================================
# Change the image :
assert(abs(dx-560) <= tol)
assert(abs(dy-361.9) <= tol)
assert(abs(dz-0) <= tol)
+assert(ImportImage_1.result().resultSubShapePair()[0].hasTexture())
+assert(Translation_1.result().resultSubShapePair()[0].hasTexture())
+assert(Scale_1.result().resultSubShapePair()[0].hasTexture())
# Close SALOME GUI
--- /dev/null
+# Copyright (C) 2021 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
+#
+
+import os, inspect
+from salome.shaper import model
+
+from PyQt5.Qt import QApplication
+
+import salome
+salome.salome_init_without_session()
+salome.salome_init(1)
+if QApplication.instance() is None:
+ app = QApplication([])
+
+from tempfile import TemporaryDirectory
+from ModelAPI import *
+
+data_dir = os.path.join(os.path.dirname(inspect.getfile(lambda: None)), "data")
+
+model.begin()
+partSet = model.moduleDocument()
+
+### Create Part
+Part_1 = model.addPart(partSet)
+Part_1_doc = Part_1.document()
+
+### Create ImportImage
+ImportImage_1 = model.addImportImage(Part_1_doc, os.path.join(data_dir, "1.jpg"))
+model.do()
+ImportImage_1.setName("drawing")
+ImportImage_1.result().setName("drawing")
+
+### Create Translation
+Translation_1 = model.addTranslation(Part_1_doc, [model.selection("FACE", "drawing")], startPoint = model.selection("VERTEX", "[drawing/Shape_1]e[drawing/Shape_4]e"), endPoint = model.selection("VERTEX", "PartSet/Origin"), keepSubResults = True)
+Translation_1.setName("translation")
+
+### Create Scale
+Scale_1 = model.addScale(Part_1_doc, [model.selection("FACE", "drawing")] , model.selection("VERTEX", "PartSet/Origin"), 0.5, keepSubResults = True)
+Scale_1.setName("scale")
+
+model.end()
+
+#=============================================================================
+# Tests :
+#=============================================================================
+model.checkResult(Scale_1, model, 1, [0], [0], [1], [4], [8])
+r=Scale_1.defaultResult()
+s=r.shape()
+dim=s.computeSize()
+dim=dim[1:]
+dx=abs(dim[3]-dim[0])
+dy=abs(dim[4]-dim[1])
+dz=abs(dim[5]-dim[2])
+tol=1e-06
+assert(abs(dx-400) <= tol)
+assert(abs(dy-258.5) <= tol)
+assert(abs(dz-0) <= tol)
+assert(ImportImage_1.result().resultSubShapePair()[0].hasTexture())
+assert(Translation_1.result().resultSubShapePair()[0].hasTexture())
+assert(Scale_1.result().resultSubShapePair()[0].hasTexture())
+
+aDr = objectToFeature(Part_1_doc.objectByName("Features", "drawing"))
+assert(aDr.firstResult().hasTexture())
+
+# check save/load document with an image
+with TemporaryDirectory() as tmp_dir:
+ aSession = ModelAPI_Session.get()
+ aFiles = StringList()
+ aSession.save(tmp_dir, aFiles)
+ aSession.closeAll()
+ assert(aSession.load(tmp_dir))
+ model.begin()
+ partSet = model.moduleDocument()
+ assert(partSet.size("Features") == 1)
+ aPart = objectToFeature(partSet.object("Features", 0))
+ aPartResult = modelAPI_ResultPart(aPart.results()[0])
+ aPartResult.activate()
+ aPartDoc = aPartResult.partDoc()
+ aSession.setActiveDocument(aPartDoc, True)
+ model.end()
+ aDr = objectToFeature(aPartDoc.objectByName("Features", "drawing"))
+ aTr = objectToFeature(aPartDoc.objectByName("Features", "translation"))
+ aSc = objectToFeature(aPartDoc.objectByName("Features", "scale"))
+ assert(aDr.firstResult().hasTexture())
+ assert(aTr.firstResult().hasTexture())
+ assert(aSc.firstResult().hasTexture())
+
+# Close SALOME GUI
+import salome_utils
+import subprocess
+port = salome_utils.getPortNumber()
+proc = subprocess.Popen(["killSalomeWithPort.py", "{}".format(port)])
SET(TEST_WITH_GUI_NAMES
TestImportImage_1.py
TestImportImage_2.py
+ TestImportImage_3.py
)
\ No newline at end of file
**Dialog box to export in STL format**
-The file name and path can be defined in **Export file** field by direct input or browsing with ‘…’ button, which opens Export file dialog box.
+The file name and path can be defined in **Export file** field by direct input or browsing with '...' button, which opens Export file dialog box.
**Object** field contains an exported object which can be selected in a viewer or object browser.
**Dialog box to import file in STEP format**
-The file name and path can be defined in **Import file** field by direct input or browsing with ‘…’ button, which opens **Import file** dialog box.
+The file name and path can be defined in **Import file** field by direct input or browsing with '...' button, which opens **Import file** dialog box.
The **Import to** combobox provides the list of destinations (one of existing Parts or a new Part).
**STEP options** provide the possibility to **Scale to International System Units** as well as to create groups from **Materials** and/or **Colors** if defined in assemblies of the file to import.
const GeomShapePtr theResultShape,
int& theResultIndex,
std::shared_ptr<GeomAlgoAPI_MakeShapeList> theMakeShapeList,
- std::vector<FeaturesPlugin_Tools::ResultBaseAlgo>& theResultBaseAlgoList)
+ std::vector<ModelAPI_Tools::ResultBaseAlgo>& theResultBaseAlgoList)
{
if (!theResultShape)
return;
std::shared_ptr<ModelAPI_ResultBody> aResultBody =
document()->createBody(data(), theResultIndex);
- FeaturesPlugin_Tools::loadModifiedShapes(aResultBody,
+ ModelAPI_Tools::loadModifiedShapes(aResultBody,
theObjects,
theTools,
theMakeShapeList,
setResult(aResultBody, theResultIndex++);
// merge algorithms
- FeaturesPlugin_Tools::ResultBaseAlgo aRBA;
+ ModelAPI_Tools::ResultBaseAlgo aRBA;
aRBA.resultBody = aResultBody;
aRBA.baseShape = theObjects.front();
- for (std::vector<FeaturesPlugin_Tools::ResultBaseAlgo>::iterator
+ for (std::vector<ModelAPI_Tools::ResultBaseAlgo>::iterator
aRBAIt = theResultBaseAlgoList.begin();
aRBAIt != theResultBaseAlgoList.end(); ++aRBAIt) {
theMakeShapeList->appendAlgo(aRBAIt->makeShape);
const GeomShapePtr theResultShape,
int& theResultIndex,
std::shared_ptr<GeomAlgoAPI_MakeShapeList> theMakeShapeList,
- std::vector<FeaturesPlugin_Tools::ResultBaseAlgo>& theResultBaseAlgoList);
+ std::vector<ModelAPI_Tools::ResultBaseAlgo>& theResultBaseAlgoList);
private:
OperationType myOperationType;
std::string anError;
std::shared_ptr<GeomAlgoAPI_MakeShapeList> aMakeShapeList(new GeomAlgoAPI_MakeShapeList());
- std::vector<FeaturesPlugin_Tools::ResultBaseAlgo> aResultBaseAlgoList;
+ std::vector<ModelAPI_Tools::ResultBaseAlgo> aResultBaseAlgoList;
ListOfShape aResultShapesList;
if (isSimpleMode) {
ListOfShape anObjectList = anObjects.objects();
ListOfShape aToolsList;
- FeaturesPlugin_Tools::loadModifiedShapes(aResultBody,
+ ModelAPI_Tools::loadModifiedShapes(aResultBody,
anObjectList,
aToolsList,
aMakeShapeList,
aResultIndex++;
aToolsList = anObjectList;
- FeaturesPlugin_Tools::ResultBaseAlgo aRBA;
+ ModelAPI_Tools::ResultBaseAlgo aRBA;
aRBA.resultBody = aResultBody;
aRBA.baseShape = aBaseShape;
aRBA.makeShape = aMakeShapeList;
// result shape has been deleted, but in another it was modified or stayed.
if (!aResultCompound)
aResultCompound = GeomAlgoAPI_CompoundBuilder::compound(aResultShapesList);
- FeaturesPlugin_Tools::loadDeletedShapes(aResultBaseAlgoList,
+ ModelAPI_Tools::loadDeletedShapes(aResultBaseAlgoList,
aTools.objects(),
aResultCompound);
#include "FeaturesPlugin_BooleanCut.h"
-#include "FeaturesPlugin_Tools.h"
-
#include <ModelAPI_ResultBody.h>
#include <ModelAPI_AttributeSelectionList.h>
#include <ModelAPI_Tools.h>
return;
}
- std::vector<FeaturesPlugin_Tools::ResultBaseAlgo> aResultBaseAlgoList;
+ std::vector<ModelAPI_Tools::ResultBaseAlgo> aResultBaseAlgoList;
ListOfShape aResultShapesList;
std::string anError;
// result shape has been deleted, but in another it was modified or stayed.
if (!aResultCompound)
aResultCompound = GeomAlgoAPI_CompoundBuilder::compound(aResultShapesList);
- FeaturesPlugin_Tools::loadDeletedShapes(aResultBaseAlgoList,
+ ModelAPI_Tools::loadDeletedShapes(aResultBaseAlgoList,
aTools.objects(),
aResultCompound);
//
#include "FeaturesPlugin_BooleanFill.h"
-#include "FeaturesPlugin_Tools.h"
#include <ModelAPI_ResultBody.h>
#include <ModelAPI_AttributeSelectionList.h>
return;
}
- std::vector<FeaturesPlugin_Tools::ResultBaseAlgo> aResultBaseAlgoList;
+ std::vector<ModelAPI_Tools::ResultBaseAlgo> aResultBaseAlgoList;
ListOfShape aResultShapesList;
std::shared_ptr<GeomAlgoAPI_MakeShapeList> aMakeShapeList(new GeomAlgoAPI_MakeShapeList());
// result shape has been deleted, but in another it was modified or stayed.
if (!aResultCompound)
aResultCompound = GeomAlgoAPI_CompoundBuilder::compound(aResultShapesList);
- FeaturesPlugin_Tools::loadDeletedShapes(aResultBaseAlgoList,
+ ModelAPI_Tools::loadDeletedShapes(aResultBaseAlgoList,
aTools.objects(),
aResultCompound);
#include "FeaturesPlugin_BooleanFuse.h"
-#include "FeaturesPlugin_Tools.h"
-
#include <ModelAPI_ResultBody.h>
#include <ModelAPI_AttributeBoolean.h>
#include <ModelAPI_AttributeInteger.h>
ResultBodyPtr aResultBody = document()->createBody(data(), aResultIndex);
ListOfShape anEmptyTools;
- FeaturesPlugin_Tools::loadModifiedShapes(aResultBody,
- anOriginalShapes,
- anEmptyTools,
- aMakeShapeList,
- aShape);
+ ModelAPI_Tools::loadModifiedShapes(aResultBody,
+ anOriginalShapes,
+ anEmptyTools,
+ aMakeShapeList,
+ aShape);
setResult(aResultBody, aResultIndex);
aResultIndex++;
- FeaturesPlugin_Tools::loadDeletedShapes(aResultBody,
- GeomShapePtr(),
- anOriginalShapes,
- aMakeShapeList,
- aShape);
+ ModelAPI_Tools::loadDeletedShapes(aResultBody,
+ GeomShapePtr(),
+ anOriginalShapes,
+ aMakeShapeList,
+ aShape);
// remove the rest results if there were produced in the previous pass
removeResults(aResultIndex);
#include "FeaturesPlugin_BooleanSmash.h"
-#include "FeaturesPlugin_Tools.h"
-
#include <ModelAPI_ResultBody.h>
#include <ModelAPI_AttributeSelectionList.h>
#include <ModelAPI_Tools.h>
std::shared_ptr<ModelAPI_ResultBody> aResultBody = document()->createBody(data(), aResultIndex);
- FeaturesPlugin_Tools::loadModifiedShapes(aResultBody,
- anOriginalShapes,
- anOriginalShapes,
- aMakeShapeList,
- aShape);
+ ModelAPI_Tools::loadModifiedShapes(aResultBody,
+ anOriginalShapes,
+ anOriginalShapes,
+ aMakeShapeList,
+ aShape);
setResult(aResultBody, aResultIndex);
aResultIndex++;
- FeaturesPlugin_Tools::loadDeletedShapes(aResultBody,
- GeomShapePtr(),
- anOriginalShapes,
- aMakeShapeList,
- aShape);
+ ModelAPI_Tools::loadDeletedShapes(aResultBody,
+ GeomShapePtr(),
+ anOriginalShapes,
+ aMakeShapeList,
+ aShape);
// remove the rest results if there were produced in the previous pass
removeResults(aResultIndex);
//
#include <FeaturesPlugin_Defeaturing.h>
-#include <FeaturesPlugin_Tools.h>
#include <ModelAPI_AttributeSelectionList.h>
#include <ModelAPI_Tools.h>
int aResultIndex = 0;
std::string anError;
- std::vector<FeaturesPlugin_Tools::ResultBaseAlgo> aResultBaseAlgoList;
+ std::vector<ModelAPI_Tools::ResultBaseAlgo> aResultBaseAlgoList;
ListOfShape anOriginalShapesList, aResultShapesList;
for (SolidFaces::iterator anIt = aBodiesAndFacesToRemove.begin();
aBaseShapes.push_back(anExp.current());
std::shared_ptr<ModelAPI_ResultBody> aResultBody = document()->createBody(data(), aResultIndex);
- FeaturesPlugin_Tools::loadModifiedShapes(aResultBody, aBaseShapes, ListOfShape(),
- anAlgo, aResult, "Defeaturing");
+ ModelAPI_Tools::loadModifiedShapes(aResultBody, aBaseShapes, ListOfShape(),
+ anAlgo, aResult, "Defeaturing");
setResult(aResultBody, aResultIndex);
aResultIndex++;
- FeaturesPlugin_Tools::ResultBaseAlgo aRBA;
+ ModelAPI_Tools::ResultBaseAlgo aRBA;
aRBA.resultBody = aResultBody;
aRBA.baseShape = aParent;
aRBA.makeShape = anAlgo;
// Store deleted shapes after all results has been proceeded. This is to avoid issue when in one
// result shape has been deleted, but in another it was modified or stayed.
GeomShapePtr aResultShapesCompound = GeomAlgoAPI_CompoundBuilder::compound(aResultShapesList);
- FeaturesPlugin_Tools::loadDeletedShapes(aResultBaseAlgoList,
+ ModelAPI_Tools::loadDeletedShapes(aResultBaseAlgoList,
anOriginalShapesList, aResultShapesCompound);
removeResults(aResultIndex);
//
#include "FeaturesPlugin_Extrusion.h"
-#include "FeaturesPlugin_Tools.h"
#include <ModelAPI_AttributeDouble.h>
#include <ModelAPI_AttributeSelection.h>
#include <ModelAPI_AttributeString.h>
#include <ModelAPI_Session.h>
#include <ModelAPI_Validator.h>
+#include <ModelAPI_Tools.h>
#include <GeomAlgoAPI_Prism.h>
#include <GeomAlgoAPI_Tools.h>
ResultBodyPtr aResultBody = document()->createBody(data(), theIndex);
// Store modified shapes.
- FeaturesPlugin_Tools::loadModifiedShapes(aResultBody, theBoundaryShapes, ListOfShape(),
- theMakeShape, theMakeShape->shape());
+ ModelAPI_Tools::loadModifiedShapes(aResultBody, theBoundaryShapes, ListOfShape(),
+ theMakeShape, theMakeShape->shape());
// Store generated edges/faces.
storeGenerationHistory(aResultBody, theBaseShape, theMakeShape);
//
#include <FeaturesPlugin_Fillet1D.h>
-#include <FeaturesPlugin_Tools.h>
#include <GeomAlgoAPI_Fillet1D.h>
#include <GeomAlgoAPI_MapShapesAndAncestors.h>
#include <ModelAPI_AttributeSelectionList.h>
#include <ModelAPI_AttributeString.h>
#include <ModelAPI_Events.h>
+#include <ModelAPI_Tools.h>
void sendMessageWithFailedShapes(const ListOfShape& theVertices)
{
ResultBodyPtr aResult = document()->createBody(data(), theResultIndex);
ListOfShape anOriginal;
anOriginal.push_back(theWire);
- FeaturesPlugin_Tools::loadModifiedShapes(aResult, anOriginal, ListOfShape(),
- aFilletBuilder, aFilletBuilder->shape(), THE_PREFIX);
+ ModelAPI_Tools::loadModifiedShapes(aResult, anOriginal, ListOfShape(),
+ aFilletBuilder, aFilletBuilder->shape(), THE_PREFIX);
setResult(aResult, theResultIndex);
// store new edges generated from vertices
for (ListOfShape::const_iterator anIt = theVertices.begin(); anIt != theVertices.end(); ++anIt)
//
#include "FeaturesPlugin_FusionFaces.h"
-#include "FeaturesPlugin_Tools.h"
#include <ModelAPI_AttributeSelectionList.h>
#include <ModelAPI_AttributeString.h>
#include <ModelAPI_ResultConstruction.h>
#include <ModelAPI_Session.h>
#include <ModelAPI_Validator.h>
+#include <ModelAPI_Tools.h>
#include <GeomAPI_ShapeIterator.h>
#include <GeomAPI_ShapeExplorer.h>
ListOfShape aBaseShapesList;
aBaseShapesList.push_back(aBaseShape);
- FeaturesPlugin_Tools::loadModifiedShapes(aResultBody, aBaseShapesList, ListOfShape(),
- anAlgo, aResultShape);
+ ModelAPI_Tools::loadModifiedShapes(aResultBody, aBaseShapesList, ListOfShape(),
+ anAlgo, aResultShape);
setResult(aResultBody);
}
#include <ModelAPI_BodyBuilder.h>
#include <ModelAPI_ResultBody.h>
#include <ModelAPI_AttributeSelectionList.h>
+#include <ModelAPI_Tools.h>
#include <GeomAlgoAPI_Intersection.h>
#include <GeomAlgoAPI_MakeShapeList.h>
}
std::shared_ptr<ModelAPI_ResultBody> aResultBody = document()->createBody(data(), aResultIndex);
- FeaturesPlugin_Tools::loadModifiedShapes(aResultBody,
- anObjects,
- ListOfShape(),
- aMakeShapeList,
- aResShape);
+ ModelAPI_Tools::loadModifiedShapes(aResultBody,
+ anObjects,
+ ListOfShape(),
+ aMakeShapeList,
+ aResShape);
setResult(aResultBody, aResultIndex);
aResultIndex++;
- FeaturesPlugin_Tools::loadDeletedShapes(aResultBody,
- GeomShapePtr(),
- anObjects,
- aMakeShapeList,
- aResShape);
+ ModelAPI_Tools::loadDeletedShapes(aResultBody,
+ GeomShapePtr(),
+ anObjects,
+ aMakeShapeList,
+ aResShape);
// remove the rest results if there were produced in the previous pass
removeResults(aResultIndex);
#include <ModelAPI_AttributeString.h>
#include <ModelAPI_ResultBody.h>
#include <ModelAPI_ResultPart.h>
+#include <ModelAPI_Tools.h>
#include <math.h>
#include <iostream>
GeomAPI_ShapeHierarchy anObjects;
std::list<ResultPtr> aParts;
- std::string theTextureFile;
- if (!FeaturesPlugin_Tools::shapesFromSelectionList(
- anObjectsSelList, isKeepSubShapes, anObjects, aParts, theTextureFile))
+ ResultPtr aTextureSource;
+ if (!FeaturesPlugin_Tools::shapesFromSelectionList
+ (anObjectsSelList, isKeepSubShapes, anObjects, aParts, aTextureSource))
return;
// Parameters of rotation.
anObjects.topLevelObjects(aTopLevel);
for (ListOfShape::iterator anIt = aTopLevel.begin(); anIt != aTopLevel.end(); ++anIt) {
ResultBodyPtr aResultBody = document()->createBody(data(), aResultIndex);
- FeaturesPlugin_Tools::loadModifiedShapes(aResultBody, anOriginalShapes, ListOfShape(),
- aMakeShapeList, *anIt, "Rotated");
- aResultBody->setTextureFile(theTextureFile);
+ ModelAPI_Tools::loadModifiedShapes(aResultBody, anOriginalShapes, ListOfShape(),
+ aMakeShapeList, *anIt, "Rotated");
+ // Copy image data, if any
+ ModelAPI_Tools::copyImageAttribute(aTextureSource, aResultBody);
setResult(aResultBody, aResultIndex++);
}
#include <ModelAPI_AttributeString.h>
#include <ModelAPI_ResultBody.h>
#include <ModelAPI_ResultPart.h>
+#include <ModelAPI_Tools.h>
#include <math.h>
GeomAPI_ShapeHierarchy anObjects;
std::list<ResultPtr> aParts;
- std::string theTextureFile;
- if (!FeaturesPlugin_Tools::shapesFromSelectionList(
- anObjectsSelList, isKeepSubShapes, anObjects, aParts, theTextureFile))
+ ResultPtr aTextureSource;
+ if (!FeaturesPlugin_Tools::shapesFromSelectionList
+ (anObjectsSelList, isKeepSubShapes, anObjects, aParts, aTextureSource))
return;
std::shared_ptr<GeomAPI_Dir> aFirstDir, aSecondDir;
anObjects.topLevelObjects(aTopLevel);
for (ListOfShape::iterator anIt = aTopLevel.begin(); anIt != aTopLevel.end(); ++anIt) {
ResultBodyPtr aResultBody = document()->createBody(data(), aResultIndex);
- FeaturesPlugin_Tools::loadModifiedShapes(aResultBody, anOriginalShapes, ListOfShape(),
- aMakeShapeList, *anIt, "Translated");
- aResultBody->setTextureFile(theTextureFile);
+ ModelAPI_Tools::loadModifiedShapes(aResultBody, anOriginalShapes, ListOfShape(),
+ aMakeShapeList, *anIt, "Translated");
+ // Copy image data, if any
+ ModelAPI_Tools::copyImageAttribute(aTextureSource, aResultBody);
setResult(aResultBody, aResultIndex++);
}
// Getting objects.
GeomAPI_ShapeHierarchy anObjects;
std::list<ResultPtr> aParts;
- std::string theTextureFile;
+ ResultPtr aTextureSource;
AttributeSelectionListPtr anObjectsSelList = selectionList(OBJECTS_LIST_ID());
- if (!FeaturesPlugin_Tools::shapesFromSelectionList(
- anObjectsSelList, isKeepSubShapes, anObjects, aParts, theTextureFile))
+ if (!FeaturesPlugin_Tools::shapesFromSelectionList
+ (anObjectsSelList, isKeepSubShapes, anObjects, aParts, aTextureSource))
return;
// Verify the start shape
for (ListOfShape::iterator anIt = aTopLevel.begin(); anIt != aTopLevel.end(); ++anIt) {
//LoadNamingDS
ResultBodyPtr aResultBody = document()->createBody(data(), aResultIndex);
- FeaturesPlugin_Tools::loadModifiedShapes(aResultBody, anOriginalShapes, ListOfShape(),
- aMakeShapeList, *anIt, "Placed");
- aResultBody->setTextureFile(theTextureFile);
+ ModelAPI_Tools::loadModifiedShapes(aResultBody, anOriginalShapes, ListOfShape(),
+ aMakeShapeList, *anIt, "Placed");
+ // Copy image data, if any
+ ModelAPI_Tools::copyImageAttribute(aTextureSource, aResultBody);
setResult(aResultBody, aResultIndex++);
}
#include <ModelAPI_AttributeString.h>
#include <ModelAPI_ResultBody.h>
#include <ModelAPI_ResultPart.h>
+#include <ModelAPI_Tools.h>
#include <GeomAlgoAPI_MakeShapeList.h>
#include <GeomAlgoAPI_PointBuilder.h>
// Getting objects.
GeomAPI_ShapeHierarchy anObjects;
std::list<ResultPtr> aParts;
- std::string theTextureFile;
+ ResultPtr aTextureSource;
AttributeSelectionListPtr anObjSelList = selectionList(OBJECTS_LIST_ID());
if (!FeaturesPlugin_Tools::shapesFromSelectionList(
- anObjSelList, isKeepSubShapes, anObjects, aParts, theTextureFile))
+ anObjSelList, isKeepSubShapes, anObjects, aParts, aTextureSource))
return;
std::string anError;
anObjects.topLevelObjects(aTopLevel);
for (ListOfShape::iterator anIt = aTopLevel.begin(); anIt != aTopLevel.end(); ++anIt) {
ResultBodyPtr aResultBody = document()->createBody(data(), aResultIndex);
- FeaturesPlugin_Tools::loadModifiedShapes(aResultBody, anOriginalShapes, ListOfShape(),
- aMakeShapeList, *anIt, "Rotated");
- aResultBody->setTextureFile(theTextureFile);
+ ModelAPI_Tools::loadModifiedShapes(aResultBody, anOriginalShapes, ListOfShape(),
+ aMakeShapeList, *anIt, "Rotated");
+ // Copy image data, if any
+ ModelAPI_Tools::copyImageAttribute(aTextureSource, aResultBody);
setResult(aResultBody, aResultIndex++);
}
#include <ModelAPI_AttributeString.h>
#include <ModelAPI_ResultBody.h>
#include <ModelAPI_ResultPart.h>
+#include <ModelAPI_Tools.h>
static const std::string SCALE_VERSION_1("v9.5");
// Getting objects.
GeomAPI_ShapeHierarchy anObjects;
std::list<ResultPtr> aParts;
- std::string theTextureFile;
+ ResultPtr aTextureSource;
AttributeSelectionListPtr anObjSelList = selectionList(OBJECTS_LIST_ID());
if (!FeaturesPlugin_Tools::shapesFromSelectionList(
- anObjSelList, isKeepSubShapes, anObjects, aParts, theTextureFile))
+ anObjSelList, isKeepSubShapes, anObjects, aParts, aTextureSource))
return;
// Getting the center point
anObjects.topLevelObjects(aTopLevel);
for (ListOfShape::iterator anIt = aTopLevel.begin(); anIt != aTopLevel.end(); ++anIt) {
ResultBodyPtr aResultBody = document()->createBody(data(), aResultIndex);
- FeaturesPlugin_Tools::loadModifiedShapes(aResultBody, anOriginalShapes, ListOfShape(),
- aMakeShapeList, *anIt, "Scaled");
- aResultBody->setTextureFile(theTextureFile);
+ ModelAPI_Tools::loadModifiedShapes(aResultBody, anOriginalShapes, ListOfShape(),
+ aMakeShapeList, *anIt, "Scaled");
+ // Copy image data, if any
+ ModelAPI_Tools::copyImageAttribute(aTextureSource, aResultBody);
setResult(aResultBody, aResultIndex++);
}
// Getting objects.
GeomAPI_ShapeHierarchy anObjects;
std::list<ResultPtr> aParts;
- std::string theTextureFile;
+ ResultPtr aTextureSource;
AttributeSelectionListPtr anObjSelList = selectionList(OBJECTS_LIST_ID());
if (!FeaturesPlugin_Tools::shapesFromSelectionList(
- anObjSelList, isKeepSubShapes, anObjects, aParts, theTextureFile))
+ anObjSelList, isKeepSubShapes, anObjects, aParts, aTextureSource))
return;
// Getting the center point
anObjects.topLevelObjects(aTopLevel);
for (ListOfShape::iterator anIt = aTopLevel.begin(); anIt != aTopLevel.end(); ++anIt) {
ResultBodyPtr aResultBody = document()->createBody(data(), aResultIndex);
- FeaturesPlugin_Tools::loadModifiedShapes(aResultBody, anOriginalShapes, ListOfShape(),
- aMakeShapeList, *anIt, "Scaled");
- aResultBody->setTextureFile(theTextureFile);
+ ModelAPI_Tools::loadModifiedShapes(aResultBody, anOriginalShapes, ListOfShape(),
+ aMakeShapeList, *anIt, "Scaled");
+ // Copy image data, if any
+ ModelAPI_Tools::copyImageAttribute(aTextureSource, aResultBody);
setResult(aResultBody, aResultIndex++);
}
#include <ModelAPI_AttributeString.h>
#include <ModelAPI_ResultBody.h>
#include <ModelAPI_ResultPart.h>
+#include <ModelAPI_Tools.h>
#include <FeaturesPlugin_Tools.h>
const std::shared_ptr<GeomAlgoAPI_MakeShapeList>& theAlgo,
const std::list<std::shared_ptr<GeomAPI_Shape> >& theOriginalShapes,
std::shared_ptr<GeomAPI_Shape> theTargetShape, int& theResultIndex,
- std::string & theTextureFile)
+ const ResultPtr& theTextureSource)
{
// Store and name the result.
ResultBodyPtr aResultBody = document()->createBody(data(), theResultIndex);
- FeaturesPlugin_Tools::loadModifiedShapes(aResultBody, theOriginalShapes, ListOfShape(),
- theAlgo, theTargetShape, "Symmetried");
- aResultBody->setTextureFile(theTextureFile);
+ ModelAPI_Tools::loadModifiedShapes(aResultBody, theOriginalShapes, ListOfShape(),
+ theAlgo, theTargetShape, "Symmetried");
+ // Copy image data, if any
+ ModelAPI_Tools::copyImageAttribute(theTextureSource, aResultBody);
setResult(aResultBody, theResultIndex++);
}
// Getting objects.
GeomAPI_ShapeHierarchy anObjects;
std::list<ResultPtr> aParts;
- std::string theTextureFile;
+ ResultPtr aTextureSource;
AttributeSelectionListPtr anObjSelList = selectionList(OBJECTS_LIST_ID());
if (!FeaturesPlugin_Tools::shapesFromSelectionList(
- anObjSelList, isKeepSubShapes, anObjects, aParts, theTextureFile))
+ anObjSelList, isKeepSubShapes, anObjects, aParts, aTextureSource))
return;
std::string anError;
ListOfShape aTopLevel;
anObjects.topLevelObjects(aTopLevel);
for (ListOfShape::iterator anIt = aTopLevel.begin(); anIt != aTopLevel.end(); ++anIt)
- buildResult(aMakeShapeList, anOriginalShapes, *anIt, aResultIndex, theTextureFile);
+ buildResult(aMakeShapeList, anOriginalShapes, *anIt, aResultIndex, aTextureSource);
// Remove the rest results if there were produced in the previous pass.
removeResults(aResultIndex);
#include <FeaturesPlugin.h>
#include <ModelAPI_Feature.h>
+#include <ModelAPI_Result.h>
class GeomAPI_Trsf;
class GeomAlgoAPI_MakeShapeList;
void buildResult(const std::shared_ptr<GeomAlgoAPI_MakeShapeList>& theAlgo,
const std::list<std::shared_ptr<GeomAPI_Shape> >& theOriginalShapes,
std::shared_ptr<GeomAPI_Shape> theTargetShape,
- int& theResultIndex, std::string &theTextureFile);
+ int& theResultIndex,
+ const ResultPtr& theTextureSource);
/// Create new result for the given part and transformation
void buildResult(std::shared_ptr<ModelAPI_ResultPart> theOriginal,
#include <GeomValidators_ShapeType.h>
-//==================================================================================================
-void FeaturesPlugin_Tools::loadModifiedShapes(ResultBodyPtr theResultBody,
- const ListOfShape& theBaseShapes,
- const ListOfShape& theTools,
- const GeomMakeShapePtr& theMakeShape,
- const GeomShapePtr theResultShape,
- const std::string& theNamePrefix)
-{
- theResultBody->storeModified(theBaseShapes, theResultShape, theMakeShape);
-
- ListOfShape aShapes = theBaseShapes;
- ListOfShape::const_iterator aToolIter = theTools.cbegin();
- for(; aToolIter != theTools.cend(); aToolIter++)
- aShapes.push_back(*aToolIter);
-
- for (ListOfShape::const_iterator anIter = aShapes.begin(); anIter != aShapes.end(); ++anIter)
- {
- theResultBody->loadModifiedShapes(theMakeShape, *anIter, GeomAPI_Shape::VERTEX, theNamePrefix);
- theResultBody->loadModifiedShapes(theMakeShape, *anIter, GeomAPI_Shape::EDGE, theNamePrefix);
- theResultBody->loadModifiedShapes(theMakeShape, *anIter, GeomAPI_Shape::FACE, theNamePrefix);
- }
-}
-
-//==================================================================================================
-void FeaturesPlugin_Tools::loadModifiedShapes(ResultBodyPtr theResultBody,
- const GeomShapePtr& theBaseShape,
- const GeomMakeShapePtr& theMakeShape,
- const std::string theName)
-{
- switch(theBaseShape->shapeType()) {
- case GeomAPI_Shape::COMPOUND: {
- for(GeomAPI_ShapeIterator anIt(theBaseShape); anIt.more(); anIt.next())
- {
- loadModifiedShapes(theResultBody,
- anIt.current(),
- theMakeShape,
- theName);
- }
- break;
- }
- case GeomAPI_Shape::COMPSOLID:
- case GeomAPI_Shape::SOLID:
- case GeomAPI_Shape::SHELL: {
- theResultBody->loadModifiedShapes(theMakeShape,
- theBaseShape,
- GeomAPI_Shape::FACE,
- theName);
- }
- case GeomAPI_Shape::FACE:
- case GeomAPI_Shape::WIRE: {
- theResultBody->loadModifiedShapes(theMakeShape,
- theBaseShape,
- GeomAPI_Shape::EDGE,
- theName);
- }
- case GeomAPI_Shape::EDGE: {
- theResultBody->loadModifiedShapes(theMakeShape,
- theBaseShape,
- GeomAPI_Shape::VERTEX,
- theName);
- }
- default: // [to avoid compilation warning]
- break;
- }
-}
-
-//==================================================================================================
-void FeaturesPlugin_Tools::loadDeletedShapes(ResultBodyPtr theResultBody,
- const GeomShapePtr theBaseShape,
- const ListOfShape& theTools,
- const GeomMakeShapePtr& theMakeShape,
- const GeomShapePtr theResultShapesCompound)
-{
- ListOfShape aShapes = theTools;
- if (theBaseShape.get())
- aShapes.push_front(theBaseShape);
-
- for (ListOfShape::const_iterator anIter = aShapes.begin(); anIter != aShapes.end(); anIter++)
- {
- theResultBody->loadDeletedShapes(theMakeShape,
- *anIter,
- GeomAPI_Shape::VERTEX,
- theResultShapesCompound);
- theResultBody->loadDeletedShapes(theMakeShape,
- *anIter,
- GeomAPI_Shape::EDGE,
- theResultShapesCompound);
- theResultBody->loadDeletedShapes(theMakeShape,
- *anIter,
- GeomAPI_Shape::FACE,
- theResultShapesCompound);
- // store information about deleted solids because of unittest TestBooleanCommon_SolidsHistory
- // on OCCT 7.4.0 : common produces modified compsolid, so, move to the end for removed solids
- // starts to produce whole compsolid
- theResultBody->loadDeletedShapes(theMakeShape,
- *anIter,
- GeomAPI_Shape::SOLID,
- theResultShapesCompound);
- }
-}
-
-//==================================================================================================
-void FeaturesPlugin_Tools::loadDeletedShapes(
- std::vector<ResultBaseAlgo>& theResultBaseAlgoList,
- const ListOfShape& theTools,
- const GeomShapePtr theResultShapesCompound)
-{
- for (std::vector<ResultBaseAlgo>::iterator anIt = theResultBaseAlgoList.begin();
- anIt != theResultBaseAlgoList.end();
- ++anIt)
- {
- ResultBaseAlgo& aRCA = *anIt;
- loadDeletedShapes(aRCA.resultBody,
- aRCA.baseShape,
- theTools,
- aRCA.makeShape,
- theResultShapesCompound);
- }
-}
-
//==================================================================================================
bool FeaturesPlugin_Tools::getShape(const AttributeSelectionListPtr theSelectionList,
const bool theShareTopology,
const std::shared_ptr<ModelAPI_AttributeSelectionList> theSelectionList,
const bool theStoreFullHierarchy,
GeomAPI_ShapeHierarchy& theHierarchy,
- std::list<ResultPtr>& theParts, std::string &theTextureFile)
+ std::list<ResultPtr>& theParts, ResultPtr& theTextureSource)
{
int aSize = theSelectionList->size();
- if(aSize == 1)
- {
+ if (aSize == 1) {
auto anObjectAttr = theSelectionList->value(0);
- if(anObjectAttr.get())
- {
+ if (anObjectAttr.get()) {
FeaturePtr aFeature = anObjectAttr->contextFeature();
- if(aFeature.get() && aFeature->results().size() == 1)
- {
- theTextureFile = aFeature->firstResult()->getTextureFile();
+ if (aFeature.get() && aFeature->results().size() == 1) {
+ theTextureSource = aFeature->firstResult();
}
- else
- {
- if(!aFeature.get())
- {
- auto aResult = anObjectAttr->context();
- if(aResult.get())
- {
- theTextureFile = aResult->getTextureFile();
+ else {
+ if (!aFeature.get()) {
+ auto aResult = anObjectAttr->context();
+ if (aResult.get()) {
+ theTextureSource = aResult;
}
}
}
class FeaturesPlugin_Tools {
public:
- struct ResultBaseAlgo {
- ResultBodyPtr resultBody;
- GeomShapePtr baseShape;
- GeomMakeShapePtr makeShape;
- };
-
-public:
- static void loadModifiedShapes(ResultBodyPtr theResultBody,
- const ListOfShape& theBaseShapes,
- const ListOfShape& theTools,
- const GeomMakeShapePtr& theMakeShape,
- const GeomShapePtr theResultShape,
- const std::string& theNamePrefix = "");
-
- static void loadModifiedShapes(ResultBodyPtr theResultBody,
- const GeomShapePtr& theBaseShape,
- const GeomMakeShapePtr& theMakeShape,
- const std::string theName);
- /// Stores deleted shapes.
- static void loadDeletedShapes(ResultBodyPtr theResultBody,
- const GeomShapePtr theBaseShape,
- const ListOfShape& theTools,
- const GeomMakeShapePtr& theMakeShape,
- const GeomShapePtr theResultShapesCompound);
-
- /// Stores deleted shapes.
- static void loadDeletedShapes(std::vector<ResultBaseAlgo>& theResultBaseAlgoList,
- const ListOfShape& theTools,
- const GeomShapePtr theResultShapesCompound);
-
/// Obtain shapes from the selection list attribute.
static bool getShape(const std::shared_ptr<ModelAPI_AttributeSelectionList> theSelectionList,
const bool theShareTopology,
const std::shared_ptr<ModelAPI_AttributeSelectionList> theSelectionList,
const bool theStoreFullHierarchy,
GeomAPI_ShapeHierarchy& theHierarchy,
- std::list<ResultPtr>& theParts, std::string& theTextureFile);
+ std::list<ResultPtr>& theParts,
+ ResultPtr& theTextureSource);
};
#endif /* FeaturesPlugin_Tools_H_ */
#include <ModelAPI_ResultBody.h>
#include <ModelAPI_ResultPart.h>
#include <ModelAPI_Session.h>
+#include <ModelAPI_Tools.h>
#include <GeomAPI_Ax1.h>
#include <GeomAPI_Edge.h>
// Getting objects.
GeomAPI_ShapeHierarchy anObjects;
std::list<ResultPtr> aParts;
- std::string theTextureFile;
+ ResultPtr aTextureSource;
AttributeSelectionListPtr anObjectsSelList = selectionList(OBJECTS_LIST_ID());
- if (!FeaturesPlugin_Tools::shapesFromSelectionList(
- anObjectsSelList, isKeepSubShapes, anObjects, aParts, theTextureFile))
+ if (!FeaturesPlugin_Tools::shapesFromSelectionList
+ (anObjectsSelList, isKeepSubShapes, anObjects, aParts, aTextureSource))
return;
std::string anError;
for (ListOfShape::iterator anIt = aTopLevel.begin(); anIt != aTopLevel.end(); ++anIt) {
//LoadNamingDS
ResultBodyPtr aResultBody = document()->createBody(data(), aResultIndex);
- FeaturesPlugin_Tools::loadModifiedShapes(aResultBody, anOriginalShapes, ListOfShape(),
- aMakeShapeList, *anIt, "Translated");
- aResultBody->setTextureFile(theTextureFile);
+ ModelAPI_Tools::loadModifiedShapes(aResultBody, anOriginalShapes, ListOfShape(),
+ aMakeShapeList, *anIt, "Translated");
+ // Copy image data, if any
+ ModelAPI_Tools::copyImageAttribute(aTextureSource, aResultBody);
setResult(aResultBody, aResultIndex++);
}
std::string anError;
int aResultIndex = 0;
- std::vector<FeaturesPlugin_Tools::ResultBaseAlgo> aResultBaseAlgoList;
+ std::vector<ModelAPI_Tools::ResultBaseAlgo> aResultBaseAlgoList;
ListOfShape aResultShapesList;
GeomShapePtr aResultCompound = GeomAlgoAPI_CompoundBuilder::compound(ListOfShape());
}
std::shared_ptr<GeomAlgoAPI_MakeShapeList> aMakeShapeList(new GeomAlgoAPI_MakeShapeList());
- for (std::vector<FeaturesPlugin_Tools::ResultBaseAlgo>::iterator
+ for (std::vector<ModelAPI_Tools::ResultBaseAlgo>::iterator
aRBAIt = aResultBaseAlgoList.begin();
aRBAIt != aResultBaseAlgoList.end(); ++aRBAIt) {
aMakeShapeList->appendAlgo(aRBAIt->makeShape);
const ListOfShape& theTools,
const ListOfShape& thePlanes,
int& theResultIndex,
- std::vector<FeaturesPlugin_Tools::ResultBaseAlgo>& theResultBaseAlgoList,
+ std::vector<ModelAPI_Tools::ResultBaseAlgo>& theResultBaseAlgoList,
ListOfShape& theResultShapesList,
GeomShapePtr theResultCompound)
{
ListOfShape aUsedTools = theTools;
aUsedTools.insert(aUsedTools.end(), thePlanes.begin(), thePlanes.end());
- FeaturesPlugin_Tools::loadModifiedShapes(aResultBody,
+ ModelAPI_Tools::loadModifiedShapes(aResultBody,
aListWithObject,
aUsedTools,
aMakeShapeList,
}
- FeaturesPlugin_Tools::ResultBaseAlgo aRBA;
+ ModelAPI_Tools::ResultBaseAlgo aRBA;
aRBA.resultBody = aResultBody;
aRBA.baseShape = theObject;
aRBA.makeShape = aMakeShapeList;
const ListOfShape& theTools,
const ListOfShape& thePlanes,
int& theResultIndex,
- std::vector<FeaturesPlugin_Tools::ResultBaseAlgo>& theResultBaseAlgoList,
+ std::vector<ModelAPI_Tools::ResultBaseAlgo>& theResultBaseAlgoList,
ListOfShape& theResultShapesList,
GeomShapePtr theResultCompound)
{
ListOfShape aUsedTools = theTools;
aUsedTools.insert(aUsedTools.end(), thePlanes.begin(), thePlanes.end());
- FeaturesPlugin_Tools::loadModifiedShapes(aResultBody,
+ ModelAPI_Tools::loadModifiedShapes(aResultBody,
aCompSolidList,
aUsedTools,
aMakeShapeList,
++theResultIndex;
}
- FeaturesPlugin_Tools::ResultBaseAlgo aRBA;
+ ModelAPI_Tools::ResultBaseAlgo aRBA;
aRBA.resultBody = aResultBody;
aRBA.baseShape = theCompsolid;
aRBA.makeShape = aMakeShapeList;
const GeomShapePtr& theCompound,
const ListOfShape& theTools,
int& theResultIndex,
- std::vector<FeaturesPlugin_Tools::ResultBaseAlgo>& theResultBaseAlgoList,
+ std::vector<ModelAPI_Tools::ResultBaseAlgo>& theResultBaseAlgoList,
ListOfShape& theResultShapesList,
GeomShapePtr theResultCompound)
{
ListOfShape aCompoundList;
aCompoundList.push_back(theCompound);
- FeaturesPlugin_Tools::loadModifiedShapes(aResultBody,
+ ModelAPI_Tools::loadModifiedShapes(aResultBody,
aCompoundList,
theTools,
aMakeShapeList,
++theResultIndex;
}
- FeaturesPlugin_Tools::ResultBaseAlgo aRBA;
+ ModelAPI_Tools::ResultBaseAlgo aRBA;
aRBA.resultBody = aResultBody;
aRBA.baseShape = theCompound;
aRBA.makeShape = aMakeShapeList;
#include <GeomAlgoAPI_Tools.h>
#include <ModelAPI_Feature.h>
+#include <ModelAPI_Tools.h>
class ModelAPI_Attribute;
class ModelAPI_Result;
const ListOfShape& theTools,
const ListOfShape& thePlanes,
int& theResultIndex,
- std::vector<FeaturesPlugin_Tools::ResultBaseAlgo>& theResultBaseAlgoList,
+ std::vector<ModelAPI_Tools::ResultBaseAlgo>& theResultBaseAlgoList,
ListOfShape& theResultShapesList,
GeomShapePtr theResulCompound = GeomShapePtr());
const ListOfShape& theTools,
const ListOfShape& thePlanes,
int& theResultIndex,
- std::vector<FeaturesPlugin_Tools::ResultBaseAlgo>& theResultBaseAlgoList,
+ std::vector<ModelAPI_Tools::ResultBaseAlgo>& theResultBaseAlgoList,
ListOfShape& theResultShapesList,
GeomShapePtr theResulCompound = GeomShapePtr());
const GeomShapePtr& theCompound,
const ListOfShape& theTools,
int& theResultIndex,
- std::vector<FeaturesPlugin_Tools::ResultBaseAlgo>& theResultBaseAlgoList,
+ std::vector<ModelAPI_Tools::ResultBaseAlgo>& theResultBaseAlgoList,
ListOfShape& theResultShapesList,
GeomShapePtr theResulCompound = GeomShapePtr());
//
#include "FeaturesPlugin_VersionedChFi.h"
-#include "FeaturesPlugin_Tools.h"
#include <ModelAPI_AttributeSelectionList.h>
#include <ModelAPI_Tools.h>
anObjectHierarchy.topLevelObjects(aTopLevel);
for (ListOfShape::iterator anIt = aTopLevel.begin(); anIt != aTopLevel.end(); ++anIt) {
ResultBodyPtr aResultBody = document()->createBody(data(), aResultIndex);
- FeaturesPlugin_Tools::loadModifiedShapes(aResultBody, anOriginalSolids, ListOfShape(),
- aMakeShapeList, *anIt, aPrefix);
+ ModelAPI_Tools::loadModifiedShapes(aResultBody, anOriginalSolids, ListOfShape(),
+ aMakeShapeList, *anIt, aPrefix);
setResult(aResultBody, aResultIndex++);
for (ListOfShape::iterator aEIt = anEdges.begin(); aEIt != anEdges.end(); ++aEIt) {
aResultBody->loadGeneratedShapes(aMakeShapeList, aBase, GeomAPI_Shape::EDGE, aPrefix, true);
}
- FeaturesPlugin_Tools::loadDeletedShapes(aResultBody, GeomShapePtr(), anOriginalSolids,
- aMakeShapeList, *anIt);
+ ModelAPI_Tools::loadDeletedShapes(aResultBody, GeomShapePtr(), anOriginalSolids,
+ aMakeShapeList, *anIt);
}
removeResults(aResultIndex);
from salome.shaper import model
import os
+### Create a Box
model.begin()
Box_1 = model.addBox(Part_1_doc, 10, 10, 10)
model.do()
-
-### Create BoundingBox
+
+### Create a top face of the box normal
Normal_1 = model.getNormal(Part_1_doc, model.selection("FACE", "Box_1_1/Top"))
model.do()
${OpenCASCADE_DataExchange_LIBRARIES}
${OpenCASCADE_ModelingAlgorithms_LIBRARIES}
${OpenCASCADE_ApplicationFramework_LIBRARIES}
- ${QT_LIBRARIES}
)
ADD_DEFINITIONS(-DGEOMALGOAPI_EXPORTS ${OpenCASCADE_DEFINITIONS})
SET_SOURCE_FILES_PROPERTIES(GeomAlgoAPI.i PROPERTIES CPLUSPLUS ON)
SET_SOURCE_FILES_PROPERTIES(GeomAlgoAPI.i PROPERTIES SWIG_DEFINITIONS "-shadow")
-INCLUDE(UseQtExt)
# additional include directories
-INCLUDE_DIRECTORIES(${QT_INCLUDES})
-
INCLUDE_DIRECTORIES(
../GeomAPI
../GeomAlgoImpl
#include <GeomAlgoAPI_ImageImport.h>
-#include <QPixmap>
#include <BRep_Builder.hxx>
#include <BRepBuilderAPI_MakeFace.hxx>
#include <BRepBuilderAPI_MakePolygon.hxx>
#include <TopoDS_Vertex.hxx>
#include <TopoDS_Wire.hxx>
-std::shared_ptr<GeomAPI_Shape> ImageImport(const std::string& theFileName,
- std::string& theError)
+std::shared_ptr<GeomAPI_Shape> ImageImport(const int width,
+ const int height,
+ std::string& theError)
{
TopoDS_Shape aResShape;
try
{
- QPixmap* pixmap = new QPixmap(theFileName.c_str());
- int height = pixmap->height();
- int width = pixmap->width();
-
- delete pixmap;
-
TopoDS_Vertex aTriVertexes[4];
gp_Pnt aPnt1( -0.5*width, -0.5*height, 0);
gp_Pnt aPnt2( 0.5*width, -0.5*height, 0);
#include <GeomAPI_Shape.h>
#include <string>
-#include <QPixmap>
+
/// Implementation of the import STL files algorithms
GEOMALGOAPI_EXPORT
-std::shared_ptr<GeomAPI_Shape> ImageImport(const std::string& theFileName,
- std::string& theError);
+std::shared_ptr<GeomAPI_Shape> ImageImport(const int theWidth,
+ const int theHeight,
+ std::string& theError);
#endif /* GEOMALGOAPI_IMAGEIMPORT_H_ */
protected:
/// \brief Sets builder type.
/// \param[in] theBuilderType new builder type.
- void setBuilderType(const BuilderType theBuilderType);
+ GEOMALGOAPI_EXPORT void setBuilderType(const BuilderType theBuilderType);
/// \brief Sets status of builder.
/// \param[in] theFlag new status.
- void setDone(const bool theFlag);
+ GEOMALGOAPI_EXPORT void setDone(const bool theFlag);
/// \brief Sets result shape.
/// \param[in] theShape new shape.
- void setShape(const GeomShapePtr theShape);
+ GEOMALGOAPI_EXPORT void setShape(const GeomShapePtr theShape);
/// \return true if passed shape is valid for history.
bool isValidForHistory(const GeomShapePtr theShape);
return aPath.Name().ToCString();
}
+std::string File_Tools::path(const std::string& theFileName)
+{
+ OSD_Path aPath (theFileName.c_str());
+ Standard_Integer aTrekLen =
+ theFileName.size() - aPath.Extension().Length() - aPath.Name().Length();
+ return theFileName.substr(0, aTrekLen);
+}
+
bool AlgoError::isAlgorithmFailed(const GeomMakeShapePtr& theAlgorithm,
const std::string& theFeature,
std::string& theError)
* Returns a name of theFileName
*/
GEOMALGOAPI_EXPORT static std::string name(const std::string& theFileName);
+ /**
+ * Returns a directory path of theFileName
+ */
+ GEOMALGOAPI_EXPORT static std::string path(const std::string& theFileName);
};
/** \class AlgoError
Model_AttributeRefList.h
Model_AttributeRefAttrList.h
Model_AttributeBoolean.h
+ Model_AttributeImage.h
Model_AttributeIntArray.h
Model_AttributeString.h
Model_AttributeStringArray.h
Model_AttributeRefList.cpp
Model_AttributeRefAttrList.cpp
Model_AttributeBoolean.cpp
+ Model_AttributeImage.cpp
Model_AttributeIntArray.cpp
Model_AttributeString.cpp
Model_AttributeStringArray.cpp
--- /dev/null
+// Copyright (C) 2014-2021 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 <Model_AttributeImage.h>
+#include <ModelAPI_AttributeString.h>
+#include <ModelAPI_Attribute.h>
+#include <ModelAPI_Data.h>
+#include <ModelAPI_Object.h>
+
+#include <Standard_TypeDef.hxx>
+#include <TCollection_AsciiString.hxx>
+#include <TCollection_ExtendedString.hxx>
+
+#include <TDataStd_IntegerArray.hxx>
+#include <TDataStd_ByteArray.hxx>
+#include <TDataStd_Comment.hxx>
+#include <TDF_CopyLabel.hxx>
+
+void Model_AttributeImage::setTexture(const int theWidth,
+ const int theHeight,
+ const std::list<unsigned char>& theByteArray,
+ const std::string& theFormat,
+ const bool sendUpdated)
+{
+ if (theWidth > 0 && theHeight > 0 && theByteArray.size() > 0) { // set new data
+ // Find or create attributes
+ Handle_TDataStd_ByteArray aByteArray =
+ TDataStd_ByteArray::Set(myLab, 0, theByteArray.size() - 1);
+ Handle_TDataStd_IntegerArray aDimensions =
+ TDataStd_IntegerArray::Set(myLab, 0, 1);
+ Handle_TDataStd_Comment aFormat = TDataStd_Comment::Set(myLab, theFormat.c_str());
+
+ // Dimensions
+ aDimensions->SetValue(0, theWidth);
+ aDimensions->SetValue(1, theHeight);
+
+ // Texture
+ Handle(TColStd_HArray1OfByte) aNewArray =
+ new TColStd_HArray1OfByte(0, theByteArray.size() - 1);
+ std::list<unsigned char>::const_iterator itBA = theByteArray.begin();
+ for (int j = 0; itBA != theByteArray.end(); ++itBA, ++j) {
+ aNewArray->SetValue(j, (Standard_Byte)(*itBA));
+ }
+ aByteArray->ChangeArray(aNewArray);
+
+ if (sendUpdated)
+ owner()->data()->sendAttributeUpdated(this);
+ }
+ else { // size is zero => arrays must be erased
+ bool isForgotten1 = myLab.ForgetAttribute(TDataStd_ByteArray::GetID());
+ bool isForgotten2 = myLab.ForgetAttribute(TDataStd_IntegerArray::GetID());
+ bool isForgotten3 = myLab.ForgetAttribute(TDataStd_Comment::GetID());
+
+ if (sendUpdated && (isForgotten1 || isForgotten2 || isForgotten3))
+ owner()->data()->sendAttributeUpdated(this);
+ }
+}
+
+bool Model_AttributeImage::hasTexture()
+{
+ Handle_TDataStd_ByteArray aByteArray;
+ Handle_TDataStd_IntegerArray aDimensions;
+ if (myLab.FindAttribute(TDataStd_ByteArray::GetID(), aByteArray) == Standard_True &&
+ myLab.FindAttribute(TDataStd_IntegerArray::GetID(), aDimensions) == Standard_True) {
+
+ // Dimensions
+ if (aDimensions->Value(0) > 0 && aDimensions->Value(1) > 0)
+ // Byte array
+ return aByteArray->Length() > 0;
+ }
+ return false;
+}
+
+bool Model_AttributeImage::texture(int& theWidth,
+ int& theHeight,
+ std::list<unsigned char>& theByteArray,
+ std::string& theFormat)
+{
+ // Init return values
+ theWidth = 0;
+ theHeight = 0;
+ theByteArray.clear();
+ theFormat = "";
+
+ Handle_TDataStd_ByteArray aByteArray;
+ Handle_TDataStd_IntegerArray aDimensions;
+ Handle_TDataStd_Comment aFormat;
+ if (myLab.FindAttribute(TDataStd_ByteArray::GetID(), aByteArray) == Standard_True &&
+ myLab.FindAttribute(TDataStd_IntegerArray::GetID(), aDimensions) == Standard_True &&
+ myLab.FindAttribute(TDataStd_Comment::GetID(), aFormat) == Standard_True) {
+
+ // Dimensions
+ theWidth = aDimensions->Value(0);
+ theHeight = aDimensions->Value(1);
+
+ // Texture
+ const Handle(TColStd_HArray1OfByte) byteArray = aByteArray->InternalArray();
+ for (int j = byteArray->Lower(); j <= byteArray->Upper(); j++) {
+ theByteArray.push_back((unsigned char)byteArray->Value( j ));
+ }
+
+ // Format
+ theFormat = TCollection_AsciiString(aFormat->Get()).ToCString();
+ return true;
+ }
+
+ return false;
+}
+
+void Model_AttributeImage::copyTo(AttributeImagePtr theTarget) const
+{
+ std::shared_ptr<Model_AttributeImage> aTarget =
+ std::dynamic_pointer_cast<Model_AttributeImage>(theTarget);
+ if (aTarget) {
+ //Model_AttributeSelectionList::copyAttrs(myLab, aTarget->myLab);
+ TDF_CopyLabel aCopyAlgo (myLab, aTarget->myLab);
+ aCopyAlgo.Perform();
+ aTarget->reinit();
+ }
+}
+
+Model_AttributeImage::Model_AttributeImage(TDF_Label& theLabel)
+{
+ myLab = theLabel;
+ reinit();
+}
+
+void Model_AttributeImage::reinit()
+{
+ myIsInitialized = myLab.IsAttribute(TDataStd_ByteArray::GetID());
+}
--- /dev/null
+// Copyright (C) 2014-2021 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
+//
+
+#ifndef MODEL_ATTRIBUTEIMAGE_H_
+#define MODEL_ATTRIBUTEIMAGE_H_
+
+#include <Model.h>
+#include <ModelAPI_AttributeImage.h>
+
+#include <TDF_Label.hxx>
+
+#include <string>
+
+/**\class Model_AttributeImage
+ * \ingroup DataModel
+ * \brief API for the attribute that contains image inside.
+ * Represented as the following OCCT attributes:
+ * TDataStd_ByteArray for the pixmap texture data,
+ * TDataStd_IntArray(2) for image dimensions (widht and height),
+ * TDataStd_String for image format.
+ */
+
+class Model_AttributeImage : public ModelAPI_AttributeImage
+{
+ /// Stores the label as the only reference to all data
+ TDF_Label myLab;
+
+ public:
+ /// Defines the value of the image attribute
+ MODEL_EXPORT virtual void setTexture(const int theWidth,
+ const int theHeight,
+ const std::list<unsigned char>& theByteArray,
+ const std::string& theFormat,
+ const bool sendUpdated = true);
+
+ /// Returns true, if texture width and height are non-zero
+ MODEL_EXPORT virtual bool hasTexture();
+
+ /// Returns the value of the image attribute
+ MODEL_EXPORT virtual bool texture(int& theWidth,
+ int& theHeight,
+ std::list<unsigned char>& theByteArray,
+ std::string& theFormat);
+
+ /// Copy the image data to the destination attribute
+ virtual void copyTo(std::shared_ptr<ModelAPI_AttributeImage> theTarget) const;
+
+ protected:
+ /// Initializes attibutes
+ Model_AttributeImage(TDF_Label& theLabel);
+ /// Reinitializes the internal state of the attribute (may be needed on undo/redo, abort, etc)
+ virtual void reinit();
+
+ friend class Model_Data;
+};
+
+#endif
#include <Model_AttributeSelection.h>
#include <Model_AttributeSelectionList.h>
#include <Model_AttributeIntArray.h>
+#include <Model_AttributeImage.h>
#include <Model_AttributeTables.h>
#include <Model_Events.h>
#include <Model_Expression.h>
anAttr = new Model_AttributeDoubleArray(anAttrLab);
} else if (theAttrType == ModelAPI_AttributeTables::typeId()) {
anAttr = new Model_AttributeTables(anAttrLab);
+ } else if (theAttrType == ModelAPI_AttributeImage::typeId()) {
+ anAttr = new Model_AttributeImage(anAttrLab);
}
// create also GeomData attributes here because only here the OCAF structure is known
else if (theAttrType == GeomData_Point::typeId()) {
GET_ATTRIBUTE_BY_ID(ModelAPI_AttributeIntArray, intArray);
GET_ATTRIBUTE_BY_ID(ModelAPI_AttributeDoubleArray, realArray);
GET_ATTRIBUTE_BY_ID(ModelAPI_AttributeTables, tables);
+GET_ATTRIBUTE_BY_ID(ModelAPI_AttributeImage, image);
std::shared_ptr<ModelAPI_Attribute> Model_Data::attribute(const std::string& theID)
{
#include <ModelAPI_AttributeString.h>
#include <ModelAPI_AttributeStringArray.h>
#include <ModelAPI_AttributeIntArray.h>
+#include <ModelAPI_AttributeImage.h>
#include <ModelAPI_Data.h>
#include <ModelAPI_Feature.h>
#include <ModelAPI_Folder.h>
/// Returns the attribute that contains string values array
MODEL_EXPORT virtual std::shared_ptr<ModelAPI_AttributeTables>
tables(const std::string& theID);
+ /// Returns the attribute that contains image
+ MODEL_EXPORT virtual std::shared_ptr<ModelAPI_AttributeImage>
+ image(const std::string& theID);
/// Returns the generic attribute by identifier
/// \param theID identifier of the attribute
#include <ModelAPI_Object.h>
#include <ModelAPI_Events.h>
#include <ModelAPI_Tools.h>
+#include <ModelAPI_AttributeImage.h>
#include <Model_Data.h>
#include <Events_Loop.h>
#include <GeomAPI_ShapeIterator.h>
delete myBuilder;
}
+void Model_ResultBody::initAttributes()
+{
+ ModelAPI_Result::initAttributes();
+ // append the image attribute. It is empty, the attribute will be filled by a request
+ data()->addAttribute(IMAGE_ID(), ModelAPI_AttributeImage::typeId())->setIsArgument(false);
+}
+
bool Model_ResultBody::generated(const GeomShapePtr& theNewShape,
const std::string& theName, const bool theCheckIsInResult)
{
myHistoryCash.Clear();
}
-void Model_ResultBody::setTextureFile(const std::string & theTextureFile)
-{
- ModelAPI_Result::setTextureFile(theTextureFile);
- for( auto sub : mySubs){
- sub->setTextureFile(theTextureFile);
- }
- for(auto map : mySubsMap){
- map.first->setTextureFile(theTextureFile);
- }
-}
-
bool Model_ResultBody::isConnectedTopology()
{
TDF_Label aDataLab = std::dynamic_pointer_cast<Model_Data>(data())->label();
}
}
+bool Model_ResultBody::hasTexture()
+{
+ AttributeImagePtr anImageAttr =
+ data()->image(ModelAPI_ResultBody::IMAGE_ID());
+ if (anImageAttr.get()) {
+ return anImageAttr->hasTexture();
+ }
+ return false;
+}
+
// adds to the theSubSubs map all sub-shapes of theSub if it is compound of compsolid
static void collectSubs(
const GeomShapePtr theSub, TopTools_MapOfShape& theSubSubs, const bool theOneLevelMore)
/// Removes the stored builders
MODEL_EXPORT virtual ~Model_ResultBody();
+ /// Request for initialization of data model of the result body: adding all attributes
+ virtual void initAttributes();
+
/// Records the subshape newShape which was generated during a topological construction.
/// As an example, consider the case of a face generated in construction of a box.
MODEL_EXPORT virtual bool generated(const GeomShapePtr& theNewShape,
MODEL_EXPORT virtual void cleanCash() override;
/// sets the texture file
- MODEL_EXPORT virtual void setTextureFile(const std::string & theTextureFile) override;
+ MODEL_EXPORT virtual bool hasTexture() override;
protected:
return ROOT_DOC->redoList();
}
+bool Model_Session::checkLicense(const std::string& thePluginName)
+{
+ return getPlugin(thePluginName);
+}
+
ModelAPI_Plugin* Model_Session::getPlugin(const std::string& thePluginName)
{
if (myPluginObjs.find(thePluginName) == myPluginObjs.end()) {
/// the plugin manager on call of the feature)
MODEL_EXPORT virtual void registerPlugin(ModelAPI_Plugin* thePlugin);
+ /// Verifies the license for the plugin is valid
+ MODEL_EXPORT virtual bool checkLicense(const std::string& thePluginName);
+
/// Processes the configuration file reading
MODEL_EXPORT virtual void processEvent(const std::shared_ptr<Events_Message>& theMessage);
ModelAPI.h
ModelAPI_Attribute.h
ModelAPI_AttributeBoolean.h
+ ModelAPI_AttributeImage.h
ModelAPI_AttributeIntArray.h
ModelAPI_AttributeDocRef.h
ModelAPI_AttributeDouble.h
SET(PROJECT_SOURCES
ModelAPI_Attribute.cpp
ModelAPI_AttributeBoolean.cpp
+ ModelAPI_AttributeImage.cpp
ModelAPI_AttributeIntArray.cpp
ModelAPI_AttributeDocRef.cpp
ModelAPI_AttributeDouble.cpp
--- /dev/null
+// Copyright (C) 2014-2021 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 <ModelAPI_AttributeImage.h>
+
+
+std::string ModelAPI_AttributeImage::attributeType()
+{
+ return typeId();
+}
+
+/// To virtually destroy the fields of successors
+ModelAPI_AttributeImage::~ModelAPI_AttributeImage()
+{
+}
+
+ModelAPI_AttributeImage::ModelAPI_AttributeImage()
+{
+}
--- /dev/null
+// Copyright (C) 2014-2021 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
+//
+
+#ifndef ModelAPI_AttributeImage_H_
+#define ModelAPI_AttributeImage_H_
+
+#include <ModelAPI.h>
+#include <ModelAPI_Attribute.h>
+
+#include <string>
+#include <list>
+
+
+/**\class ModelAPI_AttributeImage
+ * \ingroup DataModel
+ * \brief API for the attribute that contains binary data.
+ * Used for images storage for an example. By default size is one, zero-based.
+ */
+
+class ModelAPI_AttributeImage : public ModelAPI_Attribute
+{
+ public:
+ /// Defines the value of the image attribute
+ MODELAPI_EXPORT virtual void setTexture(const int theWidth,
+ const int theHeight,
+ const std::list<unsigned char>& theByteArray,
+ const std::string& theFormat,
+ const bool sendUpdated = true) = 0;
+
+ /// Returns true, if texture width and height are non-zero
+ MODELAPI_EXPORT virtual bool hasTexture() = 0;
+
+ /// Returns the value of the image attribute
+ MODELAPI_EXPORT virtual bool texture(int& theWidth,
+ int& theHeight,
+ std::list<unsigned char>& theByteArray,
+ std::string& theFormat) = 0;
+
+ /// Copy the image data to the destination attribute
+ virtual void copyTo(std::shared_ptr<ModelAPI_AttributeImage> theTarget) const = 0;
+
+ /// Returns the type of this class of attributes
+ MODELAPI_EXPORT static std::string typeId()
+ {
+ return "Image";
+ }
+
+ /// Returns the type of this class of attributes, not static method
+ MODELAPI_EXPORT virtual std::string attributeType();
+
+ /// To virtually destroy the fields of successors
+ MODELAPI_EXPORT virtual ~ModelAPI_AttributeImage();
+
+ protected:
+ /// Objects are created for features automatically
+ MODELAPI_EXPORT ModelAPI_AttributeImage();
+};
+
+//! Pointer on image attribute
+typedef std::shared_ptr<ModelAPI_AttributeImage> AttributeImagePtr;
+
+#endif
class ModelAPI_AttributeSelection;
class ModelAPI_AttributeSelectionList;
class ModelAPI_AttributeIntArray;
+class ModelAPI_AttributeImage;
class ModelAPI_AttributeTables;
class ModelAPI_Object;
class GeomAPI_Shape;
virtual std::shared_ptr<ModelAPI_AttributeIntArray> intArray(const std::string& theID) = 0;
/// Returns the attribute that contains string values array
virtual std::shared_ptr<ModelAPI_AttributeStringArray> stringArray(const std::string& theID) = 0;
+ /// Returns the attribute that contains image
+ virtual std::shared_ptr<ModelAPI_AttributeImage> image(const std::string& theID) = 0;
/// Returns the attribute that contains tables
virtual std::shared_ptr<ModelAPI_AttributeTables> tables(const std::string& theID) = 0;
{
return myShapes;
}
+
+
+// ===== ModelAPI_FeaturesLicenseValidMessage =====
+ModelAPI_FeaturesLicenseValidMessage::ModelAPI_FeaturesLicenseValidMessage(
+ const Events_ID theID, const void* theSender)
+ : Events_Message(theID, theSender)
+{}
+
+ModelAPI_FeaturesLicenseValidMessage::~ModelAPI_FeaturesLicenseValidMessage()
+{}
+
+void ModelAPI_FeaturesLicenseValidMessage::setFeatures(const std::set<std::string>& theFeatures)
+{
+ myFeatures = theFeatures;
+}
+
+const std::set<std::string>& ModelAPI_FeaturesLicenseValidMessage::features() const
+{
+ return myFeatures;
+}
/// Event ID that requests updates visual attributes for presentations
MAYBE_UNUSED static const char * EVENT_VISUAL_ATTRIBUTES = "UpdateVisualAttributes";
-
/// Event ID that 1D-fillet failed (comes with ModelAPI_ShapesFailedMessage)
MAYBE_UNUSED static const char * EVENT_OPERATION_SHAPES_FAILED = "OperationShapesFailed";
+/// Event ID that license of specified features is checked and valid
+MAYBE_UNUSED static const char * EVENT_FEATURE_LICENSE_VALID = "FeaturesLicenseValid";
+
/// Message that feature was changed (used for Object Browser update): moved, updated and deleted
class MODELAPI_EXPORT ModelAPI_ObjectUpdatedMessage : public Events_MessageGroup
{
std::list< std::shared_ptr<GeomAPI_Shape> > myShapes;
};
+/// Message that sends the features which license is checked and valid
+class ModelAPI_FeaturesLicenseValidMessage : public Events_Message
+{
+public:
+ /// Creates an message
+ MODELAPI_EXPORT
+ ModelAPI_FeaturesLicenseValidMessage(const Events_ID theID, const void* theSender = 0);
+ /// Default destructor
+ MODELAPI_EXPORT virtual ~ModelAPI_FeaturesLicenseValidMessage();
+ /// Static. Returns EventID of the message.
+ MODELAPI_EXPORT static Events_ID eventId()
+ {
+ return Events_Loop::eventByName(EVENT_FEATURE_LICENSE_VALID);
+ }
+
+ /// Sets list of features with valid license
+ MODELAPI_EXPORT void setFeatures(const std::set<std::string>& theFeatures);
+ /// Returns list of features with valid license
+ MODELAPI_EXPORT const std::set<std::string>& features() const;
+
+private:
+ std::set<std::string> myFeatures;
+};
+
#endif
{
std::shared_ptr<ModelAPI_Data> myData; ///< manager of the data model of a feature
std::shared_ptr<ModelAPI_Document> myDoc; ///< document this object belongs to
- std::string textureFile = "";
public:
#ifdef DEBUG_NAMES
std::wstring myName; // name of this object
/// signal.
MODELAPI_EXPORT virtual void setDisplayed(const bool theDisplay);
- MODELAPI_EXPORT bool hasTextureFile()
+ MODELAPI_EXPORT virtual bool hasTexture()
{
- return (textureFile != "");
- }
-
- MODELAPI_EXPORT virtual void setTextureFile(const std::string & theTextureFile)
- {
- textureFile = theTextureFile;
- }
-
- MODELAPI_EXPORT const std::string & getTextureFile()
- {
- return textureFile;
+ return false;
}
protected:
public:
/// Reference to the color of the result.
- /// The integer array is used. It contains tree values for red green and blue values.
+ /// The integer array is used. It contains three values for red, green and blue values.
/// The values are in [0, 255] range
inline static const std::string& COLOR_ID()
{
public:
MODELAPI_EXPORT virtual ~ModelAPI_ResultBody();
+ /// Reference to the image attribute of the result body.
+ inline static const std::string& IMAGE_ID()
+ {
+ static const std::string MY_IMAGE_ID("Image");
+ return MY_IMAGE_ID;
+ }
+
/// Returns the group identifier of this result
MODELAPI_EXPORT virtual std::string groupName();
/// the plugin manager on call of the feature)
virtual void registerPlugin(ModelAPI_Plugin* thePlugin) = 0;
+ /// Verifies the license for the plugin is valid
+ virtual bool checkLicense(const std::string& thePluginName) = 0;
+
/// Returns the root document of the application (that may contains sub-documents)
virtual std::shared_ptr<ModelAPI_Document> moduleDocument() = 0;
#include <ModelAPI_AttributeBoolean.h>
#include <ModelAPI_AttributeDocRef.h>
#include <ModelAPI_AttributeDouble.h>
+#include <ModelAPI_AttributeImage.h>
#include <ModelAPI_AttributeIntArray.h>
#include <ModelAPI_AttributeSelectionList.h>
#include <ModelAPI_CompositeFeature.h>
#include <Events_Loop.h>
#include <Locale_Convert.h>
+#include <GeomAlgoAPI_MakeShape.h>
#include <GeomAPI_ShapeHierarchy.h>
#include <GeomAPI_ShapeIterator.h>
return ObjectPtr();
}
+//==================================================================================================
+void loadModifiedShapes(ResultBodyPtr theResultBody,
+ const ListOfShape& theBaseShapes,
+ const ListOfShape& theTools,
+ const GeomMakeShapePtr& theMakeShape,
+ const GeomShapePtr theResultShape,
+ const std::string& theNamePrefix)
+{
+ theResultBody->storeModified(theBaseShapes, theResultShape, theMakeShape);
+
+ ListOfShape aShapes = theBaseShapes;
+ ListOfShape::const_iterator aToolIter = theTools.cbegin();
+ for (; aToolIter != theTools.cend(); aToolIter++)
+ aShapes.push_back(*aToolIter);
+
+ for (ListOfShape::const_iterator anIter = aShapes.begin(); anIter != aShapes.end(); ++anIter)
+ {
+ theResultBody->loadModifiedShapes(theMakeShape, *anIter, GeomAPI_Shape::VERTEX, theNamePrefix);
+ theResultBody->loadModifiedShapes(theMakeShape, *anIter, GeomAPI_Shape::EDGE, theNamePrefix);
+ theResultBody->loadModifiedShapes(theMakeShape, *anIter, GeomAPI_Shape::FACE, theNamePrefix);
+ }
+}
+
+//==================================================================================================
+void loadModifiedShapes(ResultBodyPtr theResultBody,
+ const GeomShapePtr& theBaseShape,
+ const GeomMakeShapePtr& theMakeShape,
+ const std::string theName)
+{
+ switch (theBaseShape->shapeType()) {
+ case GeomAPI_Shape::COMPOUND: {
+ for (GeomAPI_ShapeIterator anIt(theBaseShape); anIt.more(); anIt.next())
+ {
+ loadModifiedShapes(theResultBody,
+ anIt.current(),
+ theMakeShape,
+ theName);
+ }
+ break;
+ }
+ case GeomAPI_Shape::COMPSOLID:
+ case GeomAPI_Shape::SOLID:
+ case GeomAPI_Shape::SHELL: {
+ theResultBody->loadModifiedShapes(theMakeShape,
+ theBaseShape,
+ GeomAPI_Shape::FACE,
+ theName);
+ }
+ case GeomAPI_Shape::FACE:
+ case GeomAPI_Shape::WIRE: {
+ theResultBody->loadModifiedShapes(theMakeShape,
+ theBaseShape,
+ GeomAPI_Shape::EDGE,
+ theName);
+ }
+ case GeomAPI_Shape::EDGE: {
+ theResultBody->loadModifiedShapes(theMakeShape,
+ theBaseShape,
+ GeomAPI_Shape::VERTEX,
+ theName);
+ }
+ default: // [to avoid compilation warning]
+ break;
+ }
+}
+
+//==================================================================================================
+void loadDeletedShapes(ResultBodyPtr theResultBody,
+ const GeomShapePtr theBaseShape,
+ const ListOfShape& theTools,
+ const GeomMakeShapePtr& theMakeShape,
+ const GeomShapePtr theResultShapesCompound)
+{
+ ListOfShape aShapes = theTools;
+ if (theBaseShape.get())
+ aShapes.push_front(theBaseShape);
+
+ for (ListOfShape::const_iterator anIter = aShapes.begin(); anIter != aShapes.end(); anIter++)
+ {
+ theResultBody->loadDeletedShapes(theMakeShape,
+ *anIter,
+ GeomAPI_Shape::VERTEX,
+ theResultShapesCompound);
+ theResultBody->loadDeletedShapes(theMakeShape,
+ *anIter,
+ GeomAPI_Shape::EDGE,
+ theResultShapesCompound);
+ theResultBody->loadDeletedShapes(theMakeShape,
+ *anIter,
+ GeomAPI_Shape::FACE,
+ theResultShapesCompound);
+ // store information about deleted solids because of unittest TestBooleanCommon_SolidsHistory
+ // on OCCT 7.4.0 : common produces modified compsolid, so, move to the end for removed solids
+ // starts to produce whole compsolid
+ theResultBody->loadDeletedShapes(theMakeShape,
+ *anIter,
+ GeomAPI_Shape::SOLID,
+ theResultShapesCompound);
+ }
+}
+
+//==================================================================================================
+void loadDeletedShapes(std::vector<ResultBaseAlgo>& theResultBaseAlgoList,
+ const ListOfShape& theTools,
+ const GeomShapePtr theResultShapesCompound)
+{
+ for (std::vector<ResultBaseAlgo>::iterator anIt = theResultBaseAlgoList.begin();
+ anIt != theResultBaseAlgoList.end();
+ ++anIt)
+ {
+ ResultBaseAlgo& aRCA = *anIt;
+ loadDeletedShapes(aRCA.resultBody,
+ aRCA.baseShape,
+ theTools,
+ aRCA.makeShape,
+ theResultShapesCompound);
+ }
+}
+
bool findVariable(const DocumentPtr& theDocument, FeaturePtr theSearcher,
const std::wstring& theName, double& outValue, ResultParameterPtr& theParam)
{
}
}
+
+void copyImageAttribute (std::shared_ptr<ModelAPI_Result> theSource,
+ std::shared_ptr<ModelAPI_Result> theDest)
+{
+ if (!theSource.get() || !theDest.get())
+ return;
+
+ // images allowed only for ResultBody
+ ResultBodyPtr aSourceBody = std::dynamic_pointer_cast<ModelAPI_ResultBody>(theSource);
+ ResultBodyPtr aDestBody = std::dynamic_pointer_cast<ModelAPI_ResultBody>(theDest);
+ if (!aSourceBody.get() || !aDestBody.get())
+ return;
+
+ AttributeImagePtr aSourceImage =
+ theSource->data()->image(ModelAPI_ResultBody::IMAGE_ID());
+ if (aSourceImage.get() && aSourceImage->hasTexture()) {
+ AttributeImagePtr aDestImage =
+ theDest->data()->image(ModelAPI_ResultBody::IMAGE_ID());
+ if (aDestImage.get()) {
+ aSourceImage->copyTo(aDestImage);
+ }
+ }
+}
+
std::list<FeaturePtr> referencedFeatures(
std::shared_ptr<ModelAPI_Result> theTarget, const std::string& theFeatureKind,
const bool theSortResults)
class ModelAPI_ResultParameter;
class ModelAPI_ResultBody;
+class GeomAlgoAPI_MakeShape;
class GeomAPI_Shape;
class GeomAPI_ShapeHierarchy;
*/
MODELAPI_EXPORT std::string getFeatureError(const std::shared_ptr<ModelAPI_Feature>& theFeature);
+MODELAPI_EXPORT struct ResultBaseAlgo {
+ std::shared_ptr<ModelAPI_ResultBody> resultBody;
+ std::shared_ptr<GeomAPI_Shape> baseShape;
+ std::shared_ptr<GeomAlgoAPI_MakeShape> makeShape;
+};
+
+MODELAPI_EXPORT void loadModifiedShapes(std::shared_ptr<ModelAPI_ResultBody> theResultBody,
+ const std::list<std::shared_ptr<GeomAPI_Shape>>& theBaseShapes,
+ const std::list<std::shared_ptr<GeomAPI_Shape>>& theTools,
+ const std::shared_ptr<GeomAlgoAPI_MakeShape>& theMakeShape,
+ const std::shared_ptr<GeomAPI_Shape> theResultShape,
+ const std::string& theNamePrefix = "");
+
+MODELAPI_EXPORT void loadModifiedShapes(std::shared_ptr<ModelAPI_ResultBody> theResultBody,
+ const std::shared_ptr<GeomAPI_Shape>& theBaseShape,
+ const std::shared_ptr<GeomAlgoAPI_MakeShape>& theMakeShape,
+ const std::string theName);
+/// Stores deleted shapes.
+MODELAPI_EXPORT void loadDeletedShapes(std::shared_ptr<ModelAPI_ResultBody> theResultBody,
+ const std::shared_ptr<GeomAPI_Shape> theBaseShape,
+ const std::list<std::shared_ptr<GeomAPI_Shape>>& theTools,
+ const std::shared_ptr<GeomAlgoAPI_MakeShape>& theMakeShape,
+ const std::shared_ptr<GeomAPI_Shape> theResultShapesCompound);
+
+/// Stores deleted shapes.
+MODELAPI_EXPORT void loadDeletedShapes(std::vector<ResultBaseAlgo>& theResultBaseAlgoList,
+ const std::list<std::shared_ptr<GeomAPI_Shape>>& theTools,
+ const std::shared_ptr<GeomAPI_Shape> theResultShapesCompound);
+
/*!
* Searches for variable with name \param theName in \param theDocument.
* If found, set it value in the \param outValue and returns true.
MODELAPI_EXPORT void copyVisualizationAttrs(std::shared_ptr<ModelAPI_Result> theSource,
std::shared_ptr<ModelAPI_Result> theDest);
+/*! Copies image attribute from one result to another.
+* \param theSource a result that contains the image data
+* \param theDest a destination result that takes the image data
+*/
+MODELAPI_EXPORT void copyImageAttribute(std::shared_ptr<ModelAPI_Result> theSource,
+ std::shared_ptr<ModelAPI_Result> theDest);
+
/*! Produces list of features that reference to the given target (directly or through sub-results)
* \param theTarget the referenced result
* \param theFeatureKind the resulting features filter: the feature kind or all for the empty string
MODELHIGHAPI_EXPORT
bool process(const std::shared_ptr<ModelAPI_Document>& theDoc, const std::string& theFileName);
+ /// Keep path to the true dumping directory.
+ /// It is used to store image files or any other external files
+ /// \param theDumpDir path to the true dumping directory
+ MODELHIGHAPI_EXPORT
+ void setDumpDir(const std::string& theDumpDir) { myDumpDir = theDumpDir; }
+ /// Return path to the true dumping directory
+ MODELHIGHAPI_EXPORT std::string getDumpDir() const { return myDumpDir; }
+
/// Add module to list of imported modules
/// \param theModuleName name of the module to be imported
MODELHIGHAPI_EXPORT
std::list<EntityPtr> myPostponed; ///< list of postponed entities (sketch constraints or folders)
bool myDumpPostponedInProgress; ///< processing postponed is in progress
+ std::string myDumpDir;
+
protected:
/// list of entities, used by other features but not dumped yet
std::set<EntityPtr> myNotDumpedEntities;
} else if (aType == ModelAPI_AttributeString::typeId()) {
AttributeStringPtr anAttr = std::dynamic_pointer_cast<ModelAPI_AttributeString>(theAttr);
// do not dump solver DOF for sketch as it may be changed unexpectedly
- if(anAttr->id() == "SolverDOF") {
+ if (anAttr->id() == "SolverDOF") {
+ return "";
+ }
+ // do not dump file path for Image as it is changed after DumpPython
+ if (aFeatOwner->getKind() == "ImportImage" &&
+ anAttr->id() == "file_path") {
return "";
}
aResult<<anAttr->value();
#include <GeomDataAPI_Point2D.h>
#include <GeomDataAPI_Point2DArray.h>
//--------------------------------------------------------------------------------------
+#include <GeomAlgoAPI_Tools.h>
+//--------------------------------------------------------------------------------------
#include <Locale_Convert.h>
//--------------------------------------------------------------------------------------
#include <ModelAPI_AttributeBoolean.h>
if (aDump.get()) {
aDump->string("file_path")->setValue(theFilename);
aDump->string("file_format")->setValue("py");
+ std::string aTrek = GeomAlgoAPI_Tools::File_Tools::path(theFilename);
+ aDump->string("dump_dir")->setValue(aTrek);
aDump->boolean("topological_naming")->setValue((theSelectionType & CHECK_NAMING) != 0);
aDump->boolean("geometric_selection")->setValue((theSelectionType & CHECK_GEOMETRICAL) != 0);
aDump->boolean("weak_naming")->setValue((theSelectionType & CHECK_WEAK) != 0);
#include "ModuleBase_Dialog.h"
#include "ModuleBase_IErrorMgr.h"
+#include <Events_InfoMessage.h>
#include <Events_Loop.h>
#include <Events_Message.h>
Config_ModuleReader aXMLReader = Config_ModuleReader();
aXMLReader.readAll();
myFeaturesInFiles = aXMLReader.featuresInFiles();
+ myProprietaryFeatures = aXMLReader.proprietaryFeatures();
+ myProprietaryPlugins = aXMLReader.proprietaryPlugins();
+}
+
+void ModuleBase_IModule::processProprietaryFeatures()
+{
+ std::set<std::string>::iterator it = myFeaturesValidLicense.begin();
+ while (it != myFeaturesValidLicense.end()) {
+ std::map<std::string, std::string>::iterator aFound = myProprietaryFeatures.find(*it);
+ if (aFound == myProprietaryFeatures.end())
+ ++it;
+ else {
+ myFeaturesInFiles[aFound->first] = aFound->second;
+ myProprietaryFeatures.erase(aFound);
+ std::set<std::string>::iterator aRemoveIt = it++;
+ myFeaturesValidLicense.erase(aRemoveIt);
+ }
+ }
+}
+
+void ModuleBase_IModule::loadProprietaryPlugins()
+{
+ for (std::set<std::string>::const_iterator itP = myProprietaryPlugins.begin();
+ itP != myProprietaryPlugins.end(); ++itP) {
+ if (!ModelAPI_Session::get()->checkLicense(*itP))
+ Events_InfoMessage(*itP, "License of %1 plugin is not valid or not exist!").arg(*itP).send();
+ }
}
/// Returns new instance of operation object (used in createOperation for customization)
virtual ModuleBase_Operation* getNewOperation(const std::string& theFeatureId);
+ /// Load plugins required license
+ void loadProprietaryPlugins();
+
+ /// Collect features, which have valid license
+ void processProprietaryFeatures();
+
protected:
/// Reference to workshop
ModuleBase_IWorkshop* myWorkshop;
/// Map of features in XML
std::map<std::string, std::string> myFeaturesInFiles;
+ /// Map of features in XML, which require license but not confirmed yet
+ std::map<std::string, std::string> myProprietaryFeatures;
+ /// Proprietary plugins
+ std::set<std::string> myProprietaryPlugins;
+ /// Features, which have valid license
+ std::set<std::string> myFeaturesValidLicense;
std::map<ModuleBase_SelectionFilterType, Handle(SelectMgr_Filter)> mySelectionFilters;
${QT_LIBRARIES}
${OpenCASCADE_FoundationClasses_LIBRARIES}
${OpenCASCADE_ApplicationFramework_LIBRARIES}
- ${OCCViewer}
)
# sources / moc wrappings
isModified = true;
}
else {
- if (myFeature->firstResult().get() && myFeature->firstResult()->hasTextureFile())
- {
- PartSet_Module::setTexture( myFeature->firstResult()->getTextureFile(), aPresentation);
+ if (myFeature->firstResult().get()) {
+ PartSet_Module::setTexture(aPresentation, myFeature->firstResult());
}
anOperationPrs->Redisplay();
isModified = true;
#include <ModelAPI_Tools.h>
#include <ModelAPI_ResultConstruction.h>
#include <ModelAPI_AttributeIntArray.h>
+#include <ModelAPI_AttributeImage.h>
#include <ModelAPI_ResultGroup.h>
#include <ModelAPI_ResultParameter.h>
#include <SelectMgr_ListIteratorOfListOfFilter.hxx>
#include <Graphic3d_Texture2Dmanual.hxx>
-#ifdef HAVE_SALOME
-#include <OCCViewer_Utilities.h>
-#endif
#define FEATURE_ITEM_COLOR "0,0,225"
Events_Loop* aLoop = Events_Loop::loop();
aLoop->registerListener(this, Events_Loop::eventByName(EVENT_DOCUMENT_CHANGED));
aLoop->registerListener(this, Events_Loop::eventByName(EVENT_OBJECT_TO_REDISPLAY));
+ aLoop->registerListener(this, Events_Loop::eventByName(EVENT_FEATURE_LICENSE_VALID));
registerSelectionFilter(SF_GlobalFilter, new PartSet_GlobalFilter(myWorkshop));
registerSelectionFilter(SF_FilterInfinite, new PartSet_FilterInfinite(myWorkshop));
ModuleBase_IModule::createFeatures();
myRoot = new PartSet_RootNode();
myRoot->setWorkshop(workshop());
+ ModuleBase_IModule::loadProprietaryPlugins();
}
return aTransparency;
}
+static AttributeImagePtr findImage(const ObjectPtr& theResult)
+{
+ AttributeImagePtr anImageAttr;
+
+ if (theResult.get()) {
+ ResultBodyPtr aResultBody =
+ std::dynamic_pointer_cast<ModelAPI_ResultBody>(theResult);
+ if (aResultBody.get()) {
+ anImageAttr = aResultBody->data()->image(ModelAPI_ResultBody::IMAGE_ID());
+ if (!anImageAttr.get() || !anImageAttr->hasTexture()) {
+ // try to find an image attribute in parents
+ ObjectPtr aParent = theResult->document()->parent(theResult);
+ anImageAttr = findImage(aParent);
+ }
+ }
+ }
+
+ return anImageAttr;
+}
+
//******************************************************
-void PartSet_Module::setTexture(const std::string & theTextureFile, const AISObjectPtr& thePrs)
+void PartSet_Module::setTexture(const AISObjectPtr& thePrs,
+ const ResultPtr& theResult)
{
-#ifdef HAVE_SALOME
+ ResultBodyPtr aResultBody =
+ std::dynamic_pointer_cast<ModelAPI_ResultBody>(theResult);
+ if (!aResultBody.get())
+ return;
+
+ AttributeImagePtr anImageAttr = findImage(theResult);
+ if (!anImageAttr.get() || !anImageAttr->hasTexture())
+ return;
+
+ int aWidth, aHeight;
+ std::string aFormat;
+ std::list<unsigned char> aByteList;
+ anImageAttr->texture(aWidth, aHeight, aByteList, aFormat);
+
Handle(AIS_InteractiveObject) anAIS = thePrs->impl<Handle(AIS_InteractiveObject)>();
- if (!anAIS.IsNull())
- {
+ if (!anAIS.IsNull()) {
/// set color to white and change material aspect,
/// in order to keep a natural apect of the image.
thePrs->setColor(255, 255, 255);
myDrawer->ShadingAspect()->Aspect()->SetFrontMaterial(aMatAspect);
myDrawer->ShadingAspect()->Aspect()->SetBackMaterial(aMatAspect);
- Handle(Image_PixMap) aPixmap;
- QPixmap px(theTextureFile.c_str());
-
- if (!px.isNull() )
- aPixmap = OCCViewer_Utilities::imageToPixmap( px.toImage());
+ //aPixmap = OCCViewer_Utilities::imageToPixmap( px.toImage());
+ Handle(Image_PixMap) aPixmap = new Image_PixMap();
+ aPixmap->InitTrash(Image_PixMap::ImgBGRA, aWidth, aHeight);
+ std::list<unsigned char>::iterator aByteIter = aByteList.begin();
+ for (int aLine = 0; aLine < aHeight; ++aLine) {
+ // convert pixels from ARGB to renderer-compatible RGBA
+ for (int aByte = 0; aByte < aWidth; ++aByte) {
+ Image_ColorBGRA& aPixmapBytes = aPixmap->ChangeValue<Image_ColorBGRA>(aLine, aByte);
+
+ aPixmapBytes.b() = (Standard_Byte) *aByteIter++;
+ aPixmapBytes.g() = (Standard_Byte) *aByteIter++;
+ aPixmapBytes.r() = (Standard_Byte) *aByteIter++;
+ aPixmapBytes.a() = (Standard_Byte) *aByteIter++;
+ }
+ }
anAISShape->Attributes()->ShadingAspect()->Aspect()->SetTextureMap
(new Graphic3d_Texture2Dmanual(aPixmap));
anAISShape->SetDisplayMode(AIS_Shaded);
}
}
-#endif
}
//******************************************************
thePrs->setDeflection(getResultDeflection(aResult));
thePrs->setTransparency(getResultTransparency(aResult));
- /// set texture parameters
- if(aResult->hasTextureFile()) {
- setTexture(aResult->getTextureFile(), thePrs);
- }
+ /// set texture parameters, if any
+ setTexture(thePrs, aResult);
}
if (aFeature.get() && (aFeature->getKind() == SketchPlugin_Sketch::ID())) {
thePrs->setWidth(2);
mySketchMgr->previewSketchPlane()->createSketchPlane(aSketch, myWorkshop);
}
}
+ else if (theMessage->eventID() == Events_Loop::loop()->eventByName(EVENT_FEATURE_LICENSE_VALID)) {
+ std::shared_ptr<ModelAPI_FeaturesLicenseValidMessage> aMsg =
+ std::dynamic_pointer_cast<ModelAPI_FeaturesLicenseValidMessage>(theMessage);
+ myFeaturesValidLicense.insert(aMsg->features().begin(), aMsg->features().end());
+ processProprietaryFeatures();
+ }
}
//******************************************************
virtual void createFeatures();
/// add texture
- static void setTexture(const std::string &theTextureFile, const AISObjectPtr& thePrs);
+ static void setTexture(const AISObjectPtr& thePrs, const ResultPtr& theResult);
public slots:
/// Slolt called on object display
from .primitives import *
from .gdml import *
from .tests import *
+
+# Add-on features
+
+from .addons import *
+# move functions from .addons to top level (model) package
+import inspect
+for attribute_name in dir(addons):
+ attribute = getattr(addons, attribute_name)
+ if inspect.isfunction(attribute):
+ globals()[attribute_name] = attribute
+del inspect
--- /dev/null
+# Copyright (C) 2015-2020 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
+#
+
+import pkgutil, inspect
+
+__all__ = []
+for loader, module_name, is_pkg in pkgutil.walk_packages(__path__):
+ __all__.append(module_name)
+ module = loader.find_module(module_name).load_module(module_name)
+ globals()[module_name] = module
+
+ for attribute_name in dir(module):
+ attribute = getattr(module, attribute_name)
+ if inspect.isfunction(attribute):
+ globals()[attribute_name] = attribute
+
+del pkgutil, inspect
\ No newline at end of file
ModelAPI_Session::get()->startOperation(ExchangePlugin_Dump::ID());
FeaturePtr aFeature = aDoc->addFeature(ExchangePlugin_Dump::ID());
if (aFeature.get()) {
+ // keep path to the true dumping directory for external files dumping
+ AttributeStringPtr aAttr = aFeature->string(ExchangePlugin_Dump::DUMP_DIR_ID());
+ if (aAttr.get()) {
+ QString aDirPath = QFileInfo(thePath).path();
+ aAttr->setValue(aDirPath.toStdString());
+ }
+
+ // tmp path to write the script
std::string aTmpDir = aStudy->GetTmpDir(thePath.toStdString().c_str(), isMultiFile);
std::string aFileName = aTmpDir + DUMP_NAME;
QFile::remove(aFileName.c_str());
}
- AttributeStringPtr aAttr = aFeature->string(ExchangePlugin_Dump::FILE_PATH_ID());
+ aAttr = aFeature->string(ExchangePlugin_Dump::FILE_PATH_ID());
if (aAttr.get())
aAttr->setValue(aFileName);
ModelAPI_Session::get()->finishOperation();
if (QFile::exists(aFileName.c_str())) {
- QFile aInFile(aFileName.c_str());
+ QFile aInFile(aFileName.c_str());
if (!aInFile.open(QIODevice::ReadOnly | QIODevice::Text))
return false;
QTextStream aText(&aInFile);
