X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FSketchPlugin%2FSketchPlugin_Validators.cpp;h=d42c783606ae58dc8d45bc5f5255c60d55d4c5a0;hb=de93e11325cc65d1067e0c3484cbb5c836bdcde6;hp=6f66dc5c734d0669c3a82d0c6fc4d0f731481420;hpb=586e0f3d89e48652e2ec3587f5e5584e13109b4a;p=modules%2Fshaper.git diff --git a/src/SketchPlugin/SketchPlugin_Validators.cpp b/src/SketchPlugin/SketchPlugin_Validators.cpp index 6f66dc5c7..d42c78360 100755 --- a/src/SketchPlugin/SketchPlugin_Validators.cpp +++ b/src/SketchPlugin/SketchPlugin_Validators.cpp @@ -10,7 +10,7 @@ #include "SketchPlugin_Circle.h" #include "SketchPlugin_ConstraintCoincidence.h" #include "SketchPlugin_ConstraintDistance.h" -#include "SketchPlugin_ConstraintFillet.h" +#include "SketchPlugin_Fillet.h" #include "SketchPlugin_ConstraintRigid.h" #include "SketchPlugin_ConstraintTangent.h" #include "SketchPlugin_Line.h" @@ -20,6 +20,8 @@ #include "SketcherPrs_Tools.h" +#include + #include #include #include @@ -30,8 +32,11 @@ #include #include #include +#include #include +#include + #include #include #include @@ -43,12 +48,13 @@ const double tolerance = 1.e-7; -bool SketchPlugin_DistanceAttrValidator::isValid(const AttributePtr& theAttribute, +bool SketchPlugin_DistanceAttrValidator::isValid(const AttributePtr& theAttribute, const std::list& theArguments, - std::string& theError) const + Events_InfoMessage& theError) const { if (theAttribute->attributeType() != ModelAPI_AttributeRefAttr::typeId()) { - theError = "The attribute with the " + theAttribute->attributeType() + " type is not processed"; + theError = "The attribute with the %1 type is not processed"; + theError.arg(theAttribute->attributeType()); return false; } @@ -57,7 +63,8 @@ bool SketchPlugin_DistanceAttrValidator::isValid(const AttributePtr& theAttribut SessionPtr aMgr = ModelAPI_Session::get(); ModelAPI_ValidatorsFactory* aFactory = aMgr->validators(); - AttributeRefAttrPtr aRefAttr = std::dynamic_pointer_cast(theAttribute); + AttributeRefAttrPtr aRefAttr = std::dynamic_pointer_cast + (theAttribute); bool isObject = aRefAttr->isObject(); if (!isObject) { // an attribute is a point. A point value is valid always for the distance @@ -66,21 +73,22 @@ bool SketchPlugin_DistanceAttrValidator::isValid(const AttributePtr& theAttribut // 1. check whether the references object is a linear ObjectPtr anObject = aRefAttr->object(); - const ModelAPI_AttributeValidator* aShapeValidator = - dynamic_cast(aFactory->validator("GeomValidators_ShapeType")); + const ModelAPI_AttributeValidator* aShapeValidator = + dynamic_cast( + aFactory->validator("GeomValidators_ShapeType")); std::list anArguments; anArguments.push_back("circle"); - std::string aCircleError; + Events_InfoMessage aCircleError; bool aShapeValid = aShapeValidator->isValid(aRefAttr, anArguments, aCircleError); // the circle line is not a valid case if (aShapeValid) { theError = "Circle can not be used in distance constraint"; return false; } - + anArguments.clear(); anArguments.push_back("line"); - std::string aLineError; + Events_InfoMessage aLineError; aShapeValid = aShapeValidator->isValid(aRefAttr, anArguments, aLineError); // if the attribute value is not a line, that means it is a vertex. A vertex is always valid if (aShapeValid) { @@ -101,55 +109,13 @@ bool SketchPlugin_DistanceAttrValidator::isValid(const AttributePtr& theAttribut return true; } - -static bool hasCoincidentPoint(FeaturePtr theFeature1, FeaturePtr theFeature2) -{ - FeaturePtr aConstrFeature; - std::list anAttrList; - if (theFeature1->getKind() == SketchPlugin_Circle::ID() || - theFeature2->getKind() == SketchPlugin_Circle::ID()) - return false; - if (theFeature2->getKind() == SketchPlugin_Line::ID()) { - anAttrList.push_back(theFeature2->attribute(SketchPlugin_Line::START_ID())); - anAttrList.push_back(theFeature2->attribute(SketchPlugin_Line::END_ID())); - } else if (theFeature2->getKind() == SketchPlugin_Arc::ID()) { - anAttrList.push_back(theFeature2->attribute(SketchPlugin_Arc::START_ID())); - anAttrList.push_back(theFeature2->attribute(SketchPlugin_Arc::END_ID())); - } - - const std::set& aRefsList = theFeature1->data()->refsToMe(); - std::set::const_iterator aRefIt = aRefsList.begin(); - for (; aRefIt != aRefsList.end(); ++aRefIt) { - aConstrFeature = std::dynamic_pointer_cast((*aRefIt)->owner()); - if (aConstrFeature->getKind() != SketchPlugin_ConstraintCoincidence::ID()) - continue; - AttributeRefAttrPtr aRefAttr = std::dynamic_pointer_cast(*aRefIt); - AttributePtr anAttr = aRefAttr->attr(); - if (anAttr->id() == SketchPlugin_Arc::CENTER_ID()) - continue; - - anAttr = aConstrFeature->attribute(SketchPlugin_Constraint::ENTITY_A()); - if (anAttr == *aRefIt) - anAttr = aConstrFeature->attribute(SketchPlugin_Constraint::ENTITY_B()); - - aRefAttr = std::dynamic_pointer_cast(anAttr); - if (!aRefAttr) - continue; - anAttr = aRefAttr->attr(); - for (std::list::const_iterator anIt = anAttrList.begin(); - anIt != anAttrList.end(); ++anIt) - if (*anIt == anAttr) - return true; - } - return false; -} - -bool SketchPlugin_TangentAttrValidator::isValid(const AttributePtr& theAttribute, +bool SketchPlugin_TangentAttrValidator::isValid(const AttributePtr& theAttribute, const std::list& theArguments, - std::string& theError) const + Events_InfoMessage& theError) const { if (theAttribute->attributeType() != ModelAPI_AttributeRefAttr::typeId()) { - theError = "The attribute with the " + theAttribute->attributeType() + " type is not processed"; + theError = "The attribute with the %1 type is not processed"; + theError.arg(theAttribute->attributeType()); return false; } @@ -158,8 +124,10 @@ bool SketchPlugin_TangentAttrValidator::isValid(const AttributePtr& theAttribute SessionPtr aMgr = ModelAPI_Session::get(); ModelAPI_ValidatorsFactory* aFactory = aMgr->validators(); - FeaturePtr anAttributeFeature = std::dynamic_pointer_cast(theAttribute->owner()); - AttributeRefAttrPtr aRefAttr = std::dynamic_pointer_cast(theAttribute); + FeaturePtr anAttributeFeature = + std::dynamic_pointer_cast(theAttribute->owner()); + AttributeRefAttrPtr aRefAttr = + std::dynamic_pointer_cast(theAttribute); bool isObject = aRefAttr->isObject(); ObjectPtr anObject = aRefAttr->object(); @@ -172,37 +140,31 @@ bool SketchPlugin_TangentAttrValidator::isValid(const AttributePtr& theAttribute if (!aOtherFea) return true; - if ((aRefFea->getKind() == SketchPlugin_Arc::ID() || - aOtherFea->getKind() == SketchPlugin_Arc::ID()) && - !hasCoincidentPoint(aRefFea, aOtherFea)) - return false; - if (aRefFea->getKind() == SketchPlugin_Line::ID()) { if (aOtherFea->getKind() != SketchPlugin_Arc::ID() && aOtherFea->getKind() != SketchPlugin_Circle::ID()) { - theError = "It refers to a " + SketchPlugin_Line::ID() + ", but " + aParamA + " is neither an " - + SketchPlugin_Arc::ID() + " nor " + SketchPlugin_Circle::ID(); + theError = "It refers to a %1, but %2 is neither an %3 nor %4"; + theError.arg(SketchPlugin_Line::ID()).arg(aParamA) + .arg(SketchPlugin_Arc::ID()).arg(SketchPlugin_Circle::ID()); return false; } } - else if (aRefFea->getKind() == SketchPlugin_Arc::ID()) { + else if (aRefFea->getKind() == SketchPlugin_Arc::ID() || + aRefFea->getKind() == SketchPlugin_Circle::ID()) { if (aOtherFea->getKind() != SketchPlugin_Line::ID() && - aOtherFea->getKind() != SketchPlugin_Arc::ID()) { - theError = "It refers to an " + SketchPlugin_Arc::ID() + ", but " + aParamA + " is not a " - + SketchPlugin_Line::ID() + " or an " + SketchPlugin_Arc::ID(); - return false; - } - } - else if (aRefFea->getKind() == SketchPlugin_Circle::ID()) { - if (aOtherFea->getKind() != SketchPlugin_Line::ID()) { - theError = "It refers to an " + SketchPlugin_Circle::ID() + ", but " + aParamA + " is not a " - + SketchPlugin_Line::ID(); + aOtherFea->getKind() != SketchPlugin_Arc::ID() && + aOtherFea->getKind() != SketchPlugin_Circle::ID()) { + theError = "It refers to an %1, but %2 is not a %3 or an %4 or a %5"; + theError.arg(SketchPlugin_Arc::ID()).arg(aParamA) + .arg(SketchPlugin_Line::ID()).arg(SketchPlugin_Arc::ID()) + .arg(SketchPlugin_Circle::ID()); return false; } } else { - theError = "It refers to " + aRefFea->getKind() + ", but should refer to " + SketchPlugin_Line::ID() - + " or " + SketchPlugin_Arc::ID() + " or " + SketchPlugin_Circle::ID(); + theError = "It refers to %1, but should refer to %2 or %3 or %4"; + theError.arg(aRefFea->getKind()).arg(SketchPlugin_Line::ID()) + .arg(SketchPlugin_Arc::ID()).arg(SketchPlugin_Circle::ID()); return false; } return true; @@ -217,10 +179,11 @@ bool SketchPlugin_TangentAttrValidator::isValid(const AttributePtr& theAttribute bool SketchPlugin_NotFixedValidator::isValid(const AttributePtr& theAttribute, const std::list& theArguments, - std::string& theError) const + Events_InfoMessage& theError) const { if (theAttribute->attributeType() != ModelAPI_AttributeRefAttr::typeId()) { - theError = "The attribute with the " + theAttribute->attributeType() + " type is not processed"; + theError = "The attribute with the %1 type is not processed"; + theError.arg(theAttribute->attributeType()); return false; } @@ -243,26 +206,29 @@ bool SketchPlugin_NotFixedValidator::isValid(const AttributePtr& theAttribute, if (aRefAttr->object() == aRAttr->object()) { ObjectPtr anObject = aRefAttr->object(); std::string aName = anObject.get() ? anObject->data()->name() : ""; - theError = "The object " + aName + " has been already fixed."; + theError = "The object %1 has been already fixed."; + theError.arg(aName); return false; } } else if (aRefAttr->attr() == aRAttr->attr()) { AttributePtr anAttribute = aRefAttr->attr(); std::string aName = anAttribute.get() ? anAttribute->id() : ""; - theError = "The attribute " + aName + " has been already fixed."; + theError = "The attribute %1 has been already fixed."; + theError.arg(aName); return false; } } return true; } -bool SketchPlugin_EqualAttrValidator::isValid(const AttributePtr& theAttribute, +bool SketchPlugin_EqualAttrValidator::isValid(const AttributePtr& theAttribute, const std::list& theArguments, - std::string& theError) const + Events_InfoMessage& theError) const { if (theAttribute->attributeType() != ModelAPI_AttributeRefAttr::typeId()) { - theError = "The attribute with the " + theAttribute->attributeType() + " type is not processed"; + theError = "The attribute with the %1 type is not processed"; + theError.arg(theAttribute->attributeType()); return false; } @@ -296,9 +262,9 @@ bool SketchPlugin_EqualAttrValidator::isValid(const AttributePtr& theAttribute, if (aFeature->getKind() != SketchPlugin_Line::ID() && aFeature->getKind() != SketchPlugin_Circle::ID() && aFeature->getKind() != SketchPlugin_Arc::ID()) { - theError = "The " + aFeature->getKind() + " feature kind of attribute is wrong. It should be " + - SketchPlugin_Line::ID() + " or " + SketchPlugin_Circle::ID() + " or " + - SketchPlugin_Arc::ID(); + theError = "The %1 feature kind of attribute is wrong. It should be %2 or %3 or %4"; + theError.arg(aFeature->getKind()).arg(SketchPlugin_Line::ID()) + .arg(SketchPlugin_Circle::ID()).arg(SketchPlugin_Arc::ID()); // wrong type of attribute return false; } @@ -306,18 +272,20 @@ bool SketchPlugin_EqualAttrValidator::isValid(const AttributePtr& theAttribute, if ((aType[0] == SketchPlugin_Line::ID() || aType[1] == SketchPlugin_Line::ID()) && aType[0] != aType[1]) { - theError = "Feature with kinds " + aType[0] + " and " + aType[1] + "can not be equal."; + theError = "Feature with kinds %1 and %2 can not be equal."; + theError.arg(aType[0]).arg(aType[1]); return false; } return true; } -bool SketchPlugin_MirrorAttrValidator::isValid(const AttributePtr& theAttribute, +bool SketchPlugin_MirrorAttrValidator::isValid(const AttributePtr& theAttribute, const std::list& theArguments, - std::string& theError) const + Events_InfoMessage& theError) const { if (theAttribute->attributeType() != ModelAPI_AttributeRefList::typeId()) { - theError = "The attribute with the " + theAttribute->attributeType() + " type is not processed"; + theError = "The attribute with the %1 type is not processed"; + theError.arg(theAttribute->attributeType()); return false; } @@ -334,19 +302,21 @@ bool SketchPlugin_MirrorAttrValidator::isValid(const AttributePtr& theAttribute, std::list::iterator aMirIter = aMirroredObjects.begin(); for (; aMirIter != aMirroredObjects.end(); aMirIter++) if (aSelObject == *aMirIter) { - theError = "The object " + aName + " is a result of mirror"; + theError = "The object %1 is a result of mirror"; + theError.arg(aName); return false; } } return true; } -bool SketchPlugin_CoincidenceAttrValidator::isValid(const AttributePtr& theAttribute, +bool SketchPlugin_CoincidenceAttrValidator::isValid(const AttributePtr& theAttribute, const std::list& theArguments, - std::string& theError) const + Events_InfoMessage& theError) const { if (theAttribute->attributeType() != ModelAPI_AttributeRefAttr::typeId()) { - theError = "The attribute with the " + theAttribute->attributeType() + " type is not processed"; + theError = "The attribute with the %1 type is not processed"; + theError.arg(theAttribute->attributeType()); return false; } @@ -358,11 +328,13 @@ bool SketchPlugin_CoincidenceAttrValidator::isValid(const AttributePtr& theAttri FeaturePtr aConstraint = std::dynamic_pointer_cast(theAttribute->owner()); AttributeRefAttrPtr aRefAttrA = aConstraint->data()->refattr(aParamA); if (!aRefAttrA) { - theError = "The " + aParamA + " attribute " + " should be " + ModelAPI_AttributeRefAttr::typeId(); + theError = "The %1 attribute should be %2"; + theError.arg(aParamA).arg(ModelAPI_AttributeRefAttr::typeId()); return false; } - AttributeRefAttrPtr aRefAttrB = std::dynamic_pointer_cast(theAttribute); + AttributeRefAttrPtr aRefAttrB = + std::dynamic_pointer_cast(theAttribute); // first attribute is a point, it may coincide with any object if (!aRefAttrA->isObject()) @@ -370,12 +342,14 @@ bool SketchPlugin_CoincidenceAttrValidator::isValid(const AttributePtr& theAttri else { ObjectPtr anObject = aRefAttrA->object(); if (!anObject.get()) { - theError = aParamA + " attribute has an empty object"; + theError = "%1 attribute has an empty object"; + theError.arg(aParamA); return false; } FeaturePtr aFeature = ModelAPI_Feature::feature(aRefAttrA->object()); if (!aFeature.get()) { - theError = aParamA + " attribute has an empty feature"; + theError = "%1 attribute has an empty feature"; + theError.arg(aParamA); return false; } @@ -389,7 +363,8 @@ bool SketchPlugin_CoincidenceAttrValidator::isValid(const AttributePtr& theAttri else { FeaturePtr aFeature = ModelAPI_Feature::feature(aRefAttrB->object()); if (!aFeature) { - theError = theAttribute->id() + " attribute has an empty object"; + theError = "%1 attribute has an empty object"; + theError.arg(theAttribute->id()); return false; } if (aFeature->getKind() == SketchPlugin_Point::ID()) @@ -400,17 +375,18 @@ bool SketchPlugin_CoincidenceAttrValidator::isValid(const AttributePtr& theAttri } -bool SketchPlugin_CopyValidator::isValid(const AttributePtr& theAttribute, +bool SketchPlugin_CopyValidator::isValid(const AttributePtr& theAttribute, const std::list& theArguments, - std::string& theError) const + Events_InfoMessage& theError) const { if (theAttribute->attributeType() != ModelAPI_AttributeRefList::typeId()) { - theError = "The attribute with the " + theAttribute->attributeType() + " type is not processed"; + theError = "The attribute with the %1 type is not processed"; + theError.arg(theAttribute->attributeType()); return false; } FeaturePtr aFeature = std::dynamic_pointer_cast(theAttribute->owner()); - AttributeRefListPtr aSelAttr = + AttributeRefListPtr aSelAttr = std::dynamic_pointer_cast(theAttribute); AttributeRefListPtr aRefListOfInitial = std::dynamic_pointer_cast( @@ -433,16 +409,18 @@ bool SketchPlugin_CopyValidator::isValid(const AttributePtr& theAttribute, for (; anObjIter != aCopiedObjects.end(); anObjIter++) if (aSelObject == *anObjIter) { std::string aName = aSelObject.get() ? aSelObject->data()->name() : ""; - theError = "The object " + aName + " is a result of copy"; + theError = "The object %1 is a result of copy"; + theError.arg(aName); return false; } } return true; } -bool SketchPlugin_SolverErrorValidator::isValid(const std::shared_ptr& theFeature, - const std::list& theArguments, - std::string& theError) const +bool SketchPlugin_SolverErrorValidator::isValid( + const std::shared_ptr& theFeature, + const std::list& theArguments, + Events_InfoMessage& theError) const { AttributeStringPtr aAttributeString = theFeature->string(SketchPlugin_Sketch::SOLVER_ERROR()); @@ -454,14 +432,17 @@ bool SketchPlugin_SolverErrorValidator::isValid(const std::shared_ptr& theRefsList, const FeaturePtr theFeature) +static bool hasSameTangentFeature(const std::set& theRefsList, + const FeaturePtr theFeature) { - for(std::set::const_iterator anIt = theRefsList.cbegin(); anIt != theRefsList.cend(); ++anIt) { + for(std::set::const_iterator + anIt = theRefsList.cbegin(); anIt != theRefsList.cend(); ++anIt) { std::shared_ptr aAttr = (*anIt); FeaturePtr aFeature = std::dynamic_pointer_cast(aAttr->owner()); if (aFeature->getKind() == SketchPlugin_ConstraintTangent::ID()) { @@ -500,181 +481,171 @@ static bool hasSameTangentFeature(const std::set& theRefsList, con bool SketchPlugin_FilletVertexValidator::isValid(const AttributePtr& theAttribute, const std::list& theArguments, - std::string& theError) const + Events_InfoMessage& theError) const { - std::shared_ptr aFilletFeature = std::dynamic_pointer_cast(theAttribute->owner()); - AttributeRefAttrListPtr aPointsRefList = std::dynamic_pointer_cast(theAttribute); - if(aPointsRefList->size() == 0) { - theError = "Error: List of points is empty."; + AttributeRefAttrPtr aPointRefAttr = + std::dynamic_pointer_cast(theAttribute); + if(!aPointRefAttr.get()) { + theError = "Error: Point not selected."; return false; } - std::map aPointsFeaturesMap = aFilletFeature->pointsFeaturesMap(); - std::set aSetOfPointsOnResultEdges; - for(std::map::iterator aPointsIter = aPointsFeaturesMap.begin(); - aPointsIter != aPointsFeaturesMap.end(); - ++aPointsIter) { - const SketchPlugin_ConstraintFillet::FilletFeatures& aFeatures = aPointsIter->second; - const std::list& aResultEdges = aFeatures.resultEdges; - for(std::list::const_iterator aResultIter = aResultEdges.cbegin(); - aResultIter != aResultEdges.cend(); - ++aResultIter) { - FeaturePtr aResultFeature = *aResultIter; - if(aResultFeature->getKind() == SketchPlugin_Line::ID()) { - aSetOfPointsOnResultEdges.insert(aResultFeature->attribute(SketchPlugin_Line::START_ID())); - aSetOfPointsOnResultEdges.insert(aResultFeature->attribute(SketchPlugin_Line::END_ID())); - } else if(aResultFeature->getKind() == SketchPlugin_Arc::ID()) { - aSetOfPointsOnResultEdges.insert(aResultFeature->attribute(SketchPlugin_Arc::START_ID())); - aSetOfPointsOnResultEdges.insert(aResultFeature->attribute(SketchPlugin_Arc::END_ID())); - } - } + AttributePtr aPointAttribute = aPointRefAttr->attr(); + if (!aPointAttribute.get()) { + theError = "Error: Bad point selected."; + return false; } + std::shared_ptr aSelectedPnt = + std::dynamic_pointer_cast(aPointAttribute)->pnt(); - std::list> aPointsList = aPointsRefList->list(); - for(std::list>::const_iterator aPointsIt = aPointsList.cbegin(); aPointsIt != aPointsList.cend(); aPointsIt++) { - ObjectPtr anObject = (*aPointsIt).first; - AttributePtr aPointAttribute = (*aPointsIt).second; - std::shared_ptr aSelectedPnt = std::dynamic_pointer_cast(aPointAttribute)->pnt(); - - // If we alredy have some result then: - // - if it is the same point all ok, just skip it - // - if it is point on the fillet result edge then it is not valid - if(!aPointsFeaturesMap.empty()) { - if(aPointsFeaturesMap.find(aPointAttribute) != aPointsFeaturesMap.end()) { - continue; - } - - // Check that selected point not on the one of the fillet result edge. - if(aSetOfPointsOnResultEdges.find(aPointAttribute) != aSetOfPointsOnResultEdges.end()) { - return false; - } - } - - // Obtain constraint coincidence for the fillet point. - const std::set& aRefsList = aPointAttribute->owner()->data()->refsToMe(); - FeaturePtr aConstraintCoincidence; - for(std::set::const_iterator anIt = aRefsList.cbegin(); anIt != aRefsList.cend(); ++anIt) { - std::shared_ptr aAttr = (*anIt); - FeaturePtr aConstrFeature = std::dynamic_pointer_cast(aAttr->owner()); - if (aConstrFeature->getKind() == SketchPlugin_ConstraintCoincidence::ID()) { - AttributeRefAttrPtr anAttrRefA = std::dynamic_pointer_cast( - aConstrFeature->attribute(SketchPlugin_ConstraintCoincidence::ENTITY_A())); - AttributeRefAttrPtr anAttrRefB = std::dynamic_pointer_cast( - aConstrFeature->attribute(SketchPlugin_ConstraintCoincidence::ENTITY_B())); - if(anAttrRefA.get() && !anAttrRefA->isObject()) { - AttributePtr anAttrA = anAttrRefA->attr(); - if(aPointAttribute == anAttrA) { - aConstraintCoincidence = aConstrFeature; - break; - } + // Obtain constraint coincidence for the fillet point. + const std::set& aRefsList = aPointAttribute->owner()->data()->refsToMe(); + FeaturePtr aConstraintCoincidence; + for(std::set::const_iterator anIt = aRefsList.cbegin(); + anIt != aRefsList.cend(); ++anIt) { + std::shared_ptr aAttr = (*anIt); + FeaturePtr aConstrFeature = std::dynamic_pointer_cast(aAttr->owner()); + if (aConstrFeature->getKind() == SketchPlugin_ConstraintCoincidence::ID()) { + AttributeRefAttrPtr anAttrRefA = std::dynamic_pointer_cast( + aConstrFeature->attribute(SketchPlugin_ConstraintCoincidence::ENTITY_A())); + AttributeRefAttrPtr anAttrRefB = std::dynamic_pointer_cast( + aConstrFeature->attribute(SketchPlugin_ConstraintCoincidence::ENTITY_B())); + if(anAttrRefA.get() && !anAttrRefA->isObject()) { + AttributePtr anAttrA = anAttrRefA->attr(); + if(aPointAttribute == anAttrA) { + aConstraintCoincidence = aConstrFeature; + break; } - if(anAttrRefB.get() && !anAttrRefB->isObject()) { - AttributePtr anAttrB = anAttrRefB->attr(); - if(aPointAttribute == anAttrB) { - aConstraintCoincidence = aConstrFeature; - break; - } + } + if(anAttrRefB.get() && !anAttrRefB->isObject()) { + AttributePtr anAttrB = anAttrRefB->attr(); + if(aPointAttribute == anAttrB) { + aConstraintCoincidence = aConstrFeature; + break; } } } + } - if(!aConstraintCoincidence.get()) { - theError = "Error: one of the selected point does not have coicidence."; - return false; - } + if(!aConstraintCoincidence.get()) { + theError = "Error: one of the selected point does not have coicidence."; + return false; + } - // Get coincides from constraint. - std::set aCoinsides; - SketchPlugin_Tools::findCoincidences(aConstraintCoincidence, - SketchPlugin_ConstraintCoincidence::ENTITY_A(), - aCoinsides); - SketchPlugin_Tools::findCoincidences(aConstraintCoincidence, - SketchPlugin_ConstraintCoincidence::ENTITY_B(), - aCoinsides); - - // Remove points from set of coincides. - std::set aNewSetOfCoincides; - for(std::set::iterator anIt = aCoinsides.begin(); anIt != aCoinsides.end(); ++anIt) { - if((*anIt)->getKind() != SketchPlugin_Line::ID() && - (*anIt)->getKind() != SketchPlugin_Arc::ID()) { - continue; - } - if((*anIt)->getKind() == SketchPlugin_Arc::ID()) { - AttributePtr anArcCenter = (*anIt)->attribute(SketchPlugin_Arc::CENTER_ID()); - std::shared_ptr anArcCenterPnt = std::dynamic_pointer_cast(anArcCenter)->pnt(); - double aDistSelectedArcCenter = aSelectedPnt->distance(anArcCenterPnt); - if(aDistSelectedArcCenter < tolerance) { + // Get coincides from constraint. + std::set aCoinsides; + SketchPlugin_Tools::findCoincidences(aConstraintCoincidence, + SketchPlugin_ConstraintCoincidence::ENTITY_A(), + aCoinsides); + SketchPlugin_Tools::findCoincidences(aConstraintCoincidence, + SketchPlugin_ConstraintCoincidence::ENTITY_B(), + aCoinsides); + + // Remove points from set of coincides. + std::set aNewSetOfCoincides; + for(std::set::iterator anIt = aCoinsides.begin(); + anIt != aCoinsides.end(); ++anIt) { + std::shared_ptr aSketchEntity = + std::dynamic_pointer_cast(*anIt); + if(aSketchEntity.get() && aSketchEntity->isCopy()) { + continue; + } + if((*anIt)->getKind() != SketchPlugin_Line::ID() && + (*anIt)->getKind() != SketchPlugin_Arc::ID()) { continue; - } + } + if((*anIt)->getKind() == SketchPlugin_Arc::ID()) { + AttributePtr anArcCenter = (*anIt)->attribute(SketchPlugin_Arc::CENTER_ID()); + std::shared_ptr anArcCenterPnt = + std::dynamic_pointer_cast(anArcCenter)->pnt(); + double aDistSelectedArcCenter = aSelectedPnt->distance(anArcCenterPnt); + if(aDistSelectedArcCenter < tolerance) { + continue; } - aNewSetOfCoincides.insert(*anIt); } - aCoinsides = aNewSetOfCoincides; + aNewSetOfCoincides.insert(*anIt); + } + aCoinsides = aNewSetOfCoincides; - // If we still have more than two coincides remove auxilary entities from set of coincides. - if(aCoinsides.size() > 2) { - aNewSetOfCoincides.clear(); - for(std::set::iterator anIt = aCoinsides.begin(); anIt != aCoinsides.end(); ++anIt) { - if(!(*anIt)->boolean(SketchPlugin_SketchEntity::AUXILIARY_ID())->value()) { - aNewSetOfCoincides.insert(*anIt); - } + // If we still have more than two coincides remove auxilary entities from set of coincides. + if(aCoinsides.size() > 2) { + aNewSetOfCoincides.clear(); + for(std::set::iterator anIt = aCoinsides.begin(); + anIt != aCoinsides.end(); ++anIt) { + if(!(*anIt)->boolean(SketchPlugin_SketchEntity::AUXILIARY_ID())->value()) { + aNewSetOfCoincides.insert(*anIt); } - aCoinsides = aNewSetOfCoincides; } + aCoinsides = aNewSetOfCoincides; + } - if(aCoinsides.size() != 2) { - theError = "Error: One of the selected points does not have two suitable edges for fillet."; - return false; - } + if(aCoinsides.size() != 2) { + theError = "Error: One of the selected points does not have two suitable edges for fillet."; + return false; + } + + // Check that selected edges don't have tangent constraint. + std::set::iterator anIt = aCoinsides.begin(); + FeaturePtr aFirstFeature = *anIt++; + FeaturePtr aSecondFeature = *anIt; + const std::set& aFirstFeatureRefsList = aFirstFeature->data()->refsToMe(); + if(hasSameTangentFeature(aFirstFeatureRefsList, aSecondFeature)) { + theError = "Error: Edges in selected point has tangent constraint."; + return false; + } - // Check that selected edges don't have tangent constraint. - std::set::iterator anIt = aCoinsides.begin(); - FeaturePtr aFirstFeature = *anIt++; - FeaturePtr aSecondFeature = *anIt; - const std::set& aFirstFeatureRefsList = aFirstFeature->data()->refsToMe(); - if(hasSameTangentFeature(aFirstFeatureRefsList, aSecondFeature)) { + std::list aFirstResults = aFirstFeature->results(); + for(std::list::iterator aResIt = aFirstResults.begin(); + aResIt != aFirstResults.end(); ++aResIt) { + ResultPtr aRes = *aResIt; + const std::set& aResRefsList = aRes->data()->refsToMe(); + if(hasSameTangentFeature(aResRefsList, aSecondFeature)) { theError = "Error: Edges in selected point has tangent constraint."; return false; } + } - std::list aFirstResults = aFirstFeature->results(); - for(std::list::iterator aResIt = aFirstResults.begin(); aResIt != aFirstResults.end(); ++aResIt) { - ResultPtr aRes = *aResIt; - const std::set& aResRefsList = aRes->data()->refsToMe(); - if(hasSameTangentFeature(aResRefsList, aSecondFeature)) { - theError = "Error: Edges in selected point has tangent constraint."; - return false; - } - } - - // Check that lines not collinear - if(aFirstFeature->getKind() == SketchPlugin_Line::ID() && aSecondFeature->getKind() == SketchPlugin_Line::ID()) { - std::string aStartAttr = SketchPlugin_Line::START_ID(); - std::string anEndAttr = SketchPlugin_Line::END_ID(); - std::shared_ptr aFirstStartPnt, aFirstEndPnt, aSecondStartPnt, aSecondEndPnt; - aFirstStartPnt = std::dynamic_pointer_cast(aFirstFeature->attribute(aStartAttr))->pnt(); - aFirstEndPnt = std::dynamic_pointer_cast(aFirstFeature->attribute(anEndAttr))->pnt(); - aSecondStartPnt = std::dynamic_pointer_cast(aSecondFeature->attribute(aStartAttr))->pnt(); - aSecondEndPnt = std::dynamic_pointer_cast(aSecondFeature->attribute(anEndAttr))->pnt(); - double aCheck1 = abs((aFirstEndPnt->x() - aFirstStartPnt->x()) * (aSecondStartPnt->y() - aFirstStartPnt->y()) - - (aSecondStartPnt->x() - aFirstStartPnt->x()) * (aFirstEndPnt->y() - aFirstStartPnt->y())); - double aCheck2 = abs((aFirstEndPnt->x() - aFirstStartPnt->x()) * (aSecondEndPnt->y() - aFirstStartPnt->y()) - - (aSecondEndPnt->x() - aFirstStartPnt->x()) * (aFirstEndPnt->y() - aFirstStartPnt->y())); - if(aCheck1 < 1.e-7 && aCheck2 < 1.e-7) { - return false; - } + // Check that lines not collinear + if(aFirstFeature->getKind() == SketchPlugin_Line::ID() && + aSecondFeature->getKind() == SketchPlugin_Line::ID()) { + std::string aStartAttr = SketchPlugin_Line::START_ID(); + std::string anEndAttr = SketchPlugin_Line::END_ID(); + std::shared_ptr aFirstStartPnt, aFirstEndPnt, aSecondStartPnt, aSecondEndPnt; + aFirstStartPnt = + std::dynamic_pointer_cast( + aFirstFeature->attribute(aStartAttr))->pnt(); + aFirstEndPnt = + std::dynamic_pointer_cast(aFirstFeature->attribute(anEndAttr))->pnt(); + aSecondStartPnt = + std::dynamic_pointer_cast( + aSecondFeature->attribute(aStartAttr))->pnt(); + aSecondEndPnt = + std::dynamic_pointer_cast( + aSecondFeature->attribute(anEndAttr))->pnt(); + double aCheck1 = + fabs((aFirstEndPnt->x() - aFirstStartPnt->x()) * + (aSecondStartPnt->y() - aFirstStartPnt->y()) - + (aSecondStartPnt->x() - aFirstStartPnt->x()) * (aFirstEndPnt->y() - aFirstStartPnt->y())); + double aCheck2 = + fabs((aFirstEndPnt->x() - aFirstStartPnt->x()) * + (aSecondEndPnt->y() - aFirstStartPnt->y()) - + (aSecondEndPnt->x() - aFirstStartPnt->x()) * (aFirstEndPnt->y() - aFirstStartPnt->y())); + if(aCheck1 < 1.e-7 && aCheck2 < 1.e-7) { + return false; } } + return true; } -bool SketchPlugin_MiddlePointAttrValidator::isValid(const AttributePtr& theAttribute, +bool SketchPlugin_MiddlePointAttrValidator::isValid(const AttributePtr& theAttribute, const std::list& theArguments, - std::string& theError) const + Events_InfoMessage& theError) const { if (theAttribute->attributeType() != ModelAPI_AttributeRefAttr::typeId()) { - theError = "The attribute with the " + theAttribute->attributeType() + " type is not processed"; + theError = "The attribute with the %1 type is not processed"; + theError.arg(theAttribute->attributeType()); return false; } @@ -683,7 +654,8 @@ bool SketchPlugin_MiddlePointAttrValidator::isValid(const AttributePtr& theAttri SessionPtr aMgr = ModelAPI_Session::get(); ModelAPI_ValidatorsFactory* aFactory = aMgr->validators(); - FeaturePtr anAttributeFeature = std::dynamic_pointer_cast(theAttribute->owner()); + FeaturePtr anAttributeFeature = + std::dynamic_pointer_cast(theAttribute->owner()); AttributeRefAttrPtr aRefAttr = std::dynamic_pointer_cast(theAttribute); AttributeRefAttrPtr anOtherAttr = anAttributeFeature->data()->refattr(aParamA); @@ -717,16 +689,18 @@ bool SketchPlugin_MiddlePointAttrValidator::isValid(const AttributePtr& theAttri bool SketchPlugin_ArcTangentPointValidator::isValid(const AttributePtr& theAttribute, const std::list& /*theArguments*/, - std::string& theError) const + Events_InfoMessage& theError) const { if (theAttribute->attributeType() != ModelAPI_AttributeRefAttr::typeId()) { - theError = "The attribute with the " + theAttribute->attributeType() + " type is not processed"; + theError = "The attribute with the %1 type is not processed"; + theError.arg(theAttribute->attributeType()); return false; } AttributeRefAttrPtr aRefAttr = std::dynamic_pointer_cast(theAttribute); AttributePtr anAttr = aRefAttr->attr(); if (!anAttr) { - theError = "The attribute " + theAttribute->id() + " should be a point"; + theError = "The attribute %1 should be a point"; + theError.arg(theAttribute->id()); return false; } @@ -736,7 +710,8 @@ bool SketchPlugin_ArcTangentPointValidator::isValid(const AttributePtr& theAttri // selected point should not be a center of arc const std::string& aPntId = anAttr->id(); if (aPntId != SketchPlugin_Arc::START_ID() && aPntId != SketchPlugin_Arc::END_ID()) { - theError = "The attribute " + aPntId + " is not supported"; + theError = "The attribute %1 is not supported"; + theError.arg(aPntId); return false; } } @@ -744,12 +719,14 @@ bool SketchPlugin_ArcTangentPointValidator::isValid(const AttributePtr& theAttri // selected point should be bound point of line const std::string& aPntId = anAttr->id(); if (aPntId != SketchPlugin_Line::START_ID() && aPntId != SketchPlugin_Line::END_ID()) { - theError = "The attribute " + aPntId + " is not supported"; + theError = "The attribute %1 is not supported"; + theError.arg(aPntId); return false; } } else { - theError = "Unable to build tangent arc on " + anAttrFeature->getKind(); + theError = "Unable to build tangent arc on %1"; + theError.arg(anAttrFeature->getKind()); return false; } @@ -771,23 +748,26 @@ bool SketchPlugin_ArcTangentPointValidator::isValid(const AttributePtr& theAttri bool SketchPlugin_IntersectionValidator::isValid(const AttributePtr& theAttribute, const std::list& theArguments, - std::string& theError) const + Events_InfoMessage& theError) const { if (theAttribute->attributeType() != ModelAPI_AttributeSelection::typeId()) { - theError = "The attribute with the " + theAttribute->attributeType() + " type is not processed"; + theError = "The attribute with the %1 type is not processed"; + theError.arg(theAttribute->attributeType()); return false; } AttributeSelectionPtr aLineAttr = - std::dynamic_pointer_cast(theAttribute); + std::dynamic_pointer_cast(theAttribute); std::shared_ptr anEdge; if(aLineAttr && aLineAttr->value() && aLineAttr->value()->isEdge()) { anEdge = std::shared_ptr(new GeomAPI_Edge(aLineAttr->value())); - } else if(aLineAttr->context() && aLineAttr->context()->shape() && aLineAttr->context()->shape()->isEdge()) { + } else if(aLineAttr->context() && + aLineAttr->context()->shape() && aLineAttr->context()->shape()->isEdge()) { anEdge = std::shared_ptr(new GeomAPI_Edge(aLineAttr->context()->shape())); } if (!anEdge || !anEdge->isLine()) { - theError = "The attribute " + theAttribute->id() + " should be a line"; + theError = "The attribute %1 should be a line"; + theError.arg(theAttribute->id()); return false; } @@ -815,27 +795,98 @@ bool SketchPlugin_IntersectionValidator::isValid(const AttributePtr& theAttribut return fabs(aNormal->dot(aLineDir)) > tolerance * tolerance; } +bool SketchPlugin_SplitValidator::isValid(const AttributePtr& theAttribute, + const std::list& theArguments, + Events_InfoMessage& theError) const +{ + bool aValid = false; + + if (theAttribute->attributeType() != ModelAPI_AttributeReference::typeId()) { + theError = "The attribute with the %1 type is not processed"; + theError.arg(theAttribute->attributeType()); + return aValid; + } + AttributeReferencePtr aFeatureAttr = + std::dynamic_pointer_cast(theAttribute); + + ObjectPtr anAttrObject = aFeatureAttr->value(); + FeaturePtr anAttrFeature = ModelAPI_Feature::feature(anAttrObject); + if (!anAttrFeature) + return aValid; + + std::string aKind = anAttrFeature->getKind(); + if (aKind == SketchPlugin_Line::ID() || + aKind == SketchPlugin_Arc::ID() || + aKind == SketchPlugin_Circle::ID()) { + + std::set anEdgeShapes; + ModelAPI_Tools::shapesOfType(anAttrFeature, GeomAPI_Shape::EDGE, anEdgeShapes); + if (anEdgeShapes.empty() || anEdgeShapes.size() > 1 /*there case has not existed yet*/) + return aValid; + + // coincidences to the feature + std::set > aRefAttributes; + ModelGeomAlgo_Point2D::getPointsOfReference(anAttrFeature, + SketchPlugin_ConstraintCoincidence::ID(), + aRefAttributes, SketchPlugin_Point::ID(), SketchPlugin_Point::COORD_ID()); + + GeomShapePtr anAttrShape = (*anEdgeShapes.begin())->shape(); + std::shared_ptr aSFeature = + std::dynamic_pointer_cast(anAttrFeature); + SketchPlugin_Sketch* aSketch = aSFeature->sketch(); + + std::shared_ptr aData = aSketch->data(); + std::shared_ptr aC = std::dynamic_pointer_cast( + aData->attribute(SketchPlugin_Sketch::ORIGIN_ID())); + std::shared_ptr aX = std::dynamic_pointer_cast( + aData->attribute(SketchPlugin_Sketch::DIRX_ID())); + std::shared_ptr aNorm = std::dynamic_pointer_cast( + aData->attribute(SketchPlugin_Sketch::NORM_ID())); + std::shared_ptr aDirY(new GeomAPI_Dir(aNorm->dir()->cross(aX->dir()))); + + typedef std::map, + std::pair >, + std::list > > > PointToRefsMap; + PointToRefsMap aPointsInfo; + + ModelGeomAlgo_Point2D::getPointsInsideShape(anAttrShape, aRefAttributes, aC->pnt(), + aX->dir(), aDirY, aPointsInfo); + int aCoincidentToFeature = (int)aPointsInfo.size(); + if (aKind == SketchPlugin_Circle::ID()) + aValid = aCoincidentToFeature >= 2; + else + aValid = aCoincidentToFeature >= 1; + } + + return aValid; +} + bool SketchPlugin_ProjectionValidator::isValid(const AttributePtr& theAttribute, const std::list& theArguments, - std::string& theError) const + Events_InfoMessage& theError) const { if (theAttribute->attributeType() != ModelAPI_AttributeSelection::typeId()) { - theError = "The attribute with the " + theAttribute->attributeType() + " type is not processed"; + theError = "The attribute with the %1 type is not processed"; + theError.arg(theAttribute->attributeType()); return false; } AttributeSelectionPtr aFeatureAttr = std::dynamic_pointer_cast(theAttribute); std::shared_ptr anEdge; - if(aFeatureAttr && aFeatureAttr->value() && aFeatureAttr->value()->isEdge()) { - anEdge = std::shared_ptr(new GeomAPI_Edge(aFeatureAttr->value())); - } else if(aFeatureAttr->context() && aFeatureAttr->context()->shape() && - aFeatureAttr->context()->shape()->isEdge()) { - anEdge = std::shared_ptr(new GeomAPI_Edge(aFeatureAttr->context()->shape())); + if (aFeatureAttr.get()) { + GeomShapePtr aVal = aFeatureAttr->value(); + ResultPtr aRes = aFeatureAttr->context(); + if(aFeatureAttr->value() && aFeatureAttr->value()->isEdge()) { + anEdge = std::shared_ptr(new GeomAPI_Edge(aFeatureAttr->value())); + } else if(aFeatureAttr->context() && aFeatureAttr->context()->shape() && + aFeatureAttr->context()->shape()->isEdge()) { + anEdge = std::shared_ptr(new GeomAPI_Edge(aFeatureAttr->context()->shape())); + } } - if (!anEdge) { - theError = "The attribute " + theAttribute->id() + " should be an edge"; + theError = "The attribute %1 should be an edge"; + theError.arg(theAttribute->id()); return false; } @@ -858,17 +909,33 @@ bool SketchPlugin_ProjectionValidator::isValid(const AttributePtr& theAttribute, std::shared_ptr aPlane = aSketch->plane(); std::shared_ptr aNormal = aPlane->direction(); + std::shared_ptr anOrigin = aPlane->location(); if (anEdge->isLine()) { - std::shared_ptr aLineDir = anEdge->line()->direction(); + std::shared_ptr aLine = anEdge->line(); + std::shared_ptr aLineDir = aLine->direction(); + std::shared_ptr aLineLoc = aLine->location(); double aDot = aNormal->dot(aLineDir); - return aDot > -1.0 + tolerance && aDot < 1.0 - tolerance; + double aDist = aLineLoc->xyz()->decreased(anOrigin->xyz())->dot(aNormal->xyz()); + bool aValid = (fabs(aDot) >= tolerance && fabs(aDot) < 1.0 - tolerance) || + (fabs(aDot) < tolerance && fabs(aDist) > tolerance); + if (!aValid) + theError = "Error: Edge is already in the sketch plane."; + return aValid; } else if (anEdge->isCircle() || anEdge->isArc()) { - std::shared_ptr aCircNormal = anEdge->circle()->normal(); + std::shared_ptr aCircle = anEdge->circle(); + std::shared_ptr aCircNormal = aCircle->normal(); + std::shared_ptr aCircCenter = aCircle->center(); double aDot = fabs(aNormal->dot(aCircNormal)); - return fabs(aDot - 1.0) < tolerance * tolerance; + double aDist = aCircCenter->xyz()->decreased(anOrigin->xyz())->dot(aNormal->xyz()); + bool aValid = fabs(aDot - 1.0) < tolerance * tolerance && fabs(aDist) > tolerance; + if (!aValid) + theError.arg(anEdge->isCircle() ? "Error: Cirlce is already in the sketch plane." + : "Error: Arc is already in the sketch plane."); + return aValid; } + theError = "Error: Selected object is not line, circle or arc."; return false; }