1 // Copyright (C) 2014-20xx CEA/DEN, EDF R&D -->
3 // File: SketchPlugin_Fillet.cpp
4 // Created: 19 Mar 2015
5 // Author: Artem ZHIDKOV
7 #include "SketchPlugin_Fillet.h"
9 #include "SketchPlugin_Arc.h"
10 #include "SketchPlugin_Line.h"
11 #include "SketchPlugin_Point.h"
12 #include "SketchPlugin_Sketch.h"
13 #include "SketchPlugin_ConstraintEqual.h"
14 #include "SketchPlugin_ConstraintCoincidence.h"
15 #include "SketchPlugin_ConstraintLength.h"
16 #include "SketchPlugin_ConstraintTangent.h"
17 #include "SketchPlugin_ConstraintRadius.h"
18 #include "SketchPlugin_Tools.h"
20 #include <ModelAPI_AttributeRefAttr.h>
21 #include <ModelAPI_Data.h>
22 #include <ModelAPI_Events.h>
23 #include <ModelAPI_Session.h>
24 #include <ModelAPI_Tools.h>
25 #include <ModelAPI_Validator.h>
27 #include <GeomAlgoAPI_Circ2dBuilder.h>
28 #include <GeomAlgoAPI_EdgeBuilder.h>
30 #include <GeomAPI_Circ2d.h>
31 #include <GeomAPI_Dir2d.h>
32 #include <GeomAPI_Lin2d.h>
33 #include <GeomAPI_Pnt2d.h>
34 #include <GeomAPI_XY.h>
36 #include <GeomDataAPI_Point2D.h>
38 #include <Events_Loop.h>
42 const double tolerance = 1.e-7;
43 const double paramTolerance = 1.e-4;
44 const double PI = 3.141592653589793238463;
46 /// \brief Attract specified point on theNewArc to the attribute of theFeature
47 static void recalculateAttributes(FeaturePtr theNewArc, const std::string& theNewArcAttribute,
48 FeaturePtr theFeature, const std::string& theFeatureAttribute);
51 /// \brief Calculate radius of a fillet.
52 /// It should not be greater than 1/3 of shortest edge length.
53 static double calculateFilletRadius(FeaturePtr theFilletFeatures[2]);
55 /// \brief Calculates center of fillet arc and coordinates of tangency points
56 static void calculateFilletCenter(FeaturePtr theFilletFeatures[2],
57 double theFilletRadius,
58 const std::shared_ptr<GeomAPI_Ax3>& theSketchPlane,
59 std::shared_ptr<GeomAPI_XY>& theCenter,
60 std::shared_ptr<GeomAPI_XY>& theTangentA,
61 std::shared_ptr<GeomAPI_XY>& theTangentB);
63 /// Get coincide edges for fillet
64 static std::set<FeaturePtr> getCoincides(const FeaturePtr& theConstraintCoincidence);
66 static std::set<FeaturePtr> findFeaturesToRemove(const FeaturePtr theFeature,
67 const AttributePtr theAttribute);
69 SketchPlugin_Fillet::SketchPlugin_Fillet()
70 : myFilletCreated(false)
74 void SketchPlugin_Fillet::initAttributes()
76 data()->addAttribute(FILLET_POINT_ID(), ModelAPI_AttributeRefAttr::typeId());
79 void SketchPlugin_Fillet::execute()
81 // Wait all constraints being created, then send update events
82 static Events_ID anUpdateEvent = Events_Loop::eventByName(EVENT_OBJECT_UPDATED);
83 bool isUpdateFlushed = Events_Loop::loop()->isFlushed(anUpdateEvent);
85 Events_Loop::loop()->setFlushed(anUpdateEvent, false);
87 // Calculate Fillet parameters if does not yet
88 if (!myBaseFeatures[0] || !myBaseFeatures[1])
89 calculateFilletParameters();
91 // Create arc feature.
92 FeaturePtr aFilletArc = sketch()->addFeature(SketchPlugin_Arc::ID());
94 // Set arc attributes.
95 bool aWasBlocked = aFilletArc->data()->blockSendAttributeUpdated(true);
96 std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
97 aFilletArc->attribute(SketchPlugin_Arc::CENTER_ID()))->setValue(myCenterXY->x(),
99 std::shared_ptr<GeomDataAPI_Point2D> aStartPoint =
100 std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
101 aFilletArc->attribute(SketchPlugin_Arc::START_ID()));
102 std::shared_ptr<GeomDataAPI_Point2D> aEndPoint =
103 std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
104 aFilletArc->attribute(SketchPlugin_Arc::END_ID()));
105 if(aStartPoint->isInitialized() && aEndPoint->isInitialized()
106 && (aStartPoint->pnt()->xy()->distance(myTangentXY1) > tolerance
107 || aEndPoint->pnt()->xy()->distance(myTangentXY2) > tolerance)) {
108 std::dynamic_pointer_cast<SketchPlugin_Arc>(aFilletArc)->setReversed(false);
110 aStartPoint->setValue(myTangentXY1->x(), myTangentXY1->y());
111 aEndPoint->setValue(myTangentXY2->x(), myTangentXY2->y());
112 aFilletArc->data()->blockSendAttributeUpdated(aWasBlocked);
113 aFilletArc->execute();
115 // Delete features with refs to points of edges.
116 std::shared_ptr<GeomDataAPI_Point2D> aStartPoint1;
117 int aFeatInd1 = myIsReversed ? 1 : 0;
118 int anAttrInd1 = (myIsReversed ? 2 : 0) + (myIsNotInversed[aFeatInd1] ? 0 : 1);
119 aStartPoint1 = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
120 myBaseFeatures[aFeatInd1]->attribute(myFeatAttributes[anAttrInd1]));
121 std::set<FeaturePtr> aFeaturesToBeRemoved1 =
122 findFeaturesToRemove(myBaseFeatures[aFeatInd1], aStartPoint1);
124 std::shared_ptr<GeomDataAPI_Point2D> aStartPoint2;
125 int aFeatInd2 = myIsReversed ? 0 : 1;
126 int anAttrInd2 = (myIsReversed ? 0 : 2) + (myIsNotInversed[aFeatInd2] ? 0 : 1);
127 aStartPoint2 = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
128 myBaseFeatures[aFeatInd2]->attribute(myFeatAttributes[anAttrInd2]));
129 std::set<FeaturePtr> aFeaturesToBeRemoved2 =
130 findFeaturesToRemove(myBaseFeatures[aFeatInd2], aStartPoint2);
132 aFeaturesToBeRemoved1.insert(aFeaturesToBeRemoved2.begin(), aFeaturesToBeRemoved2.end());
133 ModelAPI_Tools::removeFeaturesAndReferences(aFeaturesToBeRemoved1);
134 Events_Loop::loop()->flush(Events_Loop::eventByName(EVENT_OBJECT_DELETED));
136 // Update fillet edges.
137 recalculateAttributes(aFilletArc, SketchPlugin_Arc::START_ID(),
138 myBaseFeatures[aFeatInd1], myFeatAttributes[anAttrInd1]);
139 recalculateAttributes(aFilletArc, SketchPlugin_Arc::END_ID(),
140 myBaseFeatures[aFeatInd2], myFeatAttributes[anAttrInd2]);
142 // Create coincidence features.
143 FeaturePtr aConstraint = sketch()->addFeature(SketchPlugin_ConstraintCoincidence::ID());
144 AttributeRefAttrPtr aRefAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(
145 aConstraint->attribute(SketchPlugin_Constraint::ENTITY_A()));
146 aRefAttr->setAttr(aFilletArc->attribute(SketchPlugin_Arc::START_ID()));
147 aRefAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(
148 aConstraint->attribute(SketchPlugin_Constraint::ENTITY_B()));
149 aRefAttr->setAttr(myBaseFeatures[aFeatInd1]->attribute(myFeatAttributes[anAttrInd1]));
150 aConstraint->execute();
151 ModelAPI_EventCreator::get()->sendUpdated(aConstraint, anUpdateEvent);
152 aConstraint = sketch()->addFeature(SketchPlugin_ConstraintCoincidence::ID());
153 aRefAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(
154 aConstraint->attribute(SketchPlugin_Constraint::ENTITY_A()));
155 aRefAttr->setAttr(aFilletArc->attribute(SketchPlugin_Arc::END_ID()));
156 aRefAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(
157 aConstraint->attribute(SketchPlugin_Constraint::ENTITY_B()));
158 aRefAttr->setAttr(myBaseFeatures[aFeatInd2]->attribute(myFeatAttributes[anAttrInd2]));
159 aConstraint->execute();
160 ModelAPI_EventCreator::get()->sendUpdated(aConstraint, anUpdateEvent);
162 // Create tangent features.
163 for (int i = 0; i < 2; i++) {
164 aConstraint = sketch()->addFeature(SketchPlugin_ConstraintTangent::ID());
165 aRefAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(
166 aConstraint->attribute(SketchPlugin_Constraint::ENTITY_A()));
167 aRefAttr->setObject(aFilletArc->lastResult());
168 aRefAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(
169 aConstraint->attribute(SketchPlugin_Constraint::ENTITY_B()));
170 bool isArc = myBaseFeatures[i]->getKind() == SketchPlugin_Arc::ID();
171 aRefAttr->setObject(isArc ? myBaseFeatures[i]->lastResult() :
172 myBaseFeatures[i]->firstResult());
173 aConstraint->execute();
174 ModelAPI_EventCreator::get()->sendUpdated(aConstraint, anUpdateEvent);
177 // Send events to update the sub-features by the solver.
178 if(isUpdateFlushed) {
179 Events_Loop::loop()->setFlushed(anUpdateEvent, true);
182 myFilletCreated = true;
185 AISObjectPtr SketchPlugin_Fillet::getAISObject(AISObjectPtr thePrevious)
187 if(myFilletCreated) {
188 return AISObjectPtr();
191 SketchPlugin_Sketch* aSketch = sketch();
193 return AISObjectPtr();
196 if (!calculateFilletParameters())
197 return AISObjectPtr();
199 // Create arc for presentation.
200 std::shared_ptr<GeomAPI_Pnt> aCenterPnt(aSketch->to3D(myCenterXY->x(), myCenterXY->y()));
201 std::shared_ptr<GeomAPI_Pnt> aTangentPnt1(aSketch->to3D(myTangentXY1->x(),
203 std::shared_ptr<GeomAPI_Pnt> aTangentPnt2(aSketch->to3D(myTangentXY2->x(),
205 std::shared_ptr<GeomDataAPI_Dir> aNDir = std::dynamic_pointer_cast<GeomDataAPI_Dir>(
206 aSketch->data()->attribute(SketchPlugin_Sketch::NORM_ID()));
207 std::shared_ptr<GeomAPI_Shape> anArcShape =
208 GeomAlgoAPI_EdgeBuilder::lineCircleArc(aCenterPnt, aTangentPnt1, aTangentPnt2, aNDir->dir());
210 AISObjectPtr anAISObject = thePrevious;
211 if(!anAISObject.get()) {
212 anAISObject = AISObjectPtr(new GeomAPI_AISObject);
214 anAISObject->createShape(anArcShape);
218 bool SketchPlugin_Fillet::calculateFilletParameters()
221 AttributeRefAttrPtr aPointRefAttr = refattr(FILLET_POINT_ID());
222 if (!aPointRefAttr->isInitialized() || aPointRefAttr->isObject())
224 std::shared_ptr<GeomDataAPI_Point2D> aFilletPoint2D =
225 std::dynamic_pointer_cast<GeomDataAPI_Point2D>(aPointRefAttr->attr());
226 if (!aFilletPoint2D.get())
229 if (!findFeaturesContainingFilletPoint(aFilletPoint2D)) {
230 setError("Error: Selected point does not have two suitable edges for fillet.");
234 std::shared_ptr<GeomAPI_Pnt2d> aFilletPnt2d = aFilletPoint2D->pnt();
235 double aRadius = calculateFilletRadius(myBaseFeatures);
237 // Calculate arc attributes.
238 static const int aNbFeatures = 2;
239 // First pair of points relate to first feature, second pair - to second.
240 std::shared_ptr<GeomAPI_Pnt2d> aStartEndPnt[aNbFeatures * 2];
241 for (int i = 0; i < aNbFeatures; i++) {
242 std::string aStartAttr, aEndAttr;
243 if (myBaseFeatures[i]->getKind() == SketchPlugin_Line::ID()) {
244 aStartAttr = SketchPlugin_Line::START_ID();
245 aEndAttr = SketchPlugin_Line::END_ID();
246 } else if (myBaseFeatures[i]->getKind() == SketchPlugin_Arc::ID()) {
247 aStartAttr = SketchPlugin_Arc::START_ID();
248 aEndAttr = SketchPlugin_Arc::END_ID();
249 } else { // Wrong argument.
250 setError("Error: One of the points has wrong coincide feature");
253 myFeatAttributes[2*i] = aStartAttr;
254 aStartEndPnt[2*i] = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
255 myBaseFeatures[i]->attribute(aStartAttr))->pnt();
256 myFeatAttributes[2*i+1] = aEndAttr;
257 aStartEndPnt[2*i+1] = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
258 myBaseFeatures[i]->attribute(aEndAttr))->pnt();
260 for (int aFeatInd = 0; aFeatInd < aNbFeatures; aFeatInd++) {
261 for (int j = 0; j < 2; j++) // loop on start-end of each feature
262 if (aStartEndPnt[aFeatInd * aNbFeatures + j]->distance(aFilletPnt2d) < 1.e-10) {
263 myIsNotInversed[aFeatInd] = (j==0);
268 std::shared_ptr<GeomAPI_Ax3> aSketchPlane = SketchPlugin_Sketch::plane(sketch());
269 calculateFilletCenter(myBaseFeatures, aRadius, aSketchPlane,
270 myCenterXY, myTangentXY1, myTangentXY2);
272 // Tangent directions of the features in coincident point.
273 std::shared_ptr<GeomAPI_Dir2d> aTangentDir[aNbFeatures];
274 for (int i = 0; i < aNbFeatures; i++) {
275 std::shared_ptr<GeomAPI_XY> aDir;
276 if (myBaseFeatures[i]->getKind() == SketchPlugin_Line::ID()) {
277 aDir = aStartEndPnt[2*i+1]->xy()->decreased(aStartEndPnt[2*i]->xy());
278 if (!myIsNotInversed[i])
279 aDir = aDir->multiplied(-1.0);
280 } else if (myBaseFeatures[i]->getKind() == SketchPlugin_Arc::ID()) {
281 std::shared_ptr<GeomAPI_Pnt2d> aCenterPoint =
282 std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
283 myBaseFeatures[i]->attribute(SketchPlugin_Arc::CENTER_ID()))->pnt();
284 aDir = myIsNotInversed[i] ? aStartEndPnt[2*i]->xy() : aStartEndPnt[2*i+1]->xy();
285 aDir = aDir->decreased(aCenterPoint->xy());
287 double x = aDir->x();
288 double y = aDir->y();
291 if (myIsNotInversed[i] ==
292 std::dynamic_pointer_cast<SketchPlugin_Arc>(myBaseFeatures[i])->isReversed())
293 aDir = aDir->multiplied(-1.0);
295 aTangentDir[i] = std::shared_ptr<GeomAPI_Dir2d>(new GeomAPI_Dir2d(aDir));
298 // By default, the start point of fillet arc is connected to FeatureA,
299 // and the end point - to FeatureB. But when the angle between TangentDirA and
300 // TangentDirB greater 180 degree, the sequaence of features need to be reversed.
301 double cosBA = aTangentDir[0]->cross(aTangentDir[1]); // cos(B-A),
302 // where A and B - angles between corresponding tanget direction and the X axis
303 myIsReversed = cosBA > 0.0;
306 std::shared_ptr<GeomAPI_XY> aTmp = myTangentXY1;
307 myTangentXY1 = myTangentXY2;
313 bool SketchPlugin_Fillet::findFeaturesContainingFilletPoint(
314 std::shared_ptr<GeomDataAPI_Point2D> theFilletPoint)
316 // Obtain constraint coincidence for the fillet point.
317 FeaturePtr aConstraintCoincidence;
318 const std::set<AttributePtr>& aRefsList = theFilletPoint->owner()->data()->refsToMe();
319 for(std::set<AttributePtr>::const_iterator anIt = aRefsList.cbegin();
320 anIt != aRefsList.cend();
322 std::shared_ptr<ModelAPI_Attribute> anAttr = (*anIt);
323 FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(anAttr->owner());
324 if(aFeature->getKind() == SketchPlugin_ConstraintCoincidence::ID()) {
325 AttributeRefAttrPtr anAttrRefA =
326 aFeature->refattr(SketchPlugin_ConstraintCoincidence::ENTITY_A());
327 AttributeRefAttrPtr anAttrRefB =
328 aFeature->refattr(SketchPlugin_ConstraintCoincidence::ENTITY_B());
329 if(anAttrRefA.get() && !anAttrRefA->isObject()) {
330 AttributePtr anAttrA = anAttrRefA->attr();
331 if(theFilletPoint == anAttrA) {
332 aConstraintCoincidence = aFeature;
336 if(anAttrRefB.get() && !anAttrRefB->isObject()) {
337 AttributePtr anAttrB = anAttrRefB->attr();
338 if(theFilletPoint == anAttrB) {
339 aConstraintCoincidence = aFeature;
346 if(!aConstraintCoincidence.get())
349 // Get coincide edges.
350 std::set<FeaturePtr> anEdgeFeatures = getCoincides(aConstraintCoincidence);
351 std::set<FeaturePtr>::iterator aLinesIt = anEdgeFeatures.begin();
352 for (int i = 0; aLinesIt != anEdgeFeatures.end() && i < 2; ++aLinesIt, ++i)
353 myBaseFeatures[i] = *aLinesIt;
355 return myBaseFeatures[0] && myBaseFeatures[1];
358 // ========= Auxiliary functions =================
359 void recalculateAttributes(FeaturePtr theNewArc, const std::string& theNewArcAttribute,
360 FeaturePtr theFeature, const std::string& theFeatureAttribute)
362 std::shared_ptr<GeomAPI_Pnt2d> anArcPoint = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
363 theNewArc->attribute(theNewArcAttribute))->pnt();
364 std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
365 theFeature->attribute(theFeatureAttribute))->setValue(anArcPoint->x(), anArcPoint->y());
368 static std::shared_ptr<GeomAPI_Pnt2d> toPoint(const AttributePtr& theAttribute)
370 std::shared_ptr<GeomAPI_Pnt2d> aPoint;
371 AttributePoint2DPtr aPointAttr = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(theAttribute);
373 aPoint = aPointAttr->pnt();
377 static std::shared_ptr<GeomAPI_Lin2d> toLine(const FeaturePtr& theFeature)
379 std::shared_ptr<GeomAPI_Lin2d> aLine;
380 if (theFeature->getKind() == SketchPlugin_Line::ID()) {
381 std::shared_ptr<GeomAPI_Pnt2d> aStart =
382 toPoint( theFeature->attribute(SketchPlugin_Line::START_ID()) );
383 std::shared_ptr<GeomAPI_Pnt2d> aEnd =
384 toPoint( theFeature->attribute(SketchPlugin_Line::END_ID()) );
385 aLine = std::shared_ptr<GeomAPI_Lin2d>(new GeomAPI_Lin2d(aStart, aEnd));
390 static std::shared_ptr<GeomAPI_Circ2d> toCircle(const FeaturePtr& theFeature)
392 std::shared_ptr<GeomAPI_Circ2d> aCircle;
393 if (theFeature->getKind() == SketchPlugin_Arc::ID()) {
394 std::shared_ptr<GeomAPI_Pnt2d> aCenter =
395 toPoint( theFeature->attribute(SketchPlugin_Arc::CENTER_ID()) );
396 std::shared_ptr<GeomAPI_Pnt2d> aStart =
397 toPoint( theFeature->attribute(SketchPlugin_Arc::START_ID()) );
398 aCircle = std::shared_ptr<GeomAPI_Circ2d>(new GeomAPI_Circ2d(aCenter, aStart));
404 void calculateFilletCenter(FeaturePtr theFilletFeatures[2],
405 double theFilletRadius,
406 const std::shared_ptr<GeomAPI_Ax3>& theSketchPlane,
407 std::shared_ptr<GeomAPI_XY>& theCenter,
408 std::shared_ptr<GeomAPI_XY>& theTangentA,
409 std::shared_ptr<GeomAPI_XY>& theTangentB)
411 GeomShapePtr aShapeA = theFilletFeatures[0]->lastResult()->shape();
412 GeomShapePtr aShapeB = theFilletFeatures[1]->lastResult()->shape();
414 GeomAlgoAPI_Circ2dBuilder aCircBuilder(theSketchPlane);
415 aCircBuilder.addTangentCurve(aShapeA);
416 aCircBuilder.addTangentCurve(aShapeB);
417 aCircBuilder.setRadius(theFilletRadius);
419 std::shared_ptr<GeomAPI_Circ2d> aFilletCircle = aCircBuilder.circle();
423 theCenter = aFilletCircle->center()->xy();
425 std::shared_ptr<GeomAPI_Pnt2d> aTgPoints[2];
426 for (int i = 0; i < 2; ++i) {
427 std::shared_ptr<GeomAPI_Circ2d> aCircle = toCircle(theFilletFeatures[i]);
429 aTgPoints[i] = aCircle->project(aFilletCircle->center());
431 std::shared_ptr<GeomAPI_Lin2d> aLine = toLine(theFilletFeatures[i]);
433 aTgPoints[i] = aLine->project(aFilletCircle->center());
436 theTangentA = aTgPoints[0]->xy();
437 theTangentB = aTgPoints[1]->xy();
440 double calculateFilletRadius(FeaturePtr theFilletFeatures[2])
442 double aLengths[2] = { 0, 0 };
443 for (int i = 0; i < 2; ++i) {
444 GeomShapePtr aShape = theFilletFeatures[i]->lastResult()->shape();
445 std::shared_ptr<GeomAPI_Edge> anEdge = std::dynamic_pointer_cast<GeomAPI_Edge>(aShape);
447 aLengths[i] = anEdge->length();
449 return std::min(aLengths[0], aLengths[1]) / 6.0;
452 std::set<FeaturePtr> getCoincides(const FeaturePtr& theConstraintCoincidence)
454 std::set<FeaturePtr> aCoincides;
456 std::shared_ptr<GeomAPI_Pnt2d> aFilletPnt =
457 SketchPlugin_Tools::getCoincidencePoint(theConstraintCoincidence);
459 SketchPlugin_Tools::findCoincidences(theConstraintCoincidence,
460 SketchPlugin_ConstraintCoincidence::ENTITY_A(),
462 SketchPlugin_Tools::findCoincidences(theConstraintCoincidence,
463 SketchPlugin_ConstraintCoincidence::ENTITY_B(),
466 // Remove points from set of coincides.
467 std::set<FeaturePtr> aNewSetOfCoincides;
468 for(std::set<FeaturePtr>::iterator anIt = aCoincides.begin(); anIt != aCoincides.end(); ++anIt) {
469 std::shared_ptr<SketchPlugin_SketchEntity> aSketchEntity =
470 std::dynamic_pointer_cast<SketchPlugin_SketchEntity>(*anIt);
471 if(aSketchEntity.get() && aSketchEntity->isCopy()) {
474 if((*anIt)->getKind() == SketchPlugin_Line::ID()) {
475 aNewSetOfCoincides.insert(*anIt);
476 } else if((*anIt)->getKind() == SketchPlugin_Arc::ID()) {
477 AttributePtr anAttrCenter = (*anIt)->attribute(SketchPlugin_Arc::CENTER_ID());
478 std::shared_ptr<GeomDataAPI_Point2D> aPointCenter2D =
479 std::dynamic_pointer_cast<GeomDataAPI_Point2D>(anAttrCenter);
480 if(aPointCenter2D.get() && aFilletPnt->isEqual(aPointCenter2D->pnt())) {
483 aNewSetOfCoincides.insert(*anIt);
486 aCoincides = aNewSetOfCoincides;
488 // If we still have more than two coincides remove auxilary entities from set of coincides.
489 if(aCoincides.size() > 2) {
490 aNewSetOfCoincides.clear();
491 for(std::set<FeaturePtr>::iterator
492 anIt = aCoincides.begin(); anIt != aCoincides.end(); ++anIt) {
493 if(!(*anIt)->boolean(SketchPlugin_SketchEntity::AUXILIARY_ID())->value()) {
494 aNewSetOfCoincides.insert(*anIt);
497 aCoincides = aNewSetOfCoincides;
503 std::set<FeaturePtr> findFeaturesToRemove(const FeaturePtr theFeature,
504 const AttributePtr theAttribute) {
505 std::set<FeaturePtr> aFeaturesToBeRemoved;
506 std::set<AttributePtr> aRefs = theFeature->data()->refsToMe();
507 std::list<ResultPtr> aResults = theFeature->results();
508 for(std::list<ResultPtr>::const_iterator aResultsIt = aResults.cbegin();
509 aResultsIt != aResults.cend();
511 ResultPtr aResult = *aResultsIt;
512 std::set<AttributePtr> aResultRefs = aResult->data()->refsToMe();
513 aRefs.insert(aResultRefs.begin(), aResultRefs.end());
515 for(std::set<AttributePtr>::const_iterator anIt = aRefs.cbegin();
516 anIt != aRefs.cend();
518 std::shared_ptr<ModelAPI_Attribute> anAttr = (*anIt);
519 FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(anAttr->owner());
520 if(aFeature->getKind() == SketchPlugin_Fillet::ID()) {
523 if(aFeature->getKind() == SketchPlugin_ConstraintLength::ID()
524 || aFeature->getKind() == SketchPlugin_ConstraintEqual::ID()) {
525 aFeaturesToBeRemoved.insert(aFeature);
527 std::list<AttributePtr> anAttrs =
528 aFeature->data()->attributes(ModelAPI_AttributeRefAttr::typeId());
529 for(std::list<AttributePtr>::const_iterator aRefAttrsIt = anAttrs.cbegin();
530 aRefAttrsIt != anAttrs.cend();
532 AttributeRefAttrPtr anAttrRefAttr =
533 std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(*aRefAttrsIt);
534 if(anAttrRefAttr.get() && anAttrRefAttr->attr() == theAttribute) {
535 aFeaturesToBeRemoved.insert(aFeature);
540 return aFeaturesToBeRemoved;