X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FGeomValidators%2FGeomValidators_ZeroOffset.cpp;h=4a919d0c4b6afe96dc4c0fe774509a0478fb1863;hb=485284976089df895e261395518201ccd85dae4d;hp=2aa3cf45a28949462727348b99420c41c5a1063f;hpb=64e9d01b48f8c4e6e22919ebceeed715d613485e;p=modules%2Fshaper.git diff --git a/src/GeomValidators/GeomValidators_ZeroOffset.cpp b/src/GeomValidators/GeomValidators_ZeroOffset.cpp index 2aa3cf45a..4a919d0c4 100644 --- a/src/GeomValidators/GeomValidators_ZeroOffset.cpp +++ b/src/GeomValidators/GeomValidators_ZeroOffset.cpp @@ -1,54 +1,212 @@ -// Copyright (C) 2014-20xx CEA/DEN, EDF R&D - -// File: GeomValidators_ZeroOffset.h -// Created: 13 May 2015 -// Author: Dmitry Bobylev +// 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 -#include +#include + #include #include +#include +#include +#include + +#include +#include +#include +#include +#include //================================================================================================= bool GeomValidators_ZeroOffset::isValid(const std::shared_ptr& theFeature, - const std::list& theArguments) const + const std::list& theArguments, + Events_InfoMessage& theError) const { - if(theArguments.size() < 4) { + if(theArguments.size() != 9) { + theError = "Wrong number of validator arguments in xml(expected 9)."; return false; } std::list::const_iterator anIt = theArguments.begin(), aLast = theArguments.end(); - std::shared_ptr aFromShape; - std::shared_ptr aToShape; + std::string aSelectedMethod; + if(theFeature->string(*anIt)) { + aSelectedMethod = theFeature->string(*anIt)->value(); + } + anIt++; + std::string aCreationMethod = *anIt; + anIt++; - std::shared_ptr anAttrSel = theFeature->selection(*anIt); - if(anAttrSel) { - aFromShape = std::dynamic_pointer_cast(anAttrSel->value()); + ListOfShape aFacesList; + if(theFeature->selection(*anIt)) { + AttributeSelectionPtr aFaceSelection = theFeature->selection(*anIt); + ResultConstructionPtr aConstruction = + std::dynamic_pointer_cast(aFaceSelection->context()); + if(aConstruction.get()) { + int aSketchFacesNum = aConstruction->facesNum(); + for(int aFaceIndex = 0; aFaceIndex < aSketchFacesNum; aFaceIndex++) { + std::shared_ptr aFace = + std::dynamic_pointer_cast(aConstruction->face(aFaceIndex)); + if(aFace->isFace() && aFace->isPlanar()) { + aFacesList.push_back(aFace); + } + } + } + } else if(theFeature->selectionList(*anIt)) { + AttributeSelectionListPtr aFacesSelectionList = theFeature->selectionList(*anIt); + 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. + if(aFaceShape->isFace() && aFaceShape->isPlanar()) { + 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()) { + break; + } + ResultConstructionPtr aConstruction = + std::dynamic_pointer_cast(aContext); + if(!aConstruction.get()) { + break; + } + int aFacesNum = aConstruction->facesNum(); + for(int aFaceIndex = 0; aFaceIndex < aFacesNum || aFacesNum == -1; aFaceIndex++) { + aFaceShape = std::dynamic_pointer_cast(aConstruction->face(aFaceIndex)); + if(aFaceShape->isFace() && aFaceShape->isPlanar()) { + aFacesList.push_back(aFaceShape); + } + } + } + } } anIt++; - anAttrSel = theFeature->selection(*anIt); - if(anAttrSel) { - aToShape = std::dynamic_pointer_cast(anAttrSel->value()); + + double aToSize = 0.0; + double aFromSize = 0.0; + + if(theFeature->real(*anIt) && theFeature->real(*anIt)->isInitialized()) { + aToSize = theFeature->real(*anIt)->value(); + } + anIt++; + if(theFeature->real(*anIt) && theFeature->real(*anIt)->isInitialized()) { + aFromSize = theFeature->real(*anIt)->value(); } anIt++; - double aFromOffset = 0.0; - double aToOffset = 0.0; + if(aSelectedMethod == aCreationMethod) { + if(aToSize == -aFromSize) { + theError = "ToSize = -FromSize."; + return false; + } else { + return true; + } + } + + std::shared_ptr aToShape; + std::shared_ptr aFromShape; + + std::shared_ptr anAttrSel = theFeature->selection(*anIt); + if(anAttrSel && anAttrSel->isInitialized()) { + aToShape = std::dynamic_pointer_cast(anAttrSel->value()); + if(aToShape.get() == NULL && anAttrSel->context().get() != NULL) { + aToShape = anAttrSel->context()->shape(); + } + } + anIt++; std::shared_ptr anAttrDouble = theFeature->real(*anIt); - if(anAttrDouble) { - aFromOffset = anAttrDouble->value(); + if(anAttrDouble && anAttrDouble->isInitialized()) { + aToSize = anAttrDouble->value(); + } + anIt++; + + anAttrSel = theFeature->selection(*anIt); + if(anAttrSel && anAttrSel->isInitialized()) { + aFromShape = std::dynamic_pointer_cast(anAttrSel->value()); + if(aFromShape.get() == NULL && anAttrSel->context().get() != NULL) { + aFromShape = anAttrSel->context()->shape(); + } } anIt++; + anAttrDouble = theFeature->real(*anIt); - if(anAttrDouble) { - aToOffset = anAttrDouble->value(); + if(anAttrDouble && anAttrDouble->isInitialized()) { + aFromSize = anAttrDouble->value(); + } + + bool isPlanesCoincident = false; + if(!aFromShape.get() && !aToShape.get()) { + isPlanesCoincident = true; + } else if(aFromShape.get() && aToShape.get()) { + std::shared_ptr aFromFace(new GeomAPI_Face(aFromShape)); + if (aFromFace->isNull()) { + theError = "From face selection is invalid."; + return false; + } + std::shared_ptr aFromPln = aFromFace->getPlane(); + + std::shared_ptr aToFace(new GeomAPI_Face(aToShape)); + if (aToFace->isNull()) { + theError = "To face selection is invalid."; + return false; + } + std::shared_ptr aToPln = aToFace->getPlane(); + + if(aFromPln.get()) { + isPlanesCoincident = aFromPln->isCoincident(aToPln); + } + } else { + std::shared_ptr aFace; + if(aFromShape.get()) { + aFace.reset(new GeomAPI_Face(aFromShape)); + if (aFace->isNull()) { + theError = "From face selection is invalid."; + return false; + } + } else { + aFace.reset(new GeomAPI_Face(aToShape)); + if (aFace->isNull()) { + theError = "To face selection is invalid."; + return false; + } + } + std::shared_ptr aPln = aFace->getPlane(); + if(aPln.get()) { + for(ListOfShape::const_iterator + anIter = aFacesList.cbegin(); anIter != aFacesList.cend(); anIter++) { + std::shared_ptr aSketchShape = *anIter; + std::shared_ptr aSketchFace(new GeomAPI_Face(aSketchShape)); + std::shared_ptr aSketchPln = aSketchFace->getPlane(); + if(aPln->isCoincident(aSketchPln)) { + isPlanesCoincident = true; + break; + } + } + } } - if(((!aFromShape && !aToShape) || ((aFromShape && aToShape) && aFromShape->isEqual(aToShape))) - && (aFromOffset == 0.0 && aToOffset == 0.0)) { + if(isPlanesCoincident && aFromSize == -aToSize) { + theError = "FromSize = -ToSize and bounding planes are coincident."; return false; }