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     updateConstraintValueByAngleValue();
  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       updateConstraintValueByAngleValue();
 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   }
 143   else if (theID == SketchPlugin_ConstraintAngle::ANGLE_VALUE_ID()) {
 144     updateConstraintValueByAngleValue();
 145   }
 146 }
 147
 148 double SketchPlugin_ConstraintAngle::calculateAngle()
 149 {
 150   std::shared_ptr<ModelAPI_Data> aData = data();
 151   std::shared_ptr<GeomAPI_Ax3> aPlane = SketchPlugin_Sketch::plane(sketch());
 152   FeaturePtr aLineA = SketcherPrs_Tools::getFeatureLine(aData, SketchPlugin_Constraint::ENTITY_A());
 153   FeaturePtr aLineB = SketcherPrs_Tools::getFeatureLine(aData, SketchPlugin_Constraint::ENTITY_B());
 154
 155   std::shared_ptr<GeomDataAPI_Point2D> aStartA = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 156       aLineA->attribute(SketchPlugin_Line::START_ID()));
 157   std::shared_ptr<GeomDataAPI_Point2D> aEndA = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 158       aLineA->attribute(SketchPlugin_Line::END_ID()));
 159   std::shared_ptr<GeomDataAPI_Point2D> aStartB = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 160       aLineB->attribute(SketchPlugin_Line::START_ID()));
 161   std::shared_ptr<GeomDataAPI_Point2D> aEndB = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 162       aLineB->attribute(SketchPlugin_Line::END_ID()));
 163
 164   std::shared_ptr<GeomAPI_Angle2d> anAng;
 165   if (!attribute(ANGLE_REVERSED_FIRST_LINE_ID())->isInitialized() ||
 166       !attribute(ANGLE_REVERSED_SECOND_LINE_ID())->isInitialized())
 167     anAng = std::shared_ptr<GeomAPI_Angle2d>(new GeomAPI_Angle2d(
 168         aStartA->pnt(), aEndA->pnt(), aStartB->pnt(), aEndB->pnt()));
 169   else {
 170     std::shared_ptr<GeomAPI_Lin2d> aLine1(new GeomAPI_Lin2d(aStartA->pnt(), aEndA->pnt()));
 171     bool isReversed1 = boolean(ANGLE_REVERSED_FIRST_LINE_ID())->value();
 172     std::shared_ptr<GeomAPI_Lin2d> aLine2(new GeomAPI_Lin2d(aStartB->pnt(), aEndB->pnt()));
 173     bool isReversed2 = boolean(ANGLE_REVERSED_SECOND_LINE_ID())->value();
 174     anAng = std::shared_ptr<GeomAPI_Angle2d>(new GeomAPI_Angle2d(aLine1, isReversed1, aLine2, isReversed2));
 175   }
 176   double anAngle = anAng->angleDegree();
 177   std::shared_ptr<ModelAPI_AttributeDouble> aValueAttr = std::dynamic_pointer_cast<
 178       ModelAPI_AttributeDouble>(data()->attribute(SketchPlugin_ConstraintAngle::VALUE()));
 179   if (!aValueAttr->isInitialized())
 180     aValueAttr->setValue(anAngle);
 181   /// an angle value should be corrected by the current angle type
 182   anAngle = getAngleForType(anAngle);
 183   boolean(ANGLE_REVERSED_FIRST_LINE_ID())->setValue(anAng->isReversed(0));
 184   boolean(ANGLE_REVERSED_SECOND_LINE_ID())->setValue(anAng->isReversed(1));
 185   return anAngle;
 186 }
 187
 188 double SketchPlugin_ConstraintAngle::getAngleForType(double theAngle, bool isPreviousValueObtuse)
 189 {
 190   double anAngle = theAngle;
 191
 192   std::shared_ptr<ModelAPI_Data> aData = data();
 193   std::shared_ptr<ModelAPI_AttributeInteger> aTypeAttr = std::dynamic_pointer_cast<
 194       ModelAPI_AttributeInteger>(aData->attribute(SketchPlugin_ConstraintAngle::TYPE_ID()));
 195   SketcherPrs_Tools::AngleType anAngleType = (SketcherPrs_Tools::AngleType)(aTypeAttr->value());
 196   switch (anAngleType) {
 197     case SketcherPrs_Tools::ANGLE_DIRECT:
 198       anAngle = theAngle;
 199     break;
 200     case SketcherPrs_Tools::ANGLE_COMPLEMENTARY: {
 201       if (theAngle > 180 || isPreviousValueObtuse)
 202         anAngle = theAngle - 180.0;
 203       else
 204         anAngle = 180.0 - theAngle;
 205
 206       if (anAngle < 0.0)
 207         anAngle += 360.0;
 208     }
 209     break;
 210     case SketcherPrs_Tools::ANGLE_BACKWARD:
 211       anAngle = 360.0 - theAngle;
 212     break;
 213     default:
 214       break;
 215   }
 216   return anAngle;
 217 }
 218
 219 void SketchPlugin_ConstraintAngle::updateConstraintValueByAngleValue()
 220 {
 221   std::shared_ptr<ModelAPI_AttributeDouble> aValueAttr = std::dynamic_pointer_cast<
 222     ModelAPI_AttributeDouble>(data()->attribute(SketchPlugin_ConstraintAngle::ANGLE_VALUE_ID()));
 223   double anAngle = aValueAttr->value();
 224
 225   /// an angle value should be corrected by the current angle type
 226   aValueAttr = std::dynamic_pointer_cast<
 227                   ModelAPI_AttributeDouble>(data()->attribute(SketchPlugin_Constraint::VALUE()));
 228   anAngle = getAngleForType(anAngle, aValueAttr->value() > 180.0);
 229   aValueAttr->setValue(anAngle);
 230 }
 231
 232 void SketchPlugin_ConstraintAngle::move(double theDeltaX, double theDeltaY)
 233 {
 234   std::shared_ptr<ModelAPI_Data> aData = data();
 235   if (!aData->isValid())
 236     return;
 237
 238   myFlyoutUpdate = true;
 239   std::shared_ptr<GeomDataAPI_Point2D> aFlyoutAttr = std::dynamic_pointer_cast<
 240       GeomDataAPI_Point2D>(aData->attribute(SketchPlugin_Constraint::FLYOUT_VALUE_PNT()));
 241   aFlyoutAttr->setValue(aFlyoutAttr->x() + theDeltaX, aFlyoutAttr->y() + theDeltaY);
 242   myFlyoutUpdate = false;
 243 }
 244
 245
 246 bool SketchPlugin_ConstraintAngle::compute(const std::string& theAttributeId)
 247 {
 248   if (theAttributeId != SketchPlugin_Constraint::FLYOUT_VALUE_PNT())
 249     return false;
 250   if (!sketch())
 251     return false;
 252
 253   std::shared_ptr<GeomDataAPI_Point2D> aFlyOutAttr = std::dynamic_pointer_cast<
 254                            GeomDataAPI_Point2D>(attribute(theAttributeId));
 255   if (fabs(aFlyOutAttr->x()) >= tolerance || fabs(aFlyOutAttr->y()) >= tolerance)
 256     return false;
 257
 258   DataPtr aData = data();
 259   std::shared_ptr<GeomAPI_Ax3> aPlane = SketchPlugin_Sketch::plane(sketch());
 260   FeaturePtr aLineA = SketcherPrs_Tools::getFeatureLine(aData, SketchPlugin_Constraint::ENTITY_A());
 261   FeaturePtr aLineB = SketcherPrs_Tools::getFeatureLine(aData, SketchPlugin_Constraint::ENTITY_B());
 262
 263   if ((aLineA.get() == NULL) || (aLineB.get() == NULL))
 264     return false;
 265
 266   // Start and end points of lines
 267   std::shared_ptr<GeomDataAPI_Point2D> aPointA1 = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 268       aLineA->attribute(SketchPlugin_Line::START_ID()));
 269   std::shared_ptr<GeomDataAPI_Point2D> aPointA2 = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 270       aLineA->attribute(SketchPlugin_Line::END_ID()));
 271
 272   std::shared_ptr<GeomAPI_Pnt2d> aStartA = aPointA1->pnt();
 273   std::shared_ptr<GeomAPI_Pnt2d> aEndA   = aPointA2->pnt();
 274   if (aStartA->distance(aEndA) < tolerance)
 275     return false;
 276
 277   myFlyoutUpdate = true;
 278   double aX = (aStartA->x() + aEndA->x()) / 2.;
 279   double aY = (aStartA->y() + aEndA->y()) / 2.;
 280
 281   aFlyOutAttr->setValue(aX, aY);
 282   myFlyoutUpdate = false;
 283
 284   return true;
 285 }
 286
 287
 288 // ===============   Auxiliary functions   ==================================
 289 std::shared_ptr<GeomAPI_Pnt2d> intersect(FeaturePtr theLine1, FeaturePtr theLine2)
 290 {
 291   // Start and end points of lines
 292   std::shared_ptr<GeomDataAPI_Point2D> aPointA1 = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 293       theLine1->attribute(SketchPlugin_Line::START_ID()));
 294   std::shared_ptr<GeomDataAPI_Point2D> aPointA2 = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 295       theLine1->attribute(SketchPlugin_Line::END_ID()));
 296
 297   std::shared_ptr<GeomDataAPI_Point2D> aPointB1 = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 298       theLine2->attribute(SketchPlugin_Line::START_ID()));
 299   std::shared_ptr<GeomDataAPI_Point2D> aPointB2 = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 300       theLine2->attribute(SketchPlugin_Line::END_ID()));
 301
 302   std::shared_ptr<GeomAPI_Pnt2d> aStartA = aPointA1->pnt();
 303   std::shared_ptr<GeomAPI_Pnt2d> aEndA   = aPointA2->pnt();
 304   std::shared_ptr<GeomAPI_Pnt2d> aStartB = aPointB1->pnt();
 305   std::shared_ptr<GeomAPI_Pnt2d> aEndB   = aPointB2->pnt();
 306   if (aStartA->distance(aEndA) < tolerance || aStartB->distance(aEndB) < tolerance)
 307     std::shared_ptr<GeomAPI_Pnt2d>();
 308
 309   // Lines and their intersection point
 310   std::shared_ptr<GeomAPI_Lin2d> aLA(new GeomAPI_Lin2d(aStartA, aEndA));
 311   std::shared_ptr<GeomAPI_Lin2d> aLB(new GeomAPI_Lin2d(aStartB, aEndB));
 312   return aLA->intersect(aLB);
 313 }