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 <cmath>
  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   if (myParamBefore == 0) { // parameter has not been calculate yet
 103     std::shared_ptr<GeomAPI_Circ2d> aCircleForArc(
 104         new GeomAPI_Circ2d(aCenterAttr->pnt(), aStartAttr->pnt()));
 105     aCircleForArc->parameter(anEndAttr->pnt(), paramTolerance, myParamBefore);
 106   }
 107
 108   GeomShapePtr anArcShape;
 109   if (fabs(myParamBefore - 2.0 * PI) < paramTolerance)
 110     anArcShape = GeomAlgoAPI_EdgeBuilder::lineCircle(aCenter, aNormal, aStart->distance(aCenter));
 111   else {
 112     anArcShape = boolean(REVERSED_ID())->value() ?
 113       GeomAlgoAPI_EdgeBuilder::lineCircleArc(aCenter, anEnd, aStart, aNormal)
 114     : GeomAlgoAPI_EdgeBuilder::lineCircleArc(aCenter, aStart, anEnd, aNormal);
 115   }
 116
 117   std::shared_ptr<ModelAPI_ResultConstruction> aResult = document()->createConstruction(data(), 1);
 118   aResult->setShape(anArcShape);
 119   aResult->setIsInHistory(false);
 120   setResult(aResult, 1);
 121 }
 122
 123 void SketchPlugin_Arc::move(double theDeltaX, double theDeltaY)
 124 {
 125   std::shared_ptr<ModelAPI_Data> aData = data();
 126   if(!aData->isValid()) {
 127     return;
 128   }
 129
 130   bool aWasBlocked = aData->blockSendAttributeUpdated(true);
 131
 132   std::shared_ptr<GeomDataAPI_Point2D> aCenter = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 133       attribute(CENTER_ID()));
 134   if(aCenter->isInitialized()) {
 135     aCenter->move(theDeltaX, theDeltaY);
 136   }
 137
 138   std::shared_ptr<GeomDataAPI_Point2D> aStart = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 139       attribute(START_ID()));
 140   if(aStart->isInitialized()) {
 141     aStart->move(theDeltaX, theDeltaY);
 142   }
 143
 144   std::shared_ptr<GeomDataAPI_Point2D> anEnd = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 145       attribute(END_ID()));
 146   if(anEnd->isInitialized()) {
 147     anEnd->move(theDeltaX, theDeltaY);
 148   }
 149
 150   aData->blockSendAttributeUpdated(aWasBlocked);
 151 }
 152
 153 bool SketchPlugin_Arc::isFixed()
 154 {
 155   return data()->selection(EXTERNAL_ID())->context().get() != NULL;
 156 }
 157
 158 void SketchPlugin_Arc::attributeChanged(const std::string& theID)
 159 {
 160   std::shared_ptr<GeomDataAPI_Point2D> aCenterAttr = std::dynamic_pointer_cast<
 161       GeomDataAPI_Point2D>(data()->attribute(CENTER_ID()));
 162   std::shared_ptr<GeomDataAPI_Point2D> aStartAttr = std::dynamic_pointer_cast<
 163       GeomDataAPI_Point2D>(data()->attribute(START_ID()));
 164   std::shared_ptr<GeomDataAPI_Point2D> anEndAttr = std::dynamic_pointer_cast<
 165       GeomDataAPI_Point2D>(data()->attribute(END_ID()));
 166
 167   // The second condition for unability to move external segments anywhere.
 168   if(theID == EXTERNAL_ID() || isFixed()) {
 169     std::shared_ptr<GeomAPI_Shape> aSelection = data()->selection(EXTERNAL_ID())->value();
 170     if(!aSelection) {
 171       // empty shape in selection shows that the shape is equal to context
 172       ResultPtr anExtRes = selection(EXTERNAL_ID())->context();
 173       if(anExtRes) {
 174         aSelection = anExtRes->shape();
 175       }
 176     }
 177     // update arguments due to the selection value
 178     if(aSelection && !aSelection->isNull() && aSelection->isEdge()) {
 179       std::shared_ptr<GeomAPI_Edge> anEdge( new GeomAPI_Edge(aSelection));
 180       std::shared_ptr<GeomAPI_Circ> aCirc = anEdge->circle();
 181       if(aCirc.get()) {
 182         bool aWasBlocked = data()->blockSendAttributeUpdated(true);
 183         aCenterAttr->setValue(sketch()->to2D(aCirc->center()));
 184         aStartAttr->setValue(sketch()->to2D(anEdge->firstPoint()));
 185         anEndAttr->setValue(sketch()->to2D(anEdge->lastPoint()));
 186         data()->blockSendAttributeUpdated(aWasBlocked, false);
 187
 188         std::shared_ptr<GeomAPI_Circ2d> aCircle2d =
 189           std::shared_ptr<GeomAPI_Circ2d>(new GeomAPI_Circ2d(aCenterAttr->pnt(),
 190                                                              aStartAttr->pnt()));
 191
 192         double anEndParam = 0.0;
 193         aCircle2d->parameter(anEndAttr->pnt(), paramTolerance, anEndParam);
 194         myParamBefore = anEndParam;
 195
 196         double aMidParam  = anEndParam / 2.0;
 197         std::shared_ptr<GeomAPI_Pnt2d> aMidPnt2d;
 198         aCircle2d->D0(aMidParam, aMidPnt2d);
 199         std::shared_ptr<GeomAPI_Pnt> aMinPnt = sketch()->to3D(aMidPnt2d->x(), aMidPnt2d->y());
 200         double aStartParam = 0.0;
 201         aCirc->parameter(anEdge->firstPoint(), paramTolerance, aStartParam);
 202         aCirc->parameter(aMinPnt, paramTolerance, aMidParam);
 203         aCirc->parameter(anEdge->lastPoint(), paramTolerance, anEndParam);
 204
 205         // adjust period
 206         anEndParam -= aStartParam;
 207         aMidParam -= aStartParam;
 208         if (anEndParam < 0.0)
 209           anEndParam += 2.0 * PI;
 210         if (aMidParam < 0.0)
 211           aMidParam += 2.0 * PI;
 212
 213         aWasBlocked = data()->blockSendAttributeUpdated(true);
 214         if(aMidParam < anEndParam) {
 215           setReversed(false);
 216         } else {
 217           setReversed(true);
 218         }
 219         data()->blockSendAttributeUpdated(aWasBlocked, false);
 220       }
 221     }
 222   } else if(theID == CENTER_ID() || theID == START_ID() || theID == END_ID()) {
 223     if(!aCenterAttr->isInitialized()
 224       || !aStartAttr->isInitialized()
 225       || !anEndAttr->isInitialized()) {
 226       return;
 227     }
 228     std::shared_ptr<GeomAPI_Pnt2d> aCenter = aCenterAttr->pnt();
 229     std::shared_ptr<GeomAPI_Pnt2d> aStart = aStartAttr->pnt();
 230     std::shared_ptr<GeomAPI_Pnt2d> anEnd = anEndAttr->pnt();
 231     double aRadius = aCenter->distance(aStart);
 232     if (aRadius < tolerance)
 233       return;
 234     std::shared_ptr<GeomAPI_Circ2d> aCircleForArc(new GeomAPI_Circ2d(aCenter, aStart));
 235
 236     // Do not recalculate REVERSED flag if the arc is not consistent
 237     std::shared_ptr<GeomAPI_Pnt2d> aProjection = aCircleForArc->project(anEnd);
 238     if (aProjection && anEnd->distance(aProjection) <= tolerance) {
 239       double aParameterNew = 0.0;
 240       if(aCircleForArc->parameter(anEnd, paramTolerance, aParameterNew)) {
 241         bool aWasBlocked = data()->blockSendAttributeUpdated(true);
 242         if(myParamBefore <= PI / 2.0 && aParameterNew >= PI * 1.5) {
 243           if(!boolean(REVERSED_ID())->value()) {
 244             boolean(REVERSED_ID())->setValue(true);
 245           }
 246         } else if(myParamBefore >= PI * 1.5 && aParameterNew <= PI / 2.0) {
 247           if(boolean(REVERSED_ID())->value()) {
 248             boolean(REVERSED_ID())->setValue(false);
 249           }
 250         }
 251         data()->blockSendAttributeUpdated(aWasBlocked, false);
 252       }
 253       if (fabs(aParameterNew) < paramTolerance ||
 254           fabs(aParameterNew - 2.0 * PI) < paramTolerance)
 255         aParameterNew = 2.0 * PI;
 256       myParamBefore = aParameterNew;
 257     }
 258   }
 259
 260   double aRadius = 0;
 261   double anAngle = 0;
 262   if(aCenterAttr->isInitialized() && aStartAttr->isInitialized()) {
 263     aRadius = aCenterAttr->pnt()->distance(aStartAttr->pnt());
 264     if(anEndAttr->isInitialized()) {
 265       if(aStartAttr->pnt()->isEqual(anEndAttr->pnt())) {
 266         anAngle = 360;
 267       } else {
 268         GeomAPI_Circ2d aCircleForArc(aCenterAttr->pnt(), aStartAttr->pnt());
 269         double aStartParam, anEndParam;
 270         aCircleForArc.parameter(aStartAttr->pnt(), paramTolerance, aStartParam);
 271         aCircleForArc.parameter(anEndAttr->pnt(), paramTolerance, anEndParam);
 272         anAngle = (anEndParam - aStartParam) / PI * 180.0;
 273         if(isReversed()) anAngle = 360.0 - anAngle;
 274       }
 275     }
 276   }
 277
 278   bool aWasBlocked = data()->blockSendAttributeUpdated(true);
 279   real(RADIUS_ID())->setValue(aRadius);
 280   real(ANGLE_ID())->setValue(anAngle);
 281   data()->blockSendAttributeUpdated(aWasBlocked, false);
 282 }
 283
 284 void SketchPlugin_Arc::setReversed(bool isReversed)
 285 {
 286   boolean(REVERSED_ID())->setValue(isReversed);
 287 }
 288
 289 bool SketchPlugin_Arc::isReversed()
 290 {
 291   return boolean(REVERSED_ID())->value();
 292 }