-// Copyright (C) 2014-20xx CEA/DEN, EDF R&D -->
-
-// File: ConstructionPlugin_Validators.cpp
-// Created: 04 July 2016
-// Author: Dmitry Bobylev
+// Copyright (C) 2014-2023 CEA, EDF
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
#include "ConstructionPlugin_Validators.h"
+#include <GeomAPI_Dir.h>
#include <GeomAPI_Edge.h>
#include <GeomAPI_Face.h>
#include <GeomAPI_Lin.h>
#include <GeomAPI_Pln.h>
#include <GeomAPI_Vertex.h>
+#include <GeomAPI_Pnt.h>
+#include <GeomAPI_ShapeIterator.h>
+#include <GeomAlgoAPI_ShapeTools.h>
#include <ModelAPI_AttributeSelection.h>
+#include <ModelAPI_AttributeBoolean.h>
#include <Events_InfoMessage.h>
+static std::shared_ptr<GeomAPI_Edge> getEdge(const GeomShapePtr theShape);
+static std::shared_ptr<GeomAPI_Face> getFace(const GeomShapePtr theShape);
static std::shared_ptr<GeomAPI_Lin> getLin(const GeomShapePtr theShape);
static std::shared_ptr<GeomAPI_Pln> getPln(const GeomShapePtr theShape);
static std::shared_ptr<GeomAPI_Pnt> getPnt(const GeomShapePtr theShape);
{
FeaturePtr aFeature = ModelAPI_Feature::feature(theAttribute->owner());
- AttributeSelectionPtr aLineAttribute1 = std::dynamic_pointer_cast<ModelAPI_AttributeSelection>(theAttribute);
+ AttributeSelectionPtr aLineAttribute1 =
+ std::dynamic_pointer_cast<ModelAPI_AttributeSelection>(theAttribute);
AttributeSelectionPtr aLineAttribute2 = aFeature->selection(theArguments.front());
GeomShapePtr aLineShape1 = aLineAttribute1->value();
ResultPtr aContext1 = aLineAttribute1->context();
if(!aContext1.get()) {
- theError = "One of the attribute not initialized.";
+ theError = "One of the attribute is not initialized.";
return false;
}
if(!aLineShape1.get()) {
std::shared_ptr<GeomAPI_Lin> aLine1 = aLineEdge1->line();
std::shared_ptr<GeomAPI_Lin> aLine2 = aLineEdge2->line();
+ if (!aLine1.get() || !aLine2.get()) {
+ theError = "Selected edge is not a line.";
+ return false;
+ }
+
if(!aLine1->isCoplanar(aLine2)) {
theError = "Selected lines not coplanar.";
return false;
}
//==================================================================================================
-bool ConstructionPlugin_ValidatorPointLineAndPlaneNotParallel::isValid(
+bool ConstructionPlugin_ValidatorPointEdgeAndPlaneNotParallel::isValid(
const AttributePtr& theAttribute,
const std::list<std::string>& theArguments,
Events_InfoMessage& theError) const
{
FeaturePtr aFeature = ModelAPI_Feature::feature(theAttribute->owner());
- AttributeSelectionPtr anAttribute1 = std::dynamic_pointer_cast<ModelAPI_AttributeSelection>(theAttribute);
+ AttributeSelectionPtr anAttribute1 =
+ std::dynamic_pointer_cast<ModelAPI_AttributeSelection>(theAttribute);
AttributeSelectionPtr anAttribute2 = aFeature->selection(theArguments.front());
- std::shared_ptr<GeomAPI_Lin> aLin;
- std::shared_ptr<GeomAPI_Pln> aPln;
+ std::shared_ptr<GeomAPI_Edge> anEdge;
+ std::shared_ptr<GeomAPI_Face> aFace;
GeomShapePtr aShape1 = anAttribute1->value();
ResultPtr aContext1 = anAttribute1->context();
if(!aContext1.get()) {
- theError = "One of the attribute not initialized.";
+ theError = "One of the attribute is not initialized.";
return false;
}
if(!aShape1.get()) {
aShape2 = aContext2->shape();
}
- aLin = getLin(aShape1);
- aPln = getPln(aShape2);
- if(!aLin.get() || !aPln.get()) {
- aLin = getLin(aShape2);
- aPln = getPln(aShape1);
+ anEdge = getEdge(aShape1);
+ aFace = getFace(aShape2);
+ if(!anEdge.get() || !aFace.get()) {
+ anEdge = getEdge(aShape2);
+ aFace = getFace(aShape1);
}
- if(!aLin.get() || !aPln.get()) {
+ if(!anEdge.get() || !aFace.get()) {
theError = "Wrong shape types selected.";
return false;
}
- if(aPln->isParallel(aLin)) {
- theError = "Plane and line are parallel.";
+ if(GeomAlgoAPI_ShapeTools::isParallel(anEdge, aFace)) {
+ theError = "Plane and edge are parallel.";
return false;
}
//==================================================================================================
bool ConstructionPlugin_ValidatorPlaneThreePoints::isValid(const AttributePtr& theAttribute,
- const std::list<std::string>& theArguments,
- Events_InfoMessage& theError) const
+ const std::list<std::string>& theArguments,
+ Events_InfoMessage& theError) const
{
FeaturePtr aFeature = ModelAPI_Feature::feature(theAttribute->owner());
- AttributeSelectionPtr aPointAttribute1 = std::dynamic_pointer_cast<ModelAPI_AttributeSelection>(theAttribute);
+ AttributeSelectionPtr aPointAttribute1 =
+ std::dynamic_pointer_cast<ModelAPI_AttributeSelection>(theAttribute);
AttributeSelectionPtr aPointAttribute2 = aFeature->selection(theArguments.front());
AttributeSelectionPtr aPointAttribute3 = aFeature->selection(theArguments.back());
GeomShapePtr aPointShape1 = aPointAttribute1->value();
ResultPtr aContext1 = aPointAttribute1->context();
if(!aContext1.get()) {
- theError = "One of the attribute not initialized.";
+ theError = "One of the attribute is not initialized.";
return false;
}
if(!aPointShape1.get()) {
std::shared_ptr<GeomAPI_Pnt> aPnt2 = aVertex2->point();
std::shared_ptr<GeomAPI_Pnt> aPnt3 = aVertex3->point();
+ if (aPnt1->isEqual(aPnt2)) {
+ theError = "Selected points are equal";
+ return false;
+ }
+
std::shared_ptr<GeomAPI_Lin> aLin(new GeomAPI_Lin(aPnt1, aPnt2));
if(aLin->contains(aPnt3)) {
{
FeaturePtr aFeature = ModelAPI_Feature::feature(theAttribute->owner());
- AttributeSelectionPtr anAttribute1 = std::dynamic_pointer_cast<ModelAPI_AttributeSelection>(theAttribute);
+ AttributeSelectionPtr anAttribute1 =
+ std::dynamic_pointer_cast<ModelAPI_AttributeSelection>(theAttribute);
AttributeSelectionPtr anAttribute2 = aFeature->selection(theArguments.front());
std::shared_ptr<GeomAPI_Lin> aLin;
GeomShapePtr aShape1 = anAttribute1->value();
ResultPtr aContext1 = anAttribute1->context();
if(!aContext1.get()) {
- theError = "One of the attribute not initialized.";
+ theError = "One of the attribute is not initialized.";
return false;
}
if(!aShape1.get()) {
return false;
}
- if(aLin->contains(aPnt)) {
- theError = "Point lies on the line.";
+ // line should not contain point only for not-prependicular case
+ AttributeBooleanPtr aBoolAttr = aFeature->boolean(theArguments.back());
+ if (aBoolAttr.get() && !aBoolAttr->value()) {
+ if(aLin->contains(aPnt)) {
+ theError = "Point lies on the line.";
+ return false;
+ }
+ }
+
+ return true;
+}
+
+//==================================================================================================
+bool ConstructionPlugin_ValidatorPlaneTwoParallelPlanes::isValid(
+ const AttributePtr& theAttribute,
+ const std::list<std::string>& theArguments,
+ Events_InfoMessage& theError) const
+{
+ FeaturePtr aFeature = ModelAPI_Feature::feature(theAttribute->owner());
+
+ AttributeSelectionPtr anAttribute1 =
+ std::dynamic_pointer_cast<ModelAPI_AttributeSelection>(theAttribute);
+ AttributeSelectionPtr anAttribute2 = aFeature->selection(theArguments.front());
+
+ std::shared_ptr<GeomAPI_Pln> aPln1;
+ std::shared_ptr<GeomAPI_Pln> aPln2;
+
+ GeomShapePtr aShape1 = anAttribute1->value();
+ ResultPtr aContext1 = anAttribute1->context();
+ if(!aContext1.get()) {
+ theError = "One of the attribute is not initialized.";
+ return false;
+ }
+ if(!aShape1.get()) {
+ aShape1 = aContext1->shape();
+ }
+
+ GeomShapePtr aShape2 = anAttribute2->value();
+ ResultPtr aContext2 = anAttribute2->context();
+ if(!aContext2.get()) {
+ return true;
+ }
+ if(!aShape2.get()) {
+ aShape2 = aContext2->shape();
+ }
+
+ aPln1 = getPln(aShape1);
+ aPln2 = getPln(aShape2);
+
+ if(!aPln1.get() || !aPln2.get()) {
+ theError = "Wrong shape types selected.";
+ return false;
+ }
+
+ std::shared_ptr<GeomAPI_Dir> aDir1 = aPln1->direction();
+ std::shared_ptr<GeomAPI_Dir> aDir2 = aPln2->direction();
+
+ if(!aDir1->isParallel(aDir2)) {
+ theError = "Planes not parallel.";
return false;
}
return true;
}
+//==================================================================================================
+bool ConstructionPlugin_ValidatorAxisTwoNotParallelPlanes::isValid(
+ const AttributePtr& theAttribute,
+ const std::list<std::string>& theArguments,
+ Events_InfoMessage& theError) const
+{
+ FeaturePtr aFeature = ModelAPI_Feature::feature(theAttribute->owner());
+
+ AttributeSelectionPtr anAttribute1 =
+ std::dynamic_pointer_cast<ModelAPI_AttributeSelection>(theAttribute);
+ AttributeSelectionPtr anAttribute2 = aFeature->selection(theArguments.front());
+
+ std::shared_ptr<GeomAPI_Pln> aPln1;
+ std::shared_ptr<GeomAPI_Pln> aPln2;
+
+ GeomShapePtr aShape1 = anAttribute1->value();
+ ResultPtr aContext1 = anAttribute1->context();
+ if(!aContext1.get()) {
+ theError = "One of the attribute is not initialized.";
+ return false;
+ }
+ if(!aShape1.get()) {
+ aShape1 = aContext1->shape();
+ }
+
+ GeomShapePtr aShape2 = anAttribute2->value();
+ ResultPtr aContext2 = anAttribute2->context();
+ if(!aContext2.get()) {
+ return true;
+ }
+ if(!aShape2.get()) {
+ aShape2 = aContext2->shape();
+ }
+
+ aPln1 = getPln(aShape1);
+ aPln2 = getPln(aShape2);
+
+ if(!aPln1.get() || !aPln2.get()) {
+ theError = "Wrong shape types selected.";
+ return false;
+ }
+
+ std::shared_ptr<GeomAPI_Dir> aDir1 = aPln1->direction();
+ std::shared_ptr<GeomAPI_Dir> aDir2 = aPln2->direction();
+
+ if(aDir1->isParallel(aDir2)) {
+ theError = "Planes are parallel.";
+ return false;
+ }
+
+ return true;
+}
+
+//==================================================================================================
+bool ConstructionPlugin_ValidatorPointThreeNonParallelPlanes::isValid(
+ const AttributePtr& theAttribute,
+ const std::list<std::string>& theArguments,
+ Events_InfoMessage& theError) const
+{
+ FeaturePtr aFeature = ModelAPI_Feature::feature(theAttribute->owner());
+
+ AttributeSelectionPtr anAttribute1 =
+ std::dynamic_pointer_cast<ModelAPI_AttributeSelection>(theAttribute);
+ AttributeSelectionPtr anAttribute2 = aFeature->selection(theArguments.front());
+ AttributeSelectionPtr anAttribute3 = aFeature->selection(theArguments.back());
+
+ GeomShapePtr aShape1 = anAttribute1->value();
+ ResultPtr aContext1 = anAttribute1->context();
+ if (!aContext1.get()) {
+ theError = "One of the attribute is not initialized.";
+ return false;
+ }
+ if (!aShape1.get()) {
+ aShape1 = aContext1->shape();
+ }
+
+ std::shared_ptr<GeomAPI_Pln> aPln1 = getPln(aShape1);
+ if (!aPln1.get()) {
+ theError = "Wrong shape types selected.";
+ return false;
+ }
+ std::shared_ptr<GeomAPI_Dir> aDir1 = aPln1->direction();
+
+ if (anAttribute2.get()) {
+ GeomShapePtr aShape2 = anAttribute2->value();
+ ResultPtr aContext2 = anAttribute2->context();
+ if (!aShape2.get() && aContext2.get()) {
+ aShape2 = aContext2->shape();
+ }
+
+ if (aShape2.get()) {
+ std::shared_ptr<GeomAPI_Pln> aPln2 = getPln(aShape2);
+ if (!aPln2.get()) {
+ theError = "Wrong shape types selected.";
+ return false;
+ }
+ std::shared_ptr<GeomAPI_Dir> aDir2 = aPln2->direction();
+ if (aDir1->isParallel(aDir2)) {
+ theError = "Planes are parallel.";
+ return false;
+ }
+ }
+ }
+
+ if (anAttribute3.get()) {
+ GeomShapePtr aShape3 = anAttribute3->value();
+ ResultPtr aContext3 = anAttribute3->context();
+ if (!aShape3.get() && aContext3.get()) {
+ aShape3 = aContext3->shape();
+ }
+
+ if (aShape3.get()) {
+ std::shared_ptr<GeomAPI_Pln> aPln3 = getPln(aShape3);
+ if (!aPln3.get()) {
+ theError = "Wrong shape types selected.";
+ return false;
+ }
+ std::shared_ptr<GeomAPI_Dir> aDir3 = aPln3->direction();
+ if (aDir1->isParallel(aDir3)) {
+ theError = "Planes are parallel.";
+ return false;
+ }
+ }
+ }
+
+ return true;
+}
+
+//==================================================================================================
+bool ConstructionPlugin_ValidatorNotFeature::isValid(
+ const AttributePtr& theAttribute,
+ const std::list<std::string>& /*theArguments*/,
+ Events_InfoMessage& theError) const
+{
+ AttributeSelectionPtr aSelAttr =
+ std::dynamic_pointer_cast<ModelAPI_AttributeSelection>(theAttribute);
+ if (!aSelAttr) {
+ theError = "Wrong attribute";
+ return false;
+ }
+
+ FeaturePtr aContextFeature = aSelAttr->contextFeature();
+ if (aContextFeature) {
+ theError = "Feature should not be selected";
+ return false;
+ }
+ return true;
+}
+
+//==================================================================================================
+
+std::shared_ptr<GeomAPI_Edge> getEdge(const GeomShapePtr theShape)
+{
+ GeomEdgePtr anEdge;
+
+ if(theShape->isEdge()) {
+ anEdge = theShape->edge();
+ }
+ else if (theShape->isCompound()) {
+ GeomAPI_ShapeIterator anIt(theShape);
+ anEdge = anIt.current()->edge();
+ }
+
+ return anEdge;
+}
+
+GeomFacePtr getFace(const GeomShapePtr theShape)
+{
+ GeomFacePtr aFace;
+
+ if (theShape->isFace()) {
+ aFace = theShape->face();
+ }
+ else if (theShape->isCompound()) {
+ GeomAPI_ShapeIterator anIt(theShape);
+ aFace = anIt.current()->face();
+ }
+
+ return aFace;
+}
+
std::shared_ptr<GeomAPI_Lin> getLin(const GeomShapePtr theShape)
{
std::shared_ptr<GeomAPI_Lin> aLin;
- if(!theShape->isEdge()) {
+ GeomEdgePtr anEdge;
+
+ if (theShape->isEdge()) {
+ anEdge = theShape->edge();
+ }
+ else if (theShape->isCompound()) {
+ GeomAPI_ShapeIterator anIt(theShape);
+ anEdge = anIt.current()->edge();
+ }
+ else {
return aLin;
}
- std::shared_ptr<GeomAPI_Edge> anEdge(new GeomAPI_Edge(theShape));
-
if(!anEdge->isLine()) {
return aLin;
}
{
std::shared_ptr<GeomAPI_Pln> aPln;
- if(!theShape->isFace()) {
+ GeomFacePtr aFace;
+
+ if(theShape->isFace()) {
+ aFace = theShape->face();
+ }
+ else if (theShape->isCompound()) {
+ GeomAPI_ShapeIterator anIt(theShape);
+ aFace = anIt.current()->face();
+ }
+ else {
return aPln;
}
- std::shared_ptr<GeomAPI_Face> aFace(new GeomAPI_Face(theShape));
-
- if(!aFace->isPlanar()) {
+ if(!aFace || !aFace->isPlanar()) {
return aPln;
}
