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