X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;ds=sidebyside;f=src%2FSketcherPrs%2FSketcherPrs_LengthDimension.cpp;h=f81fe13c244851c82ad2a2f4e4926b6285eaf630;hb=06e7f5859095193fc7f498bd89a7d28009794f53;hp=5e5c60465379a607308c023fc738da9d62df5df5;hpb=a94fc319f2aa64b43c9a73b5ff7063923648faec;p=modules%2Fshaper.git diff --git a/src/SketcherPrs/SketcherPrs_LengthDimension.cpp b/src/SketcherPrs/SketcherPrs_LengthDimension.cpp index 5e5c60465..f81fe13c2 100644 --- a/src/SketcherPrs/SketcherPrs_LengthDimension.cpp +++ b/src/SketcherPrs/SketcherPrs_LengthDimension.cpp @@ -1,4 +1,4 @@ -// Copyright (C) 2014-2017 CEA/DEN, EDF R&D +// Copyright (C) 2014-2023 CEA, EDF // // This library is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public @@ -12,15 +12,14 @@ // // 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 +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA // -// See http://www.salome-platform.org/ or -// email : webmaster.salome@opencascade.com +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com // #include "SketcherPrs_LengthDimension.h" #include "SketcherPrs_Tools.h" -#include "SketcherPrs_DimensionStyleListener.h" +#include "SketcherPrs_DimensionStyle.h" #include #include @@ -39,9 +38,10 @@ #include #include +#include -#include +#define OCCT_28850_FIXED /// Creates an aspect to be shown in length/radius dimension presentations /// \return an instance of aspect @@ -52,7 +52,7 @@ Handle(Prs3d_DimensionAspect) createDimensionAspect() anAspect->MakeText3d(false); anAspect->MakeTextShaded(false); anAspect->MakeUnitsDisplayed(false); - anAspect->TextAspect()->SetHeight(SketcherPrs_Tools::getDefaultTextHeight()); + anAspect->TextAspect()->SetHeight(SketcherPrs_Tools::getConfigTextHeight()); anAspect->ArrowAspect()->SetLength(SketcherPrs_Tools::getArrowSize()); return anAspect; @@ -63,21 +63,38 @@ Handle(Prs3d_DimensionAspect) createDimensionAspect() /// \param theDimValue an arrow value /// \param theTextSize an arrow value void updateArrows(Handle(Prs3d_DimensionAspect) theDimAspect, - double theDimValue, double theTextSize) + double theDimValue, double theTextSize, SketcherPrs_Tools::LocationType theLocationType) { - double anArrowLength = theDimAspect->ArrowAspect()->Length(); - // This is not realy correct way to get viewer scale. - double aViewerScale = (double) SketcherPrs_Tools::getDefaultArrowSize() / anArrowLength; - - if(theTextSize > ((theDimValue - 3 * SketcherPrs_Tools::getArrowSize()) * aViewerScale)) { - theDimAspect->SetTextHorizontalPosition(Prs3d_DTHP_Left); + 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); - } else { - theDimAspect->SetTextHorizontalPosition(Prs3d_DTHP_Center); - theDimAspect->SetArrowOrientation(Prs3d_DAO_Internal); + (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); @@ -88,13 +105,13 @@ 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_RTTIEXT(SketcherPrs_LengthDimension, AIS_LengthDimension); +IMPLEMENT_STANDARD_RTTIEXT(SketcherPrs_LengthDimension, PrsDim_LengthDimension); SketcherPrs_LengthDimension::SketcherPrs_LengthDimension(ModelAPI_Feature* theConstraint, - const std::shared_ptr& thePlane) -: AIS_LengthDimension(MyDefStart, MyDefEnd, MyDefPln), + SketchPlugin_Sketch* theSketcher) +: PrsDim_LengthDimension(MyDefStart, MyDefEnd, MyDefPln), myConstraint(theConstraint), - mySketcherPlane(thePlane), + mySketcher(theSketcher), myFirstPoint(MyDefStart), mySecondPoint(MyDefEnd), myPlane(MyDefPln), @@ -102,7 +119,9 @@ SketcherPrs_LengthDimension::SketcherPrs_LengthDimension(ModelAPI_Feature* theCo myValue(0., false, "") { SetDimensionAspect(createDimensionAspect()); - myStyleListener = new SketcherPrs_DimensionStyleListener(); + myStyleListener = new SketcherPrs_DimensionStyle(); + + setDirection(theConstraint, plane()); } SketcherPrs_LengthDimension::~SketcherPrs_LengthDimension() @@ -113,27 +132,71 @@ SketcherPrs_LengthDimension::~SketcherPrs_LengthDimension() bool SketcherPrs_LengthDimension::IsReadyToDisplay(ModelAPI_Feature* theConstraint, const std::shared_ptr& thePlane) { - gp_Pnt aPnt1, aPnt2; + gp_Pnt2d aPnt1, aPnt2; return readyToDisplay(theConstraint, thePlane, aPnt1, aPnt2); } +static bool isEqualPoints(ModelAPI_Feature* theConstraint, + const gp_Pnt2d& theP1, const gp_Pnt2d& theP2) +{ + bool isEqual = false; + if (theConstraint->getKind() == SketchPlugin_ConstraintDistanceHorizontal::ID()) + isEqual = Abs(theP1.X() - theP2.X()) < Precision::Confusion(); + else if (theConstraint->getKind() == SketchPlugin_ConstraintDistanceVertical::ID()) + isEqual = Abs(theP1.Y() - theP2.Y()) < Precision::Confusion(); + else { + isEqual = theP1.SquareDistance(theP2) < Precision::SquareConfusion(); + } + return isEqual; +} + void SketcherPrs_LengthDimension::Compute( const Handle(PrsMgr_PresentationManager3d)& thePresentationManager, const Handle(Prs3d_Presentation)& thePresentation, const Standard_Integer theMode) { - gp_Pnt aPnt1, aPnt2; - bool aReadyToDisplay = readyToDisplay(myConstraint, mySketcherPlane, aPnt1, aPnt2); + if (!plane().get()) + return; + gp_Pnt2d aP1, aP2; + bool aReadyToDisplay = readyToDisplay(myConstraint, plane(), aP1, aP2); if (aReadyToDisplay) { - myFirstPoint = aPnt1; - mySecondPoint = aPnt2; + if (isEqualPoints(myConstraint, aP1, aP2)) { + // 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; + + gp_XY aDir(x, y); + aP1.ChangeCoord().Add(aDir * (-Precision::Confusion())); + aP2.ChangeCoord().Add(aDir * Precision::Confusion()); + } + + myFirstPoint = plane()->to3D(aP1.X(), aP1.Y())->impl(); + mySecondPoint = plane()->to3D(aP2.X(), aP2.Y())->impl(); myDistance = SketcherPrs_Tools::getFlyoutDistance(myConstraint); - myPlane = gp_Pln(mySketcherPlane->impl()); + myPlane = gp_Pln(plane()->impl()); DataPtr aData = myConstraint->data(); - AttributeDoublePtr anAttributeValue = aData->real(SketchPlugin_Constraint::VALUE()); + 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 @@ -144,12 +207,27 @@ void SketcherPrs_LengthDimension::Compute( double aTextSize = 0.0; GetValueString(aTextSize); - updateArrows(DimensionAspect(), GetValue(), 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); + PrsDim_LengthDimension::Compute(thePresentationManager, thePresentation, theMode); if (!aReadyToDisplay) SketcherPrs_Tools::sendEmptyPresentationError(myConstraint, @@ -158,8 +236,11 @@ void SketcherPrs_LengthDimension::Compute( bool SketcherPrs_LengthDimension::readyToDisplay(ModelAPI_Feature* theConstraint, const std::shared_ptr& thePlane, - gp_Pnt& thePnt1, gp_Pnt& thePnt2) + gp_Pnt2d& thePnt1, gp_Pnt2d& thePnt2) { + if (!thePlane) + return false; + DataPtr aData = theConstraint->data(); if (theConstraint->getKind() == SketchPlugin_ConstraintLength::ID()) { // The constraint is length @@ -181,8 +262,8 @@ bool SketcherPrs_LengthDimension::readyToDisplay(ModelAPI_Feature* theConstraint std::shared_ptr aEndPoint = std::dynamic_pointer_cast (aLineData->attribute(SketchPlugin_Line::END_ID())); - thePnt1 = thePlane->to3D(aStartPoint->x(), aStartPoint->y())->impl(); - thePnt2 = thePlane->to3D(aEndPoint->x(), aEndPoint->y())->impl(); + thePnt1 = gp_Pnt2d(aStartPoint->x(), aStartPoint->y()); + thePnt2 = gp_Pnt2d(aEndPoint->x(), aEndPoint->y()); return true; } else if (theConstraint->getKind() == SketchPlugin_ConstraintDistance::ID() || @@ -221,10 +302,8 @@ bool SketcherPrs_LengthDimension::readyToDisplay(ModelAPI_Feature* theConstraint 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(); + thePnt1 = gp_Pnt2d(aPnt_A->x(), aPnt_A->y()); + thePnt2 = gp_Pnt2d(aPnt_B->x(), aPnt_B->y()); return true; } return false; @@ -256,6 +335,17 @@ void SketcherPrs_LengthDimension::ComputeSelection(const Handle(SelectMgr_Select return; } } - SetSelToleranceForText2d(SketcherPrs_Tools::getTextHeight()); - AIS_LengthDimension::ComputeSelection(aSelection, aMode); + SetSelToleranceForText2d(SketcherPrs_Tools::getArrowSize()/5.); + PrsDim_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 }