src/SketchSolver/SketchSolver_ConstraintFixed.cpp

   1 // Copyright (C) 2014-2023  CEA/DEN, EDF R&D
   2 //
   3 // This library is free software; you can redistribute it and/or
   4 // modify it under the terms of the GNU Lesser General Public
   5 // License as published by the Free Software Foundation; either
   6 // version 2.1 of the License, or (at your option) any later version.
   7 //
   8 // This library is distributed in the hope that it will be useful,
   9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 // Lesser General Public License for more details.
  12 //
  13 // You should have received a copy of the GNU Lesser General Public
  14 // License along with this library; if not, write to the Free Software
  15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16 //
  17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  18 //
  19
  20 #include <SketchSolver_ConstraintFixed.h>
  21 #include <SketchSolver_Error.h>
  22
  23 #include <PlaneGCSSolver_ConstraintWrapper.h>
  24 #include <PlaneGCSSolver_EdgeWrapper.h>
  25 #include <PlaneGCSSolver_EntityDestroyer.h>
  26 #include <PlaneGCSSolver_FeatureBuilder.h>
  27 #include <PlaneGCSSolver_PointWrapper.h>
  28
  29 #include <GeomDataAPI_Point2D.h>
  30 #include <SketchPlugin_Feature.h>
  31
  32 /// \brief Get list of parameters of current entity
  33 static GCS::VEC_pD toParameters(const EntityWrapperPtr& theEntity);
  34
  35
  36 SketchSolver_ConstraintFixed::SketchSolver_ConstraintFixed(ConstraintPtr theConstraint)
  37   : SketchSolver_Constraint(theConstraint)
  38 {
  39   myType = CONSTRAINT_FIXED;
  40 }
  41
  42 void SketchSolver_ConstraintFixed::blockEvents(bool isBlocked)
  43 {
  44   SketchSolver_Constraint::blockEvents(isBlocked);
  45 }
  46
  47 void SketchSolver_ConstraintFixed::process()
  48 {
  49   cleanErrorMsg();
  50   if (!myBaseConstraint || !myStorage) {
  51     // Not enough parameters are assigned
  52     return;
  53   }
  54
  55   EntityWrapperPtr aBaseEntity = entityToFix();
  56   if (!aBaseEntity)
  57     myErrorMsg = SketchSolver_Error::ALREADY_FIXED();
  58   if (!myErrorMsg.empty())
  59     return;
  60
  61   ConstraintWrapperPtr aConstraint = fixFeature(aBaseEntity);
  62   myStorage->addConstraint(myBaseConstraint, aConstraint);
  63 }
  64
  65 ConstraintWrapperPtr SketchSolver_ConstraintFixed::fixFeature(EntityWrapperPtr theFeature)
  66 {
  67   GCS::VEC_pD aParameters = toParameters(theFeature);
  68
  69   // Fix given list of parameters
  70   std::list<GCSConstraintPtr> aConstraints;
  71   myFixedValues.reserve(aParameters.size());
  72   GCS::VEC_pD::const_iterator anIt = aParameters.begin();
  73   for (int i = 0; anIt != aParameters.end(); ++anIt, ++i) {
  74     myFixedValues.push_back(**anIt);
  75     aConstraints.push_back(
  76         GCSConstraintPtr(new GCS::ConstraintEqual(&myFixedValues[i], *anIt)));
  77   }
  78
  79   return ConstraintWrapperPtr(
  80       new PlaneGCSSolver_ConstraintWrapper(aConstraints, getType()));
  81 }
  82
  83 EntityWrapperPtr SketchSolver_ConstraintFixed::entityToFix()
  84 {
  85   // Constraint Fixed is added by user.
  86   // Get the attribute of constraint (it should be alone in the list of constraints).
  87   EntityWrapperPtr aValue;
  88   std::vector<EntityWrapperPtr> anAttributes;
  89   SketchSolver_Constraint::getAttributes(aValue, anAttributes);
  90   std::vector<EntityWrapperPtr>::const_iterator anIt = anAttributes.begin();
  91   for (; anIt != anAttributes.end(); ++anIt)
  92     if (*anIt)
  93       return *anIt;
  94   return EntityWrapperPtr();
  95 }
  96
  97
  98
  99
 100 // ==================     Auxiliary functions     ==================
 101 GCS::VEC_pD toParameters(const EntityWrapperPtr& theEntity)
 102 {
 103   GCS::VEC_pD aParameters;
 104   if (!theEntity)
 105     return aParameters;
 106
 107   std::shared_ptr<PlaneGCSSolver_EdgeWrapper> anEntity =
 108       std::dynamic_pointer_cast<PlaneGCSSolver_EdgeWrapper>(theEntity);
 109
 110   // Collect parameters for each type of entity
 111   switch (theEntity->type()) {
 112   case ENTITY_POINT: {
 113     std::shared_ptr<PlaneGCSSolver_PointWrapper> aPoint =
 114         std::dynamic_pointer_cast<PlaneGCSSolver_PointWrapper>(theEntity);
 115     aParameters.push_back(aPoint->point()->x);
 116     aParameters.push_back(aPoint->point()->y);
 117     break;
 118     }
 119   case ENTITY_LINE: {
 120     std::shared_ptr<GCS::Line> aLine = std::dynamic_pointer_cast<GCS::Line>(anEntity->entity());
 121     aParameters.push_back(aLine->p1.x);
 122     aParameters.push_back(aLine->p1.y);
 123     aParameters.push_back(aLine->p2.x);
 124     aParameters.push_back(aLine->p2.y);
 125     break;
 126     }
 127   case ENTITY_CIRCLE: {
 128     std::shared_ptr<GCS::Circle> aCircle =
 129         std::dynamic_pointer_cast<GCS::Circle>(anEntity->entity());
 130     aParameters.push_back(aCircle->center.x);
 131     aParameters.push_back(aCircle->center.y);
 132     aParameters.push_back(aCircle->rad);
 133     break;
 134     }
 135   case ENTITY_ARC: {
 136     std::shared_ptr<GCS::Arc> anArc = std::dynamic_pointer_cast<GCS::Arc>(anEntity->entity());
 137     aParameters.push_back(anArc->center.x);
 138     aParameters.push_back(anArc->center.y);
 139     aParameters.push_back(anArc->rad);
 140     aParameters.push_back(anArc->startAngle);
 141     aParameters.push_back(anArc->endAngle);
 142     break;
 143     }
 144   case ENTITY_ELLIPSE: {
 145     std::shared_ptr<GCS::Ellipse> anEllipse =
 146         std::dynamic_pointer_cast<GCS::Ellipse>(anEntity->entity());
 147     aParameters.push_back(anEllipse->center.x);
 148     aParameters.push_back(anEllipse->center.y);
 149     aParameters.push_back(anEllipse->focus1.x);
 150     aParameters.push_back(anEllipse->focus1.y);
 151     aParameters.push_back(anEllipse->radmin);
 152     break;
 153     }
 154   case ENTITY_ELLIPTIC_ARC: {
 155     std::shared_ptr<GCS::ArcOfEllipse> anEllArc =
 156         std::dynamic_pointer_cast<GCS::ArcOfEllipse>(anEntity->entity());
 157     aParameters.push_back(anEllArc->center.x);
 158     aParameters.push_back(anEllArc->center.y);
 159     aParameters.push_back(anEllArc->focus1.x);
 160     aParameters.push_back(anEllArc->focus1.y);
 161     aParameters.push_back(anEllArc->radmin);
 162     aParameters.push_back(anEllArc->startAngle);
 163     aParameters.push_back(anEllArc->endAngle);
 164     break;
 165     }
 166   case ENTITY_BSPLINE: {
 167     std::shared_ptr<GCS::BSpline> aBSpline =
 168         std::dynamic_pointer_cast<GCS::BSpline>(anEntity->entity());
 169     for (GCS::VEC_P::iterator anIt = aBSpline->poles.begin();
 170          anIt != aBSpline->poles.end(); ++anIt) {
 171       aParameters.push_back(anIt->x);
 172       aParameters.push_back(anIt->y);
 173     }
 174     break;
 175   }
 176   default:
 177     break;
 178   }
 179
 180   return aParameters;
 181 }