src/SketcherPrs/SketcherPrs_Tools.cpp

   1 // Copyright (C) 2014-2019  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 "SketcherPrs_Tools.h"
  21
  22 #include <SketchPlugin_Constraint.h>
  23 #include <SketchPlugin_Point.h>
  24 #include <SketchPlugin_Circle.h>
  25 #include <SketchPlugin_Line.h>
  26 #include <SketchPlugin_Arc.h>
  27
  28 #include <ModelAPI_ResultConstruction.h>
  29 #include <ModelAPI_AttributeRefAttr.h>
  30 #include <ModelAPI_AttributeRefList.h>
  31 #include <ModelAPI_AttributeDouble.h>
  32 #include <ModelAPI_Events.h>
  33
  34 #include <ModelGeomAlgo_Point2D.h>
  35
  36 #include <Events_InfoMessage.h>
  37
  38 #include <GeomDataAPI_Point2D.h>
  39 #include <GeomAPI_Lin2d.h>
  40
  41 #include <TopoDS.hxx>
  42 #include <TopoDS_Shape.hxx>
  43 #include <TopoDS_Vertex.hxx>
  44
  45 #include <Prs3d_DimensionAspect.hxx>
  46
  47 #include <BRep_Tool.hxx>
  48 #include <Precision.hxx>
  49
  50 #include <AIS_Dimension.hxx>
  51
  52 namespace SketcherPrs_Tools {
  53
  54 AttributePtr getAttribute(ModelAPI_Feature* theFeature, const std::string& theAttrName)
  55 {
  56   AttributePtr anAttribute;
  57   if (theFeature) {
  58     std::shared_ptr<ModelAPI_Data> aData = theFeature->data();
  59     if (aData.get() && aData->isValid()) { /// essential check as it is called in openGl thread
  60       std::shared_ptr<ModelAPI_AttributeRefAttr> anAttr = aData->refattr(theAttrName);
  61       if (!anAttr->isObject())
  62         anAttribute = anAttr->attr();
  63     }
  64   }
  65   return anAttribute;
  66 }
  67
  68 ObjectPtr getResult(ModelAPI_Feature* theFeature, const std::string& theAttrName)
  69 {
  70   ObjectPtr anObject;
  71   if (theFeature) {
  72     std::shared_ptr<ModelAPI_Data> aData = theFeature->data();
  73     if (aData.get() && aData->isValid()) { /// essential check as it is called in openGl thread
  74       std::shared_ptr<ModelAPI_AttributeRefAttr> anAttr = aData->refattr(theAttrName);
  75       if (anAttr.get())
  76         anObject = anAttr->object();
  77     }
  78   }
  79   return anObject;
  80 }
  81
  82
  83 std::shared_ptr<GeomAPI_Shape> getShape(ObjectPtr theObject)
  84 {
  85   ResultConstructionPtr aRes = std::dynamic_pointer_cast<ModelAPI_ResultConstruction>(theObject);
  86   if (aRes.get() != NULL && aRes->data()->isValid()) {
  87     /// essential check as it is called in openGl thread
  88     return aRes->shape();
  89   }
  90   return std::shared_ptr<GeomAPI_Shape>();
  91 }
  92
  93
  94 std::shared_ptr<GeomAPI_Pnt2d> getPoint(ModelAPI_Feature* theFeature,
  95                                         const std::string& theAttribute)
  96 {
  97   std::shared_ptr<GeomDataAPI_Point2D> aPointAttr = ModelGeomAlgo_Point2D::getPointOfRefAttr(
  98                theFeature, theAttribute, SketchPlugin_Point::ID(), SketchPlugin_Point::COORD_ID());
  99   if (aPointAttr.get() != NULL)
 100     return aPointAttr->pnt();
 101   return std::shared_ptr<GeomAPI_Pnt2d>();
 102 }
 103
 104 //*************************************************************************************
 105 /// Find an attribute of the given object which corresponds to a vetrex
 106 /// defined by a shape
 107 /// \param theObject an object
 108 /// \param theShape a vertex
 109 /// \param thePlane a projection plane (sketcher plane)
 110 std::shared_ptr<GeomDataAPI_Point2D> findGeomPoint(ObjectPtr theObject,
 111                                     const TopoDS_Shape& theShape,
 112                                     const std::shared_ptr<GeomAPI_Ax3>& thePlane)
 113 {
 114   std::shared_ptr<GeomDataAPI_Point2D> aGeomPoint;
 115
 116   FeaturePtr anObjectFeature = ModelAPI_Feature::feature(theObject);
 117   if (anObjectFeature) {
 118     if (theShape.ShapeType() == TopAbs_VERTEX) {
 119       const TopoDS_Vertex& aShapeVertex = TopoDS::Vertex(theShape);
 120       if (!aShapeVertex.IsNull())  {
 121         gp_Pnt aShapePoint = BRep_Tool::Pnt(aShapeVertex);
 122         std::shared_ptr<GeomAPI_Pnt> aShapeGeomPnt = std::shared_ptr<GeomAPI_Pnt>(
 123             new GeomAPI_Pnt(aShapePoint.X(), aShapePoint.Y(), aShapePoint.Z()));
 124
 125         // find the given point in the feature attributes
 126         std::list<AttributePtr> anObjectAttiributes =
 127           anObjectFeature->data()->attributes(GeomDataAPI_Point2D::typeId());
 128         std::list<AttributePtr>::const_iterator anIt = anObjectAttiributes.begin(),
 129                                                 aLast = anObjectAttiributes.end();
 130         for (; anIt != aLast && !aGeomPoint; anIt++) {
 131           std::shared_ptr<GeomDataAPI_Point2D> anAttributePoint =
 132             std::dynamic_pointer_cast<GeomDataAPI_Point2D>(*anIt);
 133
 134           std::shared_ptr<GeomAPI_Pnt> anAttributePnt = thePlane->to3D(anAttributePoint->x(),
 135                                                                        anAttributePoint->y());
 136           if (anAttributePnt.get() &&
 137               anAttributePnt->distance(aShapeGeomPnt) < Precision::Confusion()) {
 138             aGeomPoint = anAttributePoint;
 139             break;
 140           }
 141         }
 142       }
 143     }
 144   }
 145   return aGeomPoint;
 146 }
 147
 148 //*************************************************************************************
 149 std::shared_ptr<GeomDataAPI_Point2D> getFeaturePoint(DataPtr theData,
 150                                                      const std::string& theAttribute,
 151                                                      const std::shared_ptr<GeomAPI_Ax3>& thePlane)
 152 {
 153   std::shared_ptr<GeomDataAPI_Point2D> aPointAttr;
 154
 155   if (!theData.get() || !theData->isValid()) /// essential check as it is called in openGl thread
 156     return aPointAttr;
 157
 158   FeaturePtr aFeature;
 159   std::shared_ptr<ModelAPI_AttributeRefAttr> anAttr = std::dynamic_pointer_cast<
 160       ModelAPI_AttributeRefAttr>(theData->attribute(theAttribute));
 161   if (anAttr) {
 162     if (anAttr->isObject()) {
 163       ObjectPtr anObject = anAttr->object();
 164       aFeature = ModelAPI_Feature::feature(anObject);
 165       if (aFeature && aFeature->getKind() == SketchPlugin_Point::ID()) {
 166         // Attribute refers to a point
 167         aPointAttr = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 168                      aFeature->data()->attribute(SketchPlugin_Point::COORD_ID()));
 169       }
 170       else {
 171         // if the attribute refers on another object
 172         ResultPtr aRes = std::dynamic_pointer_cast<ModelAPI_Result>(anObject);
 173         if (aRes.get()) {
 174           GeomShapePtr aShape = aRes->shape();
 175           if (aShape.get()) {
 176             TopoDS_Shape aTDSShape = aShape->impl<TopoDS_Shape>();
 177             aPointAttr = findGeomPoint(anObject, aTDSShape, thePlane);
 178           }
 179         }
 180       }
 181     }
 182     else if (anAttr->attr()) {
 183       // If attribute is a point
 184       aPointAttr = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(anAttr->attr());
 185     }
 186   }
 187   return aPointAttr;
 188 }
 189
 190 //*************************************************************************************
 191 std::list<ResultPtr> getFreePoints(const CompositeFeaturePtr& theSketch)
 192 {
 193   std::list<ResultPtr> aFreePoints;
 194   if (!theSketch)
 195     return aFreePoints;
 196
 197   AttributeRefListPtr aFeatures = theSketch->reflist(SketchPlugin_Sketch::FEATURES_ID());
 198   if (!aFeatures)
 199     return aFreePoints;
 200   std::list<ObjectPtr> anObjects = aFeatures->list();
 201   for (std::list<ObjectPtr>::iterator anObjIt = anObjects.begin();
 202        anObjIt != anObjects.end(); ++anObjIt) {
 203     FeaturePtr aCurrent = ModelAPI_Feature::feature(*anObjIt);
 204     if (aCurrent && aCurrent->getKind() == SketchPlugin_Point::ID()) {
 205       // check point is not referred by any constraints
 206       const std::set<AttributePtr>& aRefs = aCurrent->data()->refsToMe();
 207       std::set<AttributePtr>::iterator aRIt = aRefs.begin();
 208       for (; aRIt != aRefs.end(); ++aRIt) {
 209         FeaturePtr aRefFeat = ModelAPI_Feature::feature((*aRIt)->owner());
 210         std::shared_ptr<SketchPlugin_Constraint> aRefConstr =
 211             std::dynamic_pointer_cast<SketchPlugin_Constraint>(aRefFeat);
 212         if (aRefConstr)
 213           break;
 214       }
 215       if (aRIt == aRefs.end())
 216         aFreePoints.push_back(aCurrent->lastResult());
 217     }
 218   }
 219   return aFreePoints;
 220 }
 221
 222 //*************************************************************************************
 223 FeaturePtr getFeatureLine(DataPtr theData,
 224                           const std::string& theAttribute)
 225 {
 226   FeaturePtr aLine;
 227   if (!theData.get() || !theData->isValid()) /// essential check as it is called in openGl thread)
 228     return aLine;
 229
 230   std::shared_ptr<ModelAPI_AttributeRefAttr> anAttr =
 231     std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(theData->attribute(theAttribute));
 232   if (anAttr) {
 233     FeaturePtr aFeature = ModelAPI_Feature::feature(anAttr->object());
 234     if (aFeature && aFeature->getKind() == SketchPlugin_Line::ID()) {
 235       return aFeature;
 236     }
 237   }
 238   return aLine;
 239 }
 240
 241 //*************************************************************************************
 242 std::shared_ptr<GeomAPI_Pnt2d> getProjectionPoint(const FeaturePtr theLine,
 243                                                   const std::shared_ptr<GeomAPI_Pnt2d>& thePoint)
 244 {
 245   DataPtr aData = theLine->data();
 246   if (!aData.get() || !aData->isValid())
 247     return std::shared_ptr<GeomAPI_Pnt2d>();
 248
 249   std::shared_ptr<GeomDataAPI_Point2D> aPoint1 = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 250       aData->attribute(SketchPlugin_Line::START_ID()));
 251   std::shared_ptr<GeomDataAPI_Point2D> aPoint2 = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 252       aData->attribute(SketchPlugin_Line::END_ID()));
 253
 254   GeomAPI_Lin2d aLin2d(aPoint1->x(), aPoint1->y(), aPoint2->x(), aPoint2->y());
 255   return aLin2d.project(thePoint);
 256 }
 257
 258 static int MyPixelRatio = 1;
 259
 260 void setPixelRatio(int theRatio)
 261 {
 262   MyPixelRatio = theRatio;
 263 }
 264
 265 int pixelRatio()
 266 {
 267   return MyPixelRatio;
 268 }
 269
 270 static double MyArrowSize = 20;
 271
 272 double getArrowSize()
 273 {
 274   return MyArrowSize;
 275 }
 276
 277 void setArrowSize(double theSize)
 278 {
 279   MyArrowSize = theSize;
 280 }
 281
 282 int getDefaultArrowSize()
 283 {
 284   return 20;
 285 }
 286
 287 int getConfigArrowSize()
 288 {
 289   return Config_PropManager::integer("Visualization", "dimension_arrow_size");
 290 }
 291
 292 static double MyTextHeight = 16;
 293 double getTextHeight()
 294 {
 295   return MyTextHeight * MyPixelRatio;
 296 }
 297
 298 void setTextHeight(double theHeight)
 299 {
 300   MyTextHeight = theHeight;
 301 }
 302
 303 double getDefaultTextHeight()
 304 {
 305   return 16 * MyPixelRatio;
 306 }
 307
 308 double getConfigTextHeight()
 309 {
 310   return Config_PropManager::integer("Visualization", "dimension_value_size") * MyPixelRatio;
 311 }
 312
 313 double getFlyoutDistance(const ModelAPI_Feature* theConstraint)
 314 {
 315   std::shared_ptr<GeomDataAPI_Point2D> aFlyoutPoint =
 316       std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 317       const_cast<ModelAPI_Feature*>(
 318       theConstraint)->attribute(SketchPlugin_Constraint::FLYOUT_VALUE_PNT()));
 319   // for not initialized values return zero distance to avoid Presentation crash
 320   if (!aFlyoutPoint->isInitialized())
 321     return 0;
 322   return aFlyoutPoint->y();
 323 }
 324
 325 std::shared_ptr<GeomAPI_Pnt> getAnchorPoint(const ModelAPI_Feature* theConstraint,
 326                                             const std::shared_ptr<GeomAPI_Ax3>& thePlane)
 327 {
 328   ModelAPI_Feature* aConstraint = const_cast<ModelAPI_Feature*>(theConstraint);
 329   AttributeRefAttrPtr aRefAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(
 330       aConstraint->attribute(SketchPlugin_Constraint::ENTITY_A()));
 331   if (!aRefAttr || !aRefAttr->isObject() || !aRefAttr->object())
 332     return std::shared_ptr<GeomAPI_Pnt>();
 333
 334   FeaturePtr aFeature = ModelAPI_Feature::feature(aRefAttr->object());
 335   std::shared_ptr<GeomAPI_Pnt2d> aCenter;
 336   if (aFeature->getKind() == SketchPlugin_Arc::ID()) { // arc
 337     aCenter = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 338         aFeature->attribute(SketchPlugin_Arc::CENTER_ID()))->pnt();
 339   } else if (aFeature->getKind() == SketchPlugin_Circle::ID()) { // circle
 340     aCenter = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 341         aFeature->attribute(SketchPlugin_Circle::CENTER_ID()))->pnt();
 342   } else
 343     return std::shared_ptr<GeomAPI_Pnt>();
 344
 345   std::shared_ptr<GeomAPI_Pnt2d> anOrigin(new GeomAPI_Pnt2d(0.0, 0.0));
 346   std::shared_ptr<GeomAPI_Pnt2d> aFlyoutPnt = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 347       aConstraint->attribute(SketchPlugin_Constraint::FLYOUT_VALUE_PNT()))->pnt();
 348   double aRadius = std::dynamic_pointer_cast<ModelAPI_AttributeDouble>(
 349       aConstraint->attribute(SketchPlugin_Constraint::VALUE()))->value();
 350   double aLen = aFlyoutPnt->distance(anOrigin);
 351   aRadius *= 1.001; // a gap to make point much closer to the circle, but not lying on it
 352   aFlyoutPnt->setX(aCenter->x() + aFlyoutPnt->x() * aRadius / aLen);
 353   aFlyoutPnt->setY(aCenter->y() + aFlyoutPnt->y() * aRadius / aLen);
 354   return thePlane->to3D(aFlyoutPnt->x(), aFlyoutPnt->y());
 355 }
 356
 357 void sendExpressionShownEvent(const bool& theState)
 358 {
 359   static Events_ID anId = SketcherPrs_ParameterStyleMessage::eventId();
 360   std::shared_ptr<SketcherPrs_ParameterStyleMessage> aMessage = std::shared_ptr
 361     <SketcherPrs_ParameterStyleMessage>(new SketcherPrs_ParameterStyleMessage(anId, 0));
 362   aMessage->setStyle(theState ? SketcherPrs_ParameterStyleMessage::ParameterText
 363                               : SketcherPrs_ParameterStyleMessage::ParameterValue);
 364   Events_Loop::loop()->send(aMessage);
 365   Events_Loop::loop()->flush(anId);
 366 }
 367
 368 void sendEmptyPresentationError(ModelAPI_Feature* theFeature, const std::string theError)
 369 {
 370   Events_InfoMessage("SketcherPrs_Tools",
 371     "An empty AIS presentation: SketcherPrs_LengthDimension").send();
 372   static const Events_ID anEvent = Events_Loop::eventByName(EVENT_EMPTY_AIS_PRESENTATION);
 373   std::shared_ptr<ModelAPI_Object> aConstraintPtr(theFeature);
 374   ModelAPI_EventCreator::get()->sendUpdated(aConstraintPtr, anEvent);
 375 }
 376 };