src/PartSet/PartSet_Validators.cpp

   1 // Copyright (C) 2014-20xx CEA/DEN, EDF R&D
   2
   3 // File:        PartSet_Validators.cpp
   4 // Created:     09 July 2014
   5 // Author:      Vitaly SMETANNIKOV
   6
   7 #include "PartSet_Validators.h"
   8
   9 #include "PartSet_Tools.h"
  10 #include "PartSet_SketcherMgr.h"
  11
  12 #include <TopoDS.hxx>
  13 #include <TopoDS_Edge.hxx>
  14 #include <BRep_Tool.hxx>
  15 #include <GeomAdaptor_Curve.hxx>
  16 #include <GeomAbs_CurveType.hxx>
  17 #include <ModuleBase_ISelection.h>
  18 #include <ModuleBase_WidgetShapeSelector.h>
  19 #include <ModuleBase_OperationFeature.h>
  20 #include <ModuleBase_ViewerPrs.h>
  21
  22 #include <Events_InfoMessage.h>
  23
  24 #include <ModelAPI_AttributeRefAttr.h>
  25 #include <ModelAPI_AttributeSelection.h>
  26 #include <ModelAPI_AttributeReference.h>
  27 #include <ModelAPI_AttributeSelectionList.h>
  28 #include <ModelAPI_AttributeRefList.h>
  29 #include <ModelAPI_Object.h>
  30 #include <ModelAPI_Session.h>
  31 #include <ModelAPI_Tools.h>
  32
  33 #include <SketchPlugin_Sketch.h>
  34 #include <SketchPlugin_ConstraintCoincidence.h>
  35 #include <SketchPlugin_Arc.h>
  36 #include <GeomAPI_Edge.h>
  37
  38 #include <list>
  39 #ifdef _DEBUG
  40 #include <iostream>
  41 #endif
  42
  43 int shapesNbPoints(const ModuleBase_ISelection* theSelection)
  44 {
  45   QList<ModuleBase_ViewerPrsPtr> aList = theSelection->getSelected(ModuleBase_ISelection::Viewer);
  46   ModuleBase_ISelection::filterSelectionOnEqualPoints(aList);
  47
  48   int aCount = 0;
  49   foreach (ModuleBase_ViewerPrsPtr aPrs, aList) {
  50     const GeomShapePtr& aShape = aPrs->shape();
  51     if (aShape.get() && !aShape->isNull()) {
  52       if (aShape->shapeType() == GeomAPI_Shape::VERTEX)
  53         aCount++;
  54     }
  55   }
  56   return aCount;
  57 }
  58
  59 int shapesNbLines(const ModuleBase_ISelection* theSelection)
  60 {
  61   QList<ModuleBase_ViewerPrsPtr> aList = theSelection->getSelected(ModuleBase_ISelection::Viewer);
  62   int aCount = 0;
  63   foreach(ModuleBase_ViewerPrsPtr aPrs, aList) {
  64     const GeomShapePtr& aShape = aPrs->shape();
  65     if (aShape.get() && !aShape->isNull()) {
  66       if (aShape->shapeType() == GeomAPI_Shape::EDGE) {
  67         const TopoDS_Shape& aTDShape = aShape->impl<TopoDS_Shape>();
  68         TopoDS_Edge aEdge = TopoDS::Edge(aTDShape);
  69         Standard_Real aStart, aEnd;
  70         Handle(Geom_Curve) aCurve = BRep_Tool::Curve(aEdge, aStart, aEnd);
  71         GeomAdaptor_Curve aAdaptor(aCurve);
  72         if (aAdaptor.GetType() == GeomAbs_Line)
  73           aCount++;
  74       }
  75     }
  76   }
  77   return aCount;
  78 }
  79
  80
  81 std::shared_ptr<GeomAPI_Pln> sketcherPlane(ModuleBase_Operation* theOperation)
  82 {
  83   std::shared_ptr<GeomAPI_Pln> aEmptyPln;
  84   if (theOperation) {
  85     ModuleBase_OperationFeature* aFeatureOp =
  86       dynamic_cast<ModuleBase_OperationFeature*>(theOperation);
  87     if (aFeatureOp) {
  88       CompositeFeaturePtr aFeature =
  89         std::dynamic_pointer_cast<ModelAPI_CompositeFeature>(aFeatureOp->feature());
  90       if (aFeature && (aFeature->getKind() == SketchPlugin_Sketch::ID()))
  91         return PartSet_Tools::sketchPlane(aFeature);
  92     }
  93   }
  94   return aEmptyPln;
  95 }
  96
  97
  98 bool isEmptySelectionValid(ModuleBase_Operation* theOperation)
  99 {
 100   ModuleBase_OperationFeature* aFeatureOp =
 101     dynamic_cast<ModuleBase_OperationFeature*>(theOperation);
 102   // during the create operation empty selection is always valid
 103   if (!aFeatureOp->isEditOperation()) {
 104     return true;
 105   }
 106   else {
 107     if (PartSet_SketcherMgr::isSketchOperation(aFeatureOp)) {
 108       std::shared_ptr<GeomAPI_Pln> aPlane = sketcherPlane(theOperation);
 109       if (aPlane.get())
 110         return true;
 111       else
 112         return false;
 113     }
 114     else
 115       // in edit operation an empty selection is always valid, performed for re-entrant operrations
 116       return true;
 117   }
 118 }
 119
 120 bool PartSet_DistanceSelection::isValid(const ModuleBase_ISelection* theSelection,
 121                                         ModuleBase_Operation* theOperation) const
 122 {
 123   if (theSelection->getSelected(ModuleBase_ISelection::Viewer).size() == 0) {
 124     return isEmptySelectionValid(theOperation);
 125   } else {
 126     int aCount = shapesNbPoints(theSelection) + shapesNbLines(theSelection);
 127     return (aCount > 0) && (aCount < 3);
 128   }
 129 }
 130
 131 bool PartSet_LengthSelection::isValid(const ModuleBase_ISelection* theSelection,
 132                                       ModuleBase_Operation* theOperation) const
 133 {
 134   if (theSelection->getSelected(ModuleBase_ISelection::Viewer).size() == 0) {
 135     return isEmptySelectionValid(theOperation);
 136   } else {
 137     int aCount = shapesNbLines(theSelection);
 138     return (aCount == 1);
 139   }
 140 }
 141
 142 bool PartSet_PerpendicularSelection::isValid(const ModuleBase_ISelection* theSelection,
 143                                              ModuleBase_Operation* theOperation) const
 144 {
 145   if (theSelection->getSelected(ModuleBase_ISelection::Viewer).size() == 0) {
 146     return isEmptySelectionValid(theOperation);
 147   } else {
 148     int aCount = shapesNbLines(theSelection);
 149     return (aCount > 0) && (aCount < 3);
 150   }
 151 }
 152
 153 bool PartSet_ParallelSelection::isValid(const ModuleBase_ISelection* theSelection,
 154                                         ModuleBase_Operation* theOperation) const
 155 {
 156   if (theSelection->getSelected(ModuleBase_ISelection::Viewer).size() == 0) {
 157     return isEmptySelectionValid(theOperation);
 158   } else {
 159     int aCount = shapesNbLines(theSelection);
 160     return (aCount > 0) && (aCount < 3);
 161   }
 162 }
 163
 164 bool PartSet_RadiusSelection::isValid(const ModuleBase_ISelection* theSelection,
 165                                       ModuleBase_Operation* theOperation) const
 166 {
 167   if (theSelection->getSelected(ModuleBase_ISelection::Viewer).size() == 0) {
 168     return isEmptySelectionValid(theOperation);
 169   } else {
 170     QList<ModuleBase_ViewerPrsPtr> aList =
 171       theSelection->getSelected(ModuleBase_ISelection::Viewer);
 172     int aCount = 0;
 173     foreach (ModuleBase_ViewerPrsPtr aPrs, aList) {
 174       const GeomShapePtr& aShape = aPrs->shape();
 175       if (aShape.get() && !aShape->isNull()) {
 176         if (aShape->shapeType() == GeomAPI_Shape::EDGE) {
 177           const TopoDS_Shape& aTDShape = aShape->impl<TopoDS_Shape>();
 178           TopoDS_Edge aEdge = TopoDS::Edge(aTDShape);
 179           Standard_Real aStart, aEnd;
 180           Handle(Geom_Curve) aCurve = BRep_Tool::Curve(aEdge, aStart, aEnd);
 181           GeomAdaptor_Curve aAdaptor(aCurve);
 182           if (aAdaptor.GetType() == GeomAbs_Circle)
 183             aCount++;
 184         }
 185       }
 186     }
 187     return (aCount == 1);
 188   }
 189 }
 190
 191 bool PartSet_RigidSelection::isValid(const ModuleBase_ISelection* theSelection,
 192                                      ModuleBase_Operation* theOperation) const
 193 {
 194   if (theSelection->getSelected(ModuleBase_ISelection::Viewer).size() == 0) {
 195     return isEmptySelectionValid(theOperation);
 196   } else {
 197     QList<ModuleBase_ViewerPrsPtr> aList =
 198       theSelection->getSelected(ModuleBase_ISelection::Viewer);
 199     int aCount = 0;
 200     foreach (ModuleBase_ViewerPrsPtr aPrs, aList) {
 201       ObjectPtr aObj = aPrs->object();
 202       if (aObj.get()) {
 203         FeaturePtr aFeature = ModelAPI_Feature::feature(aObj);
 204         if (aFeature.get()) {
 205           std::shared_ptr<SketchPlugin_Feature> aSketch =
 206             std::dynamic_pointer_cast<SketchPlugin_Feature>(aFeature);
 207           if (aSketch.get())
 208             aCount++;
 209         }
 210       }
 211     }
 212     return (aCount == 1);
 213   }
 214 }
 215
 216
 217 bool PartSet_CoincidentSelection::isValid(const ModuleBase_ISelection* theSelection,
 218                                           ModuleBase_Operation* theOperation) const
 219 {
 220   if (theSelection->getSelected(ModuleBase_ISelection::Viewer).size() == 0) {
 221     return isEmptySelectionValid(theOperation);
 222   } else {
 223     // Coincident can be applied to points and to lines
 224     int aCount = shapesNbPoints(theSelection);
 225     aCount += shapesNbLines(theSelection);
 226     return (aCount > 0) && (aCount < 3);
 227   }
 228 }
 229
 230 bool PartSet_HVDirSelection::isValid(const ModuleBase_ISelection* theSelection,
 231                                      ModuleBase_Operation* theOperation) const
 232 {
 233   if (theSelection->getSelected(ModuleBase_ISelection::Viewer).size() == 0) {
 234     return isEmptySelectionValid(theOperation);
 235   } else {
 236     int aCount = shapesNbLines(theSelection);
 237     return (aCount == 1);
 238   }
 239 }
 240
 241 bool PartSet_FilletSelection::isValid(const ModuleBase_ISelection* theSelection,
 242                                       ModuleBase_Operation* theOperation) const
 243 {
 244   if (theSelection->getSelected(ModuleBase_ISelection::Viewer).size() == 0) {
 245     return isEmptySelectionValid(theOperation);
 246   } else {
 247     int aCount = shapesNbPoints(theSelection);
 248     return aCount > 1;
 249   }
 250 }
 251
 252 bool PartSet_TangentSelection::isValid(const ModuleBase_ISelection* theSelection,
 253                                        ModuleBase_Operation* theOperation) const
 254 {
 255   if (theSelection->getSelected(ModuleBase_ISelection::Viewer).size() == 0) {
 256     return isEmptySelectionValid(theOperation);
 257   } else {
 258     QList<ModuleBase_ViewerPrsPtr> aList = theSelection->getSelected(ModuleBase_ISelection::Viewer);
 259     if ((aList.size() == 0) || (aList.size() > 2))
 260       return false;
 261
 262     ModuleBase_ViewerPrsPtr aPrs = aList.first();
 263     const GeomShapePtr& aShape = aPrs->shape();
 264     if (!aShape.get() || aShape->isNull() || aShape->shapeType() != GeomAPI_Shape::EDGE)
 265       return false;
 266     GeomAPI_Edge aEdge1(aShape);
 267
 268     if (aEdge1.isLine() || aEdge1.isArc()) {
 269       if (aList.size() == 2) {
 270         // Check second selection
 271         aPrs = aList.last();
 272         const GeomShapePtr& aShape2 = aPrs->shape();
 273         if (!aShape2.get() || aShape2->isNull() || aShape2->shapeType() != GeomAPI_Shape::EDGE)
 274           return false;
 275         GeomAPI_Edge aEdge2(aShape2);
 276
 277         if (aEdge1.isLine() && aEdge2.isArc())
 278           return true;
 279         else if (aEdge1.isArc() && aEdge2.isLine())
 280           return true;
 281         else
 282           return false;
 283       } else
 284         return true;
 285     }
 286     return false;
 287   }
 288 }
 289
 290 bool PartSet_AngleSelection::isValid(const ModuleBase_ISelection* theSelection,
 291                                      ModuleBase_Operation* theOperation) const
 292 {
 293   if (theSelection->getSelected(ModuleBase_ISelection::Viewer).size() == 0) {
 294     return isEmptySelectionValid(theOperation);
 295   } else {
 296     int aCount = shapesNbLines(theSelection);
 297     return (aCount > 0) && (aCount < 3);
 298   }
 299 }
 300
 301 bool PartSet_EqualSelection::isValid(const ModuleBase_ISelection* theSelection,
 302                                      ModuleBase_Operation* theOperation) const
 303 {
 304   if (theSelection->getSelected(ModuleBase_ISelection::Viewer).size() == 0) {
 305     return isEmptySelectionValid(theOperation);
 306   } else {
 307     QList<ModuleBase_ViewerPrsPtr> aList =
 308       theSelection->getSelected(ModuleBase_ISelection::Viewer);
 309     int aCount = 0;
 310     int aType = 0;
 311     foreach (ModuleBase_ViewerPrsPtr aPrs, aList) {
 312       GeomShapePtr aShape = aPrs->shape();
 313       if (aShape.get() && aShape->isEdge()) {
 314         aCount++;
 315         GeomAPI_Edge aEdge(aShape);
 316         if (aEdge.isLine()) {
 317           if (aCount == 1)
 318             aType = 1;
 319           else if (aType != 1)
 320             return false;
 321         } else if (aEdge.isCircle()) {
 322           if (aCount == 1)
 323             aType = 2;
 324           else if (aType != 2)
 325             return false;
 326         } else if (aEdge.isArc()) {
 327           if (aCount == 1)
 328             aType = 3;
 329           else if (aType != 3)
 330             return false;
 331         }
 332       } else
 333         return false;
 334     }
 335     return (aCount > 0) && (aCount < 3);
 336   }
 337 }
 338
 339 bool PartSet_CollinearSelection::isValid(const ModuleBase_ISelection* theSelection,
 340                                          ModuleBase_Operation* theOperation) const
 341 {
 342   if (theSelection->getSelected(ModuleBase_ISelection::Viewer).size() == 0) {
 343     return isEmptySelectionValid(theOperation);
 344   } else {
 345     int aCount = shapesNbLines(theSelection);
 346     return (aCount > 0) && (aCount < 3);
 347   }
 348 }
 349
 350 bool PartSet_MiddlePointSelection::isValid(const ModuleBase_ISelection* theSelection,
 351                                            ModuleBase_Operation* theOperation) const
 352 {
 353   if (theSelection->getSelected(ModuleBase_ISelection::Viewer).size() == 0)
 354     return isEmptySelectionValid(theOperation);
 355   else
 356     return shapesNbLines(theSelection) == 1 || shapesNbPoints(theSelection) == 1;
 357 }
 358
 359 bool PartSet_MultyTranslationSelection::isValid(const ModuleBase_ISelection* theSelection,
 360                                      ModuleBase_Operation* theOperation) const
 361 {
 362   if (theSelection->getSelected(ModuleBase_ISelection::Viewer).size() == 0) {
 363     return isEmptySelectionValid(theOperation);
 364   } else {
 365     int aCount = shapesNbLines(theSelection);
 366     return aCount > 0;
 367   }
 368 }
 369
 370 bool PartSet_SplitSelection::isValid(const ModuleBase_ISelection* theSelection,
 371                                      ModuleBase_Operation* theOperation) const
 372 {
 373   if (theSelection->getSelected(ModuleBase_ISelection::Viewer).size() == 0) {
 374     return isEmptySelectionValid(theOperation);
 375   } else {
 376     int aCount = shapesNbLines(theSelection);
 377     return aCount > 0;
 378   }
 379 }
 380
 381 bool PartSet_ProjectionSelection::isValid(const ModuleBase_ISelection* theSelection,
 382                                      ModuleBase_Operation* theOperation) const
 383 {
 384   if (theSelection->getSelected(ModuleBase_ISelection::Viewer).size() == 0) {
 385     return isEmptySelectionValid(theOperation);
 386   } else {
 387     int aCount = shapesNbLines(theSelection);
 388     return aCount > 0;
 389   }
 390 }
 391
 392
 393 std::string PartSet_DifferentObjectsValidator::errorMessage(
 394                          const PartSet_DifferentObjectsValidator::ErrorType& theType,
 395                          const std::string& thEqualObject, const std::string& theFirstAttribute,
 396                          const std::string& theSecondAttribute) const
 397 {
 398   std::string anError;
 399   switch (theType) {
 400     case EqualObjects:
 401       anError = "The feature uses one " + thEqualObject + " object in " +
 402                 theFirstAttribute + " and " + theSecondAttribute + " attributes.";
 403       break;
 404     case EqualAttributes:
 405       anError = "The feature uses reference to one " + thEqualObject + " attribute in " +
 406                 theFirstAttribute + " and " + theSecondAttribute + " attributes.";
 407       break;
 408     case EqualShapes:
 409       anError = "The feature uses one shape in " +
 410                 theFirstAttribute + " and " + theSecondAttribute + " attributes.";
 411       break;
 412     case EmptyShapes:
 413       anError = "The feature uses empty shapes in " +
 414                 theFirstAttribute + " and " + theSecondAttribute + " attributes.";
 415       break;
 416       break;
 417     default:
 418       break;
 419   }
 420   return anError;
 421 }
 422
 423 bool PartSet_DifferentObjectsValidator::isValid(const AttributePtr& theAttribute,
 424                                                 const std::list<std::string>& theArguments,
 425                                                 Events_InfoMessage& theError) const
 426 {
 427   FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(theAttribute->owner());
 428
 429   // the type of validated attributes should be equal, attributes with
 430   // different types are not validated
 431   // Check RefAttr attributes
 432   std::string anAttrType = theAttribute->attributeType();
 433   std::list<std::shared_ptr<ModelAPI_Attribute> > anAttrs;
 434
 435   if (anAttrType == ModelAPI_AttributeRefAttr::typeId()) {
 436     AttributeRefAttrPtr anAttr =
 437       std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(theAttribute);
 438     bool isObject = anAttr->isObject();
 439     ObjectPtr anObject = anAttr->object();
 440
 441     anAttrs = aFeature->data()->attributes(ModelAPI_AttributeRefAttr::typeId());
 442     if (anAttrs.size() > 0) {
 443       std::list<std::shared_ptr<ModelAPI_Attribute> >::iterator anAttrIter = anAttrs.begin();
 444       for(; anAttrIter != anAttrs.end(); anAttrIter++) {
 445       if ((*anAttrIter).get() && (*anAttrIter)->id() != theAttribute->id()) {
 446           std::shared_ptr<ModelAPI_AttributeRefAttr> aRef =
 447                               std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(*anAttrIter);
 448           if (aRef->isObject() != isObject)
 449             continue;
 450           if (isObject) {
 451             if (aRef->object() == anObject) {
 452               theError = errorMessage(EqualObjects, anObject.get() ? anObject->data()->name() : "",
 453                                       theAttribute->id(), aRef->id());
 454               return false;
 455             }
 456           }
 457           else { // the attribute reference
 458             AttributePtr anAttributeAttr = anAttr->attr();
 459             if (aRef->attr() == anAttributeAttr) {
 460               theError = errorMessage(EqualAttributes,
 461                                       anAttributeAttr.get() ? anAttributeAttr->id() : "",
 462                                       theAttribute->id(), aRef->id());
 463               return false;
 464             }
 465           }
 466         }
 467       }
 468     }
 469   }
 470   else if (anAttrType == ModelAPI_AttributeSelection::typeId()) {
 471     AttributeSelectionPtr anAttr =
 472       std::dynamic_pointer_cast<ModelAPI_AttributeSelection>(theAttribute);
 473     ResultPtr aContext = anAttr->context();
 474     GeomShapePtr aShape = anAttr->value();
 475
 476     // Check selection attributes
 477     anAttrs = aFeature->data()->attributes(ModelAPI_AttributeSelection::typeId());
 478     if (anAttrs.size() > 0) {
 479       std::list<std::shared_ptr<ModelAPI_Attribute> >::iterator anAttr = anAttrs.begin();
 480       for(; anAttr != anAttrs.end(); anAttr++) {
 481         if ((*anAttr).get() && (*anAttr)->id() != theAttribute->id()) {
 482           std::shared_ptr<ModelAPI_AttributeSelection> aRef =
 483                               std::dynamic_pointer_cast<ModelAPI_AttributeSelection>(*anAttr);
 484           // check the object is already presented
 485           if (aRef->context() == aContext) {
 486             bool aHasShape = aShape.get() != NULL;
 487             if (!aHasShape || aRef->value()->isEqual(aShape)) {
 488               theError = errorMessage(EqualShapes, "", theAttribute->id(), aRef->id());
 489               return false;
 490             }
 491           }
 492         }
 493       }
 494     }
 495   }
 496   else if (anAttrType == ModelAPI_AttributeReference::typeId()) {
 497     AttributeReferencePtr anAttr =
 498       std::dynamic_pointer_cast<ModelAPI_AttributeReference>(theAttribute);
 499     ObjectPtr anObject = anAttr->value();
 500     // Check selection attributes
 501     anAttrs = aFeature->data()->attributes(ModelAPI_AttributeReference::typeId());
 502     if (anAttrs.size() > 0) {
 503       std::list<std::shared_ptr<ModelAPI_Attribute> >::iterator anAttr = anAttrs.begin();
 504       for(; anAttr != anAttrs.end(); anAttr++) {
 505         if ((*anAttr).get() && (*anAttr)->id() != theAttribute->id()) {
 506           std::shared_ptr<ModelAPI_AttributeReference> aRef =
 507             std::dynamic_pointer_cast<ModelAPI_AttributeReference>(*anAttr);
 508           // check the object is already presented
 509           if (aRef->value() == anObject) {
 510             theError = errorMessage(EqualObjects, anObject.get() ? anObject->data()->name() : "",
 511                                     theAttribute->id(), aRef->id());
 512             return false;
 513           }
 514         }
 515         return true;
 516       }
 517     }
 518   }
 519   else if(anAttrType == ModelAPI_AttributeSelectionList::typeId()) {
 520     std::shared_ptr<ModelAPI_AttributeSelectionList> aCurSelList =
 521             std::dynamic_pointer_cast<ModelAPI_AttributeSelectionList>(theAttribute);
 522     anAttrs = aFeature->data()->attributes(ModelAPI_AttributeSelectionList::typeId());
 523     if(anAttrs.size() > 0) {
 524       std::list<std::shared_ptr<ModelAPI_Attribute>>::iterator anAttrItr = anAttrs.begin();
 525       for(; anAttrItr != anAttrs.end(); anAttrItr++){
 526         if ((*anAttrItr).get() && (*anAttrItr)->id() != theAttribute->id()){
 527           std::shared_ptr<ModelAPI_AttributeSelectionList> aRefSelList =
 528             std::dynamic_pointer_cast<ModelAPI_AttributeSelectionList>(*anAttrItr);
 529           for(int i = 0; i < aCurSelList->size(); i++) {
 530             std::shared_ptr<ModelAPI_AttributeSelection> aCurSel = aCurSelList->value(i);
 531             ResultPtr aCurSelContext = aCurSel->context();
 532             ResultCompSolidPtr aCurSelCompSolidPtr = ModelAPI_Tools::compSolidOwner(aCurSelContext);
 533             std::shared_ptr<GeomAPI_Shape> aCurSelCompSolid;
 534             if(aCurSelCompSolidPtr.get()) {
 535               aCurSelCompSolid = aCurSelCompSolidPtr->shape();
 536             }
 537             for(int j = 0; j < aRefSelList->size(); j++) {
 538               std::shared_ptr<ModelAPI_AttributeSelection> aRefSel = aRefSelList->value(j);
 539               ResultPtr aRefSelContext = aRefSel->context();
 540               ResultCompSolidPtr aRefSelCompSolidPtr =
 541                 ModelAPI_Tools::compSolidOwner(aRefSelContext);
 542               std::shared_ptr<GeomAPI_Shape> aRefSelCompSolid;
 543               if(aRefSelCompSolidPtr.get()) {
 544                 aRefSelCompSolid = aRefSelCompSolidPtr->shape();
 545               }
 546               if ((aCurSelCompSolid.get() && aCurSelCompSolid->isEqual(aRefSel->value()))
 547                 || (aRefSelCompSolid.get() && aRefSelCompSolid->isEqual(aCurSel->value()))) {
 548                   theError = errorMessage(EqualShapes, "", theAttribute->id(),
 549                                           aRefSel->id());
 550                   return false;
 551               }
 552               if(aCurSelContext == aRefSelContext) {
 553                 if (aCurSel->value().get() == NULL || aRefSel->value().get() == NULL) {
 554                   theError = errorMessage(EmptyShapes, "", theAttribute->id(),
 555                                           aRefSel->id());
 556                   return false;
 557                 }
 558                 if (aCurSel->value()->isEqual(aRefSel->value())) {
 559                   theError = errorMessage(EqualShapes, "", theAttribute->id(),
 560                                           aRefSel->id());
 561                   return false;
 562                 }
 563               }
 564             }
 565           }
 566         }
 567       }
 568     }
 569   }
 570   else if (anAttrType == ModelAPI_AttributeRefList::typeId()) {
 571     std::shared_ptr<ModelAPI_AttributeRefList> aCurSelList =
 572       std::dynamic_pointer_cast<ModelAPI_AttributeRefList>(theAttribute);
 573     anAttrs = aFeature->data()->attributes(ModelAPI_AttributeRefList::typeId());
 574     if (anAttrs.size() > 0) {
 575       std::list<std::shared_ptr<ModelAPI_Attribute>>::iterator anAttrItr = anAttrs.begin();
 576       for (; anAttrItr != anAttrs.end(); anAttrItr++){
 577         if ((*anAttrItr).get() && (*anAttrItr)->id() != theAttribute->id()){
 578           std::shared_ptr<ModelAPI_AttributeRefList> aRefSelList =
 579             std::dynamic_pointer_cast<ModelAPI_AttributeRefList>(*anAttrItr);
 580           for (int i = 0; i < aCurSelList->size(); i++) {
 581             ObjectPtr aCurSelObject = aCurSelList->object(i);
 582             for (int j = 0; j < aRefSelList->size(); j++) {
 583               if (aCurSelObject == aRefSelList->object(j)) {
 584                 theError = errorMessage(EqualObjects,
 585                               aCurSelObject.get() ? aCurSelObject->data()->name() : "",
 586                               theAttribute->id(), aCurSelList->id());
 587                 return false;
 588               }
 589             }
 590           }
 591         }
 592       }
 593     }
 594   }
 595   return true;
 596 }
 597
 598 bool PartSet_CoincidentAttr::isValid(const AttributePtr& theAttribute,
 599                                      const std::list<std::string>& theArguments,
 600                                      Events_InfoMessage& theError) const
 601 {
 602   if (theAttribute->attributeType() != ModelAPI_AttributeRefAttr::typeId()) {
 603     theError = "The attribute with the %1 type is not processed";
 604     theError.arg(theAttribute->attributeType());
 605     return false;
 606   }
 607
 608   // there is a check whether the feature contains a point and a linear edge or two point values
 609   std::string aParamA = theArguments.front();
 610   SessionPtr aMgr = ModelAPI_Session::get();
 611   ModelAPI_ValidatorsFactory* aFactory = aMgr->validators();
 612
 613   FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(theAttribute->owner());
 614   AttributeRefAttrPtr aRefAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(theAttribute);
 615   QList<FeaturePtr> aCoinsideLines;
 616   QList<FeaturePtr> aCoins;
 617
 618   bool isObject = aRefAttr->isObject();
 619   ObjectPtr anObject = aRefAttr->object();
 620   if (isObject && anObject) {
 621     FeaturePtr aRefFea = ModelAPI_Feature::feature(anObject);
 622     AttributeRefAttrPtr aOtherAttr = aFeature->data()->refattr(aParamA);
 623     ObjectPtr aOtherObject = aOtherAttr->object();
 624     // if the other attribute is not filled still, the result is true
 625     if (!aOtherObject.get())
 626       return true;
 627     FeaturePtr aOtherFea = ModelAPI_Feature::feature(aOtherObject);
 628
 629     // check that both have coincidence
 630     FeaturePtr aConstrFeature;
 631     std::set<FeaturePtr> aCoinList;
 632     const std::set<std::shared_ptr<ModelAPI_Attribute>>& aRefsList = aRefFea->data()->refsToMe();
 633     std::set<std::shared_ptr<ModelAPI_Attribute>>::const_iterator aIt;
 634     for (aIt = aRefsList.cbegin(); aIt != aRefsList.cend(); ++aIt) {
 635       std::shared_ptr<ModelAPI_Attribute> aAttr = (*aIt);
 636       aConstrFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(aAttr->owner());
 637       if (aConstrFeature->getKind() == SketchPlugin_ConstraintCoincidence::ID()) {
 638         AttributeRefAttrPtr aRAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(aAttr);
 639         AttributePtr aAR = aRAttr->attr();
 640         if (aAR->id() != SketchPlugin_Arc::CENTER_ID()) // ignore constraint to center of arc
 641           aCoinList.insert(aConstrFeature);
 642           PartSet_Tools::findCoincidences(aConstrFeature, aCoinsideLines, aCoins,
 643                                           SketchPlugin_ConstraintCoincidence::ENTITY_A());
 644           PartSet_Tools::findCoincidences(aConstrFeature, aCoinsideLines, aCoins,
 645                                           SketchPlugin_ConstraintCoincidence::ENTITY_B());
 646       }
 647     }
 648     // if there is no coincidence then it is not valid
 649     if (aCoinList.size() > 0) {
 650       QList<FeaturePtr>::const_iterator anIt = aCoinsideLines.begin(), aLast = aCoinsideLines.end();
 651       bool aValid = false;
 652       for (; anIt != aLast && !aValid; anIt++) {
 653         aValid = *anIt == aOtherFea;
 654       }
 655       if (aValid)
 656         return true;
 657     }
 658   }
 659   theError = "There is no a common coincident point.";
 660   return false;
 661 }