]> SALOME platform Git repositories - modules/shaper.git/blob - src/FeaturesPlugin/FeaturesPlugin_Validators.cpp
Salome HOME
Initial implementation of support of any level of hierarchy in Result Bodies.
[modules/shaper.git] / src / FeaturesPlugin / FeaturesPlugin_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 "FeaturesPlugin_Validators.h"
22
23 #include "FeaturesPlugin_Boolean.h"
24 #include "FeaturesPlugin_Union.h"
25
26 #include <Events_InfoMessage.h>
27
28 #include <ModelAPI_Attribute.h>
29 #include <ModelAPI_AttributeInteger.h>
30 #include <ModelAPI_AttributeSelectionList.h>
31 #include <ModelAPI_AttributeString.h>
32 #include <ModelAPI_AttributeReference.h>
33 #include <ModelAPI_AttributeRefList.h>
34 #include <ModelAPI_Feature.h>
35 #include <ModelAPI_ResultBody.h>
36 #include <ModelAPI_ResultConstruction.h>
37 #include <ModelAPI_Tools.h>
38
39 #include <GeomValidators_BodyShapes.h>
40 #include <GeomValidators_Face.h>
41 #include <GeomValidators_FeatureKind.h>
42 #include <GeomValidators_ShapeType.h>
43
44 #include <GeomAPI_DataMapOfShapeShape.h>
45 #include <GeomAPI_Lin.h>
46 #include <GeomAPI_PlanarEdges.h>
47 #include <GeomAPI_ShapeExplorer.h>
48 #include <GeomAPI_ShapeIterator.h>
49
50 #include <GeomAlgoAPI_CompoundBuilder.h>
51 #include <GeomAlgoAPI_ShapeBuilder.h>
52 #include <GeomAlgoAPI_ShapeTools.h>
53 #include <GeomAlgoAPI_WireBuilder.h>
54
55 #define _USE_MATH_DEFINES
56 #include <math.h>
57
58 //==================================================================================================
59 bool FeaturesPlugin_ValidatorPipePath::isValid(const AttributePtr& theAttribute,
60                                                const std::list<std::string>& theArguments,
61                                                Events_InfoMessage& theError) const
62 {
63   AttributeSelectionPtr aPathAttrSelection =
64     std::dynamic_pointer_cast<ModelAPI_AttributeSelection>(theAttribute);
65   if(!aPathAttrSelection.get()) {
66     theError = "Error: This validator can only work with path selector in \"Pipe\" feature.";
67     return false;
68   }
69
70   GeomShapePtr aPathShape = aPathAttrSelection->value();
71   ResultPtr aContext = aPathAttrSelection->context();
72   if(!aContext.get()) {
73     theError = "Error: Empty context.";
74     return false;
75   }
76   GeomShapePtr aContextShape = aContext->shape();
77   if(aPathShape.get() && aPathShape->shapeType() == GeomAPI_Shape::WIRE &&
78       !aPathShape->isEqual(aContextShape)) {
79     theError = "Error: Local selection of wires not allowed.";
80     return false;
81   }
82
83   return true;
84 }
85
86 //==================================================================================================
87 bool FeaturesPlugin_ValidatorPipeLocations::isValid(
88   const std::shared_ptr<ModelAPI_Feature>& theFeature,
89   const std::list<std::string>& theArguments,
90   Events_InfoMessage& theError) const
91 {
92   static const std::string aCreationMethodID = "creation_method";
93   static const std::string aBaseObjectsID = "base_objects";
94   static const std::string aLocationsID = "locations_objects";
95
96   if(theFeature->getKind() != "Pipe") {
97     theError = "Error: Feature \"%1\" does not supported by this validator.";
98     theError.arg(theFeature->getKind());
99     return false;
100   }
101
102   AttributeStringPtr aCreationMethodAttr = theFeature->string(aCreationMethodID);
103   if(!aCreationMethodAttr.get()) {
104     theError = "Error: Could not get \"%1\" attribute.";
105     theError.arg(aCreationMethodID);
106     return false;
107   }
108
109   if(aCreationMethodAttr->value() != "locations") {
110     return true;
111   }
112
113   AttributeSelectionListPtr aBaseObjectsSelectionList = theFeature->selectionList(aBaseObjectsID);
114   if(!aBaseObjectsSelectionList.get()) {
115     theError = "Error: Could not get \"%1\" attribute.";
116     theError.arg(aBaseObjectsID);
117     return false;
118   }
119
120   AttributeSelectionListPtr aLocationsSelectionList = theFeature->selectionList(aLocationsID);
121   if(!aLocationsSelectionList.get()) {
122     theError = "Error: Could not get \"%1\" attribute.";
123     theError.arg(aBaseObjectsID);
124     return false;
125   }
126
127   if(aLocationsSelectionList->size() > 0 &&
128      aLocationsSelectionList->size() != aBaseObjectsSelectionList->size()) {
129     theError = "Error: Number of locations should be the same as base objects.";
130     return false;
131   }
132
133   return true;
134 }
135
136 //==================================================================================================
137 bool FeaturesPlugin_ValidatorBaseForGeneration::isValid(const AttributePtr& theAttribute,
138                                                         const std::list<std::string>& theArguments,
139                                                         Events_InfoMessage& theError) const
140 {
141   if(theArguments.empty()) {
142     theError = "Error: Validator parameters is empty.";
143     return false;
144   }
145
146   // Checking attribute.
147   if(!isValidAttribute(theAttribute, theArguments, theError)) {
148     if(theError.empty()) {
149       theError = "Error: Attribute contains unacceptable shape.";
150     }
151     return false;
152   }
153
154   GeomAPI_DataMapOfShapeShape aSelectedWiresFromObjects;
155   std::string anAttributeType = theAttribute->attributeType();
156   if(anAttributeType == ModelAPI_AttributeSelectionList::typeId()) {
157     AttributeSelectionListPtr aListAttr =
158       std::dynamic_pointer_cast<ModelAPI_AttributeSelectionList>(theAttribute);
159     for(int anIndex = 0; anIndex < aListAttr->size(); ++anIndex) {
160       AttributeSelectionPtr aSelectionAttr = aListAttr->value(anIndex);
161       ResultPtr aContext = aSelectionAttr->context();
162       if(!aContext.get()) {
163         theError = "Error: Empty context.";
164         return false;
165       }
166
167       ResultConstructionPtr aResultConstruction =
168         std::dynamic_pointer_cast<ModelAPI_ResultConstruction>(aContext);
169       if(!aResultConstruction.get()) {
170         // It is not a result construction.
171         // If shape is compound check that it contains only faces and edges.
172         GeomShapePtr aShape = aSelectionAttr->value();
173         if(!aShape.get()) {
174           aShape = aContext->shape();
175         }
176
177         if(aShape->shapeType() == GeomAPI_Shape::COMPOUND) {
178           for(GeomAPI_ShapeIterator anIt(aShape); anIt.more(); anIt.next()) {
179             GeomShapePtr aSubShape = anIt.current();
180             if(aSubShape->shapeType() != GeomAPI_Shape::EDGE
181                 && aSubShape->shapeType() != GeomAPI_Shape::FACE) {
182               theError = "Error: Compound should contain only faces and edges.";
183               return false;
184             }
185           }
186         }
187
188         continue;
189       }
190
191       GeomShapePtr aShape = aSelectionAttr->value();
192       GeomShapePtr aContextShape = aResultConstruction->shape();
193       if(!aShape.get()) {
194         // Whole sketch selected.
195         continue;
196       } else {
197         // Object from sketch selected.
198         for(GeomAPI_ShapeExplorer anExp(aShape, GeomAPI_Shape::WIRE); anExp.more(); anExp.next()) {
199           GeomShapePtr aWire = anExp.current();
200           if(aWire->orientation() != GeomAPI_Shape::FORWARD) {
201             theError = "Error: Wire with wrong orientation selected.";
202             return false;
203           }
204
205           if(aSelectedWiresFromObjects.isBound(aWire)) {
206             theError =
207               "Error: Objects with such wire already selected. Don't allow to select this object.";
208             return false;
209           }
210
211           aSelectedWiresFromObjects.bind(aWire, aWire);
212         }
213       }
214     }
215   }
216
217   return true;
218 }
219
220 //==================================================================================================
221 bool FeaturesPlugin_ValidatorBaseForGenerationSketchOrSketchObjects::isValid(
222   const std::shared_ptr<ModelAPI_Feature>& theFeature,
223   const std::list<std::string>& theArguments,
224   Events_InfoMessage& theError) const
225 {
226   const std::string aBaseObjectsID = theArguments.front();
227
228   AttributeSelectionListPtr aListAttr = theFeature->selectionList(aBaseObjectsID);
229   if(!aListAttr.get()) {
230     theError = "Error: Could not get \"%1\" attribute.";
231     theError.arg(aBaseObjectsID);
232     return false;
233   }
234
235   std::set<ResultConstructionPtr> aSelectedSketches;
236   std::set<ResultConstructionPtr> aSelectedSketchesFromObjects;
237
238   for(int anIndex = 0; anIndex < aListAttr->size(); ++anIndex) {
239     AttributeSelectionPtr aSelectionAttr = aListAttr->value(anIndex);
240     ResultPtr aContext = aSelectionAttr->context();
241     if(!aContext.get()) {
242       theError = "Error: Empty context.";
243       return false;
244     }
245
246     ResultConstructionPtr aResultConstruction =
247       std::dynamic_pointer_cast<ModelAPI_ResultConstruction>(aContext);
248     if(!aResultConstruction.get()) {
249       // It is not a result construction.
250       continue;
251     }
252
253     GeomShapePtr aShape = aSelectionAttr->value();
254     GeomShapePtr aContextShape = aResultConstruction->shape();
255     if(!aShape.get()) {
256       // Whole sketch selected.
257       aSelectedSketches.insert(aResultConstruction);
258     } else {
259       // Object from sketch selected.
260       aSelectedSketchesFromObjects.insert(aResultConstruction);
261     }
262   }
263
264
265   for(std::set<ResultConstructionPtr>::const_iterator anIt = aSelectedSketches.cbegin();
266       anIt != aSelectedSketches.cend();
267       ++anIt) {
268     ResultConstructionPtr aResultConstruction = *anIt;
269     if(aSelectedSketchesFromObjects.find(aResultConstruction) !=
270         aSelectedSketchesFromObjects.cend()) {
271       theError = "Sketch and objects from it can not be selected at the same time.";
272       return false;
273     }
274   }
275
276   return true;
277 }
278
279 //==================================================================================================
280 bool FeaturesPlugin_ValidatorBaseForGeneration::isValidAttribute(const AttributePtr& theAttribute,
281                                                         const std::list<std::string>& theArguments,
282                                                         Events_InfoMessage& theError) const
283 {
284   if(!theAttribute.get()) {
285     theError = "Error: Empty attribute.";
286     return false;
287   }
288
289   std::string anAttributeType = theAttribute->attributeType();
290   if(anAttributeType == ModelAPI_AttributeSelectionList::typeId()) {
291     AttributeSelectionListPtr aListAttr =
292       std::dynamic_pointer_cast<ModelAPI_AttributeSelectionList>(theAttribute);
293     for(int anIndex = 0; anIndex < aListAttr->size(); ++anIndex) {
294       // If at least one attribute is invalid, the result is false.
295       if(!isValidAttribute(aListAttr->value(anIndex), theArguments, theError)) {
296         return false;
297       }
298     }
299   } else if(anAttributeType == ModelAPI_AttributeSelection::typeId()) {
300     // Getting context.
301     AttributeSelectionPtr anAttr =
302       std::dynamic_pointer_cast<ModelAPI_AttributeSelection>(theAttribute);
303     ResultPtr aContext = anAttr->context();
304     if(!aContext.get()) {
305       theError = "Error: Attribute have empty context.";
306       return false;
307     }
308
309     GeomShapePtr aShape = anAttr->value();
310     GeomShapePtr aContextShape = aContext->shape();
311     if(!aShape.get()) {
312       aShape = aContextShape;
313     }
314     if(!aShape.get()) {
315       theError = "Error: Empty shape selected";
316       return false;
317     }
318
319     ResultConstructionPtr aConstruction =
320       std::dynamic_pointer_cast<ModelAPI_ResultConstruction>(aContext);
321     if(aConstruction.get()) {
322       // Construciotn selected. Check that is is not infinite.
323       if(aConstruction->isInfinite()) {
324         theError = "Error: Infinite constructions is not allowed as base.";
325         return false;
326       }
327
328       if(aShape->isEqual(aContextShape)) {
329         // Whole construction selected. Check that it have faces.
330         if(aConstruction->facesNum() > 0) {
331           return true;
332         }
333       } else {
334         // Shape on construction selected. Check that it is a face or wire.
335         if(aShape->shapeType() == GeomAPI_Shape::WIRE ||
336            aShape->shapeType() == GeomAPI_Shape::FACE) {
337           return true;
338         }
339       }
340
341       return false;
342     }
343
344     if(!aShape->isEqual(aContextShape)) {
345       // Local selection on body does not allowed.
346       theError =
347         "Error: Selected shape is in the local selection. Only global selection is allowed.";
348       return false;
349     }
350
351     // Check that object is a shape with allowed type.
352     GeomValidators_ShapeType aShapeTypeValidator;
353     if(!aShapeTypeValidator.isValid(anAttr, theArguments, theError)) {
354       theError = "Error: Selected shape has unacceptable type. Acceptable types are: faces or "
355                  "wires on sketch, whole sketch(if it has at least one face), "
356                  "and whole objects with shape types: %1";
357       std::string anArgumentString;
358       for(auto anIt = theArguments.cbegin(); anIt != theArguments.cend(); ++anIt) {
359         if (!anArgumentString.empty())
360           anArgumentString += ", ";
361         anArgumentString += *anIt;
362       }
363       theError.arg(anArgumentString);
364       return false;
365     }
366
367   } else {
368     theError = "Error: Attribute \"%1\" does not supported by this validator.";
369     theError.arg(anAttributeType);
370     return false;
371   }
372
373   return true;
374 }
375
376 //==================================================================================================
377 bool FeaturesPlugin_ValidatorCompositeLauncher::isValid(const AttributePtr& theAttribute,
378                                                         const std::list<std::string>& theArguments,
379                                                         Events_InfoMessage& theError) const
380 {
381   if (theAttribute->attributeType() != ModelAPI_AttributeReference::typeId()) {
382     theError = "Error: The attribute with the %1 type is not processed";
383     theError.arg(theAttribute->attributeType());
384     return false;
385   }
386   if (theArguments.size() != 2) {
387     theError = "Error: Wrong parameters in XML definition for %1 type";
388     theError.arg(theAttribute->attributeType());
389     return false;
390   }
391   // first argument is for the base attribute, second - for skipping feature kind
392   std::list<std::string>::const_iterator anIt = theArguments.begin();
393   std::string aBaseAttributeId = *anIt;
394   FeaturePtr aFeature = ModelAPI_Feature::feature(theAttribute->owner());
395   AttributePtr aBaseAttribute = aFeature->attribute(aBaseAttributeId);
396   if (!aBaseAttribute.get()) {
397     theError = "Wrong parameters in XML definition for %1 type";
398     theError.arg(theAttribute->attributeType());
399     return false;
400   }
401   if (aBaseAttribute->isInitialized()) // when base list of composite feature is already filled,
402     // this validator is not necessary anymore
403     return true;
404
405   anIt++;
406   std::string aFeatureAttributeKind = *anIt;
407   GeomValidators_FeatureKind* aValidator = new GeomValidators_FeatureKind();
408   // check whether the selection is on the sketch
409   std::list<std::string> anArguments;
410   anArguments.push_back(aFeatureAttributeKind);
411
412   bool aFeatureKind = aValidator->isValid(theAttribute, theArguments, theError);
413   bool aPlanarFace = false;
414   // check if selection has Face selected
415   GeomValidators_ShapeType* aShapeType = new GeomValidators_ShapeType();
416   anArguments.clear();
417   anArguments.push_back("face");
418   aPlanarFace = aShapeType->isValid(theAttribute, anArguments, theError);
419
420   bool aValid = !aFeatureKind && aPlanarFace;
421   return aValid;
422 }
423
424 //==================================================================================================
425 bool FeaturesPlugin_ValidatorExtrusionDir::isValid(
426                                                const std::shared_ptr<ModelAPI_Feature>& theFeature,
427                                                const std::list<std::string>& theArguments,
428                                                Events_InfoMessage& theError) const
429 {
430   if(theArguments.size() != 2) {
431     theError = "Error: Validator should be used with 2 parameters for extrusion.";
432     return false;
433   }
434
435   std::list<std::string>::const_iterator
436     anArgsIt = theArguments.begin(), aLast = theArguments.end();
437
438   AttributePtr aCheckAttribute = theFeature->attribute(*anArgsIt);
439   ++anArgsIt;
440
441   GeomShapePtr aDirShape;
442   AttributeSelectionPtr aSelAttr = theFeature->selection(*anArgsIt);
443   if(aSelAttr.get()) {
444     aDirShape = aSelAttr->value();
445     if(!aDirShape.get()) {
446       ResultPtr aContext = aSelAttr->context();
447       if(aContext.get()) {
448         aDirShape = aContext->shape();
449       }
450     }
451   }
452
453   if(!aDirShape.get()) {
454     // Check that dir can be empty.
455     if(!isShapesCanBeEmpty(aCheckAttribute, theError)) {
456       theError = "Error: Base objects list contains vertex or edge, so attribute \"%1\" "
457                  "can not be used with default value. Select direction for extrusion.";
458       theError.arg(*anArgsIt);
459       return false;
460     } else {
461       return true;
462     }
463   }
464
465   std::shared_ptr<GeomAPI_Edge> aDirEdge(new GeomAPI_Edge(aDirShape));
466
467   // If faces selected check that direction not parallel with them.
468   AttributeSelectionListPtr aListAttr =
469     std::dynamic_pointer_cast<ModelAPI_AttributeSelectionList>(aCheckAttribute);
470   for(int anIndex = 0; anIndex < aListAttr->size(); ++anIndex) {
471     AttributeSelectionPtr anAttr = aListAttr->value(anIndex);
472     GeomShapePtr aShapeInList = anAttr->value();
473     if(!aShapeInList.get()) {
474       aShapeInList = anAttr->context()->shape();
475     }
476     bool isParallel = true;
477     if(aShapeInList->shapeType() == GeomAPI_Shape::FACE ||
478        aShapeInList->shapeType() == GeomAPI_Shape::SHELL) {
479       for(GeomAPI_ShapeExplorer
480           anExp(aShapeInList, GeomAPI_Shape::FACE); anExp.more(); anExp.next()) {
481         std::shared_ptr<GeomAPI_Face> aFace(new GeomAPI_Face(anExp.current()));
482         isParallel = GeomAlgoAPI_ShapeTools::isParallel(aDirEdge, aFace);
483         if(isParallel) {
484           break;
485         }
486       }
487     } else if(aShapeInList->shapeType() == GeomAPI_Shape::COMPOUND) {
488       std::shared_ptr<GeomAPI_PlanarEdges> aPlanarEdges =
489         std::dynamic_pointer_cast<GeomAPI_PlanarEdges>(aShapeInList);
490       if(aPlanarEdges.get()) {
491         std::shared_ptr<GeomAPI_Dir> aSketchDir = aPlanarEdges->norm();
492         if(aDirEdge->isLine()) {
493           std::shared_ptr<GeomAPI_Dir> aDir = aDirEdge->line()->direction();
494           isParallel = fabs(aSketchDir->angle(aDir) - M_PI / 2.0) < 10e-7;
495         } else {
496           isParallel = false;
497         }
498       } else {
499         isParallel = false;
500       }
501     } else {
502       isParallel = false;
503     }
504     if(isParallel) {
505       theError =
506         "Error: Direction is parallel to one of the selected face or face on selected shell.";
507       return false;
508     }
509   }
510
511   return true;
512 }
513
514 //==================================================================================================
515 bool FeaturesPlugin_ValidatorExtrusionDir::isShapesCanBeEmpty(const AttributePtr& theAttribute,
516                                                               Events_InfoMessage& theError) const
517 {
518   if(!theAttribute.get()) {
519     return true;
520   }
521
522   std::string anAttributeType = theAttribute->attributeType();
523   if(anAttributeType == ModelAPI_AttributeSelectionList::typeId()) {
524     AttributeSelectionListPtr aListAttr =
525       std::dynamic_pointer_cast<ModelAPI_AttributeSelectionList>(theAttribute);
526     for(int anIndex = 0; anIndex < aListAttr->size(); ++anIndex) {
527       // If at least one attribute is invalid, the result is false.
528       if(!isShapesCanBeEmpty(aListAttr->value(anIndex), theError)) {
529         return false;
530       }
531     }
532   } else if(anAttributeType == ModelAPI_AttributeSelection::typeId()) {
533     // Getting context.
534     AttributeSelectionPtr anAttr =
535       std::dynamic_pointer_cast<ModelAPI_AttributeSelection>(theAttribute);
536     ResultPtr aContext = anAttr->context();
537     if(!aContext.get()) {
538       return false;
539     }
540
541     GeomShapePtr aShape = anAttr->value();
542     GeomShapePtr aContextShape = aContext->shape();
543     if(!aShape.get()) {
544       aShape = aContextShape;
545     }
546     if(!aShape.get()) {
547       return false;
548     }
549
550     if(aShape->shapeType() == GeomAPI_Shape::VERTEX ||
551        aShape->shapeType() == GeomAPI_Shape::EDGE ||
552        !aShape->isPlanar()) {
553       return false;
554     }
555   } else {
556     return false;
557   }
558
559   return true;
560 }
561
562 //==================================================================================================
563 bool FeaturesPlugin_ValidatorBooleanSelection::isValid(const AttributePtr& theAttribute,
564                                                        const std::list<std::string>& theArguments,
565                                                        Events_InfoMessage& theError) const
566 {
567   AttributeSelectionListPtr anAttrSelectionList =
568     std::dynamic_pointer_cast<ModelAPI_AttributeSelectionList>(theAttribute);
569   if(!anAttrSelectionList.get()) {
570     theError =
571       "Error: This validator can only work with selection list attributes in \"Boolean\" feature.";
572     return false;
573   }
574   std::shared_ptr<FeaturesPlugin_Boolean> aFeature =
575     std::dynamic_pointer_cast<FeaturesPlugin_Boolean>(theAttribute->owner());
576   FeaturesPlugin_Boolean::OperationType anOperationType = aFeature->operationType();
577
578   for(int anIndex = 0; anIndex < anAttrSelectionList->size(); ++anIndex) {
579     AttributeSelectionPtr anAttrSelection = anAttrSelectionList->value(anIndex);
580     if(!anAttrSelection.get()) {
581       theError = "Error: Empty attribute selection.";
582       return false;
583     }
584     ResultPtr aContext = anAttrSelection->context();
585     if(!aContext.get()) {
586       theError = "Error: Empty selection context.";
587       return false;
588     }
589     ResultConstructionPtr aResultConstruction =
590       std::dynamic_pointer_cast<ModelAPI_ResultConstruction>(aContext);
591     if(aResultConstruction.get()) {
592       if (anOperationType != FeaturesPlugin_Boolean::BOOL_FILL
593           || theAttribute->id() != FeaturesPlugin_Boolean::TOOL_LIST_ID()) {
594         theError = "Error: Result construction not allowed for selection.";
595         return false;
596       }
597     }
598     std::shared_ptr<GeomAPI_Shape> aShape = anAttrSelection->value();
599     GeomShapePtr aContextShape = aContext->shape();
600     if(!aShape.get()) {
601       aShape = aContextShape;
602     }
603     if(!aShape.get()) {
604       theError = "Error: Empty shape.";
605       return false;
606     }
607     if(!aShape->isEqual(aContextShape)) {
608       theError = "Error: Local selection not allowed.";
609       return false;
610     }
611
612     GeomAPI_Shape::ShapeType aShapeType = aShape->shapeType();
613     std::set<GeomAPI_Shape::ShapeType> anAllowedTypes;
614     if(anOperationType == FeaturesPlugin_Boolean::BOOL_FUSE) {
615       anAllowedTypes.insert(GeomAPI_Shape::EDGE);
616       anAllowedTypes.insert(GeomAPI_Shape::FACE);
617       anAllowedTypes.insert(GeomAPI_Shape::SOLID);
618       anAllowedTypes.insert(GeomAPI_Shape::COMPSOLID);
619       anAllowedTypes.insert(GeomAPI_Shape::COMPOUND);
620     } else if (anOperationType == FeaturesPlugin_Boolean::BOOL_FILL) {
621       anAllowedTypes.insert(GeomAPI_Shape::VERTEX);
622       anAllowedTypes.insert(GeomAPI_Shape::EDGE);
623       anAllowedTypes.insert(GeomAPI_Shape::WIRE);
624       anAllowedTypes.insert(GeomAPI_Shape::FACE);
625       anAllowedTypes.insert(GeomAPI_Shape::SHELL);
626       anAllowedTypes.insert(GeomAPI_Shape::SOLID);
627       anAllowedTypes.insert(GeomAPI_Shape::COMPSOLID);
628       anAllowedTypes.insert(GeomAPI_Shape::COMPOUND);
629     } else {
630       anAllowedTypes.insert(GeomAPI_Shape::SOLID);
631       anAllowedTypes.insert(GeomAPI_Shape::COMPSOLID);
632       anAllowedTypes.insert(GeomAPI_Shape::COMPOUND);
633     }
634
635     if(anAllowedTypes.find(aShapeType) == anAllowedTypes.end()
636       || (aResultConstruction.get() && aShapeType != GeomAPI_Shape::FACE)) {
637       theError = "Error: Selected shape has the wrong type.";
638       return false;
639     }
640
641   }
642
643   return true;
644 }
645
646 //==================================================================================================
647 bool FeaturesPlugin_ValidatorFilletSelection::isValid(const AttributePtr& theAttribute,
648                                                       const std::list<std::string>& theArguments,
649                                                       Events_InfoMessage& theError) const
650 {
651   AttributeSelectionListPtr anAttrSelectionList =
652     std::dynamic_pointer_cast<ModelAPI_AttributeSelectionList>(theAttribute);
653   if(!anAttrSelectionList.get()) {
654     theError =
655       "Error: This validator can only work with selection list attributes in \"Fillet\" feature.";
656     return false;
657   }
658
659   FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(theAttribute->owner());
660   // Check all selected entities are sub-shapes of single solid
661   GeomShapePtr aBaseSolid;
662   for(int anIndex = 0; anIndex < anAttrSelectionList->size(); ++anIndex) {
663     AttributeSelectionPtr anAttrSelection = anAttrSelectionList->value(anIndex);
664     if(!anAttrSelection.get()) {
665       theError = "Error: Empty attribute selection.";
666       return false;
667     }
668     ResultPtr aContext = anAttrSelection->context();
669     if(!aContext.get()) {
670       theError = "Error: Empty selection context.";
671       return false;
672     }
673
674     ResultBodyPtr aContextOwner = ModelAPI_Tools::bodyOwner(aContext);
675     GeomShapePtr anOwner = aContextOwner.get() ? aContextOwner->shape() : aContext->shape();
676
677     if (anOwner->shapeType() != GeomAPI_Shape::SOLID &&
678         anOwner->shapeType() != GeomAPI_Shape::COMPSOLID) {
679       theError = "Error: Not all selected shapes are sub-shapes of solids";
680       return false;
681     }
682
683     if (!aBaseSolid)
684       aBaseSolid = anOwner;
685     else if (!aBaseSolid->isEqual(anOwner)) {
686       theError = "Error: Sub-shapes of different solids have been selected.";
687       return false;
688     }
689   }
690
691   return true;
692 }
693
694 //==================================================================================================
695 bool FeaturesPlugin_ValidatorPartitionSelection::isValid(const AttributePtr& theAttribute,
696                                                        const std::list<std::string>& theArguments,
697                                                        Events_InfoMessage& theError) const
698 {
699   AttributeSelectionListPtr anAttrSelectionList =
700     std::dynamic_pointer_cast<ModelAPI_AttributeSelectionList>(theAttribute);
701   if(!anAttrSelectionList.get()) {
702     theError = "Error: This validator can only work with selection list in \"Partition\" feature.";
703     return false;
704   }
705
706   for(int anIndex = 0; anIndex < anAttrSelectionList->size(); ++anIndex) {
707     AttributeSelectionPtr aSelectAttr = anAttrSelectionList->value(anIndex);
708
709     //GeomValidators_BodyShapes aBodyValidator;
710     //if(aBodyValidator.isValid(aSelectAttr, theArguments, theError)) {
711     //  continue;
712     //}
713
714     GeomValidators_FeatureKind aFeatureKindValidator;
715     if(aFeatureKindValidator.isValid(aSelectAttr, theArguments, theError)) {
716       continue;
717     }
718
719     ResultPtr aContext = aSelectAttr->context();
720     ResultConstructionPtr aResultConstruction =
721       std::dynamic_pointer_cast<ModelAPI_ResultConstruction>(aContext);
722     if(aResultConstruction.get()) {
723       theError = "Error: Only body shapes and construction planes are allowed for selection.";
724       return false;
725     }
726
727     ResultBodyPtr aResultBody = std::dynamic_pointer_cast<ModelAPI_ResultBody>(aContext);
728     if(aResultBody.get()) {
729       continue;
730     }
731
732     theError = "Error: Only body shapes and construction planes are allowed for selection.";
733     return false;
734   }
735
736   theError = "";
737   return true;
738 }
739
740 //==================================================================================================
741 bool FeaturesPlugin_ValidatorRemoveSubShapesSelection::isValid(const AttributePtr& theAttribute,
742                                                      const std::list<std::string>& theArguments,
743                                                      Events_InfoMessage& theError) const
744 {
745   AttributeSelectionListPtr aSubShapesAttrList =
746     std::dynamic_pointer_cast<ModelAPI_AttributeSelectionList>(theAttribute);
747   if(!aSubShapesAttrList.get()) {
748     theError =
749       "Error: This validator can only work with selection list in \"Remove Sub-Shapes\" feature.";
750     return false;
751   }
752
753   static const std::string aBaseShapeID = "base_shape";
754   FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(theAttribute->owner());
755   AttributeSelectionPtr aShapeAttrSelection = aFeature->selection(aBaseShapeID);
756
757   if(!aShapeAttrSelection.get()) {
758     theError = "Error: Could not get \"%1\" attribute.";
759     theError.arg(aBaseShapeID);
760     return false;
761   }
762
763   GeomShapePtr aBaseShape = aShapeAttrSelection->value();
764   ResultPtr aContext = aShapeAttrSelection->context();
765   if(!aContext.get()) {
766     theError = "Error: Empty context.";
767     return false;
768   }
769   if(!aBaseShape.get()) {
770     aBaseShape = aContext->shape();
771   }
772   if(!aBaseShape.get()) {
773     theError = "Error: Empty base shape.";
774     return false;
775   }
776
777   for(int anIndex = 0; anIndex < aSubShapesAttrList->size(); ++anIndex) {
778     bool isSameFound = false;
779     AttributeSelectionPtr anAttrSelectionInList = aSubShapesAttrList->value(anIndex);
780     GeomShapePtr aShapeToAdd = anAttrSelectionInList->value();
781     for(GeomAPI_ShapeIterator anIt(aBaseShape); anIt.more(); anIt.next()) {
782       if(anIt.current()->isEqual(aShapeToAdd)) {
783         isSameFound = true;
784         break;
785       }
786     }
787     if(!isSameFound) {
788       theError = "Error: Only sub-shapes of selected shape is allowed for selection.";
789       return false;
790     }
791   }
792
793   return true;
794 }
795
796 //==================================================================================================
797 bool FeaturesPlugin_ValidatorRemoveSubShapesResult::isValid(
798   const std::shared_ptr<ModelAPI_Feature>& theFeature,
799   const std::list<std::string>& theArguments,
800   Events_InfoMessage& theError) const
801 {
802   static const std::string aBaseShapeID = "base_shape";
803   static const std::string aSubShapesID = "subshapes_to_keep";
804
805   if(theFeature->getKind() != "Remove_SubShapes") {
806     theError = "Error: Feature \"%1\" does not supported by this validator.";
807     theError.arg(theFeature->getKind());
808     return false;
809   }
810
811   AttributeSelectionPtr aShapeAttrSelection = theFeature->selection(aBaseShapeID);
812   if(!aShapeAttrSelection.get()) {
813     theError = "Error: Could not get \"%1\" attribute.";
814     theError.arg(aBaseShapeID);
815     return false;
816   }
817
818   AttributeSelectionListPtr aSubShapesAttrList = theFeature->selectionList(aSubShapesID);
819   if(!aSubShapesAttrList.get()) {
820     theError = "Error: Could not get \"%1\" attribute.";
821     theError.arg(aSubShapesID);
822     return false;
823   }
824
825   // Copy base shape.
826   GeomShapePtr aBaseShape = aShapeAttrSelection->value();
827   if(!aBaseShape.get()) {
828     theError = "Error: Base shape is empty.";
829     return false;
830   }
831   GeomShapePtr aResultShape = aBaseShape->emptyCopied();
832
833   if (aSubShapesAttrList->size() == 0) {
834     theError = "Error: Resulting shape is not valid.";
835     return false;
836   }
837
838   // Copy sub-shapes from list to new shape.
839   for(int anIndex = 0; anIndex < aSubShapesAttrList->size(); ++anIndex) {
840     AttributeSelectionPtr anAttrSelectionInList = aSubShapesAttrList->value(anIndex);
841     GeomShapePtr aShapeToAdd = anAttrSelectionInList->value();
842     GeomAlgoAPI_ShapeBuilder::add(aResultShape, aShapeToAdd);
843   }
844
845   // Check new shape.
846   if(!GeomAlgoAPI_ShapeTools::isShapeValid(aResultShape)) {
847     theError = "Error: Resulting shape is not valid.";
848     return false;
849   }
850
851   return true;
852 }
853
854 //==================================================================================================
855 bool FeaturesPlugin_ValidatorUnionSelection::isValid(const AttributePtr& theAttribute,
856                                                      const std::list<std::string>& theArguments,
857                                                      Events_InfoMessage& theError) const
858 {
859   AttributeSelectionListPtr aBaseObjectsAttrList =
860     std::dynamic_pointer_cast<ModelAPI_AttributeSelectionList>(theAttribute);
861   if(!aBaseObjectsAttrList.get()) {
862     theError = "Error: This validator can only work with selection list in \"%1\" feature.";
863     theError.arg(FeaturesPlugin_Union::ID());
864     return false;
865   }
866
867   for(int anIndex = 0; anIndex < aBaseObjectsAttrList->size(); ++anIndex) {
868     bool isSameFound = false;
869     AttributeSelectionPtr anAttrSelectionInList = aBaseObjectsAttrList->value(anIndex);
870     ResultPtr aContext = anAttrSelectionInList->context();
871     if (!aContext.get()) {
872       theError = "Error: selection is invalid.";
873       return false;
874     }
875
876     ResultConstructionPtr aConstruction =
877       std::dynamic_pointer_cast<ModelAPI_ResultConstruction>(aContext);
878     if(aConstruction.get()) {
879       theError = "Error: Result construction not allowed for selection.";
880       return false;
881     }
882
883     GeomShapePtr aShape = anAttrSelectionInList->value();
884     GeomShapePtr aContextShape = aContext->shape();
885     if (aShape.get() && aContextShape.get() && !aContextShape->isEqual(aShape)) {
886       theError = "Error: Local selection not allowed.";
887       return false;
888     }
889
890     ResultBodyPtr aResult =
891       std::dynamic_pointer_cast<ModelAPI_ResultBody>(aContext);
892     if(!aResult.get()) {
893       continue;
894     }
895
896     if(aResult->numberOfSubs() > 0) {
897       theError = "Error: Whole compsolids not allowed for selection.";
898       return false;
899     }
900   }
901
902   return true;
903 }
904
905 //==================================================================================================
906 bool FeaturesPlugin_ValidatorUnionArguments::isValid(
907   const std::shared_ptr<ModelAPI_Feature>& theFeature,
908   const std::list<std::string>& theArguments,
909   Events_InfoMessage& theError) const
910 {
911   // Check feature kind.
912   if(theFeature->getKind() != FeaturesPlugin_Union::ID()) {
913     theError = "Error: This validator supports only \"%1\" feature.";
914     theError.arg(FeaturesPlugin_Union::ID());
915     return false;
916   }
917
918   // Get base objects attribute list.
919   AttributeSelectionListPtr aBaseObejctsAttrList =
920     theFeature->selectionList(FeaturesPlugin_Union::BASE_OBJECTS_ID());
921   if(!aBaseObejctsAttrList.get()) {
922     theError = "Error: Could not get \"%1\" attribute.";
923     theError.arg(FeaturesPlugin_Union::BASE_OBJECTS_ID());
924     return false;
925   }
926
927   // Get all shapes.
928   GeomAPI_Shape::ShapeType aType = GeomAPI_Shape::COMPSOLID;
929   ListOfShape aBaseShapesList;
930   for(int anIndex = 0; anIndex < aBaseObejctsAttrList->size(); ++anIndex) {
931     AttributeSelectionPtr anAttrSelectionInList = aBaseObejctsAttrList->value(anIndex);
932     GeomShapePtr aShape = anAttrSelectionInList->value();
933     if (!aShape.get()) {
934       continue;
935     }
936     aBaseShapesList.push_back(aShape);
937     aType = aShape->shapeType() == GeomAPI_Shape::FACE ? GeomAPI_Shape::SHELL :
938                                                          GeomAPI_Shape::COMPSOLID;
939   }
940
941   // Make compound and find connected.
942   GeomShapePtr aCompound = GeomAlgoAPI_CompoundBuilder::compound(aBaseShapesList);
943   ListOfShape aCombined, aFree;
944   GeomAlgoAPI_ShapeTools::combineShapes(
945     aCompound,
946     aType,
947     aCombined,
948     aFree);
949
950   if(aFree.size() > 0 || aCombined.size() > 1) {
951     theError = "Error: Not all shapes have shared topology.";
952     return false;
953   }
954
955   return true;
956 }
957
958 bool FeaturesPlugin_ValidatorConcealedResult::isValid(const AttributePtr& theAttribute,
959                                             const std::list<std::string>& theArguments,
960                                             Events_InfoMessage& theError) const
961 {
962   if (theAttribute->attributeType() != ModelAPI_AttributeReference::typeId()) {
963     theError = "Error: The attribute with the %1 type is not processed";
964     theError.arg(theAttribute->attributeType());
965     return false;
966   }
967
968   AttributeReferencePtr aRefAttribute = std::dynamic_pointer_cast<ModelAPI_AttributeReference>
969                                                                                (theAttribute);
970   ObjectPtr aRefObject = aRefAttribute->value();
971   if (!aRefObject.get()) {
972     theError = "Error: Empty feature.";
973     return false;
974   }
975
976   FeaturePtr aRefFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(aRefObject);
977   if (!aRefFeature.get()) {
978     theError = "Error: Empty feature.";
979     return false;
980   }
981   std::list<std::shared_ptr<ModelAPI_Result> > aResults;
982   ModelAPI_Tools::getConcealedResults(aRefFeature, aResults);
983
984   size_t aConcealedResults = aResults.size();
985   if (!aConcealedResults && !theArguments.empty()) {
986     // find if these results are touched by the feature in another attribute
987     std::list<std::string>::const_iterator anIt = theArguments.begin();
988     std::string aRecoveredList = *anIt;
989     if (!aRecoveredList.empty()) {
990       std::shared_ptr<ModelAPI_AttributeRefList> aParameterList =
991                                  theAttribute->owner()->data()->reflist(aRecoveredList);
992       if (aParameterList.get())
993         aConcealedResults = aParameterList->size();
994     }
995   }
996
997   if (aConcealedResults == 0)
998     theError = "Error: No concealed results.";
999
1000   return theError.empty();
1001 }
1002
1003 bool FeaturesPlugin_ValidatorCircular::isValid(const AttributePtr& theAttribute,
1004                                                const std::list<std::string>& theArguments,
1005                                                Events_InfoMessage& theError) const
1006 {
1007   static std::list<std::string> aEdgeArg(1, "circle");
1008   static std::list<std::string> aFaceArg(1, "cylinder");
1009
1010   Events_InfoMessage aError;
1011   bool isValid = GeomValidators_ShapeType().isValid(theAttribute, aEdgeArg, aError);
1012   if (!isValid) {
1013     isValid = GeomValidators_Face().isValid(theAttribute, aFaceArg, aError);
1014     if (!isValid)
1015       theError = "The shape neither circle nor cylinder";
1016   }
1017   return isValid;
1018 }
1019
1020 //=================================================================================================
1021 bool FeaturesPlugin_ValidatorBooleanArguments::isValid(
1022   const std::shared_ptr<ModelAPI_Feature>& theFeature,
1023   const std::list<std::string>& theArguments,
1024   Events_InfoMessage& theError) const
1025 {
1026   if (theArguments.size() != 2)
1027   {
1028     theError = "Wrong number of arguments (expected 2).";
1029     return false;
1030   }
1031
1032   int anObjectsNb = 0, aToolsNb = 0;
1033   //int anOperationType = 0;
1034
1035   std::list<std::string>::const_iterator anIt = theArguments.begin(), aLast = theArguments.end();
1036
1037   bool isAllInSameCompSolid = true;
1038   ResultBodyPtr aCompSolid;
1039
1040   AttributeSelectionListPtr anAttrSelList = theFeature->selectionList(*anIt);
1041   if (anAttrSelList)
1042   {
1043     anObjectsNb = anAttrSelList->size();
1044     for (int anIndex = 0; anIndex < anObjectsNb; ++anIndex)
1045     {
1046       AttributeSelectionPtr anAttr = anAttrSelList->value(anIndex);
1047       ResultPtr aContext = anAttr->context();
1048       ResultBodyPtr aResCompSolidPtr = ModelAPI_Tools::bodyOwner(aContext);
1049       if (aResCompSolidPtr.get())
1050       {
1051         if (aCompSolid.get())
1052         {
1053           isAllInSameCompSolid = aCompSolid == aResCompSolidPtr;
1054         }
1055         else
1056         {
1057           aCompSolid = aResCompSolidPtr;
1058         }
1059       }
1060       else
1061       {
1062         isAllInSameCompSolid = false;
1063         break;
1064       }
1065     }
1066   }
1067   anIt++;
1068
1069
1070   anAttrSelList = theFeature->selectionList(*anIt);
1071   if (anAttrSelList)
1072   {
1073     aToolsNb = anAttrSelList->size();
1074     if (isAllInSameCompSolid)
1075     {
1076       for (int anIndex = 0; anIndex < aToolsNb; ++anIndex)
1077       {
1078         AttributeSelectionPtr anAttr = anAttrSelList->value(anIndex);
1079         ResultPtr aContext = anAttr->context();
1080         ResultBodyPtr aResCompSolidPtr = ModelAPI_Tools::bodyOwner(aContext);
1081         if (aResCompSolidPtr.get())
1082         {
1083           if (aCompSolid.get())
1084           {
1085             isAllInSameCompSolid = aCompSolid == aResCompSolidPtr;
1086           }
1087           else
1088           {
1089             aCompSolid = aResCompSolidPtr;
1090           }
1091         }
1092         else
1093         {
1094           isAllInSameCompSolid = false;
1095           break;
1096         }
1097       }
1098     }
1099   }
1100   anIt++;
1101
1102   std::shared_ptr<FeaturesPlugin_Boolean> aFeature =
1103     std::dynamic_pointer_cast<FeaturesPlugin_Boolean>(theFeature);
1104   FeaturesPlugin_Boolean::OperationType anOperationType = aFeature->operationType();
1105
1106   if (anOperationType == FeaturesPlugin_Boolean::BOOL_FUSE)
1107   {
1108     // Fuse operation
1109     if (anObjectsNb + aToolsNb < 2)
1110     {
1111       theError = "Not enough arguments for Fuse operation.";
1112       return false;
1113     }
1114     else if (isAllInSameCompSolid)
1115     {
1116       theError = "Operations only between sub-shapes of the same shape not allowed.";
1117       return false;
1118     }
1119   }
1120   else
1121   {
1122     if (anObjectsNb < 1)
1123     {
1124       theError = "Objects not selected.";
1125       return false;
1126     }
1127     if (aToolsNb < 1)
1128     {
1129       theError = "Tools not selected.";
1130       return false;
1131     }
1132     if (isAllInSameCompSolid)
1133     {
1134       theError = "Operations only between sub-shapes of the same shape not allowed.";
1135       return false;
1136     }
1137   }
1138
1139   return true;
1140 }
1141
1142 //=================================================================================================
1143 bool FeaturesPlugin_ValidatorBooleanArguments::isNotObligatory(std::string theFeature,
1144                                                                std::string theAttribute)
1145 {
1146   if (theAttribute == "main_objects" || theAttribute == "tool_objects")
1147   {
1148     return true;
1149   }
1150
1151   return false;
1152 }