src/SketcherPrs/SketcherPrs_LengthDimension.cpp

   1 // Copyright (C) 2014-20xx CEA/DEN, EDF R&D
   2
   3 // File:        SketcherPrs_LengthDimension.cpp
   4 // Created:     27 March 2015
   5 // Author:      Vitaly SMETANNIKOV
   6
   7 #include "SketcherPrs_LengthDimension.h"
   8 #include "SketcherPrs_Tools.h"
   9 #include "SketcherPrs_DimensionStyleListener.h"
  10
  11 #include <SketchPlugin_Constraint.h>
  12 #include <SketchPlugin_ConstraintLength.h>
  13 #include <SketchPlugin_ConstraintDistance.h>
  14 #include <SketchPlugin_Line.h>
  15 #include <SketchPlugin_Point.h>
  16 #include <SketchPlugin_Circle.h>
  17
  18 #include <GeomDataAPI_Point2D.h>
  19 #include <GeomAPI_Pnt.h>
  20 #include <GeomAPI_XYZ.h>
  21 #include <GeomAPI_Pnt2d.h>
  22 #include <GeomAPI_Lin2d.h>
  23
  24 #include <ModelAPI_Data.h>
  25 #include <ModelAPI_AttributeDouble.h>
  26
  27 #include <AIS_DisplaySpecialSymbol.hxx>
  28
  29
  30 static const gp_Pnt MyDefStart(0,0,0);
  31 static const gp_Pnt MyDefEnd(1,0,0);
  32 static const gp_Pln MyDefPln(gp_Pnt(0,0,0), gp_Dir(0,0,1));
  33
  34 IMPLEMENT_STANDARD_HANDLE(SketcherPrs_LengthDimension, AIS_LengthDimension);
  35 IMPLEMENT_STANDARD_RTTIEXT(SketcherPrs_LengthDimension, AIS_LengthDimension);
  36
  37 SketcherPrs_LengthDimension::SketcherPrs_LengthDimension(ModelAPI_Feature* theConstraint,
  38                                               const std::shared_ptr<GeomAPI_Ax3>& thePlane)
  39 : AIS_LengthDimension(MyDefStart, MyDefEnd, MyDefPln),
  40   myConstraint(theConstraint),
  41   mySketcherPlane(thePlane),
  42   myFirstPoint(MyDefStart),
  43   mySecondPoint(MyDefEnd),
  44   myPlane(MyDefPln),
  45   myDistance(1),
  46   myValue(0., false, "")
  47 {
  48   SetDimensionAspect(SketcherPrs_Tools::createDimensionAspect());
  49   myStyleListener = new SketcherPrs_DimensionStyleListener();
  50 }
  51
  52 SketcherPrs_LengthDimension::~SketcherPrs_LengthDimension()
  53 {
  54   delete myStyleListener;
  55 }
  56
  57 bool SketcherPrs_LengthDimension::IsReadyToDisplay(ModelAPI_Feature* theConstraint,
  58                                          const std::shared_ptr<GeomAPI_Ax3>& thePlane)
  59 {
  60   gp_Pnt aPnt1, aPnt2;
  61   return readyToDisplay(theConstraint, thePlane, aPnt1, aPnt2);
  62 }
  63
  64 void SketcherPrs_LengthDimension::Compute(
  65   const Handle(PrsMgr_PresentationManager3d)& thePresentationManager,
  66   const Handle(Prs3d_Presentation)& thePresentation,
  67   const Standard_Integer theMode)
  68 {
  69   gp_Pnt aPnt1, aPnt2;
  70   bool aReadyToDisplay = readyToDisplay(myConstraint, mySketcherPlane, aPnt1, aPnt2);
  71   if (aReadyToDisplay) {
  72     myFirstPoint = aPnt1;
  73     mySecondPoint = aPnt2;
  74
  75     myDistance = SketcherPrs_Tools::getFlyoutDistance(myConstraint);
  76     myPlane = gp_Pln(mySketcherPlane->impl<gp_Ax3>());
  77
  78     DataPtr aData = myConstraint->data();
  79     AttributeDoublePtr anAttributeValue = aData->real(SketchPlugin_Constraint::VALUE());
  80     myValue.init(anAttributeValue);
  81   }
  82
  83   // compute flyout distance
  84   SetFlyout(myDistance);
  85   SetMeasuredGeometry(myFirstPoint, mySecondPoint, myPlane);
  86
  87   // Update variable aspect parameters (depending on viewer scale)
  88   double aTextSize = 0.0;
  89   GetValueString(aTextSize);
  90   SketcherPrs_Tools::updateArrows(DimensionAspect(), GetValue(), aTextSize);
  91
  92   // Update text visualization: parameter value or parameter text
  93   myStyleListener->updateDimensions(this, myValue);
  94
  95   AIS_LengthDimension::Compute(thePresentationManager, thePresentation, theMode);
  96
  97   if (!aReadyToDisplay)
  98     SketcherPrs_Tools::sendEmptyPresentationError(myConstraint,
  99                               "An empty AIS presentation: SketcherPrs_LengthDimension");
 100 }
 101
 102 bool SketcherPrs_LengthDimension::readyToDisplay(ModelAPI_Feature* theConstraint,
 103                                                  const std::shared_ptr<GeomAPI_Ax3>& thePlane,
 104                                                  gp_Pnt& thePnt1, gp_Pnt& thePnt2)
 105 {
 106   DataPtr aData = theConstraint->data();
 107   if (theConstraint->getKind() == SketchPlugin_ConstraintLength::ID()) {
 108     // The constraint is length
 109     std::shared_ptr<ModelAPI_AttributeRefAttr> anAttr =
 110       std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>
 111       (aData->attribute(SketchPlugin_Constraint::ENTITY_A()));
 112     if (!anAttr)
 113       return false;
 114
 115     FeaturePtr aFeature = ModelAPI_Feature::feature(anAttr->object());
 116     if (!aFeature || aFeature->getKind() != SketchPlugin_Line::ID())
 117       return false;
 118
 119     // Get geometry of the object
 120     DataPtr aLineData = aFeature->data();
 121     std::shared_ptr<GeomDataAPI_Point2D> aStartPoint =
 122       std::dynamic_pointer_cast<GeomDataAPI_Point2D>
 123       (aLineData->attribute(SketchPlugin_Line::START_ID()));
 124     std::shared_ptr<GeomDataAPI_Point2D> aEndPoint =
 125       std::dynamic_pointer_cast<GeomDataAPI_Point2D>
 126       (aLineData->attribute(SketchPlugin_Line::END_ID()));
 127     thePnt1 = thePlane->to3D(aStartPoint->x(), aStartPoint->y())->impl<gp_Pnt>();
 128     thePnt2 = thePlane->to3D(aEndPoint->x(), aEndPoint->y())->impl<gp_Pnt>();
 129     return true;
 130
 131   } else if (theConstraint->getKind() == SketchPlugin_ConstraintDistance::ID()) {
 132     // The constraint is distance
 133     std::shared_ptr<GeomDataAPI_Point2D> aPoint_A = SketcherPrs_Tools::getFeaturePoint(
 134         aData, SketchPlugin_Constraint::ENTITY_A(), thePlane);
 135     std::shared_ptr<GeomDataAPI_Point2D> aPoint_B = SketcherPrs_Tools::getFeaturePoint(
 136         aData, SketchPlugin_Constraint::ENTITY_B(), thePlane);
 137
 138     std::shared_ptr<GeomAPI_Pnt2d> aPnt_A;
 139     std::shared_ptr<GeomAPI_Pnt2d> aPnt_B;
 140     if (aPoint_A && aPoint_B) {
 141       // Both objects are points
 142       aPnt_A = aPoint_A->pnt();
 143       aPnt_B = aPoint_B->pnt();
 144     } else if (!aPoint_A && aPoint_B) {
 145       // First object is line
 146       FeaturePtr aLine = SketcherPrs_Tools::getFeatureLine(
 147           aData, SketchPlugin_Constraint::ENTITY_A());
 148       if (aLine) {
 149         aPnt_B = aPoint_B->pnt();
 150         aPnt_A = SketcherPrs_Tools::getProjectionPoint(aLine, aPnt_B);
 151       }
 152     } else if (aPoint_A && !aPoint_B) {
 153       // Second object is line
 154       FeaturePtr aLine = SketcherPrs_Tools::getFeatureLine(
 155           aData, SketchPlugin_Constraint::ENTITY_B());
 156       if (aLine) {
 157         aPnt_A = aPoint_A->pnt();
 158         aPnt_B = SketcherPrs_Tools::getProjectionPoint(aLine, aPnt_A);
 159       }
 160     }
 161     if (!aPnt_A || !aPnt_B) // Objects not found
 162       return false;
 163
 164     // Get points from these object
 165     std::shared_ptr<GeomAPI_Pnt> aPoint1 = thePlane->to3D(aPnt_A->x(), aPnt_A->y());
 166     std::shared_ptr<GeomAPI_Pnt> aPoint2 = thePlane->to3D(aPnt_B->x(), aPnt_B->y());
 167     thePnt1 = aPoint1->impl<gp_Pnt>();
 168     thePnt2 = aPoint2->impl<gp_Pnt>();
 169     return true;
 170   }
 171   return false;
 172 }
 173
 174
 175
 176 void SketcherPrs_LengthDimension::ComputeSelection(const Handle(SelectMgr_Selection)& aSelection,
 177                                                    const Standard_Integer theMode)
 178 {
 179   // Map the application selection modes to standard ones
 180   Standard_Integer aMode;
 181   switch (theMode) {
 182   case 0: // we should use selection of all objects
 183     aMode = 0;
 184     break;
 185   case SketcherPrs_Tools::Sel_Dimension_All:
 186     aMode = 0;
 187     break;
 188   case SketcherPrs_Tools::Sel_Dimension_Line:
 189     aMode = 1;
 190     break;
 191   case SketcherPrs_Tools::Sel_Dimension_Text:
 192     aMode = 2;
 193     break;
 194   default: {
 195     // there are own selection modes, so the others should be ignored
 196     // otherwise, the text selection appears in the viewer
 197     return;
 198   }
 199   }
 200   SetSelToleranceForText2d(SketcherPrs_Tools::getTextHeight());
 201   AIS_LengthDimension::ComputeSelection(aSelection, aMode);
 202 }