X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;ds=sidebyside;f=src%2FSketchSolver%2FSketchSolver_ConstraintFixed.cpp;h=6b73471ab680406920680361406d173056749b74;hb=06e7f5859095193fc7f498bd89a7d28009794f53;hp=e75bda6a145c1c693321e1c9689d5381b741b8fa;hpb=1dc044fab3350100372e3d326698cb12b99497f2;p=modules%2Fshaper.git diff --git a/src/SketchSolver/SketchSolver_ConstraintFixed.cpp b/src/SketchSolver/SketchSolver_ConstraintFixed.cpp index e75bda6a1..6b73471ab 100644 --- a/src/SketchSolver/SketchSolver_ConstraintFixed.cpp +++ b/src/SketchSolver/SketchSolver_ConstraintFixed.cpp @@ -1,4 +1,21 @@ -// Copyright (C) 2014-20xx CEA/DEN, EDF R&D +// Copyright (C) 2014-2023 CEA, EDF +// +// 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 @@ -12,13 +29,7 @@ #include #include -#include - -// Verify the points are equal -static bool isEqual(const GCS::Point& thePoint1, const GCS::Point& thePoint2); -// Verify the entities are equal -static bool isEqual(const EntityWrapperPtr& theEntity1, const EntityWrapperPtr& theEntity2); -// Convert entity to the list of parameters +/// \brief Get list of parameters of current entity static GCS::VEC_pD toParameters(const EntityWrapperPtr& theEntity); @@ -28,42 +39,30 @@ SketchSolver_ConstraintFixed::SketchSolver_ConstraintFixed(ConstraintPtr theCons myType = CONSTRAINT_FIXED; } -SketchSolver_ConstraintFixed::SketchSolver_ConstraintFixed(FeaturePtr theFeature) - : SketchSolver_Constraint(), - myBaseFeature(theFeature) -{ - myType = CONSTRAINT_FIXED; -} - void SketchSolver_ConstraintFixed::blockEvents(bool isBlocked) { - if (myBaseFeature) - myBaseFeature->data()->blockSendAttributeUpdated(isBlocked); - if (myBaseConstraint) - SketchSolver_Constraint::blockEvents(isBlocked); + SketchSolver_Constraint::blockEvents(isBlocked); } void SketchSolver_ConstraintFixed::process() { cleanErrorMsg(); - if ((!myBaseConstraint && !myBaseFeature) || !myStorage) { + if (!myBaseConstraint || !myStorage) { // Not enough parameters are assigned return; } - EntityWrapperPtr aBaseEntity; - getAttributes(aBaseEntity, myFixedEntity); - if (!aBaseEntity) { - moveFeature(); // remove myFixed entity + EntityWrapperPtr aBaseEntity = entityToFix(); + if (!aBaseEntity) myErrorMsg = SketchSolver_Error::ALREADY_FIXED(); - } if (!myErrorMsg.empty()) return; - fixFeature(aBaseEntity); + ConstraintWrapperPtr aConstraint = fixFeature(aBaseEntity); + myStorage->addConstraint(myBaseConstraint, aConstraint); } -void SketchSolver_ConstraintFixed::fixFeature(EntityWrapperPtr theFeature) +ConstraintWrapperPtr SketchSolver_ConstraintFixed::fixFeature(EntityWrapperPtr theFeature) { GCS::VEC_pD aParameters = toParameters(theFeature); @@ -77,93 +76,28 @@ void SketchSolver_ConstraintFixed::fixFeature(EntityWrapperPtr theFeature) GCSConstraintPtr(new GCS::ConstraintEqual(&myFixedValues[i], *anIt))); } - myConstraint = ConstraintWrapperPtr( + return ConstraintWrapperPtr( new PlaneGCSSolver_ConstraintWrapper(aConstraints, getType())); - - if (myBaseConstraint) - myStorage->addConstraint(myBaseConstraint, myConstraint); - else - myStorage->addTemporaryConstraint(myConstraint); } -void SketchSolver_ConstraintFixed::getAttributes(EntityWrapperPtr& theBaseEntity, - EntityWrapperPtr& theFixedEntity) +EntityWrapperPtr SketchSolver_ConstraintFixed::entityToFix() { - if (myBaseFeature) { - // if the feature is copy, do not move it - std::shared_ptr aSketchFeature = - std::dynamic_pointer_cast(myBaseFeature); - if (aSketchFeature && aSketchFeature->isCopy()) { - myStorage->setNeedToResolve(true); - return; - } - - bool fixFullFeature = false; - theBaseEntity = EntityWrapperPtr(); - theFixedEntity = EntityWrapperPtr(); - - // The feature is fixed. - PlaneGCSSolver_FeatureBuilder aBuilder; - std::list aBaseAttr = myBaseFeature->data()->attributes(std::string()); - std::list::const_iterator anIt = aBaseAttr.begin(); - for (; anIt != aBaseAttr.end(); ++anIt) { - EntityWrapperPtr anEntity = aBuilder.createAttribute(*anIt); - EntityWrapperPtr aBaseEntity = myStorage->entity(*anIt); - if (!anEntity || !aBaseEntity) - continue; - - if (!fixFullFeature && anEntity->type() == ENTITY_POINT && - !isEqual(anEntity, aBaseEntity)) { - if (theFixedEntity) - fixFullFeature = true; - theFixedEntity = anEntity; - theBaseEntity = aBaseEntity; - } - } - - if (fixFullFeature) { - theFixedEntity = aBuilder.createFeature(myBaseFeature); - theBaseEntity = myStorage->entity(myBaseFeature); - if (isEqual(theBaseEntity, theFixedEntity)) - theBaseEntity = EntityWrapperPtr(); // do not want to fix already fixed entity - } - - } else if (myBaseConstraint) { - // Constraint Fixed is added by user. - // Get the attribute of constraint (it should be alone in the list of constraints). - EntityWrapperPtr aValue; - std::vector anAttributes; - SketchSolver_Constraint::getAttributes(aValue, anAttributes); - std::vector::const_iterator anIt = anAttributes.begin(); - for (; anIt != anAttributes.end(); ++anIt) - if (*anIt) - theBaseEntity = *anIt; - } else - myErrorMsg = SketchSolver_Error::NOT_INITIALIZED(); + // Constraint Fixed is added by user. + // Get the attribute of constraint (it should be alone in the list of constraints). + EntityWrapperPtr aValue; + std::vector anAttributes; + SketchSolver_Constraint::getAttributes(aValue, anAttributes); + std::vector::const_iterator anIt = anAttributes.begin(); + for (; anIt != anAttributes.end(); ++anIt) + if (*anIt) + return *anIt; + return EntityWrapperPtr(); } -void SketchSolver_ConstraintFixed::moveFeature() -{ - if (!myFixedEntity) - return; - - GCS::VEC_pD aFixedParams = toParameters(myFixedEntity); - for (int i = 0; i < aFixedParams.size() && i < myFixedValues.size(); ++i) - myFixedValues[i] = *(aFixedParams[i]); - // Remove fixed entity due to its parameters already copied into the constraint - PlaneGCSSolver_EntityDestroyer aDestroyer; - aDestroyer.remove(myFixedEntity); - std::dynamic_pointer_cast(myStorage)->removeParameters( - aDestroyer.parametersToRemove()); - - myFixedEntity = EntityWrapperPtr(); -} - - -// ==================== Auxiliary functions =============================== +// ================== Auxiliary functions ================== GCS::VEC_pD toParameters(const EntityWrapperPtr& theEntity) { GCS::VEC_pD aParameters; @@ -207,29 +141,41 @@ GCS::VEC_pD toParameters(const EntityWrapperPtr& theEntity) aParameters.push_back(anArc->endAngle); break; } + case ENTITY_ELLIPSE: { + std::shared_ptr anEllipse = + std::dynamic_pointer_cast(anEntity->entity()); + aParameters.push_back(anEllipse->center.x); + aParameters.push_back(anEllipse->center.y); + aParameters.push_back(anEllipse->focus1.x); + aParameters.push_back(anEllipse->focus1.y); + aParameters.push_back(anEllipse->radmin); + break; + } + case ENTITY_ELLIPTIC_ARC: { + std::shared_ptr anEllArc = + std::dynamic_pointer_cast(anEntity->entity()); + aParameters.push_back(anEllArc->center.x); + aParameters.push_back(anEllArc->center.y); + aParameters.push_back(anEllArc->focus1.x); + aParameters.push_back(anEllArc->focus1.y); + aParameters.push_back(anEllArc->radmin); + aParameters.push_back(anEllArc->startAngle); + aParameters.push_back(anEllArc->endAngle); + break; + } + case ENTITY_BSPLINE: { + std::shared_ptr aBSpline = + std::dynamic_pointer_cast(anEntity->entity()); + for (GCS::VEC_P::iterator anIt = aBSpline->poles.begin(); + anIt != aBSpline->poles.end(); ++anIt) { + aParameters.push_back(anIt->x); + aParameters.push_back(anIt->y); + } + break; + } default: break; } return aParameters; } - -bool isEqual(const GCS::Point& thePoint1, const GCS::Point& thePoint2) -{ - return fabs((*thePoint1.x) - (*thePoint2.x)) <= tolerance && - fabs((*thePoint1.y) - (*thePoint2.y)) <= tolerance; -} - -bool isEqual(const EntityWrapperPtr& theEntity1, const EntityWrapperPtr& theEntity2) -{ - GCS::VEC_pD aParamList1 = toParameters(theEntity1); - GCS::VEC_pD aParamList2 = toParameters(theEntity2); - - GCS::VEC_pD::const_iterator anIt1 = aParamList1.begin(); - GCS::VEC_pD::const_iterator anIt2 = aParamList2.begin(); - for (; anIt1 != aParamList1.end() && anIt2 != aParamList2.end(); ++anIt1, ++anIt2) - if (fabs((**anIt1) - (**anIt2)) > tolerance) - return false; - - return anIt1 == aParamList1.end() && anIt2 == aParamList2.end(); -}