src/SketchPlugin/SketchPlugin_MacroArc.cpp

   1 // Copyright (C) 2014-20xx CEA/DEN, EDF R&D -->
   2
   3 // File:        SketchPlugin_MacroArc.cpp
   4 // Created:     26 Apr 2014
   5 // Author:      Artem ZHIDKOV
   6
   7 #include "SketchPlugin_MacroArc.h"
   8
   9 #include "SketchPlugin_Arc.h"
  10 #include "SketchPlugin_ConstraintTangent.h"
  11 #include "SketchPlugin_Sketch.h"
  12 #include "SketchPlugin_Tools.h"
  13
  14 #include <ModelAPI_AttributeDouble.h>
  15 #include <ModelAPI_AttributeRefAttr.h>
  16 #include <ModelAPI_AttributeString.h>
  17 #include <ModelAPI_Session.h>
  18 #include <ModelAPI_Validator.h>
  19
  20 #include <GeomAPI_Circ.h>
  21 #include <GeomAPI_Circ2d.h>
  22 #include <GeomAPI_Curve.h>
  23 #include <GeomAPI_Dir2d.h>
  24 #include <GeomAPI_Edge.h>
  25 #include <GeomAPI_Lin.h>
  26 #include <GeomAPI_Lin2d.h>
  27 #include <GeomAPI_Pnt2d.h>
  28 #include <GeomAPI_Vertex.h>
  29 #include <GeomAPI_XY.h>
  30
  31 #include <GeomDataAPI_Point2D.h>
  32 #include <GeomDataAPI_Dir.h>
  33 #include <GeomAlgoAPI_PointBuilder.h>
  34 #include <GeomAlgoAPI_EdgeBuilder.h>
  35 #include <GeomAlgoAPI_CompoundBuilder.h>
  36
  37 // for sqrt on Linux
  38 #include <math.h>
  39
  40 const double tolerance = 1e-7;
  41 const double paramTolerance = 1.e-4;
  42 const double PI = 3.141592653589793238463;
  43
  44 static void projectPointOnCircle(AttributePoint2DPtr& thePoint, const GeomAPI_Circ2d& theCircle)
  45 {
  46   std::shared_ptr<GeomAPI_Pnt2d> aProjection = theCircle.project(thePoint->pnt());
  47   if(aProjection.get())
  48     thePoint->setValue(aProjection);
  49 }
  50
  51
  52 SketchPlugin_MacroArc::SketchPlugin_MacroArc()
  53 : SketchPlugin_SketchEntity(),
  54   myParamBefore(0.0)
  55 {
  56 }
  57
  58 void SketchPlugin_MacroArc::initAttributes()
  59 {
  60   data()->addAttribute(ARC_TYPE(), ModelAPI_AttributeString::typeId());
  61
  62   data()->addAttribute(CENTER_POINT_ID(), GeomDataAPI_Point2D::typeId());
  63   data()->addAttribute(START_POINT_ID(), GeomDataAPI_Point2D::typeId());
  64   data()->addAttribute(END_POINT_ID(), GeomDataAPI_Point2D::typeId());
  65
  66   data()->addAttribute(PASSED_POINT_ID(), GeomDataAPI_Point2D::typeId());
  67
  68   data()->addAttribute(TANGENT_POINT_ID(), ModelAPI_AttributeRefAttr::typeId());
  69
  70   data()->addAttribute(REVERSED_ID(), ModelAPI_AttributeBoolean::typeId());
  71
  72   data()->addAttribute(RADIUS_ID(), ModelAPI_AttributeDouble::typeId());
  73   data()->addAttribute(ANGLE_ID(), ModelAPI_AttributeDouble::typeId());
  74
  75   data()->addAttribute(AUXILIARY_ID(), ModelAPI_AttributeBoolean::typeId());
  76
  77   data()->addAttribute(CENTER_POINT_REF_ID(), ModelAPI_AttributeRefAttr::typeId());
  78   data()->addAttribute(START_POINT_REF_ID(), ModelAPI_AttributeRefAttr::typeId());
  79   data()->addAttribute(END_POINT_REF_ID(), ModelAPI_AttributeRefAttr::typeId());
  80   data()->addAttribute(PASSED_POINT_REF_ID(), ModelAPI_AttributeRefAttr::typeId());
  81
  82   boolean(REVERSED_ID())->setValue(false);
  83
  84   ModelAPI_Session::get()->validators()->registerNotObligatory(getKind(), CENTER_POINT_REF_ID());
  85   ModelAPI_Session::get()->validators()->registerNotObligatory(getKind(), START_POINT_REF_ID());
  86   ModelAPI_Session::get()->validators()->registerNotObligatory(getKind(), END_POINT_REF_ID());
  87   ModelAPI_Session::get()->validators()->registerNotObligatory(getKind(), PASSED_POINT_REF_ID());
  88 }
  89
  90 void SketchPlugin_MacroArc::attributeChanged(const std::string& theID)
  91 {
  92   std::string anArcType = string(ARC_TYPE())->value();
  93
  94   // If arc type switched reset according attributes.
  95   if(theID == ARC_TYPE()) {
  96     SketchPlugin_Tools::resetAttribute(this, CENTER_POINT_ID());
  97     SketchPlugin_Tools::resetAttribute(this, CENTER_POINT_REF_ID());
  98     SketchPlugin_Tools::resetAttribute(this, START_POINT_ID());
  99     SketchPlugin_Tools::resetAttribute(this, START_POINT_REF_ID());
 100     SketchPlugin_Tools::resetAttribute(this, END_POINT_ID());
 101     SketchPlugin_Tools::resetAttribute(this, END_POINT_REF_ID());
 102     SketchPlugin_Tools::resetAttribute(this, PASSED_POINT_ID());
 103     SketchPlugin_Tools::resetAttribute(this, PASSED_POINT_REF_ID());
 104     SketchPlugin_Tools::resetAttribute(this, TANGENT_POINT_ID());
 105     SketchPlugin_Tools::resetAttribute(this, REVERSED_ID());
 106     SketchPlugin_Tools::resetAttribute(this, RADIUS_ID());
 107     SketchPlugin_Tools::resetAttribute(this, ANGLE_ID());
 108
 109     myCenter.reset();
 110     myStart.reset();
 111     myEnd.reset();
 112     boolean(REVERSED_ID())->setValue(false);
 113     myParamBefore = 0.0;
 114   } else if(anArcType == ARC_TYPE_BY_CENTER_AND_POINTS())
 115     fillByCenterAndTwoPassed();
 116   else if(anArcType == ARC_TYPE_BY_THREE_POINTS())
 117     fillByThreePassedPoints();
 118   else if(anArcType == ARC_TYPE_BY_TANGENT_EDGE())
 119     fillByTangentEdge();
 120
 121   double aRadius = 0;
 122   double anAngle = 0;
 123   if(myCenter.get() && myStart.get()) {
 124     aRadius = myCenter->distance(myStart);
 125     if(myEnd.get()) {
 126       if(myStart->isEqual(myEnd)) {
 127         anAngle = 360;
 128       } else {
 129         GeomAPI_Circ2d aCircleForArc(myCenter, myStart);
 130         double aStartParam, anEndParam;
 131         aCircleForArc.parameter(myStart, paramTolerance, aStartParam);
 132         aCircleForArc.parameter(myEnd, paramTolerance, anEndParam);
 133         anAngle = (anEndParam - aStartParam) / PI * 180.0;
 134         if(boolean(REVERSED_ID())->value()) anAngle = 360.0 - anAngle;
 135       }
 136     }
 137   }
 138
 139   bool aWasBlocked = data()->blockSendAttributeUpdated(true);
 140   real(RADIUS_ID())->setValue(aRadius);
 141   real(ANGLE_ID())->setValue(anAngle);
 142   data()->blockSendAttributeUpdated(aWasBlocked, false);
 143 }
 144
 145 AISObjectPtr SketchPlugin_MacroArc::getAISObject(AISObjectPtr thePrevious)
 146 {
 147   if(!myStart.get() || !myEnd.get() || !myCenter.get()) {
 148     return AISObjectPtr();
 149   }
 150
 151   SketchPlugin_Sketch* aSketch = sketch();
 152   if(!aSketch) {
 153     return AISObjectPtr();
 154   }
 155
 156   std::shared_ptr<GeomAPI_Pnt> aStart = aSketch->to3D(myStart->x(), myStart->y());
 157   std::shared_ptr<GeomAPI_Pnt> anEnd = aSketch->to3D(myEnd->x(), myEnd->y());
 158   std::shared_ptr<GeomAPI_Pnt> aCenter = aSketch->to3D(myCenter->x(), myCenter->y());;
 159
 160   std::shared_ptr<GeomDataAPI_Dir> aNDir =
 161       std::dynamic_pointer_cast<GeomDataAPI_Dir>(
 162           aSketch->data()->attribute(SketchPlugin_Sketch::NORM_ID()));
 163   std::shared_ptr<GeomAPI_Dir> aNormal = aNDir->dir();
 164   GeomShapePtr anArcShape = boolean(REVERSED_ID())->value() ?
 165       GeomAlgoAPI_EdgeBuilder::lineCircleArc(aCenter, anEnd, aStart, aNormal)
 166     : GeomAlgoAPI_EdgeBuilder::lineCircleArc(aCenter, aStart, anEnd, aNormal);
 167   GeomShapePtr aCenterPointShape = GeomAlgoAPI_PointBuilder::vertex(aCenter);
 168
 169   if(!anArcShape.get() || !aCenterPointShape.get()) {
 170     return AISObjectPtr();
 171   }
 172
 173   std::list<std::shared_ptr<GeomAPI_Shape> > aShapes;
 174   aShapes.push_back(anArcShape);
 175   aShapes.push_back(aCenterPointShape);
 176
 177   std::shared_ptr<GeomAPI_Shape> aCompound = GeomAlgoAPI_CompoundBuilder::compound(aShapes);
 178   AISObjectPtr anAIS = thePrevious;
 179   if(!anAIS.get()) {
 180     anAIS.reset(new GeomAPI_AISObject());
 181   }
 182   anAIS->createShape(aCompound);
 183   return anAIS;
 184 }
 185
 186 void SketchPlugin_MacroArc::execute()
 187 {
 188   FeaturePtr anArcFeature = createArcFeature();
 189
 190   myCenter.reset();
 191   myStart.reset();
 192   myEnd.reset();
 193
 194   // Create constraints.
 195   std::string anArcType = string(ARC_TYPE())->value();
 196   if(anArcType == ARC_TYPE_BY_CENTER_AND_POINTS()) {
 197     SketchPlugin_Tools::createConstraint(this,
 198                                          CENTER_POINT_REF_ID(),
 199                                          anArcFeature->attribute(SketchPlugin_Arc::CENTER_ID()),
 200                                          ObjectPtr(),
 201                                          false);
 202     SketchPlugin_Tools::createConstraint(this,
 203                                          START_POINT_REF_ID(),
 204                                          anArcFeature->attribute(SketchPlugin_Arc::START_ID()),
 205                                          ObjectPtr(),
 206                                          false);
 207     SketchPlugin_Tools::createConstraint(this,
 208                                          END_POINT_REF_ID(),
 209                                          anArcFeature->attribute(SketchPlugin_Arc::END_ID()),
 210                                          ObjectPtr(),
 211                                          false);
 212   } else if(anArcType == ARC_TYPE_BY_THREE_POINTS()) {
 213     SketchPlugin_Tools::createConstraint(this,
 214                                          START_POINT_REF_ID(),
 215                                          anArcFeature->attribute(SketchPlugin_Arc::START_ID()),
 216                                          ObjectPtr(),
 217                                          false);
 218     SketchPlugin_Tools::createConstraint(this,
 219                                          END_POINT_REF_ID(),
 220                                          anArcFeature->attribute(SketchPlugin_Arc::END_ID()),
 221                                          ObjectPtr(),
 222                                          false);
 223     SketchPlugin_Tools::createConstraint(this,
 224                                          PASSED_POINT_REF_ID(),
 225                                          AttributePtr(),
 226                                          anArcFeature->lastResult(),
 227                                          true);
 228   } else if(anArcType == ARC_TYPE_BY_TANGENT_EDGE()) {
 229     // constraints for tangent arc
 230     SketchPlugin_Tools::createConstraint(this,
 231                                          TANGENT_POINT_ID(),
 232                                          anArcFeature->attribute(SketchPlugin_Arc::START_ID()),
 233                                          ObjectPtr(),
 234                                          false);
 235     FeaturePtr aTangent = sketch()->addFeature(SketchPlugin_ConstraintTangent::ID());
 236     AttributeRefAttrPtr aRefAttrA = aTangent->refattr(SketchPlugin_Constraint::ENTITY_A());
 237     AttributeRefAttrPtr aTgPntRefAttr = refattr(TANGENT_POINT_ID());
 238     FeaturePtr aTgFeature = ModelAPI_Feature::feature(aTgPntRefAttr->attr()->owner());
 239     aRefAttrA->setObject(aTgFeature->lastResult());
 240     AttributeRefAttrPtr aRefAttrB = aTangent->refattr(SketchPlugin_Constraint::ENTITY_B());
 241     aRefAttrB->setObject(anArcFeature->lastResult());
 242     // constraint for end point
 243     SketchPlugin_Tools::createConstraint(this,
 244                                          END_POINT_REF_ID(),
 245                                          anArcFeature->attribute(SketchPlugin_Arc::END_ID()),
 246                                          ObjectPtr(),
 247                                          false);
 248   }
 249 }
 250
 251 FeaturePtr SketchPlugin_MacroArc::createArcFeature()
 252 {
 253   FeaturePtr anArcFeature = sketch()->addFeature(SketchPlugin_Arc::ID());
 254   std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 255       anArcFeature->attribute(SketchPlugin_Arc::CENTER_ID()))->setValue(myCenter);
 256   std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 257       anArcFeature->attribute(SketchPlugin_Arc::START_ID()))->setValue(myStart);
 258   std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 259       anArcFeature->attribute(SketchPlugin_Arc::END_ID()))->setValue(myEnd);
 260   anArcFeature->boolean(SketchPlugin_Arc::REVERSED_ID())
 261                 ->setValue(boolean(REVERSED_ID())->value());
 262   anArcFeature->boolean(SketchPlugin_Arc::AUXILIARY_ID())
 263                 ->setValue(boolean(AUXILIARY_ID())->value());
 264   anArcFeature->execute();
 265
 266   return anArcFeature;
 267 }
 268
 269 void SketchPlugin_MacroArc::fillByCenterAndTwoPassed()
 270 {
 271   AttributePoint2DPtr aCenterPointAttr =
 272       std::dynamic_pointer_cast<GeomDataAPI_Point2D>(attribute(CENTER_POINT_ID()));
 273   if (!aCenterPointAttr->isInitialized())
 274       return;
 275
 276   AttributePoint2DPtr aStartPointAttr =
 277       std::dynamic_pointer_cast<GeomDataAPI_Point2D>(attribute(START_POINT_ID()));
 278   if (!aStartPointAttr->isInitialized())
 279     return;
 280
 281   myCenter = aCenterPointAttr->pnt();
 282   myStart = aStartPointAttr->pnt();
 283   myEnd = myStart;
 284
 285   AttributePoint2DPtr anEndPointAttr =
 286       std::dynamic_pointer_cast<GeomDataAPI_Point2D>(attribute(END_POINT_ID()));
 287   if (!anEndPointAttr->isInitialized())
 288     return;
 289
 290   GeomAPI_Circ2d aCircleForArc(myCenter, myStart);
 291
 292   // End point should be a projection on circle.
 293   bool aWasBlocked = data()->blockSendAttributeUpdated(true);
 294   projectPointOnCircle(anEndPointAttr, aCircleForArc);
 295   data()->blockSendAttributeUpdated(aWasBlocked, false);
 296   myEnd = anEndPointAttr->pnt();
 297
 298   // update the REVERSED flag
 299   recalculateReversedFlagByEnd(aCircleForArc);
 300 }
 301
 302 void SketchPlugin_MacroArc::recalculateReversedFlagByEnd(const GeomAPI_Circ2d& theCurrentCircular)
 303 {
 304   double aParameterNew = 0.0;
 305   if(theCurrentCircular.parameter(myEnd, paramTolerance, aParameterNew)) {
 306     if(myParamBefore <= PI / 2.0 && aParameterNew >= PI * 1.5) {
 307       boolean(REVERSED_ID())->setValue(true);
 308     } else if(myParamBefore >= PI * 1.5 && aParameterNew <= PI / 2.0) {
 309       boolean(REVERSED_ID())->setValue(false);
 310     }
 311   }
 312   myParamBefore = aParameterNew;
 313 }
 314
 315 void SketchPlugin_MacroArc::fillByThreePassedPoints()
 316 {
 317   AttributePoint2DPtr aStartPointAttr =
 318       std::dynamic_pointer_cast<GeomDataAPI_Point2D>(attribute(START_POINT_ID()));
 319   if (!aStartPointAttr->isInitialized())
 320     return;
 321
 322   AttributePoint2DPtr anEndPointAttr =
 323       std::dynamic_pointer_cast<GeomDataAPI_Point2D>(attribute(END_POINT_ID()));
 324   if (!anEndPointAttr->isInitialized())
 325     return;
 326
 327   myStart = aStartPointAttr->pnt();
 328   myEnd = anEndPointAttr->pnt();
 329
 330   AttributePoint2DPtr aPassedPointAttr =
 331       std::dynamic_pointer_cast<GeomDataAPI_Point2D>(attribute(PASSED_POINT_ID()));
 332   if (aPassedPointAttr->isInitialized()) {
 333     std::shared_ptr<GeomAPI_Pnt2d> aPassedPnt;
 334     std::shared_ptr<GeomAPI_Shape> aTangentCurve;
 335     SketchPlugin_Tools::convertRefAttrToPointOrTangentCurve(
 336         refattr(PASSED_POINT_REF_ID()), aPassedPointAttr, aTangentCurve, aPassedPnt);
 337
 338     std::shared_ptr<GeomAPI_Interface> aPassed;
 339     if (aTangentCurve)
 340       aPassed = aTangentCurve;
 341     else
 342       aPassed = aPassedPnt;
 343
 344     std::shared_ptr<GeomAPI_Ax3> anAxis = SketchPlugin_Sketch::plane(sketch());
 345     GeomAPI_Circ2d aCircle(myStart, myEnd, aPassed, anAxis);
 346     myCenter = aCircle.center();
 347
 348     recalculateReversedFlagByPassed(aCircle);
 349   } else
 350     myCenter.reset(new GeomAPI_Pnt2d(myStart->xy()->added(myEnd->xy())->multiplied(0.5)));
 351 }
 352
 353 void SketchPlugin_MacroArc::recalculateReversedFlagByPassed(
 354     const GeomAPI_Circ2d& theCurrentCircular)
 355 {
 356   AttributePoint2DPtr aPassedAttr =
 357       std::dynamic_pointer_cast<GeomDataAPI_Point2D>(attribute(PASSED_POINT_ID()));
 358   std::shared_ptr<GeomAPI_Pnt2d> aPassed = theCurrentCircular.project(aPassedAttr->pnt());
 359
 360   double aEndParam, aPassedParam;
 361   theCurrentCircular.parameter(myEnd, paramTolerance, aEndParam);
 362   theCurrentCircular.parameter(aPassed, paramTolerance, aPassedParam);
 363
 364   if(aPassedParam > aEndParam)
 365     boolean(REVERSED_ID())->setValue(true);
 366   else
 367     boolean(REVERSED_ID())->setValue(false);
 368
 369   myParamBefore = aEndParam;
 370 }
 371
 372 void SketchPlugin_MacroArc::fillByTangentEdge()
 373 {
 374   AttributeRefAttrPtr aTangentAttr = refattr(TANGENT_POINT_ID());
 375   if (!aTangentAttr->isInitialized())
 376     return;
 377
 378   AttributePoint2DPtr aTangentPointAttr =
 379       std::dynamic_pointer_cast<GeomDataAPI_Point2D>(aTangentAttr->attr());
 380   if (!aTangentPointAttr->isInitialized())
 381     return;
 382
 383   AttributePoint2DPtr anEndPointAttr =
 384       std::dynamic_pointer_cast<GeomDataAPI_Point2D>(attribute(END_POINT_ID()));
 385   if (!anEndPointAttr->isInitialized())
 386     return;
 387
 388   myStart = aTangentPointAttr->pnt();
 389   myEnd = anEndPointAttr->pnt();
 390   if (myStart->isEqual(myEnd))
 391     return;
 392
 393   // obtain a shape the tangent point belongs to
 394   FeaturePtr aTangentFeature = ModelAPI_Feature::feature(aTangentPointAttr->owner());
 395   std::shared_ptr<GeomAPI_Shape> aTangentShape = aTangentFeature->lastResult()->shape();
 396
 397   std::shared_ptr<GeomAPI_Ax3> anAxis = SketchPlugin_Sketch::plane(sketch());
 398   GeomAPI_Circ2d aCircle(myStart, myEnd, aTangentShape, anAxis);
 399   myCenter = aCircle.center();
 400
 401   // rebuild circle to set start point equal to zero parameter
 402   aCircle = GeomAPI_Circ2d(myCenter, myStart);
 403   recalculateReversedFlagByEnd(aCircle);
 404 }