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