X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FFeaturesPlugin%2FFeaturesPlugin_Placement.cpp;h=0acf3a84e07c22da2d7d80bc2c0757fde884230a;hb=b7f954c1e5b9da1fc425908ac4edfebb513ebf23;hp=d9fe0ca5f35f7f7423a20973845475ecaf1fcde0;hpb=7bf19255421b34594c7b0a76d0ce28166d0ce895;p=modules%2Fshaper.git diff --git a/src/FeaturesPlugin/FeaturesPlugin_Placement.cpp b/src/FeaturesPlugin/FeaturesPlugin_Placement.cpp index d9fe0ca5f..0acf3a84e 100644 --- a/src/FeaturesPlugin/FeaturesPlugin_Placement.cpp +++ b/src/FeaturesPlugin/FeaturesPlugin_Placement.cpp @@ -1,133 +1,223 @@ -// Copyright (C) 2014-20xx CEA/DEN, EDF R&D --> - -// File: FeaturesPlugin_Placement.cpp -// Created: 2 Dec 2014 -// Author: Artem ZHIDKOV +// 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_Placement.h" #include #include +#include #include +#include +#include +#include +#include #include #include +#include #include +#include +#include + +#include -#define _MODIFIEDF_TAG 1 -#define _MODIFIEDE_TAG 2 -#define _MODIFIEDV_TAG 3 -#define _FACE 4 FeaturesPlugin_Placement::FeaturesPlugin_Placement() { } void FeaturesPlugin_Placement::initAttributes() { - data()->addAttribute(FeaturesPlugin_Placement::BASE_FACE_ID(), ModelAPI_AttributeSelection::type()); - data()->addAttribute(FeaturesPlugin_Placement::ATTRACT_FACE_ID(), ModelAPI_AttributeSelection::type()); + + AttributeSelectionListPtr aSelection = + std::dynamic_pointer_cast(data()->addAttribute( + OBJECTS_LIST_ID(), ModelAPI_AttributeSelectionList::typeId())); + + data()->addAttribute(START_SHAPE_ID(), ModelAPI_AttributeSelection::typeId()); + data()->addAttribute(END_SHAPE_ID(), ModelAPI_AttributeSelection::typeId()); + data()->addAttribute(REVERSE_ID(), ModelAPI_AttributeBoolean::typeId()); + data()->addAttribute(CENTERING_ID(), ModelAPI_AttributeBoolean::typeId()); } void FeaturesPlugin_Placement::execute() { - // Verify the base face - std::shared_ptr aFaceRef = std::dynamic_pointer_cast< - ModelAPI_AttributeSelection>(data()->attribute(FeaturesPlugin_Placement::BASE_FACE_ID())); - if (!aFaceRef) + // Getting objects. + ListOfShape anObjects; + std::list aContextes; + AttributeSelectionListPtr anObjectsSelList = selectionList(OBJECTS_LIST_ID()); + if(anObjectsSelList->size() == 0) { return; + } + for(int anObjectsIndex = 0; anObjectsIndex < anObjectsSelList->size(); anObjectsIndex++) { + std::shared_ptr anObjectAttr = + anObjectsSelList->value(anObjectsIndex); + std::shared_ptr anObject = anObjectAttr->value(); + if(!anObject.get()) { // may be for not-activated parts + return; + } + anObjects.push_back(anObject); + aContextes.push_back(anObjectAttr->context()); + } - std::shared_ptr aBaseFace = - std::dynamic_pointer_cast(aFaceRef->value()); - if (!aBaseFace) + // Verify the start shape + AttributeSelectionPtr anObjRef = selection(START_SHAPE_ID()); + if(!anObjRef) { return; + } + std::shared_ptr aStartShape = anObjRef->value(); + if(!aStartShape) { + static const std::string aSelectionError = "Error: The start shape selection is bad."; + setError(aSelectionError); + return; + } - std::shared_ptr aBaseFaceContext; - ResultPtr aContextRes = aFaceRef->context(); - if (aContextRes) { - if (aContextRes->groupName() == ModelAPI_ResultBody::group()) - aBaseFaceContext = std::dynamic_pointer_cast(aContextRes)->shape(); - else if (aContextRes->groupName() == ModelAPI_ResultConstruction::group()) - aBaseFaceContext = std::dynamic_pointer_cast(aContextRes)->shape(); + + std::shared_ptr aStartShapeContext; + ResultPtr aContextRes = anObjRef->context(); + if (aContextRes.get()) { + aStartShapeContext = aContextRes->shape(); } - if (!aBaseFaceContext) { - static const std::string aContextError = "The selection context is bad"; + if(!aStartShapeContext.get()) { + static const std::string aContextError = "Error: The start shape selection context is bad."; setError(aContextError); return; } - // Verify the attractive face - aFaceRef = std::dynamic_pointer_cast( - data()->attribute(FeaturesPlugin_Placement::ATTRACT_FACE_ID())); - - std::shared_ptr aSlaveObjectFace = - std::dynamic_pointer_cast(aFaceRef->value()); - if (!aSlaveObjectFace) + // Verify the end shape + anObjRef = selection(END_SHAPE_ID()); + std::shared_ptr anEndShape = anObjRef->value(); + if(!anEndShape) { + static const std::string aSelectionError = "Error: The end shape selection is bad."; + setError(aSelectionError); return; + } - std::shared_ptr aSlaveObject; - aContextRes = aFaceRef->context(); - if (aContextRes) { - if (aContextRes->groupName() == ModelAPI_ResultBody::group()) - aSlaveObject = std::dynamic_pointer_cast(aContextRes)->shape(); - else if (aContextRes->groupName() == ModelAPI_ResultConstruction::group()) - aSlaveObject = std::dynamic_pointer_cast(aContextRes)->shape(); + std::shared_ptr anEndShapeContext; + aContextRes = anObjRef->context(); + if(aContextRes.get()) { + anEndShapeContext = aContextRes->shape(); } - if (!aSlaveObject) { - static const std::string aContextError = "The selection context is bad"; + if(!anEndShapeContext.get()) { + static const std::string aContextError = "Error: The end shape selection context is bad."; setError(aContextError); return; } - // Verify faces planarity - std::shared_ptr aBaseFace1(new GeomAPI_Face(aBaseFace)); - std::shared_ptr aSlaveFace1(new GeomAPI_Face(aSlaveObjectFace)); - if (!aBaseFace1->isPlanar() || !aSlaveFace1->isPlanar()) { - static const std::string aPlanarityError = "One of selected face is not planar"; - setError(aPlanarityError); - return; + // Verify planarity of faces and linearity of edges + std::shared_ptr aShapes[2] = {aStartShape, anEndShape}; + for (int i = 0; i < 2; i++) { + if (!isShapeValid(aShapes[i])) { + return; + } } - std::shared_ptr aBasePlane = aBaseFace1->getPlane(); - std::shared_ptr aSlavePlane = aSlaveFace1->getPlane(); + // Flags of the Placement + bool isReverse = boolean(REVERSE_ID())->value(); + bool isCentering = boolean(CENTERING_ID())->value(); - std::shared_ptr aResultBody = document()->createBody(data()); - GeomAlgoAPI_Placement aFeature(aSlaveObject, aSlavePlane, aBasePlane); - if(!aFeature.isDone()) { - static const std::string aFeatureError = "Placement algorithm failed"; + // Getting transformation. + GeomAlgoAPI_Placement aPlacementAlgo( + aStartShapeContext, anEndShapeContext, aStartShape, anEndShape, isReverse, isCentering, true); + if(!aPlacementAlgo.isDone()) { + static const std::string aFeatureError = "Error: Placement algorithm failed."; setError(aFeatureError); return; } - - // Check if shape is valid - if (aFeature.shape()->isNull()) { - static const std::string aShapeError = "Resulting shape is Null"; - setError(aShapeError); - return; + std::shared_ptr aTrsf = aPlacementAlgo.transformation(); + + // Applying transformation to each object. + int aResultIndex = 0; + std::string anError; + std::list::iterator aContext = aContextes.begin(); + for(ListOfShape::iterator anObjectsIt = anObjects.begin(); anObjectsIt != anObjects.end(); + anObjectsIt++, aContext++) { + + // for part results just set transformation + if (aContext->get() && (*aContext)->groupName() == ModelAPI_ResultPart::group()) { + ResultPartPtr anOrigin = std::dynamic_pointer_cast(*aContext); + ResultPartPtr aResultPart = document()->copyPart(anOrigin, data(), aResultIndex); + aResultPart->setTrsf(aContextRes, aTrsf); + setResult(aResultPart, aResultIndex); + } else { + std::shared_ptr aBaseShape = *anObjectsIt; + std::shared_ptr aTransformAlgo(new GeomAlgoAPI_Transform(aBaseShape, + aTrsf)); + + // Checking that the algorithm worked properly. + if (GeomAlgoAPI_Tools::AlgoError::isAlgorithmFailed(aTransformAlgo, getKind(), anError)) { + setError(anError); + break; + } + + //LoadNamingDS + ResultBodyPtr aResultBody = document()->createBody(data(), aResultIndex); + + ListOfShape aShapes; + aShapes.push_back(aBaseShape); + FeaturesPlugin_Tools::loadModifiedShapes(aResultBody, aShapes, ListOfShape(), + aTransformAlgo, aTransformAlgo->shape(), "Placed"); + setResult(aResultBody, aResultIndex); + } + aResultIndex++; } - if(!aFeature.isValid()) { - std::string aFeatureError = "Warning: resulting shape is not valid"; - setError(aFeatureError); - return; - } - //LoadNamingDS - LoadNamingDS(aFeature, aResultBody, aSlaveObject); - setResult(aResultBody); + // Remove the rest results if there were produced in the previous pass. + removeResults(aResultIndex); } -//============================================================================ -void FeaturesPlugin_Placement::LoadNamingDS( - GeomAlgoAPI_Placement& theFeature, - std::shared_ptr theResultBody, - std::shared_ptr theSlaveObject) +//================================================================================================== +bool FeaturesPlugin_Placement::isShapeValid(GeomShapePtr theShape) { - //load result - theResultBody->storeModified(theSlaveObject, theFeature.shape()); // the initial Slave, the resulting Slave - - GeomAPI_DataMapOfShapeShape* aSubShapes = new GeomAPI_DataMapOfShapeShape(); - theFeature.mapOfShapes(*aSubShapes); - - // put modifed faces in DF - theResultBody->loadAndOrientModifiedShapes(theFeature.makeShape(), theSlaveObject, _FACE, _MODIFIEDF_TAG, *aSubShapes); + if (theShape->isCompound()) { + GeomAPI_Shape::ShapeType aShapeType = GeomAPI_Shape::SHAPE; + for (GeomAPI_ShapeIterator anIt(theShape); anIt.more(); anIt.next()) { + GeomShapePtr aCurrentShape = anIt.current(); + if (aShapeType == GeomAPI_Shape::SHAPE) { + aShapeType = aCurrentShape->shapeType(); + } + else if (aShapeType != aCurrentShape->shapeType()) { + static const std::string aLinearityError = + "Error: Selected compound contains shapes with different types."; + setError(aLinearityError); + return false; + } + + if (!isShapeValid(aCurrentShape)) { + return false; + } + } + } + else if (theShape->isFace()) { + std::shared_ptr aFace(new GeomAPI_Face(theShape)); + if (!aFace->isPlanar()) { + static const std::string aPlanarityError = "Error: One of selected faces is not planar."; + setError(aPlanarityError); + return false; + } + } + else if (theShape->isEdge()) { + std::shared_ptr anEdge(new GeomAPI_Edge(theShape)); + if (!anEdge->isLine()) { + static const std::string aLinearityError = "Error: One of selected edges is not linear."; + setError(aLinearityError); + return false; + } + } + return true; }