-// Copyright (C) 2014-2019 CEA/DEN, EDF R&D
+// Copyright (C) 2014-2020 CEA/DEN, EDF R&D
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
#include "SketchPlugin_Validators.h"
#include "SketchPlugin_Arc.h"
+#include "SketchPlugin_BSpline.h"
+#include "SketchPlugin_BSplinePeriodic.h"
#include "SketchPlugin_Circle.h"
#include "SketchPlugin_ConstraintCoincidence.h"
+#include "SketchPlugin_ConstraintCoincidenceInternal.h"
#include "SketchPlugin_ConstraintDistance.h"
#include "SketchPlugin_ConstraintRigid.h"
#include "SketchPlugin_ConstraintTangent.h"
#include <algorithm>
#include <cmath>
+#ifdef _MSC_VER
+#pragma warning(disable: 4100)
+#endif
+
const double tolerance = 1.e-7;
+static bool isSpline(FeaturePtr theFeature)
+{
+ return theFeature && (theFeature->getKind() == SketchPlugin_BSpline::ID() ||
+ theFeature->getKind() == SketchPlugin_BSplinePeriodic::ID());
+}
+
+
bool SketchPlugin_DistanceAttrValidator::isValid(const AttributePtr& theAttribute,
const std::list<std::string>& theArguments,
Events_InfoMessage& theError) const
// there is a check whether the feature contains a point and a linear edge or two point values
std::string aParamA = theArguments.front();
- SessionPtr aMgr = ModelAPI_Session::get();
- ModelAPI_ValidatorsFactory* aFactory = aMgr->validators();
FeaturePtr anAttributeFeature =
std::dynamic_pointer_cast<ModelAPI_Feature>(theAttribute->owner());
bool isObject = aRefAttr->isObject();
ObjectPtr anObject = aRefAttr->object();
- if (isObject && anObject.get()) {
- FeaturePtr aRefFea = ModelAPI_Feature::feature(anObject);
+ if (!isObject || !anObject.get()) {
+ theError = "It uses an empty object";
+ return false;
+ }
- AttributeRefAttrPtr aOtherAttr = anAttributeFeature->data()->refattr(aParamA);
- ObjectPtr aOtherObject = aOtherAttr->object();
- FeaturePtr aOtherFea = ModelAPI_Feature::feature(aOtherObject);
- if (!aOtherFea)
- return true;
+ FeaturePtr aRefFea = ModelAPI_Feature::feature(anObject);
- if (aRefFea->getKind() == SketchPlugin_Line::ID() &&
- aOtherFea->getKind() == SketchPlugin_Line::ID()) {
- theError = "Two segments cannot be tangent";
- return false;
- }
+ AttributeRefAttrPtr aOtherAttr = anAttributeFeature->data()->refattr(aParamA);
+ ObjectPtr aOtherObject = aOtherAttr->object();
+ FeaturePtr aOtherFea = ModelAPI_Feature::feature(aOtherObject);
+ if (!aOtherFea)
return true;
+
+ if (aRefFea->getKind() == SketchPlugin_Line::ID() &&
+ aOtherFea->getKind() == SketchPlugin_Line::ID()) {
+ theError = "Two segments cannot be tangent";
+ return false;
}
- else {
- theError = "It uses an empty object";
+ else if (isSpline(aRefFea) && isSpline(aOtherFea)) {
+ theError = "Two B-splines cannot be tangent";
return false;
}
- return true;
+ bool isValid = true;
+ bool hasSpline = isSpline(aRefFea);
+ if (!hasSpline && isSpline(aOtherFea)) {
+ hasSpline = true;
+ std::swap(aRefFea, aOtherFea);
+ }
+ if (hasSpline) {
+ auto isApplicableCoincidence = [](FeaturePtr theFeature, const std::string& theAttrName) {
+ AttributeRefAttrPtr aRefAttr = theFeature->refattr(theAttrName);
+ if (aRefAttr->isObject())
+ return false;
+ AttributePtr anAttr = aRefAttr->attr();
+ FeaturePtr anOwner = ModelAPI_Feature::feature(anAttr->owner());
+ AttributePoint2DPtr aPointAttr = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(anAttr);
+ if (aPointAttr) {
+ return anOwner->getKind() == SketchPlugin_BSpline::ID() &&
+ (aPointAttr->id() == SketchPlugin_BSpline::START_ID() ||
+ aPointAttr->id() == SketchPlugin_BSpline::END_ID());
+ }
+
+ AttributePoint2DArrayPtr aPntArray =
+ std::dynamic_pointer_cast<GeomDataAPI_Point2DArray>(anAttr);
+ if (aPntArray && anOwner->getKind() == SketchPlugin_BSpline::ID()) {
+ // check index of the pole
+ AttributeIntegerPtr anIndex = theAttrName == SketchPlugin_Constraint::ENTITY_A() ?
+ theFeature->integer(SketchPlugin_ConstraintCoincidenceInternal::INDEX_ENTITY_A()) :
+ theFeature->integer(SketchPlugin_ConstraintCoincidenceInternal::INDEX_ENTITY_B());
+ return anIndex && (anIndex->value() == 0 || anIndex->value() == aPntArray->size() - 1);
+ }
+ return false;
+ };
+
+ isValid = false;
+ AttributePoint2DArrayPtr aBSplinePoles = std::dynamic_pointer_cast<GeomDataAPI_Point2DArray>(
+ aRefFea->attribute(SketchPlugin_BSplineBase::POLES_ID()));
+ // additional check the B-spline edge and the other edge have a coincident boundary point
+ std::set<FeaturePtr> aCoincidences = SketchPlugin_Tools::findCoincidentConstraints(aRefFea);
+ for (std::set<FeaturePtr>::iterator anIt = aCoincidences.begin();
+ anIt != aCoincidences.end() && !isValid; ++anIt) {
+ std::set<FeaturePtr> aCoinc;
+ if (isApplicableCoincidence(*anIt, SketchPlugin_Constraint::ENTITY_A()))
+ SketchPlugin_Tools::findCoincidences(*anIt, SketchPlugin_Constraint::ENTITY_B(),
+ aCoinc, true);
+ else if (isApplicableCoincidence(*anIt, SketchPlugin_Constraint::ENTITY_B()))
+ SketchPlugin_Tools::findCoincidences(*anIt, SketchPlugin_Constraint::ENTITY_A(),
+ aCoinc, true);
+
+ std::set<FeaturePtr>::iterator aFoundCoinc = aCoinc.find(aOtherFea);
+ if (aFoundCoinc != aCoinc.end()) {
+ // do not take into account internal constraints
+ AttributeReferencePtr aParent =
+ (*aFoundCoinc)->reference(SketchPlugin_SketchEntity::PARENT_ID());
+ isValid = !aParent || !aParent->isInitialized() || aParent->value() != aRefFea;
+ }
+ }
+ }
+
+ return isValid;
}
bool SketchPlugin_PerpendicularAttrValidator::isValid(const AttributePtr& theAttribute,
}
std::string aParamA = theArguments.front();
- SessionPtr aMgr = ModelAPI_Session::get();
- ModelAPI_ValidatorsFactory* aFactory = aMgr->validators();
FeaturePtr anOwner = std::dynamic_pointer_cast<ModelAPI_Feature>(theAttribute->owner());
AttributeRefAttrPtr aRefAttr =
AttributeRefAttrPtr aOtherAttr = anOwner->refattr(aParamA);
ObjectPtr aOtherObject = aOtherAttr->object();
FeaturePtr aOtherFea = ModelAPI_Feature::feature(aOtherObject);
- if (!aOtherFea)
- return true;
// at least one feature should be a line
if (aRefFea->getKind() != SketchPlugin_Line::ID() &&
- aOtherFea->getKind() != SketchPlugin_Line::ID()) {
+ aOtherFea && aOtherFea->getKind() != SketchPlugin_Line::ID()) {
theError = "At least one feature should be a line";
return false;
}
+ else if (isSpline(aRefFea) || isSpline(aOtherFea)) {
+ theError = "B-spline is not supported";
+ return false;
+ }
}
else {
theError = "It uses an empty object";
std::string aType[2];
std::list<std::string> anArguments;
for (int i = 0; i < 2; i++) {
- ObjectPtr anObject = aRefAttr[i]->object();
- if (!anObject.get()) {
- theError = "An empty object is used.";
- return false;
- }
-
- aFeature = ModelAPI_Feature::feature(anObject);
- if (!aFeature.get()) {
- theError = "An empty feature is used.";
- return false;
- }
+ aFeature = ModelAPI_Feature::feature(aRefAttr[i]->object());
+ if (!aFeature.get())
+ return true;
aType[i] = aFeature->getKind();
if (aFeature->getKind() != SketchPlugin_Line::ID() &&
for(int anInd = 0; anInd < aSelAttr->size(); anInd++) {
ObjectPtr aSelObject = aSelAttr->object(anInd);
+
+ // B-splines are not supported in Mirror yet
+ FeaturePtr aSelFeature = ModelAPI_Feature::feature(aSelObject);
+ if (aSelFeature && (aSelFeature->getKind() == SketchPlugin_BSpline::ID() ||
+ aSelFeature->getKind() == SketchPlugin_BSplinePeriodic::ID())) {
+ theError = "Not supported";
+ return false;
+ }
+
std::string aName = aSelObject.get() ? aSelObject->data()->name() : "";
std::list<ObjectPtr>::iterator aMirIter = aMirroredObjects.begin();
for (; aMirIter != aMirroredObjects.end(); aMirIter++)
// there is a check whether the feature contains a point and a linear edge or two point values
std::string aParamA = theArguments.front();
- SessionPtr aMgr = ModelAPI_Session::get();
- ModelAPI_ValidatorsFactory* aFactory = aMgr->validators();
FeaturePtr aConstraint = std::dynamic_pointer_cast<ModelAPI_Feature>(theAttribute->owner());
AttributeRefAttrPtr aRefAttrA = aConstraint->data()->refattr(aParamA);
break;
if (anObjIter != anInitialObjects.end())
continue;
+
+ // B-splines are not supported in Copying features
+ FeaturePtr aSelFeature = ModelAPI_Feature::feature(aSelObject);
+ if (aSelFeature && (aSelFeature->getKind() == SketchPlugin_BSpline::ID() ||
+ aSelFeature->getKind() == SketchPlugin_BSplinePeriodic::ID())) {
+ theError = "Not supported";
+ return false;
+ }
+
anObjIter = aCopiedObjects.begin();
for (; anObjIter != aCopiedObjects.end(); anObjIter++)
if (aSelObject == *anObjIter) {
// there is a check whether the feature contains a point and a linear edge or two point values
std::string aParamA = theArguments.front();
- SessionPtr aMgr = ModelAPI_Session::get();
- ModelAPI_ValidatorsFactory* aFactory = aMgr->validators();
FeaturePtr anAttributeFeature =
std::dynamic_pointer_cast<ModelAPI_Feature>(theAttribute->owner());
if (!anAttrFeature)
return aValid;
+ // B-splines are not supported by the Split yet
+ if (anAttrFeature->getKind() == SketchPlugin_BSpline::ID() ||
+ anAttrFeature->getKind() == SketchPlugin_BSplinePeriodic::ID()) {
+ theError = "Not supported";
+ return false;
+ }
+
std::set<ResultPtr> anEdgeShapes;
ModelGeomAlgo_Shape::shapesOfType(anAttrFeature, GeomAPI_Shape::EDGE, anEdgeShapes);
if (anEdgeShapes.empty() || anEdgeShapes.size() > 1 /*there case has not existed yet*/)
if (!aSketchFeature.get() || aSketchFeature->isCopy())
return aValid;
+ // B-splines are not supported by the Trim yet
+ if (aBaseFeature->getKind() == SketchPlugin_BSpline::ID() ||
+ aBaseFeature->getKind() == SketchPlugin_BSplinePeriodic::ID()) {
+ theError = "Not supported";
+ return false;
+ }
+
// point on feature
AttributePoint2DPtr aPoint = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
aTrimFeature->data()->attribute(SketchPlugin_Trim::PREVIEW_POINT()));
AttributeSelectionPtr aFeatureAttr =
std::dynamic_pointer_cast<ModelAPI_AttributeSelection>(theAttribute);
+ std::shared_ptr<GeomAPI_Vertex> aVertex;
std::shared_ptr<GeomAPI_Edge> anEdge;
std::shared_ptr<SketchPlugin_Feature> aSketchFeature;
if (aFeatureAttr.get()) {
GeomShapePtr aVal = aFeatureAttr->value();
ResultPtr aRes = aFeatureAttr->context();
if (aVal && aVal->isVertex())
- return true; // vertex is always could be projected
- if (aVal && aVal->isEdge()) {
- anEdge = std::shared_ptr<GeomAPI_Edge>(new GeomAPI_Edge(aFeatureAttr->value()));
+ aVertex = std::shared_ptr<GeomAPI_Vertex>(new GeomAPI_Vertex(aVal));
+ else if (aVal && aVal->isEdge()) {
+ anEdge = std::shared_ptr<GeomAPI_Edge>(new GeomAPI_Edge(aVal));
} else if(aRes && aRes->shape()) {
if (aRes->shape()->isVertex())
- return true; // vertex is always could be projected
+ aVertex = std::shared_ptr<GeomAPI_Vertex>(new GeomAPI_Vertex(aRes->shape()));
else if (aRes->shape()->isEdge())
- anEdge = std::shared_ptr<GeomAPI_Edge>(new GeomAPI_Edge(aFeatureAttr->context()->shape()));
+ anEdge = std::shared_ptr<GeomAPI_Edge>(new GeomAPI_Edge(aRes->shape()));
}
// try to convert result to sketch feature
std::dynamic_pointer_cast<SketchPlugin_Feature>(ModelAPI_Feature::feature(aRes));
}
}
- if (!anEdge) {
+ if (!aVertex && !anEdge) {
theError = "The attribute %1 should be an edge or vertex";
theError.arg(theAttribute->id());
return false;
std::shared_ptr<GeomAPI_Pnt> anOrigin = aPlane->location();
bool aValid = true;
- if (anEdge->isLine()) {
+ if (aVertex)
+ aValid = true; // vertex is always could be projected
+ else if (anEdge->isLine()) {
std::shared_ptr<GeomAPI_Lin> aLine = anEdge->line();
std::shared_ptr<GeomAPI_Dir> aLineDir = aLine->direction();
double aDot = fabs(aNormal->dot(aLineDir));
if (!aCopyAttr || !aCopyAttr->value())
return true; // feature is not a copy, thus valid
- // check the copy feature is already referred by the "Multi" feature
FeaturePtr aMultiFeature = ModelAPI_Feature::feature(theAttribute->owner());
+ // Collect original entities
+ std::set<FeaturePtr> anOriginalFeatures;
+ if (theArguments.size() > 1) {
+ AttributeRefListPtr anOrigList = aMultiFeature->reflist(theArguments.back());
+ for (int i = 0; i < anOrigList->size(); ++i)
+ {
+ FeaturePtr aFeature = ModelAPI_Feature::feature(anOrigList->object(i));
+ if (aFeature == anAttrOwnerFeature)
+ return true;
+ }
+ }
+
+ // check the copy feature is already referred by the "Multi" feature
AttributeRefListPtr aRefList = aMultiFeature->reflist(theArguments.front());
for (int i = 0; i < aRefList->size(); ++i)
{
const std::list<std::string>& theArguments,
Events_InfoMessage& theError) const
{
- if (theAttribute->attributeType() != ModelAPI_AttributeRefAttr::typeId()) {
+ if (theAttribute->attributeType() != ModelAPI_AttributeRefAttr::typeId() &&
+ theAttribute->attributeType() != ModelAPI_AttributeReference::typeId()) {
theError = "The attribute with the %1 type is not processed";
theError.arg(theAttribute->attributeType());
return false;
}
// check the attribute refers to a sketch feature
+ bool isSketchFeature = false;
AttributeRefAttrPtr aRefAttr =
std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(theAttribute);
- bool isSketchFeature = aRefAttr->isObject();
- if (isSketchFeature) {
- FeaturePtr aFeature = ModelAPI_Feature::feature(aRefAttr->object());
- isSketchFeature = aFeature.get() != NULL;
+ if (aRefAttr) {
+ isSketchFeature = aRefAttr->isObject();
if (isSketchFeature) {
- std::shared_ptr<SketchPlugin_Feature> aSketchFeature =
- std::dynamic_pointer_cast<SketchPlugin_Feature>(aFeature);
- isSketchFeature = aSketchFeature.get() != NULL;
+ FeaturePtr aFeature = ModelAPI_Feature::feature(aRefAttr->object());
+ isSketchFeature = aFeature.get() != NULL;
+ if (isSketchFeature) {
+ std::shared_ptr<SketchPlugin_Feature> aSketchFeature =
+ std::dynamic_pointer_cast<SketchPlugin_Feature>(aFeature);
+ isSketchFeature = aSketchFeature.get() != NULL;
+ }
+ }
+ }
+ else {
+ AttributeReferencePtr aReference =
+ std::dynamic_pointer_cast<ModelAPI_AttributeReference>(theAttribute);
+ if (aReference) {
+ FeaturePtr aFeature = ModelAPI_Feature::feature(aReference->value());
+ isSketchFeature = aFeature.get() && aFeature->getKind() == SketchPlugin_Sketch::ID();
}
}
- if (isSketchFeature)
- return true;
-
- theError = "The object selected is not a sketch feature";
- return false;
+ if (!isSketchFeature)
+ theError = "The object selected is not a sketch feature";
+ return isSketchFeature;
}
bool SketchPlugin_MultiRotationAngleValidator::isValid(const AttributePtr& theAttribute,