X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FSketchPlugin%2FSketchPlugin_ConstraintDistance.cpp;h=a119433d36f7f09a5b0cd801cd8811ce1f56505b;hb=74e9ba33303efc2282db1261706e904efa36b255;hp=0e8d30b6accfa5057a0347a7a0282ca73090d3dd;hpb=2a694eefa196c05f47e7eeba6191f313be198f25;p=modules%2Fshaper.git diff --git a/src/SketchPlugin/SketchPlugin_ConstraintDistance.cpp b/src/SketchPlugin/SketchPlugin_ConstraintDistance.cpp index 0e8d30b6a..a119433d3 100644 --- a/src/SketchPlugin/SketchPlugin_ConstraintDistance.cpp +++ b/src/SketchPlugin/SketchPlugin_ConstraintDistance.cpp @@ -1,159 +1,298 @@ +// Copyright (C) 2014-20xx CEA/DEN, EDF R&D --> + // File: SketchPlugin_ConstraintDistance.cpp // Created: 23 May 2014 // Author: Artem ZHIDKOV #include "SketchPlugin_ConstraintDistance.h" #include +#include +#include + +#include +#include -#include -#include +#include +#include +#include +#include #include #include #include -#include -#include -#include +#include + +#include -/// Obtain the point object from specified constraint parameter -static boost::shared_ptr getFeaturePoint( - DataPtr theData, - const std::string& theAttribute); +const double tolerance = 1e-7; SketchPlugin_ConstraintDistance::SketchPlugin_ConstraintDistance() { + myFlyoutUpdate = false; } +//************************************************************************************* void SketchPlugin_ConstraintDistance::initAttributes() { - data()->addAttribute(CONSTRAINT_ATTR_VALUE, ModelAPI_AttributeDouble::type()); - data()->addAttribute(CONSTRAINT_ATTR_FLYOUT_VALUE_PNT, GeomDataAPI_Point2D::type()); - data()->addAttribute(CONSTRAINT_ATTR_ENTITY_A, ModelAPI_AttributeRefAttr::type()); - data()->addAttribute(CONSTRAINT_ATTR_ENTITY_B, ModelAPI_AttributeRefAttr::type()); + data()->addAttribute(SketchPlugin_Constraint::VALUE(), ModelAPI_AttributeDouble::typeId()); + data()->addAttribute(SketchPlugin_Constraint::FLYOUT_VALUE_PNT(), GeomDataAPI_Point2D::typeId()); + data()->addAttribute(SketchPlugin_Constraint::ENTITY_A(), ModelAPI_AttributeRefAttr::typeId()); + data()->addAttribute(SketchPlugin_Constraint::ENTITY_B(), ModelAPI_AttributeRefAttr::typeId()); } +//************************************************************************************* void SketchPlugin_ConstraintDistance::execute() { - boost::shared_ptr aData = data(); + std::shared_ptr aData = data(); + AttributeDoublePtr anAttrValue = std::dynamic_pointer_cast( + aData->attribute(SketchPlugin_Constraint::VALUE())); - boost::shared_ptr aPoint_A = getFeaturePoint(aData, CONSTRAINT_ATTR_ENTITY_A); - boost::shared_ptr aPoint_B = getFeaturePoint(aData, CONSTRAINT_ATTR_ENTITY_B); - if (aPoint_A && aPoint_B) { - AttributeDoublePtr anAttr_Value = - boost::dynamic_pointer_cast(aData->attribute(CONSTRAINT_ATTR_VALUE)); + if(anAttrValue->isInitialized()) + return; - if (!anAttr_Value->isInitialized()) { - anAttr_Value->setValue(aPoint_A->pnt()->distance(aPoint_B->pnt())); - } + double aDistance = calculateCurrentDistance(); + if(aDistance >= 0) { + anAttrValue->setValue(aDistance); } + + // the value should to be computed here, not in the getAISObject in order to change the model value + // inside the object transaction. This is important for creating a constraint by preselection. + // The display of the presentation in this case happens after the transaction commit + std::shared_ptr aFlyOutAttr = std::dynamic_pointer_cast< + GeomDataAPI_Point2D>(aData->attribute(SketchPlugin_Constraint::FLYOUT_VALUE_PNT())); + if(!aFlyOutAttr->isInitialized()) + compute(SketchPlugin_Constraint::FLYOUT_VALUE_PNT()); } -Handle(AIS_InteractiveObject) SketchPlugin_ConstraintDistance::getAISShape( - Handle_AIS_InteractiveObject thePrevious) +bool SketchPlugin_ConstraintDistance::compute(const std::string& theAttributeId) { + if (theAttributeId != SketchPlugin_Constraint::FLYOUT_VALUE_PNT()) + return false; + if (!sketch()) - return thePrevious; + return false; - boost::shared_ptr aPlane = sketch()->plane(); + std::shared_ptr aFlyOutAttr = std::dynamic_pointer_cast< + GeomDataAPI_Point2D>(attribute(theAttributeId)); + if (fabs(aFlyOutAttr->x()) >= tolerance || fabs(aFlyOutAttr->y()) >= tolerance) + return false; DataPtr aData = data(); - boost::shared_ptr aPoint_A = getFeaturePoint(aData, CONSTRAINT_ATTR_ENTITY_A); - boost::shared_ptr aPoint_B = getFeaturePoint(aData, CONSTRAINT_ATTR_ENTITY_B); - if (!aPoint_A || !aPoint_B) - return thePrevious; + std::shared_ptr aPlane = SketchPlugin_Sketch::plane(sketch()); + std::shared_ptr aPoint_A = SketcherPrs_Tools::getFeaturePoint( + aData, SketchPlugin_Constraint::ENTITY_A(), aPlane); + std::shared_ptr aPoint_B = SketcherPrs_Tools::getFeaturePoint( + aData, SketchPlugin_Constraint::ENTITY_B(), aPlane); + + std::shared_ptr aPnt_A; + std::shared_ptr aPnt_B; - // fly out calculation - boost::shared_ptr aFlyOutAttr = - boost::dynamic_pointer_cast(aData->attribute(CONSTRAINT_ATTR_FLYOUT_VALUE_PNT)); - double aFlyout = 0; - if (aFlyOutAttr->isInitialized()) { - boost::shared_ptr aFlyOutPnt = aFlyOutAttr->pnt(); - - boost::shared_ptr aFeatureLin = - boost::shared_ptr(new GeomAPI_Lin2d(aPoint_A->x(), aPoint_A->y(), - aPoint_B->x(), aPoint_B->y())); - boost::shared_ptr aProjectedPoint = aFeatureLin->project(aFlyOutPnt); - double aDistance = aFlyOutPnt->distance(aProjectedPoint); - if (!aFeatureLin->isRight(aFlyOutPnt)) - aDistance = -aDistance; - aFlyout = aDistance; + if (aPoint_A && aPoint_B) { + aPnt_A = aPoint_A->pnt(); + aPnt_B = aPoint_B->pnt(); + } else if (!aPoint_A && aPoint_B) { + FeaturePtr aLine = SketcherPrs_Tools::getFeatureLine( + aData, SketchPlugin_Constraint::ENTITY_A()); + if (aLine) { + aPnt_B = aPoint_B->pnt(); + aPnt_A = SketcherPrs_Tools::getProjectionPoint(aLine, aPnt_B); + } + } else if (aPoint_A && !aPoint_B) { + FeaturePtr aLine = SketcherPrs_Tools::getFeatureLine( + aData, SketchPlugin_Constraint::ENTITY_B()); + if (aLine) { + aPnt_A = aPoint_A->pnt(); + aPnt_B = SketcherPrs_Tools::getProjectionPoint(aLine, aPnt_A); + } } + if (!aPnt_A || !aPnt_B) + return false; - //Build dimension here - boost::shared_ptr aPoint1 = sketch()->to3D(aPoint_A->x(), aPoint_A->y()); - boost::shared_ptr aPoint2 = sketch()->to3D(aPoint_B->x(), aPoint_B->y()); + std::shared_ptr aPoint1 = sketch()->to3D(aPnt_A->x(), aPnt_A->y()); + std::shared_ptr aPoint2 = sketch()->to3D(aPnt_B->x(), aPnt_B->y()); + // it is not possible to create lin2d on the points with equal position + if (aPoint1->distance(aPoint2) < tolerance) + return false; - // value calculation - boost::shared_ptr aValueAttr = - boost::dynamic_pointer_cast(aData->attribute(CONSTRAINT_ATTR_VALUE)); - double aValue = aValueAttr->value(); + std::shared_ptr aLine = std::shared_ptr(new GeomAPI_Lin2d(aPnt_A, aPnt_B)); + double aDist = aPoint1->distance(aPoint2)/5.; + std::shared_ptr aFPnt = aLine->shiftedLocation(aDist); + aFlyOutAttr->setValue(aFPnt); - Handle(AIS_InteractiveObject) anAIS = thePrevious; - if (anAIS.IsNull()) - { - Handle(AIS_LengthDimension) aDimAIS = - new AIS_LengthDimension(aPoint1->impl(), aPoint2->impl(), aPlane->impl()); - aDimAIS->SetCustomValue(aValue); - - Handle(Prs3d_DimensionAspect) anAspect = new Prs3d_DimensionAspect(); - anAspect->MakeArrows3d (Standard_False); - anAspect->MakeText3d(false); - anAspect->TextAspect()->SetHeight(CONSTRAINT_TEXT_HEIGHT); - anAspect->MakeTextShaded(false); - aDimAIS->DimensionAspect()->MakeUnitsDisplayed(false); - aDimAIS->SetDimensionAspect (anAspect); - aDimAIS->SetFlyout(aFlyout); - aDimAIS->SetSelToleranceForText2d(CONSTRAINT_TEXT_SELECTION_TOLERANCE); - - anAIS = aDimAIS; - } - else { - // update presentation - Handle(AIS_LengthDimension) aDimAIS = Handle(AIS_LengthDimension)::DownCast(anAIS); - if (!aDimAIS.IsNull()) { - aDimAIS->SetMeasuredGeometry(aPoint1->impl(), aPoint2->impl(), aPlane->impl()); - aDimAIS->SetCustomValue(aValue); - aDimAIS->SetFlyout(aFlyout); - - aDimAIS->Redisplay(Standard_True); - } + return true; +} + +//************************************************************************************* +AISObjectPtr SketchPlugin_ConstraintDistance::getAISObject(AISObjectPtr thePrevious) +{ + if (!sketch()) + return thePrevious; + + AISObjectPtr anAIS = thePrevious; + if (!anAIS) { + anAIS = SketcherPrs_Factory::lengthDimensionConstraint(this, sketch()->coordinatePlane()); } return anAIS; } +//************************************************************************************* void SketchPlugin_ConstraintDistance::move(double theDeltaX, double theDeltaY) { - boost::shared_ptr aData = data(); + std::shared_ptr aData = data(); if (!aData->isValid()) return; - boost::shared_ptr aPoint1 = - boost::dynamic_pointer_cast(aData->attribute(CONSTRAINT_ATTR_FLYOUT_VALUE_PNT)); - aPoint1->setValue(aPoint1->x() + theDeltaX, aPoint1->y() + theDeltaY); + // Recalculate a shift of flyout point in terms of local coordinates + std::shared_ptr aDir(new GeomAPI_XY(theDeltaX, theDeltaY)); + std::shared_ptr aPlane = SketchPlugin_Sketch::plane(sketch()); + std::shared_ptr aPointA = SketcherPrs_Tools::getFeaturePoint( + data(), SketchPlugin_Constraint::ENTITY_A(), aPlane); + std::shared_ptr aPointB = SketcherPrs_Tools::getFeaturePoint( + data(), SketchPlugin_Constraint::ENTITY_B(), aPlane); + + std::shared_ptr aStartPnt; + std::shared_ptr aEndPnt; + if (aPointA && aPointB) { + aStartPnt = aPointA->pnt()->xy(); + aEndPnt = aPointB->pnt()->xy(); + } else if (aPointA) { + FeaturePtr aLine = SketcherPrs_Tools::getFeatureLine(data(), + SketchPlugin_Constraint::ENTITY_B()); + if (!aLine) + return; + std::shared_ptr aPoint = aPointA->pnt(); + aStartPnt = aPoint->xy(); + aEndPnt = SketcherPrs_Tools::getProjectionPoint(aLine, aPoint)->xy(); + } else if (aPointB) { + FeaturePtr aLine = SketcherPrs_Tools::getFeatureLine(data(), + SketchPlugin_Constraint::ENTITY_A()); + if (!aLine) + return; + std::shared_ptr aPoint = aPointB->pnt(); + aStartPnt = SketcherPrs_Tools::getProjectionPoint(aLine, aPoint)->xy(); + aEndPnt = aPoint->xy(); + } else + return; + + std::shared_ptr aLineDir(new GeomAPI_Dir2d(aEndPnt->decreased(aStartPnt))); + double dX = aDir->dot(aLineDir->xy()); + double dY = -aDir->cross(aLineDir->xy()); + + std::shared_ptr aPoint = std::dynamic_pointer_cast( + aData->attribute(SketchPlugin_Constraint::FLYOUT_VALUE_PNT())); + myFlyoutUpdate = true; + aPoint->setValue(aPoint->x() + dX, aPoint->y() + dY); + myFlyoutUpdate = false; +} + +double SketchPlugin_ConstraintDistance::calculateCurrentDistance() +{ + double aDistance = -1.; + + std::shared_ptr aData = data(); + std::shared_ptr aPlane = SketchPlugin_Sketch::plane(sketch()); + std::shared_ptr aPointA = + SketcherPrs_Tools::getFeaturePoint(aData, SketchPlugin_Constraint::ENTITY_A(), aPlane); + std::shared_ptr aPointB = + SketcherPrs_Tools::getFeaturePoint(aData, SketchPlugin_Constraint::ENTITY_B(), aPlane); + + if (aPointA.get() && aPointB.get()) { // both points + aDistance = aPointA->pnt()->distance(aPointB->pnt()); + } else { + FeaturePtr aLineFeature; + std::shared_ptr aLine; + if (!aPointA.get() && aPointB.get()) { //Line and point + aLineFeature = SketcherPrs_Tools::getFeatureLine(aData, SketchPlugin_Constraint::ENTITY_A()); + aLine = std::dynamic_pointer_cast(aLineFeature); + if (aLine.get()) { + aDistance = aLine->distanceToPoint(aPointB->pnt()); + } + } else if (aPointA.get() && !aPointB.get()) { // Point and line + aLineFeature = SketcherPrs_Tools::getFeatureLine(aData, SketchPlugin_Constraint::ENTITY_B()); + aLine = std::dynamic_pointer_cast(aLineFeature); + if (aLine.get()) { + aDistance = aLine->distanceToPoint(aPointA->pnt()); + } + } + } + return aDistance; } -boost::shared_ptr getFeaturePoint(DataPtr theData, - const std::string& theAttribute) +void SketchPlugin_ConstraintDistance::attributeChanged(const std::string& theID) { - boost::shared_ptr aPointAttr; - - if (!theData) - return aPointAttr; - - FeaturePtr aFeature; - boost::shared_ptr anAttr = - boost::dynamic_pointer_cast(theData->attribute(theAttribute)); - if (anAttr) - aFeature = anAttr->feature(); - - if (aFeature && aFeature->getKind() == SKETCH_POINT_KIND) - aPointAttr = boost::dynamic_pointer_cast - (aFeature->data()->attribute(POINT_ATTR_COORD)); - else { - if (anAttr->attr()) - aPointAttr = boost::dynamic_pointer_cast(anAttr->attr()); + if (theID == SketchPlugin_Constraint::ENTITY_A() || + theID == SketchPlugin_Constraint::ENTITY_B()) + { + std::shared_ptr aValueAttr = std::dynamic_pointer_cast< + ModelAPI_AttributeDouble>(data()->attribute(SketchPlugin_Constraint::VALUE())); + if (!aValueAttr->isInitialized()) { // only if it is not initialized, try to compute the current value + double aDistance = calculateCurrentDistance(); + if (aDistance > 0) { // set as value the length of updated references + aValueAttr->setValue(aDistance); + } + } + } else if (theID == SketchPlugin_Constraint::FLYOUT_VALUE_PNT() && !myFlyoutUpdate) { + myFlyoutUpdate = true; + // Recalculate flyout point in local coordinates of the distance constraint: + // the X coordinate is a length of projection of the flyout point on the line binding two distanced points + // or a line of projection of the distanced point onto the distanced segment + // the Y coordinate is a distance from the flyout point to the line + std::shared_ptr aFlyoutAttr = + std::dynamic_pointer_cast( + attribute(SketchPlugin_Constraint::FLYOUT_VALUE_PNT())); + std::shared_ptr aFlyoutPnt = aFlyoutAttr->pnt(); + + std::shared_ptr aPlane = SketchPlugin_Sketch::plane(sketch()); + std::shared_ptr aPointA = SketcherPrs_Tools::getFeaturePoint( + data(), SketchPlugin_Constraint::ENTITY_A(), aPlane); + std::shared_ptr aPointB = SketcherPrs_Tools::getFeaturePoint( + data(), SketchPlugin_Constraint::ENTITY_B(), aPlane); + + std::shared_ptr aStartPnt; + std::shared_ptr aEndPnt; + if (aPointA && aPointB) { + aStartPnt = aPointA->pnt()->xy(); + aEndPnt = aPointB->pnt()->xy(); + } else if (aPointA) { + FeaturePtr aLine = SketcherPrs_Tools::getFeatureLine(data(), + SketchPlugin_Constraint::ENTITY_B()); + if (!aLine) + return; + std::shared_ptr aPoint = aPointA->pnt(); + aStartPnt = aPoint->xy(); + aEndPnt = SketcherPrs_Tools::getProjectionPoint(aLine, aPoint)->xy(); + } else if (aPointB) { + FeaturePtr aLine = SketcherPrs_Tools::getFeatureLine(data(), + SketchPlugin_Constraint::ENTITY_A()); + if (!aLine) + return; + std::shared_ptr aPoint = aPointB->pnt(); + aStartPnt = SketcherPrs_Tools::getProjectionPoint(aLine, aPoint)->xy(); + aEndPnt = aPoint->xy(); + } else + return; + + std::shared_ptr aLineDir(new GeomAPI_Dir2d(aEndPnt->decreased(aStartPnt))); + std::shared_ptr aFlyoutDir = aFlyoutPnt->xy()->decreased(aStartPnt); + + double X = aFlyoutDir->dot(aLineDir->xy()); + double Y = -aFlyoutDir->cross(aLineDir->xy()); + aFlyoutAttr->setValue(X, Y); + myFlyoutUpdate = false; } - return aPointAttr; } + +bool SketchPlugin_ConstraintDistance::customisePresentation(ResultPtr theResult, + AISObjectPtr thePrs, + std::shared_ptr theDefaultPrs) +{ + bool isCustomized = false; + std::vector aRGB = Config_PropManager::color("Visualization", "sketch_dimension_color", + SKETCH_DIMENSION_COLOR); + isCustomized = thePrs->setColor(aRGB[0], aRGB[1], aRGB[2]); + + return isCustomized; +} +