src/SketchPlugin/SketchPlugin_Arc.cpp

   1 // Copyright (C) 2014-20xx CEA/DEN, EDF R&D -->
   2
   3 // File:        SketchPlugin_Arc.cpp
   4 // Created:     26 Apr 2014
   5 // Author:      Artem ZHIDKOV
   6
   7 #include "SketchPlugin_Arc.h"
   8 #include "SketchPlugin_Sketch.h"
   9 #include <SketchPlugin_ConstraintCoincidence.h>
  10 #include <SketchPlugin_ConstraintTangent.h>
  11
  12 #include <Events_Loop.h>
  13 #include <ModelAPI_Data.h>
  14 #include <ModelAPI_ResultConstruction.h>
  15 #include <ModelAPI_AttributeDouble.h>
  16 #include <ModelAPI_AttributeRefAttr.h>
  17 #include <ModelAPI_AttributeSelection.h>
  18 #include <ModelAPI_AttributeString.h>
  19 #include <ModelAPI_Events.h>
  20 #include <ModelAPI_Validator.h>
  21 #include <ModelAPI_Session.h>
  22 #include <ModelAPI_Tools.h>
  23
  24 #include <GeomAPI_Ax2.h>
  25 #include <GeomAPI_Circ2d.h>
  26 #include <GeomAPI_Circ.h>
  27 #include <GeomAPI_Dir2d.h>
  28 #include <GeomAPI_Dir.h>
  29 #include <GeomAPI_Lin2d.h>
  30 #include <GeomAPI_Lin.h>
  31 #include <GeomAPI_Pnt2d.h>
  32 #include <GeomAPI_Vertex.h>
  33 #include <GeomAPI_XY.h>
  34 #include <GeomDataAPI_Point2D.h>
  35 #include <GeomDataAPI_Dir.h>
  36 #include <GeomAlgoAPI_PointBuilder.h>
  37 #include <GeomAlgoAPI_EdgeBuilder.h>
  38 #include <GeomAlgoAPI_CompoundBuilder.h>
  39 // for sqrt on Linux
  40 #include <math.h>
  41
  42 const double tolerance = 1e-7;
  43 const double paramTolerance = 1.e-4;
  44 const double PI = 3.141592653589793238463;
  45
  46
  47 SketchPlugin_Arc::SketchPlugin_Arc()
  48 : SketchPlugin_SketchEntity()
  49 {
  50   myParamBefore = 0.0;
  51 }
  52
  53 void SketchPlugin_Arc::initDerivedClassAttributes()
  54 {
  55   data()->addAttribute(CENTER_ID(), GeomDataAPI_Point2D::typeId());
  56   data()->addAttribute(START_ID(), GeomDataAPI_Point2D::typeId());
  57   data()->addAttribute(END_ID(), GeomDataAPI_Point2D::typeId());
  58
  59   data()->addAttribute(EXTERNAL_ID(), ModelAPI_AttributeSelection::typeId());
  60   ModelAPI_Session::get()->validators()->registerNotObligatory(getKind(), EXTERNAL_ID());
  61
  62   AttributeBooleanPtr isReversed = std::dynamic_pointer_cast<ModelAPI_AttributeBoolean>(
  63     data()->addAttribute(REVERSED_ID(), ModelAPI_AttributeBoolean::typeId()));
  64
  65   data()->addAttribute(RADIUS_ID(), ModelAPI_AttributeDouble::typeId());
  66   data()->addAttribute(ANGLE_ID(), ModelAPI_AttributeDouble::typeId());
  67
  68   // set after all to avoid in attributeChanged reference to not existing attributes
  69   if (!isReversed->isInitialized()) {
  70     isReversed->setValue(false);
  71   }
  72 }
  73
  74 void SketchPlugin_Arc::execute()
  75 {
  76   SketchPlugin_Sketch* aSketch = sketch();
  77   if(!aSketch) {
  78     return;
  79   }
  80
  81   std::shared_ptr<GeomDataAPI_Point2D> aCenterAttr =
  82       std::dynamic_pointer_cast<GeomDataAPI_Point2D>(data()->attribute(CENTER_ID()));
  83   std::shared_ptr<GeomDataAPI_Point2D> aStartAttr =
  84       std::dynamic_pointer_cast<GeomDataAPI_Point2D>(data()->attribute(START_ID()));
  85   std::shared_ptr<GeomDataAPI_Point2D> anEndAttr =
  86       std::dynamic_pointer_cast<GeomDataAPI_Point2D>(data()->attribute(END_ID()));
  87   if(!aCenterAttr->isInitialized() || !aStartAttr->isInitialized() || !anEndAttr->isInitialized()) {
  88     return;
  89   }
  90
  91   // Make a visible point.
  92   SketchPlugin_Sketch::createPoint2DResult(this, sketch(), CENTER_ID(), 0);
  93
  94   // Make a visible arc.
  95   std::shared_ptr<GeomAPI_Pnt> aCenter(aSketch->to3D(aCenterAttr->x(), aCenterAttr->y()));
  96   std::shared_ptr<GeomAPI_Pnt> aStart(aSketch->to3D(aStartAttr->x(), aStartAttr->y()));
  97   std::shared_ptr<GeomAPI_Pnt> anEnd(aSketch->to3D(anEndAttr->x(), anEndAttr->y()));
  98   std::shared_ptr<GeomDataAPI_Dir> aNDir = std::dynamic_pointer_cast<GeomDataAPI_Dir>(
  99       aSketch->data()->attribute(SketchPlugin_Sketch::NORM_ID()));
 100   std::shared_ptr<GeomAPI_Dir> aNormal(new GeomAPI_Dir(aNDir->x(), aNDir->y(), aNDir->z()));
 101
 102   GeomShapePtr anArcShape = boolean(REVERSED_ID())->value() ?
 103       GeomAlgoAPI_EdgeBuilder::lineCircleArc(aCenter, anEnd, aStart, aNormal)
 104     : GeomAlgoAPI_EdgeBuilder::lineCircleArc(aCenter, aStart, anEnd, aNormal);
 105
 106   std::shared_ptr<ModelAPI_ResultConstruction> aResult = document()->createConstruction(data(), 1);
 107   aResult->setShape(anArcShape);
 108   aResult->setIsInHistory(false);
 109   setResult(aResult, 1);
 110 }
 111
 112 void SketchPlugin_Arc::move(double theDeltaX, double theDeltaY)
 113 {
 114   std::shared_ptr<ModelAPI_Data> aData = data();
 115   if(!aData->isValid()) {
 116     return;
 117   }
 118
 119   bool aWasBlocked = aData->blockSendAttributeUpdated(true);
 120
 121   std::shared_ptr<GeomDataAPI_Point2D> aCenter = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 122       attribute(CENTER_ID()));
 123   if(aCenter->isInitialized()) {
 124     aCenter->move(theDeltaX, theDeltaY);
 125   }
 126
 127   std::shared_ptr<GeomDataAPI_Point2D> aStart = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 128       attribute(START_ID()));
 129   if(aStart->isInitialized()) {
 130     aStart->move(theDeltaX, theDeltaY);
 131   }
 132
 133   std::shared_ptr<GeomDataAPI_Point2D> anEnd = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 134       attribute(END_ID()));
 135   if(anEnd->isInitialized()) {
 136     anEnd->move(theDeltaX, theDeltaY);
 137   }
 138
 139   aData->blockSendAttributeUpdated(aWasBlocked);
 140 }
 141
 142 bool SketchPlugin_Arc::isFixed()
 143 {
 144   return data()->selection(EXTERNAL_ID())->context().get() != NULL;
 145 }
 146
 147 void SketchPlugin_Arc::attributeChanged(const std::string& theID)
 148 {
 149   std::shared_ptr<GeomDataAPI_Point2D> aCenterAttr = std::dynamic_pointer_cast<
 150       GeomDataAPI_Point2D>(data()->attribute(CENTER_ID()));
 151   std::shared_ptr<GeomDataAPI_Point2D> aStartAttr = std::dynamic_pointer_cast<
 152       GeomDataAPI_Point2D>(data()->attribute(START_ID()));
 153   std::shared_ptr<GeomDataAPI_Point2D> anEndAttr = std::dynamic_pointer_cast<
 154       GeomDataAPI_Point2D>(data()->attribute(END_ID()));
 155
 156   // The second condition for unability to move external segments anywhere.
 157   if(theID == EXTERNAL_ID() || isFixed()) {
 158     std::shared_ptr<GeomAPI_Shape> aSelection = data()->selection(EXTERNAL_ID())->value();
 159     if(!aSelection) {
 160       // empty shape in selection shows that the shape is equal to context
 161       ResultPtr anExtRes = selection(EXTERNAL_ID())->context();
 162       if(anExtRes) {
 163         aSelection = anExtRes->shape();
 164       }
 165     }
 166     // update arguments due to the selection value
 167     if(aSelection && !aSelection->isNull() && aSelection->isEdge()) {
 168       std::shared_ptr<GeomAPI_Edge> anEdge( new GeomAPI_Edge(aSelection));
 169       std::shared_ptr<GeomAPI_Circ> aCirc = anEdge->circle();
 170       if(aCirc.get()) {
 171         bool aWasBlocked = data()->blockSendAttributeUpdated(true);
 172         aCenterAttr->setValue(sketch()->to2D(aCirc->center()));
 173         aStartAttr->setValue(sketch()->to2D(anEdge->firstPoint()));
 174         anEndAttr->setValue(sketch()->to2D(anEdge->lastPoint()));
 175         data()->blockSendAttributeUpdated(aWasBlocked, false);
 176
 177         std::shared_ptr<GeomAPI_Circ2d> aCircle2d =
 178           std::shared_ptr<GeomAPI_Circ2d>(new GeomAPI_Circ2d(aCenterAttr->pnt(),
 179                                                              aStartAttr->pnt()));
 180
 181         double anEndParam = 0.0;
 182         aCircle2d->parameter(anEndAttr->pnt(), paramTolerance, anEndParam);
 183         myParamBefore = anEndParam;
 184
 185         double aMidParam  = anEndParam / 2.0;
 186         std::shared_ptr<GeomAPI_Pnt2d> aMidPnt2d;
 187         aCircle2d->D0(aMidParam, aMidPnt2d);
 188         std::shared_ptr<GeomAPI_Pnt> aMinPnt = sketch()->to3D(aMidPnt2d->x(), aMidPnt2d->y());
 189         double aStartParam = 0.0;
 190         aCirc->parameter(anEdge->firstPoint(), paramTolerance, aStartParam);
 191         aCirc->parameter(aMinPnt, paramTolerance, aMidParam);
 192         aCirc->parameter(anEdge->lastPoint(), paramTolerance, anEndParam);
 193         aWasBlocked = data()->blockSendAttributeUpdated(true);
 194         if(aStartParam < aMidParam && aMidParam < anEndParam) {
 195           setReversed(false);
 196         } else {
 197           setReversed(true);
 198         }
 199         data()->blockSendAttributeUpdated(aWasBlocked, false);
 200       }
 201     }
 202   } else if(theID == CENTER_ID() || theID == START_ID() || theID == END_ID()) {
 203     if(!aCenterAttr->isInitialized()
 204       || !aStartAttr->isInitialized()
 205       || !anEndAttr->isInitialized()) {
 206       return;
 207     }
 208     std::shared_ptr<GeomAPI_Pnt2d> aCenter = aCenterAttr->pnt();
 209     std::shared_ptr<GeomAPI_Pnt2d> aStart = aStartAttr->pnt();
 210     std::shared_ptr<GeomAPI_Pnt2d> anEnd = anEndAttr->pnt();
 211     double aRadius = aCenter->distance(aStart);
 212     if (aRadius < tolerance)
 213       return;
 214     std::shared_ptr<GeomAPI_Circ2d> aCircleForArc(new GeomAPI_Circ2d(aCenter, aStart));
 215
 216     bool aWasBlocked = data()->blockSendAttributeUpdated(true);
 217     // The Arc end point is projected
 218     // on the circle formed by center and start points
 219     std::shared_ptr<GeomAPI_Pnt2d> aProjection = aCircleForArc->project(anEnd);
 220     if (aProjection && anEnd->distance(aProjection) > tolerance) {
 221       anEndAttr->setValue(aProjection);
 222       anEnd = aProjection;
 223     }
 224     data()->blockSendAttributeUpdated(aWasBlocked, false);
 225
 226     double aParameterNew = 0.0;
 227     if(aCircleForArc->parameter(anEnd, paramTolerance, aParameterNew)) {
 228       bool aWasBlocked = data()->blockSendAttributeUpdated(true);
 229       if(myParamBefore <= PI / 2.0 && aParameterNew >= PI * 1.5) {
 230         if(!boolean(REVERSED_ID())->value()) {
 231           boolean(REVERSED_ID())->setValue(true);
 232         }
 233       } else if(myParamBefore >= PI * 1.5 && aParameterNew <= PI / 2.0) {
 234         if(boolean(REVERSED_ID())->value()) {
 235           boolean(REVERSED_ID())->setValue(false);
 236         }
 237       }
 238       data()->blockSendAttributeUpdated(aWasBlocked, false);
 239     }
 240     myParamBefore = aParameterNew;
 241   }
 242
 243   double aRadius = 0;
 244   double anAngle = 0;
 245   if(aCenterAttr->isInitialized() && aStartAttr->isInitialized()) {
 246     aRadius = aCenterAttr->pnt()->distance(aStartAttr->pnt());
 247     if(anEndAttr->isInitialized()) {
 248       if(aStartAttr->pnt()->isEqual(anEndAttr->pnt())) {
 249         anAngle = 360;
 250       } else {
 251         GeomAPI_Circ2d aCircleForArc(aCenterAttr->pnt(), aStartAttr->pnt());
 252         double aStartParam, anEndParam;
 253         aCircleForArc.parameter(aStartAttr->pnt(), paramTolerance, aStartParam);
 254         aCircleForArc.parameter(anEndAttr->pnt(), paramTolerance, anEndParam);
 255         anAngle = (anEndParam - aStartParam) / PI * 180.0;
 256         if(isReversed()) anAngle = 360.0 - anAngle;
 257       }
 258     }
 259   }
 260
 261   bool aWasBlocked = data()->blockSendAttributeUpdated(true);
 262   real(RADIUS_ID())->setValue(aRadius);
 263   real(ANGLE_ID())->setValue(anAngle);
 264   data()->blockSendAttributeUpdated(aWasBlocked, false);
 265 }
 266
 267 void SketchPlugin_Arc::setReversed(bool isReversed)
 268 {
 269   boolean(REVERSED_ID())->setValue(isReversed);
 270 }
 271
 272 bool SketchPlugin_Arc::isReversed()
 273 {
 274   return boolean(REVERSED_ID())->value();
 275 }