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
  37 #include <GeomAlgoAPI_ShapeTools.h>
  38
  39 #include <iomanip>
  40 #include <sstream>
  41
  42 FeaturesPlugin_Measurement::FeaturesPlugin_Measurement()
  43 {
  44 }
  45
  46 void FeaturesPlugin_Measurement::initAttributes()
  47 {
  48   data()->addAttribute(FeaturesPlugin_Measurement::MEASURE_KIND(),
  49                        ModelAPI_AttributeString::typeId());
  50
  51   // attribute for length
  52   data()->addAttribute(EDGE_FOR_LENGTH_ID(), ModelAPI_AttributeSelection::typeId());
  53   // attributes for distance
  54   data()->addAttribute(DISTANCE_FROM_OBJECT_ID(), ModelAPI_AttributeSelection::typeId());
  55   data()->addAttribute(DISTANCE_TO_OBJECT_ID(), ModelAPI_AttributeSelection::typeId());
  56   // attribute for radius
  57   data()->addAttribute(CIRCULAR_OBJECT_ID(), ModelAPI_AttributeSelection::typeId());
  58   // attribute for angle
  59   data()->addAttribute(ANGLE_FROM_EDGE_ID(), ModelAPI_AttributeSelection::typeId());
  60   data()->addAttribute(ANGLE_TO_EDGE_ID(), ModelAPI_AttributeSelection::typeId());
  61   // attribute for result message and values
  62   data()->addAttribute(RESULT_ID(), ModelAPI_AttributeString::typeId());
  63   data()->addAttribute(RESULT_VALUES_ID(), ModelAPI_AttributeDoubleArray::typeId());
  64 }
  65
  66 void FeaturesPlugin_Measurement::execute()
  67 {
  68 }
  69
  70 void FeaturesPlugin_Measurement::attributeChanged(const std::string& theID)
  71 {
  72   if (theID == MEASURE_KIND()) {
  73     // clear selected objects
  74     selection(EDGE_FOR_LENGTH_ID())->reset();
  75     selection(DISTANCE_FROM_OBJECT_ID())->reset();
  76     selection(DISTANCE_TO_OBJECT_ID())->reset();
  77     selection(CIRCULAR_OBJECT_ID())->reset();
  78     selection(ANGLE_FROM_EDGE_ID())->reset();
  79     selection(ANGLE_TO_EDGE_ID())->reset();
  80     string(RESULT_ID())->setValue("");
  81     std::dynamic_pointer_cast<ModelAPI_AttributeDoubleArray>(
  82         attribute(RESULT_VALUES_ID()))->setSize(0);
  83   }
  84   else if (theID != RESULT_ID()) {
  85     std::string aKind = string(MEASURE_KIND())->value();
  86     if (aKind == MEASURE_LENGTH())
  87       computeLength();
  88     else if (aKind == MEASURE_DISTANCE())
  89       computeDistance();
  90     else if (aKind == MEASURE_RADIUS())
  91       computeRadius();
  92     else if (aKind == MEASURE_ANGLE())
  93       computeAngle();
  94   }
  95 }
  96
  97 void FeaturesPlugin_Measurement::computeLength()
  98 {
  99   AttributeSelectionPtr aSelectedFeature = selection(EDGE_FOR_LENGTH_ID());
 100
 101   GeomShapePtr aShape;
 102   GeomEdgePtr anEdge;
 103   if (aSelectedFeature)
 104     aShape = aSelectedFeature->value();
 105   if (!aShape && aSelectedFeature->context())
 106     aShape = aSelectedFeature->context()->shape();
 107   if (aShape && aShape->isEdge())
 108     anEdge = GeomEdgePtr(new GeomAPI_Edge(aShape));
 109   if (!anEdge)
 110     return;
 111
 112   std::ostringstream anOutput;
 113   anOutput << "Length = " << std::setprecision(10) << anEdge->length();
 114   string(RESULT_ID())->setValue(anOutput.str());
 115
 116   AttributeDoubleArrayPtr aValues =
 117       std::dynamic_pointer_cast<ModelAPI_AttributeDoubleArray>(attribute(RESULT_VALUES_ID()));
 118   aValues->setSize(1);
 119   aValues->setValue(0, anEdge->length());
 120 }
 121
 122 void FeaturesPlugin_Measurement::computeDistance()
 123 {
 124   AttributeSelectionPtr aFirstFeature = selection(DISTANCE_FROM_OBJECT_ID());
 125   GeomShapePtr aShape1;
 126   if (aFirstFeature)
 127     aShape1 = aFirstFeature->value();
 128   if (!aShape1 && aFirstFeature->context())
 129     aShape1 = aFirstFeature->context()->shape();
 130
 131   AttributeSelectionPtr aSecondFeature = selection(DISTANCE_TO_OBJECT_ID());
 132   GeomShapePtr aShape2;
 133   if (aSecondFeature)
 134     aShape2 = aSecondFeature->value();
 135   if (!aShape2 && aSecondFeature->context())
 136     aShape2 = aSecondFeature->context()->shape();
 137
 138   if (!aShape1 || !aShape2)
 139     return;
 140
 141   double aDistance = GeomAlgoAPI_ShapeTools::minimalDistance(aShape1, aShape2);
 142
 143   std::ostringstream anOutput;
 144   anOutput << "Distance = " << std::setprecision(10) << aDistance;
 145   string(RESULT_ID())->setValue(anOutput.str());
 146
 147   AttributeDoubleArrayPtr aValues =
 148       std::dynamic_pointer_cast<ModelAPI_AttributeDoubleArray>(attribute(RESULT_VALUES_ID()));
 149   aValues->setSize(1);
 150   aValues->setValue(0, aDistance);
 151 }
 152
 153 void FeaturesPlugin_Measurement::computeRadius()
 154 {
 155   AttributeSelectionPtr aSelectedFeature = selection(CIRCULAR_OBJECT_ID());
 156
 157   GeomShapePtr aShape;
 158   if (aSelectedFeature)
 159     aShape = aSelectedFeature->value();
 160   if (!aShape && aSelectedFeature->context())
 161     aShape = aSelectedFeature->context()->shape();
 162
 163   double aRadius = -1.0;
 164   if (aShape) {
 165     if (aShape->isEdge()) {
 166       GeomEdgePtr anEdge(new GeomAPI_Edge(aShape));
 167       if (anEdge->isCircle() || anEdge->isArc()) {
 168         aRadius = anEdge->circle()->radius();
 169       }
 170     } else if (aShape->isFace()) {
 171       GeomFacePtr aFace(new GeomAPI_Face(aShape));
 172       aRadius = GeomAlgoAPI_ShapeTools::radius(aFace);
 173     }
 174   }
 175
 176   if (aRadius < 0.0)
 177     return;
 178
 179   std::ostringstream anOutput;
 180   anOutput << "Radius = " << std::setprecision(10) << aRadius;
 181   string(RESULT_ID())->setValue(anOutput.str());
 182
 183   AttributeDoubleArrayPtr aValues =
 184       std::dynamic_pointer_cast<ModelAPI_AttributeDoubleArray>(attribute(RESULT_VALUES_ID()));
 185   aValues->setSize(1);
 186   aValues->setValue(0, aRadius);
 187 }
 188
 189 void FeaturesPlugin_Measurement::computeAngle()
 190 {
 191   AttributeSelectionPtr aFirstFeature = selection(ANGLE_FROM_EDGE_ID());
 192   GeomShapePtr aShape1;
 193   GeomEdgePtr anEdge1;
 194   if (aFirstFeature)
 195     aShape1 = aFirstFeature->value();
 196   if (!aShape1 && aFirstFeature->context())
 197     aShape1 = aFirstFeature->context()->shape();
 198   if (aShape1 && aShape1->isEdge())
 199     anEdge1 = GeomEdgePtr(new GeomAPI_Edge(aShape1));
 200
 201
 202   AttributeSelectionPtr aSecondFeature = selection(ANGLE_TO_EDGE_ID());
 203   GeomShapePtr aShape2;
 204   GeomEdgePtr anEdge2;
 205   if (aSecondFeature)
 206     aShape2 = aSecondFeature->value();
 207   if (!aShape2 && aSecondFeature->context())
 208     aShape2 = aSecondFeature->context()->shape();
 209   if (aShape2 && aShape2->isEdge())
 210     anEdge2 = GeomEdgePtr(new GeomAPI_Edge(aShape2));
 211
 212   if (!anEdge1 || !anEdge2)
 213     return;
 214
 215   GeomShapePtr anInter = anEdge1->intersect(anEdge2);
 216
 217   std::ostringstream anOutput;
 218   anOutput << std::setprecision(10);
 219   std::list<double> aValuesList;
 220   if (anInter) {
 221     if (anInter->isVertex()) {
 222       std::shared_ptr<GeomAPI_Vertex> aVertex(new GeomAPI_Vertex(anInter));
 223       std::shared_ptr<GeomAPI_Angle> anAngle(
 224           new GeomAPI_Angle(anEdge1, anEdge2, aVertex->point()));
 225       double anAngleValue = anAngle->angleDegree();
 226       anOutput << "Angle = " << anAngleValue << std::endl;
 227       aValuesList.push_back(anAngleValue);
 228     }
 229     else {
 230       GeomAPI_ShapeIterator anIt(anInter);
 231       for (int anIndex = 1; anIt.more(); anIt.next(), ++anIndex) {
 232         GeomShapePtr aCurrent = anIt.current();
 233         if (!aCurrent->isVertex())
 234           continue;
 235         std::shared_ptr<GeomAPI_Vertex> aVertex(new GeomAPI_Vertex(aCurrent));
 236         std::shared_ptr<GeomAPI_Angle> anAngle(
 237             new GeomAPI_Angle(anEdge1, anEdge2, aVertex->point()));
 238         double anAngleValue = anAngle->angleDegree();
 239         anOutput << "Angle" << anIndex << " = " << anAngleValue << std::endl;
 240         aValuesList.push_back(anAngleValue);
 241       }
 242     }
 243   }
 244
 245   string(RESULT_ID())->setValue(anOutput.str());
 246
 247   AttributeDoubleArrayPtr aValues =
 248       std::dynamic_pointer_cast<ModelAPI_AttributeDoubleArray>(attribute(RESULT_VALUES_ID()));
 249   aValues->setSize((int)aValuesList.size());
 250   int anIndex = 0;
 251   for (std::list<double>::iterator anIt = aValuesList.begin(); anIt != aValuesList.end(); ++anIt)
 252     aValues->setValue(anIndex++, *anIt);
 253 }