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