+// 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 <SketchSolver_ConstraintFixed.h>
#include <SketchSolver_Error.h>
-#include <SketchSolver_Manager.h>
-#include <SketchPlugin_Arc.h>
-#include <SketchPlugin_Circle.h>
-#include <SketchPlugin_ConstraintRigid.h>
-#include <SketchPlugin_Line.h>
-#include <SketchPlugin_Point.h>
+#include <PlaneGCSSolver_ConstraintWrapper.h>
+#include <PlaneGCSSolver_EdgeWrapper.h>
+#include <PlaneGCSSolver_EntityDestroyer.h>
+#include <PlaneGCSSolver_FeatureBuilder.h>
+#include <PlaneGCSSolver_PointWrapper.h>
-#include <GeomAPI_Pnt2d.h>
-#include <GeomAPI_XY.h>
#include <GeomDataAPI_Point2D.h>
-#include <ModelAPI_AttributeDouble.h>
+#include <SketchPlugin_Feature.h>
+
+/// \brief Get list of parameters of current entity
+static GCS::VEC_pD toParameters(const EntityWrapperPtr& theEntity);
-#include <math.h>
SketchSolver_ConstraintFixed::SketchSolver_ConstraintFixed(ConstraintPtr theConstraint)
- : SketchSolver_Constraint()
+ : SketchSolver_Constraint(theConstraint)
{
- myBaseConstraint = theConstraint;
myType = CONSTRAINT_FIXED;
- myFixedAttribute = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(
- theConstraint->attribute(SketchPlugin_ConstraintRigid::ENTITY_A()));
}
-SketchSolver_ConstraintFixed::SketchSolver_ConstraintFixed(FeaturePtr theFeature)
- : SketchSolver_Constraint(),
- myBaseFeature(theFeature)
+void SketchSolver_ConstraintFixed::blockEvents(bool isBlocked)
{
- myType = CONSTRAINT_FIXED;
- process();
+ SketchSolver_Constraint::blockEvents(isBlocked);
}
void SketchSolver_ConstraintFixed::process()
{
cleanErrorMsg();
- if ((!myBaseConstraint && !myBaseFeature) || !myStorage || myGroupID == GID_UNKNOWN) {
+ if (!myBaseConstraint || !myStorage) {
// Not enough parameters are assigned
return;
}
- ParameterWrapperPtr aValue;
- std::vector<EntityWrapperPtr> anEntities;
- getAttributes(aValue, anEntities);
- if (!myErrorMsg.empty() || anEntities.empty())
+ EntityWrapperPtr aBaseEntity = entityToFix();
+ if (!aBaseEntity)
+ myErrorMsg = SketchSolver_Error::ALREADY_FIXED();
+ if (!myErrorMsg.empty())
return;
- fixFeature(anEntities.front());
+
+ ConstraintWrapperPtr aConstraint = fixFeature(aBaseEntity);
+ myStorage->addConstraint(myBaseConstraint, aConstraint);
}
-void SketchSolver_ConstraintFixed::fixFeature(EntityWrapperPtr theFeature)
+ConstraintWrapperPtr SketchSolver_ConstraintFixed::fixFeature(EntityWrapperPtr theFeature)
{
- // extract feature from the group
- if (theFeature->baseAttribute())
- myStorage->update(theFeature->baseAttribute(), GID_OUTOFGROUP);
- else if (theFeature->baseFeature())
- myStorage->update(theFeature->baseFeature(), GID_OUTOFGROUP);
+ GCS::VEC_pD aParameters = toParameters(theFeature);
+
+ // Fix given list of parameters
+ std::list<GCSConstraintPtr> aConstraints;
+ myFixedValues.reserve(aParameters.size());
+ GCS::VEC_pD::const_iterator anIt = aParameters.begin();
+ for (int i = 0; anIt != aParameters.end(); ++anIt, ++i) {
+ myFixedValues.push_back(**anIt);
+ aConstraints.push_back(
+ GCSConstraintPtr(new GCS::ConstraintEqual(&myFixedValues[i], *anIt)));
+ }
+
+ return ConstraintWrapperPtr(
+ new PlaneGCSSolver_ConstraintWrapper(aConstraints, getType()));
}
-void SketchSolver_ConstraintFixed::getAttributes(
- ParameterWrapperPtr& theValue,
- std::vector<EntityWrapperPtr>& theAttributes)
+EntityWrapperPtr SketchSolver_ConstraintFixed::entityToFix()
{
- BuilderPtr aBuilder = SketchSolver_Manager::instance()->builder();
-
- EntityWrapperPtr aSolverEntity;
- if (myBaseFeature) {
- // The feature is fixed.
- myStorage->update(myBaseFeature, myGroupID);
- aSolverEntity = myStorage->entity(myBaseFeature);
- } else if (myBaseConstraint) {
- // Constraint Fixed is added by user.
- // Get the attribute of constraint (it should be alone in the list of constraints).
- AttributePtr anAttr = myBaseConstraint->attribute(SketchPlugin_ConstraintRigid::ENTITY_A());
- AttributeRefAttrPtr aRefAttr =
- std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(anAttr);
- if (!aRefAttr || !aRefAttr->isInitialized()) {
- myErrorMsg = SketchSolver_Error::NOT_INITIALIZED();
- return;
- }
+ // Constraint Fixed is added by user.
+ // Get the attribute of constraint (it should be alone in the list of constraints).
+ EntityWrapperPtr aValue;
+ std::vector<EntityWrapperPtr> anAttributes;
+ SketchSolver_Constraint::getAttributes(aValue, anAttributes);
+ std::vector<EntityWrapperPtr>::const_iterator anIt = anAttributes.begin();
+ for (; anIt != anAttributes.end(); ++anIt)
+ if (*anIt)
+ return *anIt;
+ return EntityWrapperPtr();
+}
- myStorage->update(anAttr, myGroupID);
- aSolverEntity = myStorage->entity(anAttr);
- } else
- myErrorMsg = SketchSolver_Error::NOT_INITIALIZED();
- if (aSolverEntity)
- theAttributes.push_back(aSolverEntity);
-}
-bool SketchSolver_ConstraintFixed::remove()
+// ================== Auxiliary functions ==================
+GCS::VEC_pD toParameters(const EntityWrapperPtr& theEntity)
{
- cleanErrorMsg();
- // Move fixed entities back to the current group
- FeaturePtr aFeature = myBaseFeature;
- if (myBaseConstraint && myFixedAttribute && myFixedAttribute->isObject())
- aFeature = ModelAPI_Feature::feature(myFixedAttribute->object());
- if (aFeature)
- myStorage->update(aFeature, myGroupID);
- else if (myFixedAttribute)
- myStorage->update(AttributePtr(myFixedAttribute), myGroupID);
-
- // Remove constraint or base feature
- if (myBaseConstraint) {
- bool isRemoved = false;
- if (aFeature)
- isRemoved = myStorage->removeEntity(aFeature);
- return SketchSolver_Constraint::remove() || isRemoved;
- } else if (myBaseFeature)
- myStorage->removeEntity(myBaseFeature);
- return true;
+ GCS::VEC_pD aParameters;
+ if (!theEntity)
+ return aParameters;
+
+ std::shared_ptr<PlaneGCSSolver_EdgeWrapper> anEntity =
+ std::dynamic_pointer_cast<PlaneGCSSolver_EdgeWrapper>(theEntity);
+
+ // Collect parameters for each type of entity
+ switch (theEntity->type()) {
+ case ENTITY_POINT: {
+ std::shared_ptr<PlaneGCSSolver_PointWrapper> aPoint =
+ std::dynamic_pointer_cast<PlaneGCSSolver_PointWrapper>(theEntity);
+ aParameters.push_back(aPoint->point()->x);
+ aParameters.push_back(aPoint->point()->y);
+ break;
+ }
+ case ENTITY_LINE: {
+ std::shared_ptr<GCS::Line> aLine = std::dynamic_pointer_cast<GCS::Line>(anEntity->entity());
+ aParameters.push_back(aLine->p1.x);
+ aParameters.push_back(aLine->p1.y);
+ aParameters.push_back(aLine->p2.x);
+ aParameters.push_back(aLine->p2.y);
+ break;
+ }
+ case ENTITY_CIRCLE: {
+ std::shared_ptr<GCS::Circle> aCircle =
+ std::dynamic_pointer_cast<GCS::Circle>(anEntity->entity());
+ aParameters.push_back(aCircle->center.x);
+ aParameters.push_back(aCircle->center.y);
+ aParameters.push_back(aCircle->rad);
+ break;
+ }
+ case ENTITY_ARC: {
+ std::shared_ptr<GCS::Arc> anArc = std::dynamic_pointer_cast<GCS::Arc>(anEntity->entity());
+ aParameters.push_back(anArc->center.x);
+ aParameters.push_back(anArc->center.y);
+ aParameters.push_back(anArc->rad);
+ aParameters.push_back(anArc->startAngle);
+ aParameters.push_back(anArc->endAngle);
+ break;
+ }
+ case ENTITY_ELLIPSE: {
+ std::shared_ptr<GCS::Ellipse> anEllipse =
+ std::dynamic_pointer_cast<GCS::Ellipse>(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<GCS::ArcOfEllipse> anEllArc =
+ std::dynamic_pointer_cast<GCS::ArcOfEllipse>(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<GCS::BSpline> aBSpline =
+ std::dynamic_pointer_cast<GCS::BSpline>(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;
}