src/FeaturesPlugin/FeaturesPlugin_Measurement.cpp

   1 // Copyright (C) 2018-2021  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 <AIS_Dimension.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   AttributeDoubleArrayPtr aValues =
 322     std::dynamic_pointer_cast<ModelAPI_AttributeDoubleArray>(attribute(RESULT_VALUES_ID()));
 323   if ((aValues->size() == 0) || (aValues->value(0) <= Precision::Confusion()))
 324     return AISObjectPtr();
 325
 326   if (!myScreenPlane) {
 327     // initialize a default plane for dimension
 328     GeomPointPtr anOrigin(new GeomAPI_Pnt(0., 0., 0.));
 329     GeomDirPtr aNormal(new GeomAPI_Dir(0., 0., 1.));
 330     myScreenPlane = GeomPlanePtr(new GeomAPI_Pln(anOrigin, aNormal));
 331   }
 332
 333   AISObjectPtr anAIS;
 334   std::string aKind = string(MEASURE_KIND())->value();
 335   if (aKind == MEASURE_LENGTH())
 336     anAIS = lengthDimension(thePrevious);
 337   else if (aKind == MEASURE_DISTANCE())
 338     anAIS = distanceDimension(thePrevious);
 339   else if (aKind == MEASURE_RADIUS())
 340     anAIS = radiusDimension(thePrevious);
 341   else if (aKind == MEASURE_ANGLE())
 342     anAIS = angleDimension(thePrevious);
 343   else if (aKind == MEASURE_ANGLE_POINTS())
 344     anAIS = angleByPointsDimension(thePrevious);
 345   setupDimension(anAIS);
 346   return anAIS;
 347 }
 348
 349 AISObjectPtr FeaturesPlugin_Measurement::lengthDimension(AISObjectPtr thePrevious)
 350 {
 351   AISObjectPtr aAISObj;
 352
 353   AttributeSelectionPtr aSelectedFeature = selection(EDGE_FOR_LENGTH_ID());
 354
 355   GeomShapePtr aShape;
 356   GeomEdgePtr anEdge;
 357   if (aSelectedFeature && aSelectedFeature->isInitialized()) {
 358     aShape = aSelectedFeature->value();
 359     if (!aShape && aSelectedFeature->context())
 360       aShape = aSelectedFeature->context()->shape();
 361   }
 362   if (aShape && aShape->isEdge())
 363     anEdge = GeomEdgePtr(new GeomAPI_Edge(aShape));
 364   if (anEdge) {
 365     TopoDS_Edge aTEdge = TopoDS::Edge(anEdge->impl<TopoDS_Shape>());
 366     GeomPointPtr aPoint1 = anEdge->firstPoint();
 367     GeomPointPtr aPoint2 = anEdge->lastPoint();
 368
 369     gp_Pnt aPnt1(aPoint1->impl<gp_Pnt>());
 370     gp_Pnt aPnt2(aPoint2->impl<gp_Pnt>());
 371
 372     double aLength = aPnt1.Distance(aPnt2);
 373     if (aLength > 0) {
 374       gp_Pln aPlane = myScreenPlane->impl<gp_Pln>(); // gce_MP.Value();
 375       aPlane.SetLocation(aPnt1);
 376
 377       gp_XYZ aNormal = aPlane.Axis().Direction().XYZ();
 378       gp_XYZ aVec(aPnt2.X() - aPnt1.X(), aPnt2.Y() - aPnt1.Y(), aPnt2.Z() - aPnt1.Z());
 379       double aDot = aNormal.Dot(aVec);
 380       if (fabs(aDot - aLength) <= Precision::Confusion()) {
 381         aPlane = gp_Pln(aPnt1, aPlane.XAxis().Direction());
 382       }
 383
 384       Handle(AIS_LengthDimension) aDim;
 385       if (thePrevious.get()) {
 386         aAISObj = thePrevious;
 387         Handle(AIS_InteractiveObject) aAIS = aAISObj->impl<Handle(AIS_InteractiveObject)>();
 388         aDim = Handle(AIS_LengthDimension)::DownCast(aAIS);
 389         if (aDim.IsNull()) {
 390           aDim = new AIS_LengthDimension(aTEdge, aPlane);
 391           aAISObj = AISObjectPtr(new GeomAPI_AISObject());
 392           aAISObj->setImpl(new Handle(AIS_InteractiveObject)(aDim));
 393         }
 394         else {
 395           aDim->SetMeasuredGeometry(aTEdge, aPlane);
 396         }
 397       }
 398       else {
 399         aDim = new AIS_LengthDimension(aTEdge, aPlane);
 400         aAISObj = AISObjectPtr(new GeomAPI_AISObject());
 401         aAISObj->setImpl(new Handle(AIS_InteractiveObject)(aDim));
 402       }
 403       aDim->SetFlyout(aLength / 3.);
 404     }
 405   }
 406   return aAISObj;
 407 }
 408
 409 AISObjectPtr FeaturesPlugin_Measurement::distanceDimension(AISObjectPtr thePrevious)
 410 {
 411   AISObjectPtr aAISObj;
 412
 413   AttributeSelectionPtr aFirstFeature = selection(DISTANCE_FROM_OBJECT_ID());
 414   AttributeSelectionPtr aSecondFeature = selection(DISTANCE_TO_OBJECT_ID());
 415   if (aFirstFeature.get() && aSecondFeature.get()) {
 416     GeomShapePtr aShape1;
 417     GeomShapePtr aShape2;
 418     if (aFirstFeature->isInitialized() && aSecondFeature->isInitialized()) {
 419       aShape1 = aFirstFeature->value();
 420       if (!aShape1 && aFirstFeature->context())
 421         aShape1 = aFirstFeature->context()->shape();
 422       aShape2 = aSecondFeature->value();
 423       if (!aShape2 && aSecondFeature->context())
 424         aShape2 = aSecondFeature->context()->shape();
 425     }
 426
 427     if (aShape1 && aShape2) {
 428       const TopoDS_Shape& aShp1 = aShape1->impl<TopoDS_Shape>();
 429       const TopoDS_Shape& aShp2 = aShape2->impl<TopoDS_Shape>();
 430       BRepExtrema_DistShapeShape aDist(aShp1, aShp2);
 431       aDist.Perform();
 432       if (aDist.IsDone()) {
 433         gp_Pnt aPnt1 = aDist.PointOnShape1(1);
 434         gp_Pnt aPnt2 = aDist.PointOnShape2(1);
 435         double aDistance = aDist.Value();
 436         if (aDistance > 0) {
 437           gp_Pln aPlane = myScreenPlane->impl<gp_Pln>();
 438           aPlane.SetLocation(aPnt1);
 439
 440           gp_XYZ aNormal = aPlane.Axis().Direction().XYZ();
 441           gp_XYZ aVec(aPnt2.X() - aPnt1.X(), aPnt2.Y() - aPnt1.Y(), aPnt2.Z() - aPnt1.Z());
 442           double aDot = aNormal.Dot(aVec);
 443           if (fabs(aDot - aDistance) <= Precision::Confusion()) {
 444             aPlane = gp_Pln(aPnt1, aPlane.XAxis().Direction());
 445           }
 446
 447           Handle(AIS_LengthDimension) aDim;
 448           if (thePrevious.get()) {
 449             aAISObj = thePrevious;
 450             Handle(AIS_InteractiveObject) aAIS = aAISObj->impl<Handle(AIS_InteractiveObject)>();
 451             aDim = Handle(AIS_LengthDimension)::DownCast(aAIS);
 452             if (aDim.IsNull()) {
 453               aDim = new AIS_LengthDimension(aPnt1, aPnt2, aPlane);
 454               aAISObj = AISObjectPtr(new GeomAPI_AISObject());
 455               aAISObj->setImpl(new Handle(AIS_InteractiveObject)(aDim));
 456             }
 457             else {
 458               aDim->SetMeasuredGeometry(aPnt1, aPnt2, aPlane);
 459               aDim->SetFlyout(aDistance / 3.);
 460             }
 461           }
 462           else {
 463             aAISObj = AISObjectPtr(new GeomAPI_AISObject());
 464             aDim = new AIS_LengthDimension(aPnt1, aPnt2, aPlane);
 465             aAISObj->setImpl(new Handle(AIS_InteractiveObject)(aDim));
 466           }
 467           aDim->SetFlyout(aDistance / 3.);
 468         }
 469       }
 470     }
 471   }
 472   return aAISObj;
 473 }
 474
 475 AISObjectPtr FeaturesPlugin_Measurement::radiusDimension(AISObjectPtr thePrevious)
 476 {
 477   AISObjectPtr aAISObj;
 478   AttributeSelectionPtr aSelectedFeature = selection(CIRCULAR_OBJECT_ID());
 479
 480   GeomShapePtr aShape;
 481   if (aSelectedFeature && aSelectedFeature->isInitialized()) {
 482     aShape = aSelectedFeature->value();
 483     if (!aShape && aSelectedFeature->context())
 484       aShape = aSelectedFeature->context()->shape();
 485   }
 486   if (aShape.get()) {
 487     TopoDS_Shape aShp = aShape->impl<TopoDS_Shape>();
 488     if (thePrevious.get()) {
 489       aAISObj = thePrevious;
 490       Handle(AIS_InteractiveObject) aAIS = aAISObj->impl<Handle(AIS_InteractiveObject)>();
 491       Handle(AIS_RadiusDimension) aDim = Handle(AIS_RadiusDimension)::DownCast(aAIS);
 492       if (aDim.IsNull()) {
 493         aDim = new AIS_RadiusDimension(aShp);
 494         aAISObj = AISObjectPtr(new GeomAPI_AISObject());
 495         aAISObj->setImpl(new Handle(AIS_InteractiveObject)(aDim));
 496       } else
 497         aDim->SetMeasuredGeometry(aShp);
 498     } else {
 499       aAISObj = AISObjectPtr(new GeomAPI_AISObject());
 500       Handle(AIS_RadiusDimension) aDim = new AIS_RadiusDimension(aShp);
 501       aAISObj->setImpl(new Handle(AIS_InteractiveObject)(aDim));
 502     }
 503   }
 504   return aAISObj;
 505 }
 506
 507 AISObjectPtr FeaturesPlugin_Measurement::angleDimension(AISObjectPtr thePrevious)
 508 {
 509   AISObjectPtr aAISObj;
 510   AttributeSelectionPtr aFirstFeature = selection(ANGLE_FROM_EDGE_ID());
 511   GeomShapePtr aShape1;
 512   GeomEdgePtr anEdge1;
 513   if (aFirstFeature && aFirstFeature->isInitialized()) {
 514     aShape1 = aFirstFeature->value();
 515     if (!aShape1 && aFirstFeature->context())
 516       aShape1 = aFirstFeature->context()->shape();
 517   }
 518   if (aShape1 && aShape1->isEdge())
 519     anEdge1 = GeomEdgePtr(new GeomAPI_Edge(aShape1));
 520
 521   AttributeSelectionPtr aSecondFeature = selection(ANGLE_TO_EDGE_ID());
 522   GeomShapePtr aShape2;
 523   GeomEdgePtr anEdge2;
 524   if (aSecondFeature && aSecondFeature->isInitialized()) {
 525     aShape2 = aSecondFeature->value();
 526     if (!aShape2 && aSecondFeature->context())
 527       aShape2 = aSecondFeature->context()->shape();
 528   }
 529   if (aShape2 && aShape2->isEdge())
 530     anEdge2 = GeomEdgePtr(new GeomAPI_Edge(aShape2));
 531
 532   if (anEdge1.get() && anEdge2.get()) {
 533     TopoDS_Edge aTEdge1 = TopoDS::Edge(anEdge1->impl<TopoDS_Shape>());
 534     TopoDS_Edge aTEdge2 = TopoDS::Edge(anEdge2->impl<TopoDS_Shape>());
 535
 536     Handle(AIS_AngleDimension) aDim;
 537     if (thePrevious.get()) {
 538       aAISObj = thePrevious;
 539       Handle(AIS_InteractiveObject) aAIS = aAISObj->impl<Handle(AIS_InteractiveObject)>();
 540       aDim = Handle(AIS_AngleDimension)::DownCast(aAIS);
 541       if (aDim.IsNull()) {
 542         aDim = new AIS_AngleDimension(aTEdge1, aTEdge2);
 543         aAISObj = AISObjectPtr(new GeomAPI_AISObject());
 544         aAISObj->setImpl(new Handle(AIS_InteractiveObject)(aDim));
 545       } else
 546         aDim->SetMeasuredGeometry(aTEdge1, aTEdge2);
 547     } else {
 548       aAISObj = AISObjectPtr(new GeomAPI_AISObject());
 549       aDim = new AIS_AngleDimension(aTEdge1, aTEdge2);
 550       aAISObj->setImpl(new Handle(AIS_InteractiveObject)(aDim));
 551     }
 552   }
 553   return aAISObj;
 554 }
 555
 556 AISObjectPtr FeaturesPlugin_Measurement::angleByPointsDimension(AISObjectPtr thePrevious)
 557 {
 558   AISObjectPtr aAISObj;
 559   GeomVertexPtr aVertex1 = selectionToVertex(selection(ANGLE_POINT1_ID()));
 560   GeomVertexPtr aVertex2 = selectionToVertex(selection(ANGLE_POINT2_ID()));
 561   GeomVertexPtr aVertex3 = selectionToVertex(selection(ANGLE_POINT3_ID()));
 562
 563   if (aVertex1.get() && aVertex2.get() && aVertex3.get()) {
 564     GeomPointPtr aPoint1 = aVertex1->point();
 565     GeomPointPtr aPoint2 = aVertex2->point();
 566     GeomPointPtr aPoint3 = aVertex3->point();
 567     gp_Pnt aPnt1(aPoint1->impl<gp_Pnt>());
 568     gp_Pnt aPnt2(aPoint2->impl<gp_Pnt>());
 569     gp_Pnt aPnt3(aPoint3->impl<gp_Pnt>());
 570
 571     if (aPnt1.IsEqual(aPnt2, Precision::Confusion()) ||
 572       aPnt1.IsEqual(aPnt3, Precision::Confusion()) ||
 573       aPnt2.IsEqual(aPnt3, Precision::Confusion()))
 574       return thePrevious;
 575
 576     if (thePrevious.get()) {
 577       aAISObj = thePrevious;
 578       Handle(AIS_InteractiveObject) aAIS = aAISObj->impl<Handle(AIS_InteractiveObject)>();
 579       Handle(AIS_AngleDimension) aDim = Handle(AIS_AngleDimension)::DownCast(aAIS);
 580       if (aDim.IsNull()) {
 581         aDim = new AIS_AngleDimension(aPnt1, aPnt2, aPnt3);
 582         aAISObj = AISObjectPtr(new GeomAPI_AISObject());
 583         aAISObj->setImpl(new Handle(AIS_InteractiveObject)(aDim));
 584       } else
 585         aDim->SetMeasuredGeometry(aPnt1, aPnt2, aPnt3);
 586     } else {
 587       Handle(AIS_AngleDimension) aDim = new AIS_AngleDimension(aPnt1, aPnt2, aPnt3);
 588       aAISObj = AISObjectPtr(new GeomAPI_AISObject());
 589       aAISObj->setImpl(new Handle(AIS_InteractiveObject)(aDim));
 590     }
 591   }
 592   return aAISObj;
 593 }
 594
 595
 596 void FeaturesPlugin_Measurement::setupDimension(AISObjectPtr theDim)
 597 {
 598   if (theDim.get()) {
 599     Handle(AIS_InteractiveObject) aAIS = theDim->impl<Handle(AIS_InteractiveObject)>();
 600     Handle(AIS_Dimension) aDim = Handle(AIS_Dimension)::DownCast(aAIS);
 601     int aSize = Config_PropManager::integer("Visualization", "dimension_arrow_size");
 602     int aTextSize = Config_PropManager::integer("Visualization", "dimension_value_size");
 603     std::string aFont = Config_PropManager::string("Visualization", "dimension_font");
 604
 605     Handle(Prs3d_DimensionAspect) anAspect = aDim->DimensionAspect();
 606     anAspect->MakeArrows3d(false);
 607     anAspect->MakeText3d(false);
 608     anAspect->MakeTextShaded(false);
 609     anAspect->MakeUnitsDisplayed(false);
 610     anAspect->MakeUnitsDisplayed(false);
 611     anAspect->TextAspect()->SetFont(aFont.c_str());
 612     anAspect->TextAspect()->SetHeight(aTextSize);
 613     anAspect->ArrowAspect()->SetLength(aSize / mySceenScale);
 614     anAspect->SetExtensionSize((aTextSize / mySceenScale + aSize) / 2.0);
 615     aDim->SetDimensionAspect(anAspect);
 616
 617     aDim->SetZLayer(Graphic3d_ZLayerId_Top);
 618     std::vector<int> aColor = Config_PropManager::color("Visualization", "sketch_dimension_color");
 619     theDim->setColor(aColor[0], aColor[1], aColor[2]);
 620   }
 621 }