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
  10 #include <SketchPlugin_Constraint.h>
  11 #include <SketchPlugin_ConstraintLength.h>
  12 #include <SketchPlugin_ConstraintDistance.h>
  13 #include <SketchPlugin_Line.h>
  14 #include <SketchPlugin_Point.h>
  15 #include <SketchPlugin_Circle.h>
  16
  17 #include <GeomDataAPI_Point2D.h>
  18 #include <GeomAPI_Pnt.h>
  19 #include <GeomAPI_XYZ.h>
  20 #include <GeomAPI_Pnt2d.h>
  21 #include <GeomAPI_Lin2d.h>
  22
  23 #include <ModelAPI_Data.h>
  24 #include <ModelAPI_AttributeDouble.h>
  25
  26 #include <AIS_DisplaySpecialSymbol.hxx>
  27
  28
  29 static const gp_Pnt MyDefStart(0,0,0);
  30 static const gp_Pnt MyDefEnd(1,0,0);
  31 static const gp_Pln MyDefPln(gp_Pnt(0,0,0), gp_Dir(0,0,1));
  32
  33 // it is not possible to use 0x2211 as summ symbol because it is not supported by
  34 // debian Linux platform
  35 static const Standard_ExtCharacter MySummSymbol(0x03A3);
  36
  37 IMPLEMENT_STANDARD_HANDLE(SketcherPrs_LengthDimension, AIS_LengthDimension);
  38 IMPLEMENT_STANDARD_RTTIEXT(SketcherPrs_LengthDimension, AIS_LengthDimension);
  39
  40 SketcherPrs_LengthDimension::SketcherPrs_LengthDimension(ModelAPI_Feature* theConstraint,
  41                         const std::shared_ptr<GeomAPI_Ax3>& thePlane)
  42 : AIS_LengthDimension(MyDefStart, MyDefEnd, MyDefPln),
  43 myConstraint(theConstraint), myPlane(thePlane)
  44 {
  45   myAspect = new Prs3d_DimensionAspect();
  46   myAspect->MakeArrows3d(false);
  47   myAspect->MakeText3d(false);
  48   myAspect->MakeTextShaded(false);
  49   myAspect->MakeUnitsDisplayed(false);
  50   myAspect->TextAspect()->SetHeight(SketcherPrs_Tools::getDefaultTextHeight());
  51   myAspect->ArrowAspect()->SetLength(SketcherPrs_Tools::getArrowSize());
  52
  53   SetSelToleranceForText2d(SketcherPrs_Tools::getTextHeight());
  54   SetDimensionAspect(myAspect);
  55 }
  56
  57
  58 void SketcherPrs_LengthDimension::Compute(const Handle(PrsMgr_PresentationManager3d)& thePresentationManager,
  59                                  const Handle(Prs3d_Presentation)& thePresentation,
  60                                  const Standard_Integer theMode)
  61 {
  62   gp_Pnt aPnt1, aPnt2;
  63   if (!getPoints(aPnt1, aPnt2))
  64     return;
  65
  66   // compute flyout distance
  67   double aD = SketcherPrs_Tools::getFlyoutDistance(myConstraint);
  68   SetFlyout(SketcherPrs_Tools::getFlyoutDistance(myConstraint));
  69   SetMeasuredGeometry(aPnt1, aPnt2, myPlane->impl<gp_Ax3>());
  70
  71   // Update variable aspect parameters (depending on viewer scale)
  72   myAspect->SetExtensionSize(myAspect->ArrowAspect()->Length());
  73   myAspect->SetArrowTailSize(myAspect->ArrowAspect()->Length());
  74   // The value of vertical aligment is sometimes changed
  75   myAspect->TextAspect()->SetVerticalJustification(Graphic3d_VTA_CENTER);
  76
  77   AttributeDoublePtr aValue = myConstraint->data()->real(SketchPlugin_Constraint::VALUE());
  78   std::set<std::string> aParams = aValue->usedParameters();
  79   if (aParams.size() > 0) {
  80     SetSpecialSymbol(MySummSymbol);
  81     SetDisplaySpecialSymbol(AIS_DSS_Before);
  82   }
  83
  84   AIS_LengthDimension::Compute(thePresentationManager, thePresentation, theMode);
  85 }
  86
  87 bool SketcherPrs_LengthDimension::getPoints(gp_Pnt& thePnt1, gp_Pnt& thePnt2)
  88 {
  89   DataPtr aData = myConstraint->data();
  90   if (myConstraint->getKind() == SketchPlugin_ConstraintLength::ID()) {
  91     // The constraint is length
  92     std::shared_ptr<ModelAPI_AttributeRefAttr> anAttr =
  93       std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>
  94       (aData->attribute(SketchPlugin_Constraint::ENTITY_A()));
  95     if (!anAttr)
  96       return false;
  97
  98     FeaturePtr aFeature = ModelAPI_Feature::feature(anAttr->object());
  99     if (!aFeature || aFeature->getKind() != SketchPlugin_Line::ID())
 100       return false;
 101
 102     // Get geometry of the object
 103     DataPtr aLineData = aFeature->data();
 104     std::shared_ptr<GeomDataAPI_Point2D> aStartPoint =
 105       std::dynamic_pointer_cast<GeomDataAPI_Point2D>
 106       (aLineData->attribute(SketchPlugin_Line::START_ID()));
 107     std::shared_ptr<GeomDataAPI_Point2D> aEndPoint =
 108       std::dynamic_pointer_cast<GeomDataAPI_Point2D>
 109       (aLineData->attribute(SketchPlugin_Line::END_ID()));
 110     thePnt1 = myPlane->to3D(aStartPoint->x(), aStartPoint->y())->impl<gp_Pnt>();
 111     thePnt2 = myPlane->to3D(aEndPoint->x(), aEndPoint->y())->impl<gp_Pnt>();
 112     return true;
 113
 114   } else if (myConstraint->getKind() == SketchPlugin_ConstraintDistance::ID()) {
 115     // The constraint is distance
 116     std::shared_ptr<GeomDataAPI_Point2D> aPoint_A = SketcherPrs_Tools::getFeaturePoint(
 117         aData, SketchPlugin_Constraint::ENTITY_A(), myPlane);
 118     std::shared_ptr<GeomDataAPI_Point2D> aPoint_B = SketcherPrs_Tools::getFeaturePoint(
 119         aData, SketchPlugin_Constraint::ENTITY_B(), myPlane);
 120
 121     std::shared_ptr<GeomAPI_Pnt2d> aPnt_A;
 122     std::shared_ptr<GeomAPI_Pnt2d> aPnt_B;
 123     if (aPoint_A && aPoint_B) {
 124       // Both objects are points
 125       aPnt_A = aPoint_A->pnt();
 126       aPnt_B = aPoint_B->pnt();
 127     } else if (!aPoint_A && aPoint_B) {
 128       // First object is line
 129       FeaturePtr aLine = SketcherPrs_Tools::getFeatureLine(
 130           aData, SketchPlugin_Constraint::ENTITY_A());
 131       if (aLine) {
 132         aPnt_B = aPoint_B->pnt();
 133         aPnt_A = SketcherPrs_Tools::getProjectionPoint(aLine, aPnt_B);
 134       }
 135     } else if (aPoint_A && !aPoint_B) {
 136       // Second object is line
 137       FeaturePtr aLine = SketcherPrs_Tools::getFeatureLine(
 138           aData, SketchPlugin_Constraint::ENTITY_B());
 139       if (aLine) {
 140         aPnt_A = aPoint_A->pnt();
 141         aPnt_B = SketcherPrs_Tools::getProjectionPoint(aLine, aPnt_A);
 142       }
 143     }
 144     if (!aPnt_A || !aPnt_B) // Objects not found
 145       return false;
 146
 147     // Get points from these objects
 148     std::shared_ptr<GeomAPI_Pnt> aPoint1 = myPlane->to3D(aPnt_A->x(), aPnt_A->y());
 149     std::shared_ptr<GeomAPI_Pnt> aPoint2 = myPlane->to3D(aPnt_B->x(), aPnt_B->y());
 150     thePnt1 = aPoint1->impl<gp_Pnt>();
 151     thePnt2 = aPoint2->impl<gp_Pnt>();
 152     return true;
 153   }
 154   return false;
 155 }
 156
 157
 158
 159 void SketcherPrs_LengthDimension::ComputeSelection(const Handle(SelectMgr_Selection)& aSelection,
 160                                                    const Standard_Integer theMode)
 161 {
 162   // Map the application selection modes to standard ones
 163   Standard_Integer aMode;
 164   switch (theMode) {
 165   case 0: // we should use selection of all objects
 166     aMode = 0;
 167     break;
 168   case SketcherPrs_Tools::Sel_Dimension_All:
 169     aMode = 0;
 170     break;
 171   case SketcherPrs_Tools::Sel_Dimension_Line:
 172     aMode = 1;
 173     break;
 174   case SketcherPrs_Tools::Sel_Dimension_Text:
 175     aMode = 2;
 176     break;
 177   default: {
 178     // there are own selection modes, so the others should be ignored
 179     // otherwise, the text selection appears in the viewer
 180     return;
 181   }
 182   }
 183   SetSelToleranceForText2d(SketcherPrs_Tools::getTextHeight());
 184   AIS_LengthDimension::ComputeSelection(aSelection, aMode);
 185 }