src/BuildPlugin/BuildPlugin_Validators.cpp

   1 // Copyright (C) 2014-2017  CEA/DEN, EDF R&D
   2 //
   3 // This library is free software; you can redistribute it and/or
   4 // modify it under the terms of the GNU Lesser General Public
   5 // License as published by the Free Software Foundation; either
   6 // version 2.1 of the License, or (at your option) any later version.
   7 //
   8 // This library is distributed in the hope that it will be useful,
   9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 // Lesser General Public License for more details.
  12 //
  13 // You should have received a copy of the GNU Lesser General Public
  14 // License along with this library; if not, write to the Free Software
  15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  16 //
  17 // See http://www.salome-platform.org/ or
  18 // email : webmaster.salome@opencascade.com<mailto:webmaster.salome@opencascade.com>
  19 //
  20
  21 #include "BuildPlugin_Validators.h"
  22
  23 #include <ModelAPI_AttributeSelectionList.h>
  24 #include <ModelAPI_ResultConstruction.h>
  25
  26 #include <GeomAPI_PlanarEdges.h>
  27 #include <GeomAPI_Pln.h>
  28 #include <GeomAPI_ShapeExplorer.h>
  29
  30 #include <GeomAlgoAPI_CompoundBuilder.h>
  31 #include <GeomAlgoAPI_PaveFiller.h>
  32 #include <GeomAlgoAPI_ShapeBuilder.h>
  33 #include <GeomAlgoAPI_ShapeTools.h>
  34 #include <GeomAlgoAPI_SketchBuilder.h>
  35 #include <GeomAlgoAPI_WireBuilder.h>
  36 #include <GeomAlgoAPI_MakeVolume.h>
  37 #include <GeomAPI_ShapeIterator.h>
  38 #include <GeomAPI_ShapeExplorer.h>
  39
  40 #include <GeomValidators_FeatureKind.h>
  41 #include <GeomValidators_ShapeType.h>
  42
  43 #include <Events_InfoMessage.h>
  44
  45 //=================================================================================================
  46 bool BuildPlugin_ValidatorBaseForBuild::isValid(const AttributePtr& theAttribute,
  47                                                 const std::list<std::string>& theArguments,
  48                                                 Events_InfoMessage& theError) const
  49 {
  50   // Get base objects list.
  51   if(theAttribute->attributeType() != ModelAPI_AttributeSelectionList::typeId()) {
  52     std::string aMsg = "Error: BuildPlugin_ValidatorBaseForBuild does "
  53                        "not support attribute type '%1'\nOnly '%2' is supported.";
  54     Events_InfoMessage("BuildPlugin_Validators", aMsg).
  55       arg(theAttribute->attributeType()).arg(ModelAPI_AttributeSelectionList::typeId()).send();
  56     return false;
  57   }
  58   AttributeSelectionListPtr aSelectionList =
  59     std::dynamic_pointer_cast<ModelAPI_AttributeSelectionList>(theAttribute);
  60   if(!aSelectionList.get()) {
  61     theError = "Could not get selection list.";
  62     return false;
  63   }
  64   if(aSelectionList->size() == 0) {
  65     theError = "Empty selection list.";
  66     return false;
  67   }
  68
  69   // Collect base shapes.
  70   for(int anIndex = 0; anIndex < aSelectionList->size(); ++anIndex) {
  71     AttributeSelectionPtr aSelection = aSelectionList->value(anIndex);
  72     if(!aSelection.get()) {
  73       theError = "Could not get selection.";
  74       return false;
  75     }
  76     ResultPtr aContext = aSelection->context();
  77     if(!aContext.get()) {
  78       theError = "Attribute have empty context.";
  79       return false;
  80     }
  81
  82     GeomShapePtr aShape = aSelection->value();
  83     GeomShapePtr aContextShape = aContext->shape();
  84     if(!aShape.get()) {
  85       aShape = aContextShape;
  86     }
  87     if(!aShape.get()) {
  88       theError = "Empty shape selected.";
  89       return false;
  90     }
  91
  92     // Check that shapes has acceptable type.
  93     GeomValidators_ShapeType aValidatorShapeType;
  94     if(!aValidatorShapeType.isValid(aSelection, theArguments, theError)) {
  95       return false;
  96     }
  97
  98     // Check that it is shape on sketch.
  99     ResultConstructionPtr aConstruction =
 100       std::dynamic_pointer_cast<ModelAPI_ResultConstruction>(aContext);
 101     if(aConstruction.get()) {
 102       if(aConstruction->isInfinite()) {
 103         theError = "Inifinte objects not acceptable.";
 104         return false;
 105       }
 106
 107       std::shared_ptr<GeomAPI_PlanarEdges> anEdges =
 108         std::dynamic_pointer_cast<GeomAPI_PlanarEdges>(aContextShape);
 109       if(anEdges.get()) {
 110         if(aShape->isEqual(aContextShape)) {
 111           // It is whole sketch.
 112           return false;
 113         }
 114
 115         continue;
 116       }
 117     }
 118   }
 119
 120   return true;
 121 }
 122
 123 //=================================================================================================
 124 bool BuildPlugin_ValidatorBaseForWire::isValid(const std::shared_ptr<ModelAPI_Feature>& theFeature,
 125                                                const std::list<std::string>& theArguments,
 126                                                Events_InfoMessage& theError) const
 127 {
 128   // Get attribute.
 129   if(theArguments.size() != 1) {
 130     std::string aMsg = "Error: BuildPlugin_ValidatorBaseForWire should be used only "
 131                        "with 1 parameter (ID of base objects list).";
 132     Events_InfoMessage("BuildPlugin_Validators", aMsg).send();
 133     return false;
 134   }
 135   AttributeSelectionListPtr aSelectionList = theFeature->selectionList(theArguments.front());
 136   if(!aSelectionList.get()) {
 137     theError = "Empty attribute \"%1\".";
 138     theError.arg(theArguments.front());
 139     return false;
 140   }
 141
 142
 143   // Collect base shapes.
 144   ListOfShape aListOfShapes;
 145   for(int anIndex = 0; anIndex < aSelectionList->size(); ++anIndex) {
 146     AttributeSelectionPtr aSelection = aSelectionList->value(anIndex);
 147     GeomShapePtr aShape = aSelection->value();
 148     if(!aShape.get()) {
 149       if (aSelection->context().get())
 150         aShape = aSelection->context()->shape();
 151     }
 152     if (aShape.get())
 153       aListOfShapes.push_back(aShape);
 154   }
 155
 156   // Create wire.
 157   GeomShapePtr aWire = GeomAlgoAPI_WireBuilder::wire(aListOfShapes);
 158   if(!aWire.get()) {
 159     theError = "Result wire empty. Probably it has disconnected edges or non-manifold.";
 160     return false;
 161   }
 162
 163   return true;
 164 }
 165
 166 //=================================================================================================
 167 bool BuildPlugin_ValidatorBaseForFace::isValid(const std::shared_ptr<ModelAPI_Feature>& theFeature,
 168                                                const std::list<std::string>& theArguments,
 169                                                Events_InfoMessage& theError) const
 170 {
 171   // Get attribute.
 172   if(theArguments.size() != 1) {
 173     std::string aMsg = "Error: BuildPlugin_ValidatorBaseForFace should be used only with "
 174       "1 parameter (ID of base objects list).";
 175     Events_InfoMessage("BuildPlugin_Validators", aMsg).send();
 176     return false;
 177   }
 178   AttributeSelectionListPtr aSelectionList = theFeature->selectionList(theArguments.front());
 179   if(!aSelectionList.get()) {
 180     theError = "Empty attribute \"%1\".";
 181     theError.arg(theArguments.front());
 182     return false;
 183   }
 184
 185   bool hasEdgesOrWires = false;
 186   bool hasFaces = false;
 187
 188   // Collect base shapes.
 189   ListOfShape anEdges;
 190   for(int anIndex = 0; anIndex < aSelectionList->size(); ++anIndex) {
 191     AttributeSelectionPtr aSelection = aSelectionList->value(anIndex);
 192     GeomShapePtr aShape = aSelection->value();
 193     if(!aShape.get()) {
 194       if (!aSelection->context()) {
 195         theError = "Objects are not selected.";
 196         return false;
 197       }
 198       aShape = aSelection->context()->shape();
 199     }
 200     if (aShape->shapeType() == GeomAPI_Shape::FACE) {
 201       // skip faces exploding
 202       hasFaces = true;
 203       continue;
 204     }
 205
 206     for(GeomAPI_ShapeExplorer anExp(aShape, GeomAPI_Shape::EDGE); anExp.more(); anExp.next()) {
 207       hasEdgesOrWires = true;
 208       GeomShapePtr anEdge = anExp.current();
 209       anEdges.push_back(anEdge);
 210     }
 211   }
 212
 213   if (hasFaces && hasEdgesOrWires) {
 214     theError = "Faces and edges/wires should be selected together.";
 215     return false;
 216   } else if (hasEdgesOrWires && anEdges.empty()) {
 217     theError = "Objects are not selected.";
 218     return false;
 219   }
 220
 221   // Check that edges does not have intersections.
 222   if(anEdges.size() > 1) {
 223     GeomAlgoAPI_PaveFiller aPaveFiller(anEdges, false);
 224     if(!aPaveFiller.isDone()) {
 225       theError = "Error while checking if edges intersects.";
 226       return false;
 227     }
 228     GeomShapePtr aSectedEdges = aPaveFiller.shape();
 229
 230     int anEdgesNum = 0;
 231     for(GeomAPI_ShapeExplorer
 232         anExp(aSectedEdges, GeomAPI_Shape::EDGE); anExp.more(); anExp.next()) {
 233       anEdgesNum++;
 234     }
 235     if(anEdgesNum != anEdges.size()) {
 236       theError = "Selected objects have intersections.";
 237       return false;
 238     }
 239   }
 240
 241   if (!anEdges.empty()) {
 242     // Check that they are planar.
 243     std::shared_ptr<GeomAPI_Pln> aPln = GeomAlgoAPI_ShapeTools::findPlane(anEdges);
 244     if(!aPln.get()) {
 245       theError = "Selected object(s) should belong to only one plane.";
 246       return false;
 247     }
 248
 249     // Check that selected objects have closed contours.
 250     ListOfShape aFaces;
 251     GeomAlgoAPI_SketchBuilder::createFaces(aPln->location(), aPln->xDirection(),
 252                                            aPln->direction(), anEdges, aFaces);
 253     if(aFaces.empty()) {
 254       theError = "Selected objects do not generate closed contour.";
 255       return false;
 256     }
 257   }
 258
 259   return true;
 260 }
 261
 262 //=================================================================================================
 263 bool BuildPlugin_ValidatorBaseForSolids::isValid(
 264   const std::shared_ptr<ModelAPI_Feature>& theFeature, const std::list<std::string>& theArguments,
 265   Events_InfoMessage& theError) const
 266 {
 267   // Get base objects list.
 268   AttributeSelectionListPtr aSelectionList = theFeature->selectionList(theArguments.front());
 269   if (!aSelectionList.get()) {
 270     theError = "Could not get selection list.";
 271     return false;
 272   }
 273   if (aSelectionList->size() == 0) {
 274     theError = "Empty selection list.";
 275     return false;
 276   }
 277
 278   // Collect base shapes.
 279   ListOfShape anOriginalShapes;
 280   for (int anIndex = 0; anIndex < aSelectionList->size(); ++anIndex) {
 281     AttributeSelectionPtr aSelection = aSelectionList->value(anIndex);
 282     if (!aSelection->context().get()) {
 283       theError = "Invalid selection.";
 284       return false;
 285     }
 286     GeomShapePtr aShape = aSelection->value();
 287     if (!aShape.get())
 288       aShape = aSelection->context()->shape();
 289     anOriginalShapes.push_back(aShape);
 290   }
 291
 292   std::shared_ptr<GeomAlgoAPI_MakeVolume> anAlgorithm(
 293     new GeomAlgoAPI_MakeVolume(anOriginalShapes, false));
 294
 295   if (!anAlgorithm->isDone()) {
 296     theError = "MakeVolume algorithm failed.";
 297     return false;
 298   }
 299   if (anAlgorithm->shape()->isNull()) {
 300     theError = "Resulting shape of MakeVolume is Null.";
 301     return false;
 302   }
 303   if (!anAlgorithm->isValid()) {
 304     theError = "Resulting shape of MakeVolume is not valid.";
 305     return false;
 306   }
 307
 308   // set of allowed types of results
 309   std::set<GeomAPI_Shape::ShapeType> aResultType;
 310   std::string aType = theArguments.back();
 311   if (aType == "solid")
 312     aResultType.insert(GeomAPI_Shape::SOLID);
 313   else if (aType == "compsolid") {
 314     aResultType.insert(GeomAPI_Shape::COMPSOLID);
 315     aResultType.insert(GeomAPI_Shape::SOLID);
 316   }
 317
 318   GeomShapePtr aCompound = anAlgorithm->shape();
 319   if (aCompound->shapeType() == GeomAPI_Shape::COMPOUND) {
 320     GeomAPI_ShapeIterator anIt(aCompound);
 321     GeomShapePtr aFoundSub;
 322     for (; anIt.more() && !aFoundSub; anIt.next()) {
 323       aFoundSub = anIt.current();
 324       if (aResultType.count(aFoundSub->shapeType()) == 0) {
 325         theError = "Unable to build a solid";
 326         return false;
 327       }
 328     }
 329     if (anIt.more() || !aFoundSub.get()) {
 330       theError = "Unable to build a solid";
 331       return false;
 332     }
 333   } else if (aResultType.count(aCompound->shapeType()) == 0) {
 334     theError = "Unable to build a solid";
 335     return false;
 336   }
 337   // check the internal faces presence
 338   for(GeomAPI_ShapeExplorer aFaces(aCompound, GeomAPI_Shape::FACE); aFaces.more(); aFaces.next()) {
 339     if (aFaces.current()->orientation() == GeomAPI_Shape::INTERNAL) {
 340       theError = "Internal faces are not allowed in the resulting solid";
 341       return false;
 342     }
 343   }
 344
 345   return true;
 346 }
 347
 348
 349 //=================================================================================================
 350 bool BuildPlugin_ValidatorSubShapesSelection::isValid(const AttributePtr& theAttribute,
 351                                                       const std::list<std::string>& theArguments,
 352                                                       Events_InfoMessage& theError) const
 353 {
 354   if(theArguments.size() != 1) {
 355     std::string aMsg = "Error: BuildPlugin_ValidatorSubShapesSelection should be used only with "
 356       "1 parameter(Sketch feature id).";
 357     Events_InfoMessage("BuildPlugin_Validators", aMsg).send();
 358     return false;
 359   }
 360
 361   // Get base objects list.
 362   if(theAttribute->attributeType() != ModelAPI_AttributeSelectionList::typeId()) {
 363     std::string aMsg =
 364       "Error: BuildPlugin_ValidatorSubShapesSelection does not support attribute type \""
 365       "%1\"\n Only \"%2\" supported.";
 366     Events_InfoMessage("BuildPlugin_Validators", aMsg).
 367       arg(theAttribute->attributeType()).arg(ModelAPI_AttributeSelectionList::typeId()).send();
 368     return false;
 369   }
 370   AttributeSelectionListPtr aSelectionList =
 371     std::dynamic_pointer_cast<ModelAPI_AttributeSelectionList>(theAttribute);
 372   if(!aSelectionList.get()) {
 373     theError = "Could not get selection list.";
 374     return false;
 375   }
 376
 377   // Get base shape.
 378   const std::string aBaseShapeId = "base_shape";
 379   FeaturePtr aFeature = ModelAPI_Feature::feature(theAttribute->owner());
 380   AttributeSelectionPtr aShapeAttrSelection = aFeature->selection(aBaseShapeId);
 381
 382   if(!aShapeAttrSelection.get()) {
 383     theError = "Base shape is empty.";
 384     return false;
 385   }
 386
 387   ResultPtr aBaseContext = aShapeAttrSelection->context();
 388
 389   GeomShapePtr aBaseShape  = aShapeAttrSelection->value();
 390   if(!aBaseShape.get()) {
 391     theError = "Base shape is empty.";
 392     return false;
 393   }
 394
 395   GeomAlgoAPI_ShapeBuilder aBuilder;
 396   aBuilder.removeInternal(aBaseShape);
 397   aBaseShape = aBuilder.shape();
 398
 399   // If selected shape is wire allow to select only vertices. If face - allow vertices and edges.
 400   std::set<GeomAPI_Shape::ShapeType> anAllowedTypes;
 401   switch(aBaseShape->shapeType()) {
 402     case GeomAPI_Shape::FACE: anAllowedTypes.insert(GeomAPI_Shape::EDGE);
 403     case GeomAPI_Shape::WIRE: anAllowedTypes.insert(GeomAPI_Shape::VERTEX);
 404     default: break;
 405   }
 406
 407   // Check selected shapes.
 408   GeomValidators_FeatureKind aFeatureKindValidator;
 409   std::list<std::string> anArguments;
 410   anArguments.push_back(theArguments.front());
 411   for(int anIndex = 0; anIndex < aSelectionList->size(); ++anIndex) {
 412     AttributeSelectionPtr aSelectionAttrInList = aSelectionList->value(anIndex);
 413     if(!aSelectionAttrInList.get()) {
 414       theError = "Empty attribute in list.";
 415       return false;
 416     }
 417
 418     // If context of selection same skip.
 419     if(aBaseContext == aSelectionAttrInList->context()) {
 420       continue;
 421     }
 422
 423     // Check that it is a selection on Sketch.
 424     if(!aFeatureKindValidator.isValid(aSelectionAttrInList, anArguments, theError)) {
 425       return false;
 426     }
 427
 428     // Check shape type.
 429     GeomShapePtr aShapeInList = aSelectionAttrInList->value();
 430     if(!aShapeInList.get()) {
 431       aShapeInList = aSelectionAttrInList->context()->shape();
 432     }
 433     if(anAllowedTypes.find(aShapeInList->shapeType()) == anAllowedTypes.cend()) {
 434       theError = "Selected shape has unacceptable type.";
 435       return false;
 436     }
 437
 438     // Check that shape inside wire or face.
 439     if(!GeomAlgoAPI_ShapeTools::isSubShapeInsideShape(aShapeInList, aBaseShape)) {
 440       theError = "Selected shape is not inside base face.";
 441       return false;
 442     }
 443   }
 444
 445   return true;
 446 }
 447
 448
 449 //=================================================================================================
 450 bool BuildPlugin_ValidatorFillingSelection::isValid(const AttributePtr& theAttribute,
 451                                                       const std::list<std::string>& theArguments,
 452                                                       Events_InfoMessage& theError) const
 453 {
 454   // Get base objects list.
 455   if (theAttribute->attributeType() != ModelAPI_AttributeSelectionList::typeId()) {
 456     std::string aMsg =
 457       "Error: BuildPlugin_ValidatorFillingSelection does not support attribute type \""
 458       "%1\"\n Only \"%2\" supported.";
 459     Events_InfoMessage("BuildPlugin_Validators", aMsg).
 460       arg(theAttribute->attributeType()).arg(ModelAPI_AttributeSelectionList::typeId()).send();
 461     return false;
 462   }
 463   AttributeSelectionListPtr aSelectionList =
 464     std::dynamic_pointer_cast<ModelAPI_AttributeSelectionList>(theAttribute);
 465   if (!aSelectionList.get()) {
 466     theError = "Could not get selection list.";
 467     return false;
 468   }
 469
 470   FeaturePtr anOwner = ModelAPI_Feature::feature(theAttribute->owner());
 471
 472   // Check selected shapes.
 473   for (int anIndex = 0; anIndex < aSelectionList->size(); ++anIndex) {
 474     AttributeSelectionPtr aSelectionAttrInList = aSelectionList->value(anIndex);
 475     if (!aSelectionAttrInList.get()) {
 476       theError = "Empty attribute in list.";
 477       return false;
 478     }
 479
 480     // Check shape exists.
 481     GeomShapePtr aShapeInList = aSelectionAttrInList->value();
 482     if (!aShapeInList.get()) {
 483       theError = "Object has no shape";
 484       return false;
 485     }
 486
 487     // Check shape type.
 488     GeomAPI_Shape::ShapeType aType = aShapeInList->shapeType();
 489     if (aType != GeomAPI_Shape::EDGE && aType != GeomAPI_Shape::WIRE) {
 490       theError = "Incorrect objects selected";
 491       return false;
 492     }
 493   }
 494
 495   return true;
 496 }