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 <GeomDataAPI_Point2D.h>
  12
  13 #include <GeomAPI_Dir2d.h>
  14 #include <GeomAPI_Lin2d.h>
  15 #include <GeomAPI_Pnt2d.h>
  16 #include <GeomAPI_XY.h>
  17
  18 #include <SketcherPrs_Factory.h>
  19 #include <SketcherPrs_Tools.h>
  20
  21 #include <math.h>
  22
  23 const double tolerance = 1.e-7;
  24 #define PI 3.1415926535897932
  25
  26 /// \brief Calculate intersection point of two lines
  27 static std::shared_ptr<GeomAPI_Pnt2d> intersect(FeaturePtr theLine1, FeaturePtr theLine2);
  28
  29
  30 SketchPlugin_ConstraintAngle::SketchPlugin_ConstraintAngle()
  31 {
  32   myFlyoutUpdate = false;
  33 }
  34
  35 void SketchPlugin_ConstraintAngle::initAttributes()
  36 {
  37   data()->addAttribute(SketchPlugin_Constraint::VALUE(), ModelAPI_AttributeDouble::typeId());
  38   data()->addAttribute(SketchPlugin_Constraint::ENTITY_A(), ModelAPI_AttributeRefAttr::typeId());
  39   data()->addAttribute(SketchPlugin_Constraint::ENTITY_B(), ModelAPI_AttributeRefAttr::typeId());
  40   data()->addAttribute(SketchPlugin_Constraint::FLYOUT_VALUE_PNT(), GeomDataAPI_Point2D::typeId());
  41 }
  42
  43 void SketchPlugin_ConstraintAngle::execute()
  44 {
  45   std::shared_ptr<ModelAPI_Data> aData = data();
  46
  47   std::shared_ptr<ModelAPI_AttributeRefAttr> anAttrA = aData->refattr(SketchPlugin_Constraint::ENTITY_A());
  48   std::shared_ptr<ModelAPI_AttributeRefAttr> anAttrB = aData->refattr(SketchPlugin_Constraint::ENTITY_B());
  49   if (!anAttrA->isInitialized() || !anAttrB->isInitialized())
  50     return;
  51
  52   AttributeDoublePtr anAttrValue = std::dynamic_pointer_cast<ModelAPI_AttributeDouble>(
  53       aData->attribute(SketchPlugin_Constraint::VALUE()));
  54
  55   if (!anAttrValue->isInitialized()) {
  56     double anAngle = calculateAngle();
  57     anAttrValue->setValue(anAngle);
  58   }
  59   // the value should to be computed here, not in the getAISObject in order to change the model value
  60   // inside the object transaction. This is important for creating a constraint by preselection.
  61   // The display of the presentation in this case happens after the transaction commit
  62   std::shared_ptr<GeomDataAPI_Point2D> aFlyOutAttr = std::dynamic_pointer_cast<
  63       GeomDataAPI_Point2D>(aData->attribute(SketchPlugin_Constraint::FLYOUT_VALUE_PNT()));
  64   if(!aFlyOutAttr->isInitialized())
  65     compute(SketchPlugin_Constraint::FLYOUT_VALUE_PNT());
  66 }
  67
  68 AISObjectPtr SketchPlugin_ConstraintAngle::getAISObject(AISObjectPtr thePrevious)
  69 {
  70   if (!sketch())
  71     return thePrevious;
  72
  73   AISObjectPtr anAIS = thePrevious;
  74   if (!anAIS) {
  75     anAIS = SketcherPrs_Factory::angleConstraint(this, sketch()->coordinatePlane());
  76   }
  77
  78   // Set color from preferences
  79   std::vector<int> aRGB = Config_PropManager::color("Visualization", "sketch_dimension_color",
  80                                                     SKETCH_DIMENSION_COLOR);
  81   anAIS->setColor(aRGB[0], aRGB[1], aRGB[2]);
  82   return anAIS;
  83 }
  84
  85 void SketchPlugin_ConstraintAngle::attributeChanged(const std::string& theID)
  86 {
  87   std::shared_ptr<ModelAPI_Data> aData = data();
  88   if (!aData)
  89     return;
  90   FeaturePtr aLineA = SketcherPrs_Tools::getFeatureLine(aData, SketchPlugin_Constraint::ENTITY_A());
  91   FeaturePtr aLineB = SketcherPrs_Tools::getFeatureLine(aData, SketchPlugin_Constraint::ENTITY_B());
  92   if (!aLineA || !aLineB)
  93     return;
  94
  95   if (theID == SketchPlugin_Constraint::ENTITY_A() ||
  96       theID == SketchPlugin_Constraint::ENTITY_B()) {
  97     std::shared_ptr<ModelAPI_AttributeDouble> aValueAttr = std::dynamic_pointer_cast<
  98         ModelAPI_AttributeDouble>(data()->attribute(SketchPlugin_Constraint::VALUE()));
  99     if (!aValueAttr->isInitialized()) { // only if it is not initialized, try to compute the current value
 100       double anAngle = calculateAngle();
 101       aValueAttr->setValue(anAngle);
 102     }
 103   } else if (theID == SketchPlugin_Constraint::FLYOUT_VALUE_PNT() && !myFlyoutUpdate) {
 104     // Recalculate flyout point in local coordinates
 105     // coordinates are calculated according to the center of shapes intersection
 106     std::shared_ptr<GeomDataAPI_Point2D> aFlyoutAttr =
 107         std::dynamic_pointer_cast<GeomDataAPI_Point2D>(attribute(SketchPlugin_Constraint::FLYOUT_VALUE_PNT()));
 108
 109     std::shared_ptr<ModelAPI_Data> aData = data();
 110     std::shared_ptr<GeomAPI_Ax3> aPlane = SketchPlugin_Sketch::plane(sketch());
 111     FeaturePtr aLineA = SketcherPrs_Tools::getFeatureLine(aData, SketchPlugin_Constraint::ENTITY_A());
 112     FeaturePtr aLineB = SketcherPrs_Tools::getFeatureLine(aData, SketchPlugin_Constraint::ENTITY_B());
 113
 114     // Intersection of lines
 115     std::shared_ptr<GeomAPI_Pnt2d> anInter = intersect(aLineA, aLineB);
 116     if (!anInter)
 117       return;
 118
 119     myFlyoutUpdate = true;
 120     std::shared_ptr<GeomAPI_XY> aFlyoutDir = aFlyoutAttr->pnt()->xy()->decreased(anInter->xy());
 121     if (aFlyoutDir->dot(aFlyoutDir) < tolerance * tolerance)
 122       aFlyoutAttr->setValue(aFlyoutAttr->x() + tolerance, aFlyoutAttr->y());
 123     myFlyoutUpdate = false;
 124   }
 125 }
 126
 127 double SketchPlugin_ConstraintAngle::calculateAngle()
 128 {
 129   double anAngle = 0.0;
 130
 131   std::shared_ptr<ModelAPI_Data> aData = data();
 132   std::shared_ptr<GeomAPI_Ax3> aPlane = SketchPlugin_Sketch::plane(sketch());
 133   FeaturePtr aLineA = SketcherPrs_Tools::getFeatureLine(aData, SketchPlugin_Constraint::ENTITY_A());
 134   FeaturePtr aLineB = SketcherPrs_Tools::getFeatureLine(aData, SketchPlugin_Constraint::ENTITY_B());
 135
 136   // Intersection of lines
 137   std::shared_ptr<GeomAPI_Pnt2d> anInter = intersect(aLineA, aLineB);
 138   if (!anInter)
 139     return anAngle;
 140
 141   // Start and end points of lines
 142   std::shared_ptr<GeomDataAPI_Point2D> aPointA1 = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 143       aLineA->attribute(SketchPlugin_Line::START_ID()));
 144   std::shared_ptr<GeomDataAPI_Point2D> aPointA2 = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 145       aLineA->attribute(SketchPlugin_Line::END_ID()));
 146
 147   std::shared_ptr<GeomDataAPI_Point2D> aPointB1 = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 148       aLineB->attribute(SketchPlugin_Line::START_ID()));
 149   std::shared_ptr<GeomDataAPI_Point2D> aPointB2 = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 150       aLineB->attribute(SketchPlugin_Line::END_ID()));
 151
 152   std::shared_ptr<GeomAPI_Pnt2d> aStartA = aPointA1->pnt();
 153   std::shared_ptr<GeomAPI_Pnt2d> aEndA   = aPointA2->pnt();
 154   std::shared_ptr<GeomAPI_Pnt2d> aStartB = aPointB1->pnt();
 155   std::shared_ptr<GeomAPI_Pnt2d> aEndB   = aPointB2->pnt();
 156
 157   double aDist[2][2] = {
 158       { anInter->distance(aStartA), anInter->distance(aEndA) },
 159       { anInter->distance(aStartB), anInter->distance(aEndB) }
 160   };
 161
 162   // Directions of lines
 163   if (aDist[0][0] > aDist[0][1])
 164     aEndA = aStartA;
 165   if (aDist[1][0] > aDist[1][1])
 166     aEndB = aStartB;
 167   std::shared_ptr<GeomAPI_Dir2d> aDirA(new GeomAPI_Dir2d(aEndA->xy()->decreased(anInter->xy())));
 168   std::shared_ptr<GeomAPI_Dir2d> aDirB(new GeomAPI_Dir2d(aEndB->xy()->decreased(anInter->xy())));
 169
 170   anAngle = fabs(aDirA->angle(aDirB)) * 180.0 / PI;
 171   return anAngle;
 172 }
 173
 174 void SketchPlugin_ConstraintAngle::move(double theDeltaX, double theDeltaY)
 175 {
 176   std::shared_ptr<ModelAPI_Data> aData = data();
 177   if (!aData->isValid())
 178     return;
 179
 180   myFlyoutUpdate = true;
 181   std::shared_ptr<GeomDataAPI_Point2D> aFlyoutAttr = std::dynamic_pointer_cast<
 182       GeomDataAPI_Point2D>(aData->attribute(SketchPlugin_Constraint::FLYOUT_VALUE_PNT()));
 183   aFlyoutAttr->setValue(aFlyoutAttr->x() + theDeltaX, aFlyoutAttr->y() + theDeltaY);
 184   myFlyoutUpdate = false;
 185 }
 186
 187
 188 bool SketchPlugin_ConstraintAngle::compute(const std::string& theAttributeId)
 189 {
 190   if (theAttributeId != SketchPlugin_Constraint::FLYOUT_VALUE_PNT())
 191     return false;
 192   if (!sketch())
 193     return false;
 194
 195   std::shared_ptr<GeomDataAPI_Point2D> aFlyOutAttr = std::dynamic_pointer_cast<
 196                            GeomDataAPI_Point2D>(attribute(theAttributeId));
 197   if (fabs(aFlyOutAttr->x()) >= tolerance || fabs(aFlyOutAttr->y()) >= tolerance)
 198     return false;
 199
 200   DataPtr aData = data();
 201   std::shared_ptr<GeomAPI_Ax3> aPlane = SketchPlugin_Sketch::plane(sketch());
 202   FeaturePtr aLineA = SketcherPrs_Tools::getFeatureLine(aData, SketchPlugin_Constraint::ENTITY_A());
 203   FeaturePtr aLineB = SketcherPrs_Tools::getFeatureLine(aData, SketchPlugin_Constraint::ENTITY_B());
 204
 205   if ((aLineA.get() == NULL) || (aLineB.get() == NULL))
 206     return false;
 207
 208   // Start and end points of lines
 209   std::shared_ptr<GeomDataAPI_Point2D> aPointA1 = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 210       aLineA->attribute(SketchPlugin_Line::START_ID()));
 211   std::shared_ptr<GeomDataAPI_Point2D> aPointA2 = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 212       aLineA->attribute(SketchPlugin_Line::END_ID()));
 213
 214   std::shared_ptr<GeomAPI_Pnt2d> aStartA = aPointA1->pnt();
 215   std::shared_ptr<GeomAPI_Pnt2d> aEndA   = aPointA2->pnt();
 216   if (aStartA->distance(aEndA) < tolerance)
 217     return false;
 218
 219   myFlyoutUpdate = true;
 220   double aX = (aStartA->x() + aEndA->x()) / 2.;
 221   double aY = (aStartA->y() + aEndA->y()) / 2.;
 222
 223   aFlyOutAttr->setValue(aX, aY);
 224   myFlyoutUpdate = false;
 225
 226   return true;
 227 }
 228
 229
 230 // ===============   Auxiliary functions   ==================================
 231 std::shared_ptr<GeomAPI_Pnt2d> intersect(FeaturePtr theLine1, FeaturePtr theLine2)
 232 {
 233   // Start and end points of lines
 234   std::shared_ptr<GeomDataAPI_Point2D> aPointA1 = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 235       theLine1->attribute(SketchPlugin_Line::START_ID()));
 236   std::shared_ptr<GeomDataAPI_Point2D> aPointA2 = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 237       theLine1->attribute(SketchPlugin_Line::END_ID()));
 238
 239   std::shared_ptr<GeomDataAPI_Point2D> aPointB1 = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 240       theLine2->attribute(SketchPlugin_Line::START_ID()));
 241   std::shared_ptr<GeomDataAPI_Point2D> aPointB2 = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 242       theLine2->attribute(SketchPlugin_Line::END_ID()));
 243
 244   std::shared_ptr<GeomAPI_Pnt2d> aStartA = aPointA1->pnt();
 245   std::shared_ptr<GeomAPI_Pnt2d> aEndA   = aPointA2->pnt();
 246   std::shared_ptr<GeomAPI_Pnt2d> aStartB = aPointB1->pnt();
 247   std::shared_ptr<GeomAPI_Pnt2d> aEndB   = aPointB2->pnt();
 248   if (aStartA->distance(aEndA) < tolerance || aStartB->distance(aEndB) < tolerance)
 249     std::shared_ptr<GeomAPI_Pnt2d>();
 250
 251   // Lines and their intersection point
 252   std::shared_ptr<GeomAPI_Lin2d> aLA(new GeomAPI_Lin2d(aStartA, aEndA));
 253   std::shared_ptr<GeomAPI_Lin2d> aLB(new GeomAPI_Lin2d(aStartB, aEndB));
 254   return aLA->intersect(aLB);
 255 }