X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FFeaturesPlugin%2FFeaturesPlugin_Revolution.cpp;h=9994cd900268067bdf4f7ed728600b7306da9945;hb=97917d3698f5a2f7fc9596e7c755ff8f6751e373;hp=f37eac6c84c708a68de1274ee27d46f4cbffd67a;hpb=cbde248859fb0072f6012907391ea90cfc254574;p=modules%2Fshaper.git diff --git a/src/FeaturesPlugin/FeaturesPlugin_Revolution.cpp b/src/FeaturesPlugin/FeaturesPlugin_Revolution.cpp index f37eac6c8..9994cd900 100644 --- a/src/FeaturesPlugin/FeaturesPlugin_Revolution.cpp +++ b/src/FeaturesPlugin/FeaturesPlugin_Revolution.cpp @@ -1,24 +1,36 @@ -// Copyright (C) 2014-20xx CEA/DEN, EDF R&D - -// File: FeaturesPlugin_Revolution.cpp -// Created: 12 May 2015 -// Author: Dmitry Bobylev - -#include +// Copyright (C) 2014-2019 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_Revolution.h" #include -#include +#include #include -#include #include #include -#include -#include -#include -#include +#include +#include + #include #include +#include //================================================================================================= FeaturesPlugin_Revolution::FeaturesPlugin_Revolution() @@ -28,11 +40,7 @@ FeaturesPlugin_Revolution::FeaturesPlugin_Revolution() //================================================================================================= void FeaturesPlugin_Revolution::initAttributes() { - AttributeSelectionListPtr aSelection = - std::dynamic_pointer_cast(data()->addAttribute( - LIST_ID(), ModelAPI_AttributeSelectionList::typeId())); - // revolution works with faces always - aSelection->setSelectionType("FACE"); + initCompositeSketchAttribtues(InitBaseObjectsList); data()->addAttribute(AXIS_OBJECT_ID(), ModelAPI_AttributeSelection::typeId()); @@ -49,166 +57,142 @@ void FeaturesPlugin_Revolution::initAttributes() ModelAPI_Session::get()->validators()->registerNotObligatory(getKind(), TO_OBJECT_ID()); ModelAPI_Session::get()->validators()->registerNotObligatory(getKind(), FROM_OBJECT_ID()); + + initCompositeSketchAttribtues(InitSketchLauncher); } //================================================================================================= void FeaturesPlugin_Revolution::execute() { - // Getting faces. - ListOfShape aFacesList; - AttributeSelectionListPtr aFacesSelectionList = selectionList(LIST_ID()); - for(int anIndex = 0; anIndex < aFacesSelectionList->size(); anIndex++) { - AttributeSelectionPtr aFaceSel = aFacesSelectionList->value(anIndex); - std::shared_ptr aFaceShape = aFaceSel->value(); - if(aFaceShape.get() && !aFaceShape->isNull()) { // Getting face. - aFacesList.push_back(aFaceShape); - } else { // This may be the whole sketch result selected, check and get faces. - ResultPtr aContext = aFaceSel->context(); - std::shared_ptr aContextShape = aContext->shape(); - if(!aContextShape.get()) { - static const std::string aContextError = "The selection context is bad"; - setError(aContextError); - return; - } - ResultConstructionPtr aConstruction = std::dynamic_pointer_cast(aContext); - if(!aConstruction.get()) { - static const std::string aFaceError = "Can not find basis for revolution"; - setError(aFaceError); - return; - } - int aFacesNum = aConstruction->facesNum(); - for(int aFaceIndex = 0; aFaceIndex < aFacesNum || aFacesNum == -1; aFaceIndex++) { - aFaceShape = std::dynamic_pointer_cast(aConstruction->face(aFaceIndex)); - aFacesList.push_back(aFaceShape); - } + ListOfShape aBaseShapesList; + ListOfMakeShape aMakeShapesList; + + // Make revolutions. + if(!makeRevolutions(aBaseShapesList, aMakeShapesList)) { + return; + } + + // Store results. + int aResultIndex = 0; + ListOfShape::const_iterator aBaseIt = aBaseShapesList.cbegin(); + ListOfMakeShape::const_iterator anAlgoIt = aMakeShapesList.cbegin(); + for(; aBaseIt != aBaseShapesList.cend() && anAlgoIt != aMakeShapesList.cend(); + ++aBaseIt, ++anAlgoIt) { + storeResult(*aBaseIt, *anAlgoIt, aResultIndex++); + } + + removeResults(aResultIndex); +} + +//================================================================================================= +bool FeaturesPlugin_Revolution::makeRevolutions(ListOfShape& theBaseShapes, + ListOfMakeShape& theMakeShapes) +{ + theMakeShapes.clear(); + + // Getting base shapes. + getBaseShapes(theBaseShapes); + + // Getting axis. + static const std::string aSelectionError = "Error: The axis shape selection is bad."; + AttributeSelectionPtr aSelection = selection(AXIS_OBJECT_ID()); + GeomShapePtr aShape = aSelection->value(); + if (!aShape.get()) { + if (aSelection->context().get()) { + aShape = aSelection->context()->shape(); } } + if (!aShape.get()) { + setError(aSelectionError); + return false; + } + + GeomEdgePtr anEdge; + if (aShape->isEdge()) + { + anEdge = aShape->edge(); + } + else if (aShape->isCompound()) + { + GeomAPI_ShapeIterator anIt(aShape); + anEdge = anIt.current()->edge(); + } + else + { + setError(aSelectionError); + return false; + } - //Getting axis. std::shared_ptr anAxis; - std::shared_ptr anEdge; - std::shared_ptr anObjRef = selection(AXIS_OBJECT_ID()); - if(anObjRef && anObjRef->value() && anObjRef->value()->isEdge()) { - anEdge = std::shared_ptr(new GeomAPI_Edge(anObjRef->value())); - } else if(anObjRef->context() && anObjRef->context()->shape() && anObjRef->context()->shape()->isEdge()) { - anEdge = std::shared_ptr(new GeomAPI_Edge(anObjRef->context()->shape())); + if(anEdge.get()) { + if(anEdge->isLine()) { + anAxis = std::shared_ptr(new GeomAPI_Ax1(anEdge->line()->location(), + anEdge->line()->direction())); + } } - if(anEdge) { - anAxis = std::shared_ptr(new GeomAPI_Ax1(anEdge->line()->location(), anEdge->line()->direction())); + + if(!anAxis.get()) { + return false; } // Getting angles. - double aToAngle = real(TO_ANGLE_ID())->value(); - double aFromAngle = real(FROM_ANGLE_ID())->value(); + double aToAngle = 0.0; + double aFromAngle = 0.0; - if(string(CREATION_METHOD())->value() == "ByAngles") { + if(string(CREATION_METHOD())->value() == CREATION_METHOD_BY_ANGLES()) { aToAngle = real(TO_ANGLE_ID())->value(); - aFromAngle = real(FROM_ANGLE_ID())->value(); + aFromAngle = real(FROM_ANGLE_ID())->value(); } else { aToAngle = real(TO_OFFSET_ID())->value(); - aFromAngle = real(FROM_OFFSET_ID())->value(); + aFromAngle = real(FROM_OFFSET_ID())->value(); } // Getting bounding planes. - std::shared_ptr aToShape; - std::shared_ptr aFromShape; - - if(string(CREATION_METHOD())->value() == "ByPlanesAndOffsets") { - anObjRef = selection(TO_OBJECT_ID()); - if(anObjRef.get() != NULL) { - aToShape = std::dynamic_pointer_cast(anObjRef->value()); - if(aToShape.get() == NULL && anObjRef->context().get() != NULL) { - aToShape = anObjRef->context()->shape(); + GeomShapePtr aToShape; + GeomShapePtr aFromShape; + + if(string(CREATION_METHOD())->value() == CREATION_METHOD_BY_PLANES()) { + aSelection = selection(TO_OBJECT_ID()); + if(aSelection.get()) { + aToShape = std::dynamic_pointer_cast(aSelection->value()); + if(!aToShape.get() && aSelection->context().get()) { + aToShape = aSelection->context()->shape(); + } + if (aToShape.get() && aToShape->isCompound()) { + GeomAPI_ShapeIterator anIt(aToShape); + aToShape = anIt.current(); } } - anObjRef = selection(FROM_OBJECT_ID()); - if(anObjRef.get() != NULL) { - aFromShape = std::dynamic_pointer_cast(anObjRef->value()); - if(aFromShape.get() == NULL && anObjRef->context().get() != NULL) { - aFromShape = anObjRef->context()->shape(); + aSelection = selection(FROM_OBJECT_ID()); + if(aSelection.get()) { + aFromShape = std::dynamic_pointer_cast(aSelection->value()); + if(!aFromShape.get() && aSelection->context().get()) { + aFromShape = aSelection->context()->shape(); + } + if (aFromShape.get() && aFromShape->isCompound()) { + GeomAPI_ShapeIterator anIt(aFromShape); + aFromShape = anIt.current(); } } } - // Searching faces with common edges. - ListOfShape aShells; - ListOfShape aFreeFaces; - std::shared_ptr aFacesCompound = GeomAlgoAPI_CompoundBuilder::compound(aFacesList); - GeomAlgoAPI_ShapeTools::combineShapes(aFacesCompound, GeomAPI_Shape::SHELL, aShells, aFreeFaces); - aShells.insert(aShells.end(), aFreeFaces.begin(), aFreeFaces.end()); - - // Generating result for each shell and face. - int aResultIndex = 0; - for(ListOfShape::const_iterator anIter = aShells.cbegin(); anIter != aShells.cend(); anIter++) { - std::shared_ptr aBaseShape = *anIter; - - GeomAlgoAPI_Revolution aRevolAlgo(aBaseShape, anAxis, aToShape, aToAngle, aFromShape, aFromAngle); - if(!aRevolAlgo.isDone()) { - static const std::string aPrismAlgoError = "Revolution algorithm failed"; - setError(aPrismAlgoError); - aResultIndex = 0; - break; - } - - // Check if shape is valid - if(!aRevolAlgo.shape().get() || aRevolAlgo.shape()->isNull()) { - static const std::string aShapeError = "Resulting shape is Null"; - setError(aShapeError); - aResultIndex = 0; - break; - } - if(!aRevolAlgo.isValid()) { - std::string aPrismAlgoError = "Warning: resulting shape is not valid"; - setError(aPrismAlgoError); - aResultIndex = 0; - break; + // Generating result for each base shape. + std::string anError; + for(ListOfShape::const_iterator + anIter = theBaseShapes.cbegin(); anIter != theBaseShapes.cend(); anIter++) { + GeomShapePtr aBaseShape = *anIter; + + std::shared_ptr aRevolAlgo(new GeomAlgoAPI_Revolution( + aBaseShape, anAxis, + aToShape, aToAngle, + aFromShape, aFromAngle)); + if (GeomAlgoAPI_Tools::AlgoError::isAlgorithmFailed(aRevolAlgo, getKind(), anError)) { + setError(anError); + return false; } - ResultBodyPtr aResultBody = document()->createBody(data(), aResultIndex); - loadNamingDS(aRevolAlgo, aResultBody, aBaseShape); - setResult(aResultBody, aResultIndex); - aResultIndex++; + theMakeShapes.push_back(aRevolAlgo); } - removeResults(aResultIndex); -} - -//================================================================================================= -void FeaturesPlugin_Revolution::loadNamingDS(GeomAlgoAPI_Revolution& theRevolAlgo, - std::shared_ptr theResultBody, - std::shared_ptr theBasis) -{ - //load result - theResultBody->storeGenerated(theBasis, theRevolAlgo.shape()); - - std::shared_ptr aSubShapes = theRevolAlgo.mapOfShapes(); - - //Insert lateral face : Face from Edge - const std::string aLatName = "LateralFace"; - const int aLatTag = 1; - theResultBody->loadAndOrientGeneratedShapes(theRevolAlgo.makeShape().get(), theBasis, GeomAPI_Shape::EDGE, aLatTag, aLatName, *aSubShapes); - - //Insert to faces - const std::string aToName = "ToFace"; - int aToTag = 2; - const ListOfShape& aToFaces = theRevolAlgo.toFaces(); - for(ListOfShape::const_iterator anIt = aToFaces.cbegin(); anIt != aToFaces.cend(); anIt++) { - std::shared_ptr aToFace = *anIt; - if(aSubShapes->isBound(aToFace)) { - aToFace = aSubShapes->find(aToFace); - } - theResultBody->generated(aToFace, aToName, aToTag++); - } - - //Insert from faces - const std::string aFromName = "FromFace"; - int aFromTag = aToTag > 10000 ? aToTag : 10000; - const ListOfShape& aFromFaces = theRevolAlgo.fromFaces(); - for(ListOfShape::const_iterator anIt = aFromFaces.cbegin(); anIt != aFromFaces.cend(); anIt++) { - std::shared_ptr aFromFace = *anIt; - if(aSubShapes->isBound(aFromFace)) { - aFromFace = aSubShapes->find(aFromFace); - } - theResultBody->generated(aFromFace, aFromName, aFromTag++); - } + return true; }