-// Copyright (C) 2014-2019 CEA/DEN, EDF R&D
+// 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
#include "SketchPlugin_Ellipse.h"
#include "SketchPlugin_EllipticArc.h"
#include "SketchPlugin_Fillet.h"
+#include "SketchPlugin_CurveFitting.h"
#include "SketchPlugin_Line.h"
#include "SketchPlugin_MacroArc.h"
#include "SketchPlugin_MacroCircle.h"
#include "SketchPlugin_MultiRotation.h"
+#include "SketchPlugin_Offset.h"
#include "SketchPlugin_Point.h"
#include "SketchPlugin_Sketch.h"
#include "SketchPlugin_Trim.h"
#include <Events_InfoMessage.h>
+#include <Locale_Convert.h>
+
#include <ModelAPI_Data.h>
#include <ModelAPI_Validator.h>
#include <ModelAPI_AttributeDouble.h>
#include <ModelAPI_AttributeInteger.h>
#include <ModelAPI_AttributeRefAttr.h>
+#include <ModelAPI_AttributeRefAttrList.h>
#include <ModelAPI_AttributeRefList.h>
#include <ModelAPI_AttributeSelectionList.h>
#include <ModelAPI_AttributeString.h>
#include <GeomAlgoAPI_EdgeBuilder.h>
#include <GeomAlgoAPI_ShapeTools.h>
+#include <GeomAPI_BSpline.h>
#include <GeomAPI_Circ.h>
#include <GeomAPI_Dir2d.h>
#include <GeomAPI_Ellipse.h>
#include <algorithm>
#include <cmath>
+#ifdef _MSC_VER
+#pragma warning(disable: 4100)
+#endif
+
const double tolerance = 1.e-7;
static bool isSpline(FeaturePtr theFeature)
// 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());
SketchPlugin_Tools::findCoincidences(*anIt, SketchPlugin_Constraint::ENTITY_A(),
aCoinc, true);
- isValid = aCoinc.find(aOtherFea) != aCoinc.end();
+ 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;
+ }
}
}
}
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 =
if (aRefAttr->isObject()) {
if (aRefAttr->object() == aRAttr->object()) {
ObjectPtr anObject = aRefAttr->object();
- std::string aName = anObject.get() ? anObject->data()->name() : "";
+ std::wstring aName = anObject.get() ? anObject->data()->name() : L"";
theError = "The object %1 has been already fixed.";
theError.arg(aName);
return false;
}
else if (aRefAttr->attr() == aRAttr->attr()) {
AttributePtr anAttribute = aRefAttr->attr();
- std::string aName = anAttribute.get() ? anAttribute->id() : "";
+ std::wstring aName =
+ anAttribute.get() ? Locale::Convert::toWString(anAttribute->id()) : L"";
theError = "The attribute %1 has been already fixed.";
theError.arg(aName);
return false;
for(int anInd = 0; anInd < aSelAttr->size(); anInd++) {
ObjectPtr aSelObject = aSelAttr->object(anInd);
- std::string aName = aSelObject.get() ? aSelObject->data()->name() : "";
+
+ // 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::wstring aName = aSelObject.get() ? aSelObject->data()->name() : L"";
std::list<ObjectPtr>::iterator aMirIter = aMirroredObjects.begin();
for (; aMirIter != aMirroredObjects.end(); aMirIter++)
if (aSelObject == *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);
FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(theAttribute->owner());
AttributeRefListPtr aSelAttr =
std::dynamic_pointer_cast<ModelAPI_AttributeRefList>(theAttribute);
+ std::set<ObjectPtr> aSelected;
AttributeRefListPtr aRefListOfInitial = std::dynamic_pointer_cast<ModelAPI_AttributeRefList>(
aFeature->attribute(SketchPlugin_Constraint::ENTITY_A()));
std::list<ObjectPtr>::iterator anObjIter;
for(int anInd = 0; anInd < aSelAttr->size(); anInd++) {
ObjectPtr aSelObject = aSelAttr->object(anInd);
+ if (aSelected.find(aSelObject) != aSelected.end()) {
+ theError = "Error: An object selected twice";
+ return false;
+ }
+ aSelected.insert(aSelObject);
+
anObjIter = anInitialObjects.begin();
for (; anObjIter != anInitialObjects.end(); anObjIter++)
if (aSelObject == *anObjIter)
break;
if (anObjIter != anInitialObjects.end())
continue;
+
+ // B-splines are not supported in Copying features
+ FeaturePtr aSelFeature = ModelAPI_Feature::feature(aSelObject);
+ if (aFeature->getKind() != SketchPlugin_Offset::ID() &&
+ 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) {
- std::string aName = aSelObject.get() ? aSelObject->data()->name() : "";
+ for (; anObjIter != aCopiedObjects.end(); anObjIter++) {
+ bool isFound = aSelObject == *anObjIter;
+ if (!isFound) {
+ // check in the results of the feature
+ FeaturePtr aCurFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(*anObjIter);
+ if (aCurFeature) {
+ const std::list<ResultPtr>& aResults = aCurFeature->results();
+ for (std::list<ResultPtr>::const_iterator aResIt = aResults.begin();
+ aResIt != aResults.end() && !isFound; ++aResIt) {
+ isFound = aSelObject == *aResIt;
+ }
+ }
+ }
+ if (isFound) {
+ std::string aName =
+ aSelObject.get() ? Locale::Convert::toString(aSelObject->data()->name()) : "";
theError = "The object %1 is a result of copy";
theError.arg(aName);
return false;
}
+ }
}
return true;
}
bool SketchPlugin_FilletVertexValidator::isValid(const AttributePtr& theAttribute,
const std::list<std::string>& theArguments,
Events_InfoMessage& theError) const
+{
+ FeaturePtr anEdge1, anEdge2;
+ return isValidVertex(theAttribute, theError, anEdge1, anEdge2);
+}
+
+bool SketchPlugin_FilletVertexValidator::isValidVertex(const AttributePtr& theAttribute,
+ Events_InfoMessage& theError,
+ FeaturePtr& theEdge1,
+ FeaturePtr& theEdge2)
{
AttributeRefAttrPtr aPointRefAttr =
std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(theAttribute);
// Get coincides from constraint.
std::set<FeaturePtr> aCoinsides;
SketchPlugin_Tools::findCoincidences(aConstraintCoincidence,
- SketchPlugin_ConstraintCoincidence::ENTITY_A(),
- aCoinsides,
- true);
+ SketchPlugin_ConstraintCoincidence::ENTITY_A(),
+ aCoinsides,
+ true);
SketchPlugin_Tools::findCoincidences(aConstraintCoincidence,
- SketchPlugin_ConstraintCoincidence::ENTITY_B(),
- aCoinsides,
- true);
+ SketchPlugin_ConstraintCoincidence::ENTITY_B(),
+ aCoinsides,
+ true);
// Remove points and external lines from set of coincides.
std::set<FeaturePtr> aNewSetOfCoincides;
return false;
}
+ // output edges
+ std::set<FeaturePtr>::iterator aFIt = aCoinsides.begin();
+ theEdge1 = *aFIt;
+ theEdge2 = *(++aFIt);
+
// Check that selected edges don't have tangent constraint.
std::set<FeaturePtr>::iterator anIt = aCoinsides.begin();
FeaturePtr aFirstFeature = *anIt++;
// 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());
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));
std::shared_ptr<GeomAPI_Ellipse> anEllipse = anEdge->ellipse();
std::shared_ptr<GeomAPI_Dir> anEllipseNormal = anEllipse->normal();
double aDot = fabs(aNormal->dot(anEllipseNormal));
- aValid = fabs(aDot - 1.0) <= tolerance * tolerance;
+ aValid = aDot >= tolerance * tolerance;
if (!aValid)
theError.arg(anEdge->isClosed() ? "Error: Ellipse is orthogonal to the sketch plane."
: "Error: Elliptic Arc is orthogonal to the sketch plane.");
}
+ else if (anEdge->isBSpline()) {
+ // check B-spline is periodic and planar
+ std::shared_ptr<GeomAPI_Curve> aCurve(new GeomAPI_Curve(anEdge));
+ std::shared_ptr<GeomAPI_BSpline> aBSpline(new GeomAPI_BSpline(aCurve));
+ if (aBSpline->isPeriodic()) {
+ GeomPlanePtr aBSplinePlane = GeomAlgoAPI_ShapeTools::findPlane(ListOfShape(1, anEdge));
+ if (aBSplinePlane) {
+ std::shared_ptr<GeomAPI_Dir> aBSplineNormal = aBSplinePlane->direction();
+ double aDot = fabs(aNormal->dot(aBSplineNormal));
+ aValid = aDot > tolerance * tolerance;
+ if (!aValid) {
+ // B-spline's plane is orthogonal to the sketch plane,
+ // thus, need to check whether B-spline is planar.
+ std::list<GeomPointPtr> aPoles = aBSpline->poles();
+ for (std::list<GeomPointPtr>::iterator it = aPoles.begin();
+ it != aPoles.end() && !aValid; ++it) {
+ if (aBSplinePlane->distance(*it) > tolerance)
+ aValid = true; // non-planar B-spline curve
+ }
+ if (!aValid)
+ theError = "Error: Periodic B-spline is orthogonal to the sketch plane.";
+ }
+ }
+ }
+ }
return aValid;
}
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,
return true;
}
+
+bool SketchPlugin_CurveFittingValidator::isValid(const FeaturePtr& theFeature,
+ const std::list<std::string>& theArguments,
+ Events_InfoMessage& theError) const
+{
+ AttributeRefAttrListPtr aRefAttrList =
+ theFeature->refattrlist(SketchPlugin_CurveFitting::POINTS_ID());
+ AttributeBooleanPtr aPeriodicAttr =
+ theFeature->boolean(SketchPlugin_CurveFitting::PERIODIC_ID());
+
+ // check number of selected entities
+ int aMinNbPoints = aPeriodicAttr->value() ? 3 : 2;
+ if (aRefAttrList->size() < aMinNbPoints) {
+ theError = "Not enough points selected. Need at least %1 points.";
+ theError.arg(aMinNbPoints);
+ return false;
+ }
+ return true;
+}
