src/SketcherPrs/SketcherPrs_LengthDimension.cpp

   1 // Copyright (C) 2014-2020  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_LengthDimension.h"
  21 #include "SketcherPrs_Tools.h"
  22 #include "SketcherPrs_DimensionStyle.h"
  23
  24 #include <SketchPlugin_Constraint.h>
  25 #include <SketchPlugin_ConstraintLength.h>
  26 #include <SketchPlugin_ConstraintDistance.h>
  27 #include <SketchPlugin_ConstraintDistanceHorizontal.h>
  28 #include <SketchPlugin_ConstraintDistanceVertical.h>
  29 #include <SketchPlugin_Line.h>
  30 #include <SketchPlugin_Point.h>
  31 #include <SketchPlugin_Circle.h>
  32
  33 #include <GeomDataAPI_Point2D.h>
  34 #include <GeomAPI_Pnt.h>
  35 #include <GeomAPI_XYZ.h>
  36 #include <GeomAPI_Pnt2d.h>
  37 #include <GeomAPI_Lin2d.h>
  38
  39 #include <ModelAPI_Data.h>
  40 #include <ModelAPI_AttributeDouble.h>
  41 #include <ModelAPI_AttributeInteger.h>
  42
  43 #include <AIS_DisplaySpecialSymbol.hxx>
  44
  45 #define OCCT_28850_FIXED
  46
  47 /// Creates an aspect to be shown in length/radius dimension presentations
  48 /// \return an instance of aspect
  49 Handle(Prs3d_DimensionAspect) createDimensionAspect()
  50 {
  51   Handle(Prs3d_DimensionAspect) anAspect = new Prs3d_DimensionAspect();
  52   anAspect->MakeArrows3d(false);
  53   anAspect->MakeText3d(false);
  54   anAspect->MakeTextShaded(false);
  55   anAspect->MakeUnitsDisplayed(false);
  56   anAspect->TextAspect()->SetHeight(SketcherPrs_Tools::getConfigTextHeight());
  57   anAspect->ArrowAspect()->SetLength(SketcherPrs_Tools::getArrowSize());
  58
  59   return anAspect;
  60 }
  61
  62 /// Update variable aspect parameters (depending on viewer scale)
  63 /// \param theDimAspect an aspect to be changed
  64 /// \param theDimValue an arrow value
  65 /// \param theTextSize an arrow value
  66 void updateArrows(Handle(Prs3d_DimensionAspect) theDimAspect,
  67   double theDimValue, double theTextSize, SketcherPrs_Tools::LocationType theLocationType)
  68 {
  69   if (theLocationType == SketcherPrs_Tools::LOCATION_AUTOMATIC) {
  70     double anArrowLength = theDimAspect->ArrowAspect()->Length();
  71      // This is not realy correct way to get viewer scale.
  72     double aViewerScale = (double) SketcherPrs_Tools::getConfigArrowSize() / anArrowLength;
  73
  74     if(theTextSize > ((theDimValue - 3 * SketcherPrs_Tools::getArrowSize()) * aViewerScale)) {
  75       theDimAspect->SetTextHorizontalPosition(Prs3d_DTHP_Left);
  76       theDimAspect->SetArrowOrientation(Prs3d_DAO_External);
  77       theDimAspect->SetExtensionSize(
  78         (theTextSize / aViewerScale + SketcherPrs_Tools::getArrowSize()) / 2.0);
  79     } else {
  80       theDimAspect->SetTextHorizontalPosition(Prs3d_DTHP_Center);
  81       theDimAspect->SetArrowOrientation(Prs3d_DAO_Internal);
  82     }
  83   }
  84   else if (theLocationType == SketcherPrs_Tools::LOCATION_RIGHT ||
  85            theLocationType == SketcherPrs_Tools::LOCATION_LEFT) {
  86     theDimAspect->SetTextHorizontalPosition(
  87       theLocationType == SketcherPrs_Tools::LOCATION_LEFT ? Prs3d_DTHP_Left : Prs3d_DTHP_Right);
  88     theDimAspect->SetArrowOrientation(Prs3d_DAO_External);
  89
  90     double anArrowLength = theDimAspect->ArrowAspect()->Length();
  91     // This is not realy correct way to get viewer scale.
  92     double aViewerScale = (double) SketcherPrs_Tools::getConfigArrowSize() / anArrowLength;
  93     theDimAspect->SetExtensionSize(
  94         (theTextSize / aViewerScale + SketcherPrs_Tools::getArrowSize()) / 2.0);
  95   }
  96   theDimAspect->TextAspect()->SetFont(Config_PropManager::string("Visualization",
  97                                       "dimension_font").c_str());
  98
  99   theDimAspect->SetArrowTailSize(theDimAspect->ArrowAspect()->Length());
 100   // The value of vertical aligment is sometimes changed
 101   theDimAspect->TextAspect()->SetVerticalJustification(Graphic3d_VTA_CENTER);
 102 }
 103
 104
 105 static const gp_Pnt MyDefStart(0,0,0);
 106 static const gp_Pnt MyDefEnd(1,0,0);
 107 static const gp_Pln MyDefPln(gp_Pnt(0,0,0), gp_Dir(0,0,1));
 108
 109 IMPLEMENT_STANDARD_RTTIEXT(SketcherPrs_LengthDimension, AIS_LengthDimension);
 110
 111 SketcherPrs_LengthDimension::SketcherPrs_LengthDimension(ModelAPI_Feature* theConstraint,
 112   SketchPlugin_Sketch* theSketcher)
 113 : AIS_LengthDimension(MyDefStart, MyDefEnd, MyDefPln),
 114   myConstraint(theConstraint),
 115   mySketcher(theSketcher),
 116   myFirstPoint(MyDefStart),
 117   mySecondPoint(MyDefEnd),
 118   myPlane(MyDefPln),
 119   myDistance(1),
 120   myValue(0., false, "")
 121 {
 122   SetDimensionAspect(createDimensionAspect());
 123   myStyleListener = new SketcherPrs_DimensionStyle();
 124
 125   setDirection(theConstraint, plane());
 126 }
 127
 128 SketcherPrs_LengthDimension::~SketcherPrs_LengthDimension()
 129 {
 130   delete myStyleListener;
 131 }
 132
 133 bool SketcherPrs_LengthDimension::IsReadyToDisplay(ModelAPI_Feature* theConstraint,
 134                                          const std::shared_ptr<GeomAPI_Ax3>& thePlane)
 135 {
 136   gp_Pnt aPnt1, aPnt2;
 137   return readyToDisplay(theConstraint, thePlane, aPnt1, aPnt2);
 138 }
 139
 140 static bool isEqualPoints(ModelAPI_Feature* theConstraint,
 141                           const gp_Pnt& thePoint1,
 142                           const gp_Pnt& thePoint2)
 143 {
 144   bool isEqual = false;
 145   if (theConstraint->getKind() == SketchPlugin_ConstraintDistanceHorizontal::ID())
 146     isEqual = Abs(thePoint1.X() - thePoint2.X()) < Precision::Confusion();
 147   else if (theConstraint->getKind() == SketchPlugin_ConstraintDistanceVertical::ID())
 148     isEqual = Abs(thePoint1.Y() - thePoint2.Y()) < Precision::Confusion();
 149   else
 150     isEqual = thePoint1.SquareDistance(thePoint2) < Precision::SquareConfusion();
 151   return isEqual;
 152 }
 153
 154 void SketcherPrs_LengthDimension::Compute(
 155   const Handle(PrsMgr_PresentationManager3d)& thePresentationManager,
 156   const Handle(Prs3d_Presentation)& thePresentation,
 157   const Standard_Integer theMode)
 158 {
 159   if (!plane().get())
 160     return;
 161   gp_Pnt aPnt1, aPnt2;
 162   bool aReadyToDisplay = readyToDisplay(myConstraint, plane(), aPnt1, aPnt2);
 163   if (aReadyToDisplay) {
 164     if (isEqualPoints(myConstraint, aPnt1, aPnt2)) {
 165       // adjust points to draw the dimension presentation
 166       std::shared_ptr<GeomDataAPI_Dir> aDirAttr = std::dynamic_pointer_cast<GeomDataAPI_Dir>(
 167           myConstraint->attribute(SketchPlugin_ConstraintDistance::DIRECTION_ID()));
 168       double x = 0.0, y = 0.0;
 169       if (aDirAttr && aDirAttr->isInitialized()) {
 170         x = aDirAttr->x();
 171         y = aDirAttr->y();
 172         if (x == 0.0 && y == 0.0)
 173           x = 1.0;
 174       }
 175       else if (myConstraint->getKind() == SketchPlugin_ConstraintDistanceVertical::ID())
 176         y = 1.0;
 177       else
 178         x = 1.0;
 179       GeomPointPtr aCoord = plane()->to3D(x, y);
 180
 181       gp_XYZ aDir(aCoord->x(), aCoord->y(), aCoord->z());
 182       aPnt1.ChangeCoord().Add(aDir * (-Precision::Confusion()));
 183       aPnt2.ChangeCoord().Add(aDir * Precision::Confusion());
 184     }
 185
 186     myFirstPoint = aPnt1;
 187     mySecondPoint = aPnt2;
 188
 189     myDistance = SketcherPrs_Tools::getFlyoutDistance(myConstraint);
 190     myPlane = gp_Pln(plane()->impl<gp_Ax3>());
 191
 192     DataPtr aData = myConstraint->data();
 193     AttributeDoublePtr anAttributeValue;
 194     if (myConstraint->getKind() == SketchPlugin_ConstraintDistanceHorizontal::ID() ||
 195         myConstraint->getKind() == SketchPlugin_ConstraintDistanceVertical::ID())
 196       anAttributeValue = aData->real(SketchPlugin_ConstraintDistanceAlongDir::DISTANCE_VALUE_ID());
 197     else
 198       anAttributeValue = aData->real(SketchPlugin_Constraint::VALUE());
 199     myValue.init(anAttributeValue);
 200
 201     setDirection(myConstraint, plane());
 202   }
 203
 204   // compute flyout distance
 205   SetFlyout(myDistance);
 206   SetMeasuredGeometry(myFirstPoint, mySecondPoint, myPlane);
 207
 208   // Update variable aspect parameters (depending on viewer scale)
 209   double aTextSize = 0.0;
 210   GetValueString(aTextSize);
 211
 212   std::string aLocationAttribute;
 213   std::string aConstraintKind = myConstraint->getKind();
 214   if (aConstraintKind == SketchPlugin_ConstraintLength::ID())
 215     aLocationAttribute = SketchPlugin_ConstraintLength::LOCATION_TYPE_ID();
 216   else if (aConstraintKind == SketchPlugin_ConstraintDistance::ID())
 217     aLocationAttribute = SketchPlugin_ConstraintDistance::LOCATION_TYPE_ID();
 218   else if (aConstraintKind == SketchPlugin_ConstraintDistanceHorizontal::ID())
 219     aLocationAttribute = SketchPlugin_ConstraintDistanceHorizontal::LOCATION_TYPE_ID();
 220   else if (aConstraintKind == SketchPlugin_ConstraintDistanceVertical::ID())
 221     aLocationAttribute = SketchPlugin_ConstraintDistanceVertical::LOCATION_TYPE_ID();
 222
 223   AttributeIntegerPtr aLocAttr = std::dynamic_pointer_cast<ModelAPI_AttributeInteger>
 224     (myConstraint->data()->attribute(aLocationAttribute));
 225   SketcherPrs_Tools::LocationType aLocationType = aLocAttr->isInitialized() ?
 226     (SketcherPrs_Tools::LocationType)(aLocAttr->value()) : SketcherPrs_Tools::LOCATION_AUTOMATIC;
 227   updateArrows(DimensionAspect(), GetValue(), aTextSize, aLocationType);
 228
 229   // Update text visualization: parameter value or parameter text
 230   myStyleListener->updateDimensions(this, myValue);
 231
 232   AIS_LengthDimension::Compute(thePresentationManager, thePresentation, theMode);
 233
 234   if (!aReadyToDisplay)
 235     SketcherPrs_Tools::sendEmptyPresentationError(myConstraint,
 236                               "An empty AIS presentation: SketcherPrs_LengthDimension");
 237 }
 238
 239 bool SketcherPrs_LengthDimension::readyToDisplay(ModelAPI_Feature* theConstraint,
 240                                                  const std::shared_ptr<GeomAPI_Ax3>& thePlane,
 241                                                  gp_Pnt& thePnt1, gp_Pnt& thePnt2)
 242 {
 243   if (!thePlane)
 244     return false;
 245
 246   DataPtr aData = theConstraint->data();
 247   if (theConstraint->getKind() == SketchPlugin_ConstraintLength::ID()) {
 248     // The constraint is length
 249     std::shared_ptr<ModelAPI_AttributeRefAttr> anAttr =
 250       std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>
 251       (aData->attribute(SketchPlugin_Constraint::ENTITY_A()));
 252     if (!anAttr)
 253       return false;
 254
 255     FeaturePtr aFeature = ModelAPI_Feature::feature(anAttr->object());
 256     if (!aFeature || aFeature->getKind() != SketchPlugin_Line::ID())
 257       return false;
 258
 259     // Get geometry of the object
 260     DataPtr aLineData = aFeature->data();
 261     std::shared_ptr<GeomDataAPI_Point2D> aStartPoint =
 262       std::dynamic_pointer_cast<GeomDataAPI_Point2D>
 263       (aLineData->attribute(SketchPlugin_Line::START_ID()));
 264     std::shared_ptr<GeomDataAPI_Point2D> aEndPoint =
 265       std::dynamic_pointer_cast<GeomDataAPI_Point2D>
 266       (aLineData->attribute(SketchPlugin_Line::END_ID()));
 267     thePnt1 = thePlane->to3D(aStartPoint->x(), aStartPoint->y())->impl<gp_Pnt>();
 268     thePnt2 = thePlane->to3D(aEndPoint->x(), aEndPoint->y())->impl<gp_Pnt>();
 269     return true;
 270
 271   } else if (theConstraint->getKind() == SketchPlugin_ConstraintDistance::ID() ||
 272              theConstraint->getKind() == SketchPlugin_ConstraintDistanceHorizontal::ID() ||
 273              theConstraint->getKind() == SketchPlugin_ConstraintDistanceVertical::ID()) {
 274     // The constraint is distance
 275     std::shared_ptr<GeomDataAPI_Point2D> aPoint_A = SketcherPrs_Tools::getFeaturePoint(
 276         aData, SketchPlugin_Constraint::ENTITY_A(), thePlane);
 277     std::shared_ptr<GeomDataAPI_Point2D> aPoint_B = SketcherPrs_Tools::getFeaturePoint(
 278         aData, SketchPlugin_Constraint::ENTITY_B(), thePlane);
 279
 280     std::shared_ptr<GeomAPI_Pnt2d> aPnt_A;
 281     std::shared_ptr<GeomAPI_Pnt2d> aPnt_B;
 282     if (aPoint_A && aPoint_B) {
 283       // Both objects are points
 284       aPnt_A = aPoint_A->pnt();
 285       aPnt_B = aPoint_B->pnt();
 286     } else if (!aPoint_A && aPoint_B) {
 287       // First object is line
 288       FeaturePtr aLine = SketcherPrs_Tools::getFeatureLine(
 289           aData, SketchPlugin_Constraint::ENTITY_A());
 290       if (aLine) {
 291         aPnt_B = aPoint_B->pnt();
 292         aPnt_A = SketcherPrs_Tools::getProjectionPoint(aLine, aPnt_B);
 293       }
 294     } else if (aPoint_A && !aPoint_B) {
 295       // Second object is line
 296       FeaturePtr aLine = SketcherPrs_Tools::getFeatureLine(
 297           aData, SketchPlugin_Constraint::ENTITY_B());
 298       if (aLine) {
 299         aPnt_A = aPoint_A->pnt();
 300         aPnt_B = SketcherPrs_Tools::getProjectionPoint(aLine, aPnt_A);
 301       }
 302     }
 303     if (!aPnt_A || !aPnt_B) // Objects not found
 304       return false;
 305
 306     /*if (theConstraint->getKind() == SketchPlugin_ConstraintDistanceHorizontal::ID()) {
 307       if (fabs(aPnt_A->x() - aPnt_B->x()) < Precision::Confusion())
 308         return false;
 309     }
 310     else if (theConstraint->getKind() == SketchPlugin_ConstraintDistanceVertical::ID()) {
 311       if (fabs(aPnt_A->y() - aPnt_B->y()) < Precision::Confusion())
 312         return false;
 313     }*/
 314
 315     // Get points from these object
 316     std::shared_ptr<GeomAPI_Pnt> aPoint1 = thePlane->to3D(aPnt_A->x(), aPnt_A->y());
 317     std::shared_ptr<GeomAPI_Pnt> aPoint2 = thePlane->to3D(aPnt_B->x(), aPnt_B->y());
 318     thePnt1 = aPoint1->impl<gp_Pnt>();
 319     thePnt2 = aPoint2->impl<gp_Pnt>();
 320     return true;
 321   }
 322   return false;
 323 }
 324
 325
 326
 327 void SketcherPrs_LengthDimension::ComputeSelection(const Handle(SelectMgr_Selection)& aSelection,
 328                                                    const Standard_Integer theMode)
 329 {
 330   // Map the application selection modes to standard ones
 331   Standard_Integer aMode;
 332   switch (theMode) {
 333   case 0: // we should use selection of all objects
 334     aMode = 0;
 335     break;
 336   case SketcherPrs_Tools::Sel_Dimension_All:
 337     aMode = 0;
 338     break;
 339   case SketcherPrs_Tools::Sel_Dimension_Line:
 340     aMode = 1;
 341     break;
 342   case SketcherPrs_Tools::Sel_Dimension_Text:
 343     aMode = 2;
 344     break;
 345   default: {
 346     // there are own selection modes, so the others should be ignored
 347     // otherwise, the text selection appears in the viewer
 348     return;
 349   }
 350   }
 351   SetSelToleranceForText2d(SketcherPrs_Tools::getArrowSize()/5.);
 352   AIS_LengthDimension::ComputeSelection(aSelection, aMode);
 353 }
 354
 355 void SketcherPrs_LengthDimension::setDirection(ModelAPI_Feature* theConstraint,
 356                                                const std::shared_ptr<GeomAPI_Ax3>& thePlane)
 357 {
 358 #ifdef OCCT_28850_FIXED
 359   if (theConstraint->getKind() == SketchPlugin_ConstraintDistanceHorizontal::ID())
 360     SetDirection(thePlane->dirX()->impl<gp_Dir>(), true);
 361   else if (theConstraint->getKind() == SketchPlugin_ConstraintDistanceVertical::ID())
 362     SetDirection(thePlane->dirY()->impl<gp_Dir>(), true);
 363 #endif
 364 }