apply(); // finish operation to make sure the export is done on the current state of the history
}
-// Constructor with values for STL of selected result export.
-ExchangeAPI_Export::ExchangeAPI_Export(const std::shared_ptr<ModelAPI_Feature>& theFeature,
- const std::string & theFilePath,
- const ModelHighAPI_Selection& theSelectedShape,
- double aDeflectionRelative,
- double aDeflectionAbsolute,
- const bool anIsRelative,
- const bool anIsASCII)
- : ModelHighAPI_Interface(theFeature)
-{
- initialize();
- fillAttribute("STL", theFeature->string(ExchangePlugin_ExportFeature::EXPORT_TYPE_ID()));
- fillAttribute(theFilePath, theFeature->string(ExchangePlugin_ExportFeature::STL_FILE_PATH_ID()));
-
- if (anIsRelative) {
- fillAttribute(ExchangePlugin_ExportFeature::STL_DEFLECTION_TYPE_RELATIVE(),
- theFeature->string(ExchangePlugin_ExportFeature::STL_DEFLECTION_TYPE()) );
- fillAttribute(aDeflectionRelative,
- theFeature->real(ExchangePlugin_ExportFeature::STL_RELATIVE()) );
- }
- else {
- fillAttribute(ExchangePlugin_ExportFeature::STL_DEFLECTION_TYPE_ABSOLUTE(),
- theFeature->string(ExchangePlugin_ExportFeature::STL_DEFLECTION_TYPE()) );
- fillAttribute(aDeflectionAbsolute,
- theFeature->real(ExchangePlugin_ExportFeature::STL_ABSOLUTE()) );
- }
-
- if(anIsASCII){
- fillAttribute(ExchangePlugin_ExportFeature::STL_FILE_TYPE_ASCII(),
- theFeature->string(ExchangePlugin_ExportFeature::STL_FILE_TYPE()));
- }
- else
- {
- fillAttribute(ExchangePlugin_ExportFeature::STL_FILE_TYPE_BINARY(),
- theFeature->string(ExchangePlugin_ExportFeature::STL_FILE_TYPE()));
- }
-
- fillAttribute(theSelectedShape,theFeature->selection(ExchangePlugin_ExportFeature::STL_OBJECT_SELECTED()));
- fillAttribute("STL", theFeature->string(ExchangePlugin_ExportFeature::FILE_FORMAT_ID()));
- execute();
- apply(); // finish operation to make sure the export is done on the current state of the history
-}
-
-
-
ExchangeAPI_Export::ExchangeAPI_Export(const std::shared_ptr<ModelAPI_Feature>& theFeature,
const std::string & theFilePath, const ModelHighAPI_Selection& theResult,
const std::string & theAuthor, const std::string & theGeometryName)
}
-
/// Constructor with values for export in other formats than XAO.
ExchangeAPI_Export::ExchangeAPI_Export(const std::shared_ptr<ModelAPI_Feature>& theFeature,
const std::string & theFilePath,
theDumper << ", '" << theGeometryName << "'";
theDumper << ")" << std::endl;
}
- else if (exportType == "STL") {
- std::string aTmpSTLFile =
- aBase->string(ExchangePlugin_ExportFeature::STL_FILE_PATH_ID())->value();
- correctSeparators(aTmpSTLFile);
- theDumper << "exportToSTL(" << aDocName << ", '" << aTmpSTLFile << "'" ;
- AttributeSelectionPtr aShapeSelected =
- aBase->selection(ExchangePlugin_ExportFeature::STL_OBJECT_SELECTED());
-
- theDumper<<","<< aShapeSelected;
-
- theDumper <<","<< stlabsolute() <<","<< stlrelative();
-
- if (stldeflectionType()->value() == ExchangePlugin_ExportFeature::STL_DEFLECTION_TYPE_RELATIVE()) {
- theDumper <<","<< "True";
- }
- else {
- theDumper <<","<< "False";
- }
-
- if (stlfileType()->value() == ExchangePlugin_ExportFeature::STL_FILE_TYPE_BINARY()) {
- theDumper << "False";
- }
- else {
- theDumper << "True";
- }
- theDumper << ")" << std::endl;
- }
else {
std::string aFilePath = aBase->string(ExchangePlugin_ExportFeature::FILE_PATH_ID())->value();
correctSeparators(aFilePath);
return ExportPtr(new ExchangeAPI_Export(aFeature, theFilePath, theAuthor, theGeometryName));
}
-ExportPtr exportToSTL(const std::shared_ptr<ModelAPI_Document> & thePart,
- const std::string & theFilePath,
- const ModelHighAPI_Selection& theSelectedShape,
- double aDeflectionRelative,
- double aDeflectionAbsolute,
- const bool anIsRelative,
- const bool anIsASCII)
-{
- apply(); // finish previous operation to make sure all previous operations are done
- std::shared_ptr<ModelAPI_Feature> aFeature =
- thePart->addFeature(ExchangePlugin_ExportFeature::ID());
-
- return ExportPtr(new ExchangeAPI_Export(aFeature,
- theFilePath,
- theSelectedShape,
- aDeflectionRelative,
- aDeflectionAbsolute,
- anIsRelative,
- anIsASCII));
-}
-
ExportPtr exportToXAO(const std::shared_ptr<ModelAPI_Document> & thePart,
const std::string & theFilePath, const ModelHighAPI_Selection& theSelectedShape,
const std::string & /*theAuthor*/, const std::string & /*theGeometryName*/)
const std::string & theFilePath,
const std::string & theAuthor = std::string(),
const std::string & theGeometryName = std::string());
-
- /// Constructor with values for STL of selected result export.
- EXCHANGEAPI_EXPORT
- explicit ExchangeAPI_Export(const std::shared_ptr<ModelAPI_Feature>& theFeature,
- const std::string & theFilePath,
- const ModelHighAPI_Selection& theSelectedShape,
- double aDeflectionRelative ,
- double aDeflectionAbsolute,
- const bool anIsRelative,
- const bool anIsASCII);
/// Constructor with values for XAO of selected result export.
EXCHANGEAPI_EXPORT
EXCHANGEAPI_EXPORT
virtual ~ExchangeAPI_Export();
- INTERFACE_15(ExchangePlugin_ExportFeature::ID(),
+ INTERFACE_7(ExchangePlugin_ExportFeature::ID(),
exportType, ExchangePlugin_ExportFeature::EXPORT_TYPE_ID(),
ModelAPI_AttributeString, /** ExportType */,
filePath, ExchangePlugin_ExportFeature::FILE_PATH_ID(),
xaoAuthor, ExchangePlugin_ExportFeature::XAO_AUTHOR_ID(),
ModelAPI_AttributeString, /** xao author */,
xaoGeometryName, ExchangePlugin_ExportFeature::XAO_GEOMETRY_NAME_ID(),
- ModelAPI_AttributeString, /** xao geometry name */,
- stlFilePath, ExchangePlugin_ExportFeature::STL_FILE_PATH_ID(),
- ModelAPI_AttributeString, /** stl_file_path */,
- stlobjectselected, ExchangePlugin_ExportFeature::STL_OBJECT_SELECTED(),
- ModelAPI_AttributeSelection, /** Object selected to export in stl file*/,
- stldeflectionType, ExchangePlugin_ExportFeature::STL_DEFLECTION_TYPE(),
- ModelAPI_AttributeString, /** Type of the defelection */,
- stlrelative, ExchangePlugin_ExportFeature::STL_RELATIVE(),
- ModelAPI_AttributeDouble, /** Relative*/,
- stlabsolute, ExchangePlugin_ExportFeature::STL_ABSOLUTE(),
- ModelAPI_AttributeDouble, /** Absolute */,
- stlfileType, ExchangePlugin_ExportFeature::STL_FILE_TYPE(),
- ModelAPI_AttributeString, /** Type of the stl file*/,
- stldeflectionTypeabsolute, ExchangePlugin_ExportFeature::STL_DEFLECTION_TYPE_ABSOLUTE(),
- ModelAPI_AttributeString, /** Type of the defelection */,
- stldeflectionTyperelative, ExchangePlugin_ExportFeature::STL_DEFLECTION_TYPE_RELATIVE(),
- ModelAPI_AttributeString, /** Type of the defelection */)
+ ModelAPI_AttributeString, /** xao geometry name */)
/// Dump wrapped feature
EXCHANGEAPI_EXPORT
const std::string & theAuthor = std::string(),
const std::string & theGeometryName = std::string());
-/**\ingroup CPPHighAPI
- * \brief Exports to STL file the result of the current document
- */
-EXCHANGEAPI_EXPORT
-ExportPtr exportToSTL(const std::shared_ptr<ModelAPI_Document> & thePart,
- const std::string & theFilePath,
- const ModelHighAPI_Selection& theSelectedShape,
- double aDeflectionRelative,
- double aDeflectionAbsolute,
- const bool anIsRelative,
- const bool anIsASCII);
-
/**\ingroup CPPHighAPI
* \brief Exports to XAO file the selected result with groups parts related to it only.
*/
#include <ModelAPI_AttributeStringArray.h>
#include <ModelAPI_Session.h>
#include <ModelAPI_Tools.h>
-#include <GeomAlgoAPI_Tools.h>
-
//--------------------------------------------------------------------------------------
#include <algorithm>
setFilePath(theFilePath);
}
-ExchangeAPI_Import::ExchangeAPI_Import(
- const std::shared_ptr<ModelAPI_Feature> & theFeature,
- const std::string & theFilePath,
- const bool anScalInterUnits,
- const bool anMaterials,
- const bool anColor)
-: ModelHighAPI_Interface(theFeature)
-{
- if (initialize())
- setParameters(theFilePath,anScalInterUnits,anMaterials,anColor);
-}
-
ExchangeAPI_Import::~ExchangeAPI_Import()
{
}
-//--------------------------------------------------------------------------------------
-void ExchangeAPI_Import::setParameters(const std::string & theFilePath,
- const bool anScalInterUnits,
- const bool anMaterials,
- const bool anColor)
-{
- fillAttribute(theFilePath, mystepfilePath);
- fillAttribute("STEP", feature()->string(ExchangePlugin_ImportFeature::IMPORT_TYPE_ID()));
- fillAttribute(anScalInterUnits, feature()->boolean(ExchangePlugin_ImportFeature::STEP_SCALE_INTER_UNITS_ID()));
- fillAttribute(anMaterials, feature()->boolean(ExchangePlugin_ImportFeature::STEP_MATERIALS_ID()));
- fillAttribute(anColor, feature()->boolean(ExchangePlugin_ImportFeature::STEP_COLORS_ID()));
- execute();
-}
-
//--------------------------------------------------------------------------------------
void ExchangeAPI_Import::setFilePath(const std::string & theFilePath)
{
fillAttribute(theFilePath, myfilePath);
- std::string anExtension = GeomAlgoAPI_Tools::File_Tools::extension(theFilePath);
- fillAttribute(anExtension, feature()->string(ExchangePlugin_ImportFeature::IMPORT_TYPE_ID()));
+
execute();
}
FeaturePtr aBase = feature();
std::string aPartName = theDumper.name(aBase->document());
- AttributeStringPtr aImportTypeAttr = aBase->string(ExchangePlugin_ImportFeature::IMPORT_TYPE_ID());
- std::string aFormat = aImportTypeAttr->value();
- std::string aFilePath;
- if (aFormat == "STEP" || aFormat == "STP")
- {
- aFilePath = aBase->string(ExchangePlugin_ImportFeature::STEP_FILE_PATH_ID())->value();
- }else{
- aFilePath = aBase->string(ExchangePlugin_ImportFeature::FILE_PATH_ID())->value();
- }
-
+ std::string aFilePath = aBase->string(ExchangePlugin_ImportFeature::FILE_PATH_ID())->value();
std::string aFrom = "\\";
std::string aTo = "\\\\";
for(std::size_t aPos = aFilePath.find(aFrom);
aFilePath.replace(aPos, aFrom.size(), aTo);
aPos += aTo.size();
}
- std::string anExtension = GeomAlgoAPI_Tools::File_Tools::extension(aFilePath);
- if( anExtension == "STP" || anExtension == "STEP"){
- theDumper << aBase << " = model.addImportStep(" << aPartName << ", \""
- << aFilePath << "\"" ;
-
- theDumper << ", " << scalinterunits()->value()
- << ", " << materials()->value()
- << ", " << colors()->value() << ")"<< std::endl;
- }else{
- theDumper << aBase << " = model.addImport(" << aPartName << ", \""
- << aFilePath << "\")" << std::endl;
- }
+ theDumper << aBase << " = model.addImport(" << aPartName << ", \""
+ << aFilePath << "\")" << std::endl;
// to make import have results
theDumper << "model.do()" << std::endl;
return ImportPtr(new ExchangeAPI_Import(aFeature, theFilePath));
}
-ImportPtr addImportStep(
- const std::shared_ptr<ModelAPI_Document> & thePart,
- const std::string & theFilePath,
- const bool anScalInterUnits,
- const bool anMaterials,
- const bool anColor )
-{
- std::shared_ptr<ModelAPI_Feature> aFeature = thePart->addFeature(ExchangeAPI_Import::ID());
- return ImportPtr(new ExchangeAPI_Import(aFeature, theFilePath,
- anScalInterUnits, anMaterials, anColor));
-}
-
void importPart(const std::shared_ptr<ModelAPI_Document> & thePart,
const std::string & theFilePath,
const ModelHighAPI_Reference & theAfterThis)
EXCHANGEAPI_EXPORT
ExchangeAPI_Import(const std::shared_ptr<ModelAPI_Feature> & theFeature,
const std::string & theFilePath);
-
- /// Constructor with values for Step file
- EXCHANGEAPI_EXPORT
- ExchangeAPI_Import(const std::shared_ptr<ModelAPI_Feature> & theFeature,
- const std::string & theFilePath,
- const bool anScalInterUnits,
- const bool anMaterials,
- const bool anColor);
-
/// Destructor
EXCHANGEAPI_EXPORT
virtual ~ExchangeAPI_Import();
- INTERFACE_6(ExchangePlugin_ImportFeature::ID(),
+ INTERFACE_1(ExchangePlugin_ImportFeature::ID(),
filePath, ExchangePlugin_ImportFeature::FILE_PATH_ID(),
- ModelAPI_AttributeString, /** File path */,
- stepimporttype, ExchangePlugin_ImportFeature::IMPORT_TYPE_ID(),
- ModelAPI_AttributeString, /**import type */,
- stepfilePath, ExchangePlugin_ImportFeature::STEP_FILE_PATH_ID(),
- ModelAPI_AttributeString, /**step File path */,
- scalinterunits, ExchangePlugin_ImportFeature::STEP_SCALE_INTER_UNITS_ID(),
- ModelAPI_AttributeBoolean, /** Scale internationals units */,
- materials, ExchangePlugin_ImportFeature::STEP_MATERIALS_ID(),
- ModelAPI_AttributeBoolean, /** Materials */,
- colors, ExchangePlugin_ImportFeature::STEP_COLORS_ID(),
- ModelAPI_AttributeBoolean, /** Colors */
+ ModelAPI_AttributeString, /** File path */
)
/// Set point values
EXCHANGEAPI_EXPORT
void setFilePath(const std::string & theFilePath);
-
- EXCHANGEAPI_EXPORT
- void setParameters(const std::string & theFilePath,
- const bool anScalInterUnits,
- const bool anMaterials,
- const bool anColor);
/// Dump wrapped feature
EXCHANGEAPI_EXPORT
ImportPtr addImport(const std::shared_ptr<ModelAPI_Document> & thePart,
const std::string & theFilePath);
-/**\ingroup CPPHighAPI
- * \brief Create Import Step feature
- */
-EXCHANGEAPI_EXPORT
-ImportPtr addImportStep(const std::shared_ptr<ModelAPI_Document> & thePart,
- const std::string & theFilePath,
- const bool anScalInterUnits,
- const bool anMaterials,
- const bool anColor);
-
/** \ingroup CPPHighAPI
* \brief Import features from the file to the document after the current feature (or to the end).
*/
${PROJECT_SOURCE_DIR}/src/XAO
${PROJECT_SOURCE_DIR}/src/ConstructionPlugin
${PROJECT_SOURCE_DIR}/src/PartSetPlugin
- ${OpenCASCADE_INCLUDE_DIR}
)
SET(PROJECT_HEADERS
#include <ostream>
#endif
-
#include <Config_Common.h>
#include <Config_PropManager.h>
#include <GeomAlgoAPI_CompoundBuilder.h>
#include <GeomAlgoAPI_IGESExport.h>
#include <GeomAlgoAPI_STEPExport.h>
-#include <GeomAlgoAPI_STLExport.h>
#include <GeomAlgoAPI_Tools.h>
#include <GeomAlgoAPI_XAOExport.h>
#include <ModelAPI_AttributeStringArray.h>
#include <ModelAPI_AttributeIntArray.h>
#include <ModelAPI_AttributeTables.h>
-#include <ModelAPI_AttributeDouble.h>
#include <ModelAPI_Data.h>
#include <ModelAPI_Document.h>
#include <ModelAPI_Object.h>
#include <ExchangePlugin_Tools.h>
-#include <ModelAPI_ResultConstruction.h>
-
ExchangePlugin_ExportFeature::ExchangePlugin_ExportFeature()
{
}
ModelAPI_AttributeString::typeId());
data()->addAttribute(ExchangePlugin_ExportFeature::XAO_SELECTION_LIST_ID(),
ModelAPI_AttributeSelectionList::typeId());
- data()->addAttribute(ExchangePlugin_ExportFeature::STL_FILE_PATH_ID(),
- ModelAPI_AttributeString::typeId());
- data()->addAttribute(ExchangePlugin_ExportFeature::STL_OBJECT_SELECTED(),
- ModelAPI_AttributeSelection::typeId());
- data()->addAttribute(ExchangePlugin_ExportFeature::STL_DEFLECTION_TYPE(),
- ModelAPI_AttributeString::typeId());
- data()->addAttribute(ExchangePlugin_ExportFeature::STL_RELATIVE(),
- ModelAPI_AttributeDouble::typeId());
-
- double defelection = Config_PropManager::real("Visualization", "body_deflection");
- real(ExchangePlugin_ExportFeature::STL_RELATIVE())->setValue(defelection);
-
- data()->addAttribute(ExchangePlugin_ExportFeature::STL_ABSOLUTE(),
- ModelAPI_AttributeDouble::typeId());
- data()->addAttribute(ExchangePlugin_ExportFeature::STL_FILE_TYPE(),
- ModelAPI_AttributeString::typeId());
ModelAPI_Session::get()->validators()->registerNotObligatory(getKind(),
ExchangePlugin_ExportFeature::XAO_FILE_PATH_ID());
- ModelAPI_Session::get()->validators()->registerNotObligatory(getKind(),
- ExchangePlugin_ExportFeature::STL_FILE_PATH_ID());
ModelAPI_Session::get()->validators()->registerNotObligatory(getKind(),
ExchangePlugin_ExportFeature::XAO_AUTHOR_ID());
ModelAPI_Session::get()->validators()->registerNotObligatory(getKind(),
string(ExchangePlugin_ExportFeature::FILE_PATH_ID())->setValue(
string(ExchangePlugin_ExportFeature::XAO_FILE_PATH_ID())->value());
}
- else if (theID == STL_FILE_PATH_ID()) {
- string(ExchangePlugin_ExportFeature::FILE_PATH_ID())->setValue(
- string(ExchangePlugin_ExportFeature::STL_FILE_PATH_ID())->value());
- }
-
}
/*
if (aFormatName == "XAO") {
exportXAO(theFileName);
return;
- }else if (aFormatName == "STL") {
- exportSTL(theFileName);
- return;
}
// make shape for export from selected shapes
return false;
}
-void ExchangePlugin_ExportFeature::exportSTL(const std::string& theFileName)
-{
- // Get shape.
- AttributeSelectionPtr aSelection = selection(STL_OBJECT_SELECTED());
- GeomShapePtr aShape = aSelection->value();
- if (!aShape.get()) {
- aShape = aSelection->context()->shape();
- }
-
- // Get relative value and percent flag.
- double aValue;
- bool anIsRelative = false;
- bool anIsASCII = false;
-
- if (string(STL_DEFLECTION_TYPE())->value() == STL_DEFLECTION_TYPE_RELATIVE()) {
- aValue = real(STL_RELATIVE())->value();
- anIsRelative = true;
- } else {
- aValue = real(STL_ABSOLUTE())->value();
- }
-
- if (string(STL_FILE_TYPE())->value() == STL_FILE_TYPE_ASCII()) {
- anIsASCII = true;
- }
- // Perform the export
- std::string anError;
- bool aResult = false;
-
- aResult = STLExport(theFileName,
- "STL",
- aShape,
- aValue,
- anIsRelative,
- anIsASCII,
- anError);
-
- if (!aResult || !anError.empty()) {
- setError("An error occurred while exporting " + theFileName + ": " + anError);
- return;
- }
-}
-
-
void ExchangePlugin_ExportFeature::exportXAO(const std::string& theFileName)
{
try {
static const std::string MY_XAO_FILE_PATH_ID("xao_file_path");
return MY_XAO_FILE_PATH_ID;
}
- /// attribute name of stl file path
- inline static const std::string& STL_FILE_PATH_ID()
- {
- static const std::string MY_STL_FILE_PATH_ID("stl_file_path");
- return MY_STL_FILE_PATH_ID;
- }
- /// Attribute name for selected object to export in stl file path.
- inline static const std::string& STL_OBJECT_SELECTED()
- {
- static const std::string ATTR_ID("stl_object_selected");
- return ATTR_ID;
- }
- /// Attribute name for deflection type.
- inline static const std::string& STL_DEFLECTION_TYPE()
- {
- static const std::string ATTR_ID("stl_deflection_type");
- return ATTR_ID;
- }
- /// Attribute name for deflection type relative.
- inline static const std::string& STL_DEFLECTION_TYPE_RELATIVE()
- {
- static const std::string ATTR_ID("stl_deflection_type_relative");
- return ATTR_ID;
- }
- /// Attribute name for deflection type absolute.
- inline static const std::string& STL_DEFLECTION_TYPE_ABSOLUTE()
- {
- static const std::string ATTR_ID("stl_deflection_type_absolute");
- return ATTR_ID;
- }
- /// Attribute name for relative.
- inline static const std::string& STL_RELATIVE()
- {
- static const std::string ATTR_ID("stl_relative");
- return ATTR_ID;
- }
- /// Attribute name for absolute.
- inline static const std::string& STL_ABSOLUTE()
- {
- static const std::string ATTR_ID("stl_absolute");
- return ATTR_ID;
- }
- /// Attribute name for stl file type.
- inline static const std::string& STL_FILE_TYPE()
- {
- static const std::string ATTR_ID("stl_file_type");
- return ATTR_ID;
- }
- /// Attribute name for stl file type ascii.
- inline static const std::string& STL_FILE_TYPE_ASCII()
- {
- static const std::string ATTR_ID("stl_file_type_acii");
- return ATTR_ID;
- }
- /// Attribute name for stl file type binary.
- inline static const std::string& STL_FILE_TYPE_BINARY()
- {
- static const std::string ATTR_ID("stl_file_type_binary");
- return ATTR_ID;
- }
/// attribute name of file format
inline static const std::string& FILE_FORMAT_ID()
{
/// Performs export to XAO file
EXCHANGEPLUGIN_EXPORT void exportXAO(const std::string& theFileName);
-
- /// Performs export to STL file
- EXCHANGEPLUGIN_EXPORT void exportSTL(const std::string& theFileName);
};
#endif /* EXPORT_EXPORTFEATURE_H_ */
#include <ModelAPI_AttributeString.h>
#include <ModelAPI_AttributeInteger.h>
#include <ModelAPI_AttributeStringArray.h>
-#include <ModelAPI_AttributeBoolean.h>
#include <ModelAPI_Session.h>
#include <ModelAPI_ResultPart.h>
#include <ModelAPI_Tools.h>
void ExchangePlugin_Import::initAttributes()
{
data()->addAttribute(FILE_PATH_ID(), ModelAPI_AttributeString::typeId());
- data()->addAttribute(STEP_FILE_PATH_ID(), ModelAPI_AttributeString::typeId());
- data()->addAttribute(IMPORT_TYPE_ID(), ModelAPI_AttributeString::typeId());
data()->addAttribute(TARGET_PART_ID(), ModelAPI_AttributeInteger::typeId());
data()->addAttribute(TARGET_PARTS_LIST_ID(), ModelAPI_AttributeStringArray::typeId());
- data()->addAttribute(STEP_TARGET_PART_ID(), ModelAPI_AttributeInteger::typeId());
- data()->addAttribute(STEP_TARGET_PARTS_LIST_ID(), ModelAPI_AttributeStringArray::typeId());
- 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());
}
/*
*/
void ExchangePlugin_Import::execute()
{
- AttributeStringPtr aFormatAttr =
- this->string(ExchangePlugin_Import::IMPORT_TYPE_ID());
- std::string aFormat = aFormatAttr->value();
-
- AttributeStringPtr aFilePathAttr;
- std::string aFilePath;
- AttributeStringArrayPtr aPartsAttr;
- AttributeIntegerPtr aTargetAttr;
- if (aFormat == "STEP" || aFormat == "STP")
- {
- aFilePathAttr = string(ExchangePlugin_Import::STEP_FILE_PATH_ID());
- aFilePath = aFilePathAttr->value();
- // get the document where to import
- aPartsAttr = stringArray(STEP_TARGET_PARTS_LIST_ID());
- aTargetAttr = integer(STEP_TARGET_PART_ID());
- }else{
- aFilePathAttr = string(ExchangePlugin_Import::FILE_PATH_ID());
- aFilePath = aFilePathAttr->value();
- // get the document where to import
- aPartsAttr = stringArray(TARGET_PARTS_LIST_ID());
- aTargetAttr = integer(TARGET_PART_ID());
- }
-
+ AttributeStringPtr aFilePathAttr = string(ExchangePlugin_Import::FILE_PATH_ID());
+ std::string aFilePath = aFilePathAttr->value();
if (aFilePath.empty()) {
- setError("File path is empty.");
- return;
+ setError("File path is empty.");
+ return;
}
+
+ // get the document where to import
+ AttributeStringArrayPtr aPartsAttr = stringArray(TARGET_PARTS_LIST_ID());
+ AttributeIntegerPtr aTargetAttr = integer(TARGET_PART_ID());
SessionPtr aSession = ModelAPI_Session::get();
- DocumentPtr aDoc = findDocument(aSession->moduleDocument(),
+ DocumentPtr aDoc =
+ findDocument(aSession->moduleDocument(),
Locale::Convert::toWString(aPartsAttr->value(aTargetAttr->value())));
if (aDoc.get()) {
FeaturePtr aImportFeature = aDoc->addFeature(ExchangePlugin_ImportFeature::ID());
DataPtr aData = aImportFeature->data();
- AttributeStringPtr aPathAttr;
- if (aFormat == "STEP" || aFormat == "STP")
- {
- aPathAttr = aData->string(ExchangePlugin_ImportFeature::STEP_FILE_PATH_ID());
- }else
- {
- aPathAttr = aData->string(ExchangePlugin_ImportFeature::FILE_PATH_ID());
- }
-
- AttributeStringPtr aImportTypeAttr = aData->string(ExchangePlugin_ImportFeature::IMPORT_TYPE_ID());
-
- aData->boolean(ExchangePlugin_ImportFeature::STEP_MATERIALS_ID())
- ->setValue(boolean(ExchangePlugin_Import::STEP_MATERIALS_ID())->value());
- aData->boolean(ExchangePlugin_ImportFeature::STEP_COLORS_ID())
- ->setValue(boolean(ExchangePlugin_Import::STEP_COLORS_ID())->value());
- aData->boolean(ExchangePlugin_ImportFeature::STEP_SCALE_INTER_UNITS_ID())
- ->setValue(boolean(ExchangePlugin_Import::STEP_SCALE_INTER_UNITS_ID())->value());
-
+ AttributeStringPtr aPathAttr = aData->string(ExchangePlugin_ImportFeature::FILE_PATH_ID());
aPathAttr->setValue(aFilePathAttr->value());
- aImportTypeAttr->setValue(aFormat);
-
aImportFeature->execute();
}
}
void ExchangePlugin_Import::attributeChanged(const std::string& theID)
{
- AttributeStringPtr aFilePathAttr;
- AttributeStringArrayPtr aPartsAttr;
- AttributeIntegerPtr aTargetAttr;
-
- if (theID == FILE_PATH_ID() ||theID == STEP_FILE_PATH_ID() ) {
- aFilePathAttr = string(FILE_PATH_ID());
- if (theID == FILE_PATH_ID() && aFilePathAttr->value().empty())
+ if (theID == FILE_PATH_ID()) {
+ AttributeStringPtr aFilePathAttr = string(FILE_PATH_ID());
+ if (aFilePathAttr->value().empty())
return;
- aPartsAttr = stringArray(TARGET_PARTS_LIST_ID());
- aTargetAttr = integer(TARGET_PART_ID());
-
- updatePart(aPartsAttr, aTargetAttr);
- aFilePathAttr = string(STEP_FILE_PATH_ID());
- if (theID == STEP_FILE_PATH_ID() && aFilePathAttr->value().empty())
- return;
+ AttributeStringArrayPtr aPartsAttr = stringArray(TARGET_PARTS_LIST_ID());
+ AttributeIntegerPtr aTargetAttr = integer(TARGET_PART_ID());
- aPartsAttr = stringArray(STEP_TARGET_PARTS_LIST_ID());
- aTargetAttr = integer(STEP_TARGET_PART_ID());
- updatePart(aPartsAttr, aTargetAttr);
- }
-}
-
-void ExchangePlugin_Import::updatePart(AttributeStringArrayPtr &aPartsAttr, AttributeIntegerPtr &aTargetAttr)
-{
// update the list of target parts
SessionPtr aSession = ModelAPI_Session::get();
DocumentPtr aDoc = document();
aTargetAttr->setValue(0);
}
}
+ }
}
#include <ModelAPI_CompositeFeature.h>
#include <ModelAPI_Result.h>
-#include <ModelAPI_AttributeInteger.h>
-#include <ModelAPI_AttributeStringArray.h>
#include <map>
static const std::string MY_IMPORT_ID("ImportMacro");
return MY_IMPORT_ID;
}
- /// Feature kind
- inline static const std::string& IMPORT_TYPE_ID()
- {
- static const std::string MY_IMPORT_TYPE_ID("ImportType");
- return MY_IMPORT_TYPE_ID;
- }
/// attribute name of file path
inline static const std::string& FILE_PATH_ID()
{
static const std::string MY_TARGET_PARTS_LIST_ID("target_parts_list");
return MY_TARGET_PARTS_LIST_ID;
}
- /// attribute name of step file path
- inline static const std::string& STEP_FILE_PATH_ID()
- {
- static const std::string MY_STEP_FILE_PATH_ID("step_file_path");
- return MY_STEP_FILE_PATH_ID;
- }
- /// attribute name of step target part
- inline static const std::string& STEP_TARGET_PART_ID()
- {
- static const std::string MY_STEP_TARGET_PART_ID("step_target_part");
- return MY_STEP_TARGET_PART_ID;
- }
- /// attribute name of list ofstep target parts
- inline static const std::string& STEP_TARGET_PARTS_LIST_ID()
- {
- static const std::string MY_STEP_TARGET_PARTS_LIST_ID("step_target_parts_list");
- return MY_STEP_TARGET_PARTS_LIST_ID;
- }
- /// attribute name of step Scale to International System Units
- inline static const std::string& STEP_SCALE_INTER_UNITS_ID()
- {
- static const std::string MY_STEP_SCALE_INTER_UNITS_ID("step_scale_inter_units");
- return MY_STEP_SCALE_INTER_UNITS_ID;
- }
- /// attribute name of step materiels
- inline static const std::string& STEP_MATERIALS_ID()
- {
- static const std::string MY_STEP_MATERIALS_ID("step_materials");
- return MY_STEP_MATERIALS_ID;
- }
- /// attribute name of step colors
- inline static const std::string& STEP_COLORS_ID()
- {
- static const std::string MY_STEP_COLORS_ID("step_colours");
- return MY_STEP_COLORS_ID;
- }
/// Default constructor
EXCHANGEPLUGIN_EXPORT ExchangePlugin_Import();
/// Default destructor
/// \param theID identifier of changed attribute
EXCHANGEPLUGIN_EXPORT virtual void attributeChanged(const std::string& theID);
- EXCHANGEPLUGIN_EXPORT
- void updatePart(AttributeStringArrayPtr &aPartsAttr, AttributeIntegerPtr &aTargetAttr);
-
/// Computes or recomputes the results
EXCHANGEPLUGIN_EXPORT virtual void execute();
#include <GeomAlgoAPI_XAOImport.h>
#include <GeomAPI_Shape.h>
-#include <GeomAPI_Face.h>
#include <GeomAPI_ShapeExplorer.h>
#include <Locale_Convert.h>
#include <ModelAPI_AttributeStringArray.h>
#include <ModelAPI_AttributeIntArray.h>
#include <ModelAPI_AttributeTables.h>
-#include <ModelAPI_AttributeBoolean.h>
-#include <ModelAPI_AttributeInteger.h>
#include <ModelAPI_BodyBuilder.h>
#include <ModelAPI_Data.h>
#include <ModelAPI_Document.h>
#include <ExchangePlugin_Tools.h>
-#include <TopExp_Explorer.hxx>
-#include <OSD_Exception.hxx>
-
-
ExchangePlugin_ImportFeature::ExchangePlugin_ImportFeature()
{
}
data()->addAttribute(ExchangePlugin_ImportFeature::FILE_PATH_ID(),
ModelAPI_AttributeString::typeId());
AttributePtr aFeaturesAttribute =
- data()->addAttribute(ExchangePlugin_ImportFeature::FEATURES_ID(),
+ data()->addAttribute(ExchangePlugin_ImportFeature::FEATURES_ID(),
ModelAPI_AttributeRefList::typeId());
- data()->addAttribute(STEP_FILE_PATH_ID(), ModelAPI_AttributeString::typeId());
- data()->addAttribute(IMPORT_TYPE_ID(), ModelAPI_AttributeString::typeId());
- 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());
-
aFeaturesAttribute->setIsArgument(false);
-
+
ModelAPI_Session::get()->validators()->registerNotObligatory(
getKind(), ExchangePlugin_ImportFeature::FEATURES_ID());
}
*/
void ExchangePlugin_ImportFeature::execute()
{
- AttributeStringPtr aImportTypeAttr = string(ExchangePlugin_ImportFeature::IMPORT_TYPE_ID());
- std::string aFormat = aImportTypeAttr->value();
- AttributeStringPtr aFilePathAttr;
- if (aFormat == "STEP" || aFormat == "STP")
- {
- aFilePathAttr = string(ExchangePlugin_ImportFeature::STEP_FILE_PATH_ID());
- }else{
- aFilePathAttr = string(ExchangePlugin_ImportFeature::FILE_PATH_ID());
- }
+ AttributeStringPtr aFilePathAttr = string(ExchangePlugin_ImportFeature::FILE_PATH_ID());
std::string aFilePath = aFilePathAttr->value();
if (aFilePath.empty()) {
setError("File path is empty.");
}
std::shared_ptr<ModelAPI_ResultBody> ExchangePlugin_ImportFeature::createResultBody(
- std::shared_ptr<GeomAPI_Shape> aGeomShape)
+ std::shared_ptr<GeomAPI_Shape> aGeomShape)
{
std::shared_ptr<ModelAPI_ResultBody> aResultBody = document()->createBody(data());
//LoadNamingDS of the imported shape
// Perform the import
std::string anError;
std::shared_ptr<GeomAPI_Shape> aGeomShape;
-
- std::map< std::wstring, std::list<std::wstring>> theMaterialShape;
-
- std::string anObjectName = GeomAlgoAPI_Tools::File_Tools::name(theFileName);
- data()->setName(Locale::Convert::toWString(anObjectName));
-
- ResultBodyPtr result = document()->createBody(data());
-
- bool anColorGroupSelected = boolean(ExchangePlugin_ImportFeature::STEP_COLORS_ID())->value();
- bool anMaterialsGroupSelected = boolean(ExchangePlugin_ImportFeature::STEP_MATERIALS_ID())->value();
-
if (anExtension == "BREP" || anExtension == "BRP") {
aGeomShape = BREPImport(theFileName, anExtension, anError);
} else if (anExtension == "STEP" || anExtension == "STP") {
- bool anScalInterUnits = boolean(ExchangePlugin_ImportFeature::STEP_SCALE_INTER_UNITS_ID())->value();
-
-
- try{
-
- result->clearShapeNameAndColor();
- // Process groups/fields
- std::shared_ptr<ModelAPI_AttributeRefList> aRefListOfGroups =
- std::dynamic_pointer_cast<ModelAPI_AttributeRefList>(data()->attribute(FEATURES_ID()));
-
- // Remove previous groups/fields stored in RefList
- std::list<ObjectPtr> anGroupList = aRefListOfGroups->list();
- std::list<ObjectPtr>::iterator anGroupIt = anGroupList.begin();
- for (; anGroupIt != anGroupList.end(); ++anGroupIt) {
- std::shared_ptr<ModelAPI_Feature> aFeature = ModelAPI_Feature::feature(*anGroupIt);
- if (aFeature)
- document()->removeFeature(aFeature);
- }
-
- aGeomShape = STEPImportAttributs(theFileName, result, anScalInterUnits,
- anMaterialsGroupSelected, anColorGroupSelected,theMaterialShape,anError);
-
- }
- catch (OSD_Exception& e) {
- //Try to load STEP file without colors...
- aGeomShape = STEPImport(theFileName, anExtension,anScalInterUnits,anError);
- }
+ aGeomShape = STEPImport(theFileName, anExtension, anError);
} else if (anExtension == "IGES" || anExtension == "IGS") {
aGeomShape = IGESImport(theFileName, anExtension, anError);
} else {
}
// Pass the results into the model
+ std::string anObjectName = GeomAlgoAPI_Tools::File_Tools::name(theFileName);
+ data()->setName(Locale::Convert::toWString(anObjectName));
- loadNamingDS(aGeomShape, result);
-
- // create color group
- if (anColorGroupSelected)
- {
- setColorGroups(result);
- }
-
- // create Materiel group
- if (anMaterialsGroupSelected){
- setMaterielGroup(result,theMaterialShape);
- }
-
- setResult(result);
-
-}
-
-void ExchangePlugin_ImportFeature::setColorGroups(std::shared_ptr<ModelAPI_ResultBody> theResultBody)
-{
- std::vector<int> aColor;
- int indice = 1;
- std::list< std::vector<int> > aColorsRead;
-
-
- ModelAPI_Tools::getColor(theResultBody, aColor);
- if (!aColor.empty() ){
- std::wstringstream colorName;
- colorName<<L"Color_"<<indice;
- setColorGroup( theResultBody, aColor, colorName.str());
- indice++;
- aColorsRead.push_back(aColor);
- }
-
- std::list<ResultPtr> allRes;
- ModelAPI_Tools::allSubs(theResultBody, allRes);
- for(std::list<ResultPtr>::iterator aRes = allRes.begin(); aRes != allRes.end(); ++aRes) {
- ModelAPI_Tools::getColor(*aRes, aColor);
- if (!aColor.empty() ){
- auto it = std::find(aColorsRead.begin(), aColorsRead.end(), aColor);
- if ( it == aColorsRead.end() ){
- std::wstringstream colorName;
- colorName<<L"Color_"<<indice;
- setColorGroup( theResultBody, aColor, colorName.str() );
- indice++;
- aColorsRead.push_back(aColor);
- }
- }
- }
-}
-
-void ExchangePlugin_ImportFeature::setColorGroup(std::shared_ptr<ModelAPI_ResultBody> theResultBody,
- std::vector<int> &theColor,
- const std::wstring& theName )
-{
- std::vector<int> aColor;
- std::shared_ptr<ModelAPI_Feature> aGroupFeature = addFeature("Group");
-
- // group name
- aGroupFeature->data()->setName(theName);
-
- // fill selection
- AttributeSelectionListPtr aSelectionList = aGroupFeature->selectionList("group_list");
-
- ModelAPI_Tools::getColor(theResultBody, aColor);
- if (!aColor.empty() ){
- if( aColor == theColor ) {
- GeomShapePtr aShape = theResultBody->shape();
- aSelectionList->setSelectionType(aShape->shapeTypeStr() );
- aSelectionList->append(theResultBody,aShape);
- }
- }
- // add element with the same color
- std::list<ResultPtr> allRes;
- ModelAPI_Tools::allSubs(theResultBody, allRes);
- for(std::list<ResultPtr>::iterator aRes = allRes.begin();
- aRes != allRes.end(); ++aRes) {
- ModelAPI_Tools::getColor(*aRes, aColor);
- GeomShapePtr aShape = (*aRes)->shape();
-
- if (!aColor.empty() ){
- if( aRes->get() && aColor == theColor ) {
- aSelectionList->setSelectionType(aShape->shapeTypeStr() );
- aSelectionList->append(theResultBody,aShape);
- }
- }
- }
-
- if (aSelectionList->size() == 0 ){
- document()->removeFeature(aGroupFeature);
- }
+ setResult(createResultBody(aGeomShape));
}
-void ExchangePlugin_ImportFeature::setMaterielGroup(std::shared_ptr<ModelAPI_ResultBody> theResultBody,
- std::map< std::wstring, std::list<std::wstring>> &theMaterialShape)
-{
- int indice = 1;
- std::map< std::wstring, std::list<std::wstring>>::iterator it;
- for( it = theMaterialShape.begin(); it != theMaterialShape.end(); ++it) {
-
- std::shared_ptr<ModelAPI_Feature> aGroupFeature = addFeature("Group");
- // group name
- aGroupFeature->data()->setName((*it).first);
-
- // fill selection
- AttributeSelectionListPtr aSelectionList = aGroupFeature->selectionList("group_list");
- std::string aSelectionType = "solid" ;
- aSelectionList->setSelectionType(aSelectionType);
- GeomShapePtr aShape = theResultBody->shape();
-
- std::list<ResultPtr> allRes;
- ModelAPI_Tools::allSubs(theResultBody, allRes);
- for(std::list<ResultPtr>::iterator aRes = allRes.begin(); aRes != allRes.end(); ++aRes) {
-
- GeomShapePtr aShape = (*aRes)->shape();
- for(std::list<std::wstring>::iterator aResMat = it->second.begin();
- aResMat != it->second.end(); ++aResMat) {
- if( aRes->get() && ((*aRes)->data()->name() == (*aResMat)))
- {
- aSelectionList->append(theResultBody,aShape);
- break;
- }
- }
- }
- if (aSelectionList->size() == 0){
- document()->removeFeature(aGroupFeature);
- }
- }
-}
-
-
-
void ExchangePlugin_ImportFeature::importXAO(const std::string& theFileName)
{
try {
{
//load result
theResultBody->store(theGeomShape);
+
std::string aNameMS = "Shape";
theResultBody->loadFirstLevel(theGeomShape, aNameMS);
}
#include <ModelAPI_CompositeFeature.h>
#include <ModelAPI_Result.h>
-#include <GeomAPI_Shape.h>
#include <map>
static const std::string MY_IMPORT_ID("Import");
return MY_IMPORT_ID;
}
- /// Feature kind
- inline static const std::string& IMPORT_TYPE_ID()
- {
- static const std::string MY_IMPORT_TYPE_ID("ImportType");
- return MY_IMPORT_TYPE_ID;
- }
/// attribute name of file path
inline static const std::string& FILE_PATH_ID()
{
static const std::string MY_FILE_PATH_ID("file_path");
return MY_FILE_PATH_ID;
}
- /// attribute name of file path
- inline static const std::string& STEP_FILE_PATH_ID()
- {
- static const std::string MY_STEP_FILE_PATH_ID("step_file_path");
- return MY_STEP_FILE_PATH_ID;
- }
/// All features (list of references)
inline static const std::string& FEATURES_ID()
{
static const std::string MY_FEATURES_ID("Features");
return MY_FEATURES_ID;
}
- /// attribute name of step Scale to International System Units
- inline static const std::string& STEP_SCALE_INTER_UNITS_ID()
- {
- static const std::string MY_STEP_SCALE_INTER_UNITS_ID("step_scale_inter_units");
- return MY_STEP_SCALE_INTER_UNITS_ID;
- }
- /// attribute name of step materiels
- inline static const std::string& STEP_MATERIALS_ID()
- {
- static const std::string MY_STEP_MATERIALS_ID("step_materials");
- return MY_STEP_MATERIALS_ID;
- }
- /// attribute name of step colors
- inline static const std::string& STEP_COLORS_ID()
- {
- static const std::string MY_STEP_COLORS_ID("step_colours");
- return MY_STEP_COLORS_ID;
- }
/// Default constructor
EXCHANGEPLUGIN_EXPORT ExchangePlugin_ImportFeature();
/// Default destructor
/// Loads Naming data structure to the document
void loadNamingDS(std::shared_ptr<GeomAPI_Shape> theGeomShape,
std::shared_ptr<ModelAPI_ResultBody> theResultBody);
-
- // Set groups of color
- void setColorGroups(std::shared_ptr<ModelAPI_ResultBody> theResultBody);
-
- // set a group of color
- void setColorGroup(std::shared_ptr<ModelAPI_ResultBody> theResultBody,
- std::vector<int> &aColor,
- const std::wstring& theName );
-
- // set Materiel group of color
- void setMaterielGroup(std::shared_ptr<ModelAPI_ResultBody> theResultBody,
- std::map< std::wstring, std::list<std::wstring>> &theMaterialShape);
-
};
#endif /* IMPORT_IMPORTFEATURE_H_ */
<source>XAO</source>
<translation>XAO</translation>
</message>
- <message>
- <source>STL</source>
- <translation>STL</translation>
- </message>
</context>
<context>
<name>Export:file_path</name>
<translation>Veuillez saisir le nom de la géométrie</translation>
</message>
</context>
- <context>
- <name>Export:stl_file_path</name>
- <message>
- <source>Export file</source>
- <translation>Fichier d'export</translation>
- </message>
- </context>
- <context>
- <name>Export:stl_file_path:ExchangePlugin_ExportFormat</name>
- <message>
- <source>%1 is not initialized.</source>
- <translation>%1 n'est pas initialisé.</translation>
- </message>
- <message>
- <source>File name is empty.</source>
- <translation>Le nom du fichier est vide.</translation>
- </message>
- </context>
- <context>
- <name>Export:stl_object_selected</name>
- <message>
- <source>Object</source>
- <translation>Objet</translation>
- </message>
- <message>
- <source>Object to export.</source>
- <translation>Objet à exporter.</translation>
- </message>
- </context>
- <context>
- <name>Export:stl_file_type</name>
- <message>
- <source>File type</source>
- <translation>type du fichier</translation>
- </message>
- <message>
- <source>Binary</source>
- <translation>Binaire</translation>
- </message>
- <message>
- <source>ASCII</source>
- <translation>ASCII</translation>
- </message>
- </context>
- <context>
- <name>Export:Deflection</name>
- <message>
- <source>Deflection</source>
- <translation>Déflection</translation>
- </message>
- <message>
- <source>Relative</source>
- <translation>Relative</translation>
- </message>
- <message>
- <source>Relative value.</source>
- <translation>Valeur relative</translation>
- </message>
- <message>
- <source>Calculate by size of shape</source>
- <translation>Calcul par rapport à la taille de la shape</translation>
- </message>
- <message>
- <source>Absolute</source>
- <translation>Absolue</translation>
- </message>
- <message>
- <source>Value indicate by user</source>
- <translation>Valeur indiquée par l'utilisateur</translation>
- </message>
- <message>
- <source>Absolute value.</source>
- <translation>Valeur absolue.</translation>
- </message>
- </context>
<!-- Import -->
<context>
placeholder="Please input the geometry name">
</stringvalue>
</case>
- <case id="STL" title="STL">
- <export_file_selector id="stl_file_path"
- type="save"
- title="Export file"
- path="">
- <validator id="ExchangePlugin_ExportFormat"
- parameters="stl:STL" />
- </export_file_selector>
- <shape_selector id="stl_object_selected"
- label="Object"
- tooltip="Object to export."
- shape_types="vertices edges wires faces shells solids compsolids compounds">
- <validator id="GeomValidators_Finite"/>
- </shape_selector>
- <groupbox title="Deflection">
- <radiobox id="stl_deflection_type">
- <radio id="stl_deflection_type_relative"
- title="Relative"
- tooltip="Calculate by size of shape">
- <doublevalue id="stl_relative"
- tooltip="Relative value."
- min="0.0"
- step="0.001"
- default="0.001">
- </doublevalue>
- </radio>
- <radio id="stl_deflection_type_absolute"
- title="Absolute"
- tooltip="Value indicate by user">
- <doublevalue id="stl_absolute"
- tooltip="Absolute value."
- min="0.0"
- max="1.0"
- step="0.1"
- default="0.5">
- </doublevalue>
- </radio>
- </radiobox>
- </groupbox >
- <groupbox title="File type">
- <radiobox id="stl_file_type">
- <radio id="stl_file_type_binary"
- title="Binary">
- </radio>
- <radio id="stl_file_type_acii"
- title="ASCII">
- </radio>
- </radiobox>
- </groupbox >
- <!--stringvalue id="xao_author"
- label="Author"
- placeholder="Please input the author">
- </stringvalue>
- <stringvalue id="xao_geometry_name"
- label="Geometry name"
- placeholder="Please input the geometry name">
- </stringvalue-->
- </case>
</switch>
</source>
<feature id="ImportMacro" title="Import" tooltip="Import a file" icon="icons/Exchange/import.png"
helpfile="importFeature.html"
internal="1">
- <switch id="ImportType">
- <case id="Regular" title="BREP, XAO, IGES">
- <file_selector id="file_path" title="Import file" path="">
- <validator id="ExchangePlugin_ImportFormat" parameters="BREP|BRP:BREP,IGES|IGS:IGES,XAO:XAO" />
- </file_selector>
+ <file_selector id="file_path" title="Import file" path="">
+ <validator id="ExchangePlugin_ImportFormat" parameters="BREP|BRP:BREP,STEP|STP:STEP,IGES|IGS:IGES,XAO:XAO" />
+ </file_selector>
<choice id="target_part"
string_list_attribute="target_parts_list"
label="Import to"
tooltip="Select the part to import the document" />
- </case>
- <case id="STEP" title="STEP">
- <file_selector id="step_file_path" title="Import file" path="">
- <validator id="ExchangePlugin_ImportFormat" parameters="STEP|STP:STEP" />
- </file_selector>
- <choice id="step_target_part"
- string_list_attribute="step_target_parts_list"
- label="Import to"
- tooltip="Select the part to import the document" />
- <groupbox title="STEP options">
- <boolvalue id="step_scale_inter_units"
- label="Scale to International System of Units"
- default="true"/>
- <groupbox title="Create groups from">
- <boolvalue id="step_materials"
- label="Materials"
- default="false"/>
- <boolvalue id="step_colours"
- label="Colours"
- default="false"/>
- </groupbox>
- </groupbox>
- </case>
- </switch>
</feature>
<feature id="Import" title="Import" tooltip="Import a file" icon="icons/Exchange/import.png"
helpfile="importFeature.html" internal="1">
- <!--file_selector id="file_path" title="Import file" path="">
+ <file_selector id="file_path" title="Import file" path="">
<validator id="ExchangePlugin_ImportFormat" parameters="BREP|BRP:BREP,STEP|STP:STEP,IGES|IGS:IGES,XAO:XAO" />
- </file_selector-->
- <switch id="ImportType">
- <case id="Regular" title="BREP, XAO, IGES">
- <file_selector id="file_path" title="Import file" path="">
- <validator id="ExchangePlugin_ImportFormat" parameters="BREP|BRP:BREP,IGES|IGS:IGES,XAO:XAO" />
- </file_selector>
- </case>
- <case id="STEP" title="STEP">
- <file_selector id="step_file_path" title="Import file" path="">
- <validator id="ExchangePlugin_ImportFormat" parameters="STEP|STP:STEP" />
- </file_selector>
- <groupbox title="STEP options">
- <boolvalue id="step_scale_inter_units"
- label="Scale to International System of Units"
- default="true"/>
- <groupbox title="Create groups from">
- <boolvalue id="step_materials"
- label="Materials"
- default="false"/>
- <boolvalue id="step_colours"
- label="Colours"
- default="false"/>
- </groupbox>
- </groupbox>
- </case>
- </switch>
+ </file_selector>
</feature>
<feature id="Export" title="Export" tooltip="Export to file" icon="icons/Exchange/export.png"
helpfile="exportFeature.html" internal="1">
GeomAlgoAPI_Placement.h
GeomAlgoAPI_BREPImport.h
GeomAlgoAPI_STEPImport.h
- GeomAlgoAPI_STEPImportXCAF.h
GeomAlgoAPI_IGESImport.h
GeomAlgoAPI_BREPExport.h
GeomAlgoAPI_STEPExport.h
- GeomAlgoAPI_STLExport.h
GeomAlgoAPI_IGESExport.h
GeomAlgoAPI_Transform.h
GeomAlgoAPI_ShapeTools.h
GeomAlgoAPI_Placement.cpp
GeomAlgoAPI_BREPImport.cpp
GeomAlgoAPI_STEPImport.cpp
- GeomAlgoAPI_STEPImportXCAF.cpp
GeomAlgoAPI_IGESImport.cpp
GeomAlgoAPI_BREPExport.cpp
GeomAlgoAPI_STEPExport.cpp
- GeomAlgoAPI_STLExport.cpp
GeomAlgoAPI_IGESExport.cpp
GeomAlgoAPI_Transform.cpp
GeomAlgoAPI_ShapeTools.cpp
../GeomAlgoImpl
../ModelAPI
../XAO
- ${PROJECT_SOURCE_DIR}/src/Locale
${OpenCASCADE_INCLUDE_DIR}
)
#include <TopTools_IndexedMapOfShape.hxx>
#include <TopoDS_Compound.hxx>
#include <TopoDS_Iterator.hxx>
+#include <TopoDS_Shape.hxx>
-#include <XCAFApp_Application.hxx>
-#include <XCAFDoc_DocumentTool.hxx>
-#include <OSD_Exception.hxx>
-#include <STEPCAFControl_Reader.hxx>
-#include <TDocStd_Document.hxx>
-#include <XCAFDoc_ColorTool.hxx>
-#include <XCAFDoc_ShapeTool.hxx>
-#include <GeomAlgoAPI_STEPImportXCAF.h>
-#include <Quantity_Color.hxx>
#include <TColStd_SequenceOfAsciiString.hxx>
-#include <TCollection_ExtendedString.hxx>
#include <Standard_Failure.hxx>
#include <Standard_ErrorHandler.hxx> // CAREFUL ! position of this file is critic : see Lucien PIGNOLONI / OCC
-
-// ----------------------------------------------------------------------------
-
std::shared_ptr<GeomAPI_Shape> STEPImport(const std::string& theFileName,
const std::string& theFormatName,
- const bool anScalInterUnits,
std::string& theError)
{
-
TopoDS_Shape aResShape;
// Set "C" numeric locale to save numbers correctly
// Kernel_Utils::Localizer loc;
-
+
STEPControl_Reader aReader;
//VSR: 16/09/09: Convert to METERS
if (status == IFSelect_RetDone) {
// Regard or not the model units
- if (!anScalInterUnits) {
+ if (theFormatName == "STEP_SCALE") {
// set UnitFlag to units from file
TColStd_SequenceOfAsciiString anUnitLengthNames;
TColStd_SequenceOfAsciiString anUnitAngleNames;
aGeomShape->setImpl(new TopoDS_Shape(aResShape));
return aGeomShape;
}
-
-
-std::shared_ptr<GeomAPI_Shape> STEPImportAttributs(const std::string& theFileName,
- std::shared_ptr<ModelAPI_ResultBody> theResultBody,
- const bool anScalInterUnits,
- const bool anMaterials,
- const bool anColor,
- std::map< std::wstring, std::list<std::wstring>> &theMaterialShape,
- std::string& theError)
-{
-
- STEPControl_Reader aReader;
- std::shared_ptr<GeomAPI_Shape> aGeomShape(new GeomAPI_Shape);
- //VSR: 16/09/09: Convert to METERS
- Interface_Static::SetCVal("xstep.cascade.unit","M");
- Interface_Static::SetIVal("read.step.ideas", 1);
- Interface_Static::SetIVal("read.step.nonmanifold", 1);
-
- try {
- OCC_CATCH_SIGNALS;
-
- IFSelect_ReturnStatus status = aReader.ReadFile(theFileName.c_str());
-
- if (status == IFSelect_RetDone) {
-
- // Regard or not the model units
- if (!anScalInterUnits) {
- // set UnitFlag to units from file
- TColStd_SequenceOfAsciiString anUnitLengthNames;
- TColStd_SequenceOfAsciiString anUnitAngleNames;
- TColStd_SequenceOfAsciiString anUnitSolidAngleNames;
- aReader.FileUnits(anUnitLengthNames, anUnitAngleNames, anUnitSolidAngleNames);
- if (anUnitLengthNames.Length() > 0) {
- TCollection_AsciiString aLenUnits = anUnitLengthNames.First();
- if (aLenUnits == "millimetre")
- Interface_Static::SetCVal("xstep.cascade.unit", "MM");
- else if (aLenUnits == "centimetre")
- Interface_Static::SetCVal("xstep.cascade.unit", "CM");
- else if (aLenUnits == "metre" || aLenUnits.IsEmpty())
- Interface_Static::SetCVal("xstep.cascade.unit", "M");
- else if (aLenUnits == "INCH")
- Interface_Static::SetCVal("xstep.cascade.unit", "INCH");
- else {
- theError = "The file contains not supported units.";
- aGeomShape->setImpl(new TopoDS_Shape());
- return aGeomShape;
- }
- // TODO (for other units than mm, cm, m or inch)
- //else if (aLenUnits == "")
- // Interface_Static::SetCVal("xstep.cascade.unit", "???");
- }
- }
- else {
- //cout<<"need re-scale a model"<<endl;
- // set UnitFlag to 'meter'
- Interface_Static::SetCVal("xstep.cascade.unit","M");
- }
- }
- }
- catch (Standard_Failure const& anException) {
- theError = anException.GetMessageString();
- aGeomShape->setImpl(new TopoDS_Shape());
- return aGeomShape;
- }
-
- STEPCAFControl_Reader cafreader;
- cafreader.SetColorMode(true);
- cafreader.SetNameMode(true);
- cafreader.SetMatMode(true);
-
- if(cafreader.ReadFile(theFileName.c_str()) != IFSelect_RetDone) {
- theError = "Wrong format of the imported file. Can't import file.";
- std::shared_ptr<GeomAPI_Shape> aGeomShape(new GeomAPI_Shape);
- aGeomShape->setImpl(new TopoDS_Shape());
- return aGeomShape;
- }
-
- return readAttributes(cafreader,theResultBody,anMaterials, theMaterialShape, "STEP-XCAF");
- }
-
#include <GeomAlgoAPI.h>
#include <string>
-#include <GeomAPI_Shape.h>
-
-#include <ModelAPI_ResultBody.h>
+#include <GeomAPI_Shape.h>
/// Implementation of the import STEP files algorithms
GEOMALGOAPI_EXPORT
std::shared_ptr<GeomAPI_Shape> STEPImport(const std::string& theFileName,
const std::string& theFormatName,
- const bool anScalInterUnits,
std::string& theError);
-/// Implementation of the import STEP files algorithms with Attributs (Name, Color, Materials)
-GEOMALGOAPI_EXPORT
-std::shared_ptr<GeomAPI_Shape> STEPImportAttributs(const std::string& theFileName,
- std::shared_ptr<ModelAPI_ResultBody> theResultBody,
- const bool anScalInterUnits,
- const bool anMaterials,
- const bool anColor,
- std::map< std::wstring, std::list<std::wstring>> &theMaterialShape,
- std::string& theError);
-
#endif /* GEOMALGOAPI_STEPIMPORT_H_ */
#define MAX3(X, Y, Z) ( MAX2 ( MAX2(X, Y) , Z ) )
bool STLExport(const std::string& theFileName,
- const std::string& /*theFormatName*/,
- const std::shared_ptr<GeomAPI_Shape>& theShape,
- const double aDeflection,
- const bool anIsRelative,
- const bool anIsASCII,
- std::string& theError)
+ const std::shared_ptr<GeomAPI_Shape>& theShape,
+ const double theDeflection,
+ const bool theIsRelative,
+ const bool theIsASCII,
+ std::string& theError)
{
#ifdef _DEBUG
std::cout << "Export STl into file " << theFileName << std::endl;
try
{
- // Set "C" numeric locale to save numbers correctly
- GeomAlgoAPI_Tools::Localizer loc;
- double lDeflection = aDeflection;
+ double lDeflection = theDeflection;
StlAPI_Writer aWriter;
// copy source shape
BRepBuilderAPI_Copy aCopy( theShape->impl<TopoDS_Shape>(), Standard_False );
TopoDS_Shape aCopyShape = aCopy.Shape();
// ASCII mode
- aWriter.ASCIIMode() = anIsASCII;
- if ( anIsRelative ) {
+ aWriter.ASCIIMode() = theIsASCII;
+ if ( theIsRelative ) {
Standard_Real aXmin, aYmin, aZmin, aXmax, aYmax, aZmax;
Bnd_Box bndBox;
BRepBndLib::Add( theShape->impl<TopoDS_Shape>(), bndBox );
bndBox.Get( aXmin, aYmin, aZmin, aXmax, aYmax, aZmax );
- lDeflection = MAX3( aXmax-aXmin, aYmax-aYmin, aZmax-aZmin ) * aDeflection;
+ lDeflection = MAX3( aXmax-aXmin, aYmax-aYmin, aZmax-aZmin ) * theDeflection;
}
//Compute triangulation
- BRepTools::Clean( aCopyShape );
BRepMesh_IncrementalMesh aMesh( aCopyShape, lDeflection );
- aWriter.Write( aCopyShape, theFileName.c_str() );
-
+ if (!aWriter.Write( aCopyShape, theFileName.c_str())) {
+ theError = "STL Export failed";
+ return false;
+ }
return true;
}
catch( Standard_Failure )
/// Implementation of the export STL files algorithms
GEOMALGOAPI_EXPORT
bool STLExport(const std::string& theFileName,
- const std::string& /*theFormatName*/,
- const std::shared_ptr<GeomAPI_Shape>& theShape,
- const double aDeflection,
- const bool anIsRelative,
- const bool anIsASCII,
- std::string& theError);
+ const std::shared_ptr<GeomAPI_Shape>& theShape,
+ const double theDeflection,
+ const bool theIsRelative,
+ const bool theIsASCII,
+ std::string& theError);
#endif /* GEOMALGOAPI_STLEXPORT_H_ */
void Model_Objects::storeResult(std::shared_ptr<ModelAPI_Data> theFeatureData,
std::shared_ptr<ModelAPI_Result> theResult,
- const int theResultIndex,
- const std::wstring& theNameShape)
+ const int theResultIndex)
{
theResult->init();
theResult->setDoc(myDoc);
theResult->data()->setName(L"");
} else {
std::wstringstream aName;
- if( theNameShape != L"" ){
- aName << theNameShape;
- }else{
- aName << aNewName;
- // if there are several results (issue #899: any number of result),
- // add unique prefix starting from second
- if (theResultIndex > 0 || theResult->groupName() == ModelAPI_ResultBody::group())
- aName << "_" << theResultIndex + 1;
- }
+ aName << aNewName;
+ // if there are several results (issue #899: any number of result),
+ // add unique prefix starting from second
+ if (theResultIndex > 0 || theResult->groupName() == ModelAPI_ResultBody::group())
+ aName << "_" << theResultIndex + 1;
aNewName = aName.str();
}
theResult->data()->setName(aNewName);
}
std::shared_ptr<ModelAPI_ResultBody> Model_Objects::createBody(
- const std::shared_ptr<ModelAPI_Data>& theFeatureData, const int theIndex,const std::wstring& theNameShape )
+ const std::shared_ptr<ModelAPI_Data>& theFeatureData, const int theIndex)
{
TDF_Label aLab = resultLabel(theFeatureData, theIndex);
TDataStd_Comment::Set(aLab, ModelAPI_ResultBody::group().c_str());
}
if (!aResult.get()) {
aResult = std::shared_ptr<ModelAPI_ResultBody>(new Model_ResultBody);
- storeResult(theFeatureData, aResult, theIndex,theNameShape);
+ storeResult(theFeatureData, aResult, theIndex);
}
return aResult;
}
const std::shared_ptr<ModelAPI_Data>& theFeatureData, const int theIndex = 0);
/// Creates a body result
std::shared_ptr<ModelAPI_ResultBody> createBody(
- const std::shared_ptr<ModelAPI_Data>& theFeatureData, const int theIndex = 0,
- const std::wstring& theNameShape = L"");
+ const std::shared_ptr<ModelAPI_Data>& theFeatureData, const int theIndex = 0);
/// Creates a part result
std::shared_ptr<ModelAPI_ResultPart> createPart(
const std::shared_ptr<ModelAPI_Data>& theFeatureData, const int theIndex = 0);
//! Initializes the data fields of the feature
void initData(ObjectPtr theObj, TDF_Label theLab, const int theTag);
-
- //! Allows to store the result in the data tree of the document
+
+ //! Allows to store the result in the data tree of the document
//! (attaches 'data' of result to tree)
void storeResult(std::shared_ptr<ModelAPI_Data> theFeatureData,
std::shared_ptr<ModelAPI_Result> theResult,
- const int theResultIndex = 0,
- const std::wstring& theNameShape = L"");
+ const int theResultIndex = 0);
//! returns the label of result by index; creates this label if it was not created before
TDF_Label resultLabel(const std::shared_ptr<ModelAPI_Data>& theFeatureData,
#include <Events_Loop.h>
#include <GeomAPI_ShapeIterator.h>
#include <GeomAPI_ShapeExplorer.h>
-#include <GeomAPI_Face.h>
-#include <GeomAPI_Pnt.h>
#include <TopoDS_Shape.hxx>
#include <TopExp_Explorer.hxx>
}
}
-void Model_ResultBody::addShapeColor( const std::wstring& theName,std::vector<int>& color) {
-
- if( myColorsShape.find(theName) == myColorsShape.end())
- myColorsShape[ theName ] = color;
-}
-
-std::wstring Model_ResultBody::addShapeName(std::shared_ptr<GeomAPI_Shape> theshape,const std::wstring& theName ){
-
- int indice = 1;
- std::wstringstream aName;
- aName << theName;
- while(myNamesShape.find(aName.str()) != myNamesShape.end() ){
- aName.str(L"");
- aName << theName << L"__" << indice;
- indice++;
- }
- myNamesShape[ aName.str() ] = theshape;
-
- return aName.str();
-}
-
-std::wstring Model_ResultBody::findShapeName(std::shared_ptr<GeomAPI_Shape> theshape){
-
- TopoDS_Shape aShape = theshape->impl<TopoDS_Shape>();
- for (std::map< std::wstring, std::shared_ptr<GeomAPI_Shape> >::iterator it = myNamesShape.begin();
- it != myNamesShape.end();
- ++it)
- {
- TopoDS_Shape curSelectedShape = (*it).second->impl<TopoDS_Shape>();
- if( (aShape.IsSame(curSelectedShape))) {
- return (*it).first;
- }
-
- }
- return L"material not found" ;
-}
-
-
-void Model_ResultBody::setShapeName(std::map< std::wstring, std::shared_ptr<GeomAPI_Shape> > &theshapename,
- std::map< std::wstring, std::vector<int>> & theColorsShape)
-{
- myNamesShape = theshapename;
- myColorsShape = theColorsShape;
-}
-void Model_ResultBody::clearShapeNameAndColor(){
- myNamesShape.clear();
- myColorsShape.clear();
-}
void Model_ResultBody::updateSubs(const std::shared_ptr<GeomAPI_Shape>& theThisShape,
const bool theShapeChanged)
{
aShape->setImpl(new TopoDS_Shape(aShapesIter.Value()));
ResultBodyPtr aSub;
if (mySubs.size() <= aSubIndex) { // it is needed to create a new sub-result
- std::wstring thenameshape = L"";
- // find shape name read
- for (std::map< std::wstring, std::shared_ptr<GeomAPI_Shape> >::iterator it = myNamesShape.begin();
- it != myNamesShape.end();
- ++it)
- {
- TopoDS_Shape curSelectedShape = (*it).second->impl<TopoDS_Shape>();
- if( !(aShapesIter.Value().IsSame(curSelectedShape))) continue;
- thenameshape = (*it).first;
- break;
- }
- aSub = anObjects->createBody(this->data(), aSubIndex,thenameshape);
- //finf color read
- std::map< std::wstring, std::vector<int>>::iterator itColor = myColorsShape.find(thenameshape);
- if(itColor != myColorsShape.end()){
- ModelAPI_Tools::setColor(aSub,(*itColor).second);
- }
- aSub->setShapeName(myNamesShape,myColorsShape);
+ aSub = anObjects->createBody(this->data(), aSubIndex);
mySubs.push_back(aSub);
mySubsMap[aSub] = int(mySubs.size() - 1);
if (isConcealed()) { // for issue #2579 note7
aSub->ModelAPI_ResultBody::setIsConcealed(true);
std::dynamic_pointer_cast<Model_ResultBody>(aSub)->updateConcealment();
}
-
} else { // just update shape of this result
aSub = mySubs[aSubIndex];
}
/// Makes a body on the given feature
Model_ResultBody();
-/// Updates the sub-bodies if shape of this object is composite-solid
+ /// Updates the sub-bodies if shape of this object is composite-solid
void updateSubs(const std::shared_ptr<GeomAPI_Shape>& theThisShape,
const bool theShapeChanged = true);
const std::list<GeomShapePtr>& theAllOlds, std::list<GeomShapePtr>& theOldForSub);
friend class Model_Objects;
-
- // Add shape Name for read shape in step file
- std::wstring addShapeName(std::shared_ptr<GeomAPI_Shape>,const std::wstring& theName) override;
- // Add color for shape Name read shape in step file
- void addShapeColor( const std::wstring& theName,std::vector<int>& color) override;
- // Set the map of name and color read shape in step file
- void setShapeName(std::map< std::wstring, std::shared_ptr<GeomAPI_Shape> > &theshapename,std::map< std::wstring, std::vector<int>> & theColorsShape) override;
- // find the name of shapp read in step file
- std::wstring findShapeName(std::shared_ptr<GeomAPI_Shape> theshape) override;
- // Clear the map of name and color read shape in step file
- void clearShapeNameAndColor() override;
-
- // map with the name read in step file and shape
- std::map< std::wstring, std::shared_ptr<GeomAPI_Shape> > myNamesShape;
- // map with the name contruct and color read
- std::map< std::wstring, std::vector<int>> myColorsShape;
-
};
#endif
{
return data()->intArray(theID);
}
- /// Returns the double array attribute by the identifier
- inline std::shared_ptr<ModelAPI_AttributeDoubleArray> realArray(const std::string& theID)
- {
- return data()->realArray(theID);
- }
/// Returns the reference attribute by the identifier
inline std::shared_ptr<ModelAPI_AttributeRefAttr> refattr(const std::string& theID)
{
#include <GeomAPI_Shape.h>
#include <GeomAPI_DataMapOfShapeShape.h>
#include <string>
-#include <map>
-#include <vector>
class ModelAPI_BodyBuilder;
class GeomAlgoAPI_MakeShape;
/// Cleans cash related to the already stored elements
MODELAPI_EXPORT virtual void cleanCash() = 0;
-
- // Add shape Name for read shape in step file
- MODELAPI_EXPORT virtual std::wstring addShapeName(std::shared_ptr<GeomAPI_Shape>,const std::wstring& theName) = 0;
- // Add color for shape Name read shape in step file
- MODELAPI_EXPORT virtual void addShapeColor(const std::wstring& theName,std::vector<int>& color) = 0;
- // Set the map of name and color read shape in step file
- MODELAPI_EXPORT virtual void setShapeName(std::map< std::wstring, std::shared_ptr<GeomAPI_Shape> > &theshapename,
- std::map< std::wstring, std::vector<int>> & theColorsShape) = 0;
- // Clear the map of name and color read shape in step file
- MODELAPI_EXPORT virtual void clearShapeNameAndColor() = 0;
- // find the name of shapp read in step file
- MODELAPI_EXPORT virtual std::wstring findShapeName(std::shared_ptr<GeomAPI_Shape> theshape) = 0;
-
protected:
/// Default constructor accessible only from Model_Objects
MODELAPI_EXPORT ModelAPI_ResultBody();
-
-
};
//! Pointer on feature object
"""Package for Exchange plugin for the Parametric Geometry API of the Modeler.
"""
-from ExchangeAPI import addImport, addImportStep, exportToFile, exportToXAO, exportToSTL
+from ExchangeAPI import addImport, exportToFile, exportToXAO
from ExchangeAPI import exportPart, importPart
from .tools import *
