X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FFeaturesPlugin%2FFeaturesPlugin_Partition.cpp;h=cd4f34cd33a915148c3ba1fc8ebf5da5774cd3fb;hb=a55586483e5dccc5466d6ec241e2147e210d839f;hp=ec16dd41e37acba5405c9690906c7aaa7a8fd210;hpb=1d864d8beda4d31de109734a9f7f006cb361e91c;p=modules%2Fshaper.git diff --git a/src/FeaturesPlugin/FeaturesPlugin_Partition.cpp b/src/FeaturesPlugin/FeaturesPlugin_Partition.cpp index ec16dd41e..cd4f34cd3 100755 --- a/src/FeaturesPlugin/FeaturesPlugin_Partition.cpp +++ b/src/FeaturesPlugin/FeaturesPlugin_Partition.cpp @@ -1,32 +1,75 @@ -// Copyright (C) 2014-20xx CEA/DEN, EDF R&D --> - -// File: FeaturesPlugin_Partition.cpp -// Created: 31 Jul 2015 -// Author: Natalia ERMOLAEVA +// Copyright (C) 2014-2017 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 "FeaturesPlugin_Partition.h" -#include -#include #include -#include #include +#include +#include #include +#include +#include #include -#include #include +#include #include +#include #include -#include #include #include +#include #include +#include +#include #include +#include +#include #include +typedef std::list > CompsolidSubs; + +static GeomShapePtr findBase(const GeomShapePtr theObjectShape, + const GeomShapePtr theResultShape, + const GeomAPI_Shape::ShapeType theShapeType, + const std::shared_ptr theMakeShape); + +static void pullObjectsAndPlanes(const AttributeSelectionListPtr& theSelectedList, + CompsolidSubs& theObjects, ListOfShape& thePlanes); + +static void resizePlanes(const CompsolidSubs& theObjects, ListOfShape& thePlanes, + std::shared_ptr& theMakeShapeList); + +static void unusedSubsOfComposolid(const CompsolidSubs& theObjects, CompsolidSubs& theNotUsed); + +static bool cutUnusedSubs(CompsolidSubs& theObjects, CompsolidSubs& theNotUsed, + std::shared_ptr& theMakeShapeList, + std::string& theError); + +static bool isAlgoFailed(const std::shared_ptr& theAlgo, + std::string& theError); + + //================================================================================================= FeaturesPlugin_Partition::FeaturesPlugin_Partition() { @@ -41,73 +84,82 @@ void FeaturesPlugin_Partition::initAttributes() //================================================================================================= void FeaturesPlugin_Partition::execute() { - ListOfShape anObjects, aPlanes; + CompsolidSubs anObjects; + ListOfShape aPlanes; // Getting objects. - AttributeSelectionListPtr anObjectsSelList = selectionList(BASE_OBJECTS_ID()); - for(int anIndex = 0; anIndex < anObjectsSelList->size(); ++anIndex) { - AttributeSelectionPtr anObjectAttr = anObjectsSelList->value(anIndex); - GeomShapePtr anObject = anObjectAttr->value(); - if(!anObject.get()) { - // It could be a construction plane. - ResultPtr aContext = anObjectAttr->context(); - aPlanes.push_back(anObjectAttr->context()->shape()); - } else { - anObjects.push_back(anObject); - } - } - + pullObjectsAndPlanes(selectionList(BASE_OBJECTS_ID()), anObjects, aPlanes); if(anObjects.empty()) { static const std::string aFeatureError = "Error: No objects for partition."; setError(aFeatureError); return; } - std::list > aBoundingPoints = GeomAlgoAPI_ShapeTools::getBoundingBox(anObjects, 1.0); + ListOfShape aBaseObjects; + for (CompsolidSubs::iterator anIt = anObjects.begin(); anIt != anObjects.end(); ++anIt) + aBaseObjects.insert(aBaseObjects.end(), anIt->second.begin(), anIt->second.end()); + aBaseObjects.insert(aBaseObjects.end(), aPlanes.begin(), aPlanes.end()); - // Resize planes. - ListOfShape aTools; + // resize planes to the bounding box of operated shapes std::shared_ptr aMakeShapeList(new GeomAlgoAPI_MakeShapeList()); - for(ListOfShape::const_iterator anIt = aPlanes.cbegin(); anIt != aPlanes.cend(); ++anIt) { - GeomShapePtr aPlane = *anIt; - GeomShapePtr aTool = GeomAlgoAPI_ShapeTools::fitPlaneToBox(aPlane, aBoundingPoints); - std::shared_ptr aMkShCustom(new GeomAlgoAPI_MakeShapeCustom); - aMkShCustom->addModified(aPlane, aTool); - aMakeShapeList->appendAlgo(aMkShCustom); - aTools.push_back(aTool); - } + resizePlanes(anObjects, aPlanes, aMakeShapeList); - // Create single result. - std::shared_ptr aPartitionAlgo(new GeomAlgoAPI_Partition(anObjects, aTools)); + // cut unused solids of composolids from the objects of partition + CompsolidSubs anUnusedSubs; + unusedSubsOfComposolid(anObjects, anUnusedSubs); + for (CompsolidSubs::iterator anIt = anUnusedSubs.begin(); anIt != anUnusedSubs.end(); ++anIt) + aBaseObjects.insert(aBaseObjects.end(), anIt->second.begin(), anIt->second.end()); - // Checking that the algorithm worked properly. - if (!aPartitionAlgo->isDone()) { - static const std::string aFeatureError = "Error: Partition algorithm failed."; - setError(aFeatureError); - return; - } - if (aPartitionAlgo->shape()->isNull()) { - static const std::string aShapeError = "Error: Resulting shape is Null."; - setError(aShapeError); + std::string aError; + if (!cutUnusedSubs(anObjects, anUnusedSubs, aMakeShapeList, aError)) { + setError(aError); return; } - if (!aPartitionAlgo->isValid()) { - std::string aFeatureError = "Error: Resulting shape is not valid."; - setError(aFeatureError); + + // perform partition first time to split target solids + ListOfShape aTargetObjects; + for (CompsolidSubs::iterator anIt = anObjects.begin(); anIt != anObjects.end(); ++anIt) + aTargetObjects.insert(aTargetObjects.end(), anIt->second.begin(), anIt->second.end()); + + std::shared_ptr aPartitionAlgo( + new GeomAlgoAPI_Partition(aTargetObjects, aPlanes)); + + // Checking that the algorithm worked properly. + if (isAlgoFailed(aPartitionAlgo, aError)) { + setError(aError); return; } + aMakeShapeList->appendAlgo(aPartitionAlgo); GeomShapePtr aResultShape = aPartitionAlgo->shape(); + if (!anUnusedSubs.empty()) { + // second pass of a partition to split shared faces of compsolids + aTargetObjects.clear(); + aTargetObjects.push_back(aResultShape); + for (CompsolidSubs::iterator anIt = anUnusedSubs.begin(); anIt != anUnusedSubs.end(); ++anIt) + aTargetObjects.insert(aTargetObjects.end(), anIt->second.begin(), anIt->second.end()); + + aPartitionAlgo.reset(new GeomAlgoAPI_Partition(aTargetObjects, ListOfShape())); + + // Checking that the algorithm worked properly. + if (isAlgoFailed(aPartitionAlgo, aError)) { + setError(aError); + return; + } + + aMakeShapeList->appendAlgo(aPartitionAlgo); + aResultShape = aPartitionAlgo->shape(); + } + int aResultIndex = 0; - anObjects.insert(anObjects.end(), aPlanes.begin(), aPlanes.end()); if(aResultShape->shapeType() == GeomAPI_Shape::COMPOUND) { for(GeomAPI_ShapeIterator anIt(aResultShape); anIt.more(); anIt.next()) { - storeResult(anObjects, anIt.current(), aMakeShapeList, aResultIndex); + storeResult(aBaseObjects, aPlanes, anIt.current(), aMakeShapeList, aResultIndex); ++aResultIndex; } } else { - storeResult(anObjects, aResultShape, aMakeShapeList, aResultIndex); + storeResult(aBaseObjects, aPlanes, aResultShape, aMakeShapeList, aResultIndex); ++aResultIndex; } @@ -116,26 +168,29 @@ void FeaturesPlugin_Partition::execute() } //================================================================================================= -void FeaturesPlugin_Partition::storeResult(const ListOfShape& theObjects, - const GeomShapePtr theResultShape, - const std::shared_ptr theMakeShape, - const int theIndex) +void FeaturesPlugin_Partition::storeResult( + ListOfShape& theObjects, ListOfShape& thePlanes, + const GeomShapePtr theResultShape, + const std::shared_ptr theMakeShape, + const int theIndex) { - // Find base. + // Find base. The most complicated is the real modified object (#1799 if box is partitioned by + // two planes the box is the base, not planes, independently on the order in the list). GeomShapePtr aBaseShape; for(ListOfShape::const_iterator anIt = theObjects.cbegin(); anIt != theObjects.cend(); ++anIt) { GeomShapePtr anObjectShape = *anIt; - ListOfShape aModifiedShapes; - theMakeShape->modified(anObjectShape, aModifiedShapes); - for(ListOfShape::const_iterator aModIt = aModifiedShapes.cbegin(); aModIt != aModifiedShapes.cend(); ++aModIt) { - GeomShapePtr aModShape = *aModIt; - if(theResultShape->isSubShape(aModShape)) { - aBaseShape = anObjectShape; - break; - } + GeomShapePtr aCandidate = + findBase(anObjectShape, theResultShape, GeomAPI_Shape::VERTEX, theMakeShape); + if(!aCandidate.get()) { + aCandidate = findBase(anObjectShape, theResultShape, GeomAPI_Shape::EDGE, theMakeShape); } - if(aBaseShape.get()) { - break; + if (!aCandidate.get()) + aCandidate = findBase(anObjectShape, theResultShape, GeomAPI_Shape::FACE, theMakeShape); + + if(aCandidate.get()) { + if (!aBaseShape.get() || aBaseShape->shapeType() > aCandidate->shapeType()) { + aBaseShape = aCandidate; + } } } @@ -143,31 +198,243 @@ void FeaturesPlugin_Partition::storeResult(const ListOfShape& theObjects, ResultBodyPtr aResultBody = document()->createBody(data(), theIndex); // Store modified shape. - if(aBaseShape->isEqual(theResultShape)) { - aResultBody->store(theResultShape); + if(!aBaseShape.get() || aBaseShape->isEqual(theResultShape)) { + aResultBody->store(theResultShape, false); + setResult(aResultBody, theIndex); return; } const int aDelTag = 1; - const int aSubTag = 2; /// sub solids will be placed at labels 3, 4, etc. if result is compound of solids + /// sub solids will be placed at labels 3, 4, etc. if result is compound of solids + const int aSubTag = 2; int aModTag = aSubTag + 10000; const std::string aModName = "Modified"; aResultBody->storeModified(aBaseShape, theResultShape, aSubTag); std::shared_ptr aMapOfSubShapes = theMakeShape->mapOfSubShapes(); + theObjects.insert(theObjects.end(), thePlanes.begin(), thePlanes.end()); int anIndex = 1; for(ListOfShape::const_iterator anIt = theObjects.cbegin(); anIt != theObjects.cend(); ++anIt) { - std::ostringstream aStream; - aStream << aModName << "_" << anIndex++; - aResultBody->loadAndOrientModifiedShapes(theMakeShape.get(), *anIt, GeomAPI_Shape::EDGE, - aModTag, aStream.str(), *aMapOfSubShapes.get(), true); - aResultBody->loadAndOrientModifiedShapes(theMakeShape.get(), *anIt, GeomAPI_Shape::FACE, - aModTag, aStream.str(), *aMapOfSubShapes.get(), true); - aResultBody->loadDeletedShapes(theMakeShape.get(), *anIt, GeomAPI_Shape::EDGE, aDelTag); - aResultBody->loadDeletedShapes(theMakeShape.get(), *anIt, GeomAPI_Shape::FACE, aDelTag); - aModTag += 10000; + GeomShapePtr aShape = *anIt; + std::string aModEdgeName = aModName + "_Edge_" + std::to_string((long long)anIndex); + aResultBody->loadAndOrientModifiedShapes(theMakeShape.get(), aShape, GeomAPI_Shape::EDGE, + aModTag, aModEdgeName, *aMapOfSubShapes.get(), false, true, true); + std::string aModFaceName = aModName + "_Face_" + std::to_string((long long)anIndex++); + aResultBody->loadAndOrientModifiedShapes(theMakeShape.get(), aShape, GeomAPI_Shape::FACE, + aModTag + 1, aModFaceName, *aMapOfSubShapes.get(), false, true, true); + aResultBody->loadDeletedShapes(theMakeShape.get(), aShape, GeomAPI_Shape::FACE, aDelTag); } setResult(aResultBody, theIndex); } + + +//================= Auxiliary functions =================================================== + +GeomShapePtr findBase(const GeomShapePtr theObjectShape, + const GeomShapePtr theResultShape, + const GeomAPI_Shape::ShapeType theShapeType, + const std::shared_ptr theMakeShape) +{ + GeomShapePtr aBaseShape; + std::shared_ptr aMapOfSubShapes = theMakeShape->mapOfSubShapes(); + for(GeomAPI_ShapeExplorer anObjectSubShapesExp(theObjectShape, theShapeType); + anObjectSubShapesExp.more(); + anObjectSubShapesExp.next()) { + GeomShapePtr anObjectSubShape = anObjectSubShapesExp.current(); + ListOfShape aModifiedShapes; + theMakeShape->modified(anObjectSubShape, aModifiedShapes); + for(ListOfShape::const_iterator + aModIt = aModifiedShapes.cbegin(); aModIt != aModifiedShapes.cend(); ++aModIt) { + GeomShapePtr aModShape = *aModIt; + if(aMapOfSubShapes->isBound(aModShape)) { + aModShape = aMapOfSubShapes->find(aModShape); + } + if(theResultShape->isSubShape(aModShape)) { + aBaseShape = theObjectShape; + break; + } + } + if(aBaseShape.get()) { + break; + } + } + + return aBaseShape; +} + +static CompsolidSubs::iterator findOrAdd(CompsolidSubs& theList, const GeomShapePtr& theCompsolid) +{ + CompsolidSubs::iterator aFound = theList.begin(); + for (; aFound != theList.end(); ++aFound) + if (aFound->first == theCompsolid) + break; + if (aFound == theList.end()) { + theList.push_back(std::pair(theCompsolid, ListOfShape())); + aFound = --theList.end(); + } + return aFound; +} + +void pullObjectsAndPlanes(const AttributeSelectionListPtr& theSelectedList, + CompsolidSubs& theObjects, ListOfShape& thePlanes) +{ + std::map aMapCompsolidShape; + + int aSize = theSelectedList->size(); + for (int anIndex = 0; anIndex < aSize; ++anIndex) { + AttributeSelectionPtr anObjectAttr = theSelectedList->value(anIndex); + ResultPtr aContext = anObjectAttr->context(); + GeomShapePtr anObject = anObjectAttr->value(); + if (anObject) { + GeomShapePtr anOwnerShape = anObject; + // check the result is a compsolid and store all used subs in a single list + ResultBodyPtr aResCompSolidPtr = ModelAPI_Tools::bodyOwner(aContext); + if (aResCompSolidPtr && aResCompSolidPtr->shape()->shapeType() == GeomAPI_Shape::COMPSOLID) { + std::map::const_iterator + aFound = aMapCompsolidShape.find(aResCompSolidPtr); + if (aFound != aMapCompsolidShape.end()) + anOwnerShape = aFound->second; + else { + anOwnerShape = aResCompSolidPtr->shape(); + aMapCompsolidShape[aResCompSolidPtr] = anOwnerShape; + } + } + + CompsolidSubs::iterator aFound = findOrAdd(theObjects, anOwnerShape); + aFound->second.push_back(anObject); + } + else { + // It could be a construction plane. + thePlanes.push_back(anObjectAttr->context()->shape()); + } + } +} + +void resizePlanes(const CompsolidSubs& theObjects, ListOfShape& thePlanes, + std::shared_ptr& theMakeShapeList) +{ + ListOfShape aSolidsInOperation; + for (CompsolidSubs::const_iterator anIt = theObjects.begin(); anIt != theObjects.end(); ++anIt) + aSolidsInOperation.insert(aSolidsInOperation.end(), anIt->second.begin(), anIt->second.end()); + + std::list > aBoundingPoints = + GeomAlgoAPI_ShapeTools::getBoundingBox(aSolidsInOperation, 1.0); + + ListOfShape aPlanesCopy = thePlanes; + thePlanes.clear(); + + // Resize planes to fit in bounding box + for (ListOfShape::const_iterator anIt = aPlanesCopy.begin(); anIt != aPlanesCopy.end(); ++anIt) { + GeomShapePtr aPlane = *anIt; + GeomShapePtr aTool = GeomAlgoAPI_ShapeTools::fitPlaneToBox(aPlane, aBoundingPoints); + std::shared_ptr aMkShCustom(new GeomAlgoAPI_MakeShapeCustom); + aMkShCustom->addModified(aPlane, aTool); + theMakeShapeList->appendAlgo(aMkShCustom); + thePlanes.push_back(aTool); + } +} + +void unusedSubsOfComposolid(const CompsolidSubs& theObjects, CompsolidSubs& theNotUsed) +{ + for (CompsolidSubs::const_iterator aCSIt = theObjects.begin(); + aCSIt != theObjects.end(); ++aCSIt) { + if (aCSIt->first->shapeType() != GeomAPI_Shape::COMPSOLID) + continue; + + // check the compsolid is selected + if (aCSIt->second.size() == 1 && aCSIt->first->isEqual(aCSIt->second.front())) + continue; + + // process all sub-solids of compsolid + ListOfShape aNotUsedSolids; + for (GeomAPI_ShapeExplorer anExp(aCSIt->first, GeomAPI_Shape::SOLID); + anExp.more(); anExp.next()) { + GeomShapePtr aSolidInCompSolid = anExp.current(); + ListOfShape::const_iterator anIt = aCSIt->second.begin(); + for (; anIt != aCSIt->second.end(); ++anIt) + if (aSolidInCompSolid->isEqual(*anIt)) + break; + + if (anIt == aCSIt->second.end()) + aNotUsedSolids.push_back(aSolidInCompSolid); + } + + if (!aNotUsedSolids.empty()) + theNotUsed.push_back(std::pair(aCSIt->first, aNotUsedSolids)); + } +} + +static bool cutSubs(const GeomShapePtr& theFirstArgument, + CompsolidSubs& theSubsToCut, + const ListOfShape& theTools, + std::shared_ptr& theMakeShapeList, + std::string& theError) +{ + if (theTools.empty()) + return true; + + std::shared_ptr aCutAlgo; + + for (CompsolidSubs::iterator aUIt= theSubsToCut.begin(); aUIt != theSubsToCut.end(); ++aUIt) { + if (aUIt->first == theFirstArgument) + continue; // no need to split unused subs of the first compsolid + + // cut from current list of solids + aCutAlgo.reset( + new GeomAlgoAPI_Boolean(aUIt->second, theTools, GeomAlgoAPI_Boolean::BOOL_CUT)); + if (isAlgoFailed(aCutAlgo, theError)) + return false; + theMakeShapeList->appendAlgo(aCutAlgo); + + // update list of un-selected objects of the partition + GeomAPI_Shape::ShapeType aType = aUIt->second.front()->shapeType(); + aUIt->second.clear(); + for (GeomAPI_ShapeExplorer anExp(aCutAlgo->shape(), aType); anExp.more(); anExp.next()) + aUIt->second.push_back(anExp.current()); + } + return true; +} + +bool cutUnusedSubs(CompsolidSubs& theObjects, CompsolidSubs& theNotUsed, + std::shared_ptr& theMakeShapeList, + std::string& theError) +{ + GeomShapePtr aFirstArgument = theObjects.front().first; + + // compose a set of tools for the CUT operation: + // find the list of unused subs of the first argument or use itself + ListOfShape aToolsForUsed; + CompsolidSubs::iterator aUIt = theNotUsed.begin(); + for (; aUIt != theNotUsed.end(); ++aUIt) + if (aUIt->first == aFirstArgument) { + aToolsForUsed.insert(aToolsForUsed.end(), aUIt->second.begin(), aUIt->second.end()); + break; + } + ListOfShape aToolsForUnused; + aToolsForUnused.push_back(aFirstArgument); + + // cut subs + return cutSubs(aFirstArgument, theObjects, aToolsForUsed, theMakeShapeList, theError) + && cutSubs(aFirstArgument, theNotUsed, aToolsForUnused, theMakeShapeList, theError); +} + +bool isAlgoFailed(const std::shared_ptr& theAlgo, std::string& theError) +{ + if (!theAlgo->isDone()) { + theError = "Error: Partition algorithm failed."; + return true; + } + if (theAlgo->shape()->isNull()) { + theError = "Error: Resulting shape is Null."; + return true; + } + if (!theAlgo->isValid()) { + theError = "Error: Resulting shape is not valid."; + return true; + } + + theError.clear(); + return false; +}