X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FExchangePlugin%2FExchangePlugin_ImportFeature.cpp;h=91c6c188a00d5b18321ebabc99022ef2a647b93e;hb=3249432a177b03e697bc0cf42253bfe5bfb326f6;hp=0b1c6cb95a31e86f889fb5e4dd5041274ab4d96b;hpb=1dfcab3d738e427bea678317e167c587dfbff195;p=modules%2Fshaper.git diff --git a/src/ExchangePlugin/ExchangePlugin_ImportFeature.cpp b/src/ExchangePlugin/ExchangePlugin_ImportFeature.cpp index 0b1c6cb95..91c6c188a 100644 --- a/src/ExchangePlugin/ExchangePlugin_ImportFeature.cpp +++ b/src/ExchangePlugin/ExchangePlugin_ImportFeature.cpp @@ -1,4 +1,4 @@ -// Copyright (C) 2014-2020 CEA/DEN, EDF R&D +// Copyright (C) 2014-2022 CEA/DEN, EDF R&D // // This library is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public @@ -30,16 +30,25 @@ #include #include #include +#include +#include #include +#include #include +#include + +#include #include #include #include #include #include +#include #include +#include +#include #include #include #include @@ -49,6 +58,7 @@ #include #include #include +#include #include #include @@ -57,37 +67,59 @@ #include -ExchangePlugin_ImportFeature::ExchangePlugin_ImportFeature() -{ -} - -ExchangePlugin_ImportFeature::~ExchangePlugin_ImportFeature() -{ - // TODO Auto-generated destructor stub -} +#include /* * Request for initialization of data model of the feature: adding all attributes */ -void ExchangePlugin_ImportFeature::initAttributes() +void ExchangePlugin_ImportFeatureBase::initAttributes() { - data()->addAttribute(ExchangePlugin_ImportFeature::FILE_PATH_ID(), + data()->addAttribute(ExchangePlugin_ImportFeatureBase::FILE_PATH_ID(), ModelAPI_AttributeString::typeId()); AttributePtr aFeaturesAttribute = - data()->addAttribute(ExchangePlugin_ImportFeature::FEATURES_ID(), + data()->addAttribute(ExchangePlugin_ImportFeatureBase::FEATURES_ID(), ModelAPI_AttributeRefList::typeId()); aFeaturesAttribute->setIsArgument(false); ModelAPI_Session::get()->validators()->registerNotObligatory( - getKind(), ExchangePlugin_ImportFeature::FEATURES_ID()); + getKind(), ExchangePlugin_ImportFeatureBase::FEATURES_ID()); } +void ExchangePlugin_ImportFeature::initAttributes() +{ + ExchangePlugin_ImportFeatureBase::initAttributes(); + + 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()); + + ModelAPI_Session::get()->validators()->registerNotObligatory( + getKind(), ExchangePlugin_ImportFeature::STEP_COLORS_ID()); + ModelAPI_Session::get()->validators()->registerNotObligatory( + getKind(), ExchangePlugin_ImportFeature::STEP_MATERIALS_ID()); + ModelAPI_Session::get()->validators()->registerNotObligatory( + getKind(), ExchangePlugin_ImportFeature::STEP_SCALE_INTER_UNITS_ID()); + ModelAPI_Session::get()->validators()->registerNotObligatory( + getKind(), ExchangePlugin_ImportFeature::STEP_FILE_PATH_ID()); + ModelAPI_Session::get()->validators()->registerNotObligatory( + getKind(), ExchangePlugin_ImportFeature::FILE_PATH_ID()); +} /* * Computes or recomputes the results */ void ExchangePlugin_ImportFeature::execute() { - AttributeStringPtr aFilePathAttr = string(ExchangePlugin_ImportFeature::FILE_PATH_ID()); + 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()); + } std::string aFilePath = aFilePathAttr->value(); if (aFilePath.empty()) { setError("File path is empty."); @@ -97,7 +129,18 @@ void ExchangePlugin_ImportFeature::execute() importFile(aFilePath); } -std::shared_ptr ExchangePlugin_ImportFeature::createResultBody( +void ExchangePlugin_Import_ImageFeature::execute() +{ + AttributeStringPtr aFilePathAttr = string(ExchangePlugin_Import_ImageFeature::FILE_PATH_ID()); + std::string aFilePath = aFilePathAttr->value(); + if (aFilePath.empty()) { + setError("File path is empty."); + return; + } + importFile(aFilePath); +} + +std::shared_ptr ExchangePlugin_ImportFeatureBase::createResultBody( std::shared_ptr aGeomShape) { std::shared_ptr aResultBody = document()->createBody(data()); @@ -119,13 +162,40 @@ void ExchangePlugin_ImportFeature::importFile(const std::string& theFileName) // Perform the import std::string anError; std::shared_ptr aGeomShape; + std::map> theMaterialShape; + + std::string anObjectName = GeomAlgoAPI_Tools::File_Tools::name(theFileName); + data()->setName(Locale::Convert::toWString(anObjectName)); + + ResultBodyPtr aResult = document()->createBody(data()); + bool anColorGroupSelected = false, anMaterialsGroupSelected = false; if (anExtension == "BREP" || anExtension == "BRP") { aGeomShape = BREPImport(theFileName, anExtension, anError); } else if (anExtension == "STEP" || anExtension == "STP") { - aGeomShape = STEPImport(theFileName, anExtension, anError); + bool anScalInterUnits = boolean(STEP_SCALE_INTER_UNITS_ID())->value(); + anColorGroupSelected = boolean(STEP_COLORS_ID())->value(); + anMaterialsGroupSelected = boolean(STEP_MATERIALS_ID())->value(); + + // Process groups/fields + AttributeRefListPtr aRefListOfGroups = reflist(FEATURES_ID()); + + // Remove previous groups/fields stored in RefList + std::list anGroupList = aRefListOfGroups->list(); + std::list::iterator anGroupIt = anGroupList.begin(); + for (; anGroupIt != anGroupList.end(); ++anGroupIt) { + std::shared_ptr aFeature = ModelAPI_Feature::feature(*anGroupIt); + if (aFeature) + document()->removeFeature(aFeature); + } + + aGeomShape = STEPImportAttributs(theFileName, aResult, anScalInterUnits, + anMaterialsGroupSelected, anColorGroupSelected, + theMaterialShape, anError); } else if (anExtension == "IGES" || anExtension == "IGS") { aGeomShape = IGESImport(theFileName, anExtension, anError); - } else { + } else if (anExtension == "STL") { + aGeomShape = STLImport(theFileName, anError); + } else { anError = "Unsupported format: " + anExtension; } @@ -136,10 +206,155 @@ void ExchangePlugin_ImportFeature::importFile(const std::string& theFileName) } // Pass the results into the model - std::string anObjectName = GeomAlgoAPI_Tools::File_Tools::name(theFileName); - data()->setName(anObjectName); + loadNamingDS(aGeomShape, aResult); + + // create color group + if (anColorGroupSelected) + { + setColorGroups(aResult); + } + + // create Materiel group + if (anMaterialsGroupSelected){ + setMaterielGroup(aResult,theMaterialShape); + } + + setResult(aResult); + aResult->clearShapeNameAndColor(); + +} + +void ExchangePlugin_ImportFeature::setColorGroups( + std::shared_ptr theResultBody) +{ + std::vector aColor; + int anIndice = 1; + std::list> aColorsRead; + + ModelAPI_Tools::getColor(theResultBody, aColor); + if (!aColor.empty() ){ + std::wstringstream aColorName; + aColorName < allRes; + ModelAPI_Tools::allSubs(theResultBody, allRes); + for(std::list::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 aColorName; + aColorName< theResultBody, + std::vector &theColor, + const std::wstring& theName ) +{ + std::vector aColor; + std::shared_ptr 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 allRes; + ModelAPI_Tools::allSubs(theResultBody, allRes); + for(std::list::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) { + if (aShape->isCompound() || aShape->isCompSolid()) { + GeomAPI_ShapeIterator anIt(aShape); + for (; anIt.more(); anIt.next()) { + aSelectionList->setSelectionType(anIt.current()->shapeTypeStr()); + aSelectionList->append(theResultBody,anIt.current()); + } + } else { + aSelectionList->setSelectionType(aShape->shapeTypeStr()); + aSelectionList->append(theResultBody,aShape); + } + } + } + } + + // Create the group in the document to be able to set its color + ResultPtr aGroup = document()->createGroup(aGroupFeature->data()); + aGroupFeature->setResult(aGroup); + + ModelAPI_Tools::setColor(aGroupFeature->lastResult(),theColor); - setResult(createResultBody(aGeomShape)); + if (aSelectionList->size() == 0) { + document()->removeFeature(aGroupFeature); + } +} + +void ExchangePlugin_ImportFeature::setMaterielGroup( + std::shared_ptr theResultBody, + std::map< std::wstring,std::list>& theMaterialShape) +{ + std::map< std::wstring, std::list>::iterator anIt; + for (anIt = theMaterialShape.begin(); anIt != theMaterialShape.end(); ++anIt) { + + std::shared_ptr aGroupFeature = addFeature("Group"); + // group name + aGroupFeature->data()->setName((*anIt).first); + + // fill selection + AttributeSelectionListPtr aSelectionList = aGroupFeature->selectionList("group_list"); + + std::list allRes; + ModelAPI_Tools::allSubs(theResultBody, allRes); + for (std::list::iterator aRes = allRes.begin(); aRes != allRes.end(); ++aRes) { + + GeomShapePtr aShape = (*aRes)->shape(); + for (std::list::iterator aResMat = anIt->second.begin(); + aResMat != anIt->second.end(); ++aResMat) { + if (aRes->get() && ((*aRes)->data()->name() == (*aResMat))) + { + if (aShape->isCompound() || aShape->isCompSolid()) { + GeomAPI_ShapeIterator aShapeIt(aShape); + for (; aShapeIt.more(); aShapeIt.next()) { + aSelectionList->setSelectionType(aShapeIt.current()->shapeTypeStr()); + aSelectionList->append(theResultBody, aShapeIt.current()); + } + } else { + aSelectionList->setSelectionType(aShape->shapeTypeStr()); + aSelectionList->append(theResultBody,aShape); + } + break; + } + } + } + if (aSelectionList->size() == 0){ + document()->removeFeature(aGroupFeature); + } + } } void ExchangePlugin_ImportFeature::importXAO(const std::string& theFileName) @@ -161,7 +376,7 @@ void ExchangePlugin_ImportFeature::importXAO(const std::string& theFileName) std::string aBodyName = aXaoGeometry->getName(); if (aBodyName.empty()) aBodyName = GeomAlgoAPI_Tools::File_Tools::name(theFileName); - data()->setName(aBodyName); + data()->setName(Locale::Convert::toWString(aBodyName)); ResultBodyPtr aResultBody = createResultBody(aGeomShape); setResult(aResultBody); @@ -187,7 +402,7 @@ void ExchangePlugin_ImportFeature::importXAO(const std::string& theFileName) // group name if (!aXaoGroup->getName().empty()) - aGroupFeature->data()->setName(aXaoGroup->getName()); + aGroupFeature->data()->setName(Locale::Convert::toWString(aXaoGroup->getName())); // fill selection AttributeSelectionListPtr aSelectionList = aGroupFeature->selectionList("group_list"); @@ -217,7 +432,7 @@ void ExchangePlugin_ImportFeature::importXAO(const std::string& theFileName) // group name if (!aXaoField->getName().empty()) - aFieldFeature->data()->setName(aXaoField->getName()); + aFieldFeature->data()->setName(Locale::Convert::toWString(aXaoField->getName())); // fill selection AttributeSelectionListPtr aSelectionList = aFieldFeature->selectionList("selected"); @@ -341,7 +556,7 @@ void ExchangePlugin_ImportFeature::importXAO(const std::string& theFileName) } //============================================================================ -std::shared_ptr ExchangePlugin_ImportFeature::addFeature( +std::shared_ptr ExchangePlugin_ImportFeatureBase::addFeature( std::string theID) { std::shared_ptr aNew = document()->addFeature(theID, false); @@ -353,7 +568,7 @@ std::shared_ptr ExchangePlugin_ImportFeature::addFeature( } // LCOV_EXCL_START -void ExchangePlugin_ImportFeature::removeFeature( +void ExchangePlugin_ImportFeatureBase::removeFeature( std::shared_ptr theFeature) { if (!data()->isValid()) @@ -363,13 +578,13 @@ void ExchangePlugin_ImportFeature::removeFeature( } // LCOV_EXCL_STOP -int ExchangePlugin_ImportFeature::numberOfSubs(bool forTree) const +int ExchangePlugin_ImportFeatureBase::numberOfSubs(bool /*forTree*/) const { return data()->reflist(FEATURES_ID())->size(true); } -std::shared_ptr ExchangePlugin_ImportFeature::subFeature( - const int theIndex, bool forTree) +std::shared_ptr ExchangePlugin_ImportFeatureBase::subFeature( + const int theIndex, bool /*forTree*/) { ObjectPtr anObj = data()->reflist(FEATURES_ID())->object(theIndex, false); FeaturePtr aRes = std::dynamic_pointer_cast(anObj); @@ -377,7 +592,7 @@ std::shared_ptr ExchangePlugin_ImportFeature::subFeature( } // LCOV_EXCL_START -int ExchangePlugin_ImportFeature::subFeatureId(const int theIndex) const +int ExchangePlugin_ImportFeatureBase::subFeatureId(const int theIndex) const { std::shared_ptr aRefList = std::dynamic_pointer_cast< ModelAPI_AttributeRefList>(data()->attribute(FEATURES_ID())); @@ -396,7 +611,7 @@ int ExchangePlugin_ImportFeature::subFeatureId(const int theIndex) const } // LCOV_EXCL_STOP -bool ExchangePlugin_ImportFeature::isSub(ObjectPtr theObject) const +bool ExchangePlugin_ImportFeatureBase::isSub(ObjectPtr theObject) const { // check is this feature of result FeaturePtr aFeature = ModelAPI_Feature::feature(theObject); @@ -406,7 +621,7 @@ bool ExchangePlugin_ImportFeature::isSub(ObjectPtr theObject) const } //============================================================================ -void ExchangePlugin_ImportFeature::loadNamingDS( +void ExchangePlugin_ImportFeatureBase::loadNamingDS( std::shared_ptr theGeomShape, std::shared_ptr theResultBody) { @@ -416,3 +631,53 @@ void ExchangePlugin_ImportFeature::loadNamingDS( std::string aNameMS = "Shape"; theResultBody->loadFirstLevel(theGeomShape, aNameMS); } + +void ExchangePlugin_Import_ImageFeature::importFile(const std::string& theFileName) +{ + std::string anExtension = GeomAlgoAPI_Tools::File_Tools::extension(theFileName); + std::string anError; + + 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; + } + + std::shared_ptr 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); + + // 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 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); + } +}