X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FSketchPlugin%2FSketchPlugin_ConstraintAngle.cpp;h=8fb29c48c33e5866c795c9acc2c01e5798af491e;hb=3f1a42a51c7de1911c75453ff7134593d7d2c6b1;hp=fc2df7237bdaff1f5d4e2bf46c68e13c9aa7b8aa;hpb=a8ed41e2ed5a9528335f0a5d1a2203f35048620e;p=modules%2Fshaper.git diff --git a/src/SketchPlugin/SketchPlugin_ConstraintAngle.cpp b/src/SketchPlugin/SketchPlugin_ConstraintAngle.cpp index fc2df7237..8fb29c48c 100644 --- a/src/SketchPlugin/SketchPlugin_ConstraintAngle.cpp +++ b/src/SketchPlugin/SketchPlugin_ConstraintAngle.cpp @@ -8,8 +8,11 @@ #include #include +#include + #include +#include #include #include #include @@ -18,9 +21,14 @@ #include #include +#include + const double tolerance = 1.e-7; #define PI 3.1415926535897932 +/// \brief Calculate intersection point of two lines +static std::shared_ptr intersect(FeaturePtr theLine1, FeaturePtr theLine2); + SketchPlugin_ConstraintAngle::SketchPlugin_ConstraintAngle() { @@ -33,19 +41,46 @@ void SketchPlugin_ConstraintAngle::initAttributes() data()->addAttribute(SketchPlugin_Constraint::ENTITY_A(), ModelAPI_AttributeRefAttr::typeId()); data()->addAttribute(SketchPlugin_Constraint::ENTITY_B(), ModelAPI_AttributeRefAttr::typeId()); data()->addAttribute(SketchPlugin_Constraint::FLYOUT_VALUE_PNT(), GeomDataAPI_Point2D::typeId()); + + data()->addAttribute(SketchPlugin_ConstraintAngle::ANGLE_VALUE_ID(), ModelAPI_AttributeDouble::typeId()); + data()->addAttribute(SketchPlugin_ConstraintAngle::TYPE_ID(), ModelAPI_AttributeInteger::typeId()); + + data()->addAttribute(SketchPlugin_ConstraintAngle::ANGLE_REVERSED_FIRST_LINE_ID(), ModelAPI_AttributeBoolean::typeId()); + data()->addAttribute(SketchPlugin_ConstraintAngle::ANGLE_REVERSED_SECOND_LINE_ID(), ModelAPI_AttributeBoolean::typeId()); +} + +void SketchPlugin_ConstraintAngle::colorConfigInfo(std::string& theSection, std::string& theName, + std::string& theDefault) +{ + theSection = "Visualization"; + theName = "sketch_dimension_color"; + theDefault = SKETCH_DIMENSION_COLOR; } void SketchPlugin_ConstraintAngle::execute() { std::shared_ptr aData = data(); - AttributeDoublePtr anAttrValue = std::dynamic_pointer_cast( - aData->attribute(SketchPlugin_Constraint::VALUE())); - if(anAttrValue->isInitialized()) + std::shared_ptr anAttrA = aData->refattr(SketchPlugin_Constraint::ENTITY_A()); + std::shared_ptr anAttrB = aData->refattr(SketchPlugin_Constraint::ENTITY_B()); + if (!anAttrA->isInitialized() || !anAttrB->isInitialized()) return; - double anAngle = calculateAngle(); - anAttrValue->setValue(anAngle); + AttributeDoublePtr anAttrValue = std::dynamic_pointer_cast( + aData->attribute(SketchPlugin_ConstraintAngle::ANGLE_VALUE_ID())); + + if (!anAttrValue->isInitialized()) { + double anAngle = calculateAngle(); + anAttrValue->setValue(anAngle); + updateConstraintValueByAngleValue(); + } + // 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()); } AISObjectPtr SketchPlugin_ConstraintAngle::getAISObject(AISObjectPtr thePrevious) @@ -53,89 +88,147 @@ AISObjectPtr SketchPlugin_ConstraintAngle::getAISObject(AISObjectPtr thePrevious if (!sketch()) return thePrevious; - AISObjectPtr anAIS = thePrevious; - if (!anAIS) { - anAIS = SketcherPrs_Factory::angleConstraint(this, sketch()->coordinatePlane()); - } - - // Set color from preferences - std::vector aRGB = Config_PropManager::color("Visualization", "sketch_dimension_color", - SKETCH_DIMENSION_COLOR); - anAIS->setColor(aRGB[0], aRGB[1], aRGB[2]); + AISObjectPtr anAIS = SketcherPrs_Factory::angleConstraint(this, sketch()->coordinatePlane(), + thePrevious); return anAIS; } void SketchPlugin_ConstraintAngle::attributeChanged(const std::string& theID) { - if (theID == SketchPlugin_Constraint::ENTITY_A() || - theID == SketchPlugin_Constraint::ENTITY_B()) { - std::shared_ptr aData = data(); - if (!aData) - return; + std::shared_ptr aData = data(); + if (!aData) + return; FeaturePtr aLineA = SketcherPrs_Tools::getFeatureLine(aData, SketchPlugin_Constraint::ENTITY_A()); FeaturePtr aLineB = SketcherPrs_Tools::getFeatureLine(aData, SketchPlugin_Constraint::ENTITY_B()); - if (!aLineA || !aLineB) - return; + if (!aLineA || !aLineB) + return; + 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())); + ModelAPI_AttributeDouble>(data()->attribute(SketchPlugin_ConstraintAngle::ANGLE_VALUE_ID())); if (!aValueAttr->isInitialized()) { // only if it is not initialized, try to compute the current value double anAngle = calculateAngle(); aValueAttr->setValue(anAngle); + updateConstraintValueByAngleValue(); } } else if (theID == SketchPlugin_Constraint::FLYOUT_VALUE_PNT() && !myFlyoutUpdate) { // Recalculate flyout point in local coordinates + // coordinates are calculated according to the center of shapes intersection std::shared_ptr aFlyoutAttr = std::dynamic_pointer_cast(attribute(SketchPlugin_Constraint::FLYOUT_VALUE_PNT())); + + std::shared_ptr aData = data(); + std::shared_ptr aPlane = SketchPlugin_Sketch::plane(sketch()); + FeaturePtr aLineA = SketcherPrs_Tools::getFeatureLine(aData, SketchPlugin_Constraint::ENTITY_A()); + FeaturePtr aLineB = SketcherPrs_Tools::getFeatureLine(aData, SketchPlugin_Constraint::ENTITY_B()); + + // Intersection of lines + std::shared_ptr anInter = intersect(aLineA, aLineB); + if (!anInter) + return; + + myFlyoutUpdate = true; + std::shared_ptr aFlyoutDir = aFlyoutAttr->pnt()->xy()->decreased(anInter->xy()); + if (aFlyoutDir->dot(aFlyoutDir) < tolerance * tolerance) + aFlyoutAttr->setValue(aFlyoutAttr->x() + tolerance, aFlyoutAttr->y()); + myFlyoutUpdate = false; + } + else if (theID == SketchPlugin_ConstraintAngle::TYPE_ID()) { + std::shared_ptr aValueAttr = std::dynamic_pointer_cast< + ModelAPI_AttributeDouble>(data()->attribute(SketchPlugin_ConstraintAngle::ANGLE_VALUE_ID())); + double anAngle = calculateAngle(); + aValueAttr->setValue(anAngle); + } + else if (theID == SketchPlugin_ConstraintAngle::ANGLE_VALUE_ID()) { + updateConstraintValueByAngleValue(); } } double SketchPlugin_ConstraintAngle::calculateAngle() { - double anAngle = 0.0; - std::shared_ptr aData = data(); std::shared_ptr aPlane = SketchPlugin_Sketch::plane(sketch()); FeaturePtr aLineA = SketcherPrs_Tools::getFeatureLine(aData, SketchPlugin_Constraint::ENTITY_A()); FeaturePtr aLineB = SketcherPrs_Tools::getFeatureLine(aData, SketchPlugin_Constraint::ENTITY_B()); - // Start and end points of lines - std::shared_ptr aPointA1 = std::dynamic_pointer_cast( + std::shared_ptr aStartA = std::dynamic_pointer_cast( aLineA->attribute(SketchPlugin_Line::START_ID())); - std::shared_ptr aPointA2 = std::dynamic_pointer_cast( + std::shared_ptr aEndA = std::dynamic_pointer_cast( aLineA->attribute(SketchPlugin_Line::END_ID())); - - std::shared_ptr aPointB1 = std::dynamic_pointer_cast( + std::shared_ptr aStartB = std::dynamic_pointer_cast( aLineB->attribute(SketchPlugin_Line::START_ID())); - std::shared_ptr aPointB2 = std::dynamic_pointer_cast( + std::shared_ptr aEndB = std::dynamic_pointer_cast( aLineB->attribute(SketchPlugin_Line::END_ID())); - std::shared_ptr aStartA = aPointA1->pnt(); - std::shared_ptr aEndA = aPointA2->pnt(); - std::shared_ptr aStartB = aPointB1->pnt(); - std::shared_ptr aEndB = aPointB2->pnt(); - if (aStartA->distance(aEndA) < tolerance || aStartB->distance(aEndB) < tolerance) - return anAngle; + std::shared_ptr anAng; + if (!attribute(ANGLE_REVERSED_FIRST_LINE_ID())->isInitialized() || + !attribute(ANGLE_REVERSED_SECOND_LINE_ID())->isInitialized()) + anAng = std::shared_ptr(new GeomAPI_Angle2d( + aStartA->pnt(), aEndA->pnt(), aStartB->pnt(), aEndB->pnt())); + else { + std::shared_ptr aLine1(new GeomAPI_Lin2d(aStartA->pnt(), aEndA->pnt())); + bool isReversed1 = boolean(ANGLE_REVERSED_FIRST_LINE_ID())->value(); + std::shared_ptr aLine2(new GeomAPI_Lin2d(aStartB->pnt(), aEndB->pnt())); + bool isReversed2 = boolean(ANGLE_REVERSED_SECOND_LINE_ID())->value(); + anAng = std::shared_ptr(new GeomAPI_Angle2d(aLine1, isReversed1, aLine2, isReversed2)); + } + double anAngle = anAng->angleDegree(); + std::shared_ptr aValueAttr = std::dynamic_pointer_cast< + ModelAPI_AttributeDouble>(data()->attribute(SketchPlugin_ConstraintAngle::VALUE())); + if (!aValueAttr->isInitialized()) + aValueAttr->setValue(anAngle); + /// an angle value should be corrected by the current angle type + anAngle = getAngleForType(anAngle); + boolean(ANGLE_REVERSED_FIRST_LINE_ID())->setValue(anAng->isReversed(0)); + boolean(ANGLE_REVERSED_SECOND_LINE_ID())->setValue(anAng->isReversed(1)); + return anAngle; +} - // Lines and their intersection point - std::shared_ptr aLA(new GeomAPI_Lin2d(aStartA, aEndA)); - std::shared_ptr aLB(new GeomAPI_Lin2d(aStartB, aEndB)); - std::shared_ptr anInter = aLA->intersect(aLB); - if (!anInter) - return anAngle; - - // Directions of lines - if (anInter->distance(aEndA) < tolerance) - aEndA = aStartA; - if (anInter->distance(aEndB) < tolerance) - aEndB = aStartB; - std::shared_ptr aDirA(new GeomAPI_Dir2d(aEndA->xy()->decreased(anInter->xy()))); - std::shared_ptr aDirB(new GeomAPI_Dir2d(aEndB->xy()->decreased(anInter->xy()))); - - anAngle = aDirA->angle(aDirB) * 180.0 / PI; +double SketchPlugin_ConstraintAngle::getAngleForType(double theAngle, bool isPreviousValueObtuse) +{ + double anAngle = theAngle; + + std::shared_ptr aData = data(); + std::shared_ptr aTypeAttr = std::dynamic_pointer_cast< + ModelAPI_AttributeInteger>(aData->attribute(SketchPlugin_ConstraintAngle::TYPE_ID())); + SketcherPrs_Tools::AngleType anAngleType = (SketcherPrs_Tools::AngleType)(aTypeAttr->value()); + switch (anAngleType) { + case SketcherPrs_Tools::ANGLE_DIRECT: + anAngle = theAngle; + break; + case SketcherPrs_Tools::ANGLE_COMPLEMENTARY: { + if (theAngle > 180 || isPreviousValueObtuse) + anAngle = theAngle - 180.0; + else + anAngle = 180.0 - theAngle; + + if (anAngle < 0.0) + anAngle += 360.0; + } + break; + case SketcherPrs_Tools::ANGLE_BACKWARD: + anAngle = 360.0 - theAngle; + break; + default: + break; + } return anAngle; } +void SketchPlugin_ConstraintAngle::updateConstraintValueByAngleValue() +{ + std::shared_ptr aValueAttr = std::dynamic_pointer_cast< + ModelAPI_AttributeDouble>(data()->attribute(SketchPlugin_ConstraintAngle::ANGLE_VALUE_ID())); + double anAngle = aValueAttr->value(); + + /// an angle value should be corrected by the current angle type + aValueAttr = std::dynamic_pointer_cast< + ModelAPI_AttributeDouble>(data()->attribute(SketchPlugin_Constraint::VALUE())); + anAngle = getAngleForType(anAngle, aValueAttr->value() > 180.0); + aValueAttr->setValue(anAngle); +} + void SketchPlugin_ConstraintAngle::move(double theDeltaX, double theDeltaY) { std::shared_ptr aData = data(); @@ -148,3 +241,73 @@ void SketchPlugin_ConstraintAngle::move(double theDeltaX, double theDeltaY) aFlyoutAttr->setValue(aFlyoutAttr->x() + theDeltaX, aFlyoutAttr->y() + theDeltaY); myFlyoutUpdate = false; } + + +bool SketchPlugin_ConstraintAngle::compute(const std::string& theAttributeId) +{ + if (theAttributeId != SketchPlugin_Constraint::FLYOUT_VALUE_PNT()) + return false; + if (!sketch()) + return false; + + 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(); + std::shared_ptr aPlane = SketchPlugin_Sketch::plane(sketch()); + FeaturePtr aLineA = SketcherPrs_Tools::getFeatureLine(aData, SketchPlugin_Constraint::ENTITY_A()); + FeaturePtr aLineB = SketcherPrs_Tools::getFeatureLine(aData, SketchPlugin_Constraint::ENTITY_B()); + + if ((aLineA.get() == NULL) || (aLineB.get() == NULL)) + return false; + + // Start and end points of lines + std::shared_ptr aPointA1 = std::dynamic_pointer_cast( + aLineA->attribute(SketchPlugin_Line::START_ID())); + std::shared_ptr aPointA2 = std::dynamic_pointer_cast( + aLineA->attribute(SketchPlugin_Line::END_ID())); + + std::shared_ptr aStartA = aPointA1->pnt(); + std::shared_ptr aEndA = aPointA2->pnt(); + if (aStartA->distance(aEndA) < tolerance) + return false; + + myFlyoutUpdate = true; + double aX = (aStartA->x() + aEndA->x()) / 2.; + double aY = (aStartA->y() + aEndA->y()) / 2.; + + aFlyOutAttr->setValue(aX, aY); + myFlyoutUpdate = false; + + return true; +} + + +// =============== Auxiliary functions ================================== +std::shared_ptr intersect(FeaturePtr theLine1, FeaturePtr theLine2) +{ + // Start and end points of lines + std::shared_ptr aPointA1 = std::dynamic_pointer_cast( + theLine1->attribute(SketchPlugin_Line::START_ID())); + std::shared_ptr aPointA2 = std::dynamic_pointer_cast( + theLine1->attribute(SketchPlugin_Line::END_ID())); + + std::shared_ptr aPointB1 = std::dynamic_pointer_cast( + theLine2->attribute(SketchPlugin_Line::START_ID())); + std::shared_ptr aPointB2 = std::dynamic_pointer_cast( + theLine2->attribute(SketchPlugin_Line::END_ID())); + + std::shared_ptr aStartA = aPointA1->pnt(); + std::shared_ptr aEndA = aPointA2->pnt(); + std::shared_ptr aStartB = aPointB1->pnt(); + std::shared_ptr aEndB = aPointB2->pnt(); + if (aStartA->distance(aEndA) < tolerance || aStartB->distance(aEndB) < tolerance) + std::shared_ptr(); + + // Lines and their intersection point + std::shared_ptr aLA(new GeomAPI_Lin2d(aStartA, aEndA)); + std::shared_ptr aLB(new GeomAPI_Lin2d(aStartB, aEndB)); + return aLA->intersect(aLB); +}