]> SALOME platform Git repositories - modules/shaper.git/blob - src/FeaturesPlugin/FeaturesPlugin_Measurement.cpp
Salome HOME
Reverted some changes in salome build/run scripts.
[modules/shaper.git] / src / FeaturesPlugin / FeaturesPlugin_Measurement.cpp
1 // Copyright (C) 2018-20xx  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 "FeaturesPlugin_Measurement.h"
22
23 #include <ModelAPI_AttributeDoubleArray.h>
24 #include <ModelAPI_AttributeSelection.h>
25 #include <ModelAPI_AttributeString.h>
26 #include <ModelAPI_Data.h>
27 #include <ModelAPI_Session.h>
28
29 #include <GeomAPI_Angle.h>
30 #include <GeomAPI_Circ.h>
31 #include <GeomAPI_Edge.h>
32 #include <GeomAPI_Face.h>
33 #include <GeomAPI_Pnt.h>
34 #include <GeomAPI_Shape.h>
35 #include <GeomAPI_ShapeIterator.h>
36 #include <GeomAPI_Vertex.h>
37
38 #include <GeomAlgoAPI_ShapeTools.h>
39
40 #include <Config_PropManager.h>
41
42 #include <TopoDS.hxx>
43 #include <TopoDS_Edge.hxx>
44 #include <TopoDS_Shape.hxx>
45 #include <AIS_LengthDimension.hxx>
46 #include <AIS_RadiusDimension.hxx>
47 #include <AIS_AngleDimension.hxx>
48 #include <BRepExtrema_DistShapeShape.hxx>
49
50 #include <iomanip>
51 #include <sstream>
52
53 FeaturesPlugin_Measurement::FeaturesPlugin_Measurement() : mySceenScale(1)
54 {
55 }
56
57 void FeaturesPlugin_Measurement::initAttributes()
58 {
59   data()->addAttribute(FeaturesPlugin_Measurement::MEASURE_KIND(),
60                        ModelAPI_AttributeString::typeId());
61
62   // attribute for length
63   data()->addAttribute(EDGE_FOR_LENGTH_ID(), ModelAPI_AttributeSelection::typeId());
64   // attributes for distance
65   data()->addAttribute(DISTANCE_FROM_OBJECT_ID(), ModelAPI_AttributeSelection::typeId());
66   data()->addAttribute(DISTANCE_TO_OBJECT_ID(), ModelAPI_AttributeSelection::typeId());
67   // attribute for radius
68   data()->addAttribute(CIRCULAR_OBJECT_ID(), ModelAPI_AttributeSelection::typeId());
69   // attributes for angle
70   data()->addAttribute(ANGLE_FROM_EDGE_ID(), ModelAPI_AttributeSelection::typeId());
71   data()->addAttribute(ANGLE_TO_EDGE_ID(), ModelAPI_AttributeSelection::typeId());
72   // attributes for angle by 3 points
73   data()->addAttribute(ANGLE_POINT1_ID(), ModelAPI_AttributeSelection::typeId());
74   data()->addAttribute(ANGLE_POINT2_ID(), ModelAPI_AttributeSelection::typeId());
75   data()->addAttribute(ANGLE_POINT3_ID(), ModelAPI_AttributeSelection::typeId());
76   // attributes for result message and values
77   data()->addAttribute(RESULT_ID(), ModelAPI_AttributeString::typeId());
78   data()->addAttribute(RESULT_VALUES_ID(), ModelAPI_AttributeDoubleArray::typeId());
79 }
80
81 void FeaturesPlugin_Measurement::execute()
82 {
83 }
84
85 void FeaturesPlugin_Measurement::attributeChanged(const std::string& theID)
86 {
87   if (theID == MEASURE_KIND()) {
88     // clear results
89     string(RESULT_ID())->setValue("");
90     std::dynamic_pointer_cast<ModelAPI_AttributeDoubleArray>(
91       attribute(RESULT_VALUES_ID()))->setSize(0);
92   }
93   if (theID != RESULT_ID()) {
94     std::string aKind = string(MEASURE_KIND())->value();
95     if (aKind == MEASURE_LENGTH())
96       computeLength();
97     else if (aKind == MEASURE_DISTANCE())
98       computeDistance();
99     else if (aKind == MEASURE_RADIUS())
100       computeRadius();
101     else if (aKind == MEASURE_ANGLE())
102       computeAngle();
103     else if (aKind == MEASURE_ANGLE_POINTS())
104       computeAngleByPoints();
105   }
106 }
107
108 void FeaturesPlugin_Measurement::computeLength()
109 {
110   AttributeSelectionPtr aSelectedFeature = selection(EDGE_FOR_LENGTH_ID());
111
112   GeomShapePtr aShape;
113   GeomEdgePtr anEdge;
114   if (aSelectedFeature && aSelectedFeature->isInitialized()) {
115     aShape = aSelectedFeature->value();
116     if (!aShape && aSelectedFeature->context())
117       aShape = aSelectedFeature->context()->shape();
118   }
119   if (aShape && aShape->isEdge())
120     anEdge = GeomEdgePtr(new GeomAPI_Edge(aShape));
121   if (!anEdge) {
122     string(RESULT_ID())->setValue("");
123     return;
124   }
125
126   std::ostringstream anOutput;
127   anOutput << "Length = " << std::setprecision(10) << anEdge->length();
128   string(RESULT_ID())->setValue(anOutput.str());
129
130   AttributeDoubleArrayPtr aValues =
131       std::dynamic_pointer_cast<ModelAPI_AttributeDoubleArray>(attribute(RESULT_VALUES_ID()));
132   aValues->setSize(1);
133   aValues->setValue(0, anEdge->length());
134 }
135
136 void FeaturesPlugin_Measurement::computeDistance()
137 {
138   AttributeSelectionPtr aFirstFeature = selection(DISTANCE_FROM_OBJECT_ID());
139   GeomShapePtr aShape1;
140   if (aFirstFeature && aFirstFeature->isInitialized()) {
141     aShape1 = aFirstFeature->value();
142     if (!aShape1 && aFirstFeature->context())
143       aShape1 = aFirstFeature->context()->shape();
144   }
145
146   AttributeSelectionPtr aSecondFeature = selection(DISTANCE_TO_OBJECT_ID());
147   GeomShapePtr aShape2;
148   if (aSecondFeature && aSecondFeature->isInitialized()) {
149     aShape2 = aSecondFeature->value();
150     if (!aShape2 && aSecondFeature->context())
151       aShape2 = aSecondFeature->context()->shape();
152   }
153
154   if (!aShape1 || !aShape2) {
155     string(RESULT_ID())->setValue("");
156     return;
157   }
158
159   double aDistance = GeomAlgoAPI_ShapeTools::minimalDistance(aShape1, aShape2);
160
161   std::ostringstream anOutput;
162   anOutput << "Distance = " << std::setprecision(10) << aDistance;
163   string(RESULT_ID())->setValue(anOutput.str());
164
165   AttributeDoubleArrayPtr aValues =
166       std::dynamic_pointer_cast<ModelAPI_AttributeDoubleArray>(attribute(RESULT_VALUES_ID()));
167   aValues->setSize(1);
168   aValues->setValue(0, aDistance);
169 }
170
171 void FeaturesPlugin_Measurement::computeRadius()
172 {
173   AttributeSelectionPtr aSelectedFeature = selection(CIRCULAR_OBJECT_ID());
174
175   GeomShapePtr aShape;
176   if (aSelectedFeature && aSelectedFeature->isInitialized()) {
177     aShape = aSelectedFeature->value();
178     if (!aShape && aSelectedFeature->context())
179       aShape = aSelectedFeature->context()->shape();
180   }
181
182   double aRadius = -1.0;
183   if (aShape) {
184     if (aShape->isEdge()) {
185       GeomEdgePtr anEdge(new GeomAPI_Edge(aShape));
186       if (anEdge->isCircle() || anEdge->isArc()) {
187         aRadius = anEdge->circle()->radius();
188       }
189     } else if (aShape->isFace()) {
190       GeomFacePtr aFace(new GeomAPI_Face(aShape));
191       aRadius = GeomAlgoAPI_ShapeTools::radius(aFace);
192     }
193   }
194
195   if (aRadius < 0.0) {
196     string(RESULT_ID())->setValue("");
197     return;
198   }
199
200   std::ostringstream anOutput;
201   anOutput << "Radius = " << std::setprecision(10) << aRadius;
202   string(RESULT_ID())->setValue(anOutput.str());
203
204   AttributeDoubleArrayPtr aValues =
205       std::dynamic_pointer_cast<ModelAPI_AttributeDoubleArray>(attribute(RESULT_VALUES_ID()));
206   aValues->setSize(1);
207   aValues->setValue(0, aRadius);
208 }
209
210 void FeaturesPlugin_Measurement::computeAngle()
211 {
212   AttributeSelectionPtr aFirstFeature = selection(ANGLE_FROM_EDGE_ID());
213   GeomShapePtr aShape1;
214   GeomEdgePtr anEdge1;
215   if (aFirstFeature && aFirstFeature->isInitialized()) {
216     aShape1 = aFirstFeature->value();
217     if (!aShape1 && aFirstFeature->context())
218       aShape1 = aFirstFeature->context()->shape();
219   }
220   if (aShape1 && aShape1->isEdge())
221     anEdge1 = GeomEdgePtr(new GeomAPI_Edge(aShape1));
222
223   AttributeSelectionPtr aSecondFeature = selection(ANGLE_TO_EDGE_ID());
224   GeomShapePtr aShape2;
225   GeomEdgePtr anEdge2;
226   if (aSecondFeature && aSecondFeature->isInitialized()) {
227     aShape2 = aSecondFeature->value();
228     if (!aShape2 && aSecondFeature->context())
229       aShape2 = aSecondFeature->context()->shape();
230   }
231   if (aShape2 && aShape2->isEdge())
232     anEdge2 = GeomEdgePtr(new GeomAPI_Edge(aShape2));
233
234   if (!anEdge1 || !anEdge2) {
235     string(RESULT_ID())->setValue("");
236     return;
237   }
238
239   GeomShapePtr anInter = anEdge1->intersect(anEdge2);
240
241   std::ostringstream anOutput;
242   anOutput << std::setprecision(10);
243   std::list<double> aValuesList;
244   if (anInter) {
245     if (anInter->isVertex()) {
246       std::shared_ptr<GeomAPI_Vertex> aVertex(new GeomAPI_Vertex(anInter));
247       std::shared_ptr<GeomAPI_Angle> anAngle(
248           new GeomAPI_Angle(anEdge1, anEdge2, aVertex->point()));
249       double anAngleValue = anAngle->angleDegree();
250       anOutput << "Angle = " << std::setprecision(10) << anAngleValue << std::endl;
251       aValuesList.push_back(anAngleValue);
252     }
253     else {
254       GeomAPI_ShapeIterator anIt(anInter);
255       for (int anIndex = 1; anIt.more(); anIt.next(), ++anIndex) {
256         GeomShapePtr aCurrent = anIt.current();
257         if (!aCurrent->isVertex())
258           continue;
259         std::shared_ptr<GeomAPI_Vertex> aVertex(new GeomAPI_Vertex(aCurrent));
260         std::shared_ptr<GeomAPI_Angle> anAngle(
261             new GeomAPI_Angle(anEdge1, anEdge2, aVertex->point()));
262         double anAngleValue = anAngle->angleDegree();
263         anOutput << "Angle" << anIndex << " = "
264                  << std::setprecision(10) << anAngleValue << std::endl;
265         aValuesList.push_back(anAngleValue);
266       }
267     }
268   }
269
270   string(RESULT_ID())->setValue(anOutput.str());
271
272   AttributeDoubleArrayPtr aValues =
273       std::dynamic_pointer_cast<ModelAPI_AttributeDoubleArray>(attribute(RESULT_VALUES_ID()));
274   aValues->setSize((int)aValuesList.size());
275   int anIndex = 0;
276   for (std::list<double>::iterator anIt = aValuesList.begin(); anIt != aValuesList.end(); ++anIt)
277     aValues->setValue(anIndex++, *anIt);
278 }
279
280 static GeomVertexPtr selectionToVertex(const AttributeSelectionPtr& aSelection)
281 {
282   GeomShapePtr aShape;
283   GeomVertexPtr aVertex;
284   if (aSelection && aSelection->isInitialized()) {
285     aShape = aSelection->value();
286     if (!aShape && aSelection->context())
287       aShape = aSelection->context()->shape();
288   }
289   if (aShape && aShape->isVertex())
290     aVertex = GeomVertexPtr(new GeomAPI_Vertex(aShape));
291   return aVertex;
292 }
293
294 void FeaturesPlugin_Measurement::computeAngleByPoints()
295 {
296   GeomVertexPtr aVertex1 = selectionToVertex(selection(ANGLE_POINT1_ID()));
297   GeomVertexPtr aVertex2 = selectionToVertex(selection(ANGLE_POINT2_ID()));
298   GeomVertexPtr aVertex3 = selectionToVertex(selection(ANGLE_POINT3_ID()));
299
300   if (!aVertex1 || !aVertex2 || ! aVertex3) {
301     string(RESULT_ID())->setValue("");
302     return;
303   }
304
305   std::shared_ptr<GeomAPI_Angle> anAngle(
306       new GeomAPI_Angle(aVertex1->point(), aVertex2->point(), aVertex3->point()));
307   double anAngleValue = anAngle->angleDegree();
308
309   std::ostringstream anOutput;
310   anOutput << "Angle = " << std::setprecision(10) << anAngleValue;
311   string(RESULT_ID())->setValue(anOutput.str());
312
313   AttributeDoubleArrayPtr aValues =
314     std::dynamic_pointer_cast<ModelAPI_AttributeDoubleArray>(attribute(RESULT_VALUES_ID()));
315   aValues->setSize(1);
316   aValues->setValue(0, anAngleValue);
317 }
318
319 AISObjectPtr FeaturesPlugin_Measurement::getAISObject(AISObjectPtr thePrevious)
320 {
321   AISObjectPtr anAIS;
322   std::string aKind = string(MEASURE_KIND())->value();
323   if (aKind == MEASURE_LENGTH())
324     anAIS = lengthDimension(thePrevious);
325   else if (aKind == MEASURE_DISTANCE())
326     anAIS = distanceDimension(thePrevious);
327   else if (aKind == MEASURE_RADIUS())
328     anAIS = radiusDimension(thePrevious);
329   else if (aKind == MEASURE_ANGLE())
330     anAIS = angleDimension(thePrevious);
331   else if (aKind == MEASURE_ANGLE_POINTS())
332     anAIS = angleByPointsDimension(thePrevious);
333   setupDimension(anAIS);
334   return anAIS;
335 }
336
337 AISObjectPtr FeaturesPlugin_Measurement::lengthDimension(AISObjectPtr thePrevious)
338 {
339   AISObjectPtr aAISObj;
340   if (!myScreenPlane.get())
341     return aAISObj;
342
343   AttributeSelectionPtr aSelectedFeature = selection(EDGE_FOR_LENGTH_ID());
344
345   GeomShapePtr aShape;
346   GeomEdgePtr anEdge;
347   if (aSelectedFeature && aSelectedFeature->isInitialized()) {
348     aShape = aSelectedFeature->value();
349     if (!aShape && aSelectedFeature->context())
350       aShape = aSelectedFeature->context()->shape();
351   }
352   if (aShape && aShape->isEdge())
353     anEdge = GeomEdgePtr(new GeomAPI_Edge(aShape));
354   if (anEdge) {
355     TopoDS_Edge aTEdge = TopoDS::Edge(anEdge->impl<TopoDS_Shape>());
356     GeomPointPtr aPoint1 = anEdge->firstPoint();
357     GeomPointPtr aPoint2 = anEdge->lastPoint();
358
359     gp_Pnt aPnt1(aPoint1->impl<gp_Pnt>());
360     gp_Pnt aPnt2(aPoint2->impl<gp_Pnt>());
361
362     double aLength = aPnt1.Distance(aPnt2);
363     if (aLength > 0) {
364       gp_Pln aPlane = myScreenPlane->impl<gp_Pln>(); // gce_MP.Value();
365       aPlane.SetLocation(aPnt1);
366
367       gp_XYZ aNormal = aPlane.Axis().Direction().XYZ();
368       gp_XYZ aVec(aPnt2.X() - aPnt1.X(), aPnt2.Y() - aPnt1.Y(), aPnt2.Z() - aPnt1.Z());
369       double aDot = aNormal.Dot(aVec);
370       if (fabs(aDot - aLength) <= Precision::Confusion()) {
371         aPlane = gp_Pln(aPnt1, aPlane.XAxis().Direction());
372       }
373
374       Handle(AIS_LengthDimension) aDim;
375       if (thePrevious.get()) {
376         aAISObj = thePrevious;
377         Handle(AIS_InteractiveObject) aAIS = aAISObj->impl<Handle(AIS_InteractiveObject)>();
378         aDim = Handle(AIS_LengthDimension)::DownCast(aAIS);
379         if (aDim.IsNull()) {
380           aDim = new AIS_LengthDimension(aTEdge, aPlane);
381           aAISObj->setImpl(new Handle(AIS_InteractiveObject)(aDim));
382         }
383         else {
384           aDim->SetMeasuredGeometry(aTEdge, aPlane);
385         }
386       }
387       else {
388         aDim = new AIS_LengthDimension(aTEdge, aPlane);
389         aAISObj = AISObjectPtr(new GeomAPI_AISObject());
390         aAISObj->setImpl(new Handle(AIS_InteractiveObject)(aDim));
391       }
392       aDim->SetFlyout(aLength / 3.);
393     }
394   }
395   return aAISObj;
396 }
397
398 AISObjectPtr FeaturesPlugin_Measurement::distanceDimension(AISObjectPtr thePrevious)
399 {
400   AISObjectPtr aAISObj;
401   if (!myScreenPlane.get())
402     return aAISObj;
403
404   AttributeSelectionPtr aFirstFeature = selection(DISTANCE_FROM_OBJECT_ID());
405   AttributeSelectionPtr aSecondFeature = selection(DISTANCE_TO_OBJECT_ID());
406   if (aFirstFeature.get() && aSecondFeature.get()) {
407     GeomShapePtr aShape1;
408     GeomShapePtr aShape2;
409     if (aFirstFeature->isInitialized() && aSecondFeature->isInitialized()) {
410       aShape1 = aFirstFeature->value();
411       if (!aShape1 && aFirstFeature->context())
412         aShape1 = aFirstFeature->context()->shape();
413       aShape2 = aSecondFeature->value();
414       if (!aShape2 && aSecondFeature->context())
415         aShape2 = aSecondFeature->context()->shape();
416     }
417
418     if (aShape1 && aShape2) {
419       const TopoDS_Shape& aShp1 = aShape1->impl<TopoDS_Shape>();
420       const TopoDS_Shape& aShp2 = aShape2->impl<TopoDS_Shape>();
421       BRepExtrema_DistShapeShape aDist(aShp1, aShp2);
422       aDist.Perform();
423       if (aDist.IsDone()) {
424         gp_Pnt aPnt1 = aDist.PointOnShape1(1);
425         gp_Pnt aPnt2 = aDist.PointOnShape2(1);
426         double aDistance = aDist.Value();
427         if (aDistance > 0) {
428           gp_Pln aPlane = myScreenPlane->impl<gp_Pln>();
429           aPlane.SetLocation(aPnt1);
430
431           gp_XYZ aNormal = aPlane.Axis().Direction().XYZ();
432           gp_XYZ aVec(aPnt2.X() - aPnt1.X(), aPnt2.Y() - aPnt1.Y(), aPnt2.Z() - aPnt1.Z());
433           double aDot = aNormal.Dot(aVec);
434           if (fabs(aDot - aDistance) <= Precision::Confusion()) {
435             aPlane = gp_Pln(aPnt1, aPlane.XAxis().Direction());
436           }
437
438           Handle(AIS_LengthDimension) aDim;
439           if (thePrevious.get()) {
440             aAISObj = thePrevious;
441             Handle(AIS_InteractiveObject) aAIS = aAISObj->impl<Handle(AIS_InteractiveObject)>();
442             aDim = Handle(AIS_LengthDimension)::DownCast(aAIS);
443             if (aDim.IsNull()) {
444               aDim = new AIS_LengthDimension(aPnt1, aPnt2, aPlane);
445               aAISObj->setImpl(new Handle(AIS_InteractiveObject)(aDim));
446             }
447             else {
448               aDim->SetMeasuredGeometry(aPnt1, aPnt2, aPlane);
449               aDim->SetFlyout(aDistance / 3.);
450             }
451           }
452           else {
453             aAISObj = AISObjectPtr(new GeomAPI_AISObject());
454             aDim = new AIS_LengthDimension(aPnt1, aPnt2, aPlane);
455             aAISObj->setImpl(new Handle(AIS_InteractiveObject)(aDim));
456           }
457           aDim->SetFlyout(aDistance / 3.);
458         }
459       }
460     }
461   }
462   return aAISObj;
463 }
464
465 AISObjectPtr FeaturesPlugin_Measurement::radiusDimension(AISObjectPtr thePrevious)
466 {
467   AISObjectPtr aAISObj;
468   AttributeSelectionPtr aSelectedFeature = selection(CIRCULAR_OBJECT_ID());
469
470   GeomShapePtr aShape;
471   if (aSelectedFeature && aSelectedFeature->isInitialized()) {
472     aShape = aSelectedFeature->value();
473     if (!aShape && aSelectedFeature->context())
474       aShape = aSelectedFeature->context()->shape();
475   }
476   if (aShape.get()) {
477     TopoDS_Shape aShp = aShape->impl<TopoDS_Shape>();
478     Handle(AIS_RadiusDimension) aDim;
479     if (thePrevious.get()) {
480       aAISObj = thePrevious;
481       Handle(AIS_InteractiveObject) aAIS = aAISObj->impl<Handle(AIS_InteractiveObject)>();
482       Handle(AIS_RadiusDimension) aDim = Handle(AIS_RadiusDimension)::DownCast(aAIS);
483       if (aDim.IsNull()) {
484         aDim = new AIS_RadiusDimension(aShp);
485         aAISObj->setImpl(new Handle(AIS_InteractiveObject)(aDim));
486       } else
487         aDim->SetMeasuredGeometry(aShp);
488     } else {
489       aAISObj = AISObjectPtr(new GeomAPI_AISObject());
490       Handle(AIS_RadiusDimension) aDim = new AIS_RadiusDimension(aShp);
491       aAISObj->setImpl(new Handle(AIS_InteractiveObject)(aDim));
492     }
493   }
494   return aAISObj;
495 }
496
497 AISObjectPtr FeaturesPlugin_Measurement::angleDimension(AISObjectPtr thePrevious)
498 {
499   AISObjectPtr aAISObj;
500   AttributeSelectionPtr aFirstFeature = selection(ANGLE_FROM_EDGE_ID());
501   GeomShapePtr aShape1;
502   GeomEdgePtr anEdge1;
503   if (aFirstFeature && aFirstFeature->isInitialized()) {
504     aShape1 = aFirstFeature->value();
505     if (!aShape1 && aFirstFeature->context())
506       aShape1 = aFirstFeature->context()->shape();
507   }
508   if (aShape1 && aShape1->isEdge())
509     anEdge1 = GeomEdgePtr(new GeomAPI_Edge(aShape1));
510
511   AttributeSelectionPtr aSecondFeature = selection(ANGLE_TO_EDGE_ID());
512   GeomShapePtr aShape2;
513   GeomEdgePtr anEdge2;
514   if (aSecondFeature && aSecondFeature->isInitialized()) {
515     aShape2 = aSecondFeature->value();
516     if (!aShape2 && aSecondFeature->context())
517       aShape2 = aSecondFeature->context()->shape();
518   }
519   if (aShape2 && aShape2->isEdge())
520     anEdge2 = GeomEdgePtr(new GeomAPI_Edge(aShape2));
521
522   if (anEdge1.get() && anEdge2.get()) {
523     TopoDS_Edge aTEdge1 = TopoDS::Edge(anEdge1->impl<TopoDS_Shape>());
524     TopoDS_Edge aTEdge2 = TopoDS::Edge(anEdge2->impl<TopoDS_Shape>());
525     Handle(AIS_AngleDimension) aDim;
526     if (thePrevious.get()) {
527       aAISObj = thePrevious;
528       Handle(AIS_InteractiveObject) aAIS = aAISObj->impl<Handle(AIS_InteractiveObject)>();
529       aDim = Handle(AIS_AngleDimension)::DownCast(aAIS);
530       if (aDim.IsNull()) {
531         aDim = new AIS_AngleDimension(aTEdge1, aTEdge2);
532         aAISObj->setImpl(new Handle(AIS_InteractiveObject)(aDim));
533       } else
534         aDim->SetMeasuredGeometry(aTEdge1, aTEdge2);
535     } else {
536       aAISObj = AISObjectPtr(new GeomAPI_AISObject());
537       aDim = new AIS_AngleDimension(aTEdge1, aTEdge2);
538       aAISObj->setImpl(new Handle(AIS_InteractiveObject)(aDim));
539     }
540   }
541   return aAISObj;
542 }
543
544 AISObjectPtr FeaturesPlugin_Measurement::angleByPointsDimension(AISObjectPtr thePrevious)
545 {
546   AISObjectPtr aAISObj;
547   GeomVertexPtr aVertex1 = selectionToVertex(selection(ANGLE_POINT1_ID()));
548   GeomVertexPtr aVertex2 = selectionToVertex(selection(ANGLE_POINT2_ID()));
549   GeomVertexPtr aVertex3 = selectionToVertex(selection(ANGLE_POINT3_ID()));
550
551   if (aVertex1.get() && aVertex2.get() && aVertex3.get()) {
552     GeomPointPtr aPoint1 = aVertex1->point();
553     GeomPointPtr aPoint2 = aVertex2->point();
554     GeomPointPtr aPoint3 = aVertex3->point();
555     gp_Pnt aPnt1(aPoint1->impl<gp_Pnt>());
556     gp_Pnt aPnt2(aPoint2->impl<gp_Pnt>());
557     gp_Pnt aPnt3(aPoint3->impl<gp_Pnt>());
558
559     if (thePrevious.get()) {
560       aAISObj = thePrevious;
561       Handle(AIS_InteractiveObject) aAIS = aAISObj->impl<Handle(AIS_InteractiveObject)>();
562       Handle(AIS_AngleDimension) aDim = Handle(AIS_AngleDimension)::DownCast(aAIS);
563       if (aDim.IsNull()) {
564         aDim = new AIS_AngleDimension(aPnt1, aPnt2, aPnt3);
565         aAISObj->setImpl(new Handle(AIS_InteractiveObject)(aDim));
566       } else
567         aDim->SetMeasuredGeometry(aPnt1, aPnt2, aPnt3);
568     } else {
569       Handle(AIS_AngleDimension) aDim = new AIS_AngleDimension(aPnt1, aPnt2, aPnt3);
570       aAISObj = AISObjectPtr(new GeomAPI_AISObject());
571       aAISObj->setImpl(new Handle(AIS_InteractiveObject)(aDim));
572     }
573   }
574   return aAISObj;
575 }
576
577
578 void FeaturesPlugin_Measurement::setupDimension(AISObjectPtr theDim)
579 {
580   if (theDim.get()) {
581     Handle(AIS_InteractiveObject) aAIS = theDim->impl<Handle(AIS_InteractiveObject)>();
582     Handle(AIS_Dimension) aDim = Handle(AIS_Dimension)::DownCast(aAIS);
583     int aSize = Config_PropManager::integer("Visualization", "dimension_arrow_size");
584     int aTextSize = Config_PropManager::integer("Visualization", "dimension_value_size");
585     std::string aFont = Config_PropManager::string("Visualization", "dimension_font");
586
587     Handle(Prs3d_DimensionAspect) anAspect = aDim->DimensionAspect();
588     anAspect->MakeArrows3d(false);
589     anAspect->MakeText3d(false);
590     anAspect->MakeTextShaded(false);
591     anAspect->MakeUnitsDisplayed(false);
592     anAspect->MakeUnitsDisplayed(false);
593     anAspect->TextAspect()->SetFont(aFont.c_str());
594     anAspect->TextAspect()->SetHeight(aTextSize);
595     anAspect->ArrowAspect()->SetLength(aSize / mySceenScale);
596     anAspect->SetExtensionSize((aTextSize / mySceenScale + aSize) / 2.0);
597     aDim->SetDimensionAspect(anAspect);
598
599     aDim->SetZLayer(1);
600     std::vector<int> aColor = Config_PropManager::color("Visualization", "sketch_dimension_color");
601     theDim->setColor(aColor[0], aColor[1], aColor[2]);
602   }
603 }