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