X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;ds=sidebyside;f=src%2FSketchPlugin%2FSketchPlugin_ConstraintDistance.cpp;h=e75dcde94be98107862445248b2f20f5319ab821;hb=15fc1914159f4671968f56eb32d878a022edcd8b;hp=6dfa0d0bd008e203e93b4803ccbcc48e6991d051;hpb=72fe2af9c04daae44747cdce2f03ec395a4e5511;p=modules%2Fshaper.git diff --git a/src/SketchPlugin/SketchPlugin_ConstraintDistance.cpp b/src/SketchPlugin/SketchPlugin_ConstraintDistance.cpp index 6dfa0d0bd..e75dcde94 100644 --- a/src/SketchPlugin/SketchPlugin_ConstraintDistance.cpp +++ b/src/SketchPlugin/SketchPlugin_ConstraintDistance.cpp @@ -1,124 +1,229 @@ -// File: SketchPlugin_ConstraintDistance.cpp -// Created: 08 May 2014 -// Author: Artem ZHIDKOV +// Copyright (C) 2014-2017 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 "SketchPlugin_ConstraintDistance.h" +#include +#include +#include + +#include +#include + +#include +#include +#include +#include +#include #include +#include #include -#include +#include +#include + +#include + +#include + +const double tolerance = 1e-7; + SketchPlugin_ConstraintDistance::SketchPlugin_ConstraintDistance() { - myAttrList.push_back(CONSTRAINT_ATTR_DISTANCE); + myFlyoutUpdate = false; } -void SketchPlugin_ConstraintDistance::execute() +//************************************************************************************* +void SketchPlugin_ConstraintDistance::initAttributes() { + 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()); + data()->addAttribute(SIGNED(), ModelAPI_AttributeBoolean::typeId()); + + data()->addAttribute(SketchPlugin_ConstraintDistance::LOCATION_TYPE_ID(), + ModelAPI_AttributeInteger::typeId()); + ModelAPI_Session::get()->validators()->registerNotObligatory(getKind(), LOCATION_TYPE_ID()); } - -void SketchPlugin_ConstraintDistance::setAttributes( - const double theDistance, - const boost::shared_ptr theEntityA, - const boost::shared_ptr theEntityB) +void SketchPlugin_ConstraintDistance::colorConfigInfo(std::string& theSection, std::string& theName, + std::string& theDefault) { - // Assign the value of the distance - data()->addAttribute(CONSTRAINT_ATTR_DISTANCE, ModelAPI_AttributeDouble::type()); - boost::dynamic_pointer_cast( - data()->attribute(CONSTRAINT_ATTR_DISTANCE))->setValue(theDistance); - - // Assign parameters of the constraint - std::string aPoints[2] = {CONSTRAINT_ATTR_POINT_A, CONSTRAINT_ATTR_POINT_B}; - std::string anEntities[2] = {CONSTRAINT_ATTR_ENTITY_A, CONSTRAINT_ATTR_ENTITY_B}; - int aCurPt = 0; - int aCurEnt = 0; - std::string aCurAttr; - // add entityA depending on its type - if (theEntityA->getKind() == SketchPlugin_Point().getKind()) - aCurAttr = aPoints[aCurPt++]; - else - aCurAttr = anEntities[aCurEnt++]; - myAttrList.push_back(aCurAttr); - data()->addAttribute(aCurAttr, ModelAPI_AttributeReference::type()); - boost::dynamic_pointer_cast( - data()->attribute(aCurAttr))->setValue(theEntityA); - // add entityB depending on its type - if (theEntityB->getKind() == SketchPlugin_Point().getKind()) - aCurAttr = aPoints[aCurPt++]; - else - aCurAttr = anEntities[aCurEnt++]; - myAttrList.push_back(aCurAttr); - data()->addAttribute(aCurAttr, ModelAPI_AttributeReference::type()); - boost::dynamic_pointer_cast( - data()->attribute(aCurAttr))->setValue(theEntityB); + theSection = "Visualization"; + theName = "sketch_dimension_color"; + theDefault = SKETCH_DIMENSION_COLOR; } -void SketchPlugin_ConstraintDistance::setAttributes( - const double theDistance, - const boost::shared_ptr thePoint, - const boost::shared_ptr theEntity) +//************************************************************************************* +void SketchPlugin_ConstraintDistance::execute() { - // Assign the value of the distance - data()->addAttribute(CONSTRAINT_ATTR_DISTANCE, ModelAPI_AttributeDouble::type()); - boost::dynamic_pointer_cast( - data()->attribute(CONSTRAINT_ATTR_DISTANCE))->setValue(theDistance); - - // Assign reference to the first point - myAttrList.push_back(CONSTRAINT_ATTR_POINT_A); - data()->addAttribute(CONSTRAINT_ATTR_POINT_A, ModelAPI_AttributeRefAttr::type()); - //boost::dynamic_pointer_cast( - // data()->attribute(CONSTRAINT_ATTR_POINT_A))->setValue(thePoint); - - // Assign reference to the entity - std::string aCurAttr; - if (theEntity->getKind() == SketchPlugin_Point().getKind()) - aCurAttr = CONSTRAINT_ATTR_POINT_B; - else - aCurAttr = CONSTRAINT_ATTR_ENTITY_A; - myAttrList.push_back(aCurAttr); - data()->addAttribute(aCurAttr, ModelAPI_AttributeReference::type()); - boost::dynamic_pointer_cast( - data()->attribute(aCurAttr))->setValue(theEntity); + std::shared_ptr aData = data(); + AttributeDoublePtr anAttrValue = std::dynamic_pointer_cast( + aData->attribute(SketchPlugin_Constraint::VALUE())); + + if(anAttrValue->isInitialized()) + return; + + double aDistance = calculateCurrentDistance(); + if(aDistance >= 0) + anAttrValue->setValue(aDistance); } -void SketchPlugin_ConstraintDistance::setAttributes( - const double theDistance, - const boost::shared_ptr thePointA, - const boost::shared_ptr thePointB) +//************************************************************************************* +AISObjectPtr SketchPlugin_ConstraintDistance::getAISObject(AISObjectPtr thePrevious) { - // Assign the value of the distance - data()->addAttribute(CONSTRAINT_ATTR_DISTANCE, ModelAPI_AttributeDouble::type()); - boost::dynamic_pointer_cast( - data()->attribute(CONSTRAINT_ATTR_DISTANCE))->setValue(theDistance); - - // Assign reference to the first point - myAttrList.push_back(CONSTRAINT_ATTR_POINT_A); - data()->addAttribute(CONSTRAINT_ATTR_POINT_A, ModelAPI_AttributeRefAttr::type()); - //boost::dynamic_pointer_cast( - // data()->attribute(CONSTRAINT_ATTR_POINT_A))->setValue(thePointA); - - // Assign reference to the second point - myAttrList.push_back(CONSTRAINT_ATTR_POINT_B); - data()->addAttribute(CONSTRAINT_ATTR_POINT_B, ModelAPI_AttributeRefAttr::type()); - //boost::dynamic_pointer_cast( - // data()->attribute(CONSTRAINT_ATTR_POINT_B))->setValue(thePointB); + if (!sketch()) + return thePrevious; + + AISObjectPtr anAIS = SketcherPrs_Factory::lengthDimensionConstraint(this, + sketch()->coordinatePlane(), + thePrevious); + return anAIS; } -void SketchPlugin_ConstraintDistance::setAttributes( - const double theRadius, - const boost::shared_ptr theCircle) +double SketchPlugin_ConstraintDistance::calculateCurrentDistance() { - /// \todo Need to be implemented + 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; } -void SketchPlugin_ConstraintDistance::setAttributes( - const double theDistance, - const boost::shared_ptr thePointA, - const boost::shared_ptr thePointB, - const boost::shared_ptr theEntity) +bool SketchPlugin_ConstraintDistance::areAttributesInitialized() { - /// \todo Need to be implemented. Possibly need to add points by their attributes + 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 && !aPointB) + return false; + else if (aPointA || aPointB) { + FeaturePtr aLine; + if (!aPointA) + aLine = SketcherPrs_Tools::getFeatureLine(aData, SketchPlugin_Constraint::ENTITY_A()); + else if (!aPointB) + aLine = SketcherPrs_Tools::getFeatureLine(aData, SketchPlugin_Constraint::ENTITY_B()); + else // both points are initialized + return true; + + if (!aLine || aLine->getKind() != SketchPlugin_Line::ID()) + return false; + } + return true; } +void SketchPlugin_ConstraintDistance::attributeChanged(const std::string& theID) +{ + 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) { + // 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; + + if (aEndPnt->distance(aStartPnt) < tolerance) + return; + + myFlyoutUpdate = true; + 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; + } +}