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