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 }