Salome HOME
#858 'Tangency' constraint doesn't work
[modules/shaper.git] / src / SketchPlugin / SketchPlugin_ConstraintAngle.cpp
1 // Copyright (C) 2014-20xx CEA/DEN, EDF R&D -->
2
3 // File:    SketchPlugin_ConstraintAngle.cpp
4 // Created: 19 August 2015
5 // Author:  Artem ZHIDKOV
6
7 #include "SketchPlugin_ConstraintAngle.h"
8 #include <SketchPlugin_Line.h>
9
10 #include <ModelAPI_AttributeDouble.h>
11 #include <GeomDataAPI_Point2D.h>
12
13 #include <GeomAPI_Dir2d.h>
14 #include <GeomAPI_Lin2d.h>
15 #include <GeomAPI_Pnt2d.h>
16 #include <GeomAPI_XY.h>
17
18 #include <SketcherPrs_Factory.h>
19 #include <SketcherPrs_Tools.h>
20
21 #include <math.h>
22
23 const double tolerance = 1.e-7;
24 #define PI 3.1415926535897932
25
26 /// \brief Calculate intersection point of two lines
27 static std::shared_ptr<GeomAPI_Pnt2d> intersect(FeaturePtr theLine1, FeaturePtr theLine2);
28
29
30 SketchPlugin_ConstraintAngle::SketchPlugin_ConstraintAngle()
31 {
32   myFlyoutUpdate = false;
33 }
34
35 void SketchPlugin_ConstraintAngle::initAttributes()
36 {
37   data()->addAttribute(SketchPlugin_Constraint::VALUE(), ModelAPI_AttributeDouble::typeId());
38   data()->addAttribute(SketchPlugin_Constraint::ENTITY_A(), ModelAPI_AttributeRefAttr::typeId());
39   data()->addAttribute(SketchPlugin_Constraint::ENTITY_B(), ModelAPI_AttributeRefAttr::typeId());
40   data()->addAttribute(SketchPlugin_Constraint::FLYOUT_VALUE_PNT(), GeomDataAPI_Point2D::typeId());
41 }
42
43 void SketchPlugin_ConstraintAngle::execute()
44 {
45   std::shared_ptr<ModelAPI_Data> aData = data();
46
47   std::shared_ptr<ModelAPI_AttributeRefAttr> anAttrA = aData->refattr(SketchPlugin_Constraint::ENTITY_A());
48   std::shared_ptr<ModelAPI_AttributeRefAttr> anAttrB = aData->refattr(SketchPlugin_Constraint::ENTITY_B());
49   if (!anAttrA->isInitialized() || !anAttrB->isInitialized())
50     return;
51
52   AttributeDoublePtr anAttrValue = std::dynamic_pointer_cast<ModelAPI_AttributeDouble>(
53       aData->attribute(SketchPlugin_Constraint::VALUE()));
54
55   if (!anAttrValue->isInitialized()) {
56     double anAngle = calculateAngle();
57     anAttrValue->setValue(anAngle);
58   }
59   // the value should to be computed here, not in the getAISObject in order to change the model value
60   // inside the object transaction. This is important for creating a constraint by preselection.
61   // The display of the presentation in this case happens after the transaction commit
62   std::shared_ptr<GeomDataAPI_Point2D> aFlyOutAttr = std::dynamic_pointer_cast<
63       GeomDataAPI_Point2D>(aData->attribute(SketchPlugin_Constraint::FLYOUT_VALUE_PNT()));
64   if(!aFlyOutAttr->isInitialized())
65     compute(SketchPlugin_Constraint::FLYOUT_VALUE_PNT());
66 }
67
68 AISObjectPtr SketchPlugin_ConstraintAngle::getAISObject(AISObjectPtr thePrevious)
69 {
70   if (!sketch())
71     return thePrevious;
72
73   AISObjectPtr anAIS = thePrevious;
74   if (!anAIS) {
75     anAIS = SketcherPrs_Factory::angleConstraint(this, sketch()->coordinatePlane());
76   }
77
78   // Set color from preferences
79   std::vector<int> aRGB = Config_PropManager::color("Visualization", "sketch_dimension_color",
80                                                     SKETCH_DIMENSION_COLOR);
81   anAIS->setColor(aRGB[0], aRGB[1], aRGB[2]);
82   return anAIS;
83 }
84
85 void SketchPlugin_ConstraintAngle::attributeChanged(const std::string& theID)
86 {
87   std::shared_ptr<ModelAPI_Data> aData = data();
88   if (!aData)
89     return;
90   FeaturePtr aLineA = SketcherPrs_Tools::getFeatureLine(aData, SketchPlugin_Constraint::ENTITY_A());
91   FeaturePtr aLineB = SketcherPrs_Tools::getFeatureLine(aData, SketchPlugin_Constraint::ENTITY_B());
92   if (!aLineA || !aLineB)
93     return;
94
95   if (theID == SketchPlugin_Constraint::ENTITY_A() || 
96       theID == SketchPlugin_Constraint::ENTITY_B()) {
97     std::shared_ptr<ModelAPI_AttributeDouble> aValueAttr = std::dynamic_pointer_cast<
98         ModelAPI_AttributeDouble>(data()->attribute(SketchPlugin_Constraint::VALUE()));
99     if (!aValueAttr->isInitialized()) { // only if it is not initialized, try to compute the current value
100       double anAngle = calculateAngle();
101       aValueAttr->setValue(anAngle);
102     }
103   } else if (theID == SketchPlugin_Constraint::FLYOUT_VALUE_PNT() && !myFlyoutUpdate) {
104     // Recalculate flyout point in local coordinates
105     // coordinates are calculated according to the center of shapes intersection
106     std::shared_ptr<GeomDataAPI_Point2D> aFlyoutAttr =
107         std::dynamic_pointer_cast<GeomDataAPI_Point2D>(attribute(SketchPlugin_Constraint::FLYOUT_VALUE_PNT()));
108
109     std::shared_ptr<ModelAPI_Data> aData = data();
110     std::shared_ptr<GeomAPI_Ax3> aPlane = SketchPlugin_Sketch::plane(sketch());
111     FeaturePtr aLineA = SketcherPrs_Tools::getFeatureLine(aData, SketchPlugin_Constraint::ENTITY_A());
112     FeaturePtr aLineB = SketcherPrs_Tools::getFeatureLine(aData, SketchPlugin_Constraint::ENTITY_B());
113
114     // Intersection of lines
115     std::shared_ptr<GeomAPI_Pnt2d> anInter = intersect(aLineA, aLineB);
116     if (!anInter)
117       return;
118
119     myFlyoutUpdate = true;
120     std::shared_ptr<GeomAPI_XY> aFlyoutDir = aFlyoutAttr->pnt()->xy()->decreased(anInter->xy());
121     if (aFlyoutDir->dot(aFlyoutDir) < tolerance * tolerance)
122       aFlyoutAttr->setValue(aFlyoutAttr->x() + tolerance, aFlyoutAttr->y());
123     myFlyoutUpdate = false;
124   }
125 }
126
127 double SketchPlugin_ConstraintAngle::calculateAngle()
128 {
129   double anAngle = 0.0;
130
131   std::shared_ptr<ModelAPI_Data> aData = data();
132   std::shared_ptr<GeomAPI_Ax3> aPlane = SketchPlugin_Sketch::plane(sketch());
133   FeaturePtr aLineA = SketcherPrs_Tools::getFeatureLine(aData, SketchPlugin_Constraint::ENTITY_A());
134   FeaturePtr aLineB = SketcherPrs_Tools::getFeatureLine(aData, SketchPlugin_Constraint::ENTITY_B());
135
136   // Intersection of lines
137   std::shared_ptr<GeomAPI_Pnt2d> anInter = intersect(aLineA, aLineB);
138   if (!anInter)
139     return anAngle;
140
141   // Start and end points of lines
142   std::shared_ptr<GeomDataAPI_Point2D> aPointA1 = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
143       aLineA->attribute(SketchPlugin_Line::START_ID()));
144   std::shared_ptr<GeomDataAPI_Point2D> aPointA2 = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
145       aLineA->attribute(SketchPlugin_Line::END_ID()));
146
147   std::shared_ptr<GeomDataAPI_Point2D> aPointB1 = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
148       aLineB->attribute(SketchPlugin_Line::START_ID()));
149   std::shared_ptr<GeomDataAPI_Point2D> aPointB2 = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
150       aLineB->attribute(SketchPlugin_Line::END_ID()));
151
152   std::shared_ptr<GeomAPI_Pnt2d> aStartA = aPointA1->pnt();
153   std::shared_ptr<GeomAPI_Pnt2d> aEndA   = aPointA2->pnt();
154   std::shared_ptr<GeomAPI_Pnt2d> aStartB = aPointB1->pnt();
155   std::shared_ptr<GeomAPI_Pnt2d> aEndB   = aPointB2->pnt();
156
157   // Directions of lines
158   if (anInter->distance(aEndA) < tolerance)
159     aEndA = aStartA;
160   if (anInter->distance(aEndB) < tolerance)
161     aEndB = aStartB;
162   std::shared_ptr<GeomAPI_Dir2d> aDirA(new GeomAPI_Dir2d(aEndA->xy()->decreased(anInter->xy())));
163   std::shared_ptr<GeomAPI_Dir2d> aDirB(new GeomAPI_Dir2d(aEndB->xy()->decreased(anInter->xy())));
164
165   anAngle = aDirA->angle(aDirB) * 180.0 / PI;
166   return anAngle;
167 }
168
169 void SketchPlugin_ConstraintAngle::move(double theDeltaX, double theDeltaY)
170 {
171   std::shared_ptr<ModelAPI_Data> aData = data();
172   if (!aData->isValid())
173     return;
174
175   myFlyoutUpdate = true;
176   std::shared_ptr<GeomDataAPI_Point2D> aFlyoutAttr = std::dynamic_pointer_cast<
177       GeomDataAPI_Point2D>(aData->attribute(SketchPlugin_Constraint::FLYOUT_VALUE_PNT()));
178   aFlyoutAttr->setValue(aFlyoutAttr->x() + theDeltaX, aFlyoutAttr->y() + theDeltaY);
179   myFlyoutUpdate = false;
180 }
181
182
183 bool SketchPlugin_ConstraintAngle::compute(const std::string& theAttributeId)
184 {
185   if (theAttributeId != SketchPlugin_Constraint::FLYOUT_VALUE_PNT())
186     return false;
187   if (!sketch())
188     return false;
189
190   std::shared_ptr<GeomDataAPI_Point2D> aFlyOutAttr = std::dynamic_pointer_cast<
191                            GeomDataAPI_Point2D>(attribute(theAttributeId));
192   if (fabs(aFlyOutAttr->x()) >= tolerance || fabs(aFlyOutAttr->y()) >= tolerance)
193     return false;
194
195   DataPtr aData = data();
196   std::shared_ptr<GeomAPI_Ax3> aPlane = SketchPlugin_Sketch::plane(sketch());
197   FeaturePtr aLineA = SketcherPrs_Tools::getFeatureLine(aData, SketchPlugin_Constraint::ENTITY_A());
198   FeaturePtr aLineB = SketcherPrs_Tools::getFeatureLine(aData, SketchPlugin_Constraint::ENTITY_B());
199
200   if ((aLineA.get() == NULL) || (aLineB.get() == NULL))
201     return false;
202
203   // Start and end points of lines
204   std::shared_ptr<GeomDataAPI_Point2D> aPointA1 = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
205       aLineA->attribute(SketchPlugin_Line::START_ID()));
206   std::shared_ptr<GeomDataAPI_Point2D> aPointA2 = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
207       aLineA->attribute(SketchPlugin_Line::END_ID()));
208
209   std::shared_ptr<GeomAPI_Pnt2d> aStartA = aPointA1->pnt();
210   std::shared_ptr<GeomAPI_Pnt2d> aEndA   = aPointA2->pnt();
211   if (aStartA->distance(aEndA) < tolerance)
212     return false;
213
214   myFlyoutUpdate = true;
215   double aX = (aStartA->x() + aEndA->x()) / 2.;
216   double aY = (aStartA->y() + aEndA->y()) / 2.;
217
218   aFlyOutAttr->setValue(aX, aY);
219   myFlyoutUpdate = false;
220
221   return true;
222 }
223
224
225 // ===============   Auxiliary functions   ==================================
226 std::shared_ptr<GeomAPI_Pnt2d> intersect(FeaturePtr theLine1, FeaturePtr theLine2)
227 {
228   // Start and end points of lines
229   std::shared_ptr<GeomDataAPI_Point2D> aPointA1 = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
230       theLine1->attribute(SketchPlugin_Line::START_ID()));
231   std::shared_ptr<GeomDataAPI_Point2D> aPointA2 = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
232       theLine1->attribute(SketchPlugin_Line::END_ID()));
233
234   std::shared_ptr<GeomDataAPI_Point2D> aPointB1 = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
235       theLine2->attribute(SketchPlugin_Line::START_ID()));
236   std::shared_ptr<GeomDataAPI_Point2D> aPointB2 = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
237       theLine2->attribute(SketchPlugin_Line::END_ID()));
238
239   std::shared_ptr<GeomAPI_Pnt2d> aStartA = aPointA1->pnt();
240   std::shared_ptr<GeomAPI_Pnt2d> aEndA   = aPointA2->pnt();
241   std::shared_ptr<GeomAPI_Pnt2d> aStartB = aPointB1->pnt();
242   std::shared_ptr<GeomAPI_Pnt2d> aEndB   = aPointB2->pnt();
243   if (aStartA->distance(aEndA) < tolerance || aStartB->distance(aEndB) < tolerance)
244     std::shared_ptr<GeomAPI_Pnt2d>();
245
246   // Lines and their intersection point
247   std::shared_ptr<GeomAPI_Lin2d> aLA(new GeomAPI_Lin2d(aStartA, aEndA));
248   std::shared_ptr<GeomAPI_Lin2d> aLB(new GeomAPI_Lin2d(aStartB, aEndB));
249   return aLA->intersect(aLB);
250 }