X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FSketchPlugin%2FSketchPlugin_Validators.cpp;h=68817c53b83ed521bb5557044cbe81fb5b544d4d;hb=a55586483e5dccc5466d6ec241e2147e210d839f;hp=f922ce8eac2b2b0e9be1c51a2e3f6284cfb0cd46;hpb=8e97f0514a5e19febf05a98077f84f63756f169f;p=modules%2Fshaper.git diff --git a/src/SketchPlugin/SketchPlugin_Validators.cpp b/src/SketchPlugin/SketchPlugin_Validators.cpp index f922ce8ea..68817c53b 100755 --- a/src/SketchPlugin/SketchPlugin_Validators.cpp +++ b/src/SketchPlugin/SketchPlugin_Validators.cpp @@ -30,6 +30,7 @@ #include "SketchPlugin_Line.h" #include "SketchPlugin_MacroArc.h" #include "SketchPlugin_MacroCircle.h" +#include "SketchPlugin_MultiRotation.h" #include "SketchPlugin_Point.h" #include "SketchPlugin_Sketch.h" #include "SketchPlugin_Trim.h" @@ -42,8 +43,8 @@ #include #include #include +#include #include - #include #include #include @@ -467,6 +468,8 @@ static bool hasSameTangentFeature(const std::set& theRefsList, anIt = theRefsList.cbegin(); anIt != theRefsList.cend(); ++anIt) { std::shared_ptr aAttr = (*anIt); FeaturePtr aFeature = std::dynamic_pointer_cast(aAttr->owner()); + if (!aFeature) + continue; if (aFeature->getKind() == SketchPlugin_ConstraintTangent::ID()) { AttributeRefAttrPtr anAttrRefA = std::dynamic_pointer_cast( aFeature->attribute(SketchPlugin_ConstraintTangent::ENTITY_A())); @@ -800,27 +803,25 @@ bool SketchPlugin_IntersectionValidator::isValid(const AttributePtr& theAttribut theError.arg(theAttribute->attributeType()); return false; } - AttributeSelectionPtr aLineAttr = - std::dynamic_pointer_cast(theAttribute); + AttributeSelectionPtr anExternalAttr = + 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()) { - anEdge = std::shared_ptr(new GeomAPI_Edge(aLineAttr->context()->shape())); + if (anExternalAttr && anExternalAttr->value() && anExternalAttr->value()->isEdge()) { + anEdge = std::shared_ptr(new GeomAPI_Edge(anExternalAttr->value())); + } else if(anExternalAttr->context() && anExternalAttr->context()->shape() && + anExternalAttr->context()->shape()->isEdge()) { + anEdge = std::shared_ptr(new GeomAPI_Edge(anExternalAttr->context()->shape())); } - if (!anEdge || !anEdge->isLine()) { - theError = "The attribute %1 should be a line"; + if (!anEdge) { + theError = "The attribute %1 should be an edge"; theError.arg(theAttribute->id()); return false; } - std::shared_ptr aLineDir = anEdge->line()->direction(); - // find a sketch std::shared_ptr aSketch; - std::set aRefs = aLineAttr->owner()->data()->refsToMe(); + std::set aRefs = anExternalAttr->owner()->data()->refsToMe(); std::set::const_iterator anIt = aRefs.begin(); for (; anIt != aRefs.end(); ++anIt) { CompositeFeaturePtr aComp = @@ -835,9 +836,16 @@ bool SketchPlugin_IntersectionValidator::isValid(const AttributePtr& theAttribut return false; } + // check the edge is intersected with sketch plane std::shared_ptr aPlane = aSketch->plane(); - std::shared_ptr aNormal = aPlane->direction(); - return fabs(aNormal->dot(aLineDir)) > tolerance * tolerance; + + std::list anIntersectionsPoints; + anEdge->intersectWithPlane(aPlane, anIntersectionsPoints); + if (anIntersectionsPoints.empty()) { + theError = "The edge is not intersected with sketch plane"; + return false; + } + return true; } bool SketchPlugin_SplitValidator::isValid(const AttributePtr& theAttribute, @@ -979,18 +987,29 @@ bool SketchPlugin_ProjectionValidator::isValid(const AttributePtr& theAttribute, AttributeSelectionPtr aFeatureAttr = std::dynamic_pointer_cast(theAttribute); std::shared_ptr anEdge; + std::shared_ptr aSketchFeature; if (aFeatureAttr.get()) { GeomShapePtr aVal = aFeatureAttr->value(); ResultPtr aRes = aFeatureAttr->context(); - if(aFeatureAttr->value() && aFeatureAttr->value()->isEdge()) { + if (aVal && aVal->isVertex()) + return true; // vertex is always could be projected + if (aVal && aVal->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())); + } else if(aRes && aRes->shape()) { + if (aRes->shape()->isVertex()) + return true; // vertex is always could be projected + else if (aRes->shape()->isEdge()) + anEdge = std::shared_ptr(new GeomAPI_Edge(aFeatureAttr->context()->shape())); + } + + // try to convert result to sketch feature + if (aRes) { + aSketchFeature = + std::dynamic_pointer_cast(ModelAPI_Feature::feature(aRes)); } } if (!anEdge) { - theError = "The attribute %1 should be an edge"; + theError = "The attribute %1 should be an edge or vertex"; theError.arg(theAttribute->id()); return false; } @@ -1011,6 +1030,10 @@ bool SketchPlugin_ProjectionValidator::isValid(const AttributePtr& theAttribute, theError = "There is no sketch referring to the current feature"; return false; } + if (aSketchFeature && aSketch.get() == aSketchFeature->sketch()) { + theError = "Unable to project feature from the same sketch"; + return false; + } std::shared_ptr aPlane = aSketch->plane(); std::shared_ptr aNormal = aPlane->direction(); @@ -1019,11 +1042,8 @@ bool SketchPlugin_ProjectionValidator::isValid(const AttributePtr& theAttribute, if (anEdge->isLine()) { std::shared_ptr aLine = anEdge->line(); std::shared_ptr aLineDir = aLine->direction(); - std::shared_ptr aLineLoc = aLine->location(); - double aDot = aNormal->dot(aLineDir); - 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); + double aDot = fabs(aNormal->dot(aLineDir)); + bool aValid = fabs(aDot - 1.0) >= tolerance * tolerance; if (!aValid) theError = "Error: Edge is already in the sketch plane."; return aValid; @@ -1031,10 +1051,8 @@ bool SketchPlugin_ProjectionValidator::isValid(const AttributePtr& theAttribute, else if (anEdge->isCircle() || anEdge->isArc()) { std::shared_ptr aCircle = anEdge->circle(); std::shared_ptr aCircNormal = aCircle->normal(); - std::shared_ptr aCircCenter = aCircle->center(); double aDot = fabs(aNormal->dot(aCircNormal)); - double aDist = aCircCenter->xyz()->decreased(anOrigin->xyz())->dot(aNormal->xyz()); - bool aValid = fabs(aDot - 1.0) < tolerance * tolerance && fabs(aDist) > tolerance; + bool aValid = fabs(aDot - 1.0) < tolerance * tolerance; if (!aValid) theError.arg(anEdge->isCircle() ? "Error: Cirlce is already in the sketch plane." : "Error: Arc is already in the sketch plane."); @@ -1508,3 +1526,162 @@ bool SketchPlugin_ArcEndPointIntersectionValidator::isValid( return false; } + +bool SketchPlugin_HasNoConstraint::isValid(const AttributePtr& theAttribute, + const std::list& theArguments, + Events_InfoMessage& theError) const +{ + std::set aFeatureKinds; + for (std::list::const_iterator anArgIt = theArguments.begin(); + anArgIt != theArguments.end(); anArgIt++) { + aFeatureKinds.insert(*anArgIt); + } + + if (theAttribute->attributeType() != ModelAPI_AttributeRefAttr::typeId()) { + theError = "The attribute with the %1 type is not processed"; + theError.arg(theAttribute->attributeType()); + return false; + } + + AttributeRefAttrPtr aRefAttr = std::dynamic_pointer_cast + (theAttribute); + bool isObject = aRefAttr->isObject(); + if (!isObject) { + theError = "It uses an empty object"; + return false; + } + ObjectPtr anObject = aRefAttr->object(); + FeaturePtr aFeature = ModelAPI_Feature::feature(anObject); + if (!aFeature.get()) { + theError = "The feature of the checked attribute is empty"; + return false; + } + + FeaturePtr aCurrentFeature = ModelAPI_Feature::feature(aRefAttr->owner()); + + std::set aRefsList = anObject->data()->refsToMe(); + std::set::const_iterator anIt = aRefsList.begin(); + for (; anIt != aRefsList.end(); anIt++) { + FeaturePtr aRefFeature = ModelAPI_Feature::feature((*anIt)->owner()); + if (aRefFeature.get() && aCurrentFeature != aRefFeature && + aFeatureKinds.find(aRefFeature->getKind()) != aFeatureKinds.end()) + return false; // constraint is found, that means that the check is not valid + } + return true; +} + +bool SketchPlugin_ReplicationReferenceValidator::isValid( + const AttributePtr& theAttribute, + const std::list& theArguments, + Events_InfoMessage& theError) const +{ + AttributeRefAttrPtr aRefAttr = + std::dynamic_pointer_cast(theAttribute); + if (!aRefAttr) + { + theError = "Incorrect attribute"; + return false; + } + + ObjectPtr anOwner; + if (aRefAttr->isObject()) + anOwner = aRefAttr->object(); + else + { + AttributePtr anAttr = aRefAttr->attr(); + anOwner = anAttr->owner(); + } + FeaturePtr anAttrOwnerFeature = ModelAPI_Feature::feature(anOwner); + if (!anAttrOwnerFeature) + return true; + AttributeBooleanPtr aCopyAttr = anAttrOwnerFeature->boolean(SketchPlugin_SketchEntity::COPY_ID()); + if (!aCopyAttr || !aCopyAttr->value()) + return true; // feature is not a copy, thus valid + + // check the copy feature is already referred by the "Multi" feature + FeaturePtr aMultiFeature = ModelAPI_Feature::feature(theAttribute->owner()); + AttributeRefListPtr aRefList = aMultiFeature->reflist(theArguments.front()); + for (int i = 0; i < aRefList->size(); ++i) + { + FeaturePtr aRefOwner = ModelAPI_Feature::feature(aRefList->object(i)); + if (aRefOwner == anAttrOwnerFeature) + { + theError = "Attribute refers to the object generated by this feature"; + return false; + } + } + + return true; +} + +bool SketchPlugin_SketchFeatureValidator::isValid(const AttributePtr& theAttribute, + const std::list& theArguments, + Events_InfoMessage& theError) const +{ + if (theAttribute->attributeType() != ModelAPI_AttributeRefAttr::typeId()) { + theError = "The attribute with the %1 type is not processed"; + theError.arg(theAttribute->attributeType()); + return false; + } + + // check the attribute refers to a sketch feature + AttributeRefAttrPtr aRefAttr = + std::dynamic_pointer_cast(theAttribute); + bool isSketchFeature = aRefAttr->isObject(); + if (isSketchFeature) { + FeaturePtr aFeature = ModelAPI_Feature::feature(aRefAttr->object()); + isSketchFeature = aFeature.get() != NULL; + if (isSketchFeature) { + std::shared_ptr aSketchFeature = + std::dynamic_pointer_cast(aFeature); + isSketchFeature = aSketchFeature.get() != NULL; + } + } + + if (isSketchFeature) + return true; + + theError = "The object selected is not a sketch feature"; + return false; +} + +bool SketchPlugin_MultiRotationAngleValidator::isValid(const AttributePtr& theAttribute, + const std::list& theArguments, + Events_InfoMessage& theError) const +{ + if (theAttribute->attributeType() != ModelAPI_AttributeDouble::typeId()) { + theError = "The attribute with the %1 type is not processed"; + theError.arg(theAttribute->attributeType()); + return false; + } + + AttributeDoublePtr anAngleAttr = + std::dynamic_pointer_cast(theAttribute); + + FeaturePtr aMultiRotation = ModelAPI_Feature::feature(theAttribute->owner()); + AttributeStringPtr anAngleType = + aMultiRotation->string(SketchPlugin_MultiRotation::ANGLE_TYPE()); + AttributeIntegerPtr aNbCopies = + aMultiRotation->integer(SketchPlugin_MultiRotation::NUMBER_OF_OBJECTS_ID()); + + if (anAngleType->value() != "FullAngle") + { + double aFullAngleValue = anAngleAttr->value() * (aNbCopies->value() - 1); + if (aFullAngleValue < -1.e-7 || aFullAngleValue > 359.9999999) + { + theError = "Rotation single angle should produce full angle less than 360 degree"; + return false; + } + } + else + { + double aFullAngleValue = anAngleAttr->value(); + if (aFullAngleValue < -1.e-7 || aFullAngleValue > 360.0000001) + { + theError = "Rotation full angle should be in range [0, 360]"; + return false; + } + } + + return true; +}