src/SketcherPrs/SketcherPrs_Tools.cpp

   1 // Copyright (C) 2014-2017  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 "SketcherPrs_Tools.h"
  22
  23 #include <SketchPlugin_Constraint.h>
  24 #include <SketchPlugin_Point.h>
  25 #include <SketchPlugin_Circle.h>
  26 #include <SketchPlugin_Line.h>
  27 #include <SketchPlugin_Arc.h>
  28
  29 #include <ModelAPI_ResultConstruction.h>
  30 #include <ModelAPI_AttributeRefAttr.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 FeaturePtr getFeatureLine(DataPtr theData,
 192                           const std::string& theAttribute)
 193 {
 194   FeaturePtr aLine;
 195   if (!theData.get() || !theData->isValid()) /// essential check as it is called in openGl thread)
 196     return aLine;
 197
 198   std::shared_ptr<ModelAPI_AttributeRefAttr> anAttr =
 199     std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(theData->attribute(theAttribute));
 200   if (anAttr) {
 201     FeaturePtr aFeature = ModelAPI_Feature::feature(anAttr->object());
 202     if (aFeature && aFeature->getKind() == SketchPlugin_Line::ID()) {
 203       return aFeature;
 204     }
 205   }
 206   return aLine;
 207 }
 208
 209 //*************************************************************************************
 210 std::shared_ptr<GeomAPI_Pnt2d> getProjectionPoint(const FeaturePtr theLine,
 211                                                   const std::shared_ptr<GeomAPI_Pnt2d>& thePoint)
 212 {
 213   DataPtr aData = theLine->data();
 214   if (!aData.get() || !aData->isValid())
 215     return std::shared_ptr<GeomAPI_Pnt2d>();
 216
 217   std::shared_ptr<GeomDataAPI_Point2D> aPoint1 = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 218       aData->attribute(SketchPlugin_Line::START_ID()));
 219   std::shared_ptr<GeomDataAPI_Point2D> aPoint2 = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 220       aData->attribute(SketchPlugin_Line::END_ID()));
 221
 222   GeomAPI_Lin2d aLin2d(aPoint1->x(), aPoint1->y(), aPoint2->x(), aPoint2->y());
 223   return aLin2d.project(thePoint);
 224 }
 225
 226
 227 static double MyArrowSize = 20;
 228 double getArrowSize()
 229 {
 230   return MyArrowSize;
 231 }
 232
 233 void setArrowSize(double theSize)
 234 {
 235   MyArrowSize = theSize;
 236 }
 237
 238 int getDefaultArrowSize()
 239 {
 240   return 20;
 241 }
 242
 243 static double MyTextHeight = 16;
 244 double getTextHeight()
 245 {
 246   return MyTextHeight;
 247 }
 248
 249 void setTextHeight(double theHeight)
 250 {
 251   MyTextHeight = theHeight;
 252 }
 253
 254 double getDefaultTextHeight()
 255 {
 256   return 16;
 257 }
 258
 259 double getFlyoutDistance(const ModelAPI_Feature* theConstraint)
 260 {
 261   std::shared_ptr<GeomDataAPI_Point2D> aFlyoutPoint =
 262       std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 263       const_cast<ModelAPI_Feature*>(
 264       theConstraint)->attribute(SketchPlugin_Constraint::FLYOUT_VALUE_PNT()));
 265   // for not initialized values return zero distance to avoid Presentation crash
 266   if (!aFlyoutPoint->isInitialized())
 267     return 0;
 268   return aFlyoutPoint->y();
 269 }
 270
 271 std::shared_ptr<GeomAPI_Pnt> getAnchorPoint(const ModelAPI_Feature* theConstraint,
 272                                             const std::shared_ptr<GeomAPI_Ax3>& thePlane)
 273 {
 274   ModelAPI_Feature* aConstraint = const_cast<ModelAPI_Feature*>(theConstraint);
 275   AttributeRefAttrPtr aRefAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(
 276       aConstraint->attribute(SketchPlugin_Constraint::ENTITY_A()));
 277   if (!aRefAttr || !aRefAttr->isObject() || !aRefAttr->object())
 278     return std::shared_ptr<GeomAPI_Pnt>();
 279
 280   FeaturePtr aFeature = ModelAPI_Feature::feature(aRefAttr->object());
 281   std::shared_ptr<GeomAPI_Pnt2d> aCenter;
 282   if (aFeature->getKind() == SketchPlugin_Arc::ID()) { // arc
 283     aCenter = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 284         aFeature->attribute(SketchPlugin_Arc::CENTER_ID()))->pnt();
 285   } else if (aFeature->getKind() == SketchPlugin_Circle::ID()) { // circle
 286     aCenter = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 287         aFeature->attribute(SketchPlugin_Circle::CENTER_ID()))->pnt();
 288   } else
 289     return std::shared_ptr<GeomAPI_Pnt>();
 290
 291   std::shared_ptr<GeomAPI_Pnt2d> anOrigin(new GeomAPI_Pnt2d(0.0, 0.0));
 292   std::shared_ptr<GeomAPI_Pnt2d> aFlyoutPnt = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 293       aConstraint->attribute(SketchPlugin_Constraint::FLYOUT_VALUE_PNT()))->pnt();
 294   double aRadius = std::dynamic_pointer_cast<ModelAPI_AttributeDouble>(
 295       aConstraint->attribute(SketchPlugin_Constraint::VALUE()))->value();
 296   double aLen = aFlyoutPnt->distance(anOrigin);
 297   aRadius *= 1.001; // a gap to make point much closer to the circle, but not lying on it
 298   aFlyoutPnt->setX(aCenter->x() + aFlyoutPnt->x() * aRadius / aLen);
 299   aFlyoutPnt->setY(aCenter->y() + aFlyoutPnt->y() * aRadius / aLen);
 300   return thePlane->to3D(aFlyoutPnt->x(), aFlyoutPnt->y());
 301 }
 302
 303 void sendExpressionShownEvent(const bool& theState)
 304 {
 305   static Events_ID anId = SketcherPrs_ParameterStyleMessage::eventId();
 306   std::shared_ptr<SketcherPrs_ParameterStyleMessage> aMessage = std::shared_ptr
 307     <SketcherPrs_ParameterStyleMessage>(new SketcherPrs_ParameterStyleMessage(anId, 0));
 308   aMessage->setStyle(theState ? SketcherPrs_ParameterStyleMessage::ParameterText
 309                               : SketcherPrs_ParameterStyleMessage::ParameterValue);
 310   Events_Loop::loop()->send(aMessage);
 311   Events_Loop::loop()->flush(anId);
 312 }
 313
 314 void sendEmptyPresentationError(ModelAPI_Feature* theFeature, const std::string theError)
 315 {
 316   Events_InfoMessage("SketcherPrs_Tools",
 317     "An empty AIS presentation: SketcherPrs_LengthDimension").send();
 318   static const Events_ID anEvent = Events_Loop::eventByName(EVENT_EMPTY_AIS_PRESENTATION);
 319   std::shared_ptr<ModelAPI_Object> aConstraintPtr(theFeature);
 320   ModelAPI_EventCreator::get()->sendUpdated(aConstraintPtr, anEvent);
 321 }
 322 };