X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FSketchSolver%2FSketchSolver_ConstraintMultiTranslation.cpp;h=4f1741e7662916798ecae0c844f21434d02118ed;hb=4f565b2204d3fba046aa8c851abada2a5a17bf6c;hp=816aa8fccb6610cf125e4f7e895c903d79afe89c;hpb=d4c4c30796ce288f2e81205e0555457542f2e5be;p=modules%2Fshaper.git diff --git a/src/SketchSolver/SketchSolver_ConstraintMultiTranslation.cpp b/src/SketchSolver/SketchSolver_ConstraintMultiTranslation.cpp index 816aa8fcc..4f1741e76 100644 --- a/src/SketchSolver/SketchSolver_ConstraintMultiTranslation.cpp +++ b/src/SketchSolver/SketchSolver_ConstraintMultiTranslation.cpp @@ -1,27 +1,18 @@ +// Copyright (C) 2014-20xx CEA/DEN, EDF R&D + #include -#include #include +#include -#include #include -#include -#include -#include -#include -#include -#include - -#include -#include - -#include +#include +#include void SketchSolver_ConstraintMultiTranslation::getAttributes( - Slvs_hEntity& theStartPoint, Slvs_hEntity& theEndPoint, - std::vector< std::vector >& thePoints, - std::vector< std::vector >& theEntities) + EntityWrapperPtr& theStartPoint, EntityWrapperPtr& theEndPoint, + bool& theFullValue, std::list& theEntities) { DataPtr aData = myBaseConstraint->data(); AttributePtr aStartPointAttr = aData->attribute(SketchPlugin_MultiTranslation::START_POINT_ID()); @@ -32,143 +23,143 @@ void SketchSolver_ConstraintMultiTranslation::getAttributes( return; } - int aType = SLVS_E_UNKNOWN; // type of created entity - Slvs_hEntity anEntityID = myGroup->getAttributeId(aStartPointAttr); - if (anEntityID == SLVS_E_UNKNOWN) - anEntityID = changeEntity(aStartPointAttr, aType); - theStartPoint = anEntityID; - anEntityID = myGroup->getAttributeId(aEndPointAttr); - if (anEntityID == SLVS_E_UNKNOWN) - anEntityID = changeEntity(aEndPointAttr, aType); - theEndPoint = anEntityID; - - // Lists of objects and number of copies - AttributeRefListPtr anInitialRefList = std::dynamic_pointer_cast( - aData->attribute(SketchPlugin_Constraint::ENTITY_A())); - myNumberOfObjects = anInitialRefList->size(); - myNumberOfCopies = (size_t) aData->integer(SketchPlugin_MultiTranslation::NUMBER_OF_COPIES_ID())->value(); - AttributeRefListPtr aRefList = std::dynamic_pointer_cast( - myBaseConstraint->attribute(SketchPlugin_Constraint::ENTITY_B())); - if (!aRefList) { - myErrorMsg = SketchSolver_Error::INCORRECT_ATTRIBUTE(); - return; - } + myType = CONSTRAINT_MULTI_TRANSLATION; - // Obtain all points of initial features and store them into separate lists - // containing their translated copies. - // Also all circles and arc collected too, because they will be constrained by equal radii. - FeaturePtr aFeature; - ResultConstructionPtr aRC; - static const size_t MAX_POINTS = 3; - std::vector aPoints[MAX_POINTS]; // lists of points of features - std::vector anEntities; // list of translated entities - std::list anObjectList = aRefList->list(); - std::list::iterator anObjectIter = anObjectList.begin(); - while (anObjectIter != anObjectList.end()) { - for (size_t i = 0; i < MAX_POINTS; i++) - aPoints[i].clear(); - anEntities.clear(); - - for (size_t i = 0; i <= myNumberOfCopies && anObjectIter != anObjectList.end(); i++, anObjectIter++) { - aFeature = ModelAPI_Feature::feature(*anObjectIter); - if (!aFeature) - continue; - anEntityID = changeEntity(aFeature, aType); - anEntities.push_back(anEntityID); - Slvs_Entity anEntity = myStorage->getEntity(anEntityID); - switch (aType) { - case SLVS_E_POINT_IN_2D: - case SLVS_E_POINT_IN_3D: - aPoints[0].push_back(anEntityID); - break; - case SLVS_E_LINE_SEGMENT: - aPoints[0].push_back(anEntity.point[0]); // start point of line - aPoints[1].push_back(anEntity.point[1]); // end point of line - break; - case SLVS_E_CIRCLE: - aPoints[0].push_back(anEntity.point[0]); // center of circle - break; - case SLVS_E_ARC_OF_CIRCLE: - aPoints[0].push_back(anEntity.point[0]); // center of arc - aPoints[1].push_back(anEntity.point[1]); // start point of arc - aPoints[2].push_back(anEntity.point[2]); // end point of arc - break; - default: - myErrorMsg = SketchSolver_Error::INCORRECT_ATTRIBUTE(); - return; - } - } + myStorage->update(aStartPointAttr); + theStartPoint = myStorage->entity(aStartPointAttr); + myStorage->update(aEndPointAttr); + theEndPoint = myStorage->entity(aEndPointAttr); - for (size_t i = 0; i < MAX_POINTS; ++i) - if (!aPoints[i].empty()) - thePoints.push_back(aPoints[i]); - if (!anEntities.empty()) - theEntities.push_back(anEntities); - } + AttributeStringPtr aMethodTypeAttr = aData->string(SketchPlugin_MultiTranslation::VALUE_TYPE()); + theFullValue = aMethodTypeAttr->value() != "SingleValue"; + + getEntities(theEntities); } void SketchSolver_ConstraintMultiTranslation::process() { cleanErrorMsg(); - if (!myBaseConstraint || !myStorage || myGroup == 0) { + if (!myBaseConstraint || !myStorage || myGroupID == GID_UNKNOWN) { /// TODO: Put error message here return; } - if (!mySlvsConstraints.empty()) // some data is changed, update constraint - update(myBaseConstraint); - Slvs_hEntity aStartPoint, aEndPoint; - std::vector > anEntitiesAndCopies; - getAttributes(aStartPoint, aEndPoint, myPointsAndCopies, anEntitiesAndCopies); + EntityWrapperPtr aStartPoint, aEndPoint; + bool aFullValue; + std::list aBaseEntities; + getAttributes(aStartPoint, aEndPoint, aFullValue, aBaseEntities); if (!myErrorMsg.empty()) return; - // Create translation line - if (myTranslationLine == SLVS_E_UNKNOWN) { - Slvs_Entity aTranslationLine = Slvs_MakeLineSegment(SLVS_E_UNKNOWN, myGroup->getId(), - myGroup->getWorkplaneId(), aStartPoint, aEndPoint); - aTranslationLine.h = myStorage->addEntity(aTranslationLine); - myTranslationLine = aTranslationLine.h; - } else { - Slvs_Entity aTranslationLine = myStorage->getEntity(myTranslationLine); - if (aTranslationLine.point[0] != aStartPoint || aTranslationLine.point[1] != aEndPoint) { - aTranslationLine.point[0] = aStartPoint; - aTranslationLine.point[1] = aEndPoint; - myStorage->updateEntity(aTranslationLine); - } + AttributeStringPtr aMethodTypeAttr = + myBaseConstraint->data()->string(SketchPlugin_MultiTranslation::VALUE_TYPE()); + + BuilderPtr aBuilder = SketchSolver_Manager::instance()->builder(); + std::list aTransConstraints; + + std::list::iterator anEntIt = aBaseEntities.begin(); + for (; anEntIt != aBaseEntities.end(); ++anEntIt) { + std::list aNewConstraints = + aBuilder->createConstraint(myBaseConstraint, myGroupID, mySketchID, myType, + 0.0, aFullValue, aStartPoint, aEndPoint, std::list(1, *anEntIt)); + aTransConstraints.insert(aTransConstraints.end(), + aNewConstraints.begin(), aNewConstraints.end()); } - processEntities(anEntitiesAndCopies); + myStorage->addConstraint(myBaseConstraint, aTransConstraints); + + myAdjusted = false; adjustConstraint(); } -void SketchSolver_ConstraintMultiTranslation::adjustConstraint() +const std::string& SketchSolver_ConstraintMultiTranslation::nameNbObjects() { - Slvs_Entity aTranslationLine = myStorage->getEntity(myTranslationLine); - Slvs_hConstraint aFixed; // temporary variable - // Set the translation line unchanged during constraint recalculation - for (int i = 0; i < 2; i++) { - if (myStorage->isPointFixed(aTranslationLine.point[i], aFixed, true)) - continue; - Slvs_Constraint aConstraint = Slvs_MakeConstraint( - SLVS_E_UNKNOWN, myGroup->getId(), SLVS_C_WHERE_DRAGGED, myGroup->getWorkplaneId(), 0.0, - aTranslationLine.point[i], SLVS_E_UNKNOWN, SLVS_E_UNKNOWN, SLVS_E_UNKNOWN); - aConstraint.h = myStorage->addConstraint(aConstraint); - myStorage->addTemporaryConstraint(aConstraint.h); - } + return SketchPlugin_MultiTranslation::NUMBER_OF_OBJECTS_ID(); +} - // Check if the distance between point is 0, no need to resolve constraints (just wait another values) - double aXY[4]; - for (int i = 0; i < 2; i++) { - Slvs_Entity aPnt = myStorage->getEntity(aTranslationLine.point[i]); - aXY[2*i] = myStorage->getParameter(aPnt.param[0]).val; - aXY[2*i+1] = myStorage->getParameter(aPnt.param[1]).val; +void SketchSolver_ConstraintMultiTranslation::updateLocal() +{ + DataPtr aData = myBaseConstraint->data(); + AttributePoint2DPtr aStartPointAttribute = GeomDataAPI_Point2D::getPoint2D(aData, + SketchPlugin_MultiTranslation::START_POINT_ID()); + AttributePoint2DPtr anEndPointAttribute = GeomDataAPI_Point2D::getPoint2D(aData, + SketchPlugin_MultiTranslation::END_POINT_ID()); + AttributeStringPtr aMethodTypeAttr = aData->string(SketchPlugin_MultiTranslation::VALUE_TYPE()); + bool aFullValue = aMethodTypeAttr->value() != "SingleValue"; + + bool aStartPointChanged = aStartPointAttribute != myStartPointAttribute; + bool anEndPointChanged = anEndPointAttribute != myEndPointAttribute; + bool isMethodChanged = aFullValue != myIsFullValue; + + if (aStartPointChanged) + myStartPointAttribute = aStartPointAttribute; + if (aStartPointChanged) + myEndPointAttribute = anEndPointAttribute; + if (isMethodChanged) + myIsFullValue = aFullValue; + + if (aStartPointChanged || anEndPointChanged || isMethodChanged) { + DataPtr aData = myBaseConstraint->data(); + std::list aConstraints = myStorage->constraint(myBaseConstraint); + std::list::const_iterator anIt = aConstraints.begin(), + aLast = aConstraints.end(); + std::list anEntities; + for (; anIt != aLast; anIt++) { + ConstraintWrapperPtr aConstraint = *anIt; + aConstraint->setIsFullValue(myIsFullValue); + anEntities.clear(); + + const std::list& aConstraintEntities = aConstraint->entities(); + std::list::const_iterator aSIt = aConstraintEntities.begin(), + aSLast = aConstraintEntities.end(); + EntityWrapperPtr aStartEntity = *aSIt++; + if (aStartPointChanged) { + AttributePtr aStartPointAttr = + aData->attribute(SketchPlugin_MultiTranslation::START_POINT_ID()); + myStorage->update(aStartPointAttr); + aStartEntity = myStorage->entity(aStartPointAttr); + } + anEntities.push_back(aStartEntity); + + EntityWrapperPtr anEndEntity = *aSIt++; + if (anEndPointChanged) { + AttributePtr anEndPointAttr = + aData->attribute(SketchPlugin_MultiTranslation::END_POINT_ID()); + myStorage->update(anEndPointAttr); + anEndEntity = myStorage->entity(anEndPointAttr); + } + anEntities.push_back(anEndEntity); + + for (; aSIt != aSLast; ++aSIt) + anEntities.push_back(*aSIt); + + aConstraint->setEntities(anEntities); + } + myStorage->addConstraint(myBaseConstraint, aConstraints); + + myAdjusted = false; } - myDelta[0] = aXY[2] - aXY[0]; - myDelta[1] = aXY[3] - aXY[1]; - if (fabs(myDelta[0]) + fabs(myDelta[1]) < tolerance) { - myStorage->setNeedToResolve(false); +} + +void SketchSolver_ConstraintMultiTranslation::adjustConstraint() +{ + if (myAdjusted) return; + + // Obtain delta between start and end points of translation + EntityWrapperPtr aStart = myStorage->entity( + myBaseConstraint->attribute(SketchPlugin_MultiTranslation::START_POINT_ID())); + std::list aStartParams = aStart->parameters(); + EntityWrapperPtr aEnd = myStorage->entity( + myBaseConstraint->attribute(SketchPlugin_MultiTranslation::END_POINT_ID())); + std::list aEndParams = aEnd->parameters(); + + myDelta[0] = aEndParams.front()->value() - aStartParams.front()->value(); + myDelta[1] = aEndParams.back()->value() - aStartParams.back()->value(); + + if (myIsFullValue && myNumberOfCopies > 0) { + myDelta[0] /= myNumberOfCopies; + myDelta[1] /= myNumberOfCopies; } SketchSolver_ConstraintMulti::adjustConstraint(); @@ -195,7 +186,3 @@ void SketchSolver_ConstraintMultiTranslation::transformRelative(double& theX, do theY += myDelta[1]; } -const std::string& SketchSolver_ConstraintMultiTranslation::nameNbCopies() -{ - return SketchPlugin_MultiTranslation::NUMBER_OF_COPIES_ID(); -}