1 // Copyright (C) 2014-20xx CEA/DEN, EDF R&D -->
3 // File: SketchPlugin_ConstraintSplit.cpp
4 // Created: 17 Jul 2016
5 // Author: Natalia ERMOLAEVA
7 #include "SketchPlugin_ConstraintSplit.h"
9 //#include <GeomAPI_Circ2d.h>
10 //#include <GeomAPI_Dir2d.h>
11 //#include <GeomAPI_Lin2d.h>
12 #include <GeomAPI_Pnt2d.h>
13 //#include <GeomAPI_XY.h>
14 #include <GeomDataAPI_Point2D.h>
15 //#include <ModelAPI_AttributeDouble.h>
16 #include <ModelAPI_AttributeReference.h>
17 #include <ModelAPI_AttributeString.h>
18 //#include <ModelAPI_AttributeRefList.h>
19 #include <ModelAPI_AttributeRefAttr.h>
21 #include <SketchPlugin_Line.h>
22 #include <SketchPlugin_Arc.h>
23 #include <SketchPlugin_Circle.h>
24 #include <SketchPlugin_ConstraintCoincidence.h>
25 #include <SketchPlugin_ConstraintEqual.h>
26 #include <SketchPlugin_ConstraintParallel.h>
27 #include <SketchPlugin_ConstraintTangent.h>
29 //#include <ModelAPI_Data.h>
30 #include <ModelAPI_Events.h>
31 //#include <ModelAPI_Session.h>
32 //#include <ModelAPI_Validator.h>
34 //#include <SketchPlugin_Arc.h>
35 //#include <SketchPlugin_Line.h>
36 //#include <SketchPlugin_Point.h>
37 //#include <SketchPlugin_Sketch.h>
38 //#include <SketchPlugin_ConstraintCoincidence.h>
39 //#include <SketchPlugin_ConstraintTangent.h>
40 //#include <SketchPlugin_ConstraintRadius.h>
41 //#include <SketchPlugin_Tools.h>
43 #include <Events_Loop.h>
47 //const double tolerance = 1.e-7;
48 //const double paramTolerance = 1.e-4;
50 ///// \brief Attract specified point on theNewArc to the attribute of theFeature
51 //static void recalculateAttributes(FeaturePtr theNewArc, const std::string& theNewArcAttribute,
52 // FeaturePtr theFeature, const std::string& theFeatureAttribute);
54 ///// \brief Calculates center of fillet arc and coordinates of tangency points
55 //static void calculateFilletCenter(FeaturePtr theFeatureA, FeaturePtr theFeatureB,
56 // double theRadius, bool theNotInversed[2],
57 // std::shared_ptr<GeomAPI_XY>& theCenter,
58 // std::shared_ptr<GeomAPI_XY>& theTangentA,
59 // std::shared_ptr<GeomAPI_XY>& theTangentB);
61 ///// Get point on 1/3 length of edge from fillet point
62 //static void getPointOnEdge(const FeaturePtr theFeature,
63 // const std::shared_ptr<GeomAPI_Pnt2d> theFilletPoint,
64 // std::shared_ptr<GeomAPI_Pnt2d>& thePoint);
66 ///// Get distance from point to feature
67 //static double getProjectionDistance(const FeaturePtr theFeature,
68 // const std::shared_ptr<GeomAPI_Pnt2d> thePoint);
70 ///// Get coincide edges for fillet
71 //static std::set<FeaturePtr> getCoincides(const FeaturePtr& theConstraintCoincidence);
73 SketchPlugin_ConstraintSplit::SketchPlugin_ConstraintSplit()
74 //: myListOfPointsChangedInCode(false),
75 // myRadiusChangedByUser(false),
76 // myRadiusChangedInCode(false),
77 // myRadiusInitialized(false)
81 void SketchPlugin_ConstraintSplit::initAttributes()
83 data()->addAttribute(SketchPlugin_Constraint::VALUE(), ModelAPI_AttributeReference::typeId());
84 data()->addAttribute(SketchPlugin_Constraint::ENTITY_A(), ModelAPI_AttributeRefAttr::typeId());
85 data()->addAttribute(SketchPlugin_Constraint::ENTITY_B(), ModelAPI_AttributeRefAttr::typeId());
87 //data()->addAttribute(SketchPlugin_Constraint::VALUE(), ModelAPI_AttributeDouble::typeId());
88 //data()->addAttribute(SketchPlugin_Constraint::ENTITY_A(), ModelAPI_AttributeRefAttrList::typeId());
91 void SketchPlugin_ConstraintSplit::execute()
93 std::shared_ptr<ModelAPI_Data> aData = data();
95 // Check the base objects are initialized.
96 AttributeReferencePtr aBaseObjectAttr = std::dynamic_pointer_cast<ModelAPI_AttributeReference>(
97 aData->attribute(SketchPlugin_Constraint::VALUE()));
98 if(!aBaseObjectAttr->isInitialized()) {
99 setError("Error: Base object is not initialized.");
102 AttributePoint2DPtr aFirstPointAttr = getPointOfRefAttr(aData->attribute(SketchPlugin_Constraint::ENTITY_A()));
103 AttributePoint2DPtr aSecondPointAttr = getPointOfRefAttr(aData->attribute(SketchPlugin_Constraint::ENTITY_B()));
104 if (!aFirstPointAttr.get() || !aFirstPointAttr->isInitialized() ||
105 !aSecondPointAttr.get() || !aSecondPointAttr->isInitialized()) {
106 setError("Error: Sub-shape is not initialized.");
110 // Wait all constraints being created, then send update events
111 static Events_ID anUpdateEvent = Events_Loop::eventByName(EVENT_OBJECT_UPDATED);
112 bool isUpdateFlushed = Events_Loop::loop()->isFlushed(anUpdateEvent);
114 Events_Loop::loop()->setFlushed(anUpdateEvent, false);
117 FeaturePtr aBaseFeature = ModelAPI_Feature::feature(aBaseObjectAttr->value());
118 std::string aFeatureKind = aBaseFeature->getKind();
119 FeaturePtr aSplitFeature, aBeforeFeature, anAfterFeature;
120 /*if (aFeatureKind == SketchPlugin_Line::ID())
121 splitLine(aSplitFeature, anOtherFeatures);
122 else*/ if (aFeatureKind == SketchPlugin_Arc::ID())
123 splitArc(aSplitFeature, aBeforeFeature, anAfterFeature);
124 /*if (aFeatureKind == SketchPlugin_Circle::ID())
125 splitCircle(aSplitFeature, anOtherFeatures);
126 FeaturePtr aSplitFeature;
127 std::set<FeaturePtr> anOtherFeatures;*/
129 // Send events to update the sub-features by the solver.
130 if(isUpdateFlushed) {
131 Events_Loop::loop()->setFlushed(anUpdateEvent, true);
135 void SketchPlugin_ConstraintSplit::attributeChanged(const std::string& theID)
137 /* if(theID == SketchPlugin_Constraint::ENTITY_A()) {
138 if(myListOfPointsChangedInCode) {
145 // Clear list of new points.
148 // Get list of points for fillets and current radius.
149 AttributeRefAttrListPtr aRefListOfFilletPoints = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttrList>(
150 data()->attribute(SketchPlugin_Constraint::ENTITY_A()));
151 AttributeDoublePtr aRadiusAttribute = real(VALUE());
152 int aListSize = aRefListOfFilletPoints->size();
153 if(aListSize == 0 && !myRadiusChangedByUser) {
154 // If list is empty reset radius to zero (if it was not changed by user).
155 myRadiusChangedInCode = true;
156 aRadiusAttribute->setValue(0);
157 myRadiusChangedInCode = false;
161 // Iterate over points to get base lines an calculate radius for fillets.
162 double aMinimumRadius = 0;
163 std::list<std::pair<ObjectPtr, AttributePtr>> aSelectedPointsList = aRefListOfFilletPoints->list();
164 std::list<std::pair<ObjectPtr, AttributePtr>>::iterator anIter = aSelectedPointsList.begin();
165 std::set<AttributePtr> aPointsToSkeep;
166 for(int anIndex = 0; anIndex < aListSize; anIndex++, anIter++) {
167 AttributePtr aFilletPointAttr = (*anIter).second;
168 std::shared_ptr<GeomDataAPI_Point2D> aFilletPoint2D =
169 std::dynamic_pointer_cast<GeomDataAPI_Point2D>(aFilletPointAttr);
170 if(!aFilletPoint2D.get()) {
172 setError("Error: One of the selected points is invalid.");
176 // If point or coincident point is already in list remove it from attribute.
177 if(aPointsToSkeep.find(aFilletPointAttr) != aPointsToSkeep.end()) {
178 myListOfPointsChangedInCode = true;
179 aRefListOfFilletPoints->remove(aFilletPointAttr);
180 myListOfPointsChangedInCode = false;
184 // Obtain constraint coincidence for the fillet point.
185 FeaturePtr aConstraintCoincidence;
186 const std::set<AttributePtr>& aRefsList = aFilletPointAttr->owner()->data()->refsToMe();
187 for(std::set<AttributePtr>::const_iterator anIt = aRefsList.cbegin(); anIt != aRefsList.cend(); ++anIt) {
188 std::shared_ptr<ModelAPI_Attribute> anAttr = (*anIt);
189 FeaturePtr aConstrFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(anAttr->owner());
190 if(aConstrFeature->getKind() == SketchPlugin_ConstraintCoincidence::ID()) {
191 AttributeRefAttrPtr anAttrRefA = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(
192 aConstrFeature->attribute(SketchPlugin_ConstraintCoincidence::ENTITY_A()));
193 AttributeRefAttrPtr anAttrRefB = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(
194 aConstrFeature->attribute(SketchPlugin_ConstraintCoincidence::ENTITY_B()));
195 if(anAttrRefA.get()) {
196 AttributePtr anAttrA = anAttrRefA->attr();
197 if(aFilletPointAttr == anAttrA) {
198 aConstraintCoincidence = aConstrFeature;
202 if(anAttrRefB.get()) {
203 AttributePtr anAttrB = anAttrRefB->attr();
204 if(aFilletPointAttr == anAttrB) {
205 aConstraintCoincidence = aConstrFeature;
212 if(!aConstraintCoincidence.get()) {
214 setError("Error: No coincident edges at one of the selected points.");
218 // Get coincides from constraint.
219 std::set<FeaturePtr> aCoincides;
222 SketchPlugin_Tools::findCoincidences(aConstraintCoincidence,
223 SketchPlugin_ConstraintCoincidence::ENTITY_A(),
225 SketchPlugin_Tools::findCoincidences(aConstraintCoincidence,
226 SketchPlugin_ConstraintCoincidence::ENTITY_B(),
229 // Remove points from set of coincides. Also get all attributes which is equal to this point to exclude it.
230 std::shared_ptr<GeomAPI_Pnt2d> aFilletPnt2d = aFilletPoint2D->pnt();
231 std::set<FeaturePtr> aNewSetOfCoincides;
232 for(std::set<FeaturePtr>::iterator anIt = aCoincides.begin(); anIt != aCoincides.end(); ++anIt) {
233 std::string aFeatureKind = (*anIt)->getKind();
234 if(aFeatureKind == SketchPlugin_Point::ID()) {
235 AttributePtr anAttr = (*anIt)->attribute(SketchPlugin_Point::COORD_ID());
236 std::shared_ptr<GeomDataAPI_Point2D> aPoint2D =
237 std::dynamic_pointer_cast<GeomDataAPI_Point2D>(anAttr);
238 if(aPoint2D.get() && aFilletPnt2d->isEqual(aPoint2D->pnt())) {
239 aPointsToSkeep.insert(anAttr);
241 } else if(aFeatureKind == SketchPlugin_Line::ID()) {
242 AttributePtr anAttrStart = (*anIt)->attribute(SketchPlugin_Line::START_ID());
243 std::shared_ptr<GeomDataAPI_Point2D> aPointStart2D =
244 std::dynamic_pointer_cast<GeomDataAPI_Point2D>(anAttrStart);
245 if(aPointStart2D.get() && aFilletPnt2d->isEqual(aPointStart2D->pnt())) {
246 aPointsToSkeep.insert(anAttrStart);
248 AttributePtr anAttrEnd = (*anIt)->attribute(SketchPlugin_Line::END_ID());
249 std::shared_ptr<GeomDataAPI_Point2D> aPointEnd2D =
250 std::dynamic_pointer_cast<GeomDataAPI_Point2D>(anAttrEnd);
251 if(aPointEnd2D.get() && aFilletPnt2d->isEqual(aPointEnd2D->pnt())) {
252 aPointsToSkeep.insert(anAttrEnd);
254 aNewSetOfCoincides.insert(*anIt);
255 } else if(aFeatureKind == SketchPlugin_Arc::ID() ) {
256 AttributePtr anAttrCenter = (*anIt)->attribute(SketchPlugin_Arc::CENTER_ID());
257 std::shared_ptr<GeomDataAPI_Point2D> aPointCenter2D =
258 std::dynamic_pointer_cast<GeomDataAPI_Point2D>(anAttrCenter);
259 if(aPointCenter2D.get() && aFilletPnt2d->isEqual(aPointCenter2D->pnt())) {
260 aPointsToSkeep.insert(anAttrCenter);
263 AttributePtr anAttrStart = (*anIt)->attribute(SketchPlugin_Arc::START_ID());
264 std::shared_ptr<GeomDataAPI_Point2D> aPointStart2D =
265 std::dynamic_pointer_cast<GeomDataAPI_Point2D>(anAttrStart);
266 if(aPointStart2D.get() && aFilletPnt2d->isEqual(aPointStart2D->pnt())) {
267 aPointsToSkeep.insert(anAttrStart);
269 AttributePtr anAttrEnd = (*anIt)->attribute(SketchPlugin_Arc::END_ID());
270 std::shared_ptr<GeomDataAPI_Point2D> aPointEnd2D =
271 std::dynamic_pointer_cast<GeomDataAPI_Point2D>(anAttrEnd);
272 if(aPointEnd2D.get() && aFilletPnt2d->isEqual(aPointEnd2D->pnt())) {
273 aPointsToSkeep.insert(anAttrEnd);
275 aNewSetOfCoincides.insert(*anIt);
278 aCoincides = aNewSetOfCoincides;
280 // If we still have more than two coincides remove auxilary entities from set of coincides.
281 if(aCoincides.size() > 2) {
282 aNewSetOfCoincides.clear();
283 for(std::set<FeaturePtr>::iterator anIt = aCoincides.begin(); anIt != aCoincides.end(); ++anIt) {
284 if(!(*anIt)->boolean(SketchPlugin_SketchEntity::AUXILIARY_ID())->value()) {
285 aNewSetOfCoincides.insert(*anIt);
288 aCoincides = aNewSetOfCoincides;
291 if(aCoincides.size() != 2) {
293 setError("Error: One of the selected points does not have two suitable edges for fillet.");
297 // Store base point for fillet.
298 aPointsToSkeep.insert(aFilletPointAttr);
299 myNewPoints.insert(aFilletPointAttr);
301 // Get base lines for fillet.
302 FeaturePtr anOldFeatureA, anOldFeatureB;
303 std::set<FeaturePtr>::iterator aLinesIt = aCoincides.begin();
304 anOldFeatureA = *aLinesIt++;
305 anOldFeatureB = *aLinesIt;
307 // Getting radius value if it was not changed by user.
308 if(!myRadiusChangedByUser) {
309 // Getting points located at 1/3 of edge length from fillet point.
310 std::shared_ptr<GeomAPI_Pnt2d> aFilletPnt2d = aFilletPoint2D->pnt();
311 std::shared_ptr<GeomAPI_Pnt2d> aPntA, aPntB;
312 getPointOnEdge(anOldFeatureA, aFilletPnt2d, aPntA);
313 getPointOnEdge(anOldFeatureB, aFilletPnt2d, aPntB);
315 /// Getting distances.
316 double aDistanceA = getProjectionDistance(anOldFeatureB, aPntA);
317 double aDistanceB = getProjectionDistance(anOldFeatureA, aPntB);
318 double aRadius = aDistanceA < aDistanceB ? aDistanceA / 2.0 : aDistanceB / 2.0;
319 aMinimumRadius = aMinimumRadius == 0 ? aRadius : aRadius < aMinimumRadius ? aRadius : aMinimumRadius;
323 // Set new default radius if it was not changed by user.
324 if(!myRadiusChangedByUser) {
325 myRadiusChangedInCode = true;
326 aRadiusAttribute->setValue(aMinimumRadius);
327 myRadiusChangedInCode = false;
330 } else if(theID == SketchPlugin_Constraint::VALUE()) {
331 if(myRadiusInitialized && !myRadiusChangedInCode) {
332 myRadiusChangedByUser = true;
334 if(!myRadiusInitialized) {
335 myRadiusInitialized = true;
341 //AISObjectPtr SketchPlugin_ConstraintSplit::getAISObject(AISObjectPtr thePrevious)
344 // return thePrevious;
346 // AISObjectPtr anAIS = thePrevious;
347 // /// TODO: Equal constraint presentation should be put here
351 bool SketchPlugin_ConstraintSplit::isMacro() const
356 //void SketchPlugin_ConstraintSplit::clearResults()
358 ///* // Clear auxiliary flag on initial objects.
359 // for(std::map<AttributePtr, FilletFeatures>::iterator aPointsIter = myPointFeaturesMap.begin();
360 // aPointsIter != myPointFeaturesMap.end();) {
361 // const FilletFeatures& aFilletFeatures = aPointsIter->second;
362 // std::list<std::pair<FeaturePtr, bool>>::const_iterator aFeatureIt;
363 // for(aFeatureIt = aFilletFeatures.baseEdgesState.cbegin();
364 // aFeatureIt != aFilletFeatures.baseEdgesState.cend();
366 // aFeatureIt->first->boolean(SketchPlugin_SketchEntity::AUXILIARY_ID())->setValue(aFeatureIt->second);
371 // // And remove all produced features.
372 // DocumentPtr aDoc = sketch()->document();
373 // for(std::map<AttributePtr, FilletFeatures>::iterator aPointsIter = myPointFeaturesMap.begin();
374 // aPointsIter != myPointFeaturesMap.end();) {
375 // // Remove all produced constraints.
376 // const FilletFeatures& aFilletFeatures = aPointsIter->second;
377 // std::list<FeaturePtr>::const_iterator aFeatureIt;
378 // for(aFeatureIt = aFilletFeatures.resultConstraints.cbegin();
379 // aFeatureIt != aFilletFeatures.resultConstraints.cend();
381 // aDoc->removeFeature(*aFeatureIt);
384 // // Remove all result edges.
385 // for(aFeatureIt = aFilletFeatures.resultEdges.cbegin();
386 // aFeatureIt != aFilletFeatures.resultEdges.cend();
388 // aDoc->removeFeature(*aFeatureIt);
391 // // Remove point from map.
392 // myPointFeaturesMap.erase(aPointsIter++);
398 //// ========= Auxiliary functions =================
399 //void recalculateAttributes(FeaturePtr theNewArc, const std::string& theNewArcAttribute,
400 // FeaturePtr theFeature, const std::string& theFeatureAttribute)
402 // std::shared_ptr<GeomAPI_Pnt2d> anArcPoint = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
403 // theNewArc->attribute(theNewArcAttribute))->pnt();
404 // std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
405 // theFeature->attribute(theFeatureAttribute))->setValue(anArcPoint->x(), anArcPoint->y());
408 /*/// \brief Find intersections of lines shifted along normal direction
409 void possibleFilletCenterLineLine(
410 std::shared_ptr<GeomAPI_XY> thePointA, std::shared_ptr<GeomAPI_Dir2d> theDirA,
411 std::shared_ptr<GeomAPI_XY> thePointB, std::shared_ptr<GeomAPI_Dir2d> theDirB,
412 double theRadius, std::list< std::shared_ptr<GeomAPI_XY> >& theCenters)
414 std::shared_ptr<GeomAPI_Dir2d> aDirAT(new GeomAPI_Dir2d(-theDirA->y(), theDirA->x()));
415 std::shared_ptr<GeomAPI_Dir2d> aDirBT(new GeomAPI_Dir2d(-theDirB->y(), theDirB->x()));
416 std::shared_ptr<GeomAPI_XY> aPntA, aPntB;
417 double aDet = theDirA->cross(theDirB);
418 for (double aStepA = -1.0; aStepA <= 1.0; aStepA += 2.0) {
419 aPntA = thePointA->added(aDirAT->xy()->multiplied(aStepA * theRadius));
420 for (double aStepB = -1.0; aStepB <= 1.0; aStepB += 2.0) {
421 aPntB = thePointB->added(aDirBT->xy()->multiplied(aStepB * theRadius));
422 double aVX = aDirAT->xy()->dot(aPntA);
423 double aVY = aDirBT->xy()->dot(aPntB);
424 std::shared_ptr<GeomAPI_XY> aPoint(new GeomAPI_XY(
425 (theDirB->x() * aVX - theDirA->x() * aVY) / aDet,
426 (theDirB->y() * aVX - theDirA->y() * aVY) / aDet));
427 theCenters.push_back(aPoint);
432 /// \brief Find intersections of line shifted along normal direction in both sides
433 /// and a circle with extended radius
434 void possibleFilletCenterLineArc(
435 std::shared_ptr<GeomAPI_XY> theStartLine, std::shared_ptr<GeomAPI_Dir2d> theDirLine,
436 std::shared_ptr<GeomAPI_XY> theCenterArc, double theRadiusArc,
437 double theRadius, std::list< std::shared_ptr<GeomAPI_XY> >& theCenters)
439 std::shared_ptr<GeomAPI_Dir2d> aDirT(new GeomAPI_Dir2d(-theDirLine->y(), theDirLine->x()));
440 std::shared_ptr<GeomAPI_XY> aPnt;
441 double aDirNorm2 = theDirLine->dot(theDirLine);
443 double aDirX = theDirLine->x();
444 double aDirX2 = theDirLine->x() * theDirLine->x();
445 double aDirY2 = theDirLine->y() * theDirLine->y();
446 double aDirXY = theDirLine->x() * theDirLine->y();
447 for (double aStepA = -1.0; aStepA <= 1.0; aStepA += 2.0) {
448 aPnt = theStartLine->added(aDirT->xy()->multiplied(aStepA * theRadius));
449 double aCoeff = aDirT->xy()->dot(aPnt->decreased(theCenterArc));
450 double aCoeff2 = aCoeff * aCoeff;
451 for (double aStepB = -1.0; aStepB <= 1.0; aStepB += 2.0) {
452 aRad = theRadiusArc + aStepB * theRadius;
453 double aD = aRad * aRad * aDirNorm2 - aCoeff2;
456 double aDs = sqrt(aD);
457 double x1 = theCenterArc->x() + (aCoeff * aDirT->x() - aDirT->y() * aDs) / aDirNorm2;
458 double x2 = theCenterArc->x() + (aCoeff * aDirT->x() + aDirT->y() * aDs) / aDirNorm2;
459 double y1 = (aDirX2 * aPnt->y() + aDirY2 * theCenterArc->y() -
460 aDirXY * (aPnt->x() - theCenterArc->x()) - theDirLine->y() * aDs) / aDirNorm2;
461 double y2 = (aDirX2 * aPnt->y() + aDirY2 * theCenterArc->y() -
462 aDirXY * (aPnt->x() - theCenterArc->x()) + theDirLine->y() * aDs) / aDirNorm2;
464 std::shared_ptr<GeomAPI_XY> aPoint1(new GeomAPI_XY(x1, y1));
465 theCenters.push_back(aPoint1);
466 std::shared_ptr<GeomAPI_XY> aPoint2(new GeomAPI_XY(x2, y2));
467 theCenters.push_back(aPoint2);
472 /// \brief Find intersections of two circles with extended radii
473 void possibleFilletCenterArcArc(
474 std::shared_ptr<GeomAPI_XY> theCenterA, double theRadiusA,
475 std::shared_ptr<GeomAPI_XY> theCenterB, double theRadiusB,
476 double theRadius, std::list< std::shared_ptr<GeomAPI_XY> >& theCenters)
478 std::shared_ptr<GeomAPI_XY> aCenterDir = theCenterB->decreased(theCenterA);
479 double aCenterDist2 = aCenterDir->dot(aCenterDir);
480 double aCenterDist = sqrt(aCenterDist2);
483 for (double aStepA = -1.0; aStepA <= 1.0; aStepA += 2.0) {
484 aRadA = theRadiusA + aStepA * theRadius;
485 for (double aStepB = -1.0; aStepB <= 1.0; aStepB += 2.0) {
486 aRadB = theRadiusB + aStepB * theRadius;
487 if (aRadA + aRadB < aCenterDist || fabs(aRadA - aRadB) > aCenterDist)
488 continue; // there is no intersections
490 double aMedDist = (aRadA * aRadA - aRadB * aRadB + aCenterDist2) / (2.0 * aCenterDist);
491 double aHeight = sqrt(aRadA * aRadA - aMedDist * aMedDist);
493 double x1 = theCenterA->x() + (aMedDist * aCenterDir->x() + aCenterDir->y() * aHeight) / aCenterDist;
494 double y1 = theCenterA->y() + (aMedDist * aCenterDir->y() - aCenterDir->x() * aHeight) / aCenterDist;
496 double x2 = theCenterA->x() + (aMedDist * aCenterDir->x() - aCenterDir->y() * aHeight) / aCenterDist;
497 double y2 = theCenterA->y() + (aMedDist * aCenterDir->y() + aCenterDir->x() * aHeight) / aCenterDist;
499 std::shared_ptr<GeomAPI_XY> aPoint1(new GeomAPI_XY(x1, y1));
500 theCenters.push_back(aPoint1);
501 std::shared_ptr<GeomAPI_XY> aPoint2(new GeomAPI_XY(x2, y2));
502 theCenters.push_back(aPoint2);
507 void calculateFilletCenter(FeaturePtr theFeatureA, FeaturePtr theFeatureB,
508 double theRadius, bool theNotInversed[2],
509 std::shared_ptr<GeomAPI_XY>& theCenter,
510 std::shared_ptr<GeomAPI_XY>& theTangentA,
511 std::shared_ptr<GeomAPI_XY>& theTangentB)
513 static const int aNbFeatures = 2;
514 FeaturePtr aFeature[aNbFeatures] = {theFeatureA, theFeatureB};
515 std::shared_ptr<GeomAPI_XY> aStart[aNbFeatures], aEnd[aNbFeatures], aCenter[aNbFeatures];
516 std::shared_ptr<GeomDataAPI_Point2D> aStartPoint, aEndPoint;
518 for (int i = 0; i < aNbFeatures; i++) {
519 if (aFeature[i]->getKind() == SketchPlugin_Line::ID()) {
520 aStartPoint = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
521 aFeature[i]->attribute(SketchPlugin_Line::START_ID()));
522 aEndPoint = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
523 aFeature[i]->attribute(SketchPlugin_Line::END_ID()));
524 } else if (aFeature[i]->getKind() == SketchPlugin_Arc::ID()) {
525 aStartPoint = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
526 aFeature[i]->attribute(SketchPlugin_Arc::START_ID()));
527 aEndPoint = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
528 aFeature[i]->attribute(SketchPlugin_Arc::END_ID()));
529 aCenter[i] = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
530 aFeature[i]->attribute(SketchPlugin_Arc::CENTER_ID()))->pnt()->xy();
533 aStart[i] = std::shared_ptr<GeomAPI_XY>(theNotInversed[i] ?
534 new GeomAPI_XY(aStartPoint->x(), aStartPoint->y()) :
535 new GeomAPI_XY(aEndPoint->x(), aEndPoint->y()));
536 aEnd[i] = std::shared_ptr<GeomAPI_XY>(theNotInversed[i] ?
537 new GeomAPI_XY(aEndPoint->x(), aEndPoint->y()) :
538 new GeomAPI_XY(aStartPoint->x(), aStartPoint->y()));
541 if (theFeatureA->getKind() == SketchPlugin_Line::ID() &&
542 theFeatureB->getKind() == SketchPlugin_Line::ID()) {
543 std::shared_ptr<GeomAPI_Dir2d> aDir[2];
544 std::shared_ptr<GeomAPI_Dir2d> aDirT[2];
545 for (int i = 0; i < aNbFeatures; i++) {
546 aDir[i] = std::shared_ptr<GeomAPI_Dir2d>(new GeomAPI_Dir2d(aEnd[i]->decreased(aStart[i])));
547 aDirT[i] = std::shared_ptr<GeomAPI_Dir2d>(new GeomAPI_Dir2d(-aDir[i]->y(), aDir[i]->x()));
550 // get and filter possible centers
551 std::list< std::shared_ptr<GeomAPI_XY> > aSuspectCenters;
552 possibleFilletCenterLineLine(aStart[0], aDir[0], aStart[1], aDir[1], theRadius, aSuspectCenters);
554 std::list< std::shared_ptr<GeomAPI_XY> >::iterator anIt = aSuspectCenters.begin();
555 for (; anIt != aSuspectCenters.end(); anIt++) {
556 aDot = aDirT[0]->xy()->dot(aStart[0]->decreased(*anIt));
557 theTangentA = (*anIt)->added(aDirT[0]->xy()->multiplied(aDot));
558 if (theTangentA->decreased(aStart[0])->dot(aDir[0]->xy()) < 0.0)
559 continue; // incorrect position
560 aDot = aDirT[1]->xy()->dot(aStart[1]->decreased(*anIt));
561 theTangentB = (*anIt)->added(aDirT[1]->xy()->multiplied(aDot));
562 if (theTangentB->decreased(aStart[1])->dot(aDir[1]->xy()) < 0.0)
563 continue; // incorrect position
564 // the center is found, stop searching
568 } else if ((theFeatureA->getKind() == SketchPlugin_Arc::ID() &&
569 theFeatureB->getKind() == SketchPlugin_Line::ID()) ||
570 (theFeatureA->getKind() == SketchPlugin_Line::ID() &&
571 theFeatureB->getKind() == SketchPlugin_Arc::ID())) {
572 int aLineInd = theFeatureA->getKind() == SketchPlugin_Line::ID() ? 0 : 1;
573 double anArcRadius = aStart[1-aLineInd]->distance(aCenter[1-aLineInd]);
574 std::shared_ptr<GeomAPI_Dir2d> aDirLine = std::shared_ptr<GeomAPI_Dir2d>(
575 new GeomAPI_Dir2d(aEnd[aLineInd]->decreased(aStart[aLineInd])));
576 std::shared_ptr<GeomAPI_Dir2d> aDirT = std::shared_ptr<GeomAPI_Dir2d>(
577 new GeomAPI_Dir2d(-aDirLine->y(), aDirLine->x()));
579 std::shared_ptr<GeomAPI_Dir2d> aStartArcDir = std::shared_ptr<GeomAPI_Dir2d>(
580 new GeomAPI_Dir2d(aStart[1-aLineInd]->decreased(aCenter[1-aLineInd])));
581 std::shared_ptr<GeomAPI_Dir2d> aEndArcDir = std::shared_ptr<GeomAPI_Dir2d>(
582 new GeomAPI_Dir2d(aEnd[1-aLineInd]->decreased(aCenter[1-aLineInd])));
583 double anArcAngle = aEndArcDir->angle(aStartArcDir);
585 // get possible centers and filter them
586 std::list< std::shared_ptr<GeomAPI_XY> > aSuspectCenters;
587 possibleFilletCenterLineArc(aStart[aLineInd], aDirLine, aCenter[1-aLineInd], anArcRadius, theRadius, aSuspectCenters);
589 // the line is forward into the arc
590 double innerArc = aCenter[1-aLineInd]->decreased(aStart[aLineInd])->dot(aDirLine->xy());
591 std::shared_ptr<GeomAPI_XY> aLineTgPoint, anArcTgPoint;
592 // The possible centers are ranged by their positions.
593 // If the point is not satisfy one of criteria, the weight is decreased with penalty.
595 std::list< std::shared_ptr<GeomAPI_XY> >::iterator anIt = aSuspectCenters.begin();
596 for (; anIt != aSuspectCenters.end(); anIt++) {
598 aDot = aDirT->xy()->dot(aStart[aLineInd]->decreased(*anIt));
599 aLineTgPoint = (*anIt)->added(aDirT->xy()->multiplied(aDot));
600 // Check the point is placed on the correct arc (penalty if false)
601 if (aCenter[1-aLineInd]->distance(*anIt) * innerArc > anArcRadius * innerArc)
603 std::shared_ptr<GeomAPI_Dir2d> aCurDir = std::shared_ptr<GeomAPI_Dir2d>(
604 new GeomAPI_Dir2d((*anIt)->decreased(aCenter[1-aLineInd])));
605 double aCurAngle = aCurDir->angle(aStartArcDir);
606 if (anArcAngle < 0.0) aCurAngle *= -1.0;
607 if (aCurAngle < 0.0 || aCurAngle > fabs(anArcAngle))
609 if (aWeight > aBestWeight)
610 aBestWeight = aWeight;
611 else if (aWeight < aBestWeight ||
612 aStart[aLineInd]->distance(*anIt) >
613 aStart[aLineInd]->distance(theCenter)) // <-- take closer point
615 // the center is found, stop searching
617 anArcTgPoint = aCenter[1-aLineInd]->added(aCurDir->xy()->multiplied(anArcRadius));
618 if (theFeatureA->getKind() == SketchPlugin_Line::ID()) {
619 theTangentA = aLineTgPoint;
620 theTangentB = anArcTgPoint;
622 theTangentA = anArcTgPoint;
623 theTangentB = aLineTgPoint;
627 } else if (theFeatureA->getKind() == SketchPlugin_Arc::ID() &&
628 theFeatureB->getKind() == SketchPlugin_Arc::ID()) {
629 double anArcRadius[aNbFeatures];
630 double anArcAngle[aNbFeatures];
631 std::shared_ptr<GeomAPI_Dir2d> aStartArcDir[aNbFeatures];
632 for (int i = 0; i < aNbFeatures; i++) {
633 anArcRadius[i] = aStart[i]->distance(aCenter[i]);
634 aStartArcDir[i] = std::shared_ptr<GeomAPI_Dir2d>(
635 new GeomAPI_Dir2d(aStart[i]->decreased(aCenter[i])));
636 std::shared_ptr<GeomAPI_Dir2d> aEndArcDir = std::shared_ptr<GeomAPI_Dir2d>(
637 new GeomAPI_Dir2d(aEnd[i]->decreased(aCenter[i])));
638 anArcAngle[i] = aEndArcDir->angle(aStartArcDir[i]);
641 // get and filter possible centers
642 std::list< std::shared_ptr<GeomAPI_XY> > aSuspectCenters;
643 possibleFilletCenterArcArc(aCenter[0], anArcRadius[0], aCenter[1], anArcRadius[1], theRadius, aSuspectCenters);
645 std::shared_ptr<GeomAPI_XY> aLineTgPoint, anArcTgPoint;
646 std::list< std::shared_ptr<GeomAPI_XY> >::iterator anIt = aSuspectCenters.begin();
647 for (; anIt != aSuspectCenters.end(); anIt++) {
648 std::shared_ptr<GeomAPI_Dir2d> aCurDir = std::shared_ptr<GeomAPI_Dir2d>(
649 new GeomAPI_Dir2d((*anIt)->decreased(aCenter[0])));
650 double aCurAngle = aCurDir->angle(aStartArcDir[0]);
651 if (anArcAngle[0] < 0.0) aCurAngle *= -1.0;
652 if (aCurAngle < 0.0 || aCurAngle > fabs(anArcAngle[0]))
653 continue; // incorrect position
654 theTangentA = aCenter[0]->added(aCurDir->xy()->multiplied(anArcRadius[0]));
656 aCurDir = std::shared_ptr<GeomAPI_Dir2d>(new GeomAPI_Dir2d((*anIt)->decreased(aCenter[1])));
657 aCurAngle = aCurDir->angle(aStartArcDir[1]);
658 if (anArcAngle[1] < 0.0) aCurAngle *= -1.0;
659 if (aCurAngle < 0.0 || aCurAngle > fabs(anArcAngle[1]))
660 continue; // incorrect position
661 theTangentB = aCenter[1]->added(aCurDir->xy()->multiplied(anArcRadius[1]));
663 // the center is found, stop searching
670 void getPointOnEdge(const FeaturePtr theFeature,
671 const std::shared_ptr<GeomAPI_Pnt2d> theFilletPoint,
672 std::shared_ptr<GeomAPI_Pnt2d>& thePoint) {
673 if(theFeature->getKind() == SketchPlugin_Line::ID()) {
674 std::shared_ptr<GeomAPI_Pnt2d> aPntStart = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
675 theFeature->attribute(SketchPlugin_Line::START_ID()))->pnt();
676 std::shared_ptr<GeomAPI_Pnt2d> aPntEnd = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
677 theFeature->attribute(SketchPlugin_Line::END_ID()))->pnt();
678 if(aPntStart->distance(theFilletPoint) > 1.e-7) {
679 aPntStart = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
680 theFeature->attribute(SketchPlugin_Line::END_ID()))->pnt();
681 aPntEnd = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
682 theFeature->attribute(SketchPlugin_Line::START_ID()))->pnt();
684 thePoint.reset( new GeomAPI_Pnt2d(aPntStart->xy()->added( aPntEnd->xy()->decreased( aPntStart->xy() )->multiplied(1.0 / 3.0) ) ) );
686 std::shared_ptr<GeomAPI_Pnt2d> aPntTemp;
687 std::shared_ptr<GeomAPI_Pnt2d> aPntStart = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
688 theFeature->attribute(SketchPlugin_Arc::START_ID()))->pnt();
689 std::shared_ptr<GeomAPI_Pnt2d> aPntEnd = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
690 theFeature->attribute(SketchPlugin_Arc::END_ID()))->pnt();
691 if(theFeature->attribute(SketchPlugin_Arc::INVERSED_ID())) {
692 aPntTemp = aPntStart;
696 std::shared_ptr<GeomAPI_Pnt2d> aCenterPnt = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
697 theFeature->attribute(SketchPlugin_Arc::CENTER_ID()))->pnt();
698 std::shared_ptr<GeomAPI_Circ2d> aCirc(new GeomAPI_Circ2d(aCenterPnt, aPntStart));
699 double aStartParameter(0), anEndParameter(0);
700 aCirc->parameter(aPntStart, paramTolerance, aStartParameter);
701 aCirc->parameter(aPntEnd, paramTolerance, anEndParameter);
702 if(aPntStart->distance(theFilletPoint) > tolerance) {
703 double aTmpParameter = aStartParameter;
704 aStartParameter = anEndParameter;
705 anEndParameter = aTmpParameter;
707 double aPntParameter = aStartParameter + (anEndParameter - aStartParameter) / 3.0;
708 aCirc->D0(aPntParameter, thePoint);
712 double getProjectionDistance(const FeaturePtr theFeature,
713 const std::shared_ptr<GeomAPI_Pnt2d> thePoint)
715 std::shared_ptr<GeomAPI_Pnt2d> aProjectPnt;
716 if(theFeature->getKind() == SketchPlugin_Line::ID()) {
717 std::shared_ptr<GeomAPI_Pnt2d> aPntStart = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
718 theFeature->attribute(SketchPlugin_Line::START_ID()))->pnt();
719 std::shared_ptr<GeomAPI_Pnt2d> aPntEnd = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
720 theFeature->attribute(SketchPlugin_Line::END_ID()))->pnt();
721 std::shared_ptr<GeomAPI_Lin2d> aLin(new GeomAPI_Lin2d(aPntStart, aPntEnd));
722 aProjectPnt = aLin->project(thePoint);
724 std::shared_ptr<GeomAPI_Pnt2d> aPntStart = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
725 theFeature->attribute(SketchPlugin_Arc::START_ID()))->pnt();
726 std::shared_ptr<GeomAPI_Pnt2d> aPntEnd = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
727 theFeature->attribute(SketchPlugin_Arc::END_ID()))->pnt();
728 std::shared_ptr<GeomAPI_Pnt2d> aCenterPnt = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
729 theFeature->attribute(SketchPlugin_Arc::CENTER_ID()))->pnt();
730 std::shared_ptr<GeomAPI_Circ2d> aCirc(new GeomAPI_Circ2d(aCenterPnt, aPntStart));
731 aProjectPnt = aCirc->project(thePoint);
733 if(aProjectPnt.get()) {
734 return aProjectPnt->distance(thePoint);
739 std::set<FeaturePtr> getCoincides(const FeaturePtr& theConstraintCoincidence)
741 std::set<FeaturePtr> aCoincides;
743 std::shared_ptr<GeomAPI_Pnt2d> aFilletPnt = SketchPlugin_Tools::getCoincidencePoint(theConstraintCoincidence);
745 SketchPlugin_Tools::findCoincidences(theConstraintCoincidence,
746 SketchPlugin_ConstraintCoincidence::ENTITY_A(),
748 SketchPlugin_Tools::findCoincidences(theConstraintCoincidence,
749 SketchPlugin_ConstraintCoincidence::ENTITY_B(),
752 // Remove points from set of coincides.
753 std::set<FeaturePtr> aNewSetOfCoincides;
754 for(std::set<FeaturePtr>::iterator anIt = aCoincides.begin(); anIt != aCoincides.end(); ++anIt) {
755 if((*anIt)->getKind() == SketchPlugin_Line::ID()) {
756 aNewSetOfCoincides.insert(*anIt);
757 } else if((*anIt)->getKind() == SketchPlugin_Arc::ID()) {
758 AttributePtr anAttrCenter = (*anIt)->attribute(SketchPlugin_Arc::CENTER_ID());
759 std::shared_ptr<GeomDataAPI_Point2D> aPointCenter2D =
760 std::dynamic_pointer_cast<GeomDataAPI_Point2D>(anAttrCenter);
761 if(aPointCenter2D.get() && aFilletPnt->isEqual(aPointCenter2D->pnt())) {
764 aNewSetOfCoincides.insert(*anIt);
767 aCoincides = aNewSetOfCoincides;
769 // If we still have more than two coincides remove auxilary entities from set of coincides.
770 if(aCoincides.size() > 2) {
771 aNewSetOfCoincides.clear();
772 for(std::set<FeaturePtr>::iterator anIt = aCoincides.begin(); anIt != aCoincides.end(); ++anIt) {
773 if(!(*anIt)->boolean(SketchPlugin_SketchEntity::AUXILIARY_ID())->value()) {
774 aNewSetOfCoincides.insert(*anIt);
777 aCoincides = aNewSetOfCoincides;
784 std::shared_ptr<GeomDataAPI_Point2D> SketchPlugin_ConstraintSplit::getPointOfRefAttr(
785 const AttributePtr& theAttribute)
787 AttributePoint2DPtr aPointAttribute;
789 if (theAttribute->attributeType() == ModelAPI_AttributeRefAttr::typeId()) {
790 AttributeRefAttrPtr aRefAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(theAttribute);
791 if (aRefAttr.get() && aRefAttr->isInitialized()) {
792 AttributePtr anAttribute = aRefAttr->attr();
793 if (anAttribute.get() && anAttribute->attributeType() == GeomDataAPI_Point2D::typeId())
794 aPointAttribute = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(anAttribute);
797 return aPointAttribute;
800 void SketchPlugin_ConstraintSplit::getFeaturePoints(AttributePoint2DPtr& theStartPointAttr,
801 AttributePoint2DPtr& theEndPointAttr)
803 AttributePoint2DPtr aPointAttribute;
805 AttributeReferencePtr aBaseObjectAttr = std::dynamic_pointer_cast<ModelAPI_AttributeReference>(
806 data()->attribute(SketchPlugin_Constraint::VALUE()));
807 FeaturePtr aBaseFeature = ModelAPI_Feature::feature(aBaseObjectAttr->value());
809 std::string aFeatureKind = aBaseFeature->getKind();
810 std::string aStartAttributeName, anEndAttributeName;
811 if (aFeatureKind == SketchPlugin_Line::ID()) {
812 aStartAttributeName = SketchPlugin_Line::START_ID();
813 anEndAttributeName = SketchPlugin_Line::END_ID();
815 else if (aFeatureKind == SketchPlugin_Arc::ID()) {
816 aStartAttributeName = SketchPlugin_Arc::START_ID();
817 anEndAttributeName = SketchPlugin_Arc::END_ID();
819 if (!aStartAttributeName.empty() && !anEndAttributeName.empty()) {
820 theStartPointAttr = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
821 aBaseFeature->attribute(aStartAttributeName));
822 theEndPointAttr = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
823 aBaseFeature->attribute(anEndAttributeName));
827 void SketchPlugin_ConstraintSplit::splitArc(FeaturePtr& theSplitFeature,
828 FeaturePtr& theBeforeFeature,
829 FeaturePtr& theAfterFeature)
831 SketchPlugin_Sketch* aSketch = sketch();
835 AttributeReferencePtr aBaseObjectAttr = std::dynamic_pointer_cast<ModelAPI_AttributeReference>(
836 data()->attribute(SketchPlugin_Constraint::VALUE()));
837 FeaturePtr aBaseFeature = ModelAPI_Feature::feature(aBaseObjectAttr->value());
838 std::string aFeatureKind = aBaseFeature->getKind();
839 if (aFeatureKind != SketchPlugin_Arc::ID())
842 AttributePoint2DPtr aFirstPointAttr = getPointOfRefAttr(data()->attribute(SketchPlugin_Constraint::ENTITY_A()));
843 AttributePoint2DPtr aSecondPointAttr = getPointOfRefAttr(data()->attribute(SketchPlugin_Constraint::ENTITY_B()));
844 AttributePoint2DPtr aStartPointAttr, anEndPointAttr;
845 getFeaturePoints(aStartPointAttr, anEndPointAttr);
846 if (!aStartPointAttr.get() && !anEndPointAttr.get()) {
847 setError("Error: Feature has no start and end points.");
851 arrangePoints(aStartPointAttr, anEndPointAttr, aFirstPointAttr, aSecondPointAttr);
854 theSplitFeature = aSketch->addFeature(aFeatureKind);
855 theSplitFeature->string(SketchPlugin_Arc::ARC_TYPE())->setValue(
856 SketchPlugin_Arc::ARC_TYPE_CENTER_START_END());
857 fillAttribute(theSplitFeature->attribute(SketchPlugin_Arc::CENTER_ID()),
858 aBaseFeature->attribute(SketchPlugin_Arc::CENTER_ID()));
859 fillAttribute(theSplitFeature->attribute(SketchPlugin_Arc::START_ID()), aFirstPointAttr);
860 fillAttribute(theSplitFeature->attribute(SketchPlugin_Arc::END_ID()), aSecondPointAttr);
861 theSplitFeature->execute(); /// to use result of the feature in constraint
863 if (!aStartPointAttr->pnt()->isEqual(aFirstPointAttr->pnt())) {
864 theBeforeFeature = aBaseFeature; ///< use base feature to store all constraints here
865 /// move end arc point to start of split
866 fillAttribute(theBeforeFeature->attribute(SketchPlugin_Arc::END_ID()), aFirstPointAttr);
867 createConstraint(SketchPlugin_ConstraintCoincidence::ID(),
868 theBeforeFeature->attribute(SketchPlugin_Arc::END_ID()),
869 theSplitFeature->attribute(SketchPlugin_Arc::START_ID()));
872 if (!aSecondPointAttr->pnt()->isEqual(anEndPointAttr->pnt())) {
873 if (!theBeforeFeature) {
874 theAfterFeature = aBaseFeature; ///< use base feature to store all constraints here
875 fillAttribute(theBeforeFeature->attribute(SketchPlugin_Arc::START_ID()), aSecondPointAttr);
878 theAfterFeature = aSketch->addFeature(aFeatureKind);
879 theAfterFeature->string(SketchPlugin_Arc::ARC_TYPE())->setValue(
880 SketchPlugin_Arc::ARC_TYPE_CENTER_START_END());
881 fillAttribute(theAfterFeature->attribute(SketchPlugin_Arc::CENTER_ID()),
882 aBaseFeature->attribute(SketchPlugin_Arc::CENTER_ID()));
883 fillAttribute(theAfterFeature->attribute(SketchPlugin_Arc::START_ID()), aSecondPointAttr);
884 fillAttribute(theAfterFeature->attribute(SketchPlugin_Arc::END_ID()), anEndPointAttr);
885 theAfterFeature->execute(); /// to use result of the feature in constraint
887 createConstraint(SketchPlugin_ConstraintCoincidence::ID(),
888 theSplitFeature->attribute(SketchPlugin_Arc::END_ID()),
889 theAfterFeature->attribute(SketchPlugin_Arc::START_ID()));
892 // additional constraints between split and base features
893 createConstraint(SketchPlugin_ConstraintEqual::ID(), getFeatureResult(aBaseFeature),
894 getFeatureResult(theSplitFeature));
895 createConstraint(SketchPlugin_ConstraintTangent::ID(), getFeatureResult(theSplitFeature),
896 getFeatureResult(aBaseFeature));
897 if (theAfterFeature.get()) {
898 createConstraint(SketchPlugin_ConstraintEqual::ID(), getFeatureResult(aBaseFeature),
899 getFeatureResult(theAfterFeature));
900 createConstraint(SketchPlugin_ConstraintTangent::ID(), getFeatureResult(theSplitFeature),
901 getFeatureResult(theAfterFeature));
905 void SketchPlugin_ConstraintSplit::arrangePoints(const AttributePoint2DPtr& theStartPointAttr,
906 const AttributePoint2DPtr& theEndPointAttr,
907 AttributePoint2DPtr& theFirstPointAttr,
908 AttributePoint2DPtr& theLastPointAttr)
910 /// if first point is closer to last point, wrap first and last values
911 if (theStartPointAttr->pnt()->distance(theFirstPointAttr->pnt()) >
912 theEndPointAttr->pnt()->distance(theLastPointAttr->pnt())) {
913 AttributePoint2DPtr aTmpPoint = theFirstPointAttr;
914 theFirstPointAttr = theLastPointAttr;
915 theLastPointAttr = aTmpPoint;
919 void SketchPlugin_ConstraintSplit::fillAttribute(const AttributePtr& theModifiedAttribute,
920 const AttributePtr& theSourceAttribute)
922 AttributePoint2DPtr aModifiedAttribute = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
923 theModifiedAttribute);
924 AttributePoint2DPtr aSourceAttribute = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
927 if (aModifiedAttribute.get() && aSourceAttribute.get())
928 aSourceAttribute->setValue(aModifiedAttribute->pnt());
931 void SketchPlugin_ConstraintSplit::createConstraint(const std::string& theConstraintId,
932 const AttributePtr& theFirstAttribute,
933 const AttributePtr& theSecondAttribute)
935 FeaturePtr aConstraint = sketch()->addFeature(theConstraintId);
936 AttributeRefAttrPtr aRefAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(
937 aConstraint->attribute(SketchPlugin_Constraint::ENTITY_A()));
938 aRefAttr->setAttr(theFirstAttribute);
940 aRefAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(
941 aConstraint->attribute(SketchPlugin_Constraint::ENTITY_B()));
942 aRefAttr->setAttr(theSecondAttribute);
945 void SketchPlugin_ConstraintSplit::createConstraint(const std::string& theConstraintId,
946 const ObjectPtr& theFirstObject,
947 const ObjectPtr& theSecondObject)
949 FeaturePtr aConstraint = sketch()->addFeature(theConstraintId);
950 AttributeRefAttrPtr aRefAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(
951 aConstraint->attribute(SketchPlugin_Constraint::ENTITY_A()));
952 aRefAttr->setObject(theFirstObject);
954 aRefAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(
955 aConstraint->attribute(SketchPlugin_Constraint::ENTITY_B()));
956 aRefAttr->setObject(theSecondObject);
959 std::shared_ptr<ModelAPI_Object> SketchPlugin_ConstraintSplit::getFeatureResult(
960 const std::shared_ptr<ModelAPI_Feature>& theFeature)
962 std::shared_ptr<ModelAPI_Object> aResult;
964 std::string aFeatureKind = theFeature->getKind();
965 if (aFeatureKind == SketchPlugin_Line::ID())
966 aResult = theFeature->firstResult();
967 else if (aFeatureKind == SketchPlugin_Arc::ID())
968 aResult = theFeature->lastResult();
969 else if (aFeatureKind == SketchPlugin_Circle::ID())
970 aResult = theFeature->lastResult();