src/SketchPlugin/SketchPlugin_ConstraintAngle.cpp

   1 // Copyright (C) 2014-20xx CEA/DEN, EDF R&D -->
   2
   3 // File:    SketchPlugin_ConstraintAngle.cpp
   4 // Created: 19 August 2015
   5 // Author:  Artem ZHIDKOV
   6
   7 #include "SketchPlugin_ConstraintAngle.h"
   8 #include <SketchPlugin_Line.h>
   9
  10 #include <ModelAPI_AttributeDouble.h>
  11 #include <ModelAPI_AttributeInteger.h>
  12
  13 #include <GeomDataAPI_Point2D.h>
  14
  15 #include <GeomAPI_Angle2d.h>
  16 #include <GeomAPI_Dir2d.h>
  17 #include <GeomAPI_Lin2d.h>
  18 #include <GeomAPI_Pnt2d.h>
  19 #include <GeomAPI_XY.h>
  20
  21 #include <SketcherPrs_Factory.h>
  22 #include <SketcherPrs_Tools.h>
  23
  24 #include <math.h>
  25
  26 const double tolerance = 1.e-7;
  27 #define PI 3.1415926535897932
  28
  29 /// \brief Calculate intersection point of two lines
  30 static std::shared_ptr<GeomAPI_Pnt2d> intersect(FeaturePtr theLine1, FeaturePtr theLine2);
  31
  32
  33 SketchPlugin_ConstraintAngle::SketchPlugin_ConstraintAngle()
  34 {
  35   myFlyoutUpdate = false;
  36 }
  37
  38 void SketchPlugin_ConstraintAngle::initAttributes()
  39 {
  40   data()->addAttribute(SketchPlugin_Constraint::VALUE(), ModelAPI_AttributeDouble::typeId());
  41   data()->addAttribute(SketchPlugin_Constraint::ENTITY_A(), ModelAPI_AttributeRefAttr::typeId());
  42   data()->addAttribute(SketchPlugin_Constraint::ENTITY_B(), ModelAPI_AttributeRefAttr::typeId());
  43   data()->addAttribute(SketchPlugin_Constraint::FLYOUT_VALUE_PNT(), GeomDataAPI_Point2D::typeId());
  44
  45   data()->addAttribute(SketchPlugin_ConstraintAngle::ANGLE_VALUE_ID(), ModelAPI_AttributeDouble::typeId());
  46   data()->addAttribute(SketchPlugin_ConstraintAngle::TYPE_ID(), ModelAPI_AttributeInteger::typeId());
  47
  48   data()->addAttribute(SketchPlugin_ConstraintAngle::ANGLE_REVERSED_FIRST_LINE_ID(), ModelAPI_AttributeBoolean::typeId());
  49   data()->addAttribute(SketchPlugin_ConstraintAngle::ANGLE_REVERSED_SECOND_LINE_ID(), ModelAPI_AttributeBoolean::typeId());
  50 }
  51
  52 void SketchPlugin_ConstraintAngle::colorConfigInfo(std::string& theSection, std::string& theName,
  53                                                    std::string& theDefault)
  54 {
  55   theSection = "Visualization";
  56   theName = "sketch_dimension_color";
  57   theDefault = SKETCH_DIMENSION_COLOR;
  58 }
  59
  60 void SketchPlugin_ConstraintAngle::execute()
  61 {
  62   std::shared_ptr<ModelAPI_Data> aData = data();
  63
  64   std::shared_ptr<ModelAPI_AttributeRefAttr> anAttrA = aData->refattr(SketchPlugin_Constraint::ENTITY_A());
  65   std::shared_ptr<ModelAPI_AttributeRefAttr> anAttrB = aData->refattr(SketchPlugin_Constraint::ENTITY_B());
  66   if (!anAttrA->isInitialized() || !anAttrB->isInitialized())
  67     return;
  68
  69   AttributeDoublePtr anAttrValue = std::dynamic_pointer_cast<ModelAPI_AttributeDouble>(
  70       aData->attribute(SketchPlugin_ConstraintAngle::ANGLE_VALUE_ID()));
  71
  72   if (!anAttrValue->isInitialized()) {
  73     double anAngle = calculateAngle();
  74     anAttrValue->setValue(anAngle);
  75     updateAngleValue();
  76   }
  77   // the value should to be computed here, not in the getAISObject in order to change the model value
  78   // inside the object transaction. This is important for creating a constraint by preselection.
  79   // The display of the presentation in this case happens after the transaction commit
  80   std::shared_ptr<GeomDataAPI_Point2D> aFlyOutAttr = std::dynamic_pointer_cast<
  81       GeomDataAPI_Point2D>(aData->attribute(SketchPlugin_Constraint::FLYOUT_VALUE_PNT()));
  82   if(!aFlyOutAttr->isInitialized())
  83     compute(SketchPlugin_Constraint::FLYOUT_VALUE_PNT());
  84 }
  85
  86 AISObjectPtr SketchPlugin_ConstraintAngle::getAISObject(AISObjectPtr thePrevious)
  87 {
  88   if (!sketch())
  89     return thePrevious;
  90
  91   AISObjectPtr anAIS = SketcherPrs_Factory::angleConstraint(this, sketch()->coordinatePlane(),
  92                                                             thePrevious);
  93   return anAIS;
  94 }
  95
  96 void SketchPlugin_ConstraintAngle::attributeChanged(const std::string& theID)
  97 {
  98   std::shared_ptr<ModelAPI_Data> aData = data();
  99   if (!aData)
 100     return;
 101   FeaturePtr aLineA = SketcherPrs_Tools::getFeatureLine(aData, SketchPlugin_Constraint::ENTITY_A());
 102   FeaturePtr aLineB = SketcherPrs_Tools::getFeatureLine(aData, SketchPlugin_Constraint::ENTITY_B());
 103   if (!aLineA || !aLineB)
 104     return;
 105
 106   if (theID == SketchPlugin_Constraint::ENTITY_A() ||
 107       theID == SketchPlugin_Constraint::ENTITY_B()) {
 108     std::shared_ptr<ModelAPI_AttributeDouble> aValueAttr = std::dynamic_pointer_cast<
 109         ModelAPI_AttributeDouble>(data()->attribute(SketchPlugin_ConstraintAngle::ANGLE_VALUE_ID()));
 110     if (!aValueAttr->isInitialized()) { // only if it is not initialized, try to compute the current value
 111       double anAngle = calculateAngle();
 112       aValueAttr->setValue(anAngle);
 113       updateAngleValue();
 114     }
 115   } else if (theID == SketchPlugin_Constraint::FLYOUT_VALUE_PNT() && !myFlyoutUpdate) {
 116     // Recalculate flyout point in local coordinates
 117     // coordinates are calculated according to the center of shapes intersection
 118     std::shared_ptr<GeomDataAPI_Point2D> aFlyoutAttr =
 119         std::dynamic_pointer_cast<GeomDataAPI_Point2D>(attribute(SketchPlugin_Constraint::FLYOUT_VALUE_PNT()));
 120
 121     std::shared_ptr<ModelAPI_Data> aData = data();
 122     std::shared_ptr<GeomAPI_Ax3> aPlane = SketchPlugin_Sketch::plane(sketch());
 123     FeaturePtr aLineA = SketcherPrs_Tools::getFeatureLine(aData, SketchPlugin_Constraint::ENTITY_A());
 124     FeaturePtr aLineB = SketcherPrs_Tools::getFeatureLine(aData, SketchPlugin_Constraint::ENTITY_B());
 125
 126     // Intersection of lines
 127     std::shared_ptr<GeomAPI_Pnt2d> anInter = intersect(aLineA, aLineB);
 128     if (!anInter)
 129       return;
 130
 131     myFlyoutUpdate = true;
 132     std::shared_ptr<GeomAPI_XY> aFlyoutDir = aFlyoutAttr->pnt()->xy()->decreased(anInter->xy());
 133     if (aFlyoutDir->dot(aFlyoutDir) < tolerance * tolerance)
 134       aFlyoutAttr->setValue(aFlyoutAttr->x() + tolerance, aFlyoutAttr->y());
 135     myFlyoutUpdate = false;
 136   }
 137   else if (theID == SketchPlugin_ConstraintAngle::TYPE_ID()) {
 138     std::shared_ptr<ModelAPI_AttributeDouble> aValueAttr = std::dynamic_pointer_cast<
 139       ModelAPI_AttributeDouble>(data()->attribute(SketchPlugin_ConstraintAngle::ANGLE_VALUE_ID()));
 140     double anAngle = calculateAngle();
 141     aValueAttr->setValue(anAngle);
 142     updateAngleValue();
 143   }
 144   else if (theID == SketchPlugin_ConstraintAngle::ANGLE_VALUE_ID()) {
 145     updateAngleValue();
 146   }
 147 }
 148
 149 double SketchPlugin_ConstraintAngle::calculateAngle()
 150 {
 151   std::shared_ptr<ModelAPI_Data> aData = data();
 152   std::shared_ptr<GeomAPI_Ax3> aPlane = SketchPlugin_Sketch::plane(sketch());
 153   FeaturePtr aLineA = SketcherPrs_Tools::getFeatureLine(aData, SketchPlugin_Constraint::ENTITY_A());
 154   FeaturePtr aLineB = SketcherPrs_Tools::getFeatureLine(aData, SketchPlugin_Constraint::ENTITY_B());
 155
 156   std::shared_ptr<GeomDataAPI_Point2D> aStartA = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 157       aLineA->attribute(SketchPlugin_Line::START_ID()));
 158   std::shared_ptr<GeomDataAPI_Point2D> aEndA = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 159       aLineA->attribute(SketchPlugin_Line::END_ID()));
 160   std::shared_ptr<GeomDataAPI_Point2D> aStartB = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 161       aLineB->attribute(SketchPlugin_Line::START_ID()));
 162   std::shared_ptr<GeomDataAPI_Point2D> aEndB = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 163       aLineB->attribute(SketchPlugin_Line::END_ID()));
 164
 165   std::shared_ptr<GeomAPI_Angle2d> anAng;
 166   if (!attribute(ANGLE_REVERSED_FIRST_LINE_ID())->isInitialized() ||
 167       !attribute(ANGLE_REVERSED_SECOND_LINE_ID())->isInitialized())
 168     anAng = std::shared_ptr<GeomAPI_Angle2d>(new GeomAPI_Angle2d(
 169         aStartA->pnt(), aEndA->pnt(), aStartB->pnt(), aEndB->pnt()));
 170   else {
 171     std::shared_ptr<GeomAPI_Lin2d> aLine1(new GeomAPI_Lin2d(aStartA->pnt(), aEndA->pnt()));
 172     bool isReversed1 = boolean(ANGLE_REVERSED_FIRST_LINE_ID())->value();
 173     std::shared_ptr<GeomAPI_Lin2d> aLine2(new GeomAPI_Lin2d(aStartB->pnt(), aEndB->pnt()));
 174     bool isReversed2 = boolean(ANGLE_REVERSED_SECOND_LINE_ID())->value();
 175     anAng = std::shared_ptr<GeomAPI_Angle2d>(new GeomAPI_Angle2d(aLine1, isReversed1, aLine2, isReversed2));
 176   }
 177   double anAngle = anAng->angleDegree();
 178   /// an angle value should be corrected by the current angle type
 179   anAngle = getAngleForType(anAngle);
 180   boolean(ANGLE_REVERSED_FIRST_LINE_ID())->setValue(anAng->isReversed(0));
 181   boolean(ANGLE_REVERSED_SECOND_LINE_ID())->setValue(anAng->isReversed(1));
 182   return anAngle;
 183 }
 184
 185 double SketchPlugin_ConstraintAngle::getAngleForType(double theAngle)
 186 {
 187   double anAngle = theAngle;
 188
 189   std::shared_ptr<ModelAPI_Data> aData = data();
 190   std::shared_ptr<ModelAPI_AttributeInteger> aTypeAttr = std::dynamic_pointer_cast<
 191       ModelAPI_AttributeInteger>(aData->attribute(SketchPlugin_ConstraintAngle::TYPE_ID()));
 192   SketcherPrs_Tools::AngleType anAngleType = (SketcherPrs_Tools::AngleType)(aTypeAttr->value());
 193   switch (anAngleType) {
 194     case SketcherPrs_Tools::ANGLE_DIRECT:
 195       anAngle = theAngle;
 196     break;
 197     case SketcherPrs_Tools::ANGLE_COMPLEMENTARY:
 198       anAngle = fabs(180.0 - theAngle);
 199     break;
 200     case SketcherPrs_Tools::ANGLE_BACKWARD:
 201       anAngle = 360.0 - theAngle;
 202     break;
 203     default:
 204       break;
 205   }
 206   return anAngle;
 207 }
 208
 209 void SketchPlugin_ConstraintAngle::updateAngleValue()
 210 {
 211   std::shared_ptr<ModelAPI_AttributeDouble> aValueAttr = std::dynamic_pointer_cast<
 212     ModelAPI_AttributeDouble>(data()->attribute(SketchPlugin_ConstraintAngle::ANGLE_VALUE_ID()));
 213   double anAngle = aValueAttr->value();
 214
 215   /// an angle value should be corrected by the current angle type
 216   anAngle = getAngleForType(anAngle);
 217   aValueAttr = std::dynamic_pointer_cast<
 218                   ModelAPI_AttributeDouble>(data()->attribute(SketchPlugin_Constraint::VALUE()));
 219   aValueAttr->setValue(anAngle);
 220 }
 221
 222 void SketchPlugin_ConstraintAngle::move(double theDeltaX, double theDeltaY)
 223 {
 224   std::shared_ptr<ModelAPI_Data> aData = data();
 225   if (!aData->isValid())
 226     return;
 227
 228   myFlyoutUpdate = true;
 229   std::shared_ptr<GeomDataAPI_Point2D> aFlyoutAttr = std::dynamic_pointer_cast<
 230       GeomDataAPI_Point2D>(aData->attribute(SketchPlugin_Constraint::FLYOUT_VALUE_PNT()));
 231   aFlyoutAttr->setValue(aFlyoutAttr->x() + theDeltaX, aFlyoutAttr->y() + theDeltaY);
 232   myFlyoutUpdate = false;
 233 }
 234
 235
 236 bool SketchPlugin_ConstraintAngle::compute(const std::string& theAttributeId)
 237 {
 238   if (theAttributeId != SketchPlugin_Constraint::FLYOUT_VALUE_PNT())
 239     return false;
 240   if (!sketch())
 241     return false;
 242
 243   std::shared_ptr<GeomDataAPI_Point2D> aFlyOutAttr = std::dynamic_pointer_cast<
 244                            GeomDataAPI_Point2D>(attribute(theAttributeId));
 245   if (fabs(aFlyOutAttr->x()) >= tolerance || fabs(aFlyOutAttr->y()) >= tolerance)
 246     return false;
 247
 248   DataPtr aData = data();
 249   std::shared_ptr<GeomAPI_Ax3> aPlane = SketchPlugin_Sketch::plane(sketch());
 250   FeaturePtr aLineA = SketcherPrs_Tools::getFeatureLine(aData, SketchPlugin_Constraint::ENTITY_A());
 251   FeaturePtr aLineB = SketcherPrs_Tools::getFeatureLine(aData, SketchPlugin_Constraint::ENTITY_B());
 252
 253   if ((aLineA.get() == NULL) || (aLineB.get() == NULL))
 254     return false;
 255
 256   // Start and end points of lines
 257   std::shared_ptr<GeomDataAPI_Point2D> aPointA1 = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 258       aLineA->attribute(SketchPlugin_Line::START_ID()));
 259   std::shared_ptr<GeomDataAPI_Point2D> aPointA2 = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 260       aLineA->attribute(SketchPlugin_Line::END_ID()));
 261
 262   std::shared_ptr<GeomAPI_Pnt2d> aStartA = aPointA1->pnt();
 263   std::shared_ptr<GeomAPI_Pnt2d> aEndA   = aPointA2->pnt();
 264   if (aStartA->distance(aEndA) < tolerance)
 265     return false;
 266
 267   myFlyoutUpdate = true;
 268   double aX = (aStartA->x() + aEndA->x()) / 2.;
 269   double aY = (aStartA->y() + aEndA->y()) / 2.;
 270
 271   aFlyOutAttr->setValue(aX, aY);
 272   myFlyoutUpdate = false;
 273
 274   return true;
 275 }
 276
 277
 278 // ===============   Auxiliary functions   ==================================
 279 std::shared_ptr<GeomAPI_Pnt2d> intersect(FeaturePtr theLine1, FeaturePtr theLine2)
 280 {
 281   // Start and end points of lines
 282   std::shared_ptr<GeomDataAPI_Point2D> aPointA1 = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 283       theLine1->attribute(SketchPlugin_Line::START_ID()));
 284   std::shared_ptr<GeomDataAPI_Point2D> aPointA2 = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 285       theLine1->attribute(SketchPlugin_Line::END_ID()));
 286
 287   std::shared_ptr<GeomDataAPI_Point2D> aPointB1 = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 288       theLine2->attribute(SketchPlugin_Line::START_ID()));
 289   std::shared_ptr<GeomDataAPI_Point2D> aPointB2 = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 290       theLine2->attribute(SketchPlugin_Line::END_ID()));
 291
 292   std::shared_ptr<GeomAPI_Pnt2d> aStartA = aPointA1->pnt();
 293   std::shared_ptr<GeomAPI_Pnt2d> aEndA   = aPointA2->pnt();
 294   std::shared_ptr<GeomAPI_Pnt2d> aStartB = aPointB1->pnt();
 295   std::shared_ptr<GeomAPI_Pnt2d> aEndB   = aPointB2->pnt();
 296   if (aStartA->distance(aEndA) < tolerance || aStartB->distance(aEndB) < tolerance)
 297     std::shared_ptr<GeomAPI_Pnt2d>();
 298
 299   // Lines and their intersection point
 300   std::shared_ptr<GeomAPI_Lin2d> aLA(new GeomAPI_Lin2d(aStartA, aEndA));
 301   std::shared_ptr<GeomAPI_Lin2d> aLB(new GeomAPI_Lin2d(aStartB, aEndB));
 302   return aLA->intersect(aLB);
 303 }