X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FSketcherPrs%2FSketcherPrs_LengthDimension.cpp;h=1ac0cf756283787c7b23bdf528f577ae9519b095;hb=1dfcab3d738e427bea678317e167c587dfbff195;hp=99cd15c37b176b488c3c403f855ccad6bff2ca53;hpb=acaa4d04df93d44ed6c093584aa7de2f7f86b5e3;p=modules%2Fshaper.git diff --git a/src/SketcherPrs/SketcherPrs_LengthDimension.cpp b/src/SketcherPrs/SketcherPrs_LengthDimension.cpp index 99cd15c37..1ac0cf756 100644 --- a/src/SketcherPrs/SketcherPrs_LengthDimension.cpp +++ b/src/SketcherPrs/SketcherPrs_LengthDimension.cpp @@ -1,15 +1,31 @@ -// Copyright (C) 2014-20xx CEA/DEN, EDF R&D - -// File: SketcherPrs_LengthDimension.cpp -// Created: 27 March 2015 -// Author: Vitaly SMETANNIKOV +// Copyright (C) 2014-2020 CEA/DEN, EDF R&D +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +// #include "SketcherPrs_LengthDimension.h" #include "SketcherPrs_Tools.h" +#include "SketcherPrs_DimensionStyle.h" #include #include #include +#include +#include #include #include #include @@ -21,80 +37,216 @@ #include #include +#include +#include + +#include + +#define OCCT_28850_FIXED + +/// Creates an aspect to be shown in length/radius dimension presentations +/// \return an instance of aspect +Handle(Prs3d_DimensionAspect) createDimensionAspect() +{ + Handle(Prs3d_DimensionAspect) anAspect = new Prs3d_DimensionAspect(); + anAspect->MakeArrows3d(false); + anAspect->MakeText3d(false); + anAspect->MakeTextShaded(false); + anAspect->MakeUnitsDisplayed(false); + anAspect->TextAspect()->SetHeight(SketcherPrs_Tools::getConfigTextHeight()); + anAspect->ArrowAspect()->SetLength(SketcherPrs_Tools::getArrowSize()); + + return anAspect; +} + +/// Update variable aspect parameters (depending on viewer scale) +/// \param theDimAspect an aspect to be changed +/// \param theDimValue an arrow value +/// \param theTextSize an arrow value +void updateArrows(Handle(Prs3d_DimensionAspect) theDimAspect, + double theDimValue, double theTextSize, SketcherPrs_Tools::LocationType theLocationType) +{ + if (theLocationType == SketcherPrs_Tools::LOCATION_AUTOMATIC) { + double anArrowLength = theDimAspect->ArrowAspect()->Length(); + // This is not realy correct way to get viewer scale. + double aViewerScale = (double) SketcherPrs_Tools::getConfigArrowSize() / anArrowLength; + + if(theTextSize > ((theDimValue - 3 * SketcherPrs_Tools::getArrowSize()) * aViewerScale)) { + theDimAspect->SetTextHorizontalPosition(Prs3d_DTHP_Left); + theDimAspect->SetArrowOrientation(Prs3d_DAO_External); + theDimAspect->SetExtensionSize( + (theTextSize / aViewerScale + SketcherPrs_Tools::getArrowSize()) / 2.0); + } else { + theDimAspect->SetTextHorizontalPosition(Prs3d_DTHP_Center); + theDimAspect->SetArrowOrientation(Prs3d_DAO_Internal); + } + } + else if (theLocationType == SketcherPrs_Tools::LOCATION_RIGHT || + theLocationType == SketcherPrs_Tools::LOCATION_LEFT) { + theDimAspect->SetTextHorizontalPosition( + theLocationType == SketcherPrs_Tools::LOCATION_LEFT ? Prs3d_DTHP_Left : Prs3d_DTHP_Right); + theDimAspect->SetArrowOrientation(Prs3d_DAO_External); + + double anArrowLength = theDimAspect->ArrowAspect()->Length(); + // This is not realy correct way to get viewer scale. + double aViewerScale = (double) SketcherPrs_Tools::getConfigArrowSize() / anArrowLength; + theDimAspect->SetExtensionSize( + (theTextSize / aViewerScale + SketcherPrs_Tools::getArrowSize()) / 2.0); + } + theDimAspect->TextAspect()->SetFont(Config_PropManager::string("Visualization", + "dimension_font").c_str()); + + theDimAspect->SetArrowTailSize(theDimAspect->ArrowAspect()->Length()); + // The value of vertical aligment is sometimes changed + theDimAspect->TextAspect()->SetVerticalJustification(Graphic3d_VTA_CENTER); +} static const gp_Pnt MyDefStart(0,0,0); static const gp_Pnt MyDefEnd(1,0,0); static const gp_Pln MyDefPln(gp_Pnt(0,0,0), gp_Dir(0,0,1)); -IMPLEMENT_STANDARD_HANDLE(SketcherPrs_LengthDimension, AIS_LengthDimension); IMPLEMENT_STANDARD_RTTIEXT(SketcherPrs_LengthDimension, AIS_LengthDimension); -SketcherPrs_LengthDimension::SketcherPrs_LengthDimension(ModelAPI_Feature* theConstraint, - const std::shared_ptr& thePlane) -: AIS_LengthDimension(MyDefStart, MyDefEnd, MyDefPln), -myConstraint(theConstraint), myPlane(thePlane) +SketcherPrs_LengthDimension::SketcherPrs_LengthDimension(ModelAPI_Feature* theConstraint, + SketchPlugin_Sketch* theSketcher) +: AIS_LengthDimension(MyDefStart, MyDefEnd, MyDefPln), + myConstraint(theConstraint), + mySketcher(theSketcher), + myFirstPoint(MyDefStart), + mySecondPoint(MyDefEnd), + myPlane(MyDefPln), + myDistance(1), + myValue(0., false, "") { - myAspect = new Prs3d_DimensionAspect(); - myAspect->MakeArrows3d(false); - myAspect->MakeText3d(false); - myAspect->MakeTextShaded(false); - myAspect->MakeUnitsDisplayed(false); - myAspect->TextAspect()->SetHeight(MyTextHeight); - myAspect->ArrowAspect()->SetLength(SketcherPrs_Tools::getArrowSize()); - - SetSelToleranceForText2d(MyTextHeight); - SetDimensionAspect(myAspect); + SetDimensionAspect(createDimensionAspect()); + myStyleListener = new SketcherPrs_DimensionStyle(); + + setDirection(theConstraint, plane()); } +SketcherPrs_LengthDimension::~SketcherPrs_LengthDimension() +{ + delete myStyleListener; +} -void SketcherPrs_LengthDimension::Compute(const Handle(PrsMgr_PresentationManager3d)& thePresentationManager, - const Handle(Prs3d_Presentation)& thePresentation, - const Standard_Integer theMode) +bool SketcherPrs_LengthDimension::IsReadyToDisplay(ModelAPI_Feature* theConstraint, + const std::shared_ptr& thePlane) { gp_Pnt aPnt1, aPnt2; - if (!getPoints(aPnt1, aPnt2)) + return readyToDisplay(theConstraint, thePlane, aPnt1, aPnt2); +} + +static bool isEqualPoints(ModelAPI_Feature* theConstraint, + const gp_Pnt& thePoint1, + const gp_Pnt& thePoint2) +{ + bool isEqual = false; + if (theConstraint->getKind() == SketchPlugin_ConstraintDistanceHorizontal::ID()) + isEqual = Abs(thePoint1.X() - thePoint2.X()) < Precision::Confusion(); + else if (theConstraint->getKind() == SketchPlugin_ConstraintDistanceVertical::ID()) + isEqual = Abs(thePoint1.Y() - thePoint2.Y()) < Precision::Confusion(); + else + isEqual = thePoint1.SquareDistance(thePoint2) < Precision::SquareConfusion(); + return isEqual; +} + +void SketcherPrs_LengthDimension::Compute( + const Handle(PrsMgr_PresentationManager3d)& thePresentationManager, + const Handle(Prs3d_Presentation)& thePresentation, + const Standard_Integer theMode) +{ + if (!plane().get()) return; - //DataPtr aData = myConstraint->data(); - - //AttributePtr aFlyOutAttribute = aData->attribute(SketchPlugin_Constraint::FLYOUT_VALUE_PNT()); - //if (!aFlyOutAttribute->isInitialized()) { - // return; // not possible to show length because points are not defined - //} - //std::shared_ptr aFlyOutAttr = - // std::dynamic_pointer_cast(aFlyOutAttribute); - //std::shared_ptr aFlyoutPnt = myPlane->to3D(aFlyOutAttr->x(), aFlyOutAttr->y()); - //gp_Pnt aFlyPnt = aFlyoutPnt->impl(); - - //double aDistance = aPnt1.Distance(aPnt2); - - //double aFlyout = 0; - //double aDist = 0.0; - //if (aDistance < Precision::Confusion()) - // aDist = aPnt1.Distance(aFlyPnt); - //else { - // gp_Lin aLine(aPnt1, gp_Vec(aPnt1, aPnt2)); - // aDist = aLine.Distance(aFlyPnt); - //} - - //gp_XYZ aLineDir = aPnt2.XYZ().Subtracted(aPnt1.XYZ()); - //gp_XYZ aFOutDir = aFlyPnt.XYZ().Subtracted(aPnt1.XYZ()); - //gp_XYZ aNorm = myPlane->norm()->xyz()->impl(); - //if (aLineDir.Crossed(aFOutDir).Dot(aNorm) < 0) - // aDist = -aDist; - //aFlyout = aDist; - - //SetFlyout(aFlyout); - SetFlyout(SketcherPrs_Tools::getFlyoutDistance(myConstraint)); - SetMeasuredGeometry(aPnt1, aPnt2, myPlane->impl()); + gp_Pnt aPnt1, aPnt2; + bool aReadyToDisplay = readyToDisplay(myConstraint, plane(), aPnt1, aPnt2); + if (aReadyToDisplay) { + if (isEqualPoints(myConstraint, aPnt1, aPnt2)) { + // adjust points to draw the dimension presentation + std::shared_ptr aDirAttr = std::dynamic_pointer_cast( + myConstraint->attribute(SketchPlugin_ConstraintDistance::DIRECTION_ID())); + double x = 0.0, y = 0.0; + if (aDirAttr && aDirAttr->isInitialized()) { + x = aDirAttr->x(); + y = aDirAttr->y(); + if (x == 0.0 && y == 0.0) + x = 1.0; + } + else if (myConstraint->getKind() == SketchPlugin_ConstraintDistanceVertical::ID()) + y = 1.0; + else + x = 1.0; + GeomPointPtr aCoord = plane()->to3D(x, y); + + gp_XYZ aDir(aCoord->x(), aCoord->y(), aCoord->z()); + aPnt1.ChangeCoord().Add(aDir * (-Precision::Confusion())); + aPnt2.ChangeCoord().Add(aDir * Precision::Confusion()); + } + + myFirstPoint = aPnt1; + mySecondPoint = aPnt2; + + myDistance = SketcherPrs_Tools::getFlyoutDistance(myConstraint); + myPlane = gp_Pln(plane()->impl()); + + DataPtr aData = myConstraint->data(); + AttributeDoublePtr anAttributeValue; + if (myConstraint->getKind() == SketchPlugin_ConstraintDistanceHorizontal::ID() || + myConstraint->getKind() == SketchPlugin_ConstraintDistanceVertical::ID()) + anAttributeValue = aData->real(SketchPlugin_ConstraintDistanceAlongDir::DISTANCE_VALUE_ID()); + else + anAttributeValue = aData->real(SketchPlugin_Constraint::VALUE()); + myValue.init(anAttributeValue); + + setDirection(myConstraint, plane()); + } + + // compute flyout distance + SetFlyout(myDistance); + SetMeasuredGeometry(myFirstPoint, mySecondPoint, myPlane); + + // Update variable aspect parameters (depending on viewer scale) + double aTextSize = 0.0; + GetValueString(aTextSize); + + std::string aLocationAttribute; + std::string aConstraintKind = myConstraint->getKind(); + if (aConstraintKind == SketchPlugin_ConstraintLength::ID()) + aLocationAttribute = SketchPlugin_ConstraintLength::LOCATION_TYPE_ID(); + else if (aConstraintKind == SketchPlugin_ConstraintDistance::ID()) + aLocationAttribute = SketchPlugin_ConstraintDistance::LOCATION_TYPE_ID(); + else if (aConstraintKind == SketchPlugin_ConstraintDistanceHorizontal::ID()) + aLocationAttribute = SketchPlugin_ConstraintDistanceHorizontal::LOCATION_TYPE_ID(); + else if (aConstraintKind == SketchPlugin_ConstraintDistanceVertical::ID()) + aLocationAttribute = SketchPlugin_ConstraintDistanceVertical::LOCATION_TYPE_ID(); + + AttributeIntegerPtr aLocAttr = std::dynamic_pointer_cast + (myConstraint->data()->attribute(aLocationAttribute)); + SketcherPrs_Tools::LocationType aLocationType = aLocAttr->isInitialized() ? + (SketcherPrs_Tools::LocationType)(aLocAttr->value()) : SketcherPrs_Tools::LOCATION_AUTOMATIC; + updateArrows(DimensionAspect(), GetValue(), aTextSize, aLocationType); + + // Update text visualization: parameter value or parameter text + myStyleListener->updateDimensions(this, myValue); + AIS_LengthDimension::Compute(thePresentationManager, thePresentation, theMode); + + if (!aReadyToDisplay) + SketcherPrs_Tools::sendEmptyPresentationError(myConstraint, + "An empty AIS presentation: SketcherPrs_LengthDimension"); } -bool SketcherPrs_LengthDimension::getPoints(gp_Pnt& thePnt1, gp_Pnt& thePnt2) const +bool SketcherPrs_LengthDimension::readyToDisplay(ModelAPI_Feature* theConstraint, + const std::shared_ptr& thePlane, + gp_Pnt& thePnt1, gp_Pnt& thePnt2) { - DataPtr aData = myConstraint->data(); - if (myConstraint->getKind() == SketchPlugin_ConstraintLength::ID()) { - std::shared_ptr anAttr = + if (!thePlane) + return false; + + DataPtr aData = theConstraint->data(); + if (theConstraint->getKind() == SketchPlugin_ConstraintLength::ID()) { + // The constraint is length + std::shared_ptr anAttr = std::dynamic_pointer_cast (aData->attribute(SketchPlugin_Constraint::ENTITY_A())); if (!anAttr) @@ -104,29 +256,35 @@ bool SketcherPrs_LengthDimension::getPoints(gp_Pnt& thePnt1, gp_Pnt& thePnt2) co if (!aFeature || aFeature->getKind() != SketchPlugin_Line::ID()) return false; + // Get geometry of the object DataPtr aLineData = aFeature->data(); - std::shared_ptr aStartPoint = + std::shared_ptr aStartPoint = std::dynamic_pointer_cast (aLineData->attribute(SketchPlugin_Line::START_ID())); - std::shared_ptr aEndPoint = + std::shared_ptr aEndPoint = std::dynamic_pointer_cast (aLineData->attribute(SketchPlugin_Line::END_ID())); - thePnt1 = myPlane->to3D(aStartPoint->x(), aStartPoint->y())->impl(); - thePnt2 = myPlane->to3D(aEndPoint->x(), aEndPoint->y())->impl(); + thePnt1 = thePlane->to3D(aStartPoint->x(), aStartPoint->y())->impl(); + thePnt2 = thePlane->to3D(aEndPoint->x(), aEndPoint->y())->impl(); return true; - } else if (myConstraint->getKind() == SketchPlugin_ConstraintDistance::ID()) { + } else if (theConstraint->getKind() == SketchPlugin_ConstraintDistance::ID() || + theConstraint->getKind() == SketchPlugin_ConstraintDistanceHorizontal::ID() || + theConstraint->getKind() == SketchPlugin_ConstraintDistanceVertical::ID()) { + // The constraint is distance std::shared_ptr aPoint_A = SketcherPrs_Tools::getFeaturePoint( - aData, SketchPlugin_Constraint::ENTITY_A()); + aData, SketchPlugin_Constraint::ENTITY_A(), thePlane); std::shared_ptr aPoint_B = SketcherPrs_Tools::getFeaturePoint( - aData, SketchPlugin_Constraint::ENTITY_B()); + aData, SketchPlugin_Constraint::ENTITY_B(), thePlane); std::shared_ptr aPnt_A; std::shared_ptr aPnt_B; if (aPoint_A && aPoint_B) { + // Both objects are points aPnt_A = aPoint_A->pnt(); aPnt_B = aPoint_B->pnt(); } else if (!aPoint_A && aPoint_B) { + // First object is line FeaturePtr aLine = SketcherPrs_Tools::getFeatureLine( aData, SketchPlugin_Constraint::ENTITY_A()); if (aLine) { @@ -134,6 +292,7 @@ bool SketcherPrs_LengthDimension::getPoints(gp_Pnt& thePnt1, gp_Pnt& thePnt2) co aPnt_A = SketcherPrs_Tools::getProjectionPoint(aLine, aPnt_B); } } else if (aPoint_A && !aPoint_B) { + // Second object is line FeaturePtr aLine = SketcherPrs_Tools::getFeatureLine( aData, SketchPlugin_Constraint::ENTITY_B()); if (aLine) { @@ -141,11 +300,21 @@ bool SketcherPrs_LengthDimension::getPoints(gp_Pnt& thePnt1, gp_Pnt& thePnt2) co aPnt_B = SketcherPrs_Tools::getProjectionPoint(aLine, aPnt_A); } } - if (!aPnt_A || !aPnt_B) + if (!aPnt_A || !aPnt_B) // Objects not found return false; - std::shared_ptr aPoint1 = myPlane->to3D(aPnt_A->x(), aPnt_A->y()); - std::shared_ptr aPoint2 = myPlane->to3D(aPnt_B->x(), aPnt_B->y()); + /*if (theConstraint->getKind() == SketchPlugin_ConstraintDistanceHorizontal::ID()) { + if (fabs(aPnt_A->x() - aPnt_B->x()) < Precision::Confusion()) + return false; + } + else if (theConstraint->getKind() == SketchPlugin_ConstraintDistanceVertical::ID()) { + if (fabs(aPnt_A->y() - aPnt_B->y()) < Precision::Confusion()) + return false; + }*/ + + // Get points from these object + std::shared_ptr aPoint1 = thePlane->to3D(aPnt_A->x(), aPnt_A->y()); + std::shared_ptr aPoint2 = thePlane->to3D(aPnt_B->x(), aPnt_B->y()); thePnt1 = aPoint1->impl(); thePnt2 = aPoint2->impl(); return true; @@ -158,8 +327,12 @@ bool SketcherPrs_LengthDimension::getPoints(gp_Pnt& thePnt1, gp_Pnt& thePnt2) co void SketcherPrs_LengthDimension::ComputeSelection(const Handle(SelectMgr_Selection)& aSelection, const Standard_Integer theMode) { + // Map the application selection modes to standard ones Standard_Integer aMode; switch (theMode) { + case 0: // we should use selection of all objects + aMode = 0; + break; case SketcherPrs_Tools::Sel_Dimension_All: aMode = 0; break; @@ -169,8 +342,23 @@ void SketcherPrs_LengthDimension::ComputeSelection(const Handle(SelectMgr_Select case SketcherPrs_Tools::Sel_Dimension_Text: aMode = 2; break; - default: - aMode = theMode; + default: { + // there are own selection modes, so the others should be ignored + // otherwise, the text selection appears in the viewer + return; + } } + SetSelToleranceForText2d(SketcherPrs_Tools::getArrowSize()/5.); AIS_LengthDimension::ComputeSelection(aSelection, aMode); } + +void SketcherPrs_LengthDimension::setDirection(ModelAPI_Feature* theConstraint, + const std::shared_ptr& thePlane) +{ +#ifdef OCCT_28850_FIXED + if (theConstraint->getKind() == SketchPlugin_ConstraintDistanceHorizontal::ID()) + SetDirection(thePlane->dirX()->impl(), true); + else if (theConstraint->getKind() == SketchPlugin_ConstraintDistanceVertical::ID()) + SetDirection(thePlane->dirY()->impl(), true); +#endif +}