src/SketchPlugin/SketchPlugin_ConstraintSplit.h

   1 // Copyright (C) 2014-20xx CEA/DEN, EDF R&D -->
   2
   3 // File:    SketchPlugin_ConstraintSplit.h
   4 // Created: 25 Aug 2016
   5 // Author:  Natalia ERMOLAEVA
   6
   7 #ifndef SketchPlugin_ConstraintSplit_H_
   8 #define SketchPlugin_ConstraintSplit_H_
   9
  10 #include "SketchPlugin.h"
  11 #include <SketchPlugin_Sketch.h>
  12 #include "SketchPlugin_ConstraintBase.h"
  13
  14 class GeomDataAPI_Point2D;
  15 class ModelAPI_Feature;
  16 class ModelAPI_Result;
  17
  18 typedef std::pair<std::string, std::shared_ptr<GeomDataAPI_Point2D> > IdToPointPair;
  19
  20 /** \class SketchPlugin_ConstraintSplit
  21  *  \ingroup Plugins
  22  *  \brief Feature for creation of a new constraint splitting object. Entities for split:
  23  * - Linear segment by point(s) on this line
  24  * - Arc by point(s) on this arc
  25  * - Circle by at least 2 split-points on this circle
  26  *
  27  * The following constraints will be applied after split to keep the divided segments geometry:
  28  * - Coincident constraints for both parts of created segments in the point of splitting
  29  * - For linear segments parallel, for circles - tangent constraint, for arc - tangent and equal
  30  *   constraints. In case of three segments in result two couple of constraints are created
  31  *    - parallel and equal constraints: the first is between 1st and middle entity, the second is
  32  *      between 1st and 3rd.
  33  *    - tangency constraints: the first between 1st and 2nd, the second between 2nd and 3rd.
  34  * - Constraints assigned to the feature before split operation are assigned after using rules:
  35  *    - Coincident constraints are assigned to the segment where they belong to. Segment of split
  36  *      has only a coincidence to the neighbor segment. All constraints used in the splitting of
  37  *      this segment are moved to point of neighbor segment. If constraint was initially built
  38  *      to the point of splitting segment, it stays for this point.
  39  *    - Geometrical and dimensional constraints are assigned to one of result segment, not the
  40  *      selected for split. In case of 3 result segments, this will be the segment nearest to the
  41  *      start point of arc/line.
  42  *    - Replication constraint used split feature will be deleted in the same way as it is deleted
  43  *      by any of entity delete in sketch which is used in this constraint.
  44  *
  45  *  This constraint has three attributes:
  46  *  SketchPlugin_Constraint::VALUE() contains reference object to be splitted
  47  *  SketchPlugin_Constraint::ENTITY_A() and SketchPlugin_Constraint::ENTITY_B() for the points of split;
  48  *
  49  */
  50 class SketchPlugin_ConstraintSplit : public SketchPlugin_ConstraintBase
  51 {
  52  public:
  53   /// Split constraint kind
  54   inline static const std::string& ID()
  55   {
  56     static const std::string MY_CONSTRAINT_SPLIT_ID("SketchConstraintSplit");
  57     return MY_CONSTRAINT_SPLIT_ID;
  58   }
  59   /// \brief Returns the kind of a feature
  60   SKETCHPLUGIN_EXPORT virtual const std::string& getKind()
  61   {
  62     static std::string MY_KIND = SketchPlugin_ConstraintSplit::ID();
  63     return MY_KIND;
  64   }
  65
  66   /// \brief Creates a new part document if needed
  67   SKETCHPLUGIN_EXPORT virtual void execute();
  68
  69   /// \brief Request for initialization of data model of the feature: adding all attributes
  70   SKETCHPLUGIN_EXPORT virtual void initAttributes();
  71
  72   /// Reimplemented from ModelAPI_Feature::isMacro().
  73   /// \returns true
  74   SKETCHPLUGIN_EXPORT virtual bool isMacro() const;
  75
  76   /// Reimplemented from ModelAPI_Feature::isPreviewNeeded(). Returns false.
  77   /// This is necessary to perform execute only by apply the feature
  78   SKETCHPLUGIN_EXPORT virtual bool isPreviewNeeded() const { return false; }
  79
  80   /// \brief Use plugin manager for features creation
  81   SketchPlugin_ConstraintSplit();
  82
  83   /// \return map of base points and features;
  84   //SKETCHPLUGIN_EXPORT const std::map<AttributePtr, FilletFeatures> pointsFeaturesMap() const {
  85   //  return myPointFeaturesMap;
  86   //};
  87
  88   /// Returns the AIS preview
  89   SKETCHPLUGIN_EXPORT virtual AISObjectPtr getAISObject(AISObjectPtr thePrevious);
  90
  91 private:
  92   /// Returns geom point attribute of the feature bounds. It processes line or arc.
  93   /// For circle feature, the result attributes are null
  94   /// \param theFeature a source feature
  95   /// \param theStartPointAttr an out attribute to start point
  96   /// \param theStartPointAttr an out attribute to end point
  97   void getFeaturePoints(const FeaturePtr& theFeature,
  98                         std::shared_ptr<GeomDataAPI_Point2D>& theStartPointAttr,
  99                         std::shared_ptr<GeomDataAPI_Point2D>& theEndPointAttr);
 100
 101   /// Returns cast of attribute to geometrical point if the attribute is a ref attr attribute
 102   /// \param theAttribute an attribute
 103   /// \param geom point 2D or NULL
 104   std::shared_ptr<GeomDataAPI_Point2D> getPointOfRefAttr(const AttributePtr& theAttribute);
 105
 106   /// Obtains those constraints of the feature that should be modified. output maps contain
 107   /// point of coincidence and attribute id to be modified after split
 108   /// \param theFeaturesToDelete [out] constrains that will be deleted after split
 109   /// \param theFeaturesToUpdate [out] constrains that will be updated after split
 110   /// \param theTangentFeatures  [out] tangent feature to be connected to new feature
 111   /// \param theCoincidenceToFeature [out] coincidence to feature to be connected to new feature
 112   /// \param theCoincidenceToPoint [out] coincidence to point be connected to new feature
 113   void getConstraints(std::set<std::shared_ptr<ModelAPI_Feature>>& theFeaturesToDelete,
 114               std::set<std::shared_ptr<ModelAPI_Feature>>& theFeaturesToUpdate,
 115               std::map<std::shared_ptr<ModelAPI_Feature>, IdToPointPair>& theTangentFeatures,
 116               std::map<std::shared_ptr<ModelAPI_Feature>, IdToPointPair>& theCoincidenceToFeature/*,
 117               std::map<std::shared_ptr<ModelAPI_Feature>, IdToPointPair>& theCoincidenceToPoint*/);
 118
 119   /// Obtains references to feature point attributes and to feature,
 120   /// e.g. for feature line: 1st container is
 121   ///             <1st line point, list<entity_a in distance, entity_b in parallel> >
 122   ///             <2nd line point, list<> >
 123   ///      for feature circle 2nd container is <entity_a in Radius, entity_b in equal, ...>
 124   /// \param theFeature an investigated feature
 125   /// \param theRefs a container of list of referenced attributes
 126   void getRefAttributes(const FeaturePtr& theFeature,
 127                         std::map<AttributePtr, std::list<AttributePtr> >& theRefs,
 128                         std::list<AttributePtr>& theRefsToFeature);
 129
 130   /// Move coincidence constraint from feature to point if it is found
 131   /// \param theCoincidenceToFeature coincidence to feature to be connected to new feature
 132   /// \param theFurtherCoincidences a list of points where coincidences will be build
 133   /// \param theFeatureResults created results after split where constaint might be connected
 134   /// \param theSplitFeature feature created by split, new coincidences to points should be created
 135   /// if theCoincidenceToFeature contains equal points
 136   void updateCoincidenceConstraintsToFeature(
 137       const std::map<std::shared_ptr<ModelAPI_Feature>, IdToPointPair>& theCoincidenceToFeature,
 138       const std::set<std::shared_ptr<GeomDataAPI_Point2D> >& theFurtherCoincidences,
 139       const std::set<ResultPtr>& theFeatureResults,
 140       const FeaturePtr& theSplitFeature);
 141
 142   /// Move tangency constraint to the nearest split feature that has a coincidence to the tangent
 143   /// \param theTangentFeatures tangencies to feature to be connected to nearest feature
 144   /// \param theFurtherCoincidences a list of points where coincidences is built
 145   void updateTangentConstraintsToFeature(
 146               const std::map<std::shared_ptr<ModelAPI_Feature>, IdToPointPair>& theTangentFeatures,
 147               const std::set<std::shared_ptr<GeomDataAPI_Point2D> >& theFurtherCoincidences);
 148
 149
 150   /// Move constraints from base feature to given feature
 151   /// \param theFeature a base feature
 152   /// \param theRefsToFeature list of attributes referenced to base feature
 153   void updateRefFeatureConstraints(const std::shared_ptr<ModelAPI_Result>& theFeatureBaseResult,
 154                                    const std::list<AttributePtr>& theRefsToFeature);
 155
 156   /// Move constraints from attribute of base feature to attribute after modification
 157   /// \param theBaseRefAttributes container of references to the attributes of base feature
 158   /// \param theModifiedAttributes container of attributes placed instead of base attributes
 159   /// at the same place
 160   void updateRefAttConstraints(
 161                const std::map<AttributePtr, std::list<AttributePtr> >& theBaseRefAttributes,
 162                const std::set<std::pair<AttributePtr, AttributePtr> >& theModifiedAttributes);
 163
 164   /// Make the base object is splitted by the point attributes
 165   /// \param theSplitFeature a result split feature
 166   /// \param theBeforeFeature a feature between start point and the 1st point of split feature
 167   /// \param theAfterFeature a feature between last point of split feature and the end point
 168   /// \param thePoints a list of points where coincidences will be build
 169   /// \param theCreatedFeatures a container of created features
 170   /// \param theModifiedAttributes a container of attribute on base
 171   /// feature to attribute on new feature
 172   void splitLine(std::shared_ptr<ModelAPI_Feature>& theSplitFeature,
 173                  std::shared_ptr<ModelAPI_Feature>& theBeforeFeature,
 174                  std::shared_ptr<ModelAPI_Feature>& theAfterFeature,
 175                  std::set<std::shared_ptr<GeomDataAPI_Point2D> >& thePoints,
 176                  std::set<std::shared_ptr<ModelAPI_Feature>>& theCreatedFeatures,
 177                  std::set<std::pair<AttributePtr, AttributePtr>>& theModifiedAttributes);
 178
 179   /// Make the base object is splitted by the point attributes
 180   /// \param theSplitFeature a result split feature
 181   /// \param theBeforeFeature a feature between start point and the 1st point of split feature
 182   /// \param theAfterFeature a feature between last point of split feature and the end point
 183   /// \param thePoints a list of points where coincidences will be build
 184   /// \param theCreatedFeatures a container of created features
 185   void splitArc(std::shared_ptr<ModelAPI_Feature>& theSplitFeature,
 186                 std::shared_ptr<ModelAPI_Feature>& theBeforeFeature,
 187                 std::shared_ptr<ModelAPI_Feature>& theAfterFeature,
 188                 std::set<std::shared_ptr<GeomDataAPI_Point2D> >& thePoints,
 189                 std::set<std::shared_ptr<ModelAPI_Feature>>& theCreatedFeatures,
 190                 std::set<std::pair<AttributePtr, AttributePtr>>& theModifiedAttributes);
 191
 192   /// Make the base object is splitted by the point attributes
 193   /// \param theSplitFeature a result split feature
 194   /// \param theBeforeFeature a feature between start point and the 1st point of split feature
 195   /// \param theAfterFeature a feature between last point of split feature and the end point
 196   /// \param thePoints a list of points where coincidences will be build
 197   /// \param theCreatedFeatures a container of created features
 198   void splitCircle(std::shared_ptr<ModelAPI_Feature>& theSplitFeature,
 199                    std::shared_ptr<ModelAPI_Feature>& theBeforeFeature,
 200                    std::shared_ptr<ModelAPI_Feature>& theAfterFeature,
 201                    std::set<std::shared_ptr<GeomDataAPI_Point2D> >& thePoints,
 202                    std::set<std::shared_ptr<ModelAPI_Feature>>& theCreatedFeatures,
 203                    std::set<std::pair<AttributePtr, AttributePtr>>& theModifiedAttributes);
 204
 205   /// Correct the first and the second point to provide condition that the first is closer to
 206   /// the start point and the second point - to the last end of current segment. To rearrange
 207   /// them if this condition is not satisfied.
 208   /// \param theStartPointAttr a start point of a segment
 209   /// \param theEndPointAttr an end point of a segment
 210   /// \param theFirstPointAttr a start point of a segment
 211   /// \param theSecondPointAttr an end point of a segment
 212   void arrangePointsOnLine(const std::shared_ptr<GeomDataAPI_Point2D>& theStartPointAttr,
 213                            const std::shared_ptr<GeomDataAPI_Point2D>& theEndPointAttr,
 214                            std::shared_ptr<GeomDataAPI_Point2D>& theFirstPointAttr,
 215                            std::shared_ptr<GeomDataAPI_Point2D>& theSecondPointAttr) const;
 216
 217   /// Correct the first and the second point to provide condition that the first is closer to
 218   /// the start point and the second point - to the last end of current segment. To rearrange
 219   /// them if this condition is not satisfied.
 220   /// \param theArc an arc to be split
 221   /// \param theStartPointAttr a start point of a segment
 222   /// \param theEndPointAttr an end point of a segment
 223   /// \param theFirstPointAttr a start point of a segment
 224   /// \param theSecondPointAttr an end point of a segment
 225   void arrangePointsOnArc(const FeaturePtr& theArc,
 226                           const std::shared_ptr<GeomDataAPI_Point2D>& theStartPointAttr,
 227                           const std::shared_ptr<GeomDataAPI_Point2D>& theEndPointAttr,
 228                           std::shared_ptr<GeomDataAPI_Point2D>& theFirstPointAttr,
 229                           std::shared_ptr<GeomDataAPI_Point2D>& theSecondPointAttr) const;
 230
 231   /// Fill attribute by value of another attribute. It processes only Point 2D attributes.
 232   /// \param theModifiedAttribute an attribute of GeomDataAPI_Point2D on feature to be modified
 233   /// \param theSourceAttribute an attribute of GeomDataAPI_Point2D to obtain data
 234   void fillAttribute(const AttributePtr& theModifiedAttribute,
 235                      const AttributePtr& theSourceAttribute);
 236
 237   /// Creates a line feature filled by center of base feature and given points
 238   /// \param theBaseFeature another arc feature
 239   /// \param theFirstAttribute an attribute with coordinates for the start point
 240   /// \param theSecondAttribute an attribute with coordinates for the end point
 241   FeaturePtr createLineFeature(const FeaturePtr& theBaseFeature,
 242                                const AttributePtr& theFirstPointAttr,
 243                                const AttributePtr& theSecondPointAttr);
 244
 245   /// Creates an arc feature filled by center of base feature and given points
 246   /// \param theBaseFeature another arc feature
 247   /// \param theFirstAttribute an attribute with coordinates for the start point
 248   /// \param theSecondAttribute an attribute with coordinates for the end point
 249   FeaturePtr createArcFeature(const FeaturePtr& theBaseFeature,
 250                               const AttributePtr& theFirstPointAttr,
 251                               const AttributePtr& theSecondPointAttr);
 252
 253   /// Add feature coincidence constraint between given attributes
 254   /// \param theConstraintId a constraint index
 255   /// \param theFirstAttribute an attribute of further coincidence
 256   /// \param theSecondAttribute an attribute of further coincidence
 257   std::shared_ptr<ModelAPI_Feature> createConstraint(const std::string& theConstraintId,
 258                         const std::shared_ptr<ModelAPI_Attribute>& theFirstAttribute,
 259                         const std::shared_ptr<ModelAPI_Attribute>& theSecondAttribute);
 260
 261   /// Add feature coincidence constraint between given attributes
 262   /// \param theConstraintId a constraint index
 263   /// \param theFirstAttribute an attribute of further coincidence
 264   /// \param theFirstAttribute an attribute of further coincidence
 265   std::shared_ptr<ModelAPI_Feature> createConstraintForObjects(const std::string& theConstraintId,
 266                         const std::shared_ptr<ModelAPI_Object>& theFirstObject,
 267                         const std::shared_ptr<ModelAPI_Object>& theSecondObject);
 268
 269   /// Add feature coincidence constraint between given attributes
 270   /// \param theFeaturesToUpdate a constraint index
 271   void updateFeaturesAfterSplit(const std::set<FeaturePtr>& theFeaturesToUpdate);
 272
 273   /// Result result of the feature to build constraint with. For arc, circle it is an edge result.
 274   /// \param theFeature a feature
 275   /// \return result object
 276   std::shared_ptr<ModelAPI_Result> getFeatureResult(
 277                                     const std::shared_ptr<ModelAPI_Feature>& theFeature);
 278
 279   /// Returns attributes of the feature, used in edge build, for arc it is end and start points
 280   /// \param theFeature a feature
 281   /// \return container of attributes
 282   std::set<std::shared_ptr<ModelAPI_Attribute> > getEdgeAttributes(
 283                                     const std::shared_ptr<ModelAPI_Feature>& theFeature);
 284
 285 #ifdef _DEBUG
 286   /// Return feature name, kind, point attribute values united in a string
 287   /// \param theFeature an investigated feature
 288   /// \return string value
 289   std::string getFeatureInfo(const std::shared_ptr<ModelAPI_Feature>& theFeature,
 290                              const bool isUseAttributesInfo = true);
 291 #endif
 292 };
 293
 294 #endif