src/SketchPlugin/SketchPlugin_ConstraintAngle.cpp

   1 // Copyright (C) 2014-2019  CEA/DEN, EDF R&D
   2 //
   3 // This library is free software; you can redistribute it and/or
   4 // modify it under the terms of the GNU Lesser General Public
   5 // License as published by the Free Software Foundation; either
   6 // version 2.1 of the License, or (at your option) any later version.
   7 //
   8 // This library is distributed in the hope that it will be useful,
   9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 // Lesser General Public License for more details.
  12 //
  13 // You should have received a copy of the GNU Lesser General Public
  14 // License along with this library; if not, write to the Free Software
  15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16 //
  17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  18 //
  19
  20 #include "SketchPlugin_ConstraintAngle.h"
  21 #include <SketchPlugin_Line.h>
  22 #include <SketchPlugin_Tools.h>
  23 #include <SketcherPrs_Tools.h>
  24
  25 #include <ModelAPI_AttributeDouble.h>
  26 #include <ModelAPI_AttributeInteger.h>
  27 #include <ModelAPI_Session.h>
  28 #include <ModelAPI_Validator.h>
  29
  30 #include <GeomDataAPI_Point2D.h>
  31
  32 #include <GeomAPI_Angle2d.h>
  33 #include <GeomAPI_Dir2d.h>
  34 #include <GeomAPI_Lin2d.h>
  35 #include <GeomAPI_Pnt2d.h>
  36 #include <GeomAPI_XY.h>
  37
  38 #include <SketcherPrs_Factory.h>
  39 #include <SketcherPrs_Tools.h>
  40
  41 #include <math.h>
  42
  43 const double tolerance = 1.e-7;
  44 #define PI 3.1415926535897932
  45
  46 /// \brief Calculate intersection point of two lines
  47 static std::shared_ptr<GeomAPI_Pnt2d> intersect(FeaturePtr theLine1, FeaturePtr theLine2);
  48
  49
  50 SketchPlugin_ConstraintAngle::SketchPlugin_ConstraintAngle()
  51 {
  52   myFlyoutUpdate = false;
  53 }
  54
  55 void SketchPlugin_ConstraintAngle::initAttributes()
  56 {
  57   data()->addAttribute(SketchPlugin_Constraint::VALUE(), ModelAPI_AttributeDouble::typeId());
  58   data()->addAttribute(SketchPlugin_Constraint::ENTITY_A(), ModelAPI_AttributeRefAttr::typeId());
  59   data()->addAttribute(SketchPlugin_Constraint::ENTITY_B(), ModelAPI_AttributeRefAttr::typeId());
  60   data()->addAttribute(SketchPlugin_Constraint::FLYOUT_VALUE_PNT(), GeomDataAPI_Point2D::typeId());
  61
  62   data()->addAttribute(SketchPlugin_ConstraintAngle::ANGLE_VALUE_ID(),
  63                        ModelAPI_AttributeDouble::typeId());
  64   data()->addAttribute(SketchPlugin_ConstraintAngle::TYPE_ID(),
  65                        ModelAPI_AttributeInteger::typeId());
  66
  67   data()->addAttribute(SketchPlugin_ConstraintAngle::ANGLE_REVERSED_FIRST_LINE_ID(),
  68                        ModelAPI_AttributeBoolean::typeId());
  69   data()->addAttribute(SketchPlugin_ConstraintAngle::ANGLE_REVERSED_SECOND_LINE_ID(),
  70                        ModelAPI_AttributeBoolean::typeId());
  71
  72   data()->addAttribute(SketchPlugin_ConstraintAngle::LOCATION_TYPE_ID(),
  73                        ModelAPI_AttributeInteger::typeId());
  74   ModelAPI_Session::get()->validators()->registerNotObligatory(getKind(), LOCATION_TYPE_ID());
  75 }
  76
  77 void SketchPlugin_ConstraintAngle::colorConfigInfo(std::string& theSection, std::string& theName,
  78                                                    std::string& theDefault)
  79 {
  80   theSection = "Visualization";
  81   theName = "sketch_dimension_color";
  82   theDefault = SKETCH_DIMENSION_COLOR;
  83 }
  84
  85 void SketchPlugin_ConstraintAngle::execute()
  86 {
  87   std::shared_ptr<ModelAPI_Data> aData = data();
  88
  89   std::shared_ptr<ModelAPI_AttributeRefAttr> anAttrA =
  90     aData->refattr(SketchPlugin_Constraint::ENTITY_A());
  91   std::shared_ptr<ModelAPI_AttributeRefAttr> anAttrB =
  92     aData->refattr(SketchPlugin_Constraint::ENTITY_B());
  93   if (!anAttrA->isInitialized() || !anAttrB->isInitialized())
  94     return;
  95
  96   AttributeDoublePtr anAttrValue = std::dynamic_pointer_cast<ModelAPI_AttributeDouble>(
  97       aData->attribute(SketchPlugin_ConstraintAngle::ANGLE_VALUE_ID()));
  98
  99   if (!anAttrValue->isInitialized()) {
 100     double anAngle = calculateAngle();
 101     anAttrValue->setValue(anAngle);
 102     updateConstraintValueByAngleValue();
 103   }
 104   // the value should to be computed here, not in the
 105   // getAISObject in order to change the model value
 106   // inside the object transaction. This is important for creating a constraint by preselection.
 107   // The display of the presentation in this case happens after the transaction commit
 108   std::shared_ptr<GeomDataAPI_Point2D> aFlyOutAttr = std::dynamic_pointer_cast<
 109       GeomDataAPI_Point2D>(aData->attribute(SketchPlugin_Constraint::FLYOUT_VALUE_PNT()));
 110   if(!aFlyOutAttr->isInitialized())
 111     compute(SketchPlugin_Constraint::FLYOUT_VALUE_PNT());
 112 }
 113
 114 AISObjectPtr SketchPlugin_ConstraintAngle::getAISObject(AISObjectPtr thePrevious)
 115 {
 116   if (!sketch())
 117     return thePrevious;
 118
 119   AISObjectPtr anAIS = SketcherPrs_Factory::angleConstraint(this, sketch(),
 120                                                             thePrevious);
 121   if (anAIS.get() && !thePrevious.get())
 122     SketchPlugin_Tools::setDimensionColor(anAIS);
 123   return anAIS;
 124 }
 125
 126 void SketchPlugin_ConstraintAngle::attributeChanged(const std::string& theID)
 127 {
 128   std::shared_ptr<ModelAPI_Data> aData = data();
 129   if (!aData)
 130     return;
 131   FeaturePtr aLineA = SketcherPrs_Tools::getFeatureLine(aData, SketchPlugin_Constraint::ENTITY_A());
 132   FeaturePtr aLineB = SketcherPrs_Tools::getFeatureLine(aData, SketchPlugin_Constraint::ENTITY_B());
 133   if (!aLineA || !aLineB)
 134     return;
 135
 136   if (theID == SketchPlugin_Constraint::ENTITY_A() ||
 137       theID == SketchPlugin_Constraint::ENTITY_B()) {
 138     AttributeDoublePtr aValueAttr = real(SketchPlugin_ConstraintAngle::ANGLE_VALUE_ID());
 139     AttributeDoublePtr aConstrValueAttr = real(SketchPlugin_Constraint::VALUE());
 140     // only if one of attributes is not initialized, try to compute the current value
 141     if (!aValueAttr->isInitialized() || !aConstrValueAttr->isInitialized()) {
 142       if (aValueAttr->isInitialized() && !aConstrValueAttr->isInitialized())
 143         // initialize base value of constraint
 144         updateConstraintValueByAngleValue();
 145       double anAngle = calculateAngle();
 146       aValueAttr->setValue(anAngle);
 147       updateConstraintValueByAngleValue();
 148     }
 149   } else if (theID == SketchPlugin_Constraint::FLYOUT_VALUE_PNT() && !myFlyoutUpdate) {
 150     // Recalculate flyout point in local coordinates
 151     // coordinates are calculated according to the center of shapes intersection
 152     std::shared_ptr<GeomDataAPI_Point2D> aFlyoutAttr =
 153       std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 154       attribute(SketchPlugin_Constraint::FLYOUT_VALUE_PNT()));
 155
 156     std::shared_ptr<ModelAPI_Data> aData = data();
 157     std::shared_ptr<GeomAPI_Ax3> aPlane = SketchPlugin_Sketch::plane(sketch());
 158     FeaturePtr aLineA =
 159       SketcherPrs_Tools::getFeatureLine(aData, SketchPlugin_Constraint::ENTITY_A());
 160     FeaturePtr aLineB =
 161       SketcherPrs_Tools::getFeatureLine(aData, SketchPlugin_Constraint::ENTITY_B());
 162
 163     // Intersection of lines
 164     std::shared_ptr<GeomAPI_Pnt2d> anInter = intersect(aLineA, aLineB);
 165     if (!anInter)
 166       return;
 167
 168     myFlyoutUpdate = true;
 169     std::shared_ptr<GeomAPI_XY> aFlyoutDir = aFlyoutAttr->pnt()->xy()->decreased(anInter->xy());
 170     if (aFlyoutDir->dot(aFlyoutDir) < tolerance * tolerance)
 171       aFlyoutAttr->setValue(aFlyoutAttr->x() + tolerance, aFlyoutAttr->y());
 172     myFlyoutUpdate = false;
 173   }
 174   else if (theID == SketchPlugin_ConstraintAngle::TYPE_ID()) {
 175     std::shared_ptr<ModelAPI_AttributeDouble> aValueAttr = std::dynamic_pointer_cast<
 176       ModelAPI_AttributeDouble>(data()->attribute(SketchPlugin_ConstraintAngle::ANGLE_VALUE_ID()));
 177     double anAngle = calculateAngle();
 178     if (aValueAttr->text().empty())
 179       aValueAttr->setValue(anAngle);
 180     else {
 181       aValueAttr = std::dynamic_pointer_cast<
 182         ModelAPI_AttributeDouble>(data()->attribute(SketchPlugin_ConstraintAngle::VALUE()));
 183       aValueAttr->setValue(anAngle);
 184     }
 185   }
 186   else if (theID == SketchPlugin_ConstraintAngle::ANGLE_VALUE_ID()) {
 187     updateConstraintValueByAngleValue();
 188   }
 189 }
 190
 191 double SketchPlugin_ConstraintAngle::calculateAngle()
 192 {
 193   std::shared_ptr<ModelAPI_Data> aData = data();
 194   std::shared_ptr<GeomAPI_Ax3> aPlane = SketchPlugin_Sketch::plane(sketch());
 195   FeaturePtr aLineA = SketcherPrs_Tools::getFeatureLine(aData, SketchPlugin_Constraint::ENTITY_A());
 196   FeaturePtr aLineB = SketcherPrs_Tools::getFeatureLine(aData, SketchPlugin_Constraint::ENTITY_B());
 197
 198   std::shared_ptr<GeomDataAPI_Point2D> aStartA = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 199       aLineA->attribute(SketchPlugin_Line::START_ID()));
 200   std::shared_ptr<GeomDataAPI_Point2D> aEndA = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 201       aLineA->attribute(SketchPlugin_Line::END_ID()));
 202   std::shared_ptr<GeomDataAPI_Point2D> aStartB = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 203       aLineB->attribute(SketchPlugin_Line::START_ID()));
 204   std::shared_ptr<GeomDataAPI_Point2D> aEndB = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 205       aLineB->attribute(SketchPlugin_Line::END_ID()));
 206
 207   std::shared_ptr<GeomAPI_Angle2d> anAng;
 208   if (!attribute(ANGLE_REVERSED_FIRST_LINE_ID())->isInitialized() ||
 209       !attribute(ANGLE_REVERSED_SECOND_LINE_ID())->isInitialized())
 210     anAng = std::shared_ptr<GeomAPI_Angle2d>(new GeomAPI_Angle2d(
 211         aStartA->pnt(), aEndA->pnt(), aStartB->pnt(), aEndB->pnt()));
 212   else {
 213     std::shared_ptr<GeomAPI_Lin2d> aLine1(new GeomAPI_Lin2d(aStartA->pnt(), aEndA->pnt()));
 214     bool isReversed1 = boolean(ANGLE_REVERSED_FIRST_LINE_ID())->value();
 215     std::shared_ptr<GeomAPI_Lin2d> aLine2(new GeomAPI_Lin2d(aStartB->pnt(), aEndB->pnt()));
 216     bool isReversed2 = boolean(ANGLE_REVERSED_SECOND_LINE_ID())->value();
 217     anAng = std::shared_ptr<GeomAPI_Angle2d>(
 218       new GeomAPI_Angle2d(aLine1, isReversed1, aLine2, isReversed2));
 219   }
 220   double anAngle = anAng->angleDegree();
 221   std::shared_ptr<ModelAPI_AttributeDouble> aValueAttr = std::dynamic_pointer_cast<
 222       ModelAPI_AttributeDouble>(data()->attribute(VALUE()));
 223   std::shared_ptr<ModelAPI_AttributeDouble> anAngleValueAttr = std::dynamic_pointer_cast<
 224       ModelAPI_AttributeDouble>(data()->attribute(ANGLE_VALUE_ID()));
 225   if (!aValueAttr->isInitialized())
 226     aValueAttr->setValue(anAngle);
 227   /// an angle value should be corrected by the current angle type
 228   anAngle = getAngleForType(anAngleValueAttr->text().empty() ?
 229                             anAngle : anAngleValueAttr->value());
 230   boolean(ANGLE_REVERSED_FIRST_LINE_ID())->setValue(anAng->isReversed(0));
 231   boolean(ANGLE_REVERSED_SECOND_LINE_ID())->setValue(anAng->isReversed(1));
 232   return anAngle;
 233 }
 234
 235 double SketchPlugin_ConstraintAngle::getAngleForType(double theAngle, bool isPreviousValueObtuse)
 236 {
 237   double anAngle = theAngle;
 238
 239   std::shared_ptr<ModelAPI_Data> aData = data();
 240   std::shared_ptr<ModelAPI_AttributeInteger> aTypeAttr = std::dynamic_pointer_cast<
 241       ModelAPI_AttributeInteger>(aData->attribute(SketchPlugin_ConstraintAngle::TYPE_ID()));
 242   SketcherPrs_Tools::AngleType anAngleType = (SketcherPrs_Tools::AngleType)(aTypeAttr->value());
 243   switch (anAngleType) {
 244     case SketcherPrs_Tools::ANGLE_DIRECT:
 245       anAngle = theAngle;
 246     break;
 247     case SketcherPrs_Tools::ANGLE_COMPLEMENTARY: {
 248       if (theAngle > 180 || isPreviousValueObtuse)
 249         anAngle = theAngle - 180.0;
 250       else
 251         anAngle = 180.0 - theAngle;
 252
 253       if (anAngle < 0.0)
 254         anAngle += 360.0;
 255     }
 256     break;
 257     case SketcherPrs_Tools::ANGLE_BACKWARD:
 258       anAngle = 360.0 - theAngle;
 259     break;
 260     default:
 261       break;
 262   }
 263   return anAngle;
 264 }
 265
 266 void SketchPlugin_ConstraintAngle::updateConstraintValueByAngleValue()
 267 {
 268   std::shared_ptr<ModelAPI_AttributeDouble> aValueAttr = std::dynamic_pointer_cast<
 269     ModelAPI_AttributeDouble>(data()->attribute(SketchPlugin_ConstraintAngle::ANGLE_VALUE_ID()));
 270   double anAngle = aValueAttr->value();
 271
 272   /// an angle value should be corrected by the current angle type
 273   aValueAttr = std::dynamic_pointer_cast<
 274                   ModelAPI_AttributeDouble>(data()->attribute(SketchPlugin_Constraint::VALUE()));
 275   if (!aValueAttr->isInitialized())
 276     calculateAngle();
 277   anAngle = getAngleForType(anAngle, aValueAttr->value() > 180.0);
 278   aValueAttr->setValue(anAngle);
 279 }
 280
 281 bool SketchPlugin_ConstraintAngle::compute(const std::string& theAttributeId)
 282 {
 283   if (theAttributeId != SketchPlugin_Constraint::FLYOUT_VALUE_PNT())
 284     return false;
 285   if (!sketch())
 286     return false;
 287
 288   std::shared_ptr<GeomDataAPI_Point2D> aFlyOutAttr = std::dynamic_pointer_cast<
 289                            GeomDataAPI_Point2D>(attribute(theAttributeId));
 290   if (aFlyOutAttr->isInitialized() &&
 291       (fabs(aFlyOutAttr->x()) >= tolerance || fabs(aFlyOutAttr->y()) >= tolerance))
 292     return false;
 293
 294   DataPtr aData = data();
 295   std::shared_ptr<GeomAPI_Ax3> aPlane = SketchPlugin_Sketch::plane(sketch());
 296   FeaturePtr aLineA = SketcherPrs_Tools::getFeatureLine(aData, SketchPlugin_Constraint::ENTITY_A());
 297   FeaturePtr aLineB = SketcherPrs_Tools::getFeatureLine(aData, SketchPlugin_Constraint::ENTITY_B());
 298
 299   if ((aLineA.get() == NULL) || (aLineB.get() == NULL))
 300     return false;
 301
 302   // Start and end points of lines
 303   std::shared_ptr<GeomDataAPI_Point2D> aPointA1 = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 304       aLineA->attribute(SketchPlugin_Line::START_ID()));
 305   std::shared_ptr<GeomDataAPI_Point2D> aPointA2 = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 306       aLineA->attribute(SketchPlugin_Line::END_ID()));
 307
 308   std::shared_ptr<GeomAPI_Pnt2d> aStartA = aPointA1->pnt();
 309   std::shared_ptr<GeomAPI_Pnt2d> aEndA   = aPointA2->pnt();
 310   if (aStartA->distance(aEndA) < tolerance)
 311     return false;
 312
 313   myFlyoutUpdate = true;
 314   double aX = (aStartA->x() + aEndA->x()) / 2.;
 315   double aY = (aStartA->y() + aEndA->y()) / 2.;
 316
 317   aFlyOutAttr->setValue(aX, aY);
 318   myFlyoutUpdate = false;
 319
 320   return true;
 321 }
 322
 323
 324 // ===============   Auxiliary functions   ==================================
 325 std::shared_ptr<GeomAPI_Pnt2d> intersect(FeaturePtr theLine1, FeaturePtr theLine2)
 326 {
 327   // Start and end points of lines
 328   std::shared_ptr<GeomDataAPI_Point2D> aPointA1 = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 329       theLine1->attribute(SketchPlugin_Line::START_ID()));
 330   std::shared_ptr<GeomDataAPI_Point2D> aPointA2 = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 331       theLine1->attribute(SketchPlugin_Line::END_ID()));
 332
 333   std::shared_ptr<GeomDataAPI_Point2D> aPointB1 = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 334       theLine2->attribute(SketchPlugin_Line::START_ID()));
 335   std::shared_ptr<GeomDataAPI_Point2D> aPointB2 = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 336       theLine2->attribute(SketchPlugin_Line::END_ID()));
 337
 338   std::shared_ptr<GeomAPI_Pnt2d> aStartA = aPointA1->pnt();
 339   std::shared_ptr<GeomAPI_Pnt2d> aEndA   = aPointA2->pnt();
 340   std::shared_ptr<GeomAPI_Pnt2d> aStartB = aPointB1->pnt();
 341   std::shared_ptr<GeomAPI_Pnt2d> aEndB   = aPointB2->pnt();
 342   if (aStartA->distance(aEndA) < tolerance || aStartB->distance(aEndB) < tolerance)
 343     std::shared_ptr<GeomAPI_Pnt2d>();
 344
 345   // Lines and their intersection point
 346   std::shared_ptr<GeomAPI_Lin2d> aLA(new GeomAPI_Lin2d(aStartA, aEndA));
 347   std::shared_ptr<GeomAPI_Lin2d> aLB(new GeomAPI_Lin2d(aStartB, aEndB));
 348   return aLA->intersect(aLB);
 349 }