]> SALOME platform Git repositories - modules/shaper.git/blob - src/SketchPlugin/SketchPlugin_Fillet.cpp
Salome HOME
Add SketchPlugin document template.
[modules/shaper.git] / src / SketchPlugin / SketchPlugin_Fillet.cpp
1 // Copyright (C) 2014-2017  CEA/DEN, EDF R&D
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
18 // email : webmaster.salome@opencascade.com<mailto:webmaster.salome@opencascade.com>
19 //
20
21 #include "SketchPlugin_Fillet.h"
22
23 #include "SketchPlugin_Arc.h"
24 #include "SketchPlugin_Line.h"
25 #include "SketchPlugin_Point.h"
26 #include "SketchPlugin_Sketch.h"
27 #include "SketchPlugin_ConstraintDistance.h"
28 #include "SketchPlugin_ConstraintEqual.h"
29 #include "SketchPlugin_ConstraintCoincidence.h"
30 #include "SketchPlugin_ConstraintLength.h"
31 #include "SketchPlugin_ConstraintMiddle.h"
32 #include "SketchPlugin_ConstraintTangent.h"
33 #include "SketchPlugin_ConstraintRadius.h"
34 #include "SketchPlugin_Tools.h"
35
36 #include <ModelAPI_AttributeDouble.h>
37 #include <ModelAPI_AttributeInteger.h>
38 #include <ModelAPI_AttributeRefAttr.h>
39 #include <ModelAPI_Data.h>
40 #include <ModelAPI_Events.h>
41 #include <ModelAPI_Session.h>
42 #include <ModelAPI_Tools.h>
43 #include <ModelAPI_Validator.h>
44
45 #include <GeomAlgoAPI_Circ2dBuilder.h>
46 #include <GeomAlgoAPI_EdgeBuilder.h>
47
48 #include <GeomAPI_Circ2d.h>
49 #include <GeomAPI_Dir2d.h>
50 #include <GeomAPI_Lin2d.h>
51 #include <GeomAPI_Pnt2d.h>
52 #include <GeomAPI_XY.h>
53
54 #include <GeomDataAPI_Point2D.h>
55
56 #include <Events_Loop.h>
57
58 #include <math.h>
59
60 const double tolerance = 1.e-7;
61 const double paramTolerance = 1.e-4;
62 const double PI = 3.141592653589793238463;
63
64 /// \brief Attract specified point on theNewArc to the attribute of theFeature
65 static void recalculateAttributes(FeaturePtr theNewArc, const std::string& theNewArcAttribute,
66   FeaturePtr theFeature, const std::string& theFeatureAttribute);
67
68
69 /// \brief Calculate radius of a fillet.
70 ///        It should not be greater than 1/3 of shortest edge length.
71 static double calculateFilletRadius(FeaturePtr theFilletFeatures[2]);
72
73 /// \brief Calculates center of fillet arc and coordinates of tangency points
74 static void calculateFilletCenter(FeaturePtr theFilletFeatures[2],
75                                   double theFilletRadius,
76                                   const std::shared_ptr<GeomAPI_Ax3>& theSketchPlane,
77                                   std::shared_ptr<GeomAPI_XY>& theCenter,
78                                   std::shared_ptr<GeomAPI_XY>& theTangentA,
79                                   std::shared_ptr<GeomAPI_XY>& theTangentB);
80
81 static std::set<FeaturePtr> findFeaturesToRemove(const FeaturePtr theFeature,
82                                                  const AttributePtr theAttribute);
83
84 SketchPlugin_Fillet::SketchPlugin_Fillet()
85 : myFilletCreated(false)
86 {
87 }
88
89 void SketchPlugin_Fillet::initAttributes()
90 {
91   data()->addAttribute(FILLET_POINT_ID(), ModelAPI_AttributeRefAttr::typeId());
92 }
93
94 void SketchPlugin_Fillet::execute()
95 {
96   // Wait all constraints being created, then send update events
97   static Events_ID anUpdateEvent = Events_Loop::eventByName(EVENT_OBJECT_UPDATED);
98   bool isUpdateFlushed = Events_Loop::loop()->isFlushed(anUpdateEvent);
99   if (isUpdateFlushed)
100     Events_Loop::loop()->setFlushed(anUpdateEvent, false);
101
102   // set flag here to avoid building Fillet presentation if "Redisplay" event appears
103   myFilletCreated = true;
104
105   // create feature for fillet arc
106   FeaturePtr aFilletArc = createFilletArc();
107
108   // collect features referred to the edges participating in fillet
109   AttributePoint2DPtr aFilletPoints[2];
110   int aFeatInd[2];
111   int anAttrInd[2];
112   std::set<FeaturePtr> aFeaturesToBeRemoved;
113   for (int i = 0; i < 2; ++i) {
114     bool isFirstIndex = (i == 0);
115     aFeatInd[i] = myIsReversed == isFirstIndex ? 1 : 0;
116     anAttrInd[i] = (myIsReversed == isFirstIndex ? 2 : 0) + (myIsNotInversed[aFeatInd[i]] ? 0 : 1);
117     aFilletPoints[i] = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
118         myBaseFeatures[aFeatInd[i]]->attribute(myFeatAttributes[anAttrInd[i]]));
119     std::set<FeaturePtr> aRemove =
120         findFeaturesToRemove(myBaseFeatures[aFeatInd[i]], aFilletPoints[i]);
121     aFeaturesToBeRemoved.insert(aRemove.begin(), aRemove.end());
122   }
123
124   // keep "distance" constraints and remove all other references
125   removeReferencesButKeepDistances(aFeaturesToBeRemoved, aFilletPoints);
126
127   // Update fillet edges.
128   recalculateAttributes(aFilletArc, SketchPlugin_Arc::START_ID(),
129                         myBaseFeatures[aFeatInd[0]], myFeatAttributes[anAttrInd[0]]);
130   recalculateAttributes(aFilletArc, SketchPlugin_Arc::END_ID(),
131                         myBaseFeatures[aFeatInd[1]], myFeatAttributes[anAttrInd[1]]);
132
133   FeaturePtr aConstraint;
134
135   // Create coincidence features.
136   aConstraint = SketchPlugin_Tools::createConstraintAttrAttr(sketch(),
137                     SketchPlugin_ConstraintCoincidence::ID(),
138                     aFilletArc->attribute(SketchPlugin_Arc::START_ID()),
139                     myBaseFeatures[aFeatInd[0]]->attribute(myFeatAttributes[anAttrInd[0]]));
140   ModelAPI_EventCreator::get()->sendUpdated(aConstraint, anUpdateEvent);
141   aConstraint = SketchPlugin_Tools::createConstraintAttrAttr(sketch(),
142                     SketchPlugin_ConstraintCoincidence::ID(),
143                     aFilletArc->attribute(SketchPlugin_Arc::END_ID()),
144                     myBaseFeatures[aFeatInd[1]]->attribute(myFeatAttributes[anAttrInd[1]]));
145   ModelAPI_EventCreator::get()->sendUpdated(aConstraint, anUpdateEvent);
146
147   // Create tangent features.
148   for (int i = 0; i < 2; i++) {
149     aConstraint = SketchPlugin_Tools::createConstraintObjectObject(sketch(),
150                       SketchPlugin_ConstraintTangent::ID(),
151                       aFilletArc->lastResult(),
152                       myBaseFeatures[i]->lastResult());
153     aConstraint->execute();
154     ModelAPI_EventCreator::get()->sendUpdated(aConstraint, anUpdateEvent);
155   }
156
157   // Send events to update the sub-features by the solver.
158   if (isUpdateFlushed)
159     Events_Loop::loop()->setFlushed(anUpdateEvent, true);
160 }
161
162 AISObjectPtr SketchPlugin_Fillet::getAISObject(AISObjectPtr thePrevious)
163 {
164   if(myFilletCreated) {
165     return AISObjectPtr();
166   }
167
168   SketchPlugin_Sketch* aSketch = sketch();
169   if(!aSketch) {
170     return AISObjectPtr();
171   }
172
173   if (!calculateFilletParameters())
174     return AISObjectPtr();
175
176   // Create arc for presentation.
177   std::shared_ptr<GeomAPI_Pnt> aCenterPnt(aSketch->to3D(myCenterXY->x(), myCenterXY->y()));
178   std::shared_ptr<GeomAPI_Pnt> aTangentPnt1(aSketch->to3D(myTangentXY1->x(),
179                                                           myTangentXY1->y()));
180   std::shared_ptr<GeomAPI_Pnt> aTangentPnt2(aSketch->to3D(myTangentXY2->x(),
181                                                           myTangentXY2->y()));
182   std::shared_ptr<GeomDataAPI_Dir> aNDir = std::dynamic_pointer_cast<GeomDataAPI_Dir>(
183     aSketch->data()->attribute(SketchPlugin_Sketch::NORM_ID()));
184   std::shared_ptr<GeomAPI_Shape> anArcShape =
185       GeomAlgoAPI_EdgeBuilder::lineCircleArc(aCenterPnt, aTangentPnt1, aTangentPnt2, aNDir->dir());
186
187   AISObjectPtr anAISObject = thePrevious;
188   if(!anAISObject.get()) {
189     anAISObject = AISObjectPtr(new GeomAPI_AISObject);
190   }
191   anAISObject->createShape(anArcShape);
192   return anAISObject;
193 }
194
195 bool SketchPlugin_Fillet::calculateFilletParameters()
196 {
197   // Get fillet point.
198   AttributeRefAttrPtr aPointRefAttr = refattr(FILLET_POINT_ID());
199   if (!aPointRefAttr->isInitialized() || aPointRefAttr->isObject())
200     return false;
201   std::shared_ptr<GeomDataAPI_Point2D> aFilletPoint2D =
202     std::dynamic_pointer_cast<GeomDataAPI_Point2D>(aPointRefAttr->attr());
203   if (!aFilletPoint2D.get())
204     return false;
205
206   std::set<AttributePoint2DPtr> aCoincidentPoints =
207       SketchPlugin_Tools::findPointsCoincidentToPoint(aFilletPoint2D);
208   std::set<FeaturePtr> aFilletFeatures;
209   for (std::set<AttributePoint2DPtr>::iterator aCPIt = aCoincidentPoints.begin();
210        aCPIt != aCoincidentPoints.end(); ++aCPIt) {
211     std::shared_ptr<SketchPlugin_Feature> anOwner =
212         std::dynamic_pointer_cast<SketchPlugin_Feature>(
213         ModelAPI_Feature::feature((*aCPIt)->owner()));
214     if (anOwner && !anOwner->isExternal())
215       aFilletFeatures.insert(anOwner);
216   }
217   if (aFilletFeatures.size() != 2) {
218     setError("Error: Selected point does not have two suitable edges for fillet.");
219     return false;
220   }
221
222   std::set<FeaturePtr>::iterator aFIt = aFilletFeatures.begin();
223   myBaseFeatures[0] = *aFIt;
224   myBaseFeatures[1] = *(++aFIt);
225
226   std::shared_ptr<GeomAPI_Pnt2d> aFilletPnt2d = aFilletPoint2D->pnt();
227   double aRadius = calculateFilletRadius(myBaseFeatures);
228
229   // Calculate arc attributes.
230   static const int aNbFeatures = 2;
231   // First pair of points relate to first feature, second pair -  to second.
232   std::shared_ptr<GeomAPI_Pnt2d> aStartEndPnt[aNbFeatures * 2];
233   for (int i = 0; i < aNbFeatures; i++) {
234     std::string aStartAttr, aEndAttr;
235     if (myBaseFeatures[i]->getKind() == SketchPlugin_Line::ID()) {
236       aStartAttr = SketchPlugin_Line::START_ID();
237       aEndAttr = SketchPlugin_Line::END_ID();
238     } else if (myBaseFeatures[i]->getKind() == SketchPlugin_Arc::ID()) {
239       aStartAttr = SketchPlugin_Arc::START_ID();
240       aEndAttr = SketchPlugin_Arc::END_ID();
241     } else { // Wrong argument.
242       setError("Error: One of the points has wrong coincide feature");
243       return false;
244     }
245     myFeatAttributes[2*i] = aStartAttr;
246     aStartEndPnt[2*i] = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
247       myBaseFeatures[i]->attribute(aStartAttr))->pnt();
248     myFeatAttributes[2*i+1] = aEndAttr;
249     aStartEndPnt[2*i+1] = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
250       myBaseFeatures[i]->attribute(aEndAttr))->pnt();
251   }
252   for (int aFeatInd = 0; aFeatInd < aNbFeatures; aFeatInd++) {
253     for (int j = 0; j < 2; j++) // loop on start-end of each feature
254       if (aStartEndPnt[aFeatInd * aNbFeatures + j]->distance(aFilletPnt2d) < 1.e-10) {
255         myIsNotInversed[aFeatInd] = (j==0);
256         break;
257       }
258   }
259
260   std::shared_ptr<GeomAPI_Ax3> aSketchPlane = SketchPlugin_Sketch::plane(sketch());
261   calculateFilletCenter(myBaseFeatures, aRadius, aSketchPlane,
262                         myCenterXY, myTangentXY1, myTangentXY2);
263
264   // Tangent directions of the features in coincident point.
265   std::shared_ptr<GeomAPI_Dir2d> aTangentDir[aNbFeatures];
266   for (int i = 0; i < aNbFeatures; i++) {
267     std::shared_ptr<GeomAPI_XY> aDir;
268     if (myBaseFeatures[i]->getKind() == SketchPlugin_Line::ID()) {
269       aDir = aStartEndPnt[2*i+1]->xy()->decreased(aStartEndPnt[2*i]->xy());
270       if (!myIsNotInversed[i])
271         aDir = aDir->multiplied(-1.0);
272     } else if (myBaseFeatures[i]->getKind() == SketchPlugin_Arc::ID()) {
273       std::shared_ptr<GeomAPI_Pnt2d> aCenterPoint =
274         std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
275         myBaseFeatures[i]->attribute(SketchPlugin_Arc::CENTER_ID()))->pnt();
276       aDir = myIsNotInversed[i] ? aStartEndPnt[2*i]->xy() : aStartEndPnt[2*i+1]->xy();
277       aDir = aDir->decreased(aCenterPoint->xy());
278
279       double x = aDir->x();
280       double y = aDir->y();
281       aDir->setX(-y);
282       aDir->setY(x);
283       if (myIsNotInversed[i] ==
284           std::dynamic_pointer_cast<SketchPlugin_Arc>(myBaseFeatures[i])->isReversed())
285         aDir = aDir->multiplied(-1.0);
286     }
287     aTangentDir[i] = std::shared_ptr<GeomAPI_Dir2d>(new GeomAPI_Dir2d(aDir));
288   }
289
290   // By default, the start point of fillet arc is connected to FeatureA,
291   // and the end point - to FeatureB. But when the angle between TangentDirA and
292   // TangentDirB greater 180 degree, the sequaence of features need to be reversed.
293   double cosBA = aTangentDir[0]->cross(aTangentDir[1]); // cos(B-A),
294   // where A and B - angles between corresponding tanget direction and the X axis
295   myIsReversed = cosBA > 0.0;
296
297   if(myIsReversed) {
298     std::shared_ptr<GeomAPI_XY> aTmp = myTangentXY1;
299     myTangentXY1 = myTangentXY2;
300     myTangentXY2 = aTmp;
301   }
302   return true;
303 }
304
305 FeaturePtr SketchPlugin_Fillet::createFilletArc()
306 {
307   // Calculate Fillet parameters if does not yet
308   if (!myBaseFeatures[0] || !myBaseFeatures[1])
309     calculateFilletParameters();
310
311   // Create arc feature.
312   FeaturePtr aFilletArc = sketch()->addFeature(SketchPlugin_Arc::ID());
313
314   // Set arc attributes.
315   bool aWasBlocked = aFilletArc->data()->blockSendAttributeUpdated(true);
316   std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
317       aFilletArc->attribute(SketchPlugin_Arc::CENTER_ID()))->setValue(myCenterXY->x(),
318                                                                       myCenterXY->y());
319   std::shared_ptr<GeomDataAPI_Point2D> aStartPoint =
320       std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
321           aFilletArc->attribute(SketchPlugin_Arc::START_ID()));
322   std::shared_ptr<GeomDataAPI_Point2D> aEndPoint =
323       std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
324           aFilletArc->attribute(SketchPlugin_Arc::END_ID()));
325   if(aStartPoint->isInitialized() && aEndPoint->isInitialized()
326       && (aStartPoint->pnt()->xy()->distance(myTangentXY1) > tolerance
327       || aEndPoint->pnt()->xy()->distance(myTangentXY2) > tolerance)) {
328     std::dynamic_pointer_cast<SketchPlugin_Arc>(aFilletArc)->setReversed(false);
329   }
330   aStartPoint->setValue(myTangentXY1->x(), myTangentXY1->y());
331   aEndPoint->setValue(myTangentXY2->x(), myTangentXY2->y());
332   aFilletArc->data()->blockSendAttributeUpdated(aWasBlocked);
333   aFilletArc->execute();
334
335   return aFilletArc;
336 }
337
338 FeaturePtr SketchPlugin_Fillet::createFilletApex(const GeomPnt2dPtr& theCoordinates)
339 {
340   FeaturePtr anApex = sketch()->addFeature(SketchPlugin_Point::ID());
341   AttributePoint2DPtr aCoord = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
342       anApex->attribute(SketchPlugin_Point::COORD_ID()));
343   aCoord->setValue(theCoordinates);
344   anApex->boolean(SketchPlugin_Point::AUXILIARY_ID())->setValue(true);
345
346   // additional coincidence constraints
347   static Events_ID anUpdateEvent = Events_Loop::eventByName(EVENT_OBJECT_UPDATED);
348   FeaturePtr aConstraint;
349   for (int i = 0; i < 2; i++) {
350     aConstraint = SketchPlugin_Tools::createConstraintAttrObject(sketch(),
351                       SketchPlugin_ConstraintCoincidence::ID(),
352                       aCoord,
353                       myBaseFeatures[i]->lastResult());
354     aConstraint->execute();
355     ModelAPI_EventCreator::get()->sendUpdated(aConstraint, anUpdateEvent);
356   }
357
358   return anApex;
359 }
360
361 struct Length {
362   AttributePtr myPoints[2];
363   std::string myValueText;
364   double myValueDouble;
365   GeomPnt2dPtr myFlyoutPoint;
366   int myLocationType;
367 };
368
369 void SketchPlugin_Fillet::removeReferencesButKeepDistances(
370     std::set<FeaturePtr>& theFeaturesToRemove,
371     const AttributePoint2DPtr theFilletPoints[2])
372 {
373   FeaturePtr aFilletApex;
374   std::list<Length> aLengthToDistance;
375
376   std::set<FeaturePtr>::iterator aFeat = theFeaturesToRemove.begin();
377   while (aFeat != theFeaturesToRemove.end()) {
378     std::shared_ptr<SketchPlugin_ConstraintDistance> aDistance =
379         std::dynamic_pointer_cast<SketchPlugin_ConstraintDistance>(*aFeat);
380     if (aDistance) {
381       if (!aFilletApex)
382         aFilletApex = createFilletApex(theFilletPoints[0]->pnt());
383       // update attributes of distance constraints
384       bool isUpdated = false;
385       for (int attrInd = 0; attrInd < CONSTRAINT_ATTR_SIZE && !isUpdated; ++attrInd) {
386         AttributeRefAttrPtr aRefAttr =
387             aDistance->refattr(SketchPlugin_Constraint::ATTRIBUTE(attrInd));
388         if (aRefAttr && !aRefAttr->isObject() &&
389            (aRefAttr->attr() == theFilletPoints[0] || aRefAttr->attr() == theFilletPoints[1])) {
390           aRefAttr->setAttr(aFilletApex->attribute(SketchPlugin_Point::COORD_ID()));
391           isUpdated = true;
392         }
393       }
394       // avoid distance from removing if it is updated
395       std::set<FeaturePtr>::iterator aKeepIt = aFeat++;
396       if (isUpdated)
397         theFeaturesToRemove.erase(aKeepIt);
398
399     } else {
400       std::shared_ptr<SketchPlugin_ConstraintLength> aLength =
401           std::dynamic_pointer_cast<SketchPlugin_ConstraintLength>(*aFeat);
402       if (aLength) {
403         if (!aFilletApex)
404           aFilletApex = createFilletApex(theFilletPoints[0]->pnt());
405         // remove Length, but create new distance constraint
406         AttributeRefAttrPtr aRefAttr =
407           aLength->refattr(SketchPlugin_Constraint::ENTITY_A());
408         FeaturePtr aLine = ModelAPI_Feature::feature(aRefAttr->object());
409         if (aLine) {
410           aLengthToDistance.push_back(Length());
411           Length& aNewLength = aLengthToDistance.back();
412           // main attrbutes
413           for (int i = 0; i < 2; ++i) {
414             AttributePtr anAttr = aLine->attribute(
415                 i == 0 ? SketchPlugin_Line::START_ID() : SketchPlugin_Line::END_ID());
416             if (anAttr == theFilletPoints[0] || anAttr == theFilletPoints[1])
417               aNewLength.myPoints[i] = aFilletApex->attribute(SketchPlugin_Point::COORD_ID());
418             else
419               aNewLength.myPoints[i] = anAttr;
420           }
421           // value
422           AttributeDoublePtr aValue = aLength->real(SketchPlugin_Constraint::VALUE());
423           aNewLength.myValueDouble = aValue->value();
424           aNewLength.myValueText = aValue->text();
425           // auxiliary attributes
426           AttributePoint2DPtr aFlyoutAttr = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
427               aLength->attribute(SketchPlugin_ConstraintLength::FLYOUT_VALUE_PNT()));
428           if (aFlyoutAttr && aFlyoutAttr->isInitialized())
429             aNewLength.myFlyoutPoint = SketchPlugin_Tools::flyoutPointCoordinates(aLength);
430           AttributeIntegerPtr aLocationAttr =
431               aLength->integer(SketchPlugin_ConstraintLength::LOCATION_TYPE_ID());
432           if (aLocationAttr && aLocationAttr->isInitialized())
433             aNewLength.myLocationType = aLocationAttr->value();
434           else
435             aNewLength.myLocationType = -1;
436         }
437       }
438
439       ++aFeat;
440     }
441   }
442
443   // remove references
444   ModelAPI_Tools::removeFeaturesAndReferences(theFeaturesToRemove);
445   Events_Loop::loop()->flush(Events_Loop::eventByName(EVENT_OBJECT_DELETED));
446
447   // restore Length constraints as point-point distances
448   FeaturePtr aConstraint;
449   std::list<Length>::iterator anIt = aLengthToDistance.begin();
450   for (; anIt != aLengthToDistance.end(); ++anIt) {
451     aConstraint = SketchPlugin_Tools::createConstraintAttrAttr(sketch(),
452         SketchPlugin_ConstraintDistance::ID(), anIt->myPoints[0], anIt->myPoints[1]);
453     // set value
454     AttributeDoublePtr aValue = aConstraint->real(SketchPlugin_Constraint::VALUE());
455     if (anIt->myValueText.empty())
456       aValue->setValue(anIt->myValueDouble);
457     else
458       aValue->setText(anIt->myValueText);
459     // set flyout point if exists
460     if (anIt->myFlyoutPoint) {
461       AttributePoint2DPtr aFlyoutAttr = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
462           aConstraint->attribute(SketchPlugin_ConstraintDistance::FLYOUT_VALUE_PNT()));
463       aFlyoutAttr->setValue(anIt->myFlyoutPoint);
464     }
465     // set location type if initialized
466     if (anIt->myLocationType >= 0) {
467       AttributeIntegerPtr aLocationType =
468           aConstraint->integer(SketchPlugin_ConstraintDistance::LOCATION_TYPE_ID());
469       aLocationType->setValue(anIt->myLocationType);
470     }
471     aConstraint->execute();
472     ModelAPI_EventCreator::get()->sendUpdated(aConstraint,
473         Events_Loop::eventByName(EVENT_OBJECT_UPDATED));
474   }
475 }
476
477 // =========   Auxiliary functions   =================
478 void recalculateAttributes(FeaturePtr theNewArc,  const std::string& theNewArcAttribute,
479                            FeaturePtr theFeature, const std::string& theFeatureAttribute)
480 {
481   std::shared_ptr<GeomAPI_Pnt2d> anArcPoint = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
482       theNewArc->attribute(theNewArcAttribute))->pnt();
483   std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
484       theFeature->attribute(theFeatureAttribute))->setValue(anArcPoint->x(), anArcPoint->y());
485 }
486
487 static std::shared_ptr<GeomAPI_Pnt2d> toPoint(const AttributePtr& theAttribute)
488 {
489   std::shared_ptr<GeomAPI_Pnt2d> aPoint;
490   AttributePoint2DPtr aPointAttr = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(theAttribute);
491   if (aPointAttr)
492     aPoint = aPointAttr->pnt();
493   return aPoint;
494 }
495
496 static std::shared_ptr<GeomAPI_Lin2d> toLine(const FeaturePtr& theFeature)
497 {
498   std::shared_ptr<GeomAPI_Lin2d> aLine;
499   if (theFeature->getKind() == SketchPlugin_Line::ID()) {
500     std::shared_ptr<GeomAPI_Pnt2d> aStart =
501         toPoint( theFeature->attribute(SketchPlugin_Line::START_ID()) );
502     std::shared_ptr<GeomAPI_Pnt2d> aEnd =
503         toPoint( theFeature->attribute(SketchPlugin_Line::END_ID()) );
504     aLine = std::shared_ptr<GeomAPI_Lin2d>(new GeomAPI_Lin2d(aStart, aEnd));
505   }
506   return aLine;
507 }
508
509 static std::shared_ptr<GeomAPI_Circ2d> toCircle(const FeaturePtr& theFeature)
510 {
511   std::shared_ptr<GeomAPI_Circ2d> aCircle;
512   if (theFeature->getKind() == SketchPlugin_Arc::ID()) {
513     std::shared_ptr<GeomAPI_Pnt2d> aCenter =
514         toPoint( theFeature->attribute(SketchPlugin_Arc::CENTER_ID()) );
515     std::shared_ptr<GeomAPI_Pnt2d> aStart =
516         toPoint( theFeature->attribute(SketchPlugin_Arc::START_ID()) );
517     aCircle = std::shared_ptr<GeomAPI_Circ2d>(new GeomAPI_Circ2d(aCenter, aStart));
518   }
519   return aCircle;
520 }
521
522
523 void calculateFilletCenter(FeaturePtr theFilletFeatures[2],
524                            double theFilletRadius,
525                            const std::shared_ptr<GeomAPI_Ax3>& theSketchPlane,
526                            std::shared_ptr<GeomAPI_XY>& theCenter,
527                            std::shared_ptr<GeomAPI_XY>& theTangentA,
528                            std::shared_ptr<GeomAPI_XY>& theTangentB)
529 {
530   GeomShapePtr aShapeA = theFilletFeatures[0]->lastResult()->shape();
531   GeomShapePtr aShapeB = theFilletFeatures[1]->lastResult()->shape();
532
533   GeomAlgoAPI_Circ2dBuilder aCircBuilder(theSketchPlane);
534   aCircBuilder.addTangentCurve(aShapeA);
535   aCircBuilder.addTangentCurve(aShapeB);
536   aCircBuilder.setRadius(theFilletRadius);
537
538   std::shared_ptr<GeomAPI_Circ2d> aFilletCircle = aCircBuilder.circle();
539   if (!aFilletCircle)
540     return;
541
542   theCenter = aFilletCircle->center()->xy();
543   // tangent points
544   std::shared_ptr<GeomAPI_Pnt2d> aTgPoints[2];
545   for (int i = 0; i < 2; ++i) {
546     std::shared_ptr<GeomAPI_Circ2d> aCircle = toCircle(theFilletFeatures[i]);
547     if (aCircle)
548       aTgPoints[i] = aCircle->project(aFilletCircle->center());
549     else {
550       std::shared_ptr<GeomAPI_Lin2d> aLine = toLine(theFilletFeatures[i]);
551       if (aLine)
552         aTgPoints[i] = aLine->project(aFilletCircle->center());
553     }
554   }
555   theTangentA = aTgPoints[0]->xy();
556   theTangentB = aTgPoints[1]->xy();
557 }
558
559 double calculateFilletRadius(FeaturePtr theFilletFeatures[2])
560 {
561   double aLengths[2] = { 0, 0 };
562   for (int i = 0; i < 2; ++i) {
563     GeomShapePtr aShape = theFilletFeatures[i]->lastResult()->shape();
564     std::shared_ptr<GeomAPI_Edge> anEdge = std::dynamic_pointer_cast<GeomAPI_Edge>(aShape);
565     if (anEdge)
566       aLengths[i] = anEdge->length();
567   }
568   return (aLengths[0] < aLengths[1] ? aLengths[0] : aLengths[1]) / 6.0;
569 }
570
571 std::set<FeaturePtr> findFeaturesToRemove(const FeaturePtr theFeature,
572                                           const AttributePtr theAttribute) {
573   std::set<FeaturePtr> aFeaturesToBeRemoved;
574   std::set<AttributePtr> aRefs = theFeature->data()->refsToMe();
575   std::list<ResultPtr> aResults = theFeature->results();
576   for(std::list<ResultPtr>::const_iterator aResultsIt = aResults.cbegin();
577       aResultsIt != aResults.cend();
578       ++aResultsIt) {
579     ResultPtr aResult = *aResultsIt;
580     std::set<AttributePtr> aResultRefs = aResult->data()->refsToMe();
581     aRefs.insert(aResultRefs.begin(), aResultRefs.end());
582   }
583   for(std::set<AttributePtr>::const_iterator anIt = aRefs.cbegin();
584     anIt != aRefs.cend();
585     ++anIt) {
586     std::shared_ptr<ModelAPI_Attribute> anAttr = (*anIt);
587     FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(anAttr->owner());
588     if(aFeature->getKind() == SketchPlugin_Fillet::ID()) {
589       continue;
590     }
591     if(aFeature->getKind() == SketchPlugin_ConstraintLength::ID()
592         || aFeature->getKind() == SketchPlugin_ConstraintEqual::ID()
593         || aFeature->getKind() == SketchPlugin_ConstraintMiddle::ID()) {
594       aFeaturesToBeRemoved.insert(aFeature);
595     } else {
596       std::list<AttributePtr> anAttrs =
597           aFeature->data()->attributes(ModelAPI_AttributeRefAttr::typeId());
598       for(std::list<AttributePtr>::const_iterator aRefAttrsIt = anAttrs.cbegin();
599           aRefAttrsIt != anAttrs.cend();
600           ++aRefAttrsIt) {
601         AttributeRefAttrPtr anAttrRefAttr =
602           std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(*aRefAttrsIt);
603         if(anAttrRefAttr.get() && anAttrRefAttr->attr() == theAttribute) {
604           aFeaturesToBeRemoved.insert(aFeature);
605         }
606       }
607     }
608   }
609   return aFeaturesToBeRemoved;
610 }