From: mpv Date: Tue, 14 Jun 2016 09:25:37 +0000 (+0300) Subject: Optimization of circle and arc creation X-Git-Tag: V_2.4.0~112 X-Git-Url: http://git.salome-platform.org/gitweb/?a=commitdiff_plain;h=84b36b8deb02c2661b3d09299560266388329d01;p=modules%2Fshaper.git Optimization of circle and arc creation --- diff --git a/src/Model/Model_Data.cpp b/src/Model/Model_Data.cpp index 1e63282bb..4d1b40b22 100644 --- a/src/Model/Model_Data.cpp +++ b/src/Model/Model_Data.cpp @@ -283,19 +283,31 @@ void Model_Data::sendAttributeUpdated(ModelAPI_Attribute* theAttr) ModelAPI_EventCreator::get()->sendUpdated(myObject, anEvent); } } else { - myWasChangedButBlocked = true; + // to avoid too many duplications do not add the same like the last + if (myWasChangedButBlocked.empty() || *(myWasChangedButBlocked.rbegin()) != theAttr) + myWasChangedButBlocked.push_back(theAttr); } } } -void Model_Data::blockSendAttributeUpdated(const bool theBlock) +void Model_Data::blockSendAttributeUpdated(const bool theBlock, const bool theSendMessage) { if (mySendAttributeUpdated == theBlock) { mySendAttributeUpdated = !theBlock; - if (mySendAttributeUpdated && myWasChangedButBlocked) { // so, now it is ok to send the update signal - static const Events_ID anEvent = Events_Loop::eventByName(EVENT_OBJECT_UPDATED); - ModelAPI_EventCreator::get()->sendUpdated(myObject, anEvent); - myWasChangedButBlocked = false; + if (mySendAttributeUpdated && !myWasChangedButBlocked.empty()) { // so, now it is ok to send the update signal + if (theSendMessage) { + // make a copy to avoid iteration on modified list (may be cleared by attribute changed call) + std::list aWasChangedButBlocked = myWasChangedButBlocked; + myWasChangedButBlocked.clear(); + std::list::iterator aChangedIter = aWasChangedButBlocked.begin(); + for(; aChangedIter != aWasChangedButBlocked.end(); aChangedIter++) { + myObject->attributeChanged((*aChangedIter)->id()); + } + static const Events_ID anEvent = Events_Loop::eventByName(EVENT_OBJECT_UPDATED); + ModelAPI_EventCreator::get()->sendUpdated(myObject, anEvent); + } else { + myWasChangedButBlocked.clear(); + } } } } diff --git a/src/Model/Model_Data.h b/src/Model/Model_Data.h index 8f8cfe515..e505d3751 100644 --- a/src/Model/Model_Data.h +++ b/src/Model/Model_Data.h @@ -56,8 +56,8 @@ class Model_Data : public ModelAPI_Data std::set myRefsToMe; /// flag that may block the "attribute updated" sending bool mySendAttributeUpdated; - /// if some attribute was changed, but mySendAttributeUpdated was false, this flag stores this - bool myWasChangedButBlocked; + /// if some attribute was changed, but mySendAttributeUpdated was false, this stores this + std::list myWasChangedButBlocked; /// Returns label of this feature TDF_Label label() @@ -155,7 +155,11 @@ class Model_Data : public ModelAPI_Data /// makes attribute initialized MODEL_EXPORT virtual void sendAttributeUpdated(ModelAPI_Attribute* theAttr); /// Blocks sending "attribute updated" if theBlock is true - MODEL_EXPORT virtual void blockSendAttributeUpdated(const bool theBlock); + /// \param theBlock allows switching on/off the blocking state + /// \param theSendMessage if false, it does not send the update message even if something is changed + /// (normally is it used in attributeChanged because this message will be sent anyway) + MODEL_EXPORT virtual void blockSendAttributeUpdated( + const bool theBlock, const bool theSendMessage = true); /// Puts feature to the document data sub-structure MODEL_EXPORT void setLabel(TDF_Label theLab); diff --git a/src/Model/Model_Update.cpp b/src/Model/Model_Update.cpp index 2eb0e7dbe..47c6db4b8 100755 --- a/src/Model/Model_Update.cpp +++ b/src/Model/Model_Update.cpp @@ -405,14 +405,26 @@ bool Model_Update::processFeature(FeaturePtr theFeature) // check all features this feature depended on (recursive call of updateFeature) std::set >& aReasons = myModified[theFeature]; if (aReasons.find(theFeature) == aReasons.end()) { - std::set >::iterator aReasonIter = aReasons.begin(); - for(; aReasonIter != aReasons.end(); aReasonIter++) { - if (*aReasonIter != theFeature && (*aReasonIter)->data()->isValid()) { - if (processFeature(*aReasonIter)) + // take reasons one by one (they may be added during the feature process (circle by the radius of sketch) + std::set aProcessedReasons; + FeaturePtr aReason = aReasons.empty() ? FeaturePtr() : *(aReasons.begin()); + while(aReason.get()) { + if (aReason != theFeature && (aReason)->data()->isValid()) { + if (processFeature(aReason)) aIsModified = true; - if ((*aReasonIter)->data()->execState() == ModelAPI_StateInvalidArgument) + if (aReason->data()->execState() == ModelAPI_StateInvalidArgument) isReferencedInvalid = true; } + // searching for the next not used reason + aProcessedReasons.insert(aReason); + aReason.reset(); + std::set >::iterator aReasonIter = aReasons.begin(); + for(; aReasonIter != aReasons.end(); aReasonIter++) { + if (aProcessedReasons.find(*aReasonIter) == aProcessedReasons.end()) { + aReason = *aReasonIter; + break; + } + } } } else { // check all features this feature depended on because here which one was modified is unknown std::list > > > aDeps; diff --git a/src/ModelAPI/ModelAPI_Data.h b/src/ModelAPI/ModelAPI_Data.h index 05dc2be64..320dffb40 100644 --- a/src/ModelAPI/ModelAPI_Data.h +++ b/src/ModelAPI/ModelAPI_Data.h @@ -118,7 +118,11 @@ class MODELAPI_EXPORT ModelAPI_Data /// makes attribute initialized virtual void sendAttributeUpdated(ModelAPI_Attribute* theAttr) = 0; /// Blocks sending "attribute updated" if theBlock is true - virtual void blockSendAttributeUpdated(const bool theBlock) = 0; + /// \param theID identifier of the attribute that can be referenced by this ID later + /// \param theAttrType type of the created attribute (received from the type method) + /// \returns the just created attribute + virtual void blockSendAttributeUpdated( + const bool theBlock, const bool theSendMessage = true) = 0; /// Erases all the data from the data model virtual void erase() = 0; diff --git a/src/ParametersPlugin/ParametersPlugin_EvalListener.cpp b/src/ParametersPlugin/ParametersPlugin_EvalListener.cpp index fcd4b0dc8..c2deeff2d 100644 --- a/src/ParametersPlugin/ParametersPlugin_EvalListener.cpp +++ b/src/ParametersPlugin/ParametersPlugin_EvalListener.cpp @@ -346,7 +346,7 @@ void setParameterName(ResultParameterPtr theResultParameter, const std::string& { theResultParameter->data()->blockSendAttributeUpdated(true); theResultParameter->data()->setName(theName); - theResultParameter->data()->blockSendAttributeUpdated(false); + theResultParameter->data()->blockSendAttributeUpdated(false, false); std::shared_ptr aParameter = std::dynamic_pointer_cast( diff --git a/src/SketchPlugin/SketchPlugin_Arc.cpp b/src/SketchPlugin/SketchPlugin_Arc.cpp index f0aaaef9f..b98a915bf 100644 --- a/src/SketchPlugin/SketchPlugin_Arc.cpp +++ b/src/SketchPlugin/SketchPlugin_Arc.cpp @@ -135,8 +135,7 @@ void SketchPlugin_Arc::execute() // result for the arc is set only when all obligatory attributes are initialized, // otherwise AIS object is used to visualize the arc's preview if (aSketch && isFeatureValid()) { - ResultPtr aLastResult = lastResult(); - bool hasResult = aLastResult && aLastResult.get(); + bool hasResult = lastResult().get() != NULL; // compute a circle point in 3D view std::shared_ptr aCenterAttr = std::dynamic_pointer_cast< @@ -201,9 +200,6 @@ void SketchPlugin_Arc::execute() aConstr2->setIsInHistory(false); setResult(aConstr2, 1); } - - // update radius and angle - updateDependentAttributes(); } } @@ -220,9 +216,6 @@ AISObjectPtr SketchPlugin_Arc::getAISObject(AISObjectPtr thePrevious) std::list > aShapes; if (aCenterAttr->isInitialized()) { std::shared_ptr aCenter(aSketch->to3D(aCenterAttr->x(), aCenterAttr->y())); - // make a visible point - std::shared_ptr aCenterPointShape = GeomAlgoAPI_PointBuilder::point(aCenter); - aShapes.push_back(aCenterPointShape); std::shared_ptr aStartAttr = std::dynamic_pointer_cast< GeomDataAPI_Point2D>(data()->attribute(SketchPlugin_Arc::START_ID())); @@ -241,8 +234,22 @@ AISObjectPtr SketchPlugin_Arc::getAISObject(AISObjectPtr thePrevious) std::shared_ptr aStartPoint(aSketch->to3D(aStartAttr->x(), aStartAttr->y())); std::shared_ptr aEndPoint = aStartPoint; if (aTypeAttr && aTypeAttr->isInitialized() && - aTypeAttr->value() == ARC_TYPE_THREE_POINTS() && aEndAttr->isInitialized()) + aTypeAttr->value() == ARC_TYPE_THREE_POINTS() && aEndAttr->isInitialized() && + aEndAttr->pnt()->distance(aStartAttr->pnt()) > tolerance) { aEndPoint = aSketch->to3D(aEndAttr->x(), aEndAttr->y()); + std::shared_ptr aPassedAttr = + std::dynamic_pointer_cast(data()->attribute(PASSED_POINT_ID())); + if (!aPassedAttr->isInitialized()) { // calculate the appropriate center for the presentation + std::shared_ptr aDir = + aEndAttr->pnt()->xy()->decreased(aStartAttr->pnt()->xy())->multiplied(0.5); + double x = aDir->x(); + double y = aDir->y(); + aDir->setX(x - y); + aDir->setY(y + x); + std::shared_ptr aCenterXY = aStartAttr->pnt()->xy()->added(aDir); + aCenter = aSketch->to3D(aCenterXY->x(), aCenterXY->y()); + } + } std::shared_ptr aCircleShape = GeomAlgoAPI_EdgeBuilder::lineCircleArc( aCenter, aStartPoint, aEndPoint, aNormal); @@ -250,6 +257,9 @@ AISObjectPtr SketchPlugin_Arc::getAISObject(AISObjectPtr thePrevious) aShapes.push_back(aCircleShape); } } + // make a visible point + std::shared_ptr aCenterPointShape = GeomAlgoAPI_PointBuilder::point(aCenter); + aShapes.push_back(aCenterPointShape); } if (!aShapes.empty()) { std::shared_ptr aCompound = GeomAlgoAPI_CompoundBuilder::compound(aShapes); @@ -332,93 +342,6 @@ static inline void adjustPeriod(double& theParam) while (theParam >= PERIOD) theParam -= PERIOD; } -static inline void calculateArcAngleRadius( - const std::shared_ptr& theCircle, - const std::shared_ptr& theStartPoint, - const std::shared_ptr& theEndPoint, - const std::shared_ptr& thePassedPoint, - AttributeDoublePtr theAngleAttr, - AttributeDoublePtr theRadiusAttr) -{ - double aStartParam, aEndParam, aPassedParam; - theCircle->parameter(theStartPoint, paramTolerance, aStartParam); - theCircle->parameter(theEndPoint, paramTolerance, aEndParam); - theCircle->parameter(thePassedPoint, paramTolerance, aPassedParam); - adjustPeriod(aStartParam); - adjustPeriod(aEndParam); - adjustPeriod(aPassedParam); - - if (aPassedParam >= aStartParam && aPassedParam <= aEndParam) - theAngleAttr->setValue((aEndParam - aStartParam) * 180.0 / PI); - else - theAngleAttr->setValue((aEndParam - aStartParam - 2.0 * PI) * 180.0 / PI); - theRadiusAttr->setValue(theCircle->radius()); -} - -static inline bool calculatePassedPoint( - const std::shared_ptr& theCenter, - const std::shared_ptr& theStartPoint, - const std::shared_ptr& theEndPoint, - bool theArcReversed, - std::shared_ptr thePassedPoint) -{ - if (theCenter->distance(theStartPoint) < tolerance || - theCenter->distance(theEndPoint) < tolerance) - return false; - - std::shared_ptr aStartDir(new GeomAPI_Dir2d( - theStartPoint->xy()->decreased(theCenter->xy()))); - std::shared_ptr aEndDir(new GeomAPI_Dir2d( - theEndPoint->xy()->decreased(theCenter->xy()))); - std::shared_ptr aMidDirXY = aStartDir->xy()->added(aEndDir->xy()); - if (aMidDirXY->dot(aMidDirXY) < tolerance * tolerance) { - // start and end directions are opposite, so middle direction will be orthogonal - aMidDirXY->setX(-aStartDir->y()); - aMidDirXY->setY(aStartDir->x()); - } - std::shared_ptr aMidDir(new GeomAPI_Dir2d(aMidDirXY)); - if ((aStartDir->cross(aMidDir) > 0) ^ !theArcReversed) - aMidDir->reverse(); - - double aRadius = theCenter->distance(theStartPoint); - std::shared_ptr aPassedPnt = theCenter->xy()->added( aMidDir->xy()->multiplied(aRadius) ); - thePassedPoint->setValue(aPassedPnt->x(), aPassedPnt->y()); - return true; -} - -void SketchPlugin_Arc::updateDependentAttributes() -{ - std::shared_ptr aCenterAttr = std::dynamic_pointer_cast< - GeomDataAPI_Point2D>(data()->attribute(CENTER_ID())); - std::shared_ptr aStartAttr = std::dynamic_pointer_cast< - GeomDataAPI_Point2D>(data()->attribute(START_ID())); - std::shared_ptr anEndAttr = std::dynamic_pointer_cast< - GeomDataAPI_Point2D>(data()->attribute(END_ID())); - std::shared_ptr aPassedPoint = - std::dynamic_pointer_cast(attribute(PASSED_POINT_ID())); - AttributeDoublePtr aRadiusAttr = std::dynamic_pointer_cast( - data()->attribute(RADIUS_ID())); - AttributeDoublePtr anAngleAttr = std::dynamic_pointer_cast( - data()->attribute(ANGLE_ID())); - - if (!aPassedPoint) - return; - - data()->blockSendAttributeUpdated(true); - - bool isOk = calculatePassedPoint(aCenterAttr->pnt(), aStartAttr->pnt(), anEndAttr->pnt(), - isReversed(), aPassedPoint); - if (isOk && aRadiusAttr && anAngleAttr) { - std::shared_ptr aCircle( - new GeomAPI_Circ2d(aStartAttr->pnt(), anEndAttr->pnt(), aPassedPoint->pnt())); - if (aCircle->implPtr()) - calculateArcAngleRadius(aCircle, aStartAttr->pnt(), anEndAttr->pnt(), aPassedPoint->pnt(), - anAngleAttr, aRadiusAttr); - } - data()->blockSendAttributeUpdated(false); -} - - void SketchPlugin_Arc::attributeChanged(const std::string& theID) { std::shared_ptr aCenterAttr = std::dynamic_pointer_cast< @@ -442,161 +365,16 @@ void SketchPlugin_Arc::attributeChanged(const std::string& theID) } return; } - - AttributeDoublePtr aRadiusAttr = std::dynamic_pointer_cast( - data()->attribute(RADIUS_ID())); - AttributeDoublePtr anAngleAttr = std::dynamic_pointer_cast( - data()->attribute(ANGLE_ID())); - - if (theID == RADIUS_ID()) { - if (!aStartAttr->isInitialized() || !anEndAttr->isInitialized()) - return; - // move center and passed point - std::shared_ptr aStartPnt = aStartAttr->pnt()->xy(); - std::shared_ptr aEndPnt = anEndAttr->pnt()->xy(); - double aDist = aStartPnt->distance(aEndPnt); - if (fabs(aDist) < tolerance) - return; - std::shared_ptr aDir(new GeomAPI_Dir2d(aEndPnt->decreased(aStartPnt))); - std::shared_ptr aMidPerpDir(new GeomAPI_Dir2d(-aDir->y(), aDir->x())); - std::shared_ptr aMidPnt = aStartPnt->added(aEndPnt)->multiplied(0.5); - - double anAngle = anAngleAttr->value() * PI / 180.0; - adjustPeriod(anAngle); - if (anAngle > PI) - aMidPerpDir->reverse(); - - double aRadius = aRadiusAttr->value(); - // The center is placed on a perpendicular bisector of a start-end points segment. - // If the radius is smaller that necessary, start and end points are moved too. - double aDist2 = aRadius * aRadius - aDist * aDist / 4.0; - aDist = aDist2 > 0.0 ? sqrt(aDist2) : 0.0; - // distance between middle point and start point (does not changed if the arc diameter is greater than start-end distance) - aDist2 = sqrt(aRadius * aRadius - aDist * aDist); - - std::shared_ptr aCenter = aMidPnt->added(aMidPerpDir->xy()->multiplied(aDist)); - aStartPnt = aMidPnt->added(aDir->xy()->multiplied(-aDist2)); - aEndPnt = aMidPnt->added(aDir->xy()->multiplied(aDist2)); - - data()->blockSendAttributeUpdated(true); - aCenterAttr->setValue(aCenter->x(), aCenter->y()); - aStartAttr->setValue(aStartPnt->x(), aStartPnt->y()); - anEndAttr->setValue(aEndPnt->x(), aEndPnt->y()); - updateDependentAttributes(); - data()->blockSendAttributeUpdated(false); - return; - } - if (theID == ANGLE_ID()) { - if (!aStartAttr->isInitialized() || !aCenterAttr->isInitialized()) - return; - data()->blockSendAttributeUpdated(true); - // move end point and passed point - std::shared_ptr aCenter = aCenterAttr->pnt()->xy(); - double anAngle = anAngleAttr->value() * PI / 180.0; - double sinA = sin(anAngle); - double cosA = cos(anAngle); - std::shared_ptr aStartDir = aStartAttr->pnt()->xy()->decreased(aCenter); - std::shared_ptr aDir(new GeomAPI_XY( - aStartDir->x() * cosA - aStartDir->y() * sinA, - aStartDir->x() * sinA + aStartDir->y() * cosA)); - anEndAttr->setValue(aCenter->x() + aDir->x(), aCenter->y() + aDir->y()); - - anAngle /= 2.0; - sinA = sin(anAngle); - cosA = cos(anAngle); - aDir = std::shared_ptr(new GeomAPI_XY( - aStartDir->x() * cosA - aStartDir->y() * sinA, - aStartDir->x() * sinA + aStartDir->y() * cosA)); - std::shared_ptr aPassedPoint = - std::dynamic_pointer_cast(attribute(PASSED_POINT_ID())); - aPassedPoint->setValue(aCenter->x() + aDir->x(), aCenter->y() + aDir->y()); - - std::shared_ptr aCircle( - new GeomAPI_Circ2d(aStartAttr->pnt(), anEndAttr->pnt(), aPassedPoint->pnt())); - calculateArcAngleRadius(aCircle, aStartAttr->pnt(), anEndAttr->pnt(), aPassedPoint->pnt(), - anAngleAttr, aRadiusAttr); - data()->blockSendAttributeUpdated(false); - return; - } - - if (theID == CENTER_ID()) { - if (isFeatureValid()) - projectEndPoint(); - return; - } - AttributeStringPtr aTypeAttr = std::dynamic_pointer_cast(attribute(ARC_TYPE())); - if (!aTypeAttr) - return; - std::string anArcType = aTypeAttr->value(); - - // update the points in accordance to the changed point changes - if (anArcType == ARC_TYPE_CENTER_START_END()) { - if (!isFeatureValid()) - return; - if (theID == END_ID() && isStable()) { - // The arc is under construction, so its end point projected - // on the circle formed by center and start points - projectEndPoint(); - } - updateDependentAttributes(); - } - else if (anArcType == ARC_TYPE_THREE_POINTS() && - (theID == START_ID() || theID == END_ID() || theID == PASSED_POINT_ID())) { - data()->blockSendAttributeUpdated(true); - std::shared_ptr aPoints[3]; - int aNbInitialized = 0; - for (int i = 1; i <= 3; ++i) { - std::shared_ptr aCurPnt = - std::dynamic_pointer_cast(attribute(POINT_ID(i))); - if (aCurPnt->isInitialized()) - aPoints[aNbInitialized++] = aCurPnt->pnt(); - } - - if (aNbInitialized == 1) - aCenterAttr->setValue(aPoints[0]->x(), aPoints[0]->y()); - else if (aNbInitialized == 2) { - // calculate center point, which gives a quarter of circle for the given start and end points - std::shared_ptr aStartPnt = aPoints[0]; - std::shared_ptr aEndPnt = aPoints[1]; - std::shared_ptr aDir = aEndPnt->xy()->decreased(aStartPnt->xy())->multiplied(0.5); - double x = aDir->x(); - double y = aDir->y(); - aDir->setX(x - y); - aDir->setY(y + x); - std::shared_ptr aCenter = aStartPnt->xy()->added(aDir); - double aRadius = sqrt(aDir->dot(aDir)); - - aCenterAttr->setValue(aCenter->x(), aCenter->y()); - aRadiusAttr->setValue(aRadius); - anAngleAttr->setValue(90.0); - } - else { - std::shared_ptr aCircle( - new GeomAPI_Circ2d(aPoints[0], aPoints[1], aPoints[2])); - - std::shared_ptr aCenter = aCircle->center(); - if (aCenter) { - aCenterAttr->setValue(aCenter); - if (theID == START_ID() || theID == END_ID()) - updateDependentAttributes(); - else - calculateArcAngleRadius(aCircle, aPoints[0], aPoints[1], aPoints[2], - anAngleAttr, aRadiusAttr); - } - } - - data()->blockSendAttributeUpdated(false); - } - else if (anArcType == ARC_TYPE_TANGENT() && (theID == TANGENT_POINT_ID() || theID == END_ID())) { + // this is before others since here end attribute may be changed, but with the special behavior + if (aTypeAttr->value() == ARC_TYPE_TANGENT() && (theID == TANGENT_POINT_ID() || theID == END_ID())) { SketchPlugin_Sketch* aSketch = sketch(); AttributeRefAttrPtr aTangPtAttr = std::dynamic_pointer_cast( data()->attribute(TANGENT_POINT_ID())); if (aTangPtAttr->isInitialized() && anEndAttr->isInitialized()) { - data()->blockSendAttributeUpdated(true); // compute orthogonal direction std::shared_ptr anOrthoDir; std::shared_ptr aTangentPoint = @@ -630,14 +408,171 @@ void SketchPlugin_Arc::attributeChanged(const std::string& theID) std::shared_ptr aMiddleLine(new GeomAPI_Lin2d(aMidPnt, aMidDir)); std::shared_ptr aCenter = anOrthoLine->intersect(aMiddleLine); if (aCenter) { + data()->blockSendAttributeUpdated(true); aCenterAttr->setValue(aCenter); aStartAttr->setValue(aTangPnt2d); - updateDependentAttributes(); + data()->blockSendAttributeUpdated(false); } - data()->blockSendAttributeUpdated(false); tangencyArcConstraints(); } + return; + } + + // if changed the base attributes, update all other (is necessary) without recursion + if (theID == CENTER_ID() || theID == START_ID() || theID == END_ID() || theID == ARC_TYPE()) { + if (!isFeatureValid()) + return; + std::shared_ptr aCenter = aCenterAttr->pnt(); + std::shared_ptr aStart = aStartAttr->pnt(); + std::shared_ptr anEnd = anEndAttr->pnt(); + double aRadius = aCenter->distance(aStart); + if (aRadius < tolerance) + return; + std::shared_ptr aCircleForArc(new GeomAPI_Circ2d(aCenter, aStart)); + + data()->blockSendAttributeUpdated(true); + if (theID == END_ID() && isStable()) { + // The arc is under construction, so its end point projected + // on the circle formed by center and start points + std::shared_ptr aProjection = aCircleForArc->project(anEnd); + if (aProjection && anEnd->distance(aProjection) > tolerance) { + anEndAttr->setValue(aProjection); + anEnd = aProjection; + } + } + // update all other attributes due to the base attributes values + if (aTypeAttr->value() == ARC_TYPE_THREE_POINTS()) { // update passed point due to start, end and center + if (aCenter->distance(aStart) > tolerance && aCenter->distance(anEnd) > tolerance) { + // project passed point t othe circle + std::shared_ptr aPassedAttr = + std::dynamic_pointer_cast(data()->attribute(PASSED_POINT_ID())); + if (aPassedAttr->isInitialized()) { + std::shared_ptr aProjection = aCircleForArc->project(aPassedAttr->pnt()); + if (aProjection && aPassedAttr->pnt()->distance(aProjection) > tolerance) { + aPassedAttr->setValue(aProjection); + } + } else { // initialize it by some middle - value + std::shared_ptr aStartDir(new GeomAPI_Dir2d( + aStart->xy()->decreased(aCenter->xy()))); + std::shared_ptr aEndDir(new GeomAPI_Dir2d( + anEnd->xy()->decreased(aCenter->xy()))); + std::shared_ptr aMidDirXY = aStartDir->xy()->added(aEndDir->xy()); + if (aMidDirXY->dot(aMidDirXY) < tolerance * tolerance) { + // start and end directions are opposite, so middle direction will be orthogonal + aMidDirXY->setX(-aStartDir->y()); + aMidDirXY->setY(aStartDir->x()); + } + std::shared_ptr aMidDir(new GeomAPI_Dir2d(aMidDirXY)); + if ((aStartDir->cross(aMidDir) > 0) ^ !isReversed()) + aMidDir->reverse(); + std::shared_ptr aPassedPnt = + aCenter->xy()->added(aMidDir->xy()->multiplied(aCenter->distance(aStart))); + std::dynamic_pointer_cast(data()->attribute(PASSED_POINT_ID()))-> + setValue(aPassedPnt->x(), aPassedPnt->y()); + } + } + } + // update radius and angle + AttributeDoublePtr aRadiusAttr = std::dynamic_pointer_cast( + data()->attribute(RADIUS_ID())); + aRadiusAttr->setValue(aRadius); + AttributeDoublePtr anAngleAttr = std::dynamic_pointer_cast( + data()->attribute(ANGLE_ID())); + std::shared_ptr aCircle(new GeomAPI_Circ2d(aCenter, aStart)); + double aStartParam, aEndParam; + aCircle->parameter(aStart, paramTolerance, aStartParam); + aCircle->parameter(anEnd, paramTolerance, aEndParam); + adjustPeriod(aStartParam); + adjustPeriod(aEndParam); + if (aTypeAttr->value() == ARC_TYPE_THREE_POINTS()) { // use the passed point for the angle calculation + std::shared_ptr aPassedAttr = + std::dynamic_pointer_cast(data()->attribute(PASSED_POINT_ID())); + double aPassedParam; + aCircle->parameter(aPassedAttr->pnt(), paramTolerance, aPassedParam); + adjustPeriod(aPassedParam); + double aNewAngle = aPassedParam >= aStartParam && aPassedParam <= aEndParam ? + ((aEndParam - aStartParam) * 180.0 / PI) : + ((aEndParam - aStartParam - 2.0 * PI) * 180.0 / PI); + if (fabs(aNewAngle - anAngleAttr->value()) > tolerance) + anAngleAttr->setValue(aNewAngle); + } else { + double aNewAngle = (aEndParam - aStartParam) * 180.0 / PI; + if (fabs(aNewAngle - anAngleAttr->value()) > tolerance) + anAngleAttr->setValue(aNewAngle); + } + // do not need to inform that other parameters were changed in this basis mode: these arguments + // change is enough + data()->blockSendAttributeUpdated(false, false); + return; + } + + if (theID == PASSED_POINT_ID()) { + data()->blockSendAttributeUpdated(true); + + std::shared_ptr aPoints[3]; + int aNbInitialized = 0; + for (int i = 1; i <= 3; ++i) { + std::shared_ptr aCurPnt = + std::dynamic_pointer_cast(attribute(POINT_ID(i))); + if (aCurPnt->isInitialized()) + aPoints[aNbInitialized++] = aCurPnt->pnt(); + } + + if (aNbInitialized == 3) { + std::shared_ptr aCircle( + new GeomAPI_Circ2d(aPoints[0], aPoints[1], aPoints[2])); + + std::shared_ptr aCenter = aCircle->center(); + if (aCenter) { + aCenterAttr->setValue(aCenter); + } + } + data()->blockSendAttributeUpdated(false); + return; + } + + if (theID == RADIUS_ID()) { + if (!aStartAttr->isInitialized() || !anEndAttr->isInitialized() || !aCenterAttr->isInitialized()) + return; + // move center and passed point + std::shared_ptr aStart = aStartAttr->pnt(); + std::shared_ptr anEnd = anEndAttr->pnt(); + std::shared_ptr aCenter = aCenterAttr->pnt(); + if (aStart->distance(aCenter) < tolerance || anEnd->distance(aCenter) < tolerance) + return; + AttributeDoublePtr aRadiusAttr = std::dynamic_pointer_cast( + data()->attribute(RADIUS_ID())); + double aRadius = aRadiusAttr->value(); + + data()->blockSendAttributeUpdated(true); + std::shared_ptr aStartDir(new GeomAPI_Dir2d(aStart->xy()->decreased(aCenter->xy()))); + std::shared_ptr aNewStart = aStartDir->xy()->multiplied(aRadius)->added(aCenter->xy()); + aStartAttr->setValue(aNewStart->x(), aNewStart->y()); + std::shared_ptr anEndDir(new GeomAPI_Dir2d(anEnd->xy()->decreased(aCenter->xy()))); + std::shared_ptr aNewEnd = anEndDir->xy()->multiplied(aRadius)->added(aCenter->xy()); + anEndAttr->setValue(aNewEnd->x(), aNewEnd->y()); + data()->blockSendAttributeUpdated(false); + return; + } + if (theID == ANGLE_ID()) { + if (!aStartAttr->isInitialized() || !aCenterAttr->isInitialized()) + return; + AttributeDoublePtr anAngleAttr = std::dynamic_pointer_cast( + data()->attribute(ANGLE_ID())); + data()->blockSendAttributeUpdated(true); + // move end point and passed point + std::shared_ptr aCenter = aCenterAttr->pnt()->xy(); + double anAngle = anAngleAttr->value() * PI / 180.0; + double sinA = sin(anAngle); + double cosA = cos(anAngle); + std::shared_ptr aStartDir = aStartAttr->pnt()->xy()->decreased(aCenter); + std::shared_ptr aDir(new GeomAPI_XY( + aStartDir->x() * cosA - aStartDir->y() * sinA, + aStartDir->x() * sinA + aStartDir->y() * cosA)); + anEndAttr->setValue(aCenter->x() + aDir->x(), aCenter->y() + aDir->y()); + data()->blockSendAttributeUpdated(false); + return; } } @@ -800,25 +735,3 @@ void SketchPlugin_Arc::tangencyArcConstraints() Events_Loop::loop()->flush(aCreateEvent); } } - -void SketchPlugin_Arc::projectEndPoint() -{ - std::shared_ptr aCenterAttr = std::dynamic_pointer_cast< - GeomDataAPI_Point2D>(data()->attribute(CENTER_ID())); - std::shared_ptr aStartAttr = std::dynamic_pointer_cast< - GeomDataAPI_Point2D>(data()->attribute(START_ID())); - std::shared_ptr anEndAttr = std::dynamic_pointer_cast< - GeomDataAPI_Point2D>(data()->attribute(END_ID())); - - if (aCenterAttr->pnt()->distance(aStartAttr->pnt()) < tolerance) - return; - data()->blockSendAttributeUpdated(true); - // compute and change the arc end point - std::shared_ptr aCircleForArc( - new GeomAPI_Circ2d(aCenterAttr->pnt(), aStartAttr->pnt())); - std::shared_ptr aProjection = aCircleForArc->project(anEndAttr->pnt()); - if (aProjection && anEndAttr->pnt()->distance(aProjection) > tolerance) - anEndAttr->setValue(aProjection); - updateDependentAttributes(); - data()->blockSendAttributeUpdated(false); -} diff --git a/src/SketchPlugin/SketchPlugin_Arc.h b/src/SketchPlugin/SketchPlugin_Arc.h index 37d1d8ff6..0fd638d93 100644 --- a/src/SketchPlugin/SketchPlugin_Arc.h +++ b/src/SketchPlugin/SketchPlugin_Arc.h @@ -124,14 +124,9 @@ private: /// Returns true if all obligatory attributes are initialized bool isFeatureValid(); - /// Update attributes like passed point, radius and angle of the arc - void updateDependentAttributes(); - /// Compose constraints to build tangency arc void tangencyArcConstraints(); - /// Project end point of arc to the circle - void projectEndPoint(); }; #endif diff --git a/src/SketchPlugin/SketchPlugin_Circle.cpp b/src/SketchPlugin/SketchPlugin_Circle.cpp index bd3efaf41..ac719a708 100644 --- a/src/SketchPlugin/SketchPlugin_Circle.cpp +++ b/src/SketchPlugin/SketchPlugin_Circle.cpp @@ -121,8 +121,6 @@ void SketchPlugin_Circle::execute() aConstr2->setShape(aCircleShape); aConstr2->setIsInHistory(false); setResult(aConstr2, 1); - - adjustThreePoints(); } } } @@ -221,23 +219,15 @@ void SketchPlugin_Circle::attributeChanged(const std::string& theID) { else if (theID == CENTER_ID() || theID == RADIUS_ID()) { std::string aType = std::dynamic_pointer_cast( data()->attribute(CIRCLE_TYPE()))->value(); - if (aType == CIRCLE_TYPE_THREE_POINTS()) - return; - - // check the execute() was called and the shape was built - if (!lastResult()) - return; - - adjustThreePoints(); - } - else if (theID == FIRST_POINT_ID() || theID == SECOND_POINT_ID() || theID == THIRD_POINT_ID()) { + if (aType == CIRCLE_TYPE_THREE_POINTS() && lastResult()) // adjust data from the solver + adjustThreePoints(); + } else if (theID == FIRST_POINT_ID() || theID == SECOND_POINT_ID() || theID == THIRD_POINT_ID()) { + // support the center and radius attributes enev in other mode: solver uses them std::string aType = std::dynamic_pointer_cast( data()->attribute(CIRCLE_TYPE()))->value(); if (aType == CIRCLE_TYPE_CENTER_AND_RADIUS()) return; - - data()->blockSendAttributeUpdated(true); - + data()->blockSendAttributeUpdated(true); // to modify two attributes at once std::shared_ptr aPoints[3]; int aNbInitialized = 0; for (int i = 1; i <= 3; ++i) { @@ -271,8 +261,14 @@ void SketchPlugin_Circle::attributeChanged(const std::string& theID) { aRadiusAttr->setValue(aRadius); } } + data()->blockSendAttributeUpdated(false, false); - data()->blockSendAttributeUpdated(false); + } else if (theID == CIRCLE_TYPE()) { // if switched to 3 points mode, adjust the needed attributes + std::string aType = std::dynamic_pointer_cast( + data()->attribute(CIRCLE_TYPE()))->value(); + if (aType == CIRCLE_TYPE_THREE_POINTS()) { + adjustThreePoints(); + } } } @@ -303,5 +299,5 @@ void SketchPlugin_Circle::adjustThreePoints() aSecondPnt->setValue(aCenterAttr->x(), aCenterAttr->y() + aRadius); aThirdPnt->setValue(aCenterAttr->x() - aRadius, aCenterAttr->y()); } - data()->blockSendAttributeUpdated(false); + data()->blockSendAttributeUpdated(false, false); }