src/SketchSolver/SketchSolver_Constraint.h

   1 // Copyright (C) 2014-20xx CEA/DEN, EDF R&D
   2
   3 // File:    SketchSolver_Constraint.h
   4 // Created: 27 May 2014
   5 // Author:  Artem ZHIDKOV
   6
   7 #ifndef SketchSolver_Constraint_H_
   8 #define SketchSolver_Constraint_H_
   9
  10 #include "SketchSolver.h"
  11 #include <SketchSolver_Storage.h>
  12
  13 #include <SketchPlugin_Constraint.h>
  14
  15 #include <ModelAPI_AttributeRefAttr.h>
  16
  17 #include <string>
  18 #include <vector>
  19
  20 class SketchSolver_Group;
  21
  22 /** \class   SketchSolver_Constraint
  23  *  \ingroup Plugins
  24  *  \brief   Stores mapping between SketchPlugin and SolveSpace constraints data
  25  */
  26 class SketchSolver_Constraint
  27 {
  28 protected:
  29   /// Default constructor
  30   SketchSolver_Constraint() {}
  31   SketchSolver_Constraint(ConstraintPtr theConstraint);
  32
  33 public:
  34   virtual ~SketchSolver_Constraint();
  35
  36   /// \brief Initializes the storage of SolveSpace constraints
  37   void setStorage(StoragePtr theStorage);
  38   /// \brief Initializes group ID for this constraint
  39   void setGroup(SketchSolver_Group* theGroup);
  40
  41   /// \brief Update constraint
  42   virtual void update(ConstraintPtr theConstraint = ConstraintPtr());
  43
  44   /// \brief Tries to remove constraint
  45   /// \return \c false, if current constraint contains another SketchPlugin constraints (like for multiple coincidence)
  46   virtual bool remove(ConstraintPtr theConstraint = ConstraintPtr());
  47
  48   /// \brief Update SketchPlugin attributes using the data obtained from SolveSpace entities
  49   void refresh();
  50
  51   /// \brief Returns the type of constraint
  52   virtual int getType() const = 0;
  53
  54   /// \brief The constraint is made temoparary
  55   void makeTemporary() const;
  56
  57   /// \brief Checks the constraint is used by current object
  58   virtual bool hasConstraint(ConstraintPtr theConstraint) const
  59   { return theConstraint == myBaseConstraint; }
  60
  61   /// \brief Return list of SketchPlugin constraints attached to this object
  62   virtual std::list<ConstraintPtr> constraints() const;
  63
  64   /// \brief Return identifier of SolveSpace entity relating to the feature
  65   Slvs_hEntity getId(FeaturePtr theFeature) const;
  66   /// \brief Return identifier of SolveSpace entity relating to the attribute
  67   Slvs_hEntity getId(AttributePtr theAttribute) const;
  68
  69   /// \brief Adds a feature to constraint and create its analogue in SolveSpace
  70   virtual void addFeature(FeaturePtr theFeature);
  71
  72   /// \brief Shows error message
  73   const std::string& error() const
  74   { return myErrorMsg; }
  75
  76 protected:
  77   /// \brief Converts SketchPlugin constraint to a list of SolveSpace constraints
  78   virtual void process();
  79
  80   /// \brief Generate list of attributes of constraint in order useful for SolveSpace constraints
  81   /// \param[out] theValue      numerical characteristic of constraint (e.g. distance)
  82   /// \param[out] theAttributes list of attributes to be filled
  83   virtual void getAttributes(double& theValue, std::vector<Slvs_hEntity>& theAttributes);
  84
  85   /// \brief Verify the attributes of constraint are changed (and constraint need to rebuild)
  86   /// \param[in] theConstraint constraint, which attributes should be checked (if NULL, the myBaseConstraint is used)
  87   /// \return \c true if some attributes are changed
  88   virtual bool checkAttributesChanged(ConstraintPtr theConstraint);
  89
  90   /// \brief This method is used in derived objects to check consistence of constraint.
  91   ///        E.g. the distance between line and point may be signed.
  92   virtual void adjustConstraint()
  93   {}
  94
  95   /// \brief Create or change SlveSpace entity according to the given attribute
  96   /// \param[in]  theAttribute  reference to the entity to be changed
  97   /// \param[out] theType       type of created entity
  98   /// \return identifier of created/updated entity
  99   Slvs_hEntity changeEntity(AttributeRefAttrPtr theAttribute, int& theType);
 100   /// \brief Create or change SlveSpace entity according to the given attribute
 101   Slvs_hEntity changeEntity(AttributePtr theAttribute, int& theType);
 102   /// \brief Create or change SlveSpace entity according to the given feature
 103   Slvs_hEntity changeEntity(FeaturePtr theFeature, int& theType);
 104
 105   /// \brief Calculate middle point on the specified entity
 106   /// \param[in]  theEntity  arc or line
 107   /// \param[in]  theCoeff   is a value in [0.0, 1.0] which shows the position of the point on the entity (0.0 - start point, 1.0 - end point)
 108   /// \param[out] theX       X coordinate of middle point
 109   /// \param[out] theY       Y coordinate of middle point
 110   void calculateMiddlePoint(const Slvs_Entity& theEntity, double theCoeff,
 111                             double& theX, double& theY) const;
 112
 113   /// \brief Removes the links to unused entities
 114   void cleanRemovedEntities();
 115
 116   /// \brief Removes last error
 117   void cleanErrorMsg()
 118   { myErrorMsg.clear(); }
 119
 120 private:
 121   /// \brief Sets error, if the attribute is not initialized
 122   bool isInitialized(AttributePtr theAttribute);
 123
 124 protected:
 125   SketchSolver_Group* myGroup; ///< the group which contains current constraint
 126   ConstraintPtr myBaseConstraint; ///< SketchPlugin constraint
 127   std::vector<Slvs_hConstraint> mySlvsConstraints; ///< list of indices of SolveSpace constraints, together which equivalent to SketchPlugin constraint
 128   std::map<FeaturePtr, Slvs_hEntity> myFeatureMap; ///< map feature to the entity it represents
 129   std::map<AttributePtr, Slvs_hEntity> myAttributeMap; ///< map attribute to the corresponding entity
 130   std::map<AttributePtr, Slvs_hParam> myValueMap; ///< list of attributes, which represents single value (e.g. distance) used in constraint
 131   StoragePtr myStorage; ///< storage, which contains all information about entities and constraints in current group
 132
 133   std::string myErrorMsg; ///< error message
 134 };
 135
 136 typedef std::shared_ptr<SketchSolver_Constraint> SolverConstraintPtr;
 137
 138
 139
 140 /** \class   SketchSolver_ConstraintParallel
 141  *  \ingroup Plugins
 142  *  \brief   Convert Parallel constraint to SolveSpace structure
 143  */
 144 class SketchSolver_ConstraintParallel : public SketchSolver_Constraint
 145 {
 146 public:
 147   SketchSolver_ConstraintParallel(ConstraintPtr theConstraint) :
 148       SketchSolver_Constraint(theConstraint)
 149   {}
 150
 151   virtual int getType() const
 152   { return SLVS_C_PARALLEL; }
 153 };
 154
 155
 156 /** \class   SketchSolver_ConstraintPerpendicular
 157  *  \ingroup Plugins
 158  *  \brief   Convert Perpendicular constraint to SolveSpace structure
 159  */
 160 class SketchSolver_ConstraintPerpendicular : public SketchSolver_Constraint
 161 {
 162 public:
 163   SketchSolver_ConstraintPerpendicular(ConstraintPtr theConstraint) :
 164       SketchSolver_Constraint(theConstraint)
 165   {}
 166
 167   virtual int getType() const
 168   { return SLVS_C_PERPENDICULAR; }
 169 };
 170
 171
 172 /** \class   SketchSolver_ConstraintHorizontal
 173  *  \ingroup Plugins
 174  *  \brief   Convert Horizontal constraint to SolveSpace structure
 175  */
 176 class SketchSolver_ConstraintHorizontal : public SketchSolver_Constraint
 177 {
 178 public:
 179   SketchSolver_ConstraintHorizontal(ConstraintPtr theConstraint) :
 180       SketchSolver_Constraint(theConstraint)
 181   {}
 182
 183   virtual int getType() const
 184   { return SLVS_C_HORIZONTAL; }
 185 };
 186
 187
 188 /** \class   SketchSolver_ConstraintVertical
 189  *  \ingroup Plugins
 190  *  \brief   Convert Vertical constraint to SolveSpace structure
 191  */
 192 class SketchSolver_ConstraintVertical : public SketchSolver_Constraint
 193 {
 194 public:
 195   SketchSolver_ConstraintVertical(ConstraintPtr theConstraint) :
 196       SketchSolver_Constraint(theConstraint)
 197   {}
 198
 199   virtual int getType() const
 200   { return SLVS_C_VERTICAL; }
 201 };
 202
 203
 204 /** \class   SketchSolver_ConstraintRadius
 205  *  \ingroup Plugins
 206  *  \brief   Convert Radius constraint to SolveSpace structure
 207  */
 208 class SketchSolver_ConstraintRadius : public SketchSolver_Constraint
 209 {
 210 public:
 211   SketchSolver_ConstraintRadius(ConstraintPtr theConstraint) :
 212       SketchSolver_Constraint(theConstraint)
 213   {}
 214
 215   virtual int getType() const
 216   { return SLVS_C_DIAMETER; }
 217
 218   virtual void adjustConstraint()
 219   {
 220     Slvs_Constraint aConstraint = myStorage->getConstraint(mySlvsConstraints.front());
 221     aConstraint.valA *= 2.0;
 222     myStorage->updateConstraint(aConstraint);
 223   }
 224 };
 225
 226
 227 /** \class   SketchSolver_ConstraintAngle
 228  *  \ingroup Plugins
 229  *  \brief   Convert Agnle constraint to SolveSpace structure
 230  */
 231 class SketchSolver_ConstraintAngle : public SketchSolver_Constraint
 232 {
 233 public:
 234   SketchSolver_ConstraintAngle(ConstraintPtr theConstraint) :
 235       SketchSolver_Constraint(theConstraint)
 236   {}
 237
 238   virtual int getType() const
 239   { return SLVS_C_ANGLE; }
 240
 241   virtual void adjustConstraint()
 242   {
 243     Slvs_Constraint aConstraint = myStorage->getConstraint(mySlvsConstraints.front());
 244     aConstraint.other = aConstraint.valA >= 0.0;
 245     myStorage->updateConstraint(aConstraint);
 246   }
 247 };
 248
 249 #endif