]> SALOME platform Git repositories - modules/shaper.git/blob - src/SketchPlugin/SketchPlugin_Arc.cpp
Salome HOME
Revert change for MacroArc attribute names
[modules/shaper.git] / 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 }