]> SALOME platform Git repositories - modules/shaper.git/blob - src/SketchPlugin/SketchPlugin_ConstraintAngle.cpp
Salome HOME
[bos #37570] [CEA] SHAPER hdf tests are failing. Fix Sphere feature attributes order.
[modules/shaper.git] / src / SketchPlugin / SketchPlugin_ConstraintAngle.cpp
1 // Copyright (C) 2014-2023  CEA, EDF
2 //
3 // This library is free software; you can redistribute it and/or
4 // modify it under the terms of the GNU Lesser General Public
5 // License as published by the Free Software Foundation; either
6 // version 2.1 of the License, or (at your option) any later version.
7 //
8 // This library is distributed in the hope that it will be useful,
9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
11 // Lesser General Public License for more details.
12 //
13 // You should have received a copy of the GNU Lesser General Public
14 // License along with this library; if not, write to the Free Software
15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
16 //
17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
18 //
19
20 #include "SketchPlugin_ConstraintAngle.h"
21 #include <SketchPlugin_Line.h>
22 #include <SketchPlugin_Tools.h>
23 #include <SketcherPrs_Tools.h>
24
25 #include <ModelAPI_AttributeDouble.h>
26 #include <ModelAPI_AttributeInteger.h>
27 #include <ModelAPI_EventReentrantMessage.h>
28 #include <ModelAPI_Session.h>
29 #include <ModelAPI_Validator.h>
30
31 #include <Locale_Convert.h>
32
33 #include <GeomDataAPI_Point2D.h>
34
35 #include <GeomAPI_Angle2d.h>
36 #include <GeomAPI_Dir2d.h>
37 #include <GeomAPI_Lin2d.h>
38 #include <GeomAPI_Pnt2d.h>
39 #include <GeomAPI_XY.h>
40
41 #include <SketcherPrs_Factory.h>
42 #include <SketcherPrs_Tools.h>
43
44 #include <cmath>
45 #include <regex>
46 #include <sstream>
47 #include <vector>
48
49 const double tolerance = 1.e-7;
50 #define PI 3.1415926535897932
51
52 // To support old types of GCC (less than 4.9), check the regular expressions are working
53 #if (__cplusplus >= 201103L || _MSVC_LANG >= 201103L)  && \
54     (__cplusplus >= 201402L || !defined(__GLIBCXX__)   || \
55         (defined(_GLIBCXX_REGEX_DFS_QUANTIFIERS_LIMIT) || \
56          defined(_GLIBCXX_REGEX_STATE_LIMIT)           || \
57          (defined(_GLIBCXX_RELEASE) && _GLIBCXX_RELEASE > 4)))
58 #define HAVE_WORKING_REGEX 1
59 #else
60 #define HAVE_WORKING_REGEX 0
61 #endif
62
63
64 /// \brief Calculate intersection point of two lines
65 static std::shared_ptr<GeomAPI_Pnt2d> intersect(FeaturePtr theLine1, FeaturePtr theLine2);
66
67
68 SketchPlugin_ConstraintAngle::SketchPlugin_ConstraintAngle()
69 {
70   myFlyoutUpdate = false;
71 }
72
73 void SketchPlugin_ConstraintAngle::initAttributes()
74 {
75   ModelAPI_ValidatorsFactory* aValidators = ModelAPI_Session::get()->validators();
76
77   data()->addAttribute(SketchPlugin_Constraint::VALUE(), ModelAPI_AttributeDouble::typeId());
78   data()->addAttribute(SketchPlugin_Constraint::ENTITY_A(), ModelAPI_AttributeRefAttr::typeId());
79   data()->addAttribute(SketchPlugin_Constraint::ENTITY_B(), ModelAPI_AttributeRefAttr::typeId());
80   data()->addAttribute(SketchPlugin_Constraint::FLYOUT_VALUE_PNT(), GeomDataAPI_Point2D::typeId());
81
82   data()->addAttribute(ANGLE_VALUE_ID(), ModelAPI_AttributeDouble::typeId());
83   data()->addAttribute(TYPE_ID(), ModelAPI_AttributeInteger::typeId());
84
85   data()->addAttribute(ANGLE_REVERSED_FIRST_LINE_ID(), ModelAPI_AttributeBoolean::typeId());
86   data()->addAttribute(ANGLE_REVERSED_SECOND_LINE_ID(), ModelAPI_AttributeBoolean::typeId());
87
88   data()->addAttribute(LOCATION_TYPE_ID(), ModelAPI_AttributeInteger::typeId());
89   aValidators->registerNotObligatory(getKind(), LOCATION_TYPE_ID());
90
91   data()->addAttribute(PREV_TYPE_ID(), ModelAPI_AttributeInteger::typeId());
92   data()->attribute(PREV_TYPE_ID())->setIsArgument(false);
93   aValidators->registerNotObligatory(getKind(), PREV_TYPE_ID());
94   if (attribute(TYPE_ID())->isInitialized())
95     integer(PREV_TYPE_ID())->setValue(integer(TYPE_ID())->value());
96
97   data()->addAttribute(SELECTED_FIRST_POINT_ID(), GeomDataAPI_Point2D::typeId());
98   data()->attribute(SELECTED_FIRST_POINT_ID())->setIsArgument(false);
99   aValidators->registerNotObligatory(getKind(), SELECTED_FIRST_POINT_ID());
100
101   data()->addAttribute(SELECTED_SECOND_POINT_ID(), GeomDataAPI_Point2D::typeId());
102   data()->attribute(SELECTED_SECOND_POINT_ID())->setIsArgument(false);
103   aValidators->registerNotObligatory(getKind(), SELECTED_SECOND_POINT_ID());
104
105   AttributeIntegerPtr aVerAttr = std::dynamic_pointer_cast<ModelAPI_AttributeInteger>(
106       data()->addAttribute(VERSION_ID(), ModelAPI_AttributeInteger::typeId()));
107   aVerAttr->setIsArgument(false);
108   ModelAPI_Session::get()->validators()->registerNotObligatory(getKind(), VERSION_ID());
109   if (!aVerAttr->isInitialized()) {
110     // this is a newly created feature (not read from file),
111     // so, initialize the latest version
112     aVerAttr->setValue(THE_VERSION_1);
113   }
114 }
115
116 void SketchPlugin_ConstraintAngle::colorConfigInfo(std::string& theSection, std::string& theName,
117                                                    std::string& theDefault)
118 {
119   theSection = "Visualization";
120   theName = "sketch_dimension_color";
121   theDefault = SKETCH_DIMENSION_COLOR;
122 }
123
124 void SketchPlugin_ConstraintAngle::execute()
125 {
126   std::shared_ptr<ModelAPI_Data> aData = data();
127
128   AttributeRefAttrPtr anAttrA = aData->refattr(SketchPlugin_Constraint::ENTITY_A());
129   AttributeRefAttrPtr anAttrB = aData->refattr(SketchPlugin_Constraint::ENTITY_B());
130   if (!anAttrA->isInitialized() || !anAttrB->isInitialized())
131     return;
132
133   AttributeIntegerPtr aVersion = integer(VERSION_ID());
134   if (!aVersion->isInitialized() || aVersion->value() < THE_VERSION_1)
135     updateVersion();
136
137   AttributeDoublePtr anAttrValue = real(ANGLE_VALUE_ID());
138   if (!anAttrValue->isInitialized())
139     calculateAngle();
140
141   // the value should to be computed here, not in the
142   // getAISObject in order to change the model value
143   // inside the object transaction. This is important for creating a constraint by preselection.
144   // The display of the presentation in this case happens after the transaction commit
145   std::shared_ptr<GeomDataAPI_Point2D> aFlyOutAttr = std::dynamic_pointer_cast<
146       GeomDataAPI_Point2D>(aData->attribute(SketchPlugin_Constraint::FLYOUT_VALUE_PNT()));
147   if(!aFlyOutAttr->isInitialized())
148     compute(SketchPlugin_Constraint::FLYOUT_VALUE_PNT());
149 }
150
151 AISObjectPtr SketchPlugin_ConstraintAngle::getAISObject(AISObjectPtr thePrevious)
152 {
153   if (!sketch())
154     return thePrevious;
155
156   AISObjectPtr anAIS = SketcherPrs_Factory::angleConstraint(this, sketch(),
157                                                             thePrevious);
158   if (anAIS.get() && !thePrevious.get())
159     SketchPlugin_Tools::setDimensionColor(anAIS);
160   return anAIS;
161 }
162
163 // LCOV_EXCL_START
164 std::string SketchPlugin_ConstraintAngle::processEvent(
165     const std::shared_ptr<Events_Message>& theMessage)
166 {
167   std::string aFilledAttributeName;
168
169   std::shared_ptr<ModelAPI_EventReentrantMessage> aReentrantMessage =
170       std::dynamic_pointer_cast<ModelAPI_EventReentrantMessage>(theMessage);
171   if (aReentrantMessage.get()) {
172     aFilledAttributeName = ENTITY_A();
173     refattr(ENTITY_A())->setObject(aReentrantMessage->selectedObject());
174     std::dynamic_pointer_cast<GeomDataAPI_Point2D>(attribute(SELECTED_FIRST_POINT_ID()))
175         ->setValue(aReentrantMessage->clickedPoint());
176   }
177   return aFilledAttributeName;
178 }
179 // LCOV_EXCL_STOP
180
181 void SketchPlugin_ConstraintAngle::attributeChanged(const std::string& theID)
182 {
183   if (myFlyoutUpdate)
184     return;
185
186   std::shared_ptr<ModelAPI_Data> aData = data();
187   if (!aData)
188     return;
189
190   if (theID == TYPE_ID())
191     updateAngleValue();
192
193   FeaturePtr aLineA = SketcherPrs_Tools::getFeatureLine(aData, ENTITY_A());
194   FeaturePtr aLineB = SketcherPrs_Tools::getFeatureLine(aData, ENTITY_B());
195   if (!aLineA || !aLineB)
196     return;
197
198   AttributeIntegerPtr aVersion = integer(VERSION_ID());
199   if (!aVersion->isInitialized() || aVersion->value() < THE_VERSION_1)
200     updateVersion();
201
202   if (theID == ENTITY_A() || theID == ENTITY_B() ||
203       theID == TYPE_ID() || theID == ANGLE_VALUE_ID()) {
204     calculateAngle();
205   } else if (theID == FLYOUT_VALUE_PNT()) {
206     compute(theID);
207   }
208 }
209
210 void SketchPlugin_ConstraintAngle::calculateAngle()
211 {
212   // update *_REVERSED_* flags
213   calculateAnglePosition();
214
215   std::shared_ptr<ModelAPI_Data> aData = data();
216   std::shared_ptr<GeomAPI_Ax3> aPlane = SketchPlugin_Sketch::plane(sketch());
217   FeaturePtr aLineA = SketcherPrs_Tools::getFeatureLine(aData, ENTITY_A());
218   FeaturePtr aLineB = SketcherPrs_Tools::getFeatureLine(aData, ENTITY_B());
219
220   GeomPnt2dPtr aStartA = SketcherPrs_Tools::getPoint(aLineA.get(), SketchPlugin_Line::START_ID());
221   GeomPnt2dPtr aEndA = SketcherPrs_Tools::getPoint(aLineA.get(), SketchPlugin_Line::END_ID());
222   GeomPnt2dPtr aStartB = SketcherPrs_Tools::getPoint(aLineB.get(), SketchPlugin_Line::START_ID());
223   GeomPnt2dPtr aEndB = SketcherPrs_Tools::getPoint(aLineB.get(), SketchPlugin_Line::END_ID());
224
225   std::shared_ptr<GeomAPI_Lin2d> aLine1(new GeomAPI_Lin2d(aStartA, aEndA));
226   std::shared_ptr<GeomAPI_Lin2d> aLine2(new GeomAPI_Lin2d(aStartB, aEndB));
227
228   bool isReversed1 = boolean(ANGLE_REVERSED_FIRST_LINE_ID())->value();
229   bool isReversed2 = boolean(ANGLE_REVERSED_SECOND_LINE_ID())->value();
230
231   AttributeDoublePtr anAngleValueAttr = real(ANGLE_VALUE_ID());
232   if (!anAngleValueAttr->isInitialized()) {
233     std::shared_ptr<GeomAPI_Angle2d> anAng(
234         new GeomAPI_Angle2d(aLine1, isReversed1, aLine2, isReversed2));
235     anAngleValueAttr->setValue(getAngleForType(fabs(anAng->angleDegree())));
236   }
237
238   std::shared_ptr<GeomAPI_Angle2d> anAng(new GeomAPI_Angle2d(aLine1, false, aLine2, false));
239   double anAngle = anAng->angleDegree();
240
241   anAngle /= fabs(anAngle);
242   anAngle *= getAngleForType(anAngleValueAttr->value(), isReversed1, isReversed2);
243
244   // update value of the constraint to be passed to the solver
245   real(SketchPlugin_Constraint::VALUE())->setValue(anAngle);
246 }
247
248 void SketchPlugin_ConstraintAngle::calculateAnglePosition()
249 {
250   if (attribute(ANGLE_REVERSED_FIRST_LINE_ID())->isInitialized() &&
251       attribute(ANGLE_REVERSED_SECOND_LINE_ID())->isInitialized())
252     return; // already calculated
253
254   DataPtr aData = data();
255   FeaturePtr aLineA = SketcherPrs_Tools::getFeatureLine(aData, ENTITY_A());
256   FeaturePtr aLineB = SketcherPrs_Tools::getFeatureLine(aData, ENTITY_B());
257
258   GeomPnt2dPtr aStartA = SketcherPrs_Tools::getPoint(aLineA.get(), SketchPlugin_Line::START_ID());
259   GeomPnt2dPtr aEndA = SketcherPrs_Tools::getPoint(aLineA.get(), SketchPlugin_Line::END_ID());
260   GeomPnt2dPtr aStartB = SketcherPrs_Tools::getPoint(aLineB.get(), SketchPlugin_Line::START_ID());
261   GeomPnt2dPtr aEndB = SketcherPrs_Tools::getPoint(aLineB.get(), SketchPlugin_Line::END_ID());
262
263   bool isReversed1 = false;
264   bool isReversed2 = false;
265
266   GeomPnt2dPtr aSelected1 = SketcherPrs_Tools::getPoint(this, SELECTED_FIRST_POINT_ID());
267   GeomPnt2dPtr aSelected2 = SketcherPrs_Tools::getPoint(this, SELECTED_SECOND_POINT_ID());
268   if (aSelected1 && aSelected2) {
269     GeomPnt2dPtr anInterPnt = intersect(aLineA, aLineB);
270     if (!anInterPnt)
271       return;
272     std::shared_ptr<GeomAPI_XY> anInterXY = anInterPnt->xy();
273     isReversed1 = aSelected1->xy()->decreased(anInterXY)->dot(
274                   aEndA->xy()->decreased(aStartA->xy())) < -tolerance;
275     isReversed2 = aSelected2->xy()->decreased(anInterXY)->dot(
276                   aEndB->xy()->decreased(aStartB->xy())) < -tolerance;
277   }
278   else {
279     // no point is selected (document opened or Python script is loaded),
280     // calculate basing on the value
281     std::shared_ptr<GeomAPI_Angle2d> anAng(new GeomAPI_Angle2d(aStartA, aEndA, aStartB, aEndB));
282     isReversed1 = anAng->isReversed(0);
283     isReversed2 = anAng->isReversed(1);
284   }
285
286   // adjust reversed flags according to the angle type
287   AttributeIntegerPtr aTypeAttr = integer(TYPE_ID());
288   if (aTypeAttr && aTypeAttr->isInitialized() &&
289      (SketcherPrs_Tools::AngleType)(aTypeAttr->value()) == SketcherPrs_Tools::ANGLE_COMPLEMENTARY)
290     isReversed1 = !isReversed1;
291
292   boolean(ANGLE_REVERSED_FIRST_LINE_ID())->setValue(isReversed1);
293   boolean(ANGLE_REVERSED_SECOND_LINE_ID())->setValue(isReversed2);
294 }
295
296 // Convert angle value from the DIRECT to any given type.
297 static double angleForType(const double theAngle, const int theType)
298 {
299   double anAngle = theAngle;
300   switch ((SketcherPrs_Tools::AngleType)theType) {
301     case SketcherPrs_Tools::ANGLE_DIRECT:
302       anAngle = theAngle;
303       break;
304     case SketcherPrs_Tools::ANGLE_COMPLEMENTARY:
305       anAngle = 180.0 - theAngle;
306       break;
307     case SketcherPrs_Tools::ANGLE_BACKWARD:
308       anAngle = 360.0 - theAngle;
309       break;
310     default:
311       break;
312   }
313   return anAngle;
314 }
315
316 double SketchPlugin_ConstraintAngle::getAngleForType(double theAngle,
317                                                      bool isReversed1,
318                                                      bool isReversed2)
319 {
320   double anAngle = angleForType(theAngle, integer(TYPE_ID())->value());
321   if (isReversed1 != isReversed2)
322     anAngle = 180.0 - anAngle;
323   return anAngle;
324 }
325
326 #if !HAVE_WORKING_REGEX
327 static bool parseString(const std::wstring& theString, std::wostringstream* theResult)
328 {
329   // skip leading spaces
330   size_t aLength = theString.size();
331   size_t aPos = theString.find_first_not_of(L' ');
332   if (aPos == std::wstring::npos)
333     return false;
334   // first should be a value
335   if (theString[aPos] == L'-' || theString[aPos] == L'+')
336     theResult[1] << theString[aPos++];
337   while (aPos < aLength && theString[aPos] >= L'0' && theString[aPos] <= L'9')
338     theResult[1] << theString[aPos++];
339   if (theString[aPos] != L' ') {
340     if (theString[aPos] != L'.')
341       return false;
342     theResult[1] << theString[aPos++];
343     while (aPos < aLength && theString[aPos] >= L'0' && theString[aPos] <= L'9')
344       theResult[1] << theString[aPos++];
345   }
346
347   // next, find the sign
348   aPos = theString.find_first_not_of(L' ', aPos);
349   if (aPos == std::wstring::npos)
350     return false;
351   if (theString[aPos] == L'-' || theString[aPos] == L'+')
352     theResult[2] << theString[aPos++];
353
354   // a variable should be at the end
355   aPos = theString.find_first_not_of(L' ', aPos);
356   if (aPos == std::wstring::npos)
357     return false;
358   if (theString[aPos] != L'(' || theString.back() != L')')
359     return false;
360   theResult[3] << theString.substr(aPos + 1, aLength - aPos - 2);
361
362   return true;
363 }
364 #endif
365
366 // Convert angle value or a text expression from one angle type to another
367 static void convertAngle(AttributeDoublePtr theAngle,
368                          const int thePrevType, const int theNewType)
369 {
370   if (theAngle->isInitialized()) {
371     if (theAngle->text().empty()) {
372       // calculate value related to the type twice:
373       // the first time - to return to direct angle,
374       // the second time - to apply new type
375       double aValue = angleForType(theAngle->value(), thePrevType);
376       aValue = angleForType(aValue, theNewType);
377       theAngle->setValue(aValue);
378     }
379     else {
380       // process the parametric value
381       std::wstring anAngleText = theAngle->text();
382 #if HAVE_WORKING_REGEX
383       std::wregex anAngleRegex(L"\\s*([-+]?[0-9]*\\.?[0-9]*)\\s*([-+])\\s*\\((.*)\\)$",
384                                std::regex_constants::ECMAScript);
385 #endif
386
387       double anAnglePrefix = 0.0;
388       static const wchar_t aSignPrefix[2] = { L'-', L'+' };
389       int aSignInd = 1;
390
391 #if HAVE_WORKING_REGEX
392       std::wsmatch aResult;
393       if (std::regex_search(anAngleText, aResult, anAngleRegex)) {
394 #else
395       // workaround to support old versions of GCC (less than 4.9)
396       std::wostringstream aResult[4];
397       if (parseString(anAngleText, aResult)) {
398 #endif
399         anAnglePrefix = std::atof(Locale::Convert::toString(aResult[1].str()).c_str());
400         aSignInd = aResult[2].str()[0] == aSignPrefix[0] ? 0 : 1;
401         anAngleText = aResult[3].str();
402       }
403
404       if (thePrevType != SketcherPrs_Tools::ANGLE_DIRECT)
405         aSignInd = 1 - aSignInd;
406       anAnglePrefix = angleForType(anAnglePrefix, thePrevType);
407
408       if (theNewType != SketcherPrs_Tools::ANGLE_DIRECT)
409         aSignInd = 1 - aSignInd;
410       anAnglePrefix = angleForType(anAnglePrefix, theNewType);
411
412       std::wostringstream aText;
413       bool isPrintSign = true;
414       if (fabs(anAnglePrefix) > tolerance)
415         aText << anAnglePrefix;
416       else
417         isPrintSign = aSignInd == 0;
418       if (isPrintSign)
419         aText << L" " << aSignPrefix[aSignInd] << L" (";
420       aText << anAngleText << (isPrintSign ? L")" : L"");
421       theAngle->setText(aText.str());
422     }
423   }
424 }
425
426 void SketchPlugin_ConstraintAngle::updateAngleValue()
427 {
428   AttributeIntegerPtr anAngleType = integer(TYPE_ID());
429   AttributeIntegerPtr aPrevAngleType = integer(PREV_TYPE_ID());
430   convertAngle(real(ANGLE_VALUE_ID()), aPrevAngleType->value(), anAngleType->value());
431   aPrevAngleType->setValue(anAngleType->value());
432 }
433
434 static GeomPnt2dPtr lineBoundary(const FeaturePtr& theLine, const bool theReversed,
435                                  const GeomPnt2dPtr& thePointToAvoid)
436 {
437   GeomPnt2dPtr aPoint = SketcherPrs_Tools::getPoint(theLine.get(),
438       theReversed ? SketchPlugin_Line::START_ID() : SketchPlugin_Line::END_ID());
439   if (aPoint->distance(thePointToAvoid) < tolerance) {
440     // extremity is equal to the intersection point,
441     // thus recalculate it using another boundary point
442     aPoint = SketcherPrs_Tools::getPoint(theLine.get(),
443         theReversed ? SketchPlugin_Line::END_ID() : SketchPlugin_Line::START_ID());
444     aPoint->setX(thePointToAvoid->x() * 2.0 - aPoint->x());
445     aPoint->setY(thePointToAvoid->y() * 2.0 - aPoint->y());
446   }
447   return aPoint;
448 }
449
450 bool SketchPlugin_ConstraintAngle::compute(const std::string& theAttributeId)
451 {
452   if (theAttributeId != SketchPlugin_Constraint::FLYOUT_VALUE_PNT())
453     return false;
454   if (!sketch())
455     return false;
456
457   std::shared_ptr<GeomDataAPI_Point2D> aFlyOutAttr = std::dynamic_pointer_cast<
458                            GeomDataAPI_Point2D>(attribute(theAttributeId));
459
460   DataPtr aData = data();
461   std::shared_ptr<GeomAPI_Ax3> aPlane = SketchPlugin_Sketch::plane(sketch());
462   FeaturePtr aLineA = SketcherPrs_Tools::getFeatureLine(aData, ENTITY_A());
463   FeaturePtr aLineB = SketcherPrs_Tools::getFeatureLine(aData, ENTITY_B());
464
465   if ((aLineA.get() == NULL) || (aLineB.get() == NULL))
466     return false;
467
468   // Intersection of lines
469   std::shared_ptr<GeomAPI_Pnt2d> anInter = intersect(aLineA, aLineB);
470   if (!anInter)
471     return false;
472
473   bool isReversed1 = boolean(ANGLE_REVERSED_FIRST_LINE_ID())->value();
474   bool isReversed2 = boolean(ANGLE_REVERSED_SECOND_LINE_ID())->value();
475
476   int anAngleType = integer(TYPE_ID())->value();
477
478   bool isSupplementary = anAngleType == (int)SketcherPrs_Tools::ANGLE_COMPLEMENTARY;
479
480   // point on lines to compose an angle
481   GeomPnt2dPtr aPointA = lineBoundary(aLineA, isReversed1 ^ isSupplementary, anInter);
482   GeomPnt2dPtr aPointB = lineBoundary(aLineB, isReversed2, anInter);
483
484   myFlyoutUpdate = true;
485   if (aFlyOutAttr->isInitialized()) {
486     std::shared_ptr<GeomAPI_XY> aFlyoutPoint = aFlyOutAttr->pnt()->xy();
487     std::shared_ptr<GeomAPI_XY> anInterXY = anInter->xy();
488     std::shared_ptr<GeomAPI_XY> aDirIF = aFlyoutPoint->decreased(anInterXY);
489     std::shared_ptr<GeomAPI_XY> aDirIA = aPointA->xy()->decreased(anInterXY);
490     std::shared_ptr<GeomAPI_XY> aDirIB = aPointB->xy()->decreased(anInterXY);
491     double aSign = aDirIA->cross(aDirIB);
492     aSign /= fabs(aSign);
493     if (anAngleType == (int)SketcherPrs_Tools::ANGLE_BACKWARD)
494       aSign *= -1.0;
495
496     double cross1 = aSign * aDirIA->cross(aDirIF);
497     if (cross1 < -tolerance)
498       boolean(ANGLE_REVERSED_SECOND_LINE_ID())->setValue(!isReversed2);
499     double cross2 = aSign * aDirIF->cross(aDirIB);
500     if (cross2 < -tolerance)
501       boolean(ANGLE_REVERSED_FIRST_LINE_ID())->setValue(!isReversed1);
502
503     // the direction is reversed only once
504     if ((cross1 + tolerance) * (cross2 + tolerance) < 0.0) {
505       if (anAngleType == (int)SketcherPrs_Tools::ANGLE_BACKWARD) {
506         convertAngle(real(ANGLE_VALUE_ID()), (int)SketcherPrs_Tools::ANGLE_BACKWARD,
507                      (int)SketcherPrs_Tools::ANGLE_DIRECT);
508       }
509       convertAngle(real(ANGLE_VALUE_ID()), (int)SketcherPrs_Tools::ANGLE_DIRECT,
510                    (int)SketcherPrs_Tools::ANGLE_COMPLEMENTARY);
511       if (anAngleType == (int)SketcherPrs_Tools::ANGLE_BACKWARD) {
512         convertAngle(real(ANGLE_VALUE_ID()), (int)SketcherPrs_Tools::ANGLE_DIRECT,
513                      (int)SketcherPrs_Tools::ANGLE_BACKWARD);
514       }
515     }
516
517     calculateAngle();
518   }
519   else {
520     // default position of the presentation
521     double aX = (aPointA->x() + aPointB->x() + anInter->x()) / 3.;
522     double aY = (aPointA->y() + aPointB->y() + anInter->y()) / 3.;
523     aFlyOutAttr->setValue(aX, aY);
524   }
525   myFlyoutUpdate = false;
526
527   return true;
528 }
529
530 void SketchPlugin_ConstraintAngle::updateVersion()
531 {
532   bool aWasBlocked = data()->blockSendAttributeUpdated(true);
533
534   // Calculate angle value by the old algorithm and
535   // update the corresponding attribute to meet the new requirements.
536   FeaturePtr aLineA = SketcherPrs_Tools::getFeatureLine(data(), ENTITY_A());
537   FeaturePtr aLineB = SketcherPrs_Tools::getFeatureLine(data(), ENTITY_B());
538
539   GeomPnt2dPtr aStartA = SketcherPrs_Tools::getPoint(aLineA.get(), SketchPlugin_Line::START_ID());
540   GeomPnt2dPtr aEndA = SketcherPrs_Tools::getPoint(aLineA.get(), SketchPlugin_Line::END_ID());
541   GeomPnt2dPtr aStartB = SketcherPrs_Tools::getPoint(aLineB.get(), SketchPlugin_Line::START_ID());
542   GeomPnt2dPtr aEndB = SketcherPrs_Tools::getPoint(aLineB.get(), SketchPlugin_Line::END_ID());
543
544   std::shared_ptr<GeomAPI_Angle2d> anAng;
545
546   if (boolean(ANGLE_REVERSED_FIRST_LINE_ID())->isInitialized() &&
547       boolean(ANGLE_REVERSED_SECOND_LINE_ID())->isInitialized()) {
548     bool isReversed1 = boolean(ANGLE_REVERSED_FIRST_LINE_ID())->value();
549     bool isReversed2 = boolean(ANGLE_REVERSED_SECOND_LINE_ID())->value();
550
551     std::shared_ptr<GeomAPI_Lin2d> aLine1(new GeomAPI_Lin2d(aStartA, aEndA));
552     std::shared_ptr<GeomAPI_Lin2d> aLine2(new GeomAPI_Lin2d(aStartB, aEndB));
553     anAng.reset(new GeomAPI_Angle2d(aLine1, isReversed1, aLine2, isReversed2));
554   }
555   else {
556     anAng.reset(new GeomAPI_Angle2d(aStartA, aEndA, aStartB, aEndB));
557
558     bool isReversed1 = anAng->isReversed(0);
559     bool isReversed2 = anAng->isReversed(1);
560
561     boolean(ANGLE_REVERSED_FIRST_LINE_ID())->setValue(isReversed1);
562     boolean(ANGLE_REVERSED_SECOND_LINE_ID())->setValue(isReversed2);
563   }
564   double anAngleValue = anAng->angleDegree();
565   double aConstValue = real(ANGLE_VALUE_ID())->value();
566
567   AttributeIntegerPtr aType = integer(TYPE_ID());
568   switch ((SketcherPrs_Tools::AngleType)aType->value()) {
569   case SketcherPrs_Tools::ANGLE_DIRECT:
570     if (anAngleValue < 0.0 && aConstValue > 180.0)
571       convertAngle(real(ANGLE_VALUE_ID()), SketcherPrs_Tools::ANGLE_BACKWARD,
572                                            SketcherPrs_Tools::ANGLE_DIRECT);
573     break;
574   case SketcherPrs_Tools::ANGLE_BACKWARD:
575     if (anAngleValue < 0.0 && aConstValue < 180.0)
576       convertAngle(real(ANGLE_VALUE_ID()), SketcherPrs_Tools::ANGLE_DIRECT,
577                                            SketcherPrs_Tools::ANGLE_BACKWARD);
578     break;
579   default:
580     break;
581   }
582   data()->blockSendAttributeUpdated(aWasBlocked, false);
583   integer(VERSION_ID())->setValue(THE_VERSION_1);
584 }
585
586
587 // ===============   Auxiliary functions   ==================================
588 std::shared_ptr<GeomAPI_Pnt2d> intersect(FeaturePtr theLine1, FeaturePtr theLine2)
589 {
590   // Start and end points of lines
591   const std::string& aLineStartAttr = SketchPlugin_Line::START_ID();
592   const std::string& aLineEndAttr = SketchPlugin_Line::END_ID();
593   GeomPnt2dPtr aStartA = SketcherPrs_Tools::getPoint(theLine1.get(), aLineStartAttr);
594   GeomPnt2dPtr aEndA   = SketcherPrs_Tools::getPoint(theLine1.get(), aLineEndAttr);
595   GeomPnt2dPtr aStartB = SketcherPrs_Tools::getPoint(theLine2.get(), aLineStartAttr);
596   GeomPnt2dPtr aEndB   = SketcherPrs_Tools::getPoint(theLine2.get(), aLineEndAttr);
597   if (aStartA->distance(aEndA) < tolerance || aStartB->distance(aEndB) < tolerance)
598     std::shared_ptr<GeomAPI_Pnt2d>();
599
600   // Lines and their intersection point
601   std::shared_ptr<GeomAPI_Lin2d> aLA(new GeomAPI_Lin2d(aStartA, aEndA));
602   std::shared_ptr<GeomAPI_Lin2d> aLB(new GeomAPI_Lin2d(aStartB, aEndB));
603   return aLA->intersect(aLB);
604 }