#include <GeomDataAPI_Point2D.h>
#include <ModelAPI_AttributeRefAttr.h>
+#include <ModelAPI_AttributeRefList.h>
#include <SketchPlugin_Arc.h>
#include <SketchPlugin_Circle.h>
+#include <SketchPlugin_ConstraintRigid.h>
/// \brief Verify two vectors of constraints are equal.
void SketchSolver_Storage::addConstraint(ConstraintPtr theConstraint,
ConstraintWrapperPtr theSolverConstraint)
{
- std::list<ConstraintWrapperPtr> aConstrList(1, theSolverConstraint);
- addConstraint(theConstraint, aConstrList);
+ if (theSolverConstraint) {
+ std::list<ConstraintWrapperPtr> aConstrList(1, theSolverConstraint);
+ addConstraint(theConstraint, aConstrList);
+ } else
+ addConstraint(theConstraint, std::list<ConstraintWrapperPtr>());
}
void SketchSolver_Storage::addConstraint(
if (aFound == myConstraintMap.end() || !isEqual(aFound->second, theSolverConstraints))
setNeedToResolve(true);
- // Do not add point-point coincidence, because it is already made by setting
- // the same parameters for both points
- if (!theSolverConstraints.empty() &&
- theSolverConstraints.front()->type() != CONSTRAINT_PT_PT_COINCIDENT) {
+ if (theSolverConstraints.empty()) {
+ // constraint links to the empty list, add its attributes linked to the empty entities
+ std::list<AttributePtr> aRefAttrs =
+ theConstraint->data()->attributes(ModelAPI_AttributeRefAttr::typeId());
+ std::list<AttributePtr>::const_iterator anAttrIt = aRefAttrs.begin();
+ for (; anAttrIt != aRefAttrs.end(); ++anAttrIt) {
+ AttributeRefAttrPtr aRef = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(*anAttrIt);
+ if (aRef->isObject()) {
+ FeaturePtr aFeature = ModelAPI_Feature::feature(aRef->object());
+ if (aFeature) addEntity(aFeature, EntityWrapperPtr());
+ } else
+ addEntity(aRef->attr(), EntityWrapperPtr());
+ }
+ std::list<AttributePtr> aRefLists =
+ theConstraint->data()->attributes(ModelAPI_AttributeRefList::typeId());
+ for (anAttrIt = aRefLists.begin(); anAttrIt != aRefLists.end(); ++anAttrIt) {
+ AttributeRefListPtr aRef = std::dynamic_pointer_cast<ModelAPI_AttributeRefList>(*anAttrIt);
+ std::list<ObjectPtr> anObj = aRef->list();
+ std::list<ObjectPtr>::iterator anIt = anObj.begin();
+ for (; anIt != anObj.end(); ++anIt) {
+ FeaturePtr aFeature = ModelAPI_Feature::feature(*anIt);
+ if (aFeature) addEntity(aFeature, EntityWrapperPtr());
+ }
+ }
+ }
+ else if (theSolverConstraints.front()->type() != CONSTRAINT_PT_PT_COINCIDENT) {
+ // Do not add point-point coincidence, because it is already made by setting
+ // the same parameters for both points
std::list<ConstraintWrapperPtr>::iterator aCIt = theSolverConstraints.begin();
for (; aCIt != theSolverConstraints.end(); ++aCIt)
update(*aCIt);
}
- myConstraintMap[theConstraint] = theSolverConstraints;
+
+ if (!theSolverConstraints.empty() || aFound == myConstraintMap.end())
+ myConstraintMap[theConstraint] = theSolverConstraints;
+ // block events if necessary
+ if (myEventsBlocked && theConstraint && theConstraint->data() && theConstraint->data()->isValid())
+ theConstraint->data()->blockSendAttributeUpdated(myEventsBlocked);
}
void SketchSolver_Storage::addEntity(FeaturePtr theFeature,
EntityWrapperPtr theSolverEntity)
{
std::map<FeaturePtr, EntityWrapperPtr>::const_iterator aFound = myFeatureMap.find(theFeature);
- if (aFound == myFeatureMap.end() || !aFound->second->isEqual(theSolverEntity))
+ if (aFound == myFeatureMap.end() || !aFound->second ||
+ (theSolverEntity && !aFound->second->isEqual(theSolverEntity)))
setNeedToResolve(true); // the entity is new or modified
- myFeatureMap[theFeature] = theSolverEntity;
+ if (!theSolverEntity) {
+ // feature links to the empty entity, add its attributes
+ std::list<AttributePtr> aPntAttrs =
+ theFeature->data()->attributes(GeomDataAPI_Point2D::typeId());
+ std::list<AttributePtr>::const_iterator anAttrIt = aPntAttrs.begin();
+ for (; anAttrIt != aPntAttrs.end(); ++anAttrIt)
+ addEntity(*anAttrIt, EntityWrapperPtr());
+ if (aFound == myFeatureMap.end())
+ myFeatureMap[theFeature] = theSolverEntity;
+ } else
+ myFeatureMap[theFeature] = theSolverEntity;
+
+ // block events if necessary
+ if (myEventsBlocked && theFeature->data() && theFeature->data()->isValid())
+ theFeature->data()->blockSendAttributeUpdated(myEventsBlocked);
}
void SketchSolver_Storage::addEntity(AttributePtr theAttribute,
EntityWrapperPtr theSolverEntity)
{
std::map<AttributePtr, EntityWrapperPtr>::const_iterator aFound = myAttributeMap.find(theAttribute);
- if (aFound == myAttributeMap.end() || !aFound->second->isEqual(theSolverEntity))
+ if (aFound == myAttributeMap.end() || !aFound->second ||
+ (theSolverEntity && !aFound->second->isEqual(theSolverEntity)))
setNeedToResolve(true); // the entity is new or modified
- myAttributeMap[theAttribute] = theSolverEntity;
+ if (theSolverEntity || aFound == myAttributeMap.end())
+ myAttributeMap[theAttribute] = theSolverEntity;
+ // block events if necessary
+ if (myEventsBlocked && theAttribute->owner() &&
+ theAttribute->owner()->data() && theAttribute->owner()->data()->isValid())
+ theAttribute->owner()->data()->blockSendAttributeUpdated(myEventsBlocked);
}
EntityWrapperPtr aRelated = entity(theFeature);
if (!aRelated) { // Feature is not exist, create it
std::list<EntityWrapperPtr> aSubs;
+ // Reserve the feature in the map of features (do not want to add several copies of it)
+ myFeatureMap[theFeature] = aRelated;
// Firstly, create/update its attributes
std::list<AttributePtr> anAttrs =
theFeature->data()->attributes(GeomDataAPI_Point2D::typeId());
}
// Secondly, convert feature
BuilderPtr aBuilder = SketchSolver_Manager::instance()->builder();
- aRelated = aBuilder->createFeature(theFeature, aSubs, theGroup);
+ GroupID aGroup = theGroup != GID_UNKNOWN ? theGroup : myGroupID;
+ // Check external feature
+ std::shared_ptr<SketchPlugin_Feature> aSketchFeature =
+ std::dynamic_pointer_cast<SketchPlugin_Feature>(theFeature);
+ if (aSketchFeature && aSketchFeature->isExternal())
+ aGroup = GID_OUTOFGROUP;
+ aRelated = aBuilder->createFeature(theFeature, aSubs, aGroup);
if (!aRelated)
return false;
addEntity(theFeature, aRelated);
EntityWrapperPtr aRelated = entity(anAttribute);
if (!aRelated) { // Attribute is not exist, create it
+ // verify the attribute is a point of arc and add whole arc
+ if (anAttribute->owner()) {
+ FeaturePtr aFeature = ModelAPI_Feature::feature(anAttribute->owner());
+ if (aFeature->getKind() == SketchPlugin_Arc::ID() &&
+ myFeatureMap.find(aFeature) == myFeatureMap.end()) {
+ // Additional checking that all attributes are initialized
+ if (aFeature->attribute(SketchPlugin_Arc::CENTER_ID())->isInitialized() &&
+ aFeature->attribute(SketchPlugin_Arc::START_ID())->isInitialized() &&
+ aFeature->attribute(SketchPlugin_Arc::END_ID())->isInitialized()) {
+ return SketchSolver_Storage::update(aFeature);
+ } else {
+ myFeatureMap[aFeature] = EntityWrapperPtr();
+ myExistArc = true;
+ }
+ }
+ }
BuilderPtr aBuilder = SketchSolver_Manager::instance()->builder();
- aRelated = aBuilder->createAttribute(anAttribute, theGroup);
+ GroupID aGroup = theGroup != GID_UNKNOWN ? theGroup : myGroupID;
+ // Check attribute of external features
+ std::shared_ptr<SketchPlugin_Feature> aSketchFeature =
+ std::dynamic_pointer_cast<SketchPlugin_Feature>(theAttribute->owner());
+ if (aSketchFeature && aSketchFeature->isExternal())
+ aGroup = GID_OUTOFGROUP;
+ aRelated = aBuilder->createAttribute(anAttribute, aGroup);
if (!aRelated)
return false;
addEntity(anAttribute, aRelated);
return aDummy;
}
+bool SketchSolver_Storage::removeConstraint(ConstraintPtr theConstraint)
+{
+ std::map<ConstraintPtr, std::list<ConstraintWrapperPtr> >::iterator
+ aFound = myConstraintMap.find(theConstraint);
+ if (aFound == myConstraintMap.end())
+ return true; // no constraint, already deleted
+
+ // Remove constraint
+ std::list<ConstraintWrapperPtr> aConstrList = aFound->second;
+ myConstraintMap.erase(aFound);
+ // Remove SolveSpace constraints
+ bool isFullyRemoved = true;
+ std::list<ConstraintWrapperPtr>::iterator anIt = aConstrList.begin();
+ while (anIt != aConstrList.end()) {
+ if (remove(*anIt)) {
+ std::list<ConstraintWrapperPtr>::iterator aRemoveIt = anIt++;
+ aConstrList.erase(aRemoveIt);
+ } else {
+ isFullyRemoved = false;
+ ++anIt;
+ }
+ }
+ return isFullyRemoved;
+}
+
+template <class ENT_TYPE>
+static bool isUsed(ConstraintWrapperPtr theConstraint, ENT_TYPE theEntity)
+{
+ if (!theConstraint || !theEntity)
+ return false;
+ std::list<EntityWrapperPtr>::const_iterator anEntIt = theConstraint->entities().begin();
+ for (; anEntIt != theConstraint->entities().end(); ++anEntIt)
+ if ((*anEntIt)->isBase(theEntity))
+ return true;
+ return false;
+}
+
+static bool isUsed(EntityWrapperPtr theFeature, AttributePtr theSubEntity)
+{
+ if (!theFeature || !theSubEntity)
+ return false;
+ std::list<EntityWrapperPtr>::const_iterator aSubIt = theFeature->subEntities().begin();
+ for (; aSubIt != theFeature->subEntities().end(); ++aSubIt)
+ if ((*aSubIt)->isBase(theSubEntity))
+ return true;
+ return false;
+}
+
+static bool isUsed(ConstraintPtr theConstraint, AttributePtr theAttribute)
+{
+ if (!theConstraint || !theAttribute)
+ return false;
+ std::list<AttributePtr> anAttrList = theConstraint->data()->attributes(std::string());
+ std::list<AttributePtr>::const_iterator anIt = anAttrList.begin();
+ for (; anIt != anAttrList.end(); ++anIt) {
+ if (*anIt == theAttribute)
+ return true;
+ AttributeRefAttrPtr aRefAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(*anIt);
+ if (aRefAttr && !aRefAttr->isObject() && aRefAttr->attr() == theAttribute)
+ return true;
+ }
+ return false;
+}
+
+bool SketchSolver_Storage::isUsed(FeaturePtr theFeature) const
+{
+ if (myFeatureMap.find(theFeature) != myFeatureMap.end())
+ return true;
+ // check constraints
+ std::map<ConstraintPtr, std::list<ConstraintWrapperPtr> >::const_iterator
+ aCIt = myConstraintMap.begin();
+ std::list<ConstraintWrapperPtr>::const_iterator aCWIt;
+ for (; aCIt != myConstraintMap.end(); ++aCIt)
+ for (aCWIt = aCIt->second.begin(); aCWIt != aCIt->second.end(); ++aCWIt)
+ if (::isUsed(*aCWIt, theFeature))
+ return true;
+ // check attributes
+ std::list<AttributePtr> anAttrList = theFeature->data()->attributes(GeomDataAPI_Point2D::typeId());
+ std::list<AttributePtr>::const_iterator anIt = anAttrList.begin();
+ for (; anIt != anAttrList.end(); ++anIt)
+ if (isUsed(*anIt))
+ return true;
+ return false;
+}
+
+bool SketchSolver_Storage::isUsed(AttributePtr theAttribute) const
+{
+ AttributePtr anAttribute = theAttribute;
+ AttributeRefAttrPtr aRefAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(anAttribute);
+ if (aRefAttr) {
+ if (aRefAttr->isObject())
+ return isUsed(ModelAPI_Feature::feature(aRefAttr->object()));
+ else
+ anAttribute = aRefAttr->attr();
+ }
+
+ if (myAttributeMap.find(theAttribute) != myAttributeMap.end())
+ return true;
+ // check in constraints
+ std::map<ConstraintPtr, std::list<ConstraintWrapperPtr> >::const_iterator
+ aCIt = myConstraintMap.begin();
+ std::list<ConstraintWrapperPtr>::const_iterator aCWIt;
+ for (; aCIt != myConstraintMap.end(); ++aCIt) {
+ for (aCWIt = aCIt->second.begin(); aCWIt != aCIt->second.end(); ++aCWIt)
+ if (::isUsed(*aCWIt, anAttribute))
+ return true;
+ // Additional check for the Fixed constraints, which have no wrapper associated.
+ if (aCIt->first->getKind() == SketchPlugin_ConstraintRigid::ID() &&
+ ::isUsed(aCIt->first, anAttribute))
+ return true;
+ }
+ // check in features
+ std::map<FeaturePtr, EntityWrapperPtr>::const_iterator aFIt = myFeatureMap.begin();
+ for (; aFIt != myFeatureMap.end(); ++aFIt)
+ if (::isUsed(aFIt->second, anAttribute))
+ return true;
+ return false;
+}
+
+
+bool SketchSolver_Storage::removeEntity(FeaturePtr theFeature)
+{
+ std::map<FeaturePtr, EntityWrapperPtr>::iterator aFound = myFeatureMap.find(theFeature);
+ if (aFound == myFeatureMap.end())
+ return true; // feature not found, nothing to delete
+
+ EntityWrapperPtr anEntity = aFound->second;
+ myFeatureMap.erase(aFound);
+
+ // Check if the feature is not used by constraints, remove it
+ if (!anEntity || (!isUsed(theFeature) && remove(anEntity)))
+ return true;
+
+ // feature is not removed, revert operation
+ myFeatureMap[theFeature] = anEntity;
+ update(anEntity);
+ return false;
+}
+
+bool SketchSolver_Storage::removeEntity(AttributePtr theAttribute)
+{
+ std::map<AttributePtr, EntityWrapperPtr>::iterator aFound = myAttributeMap.find(theAttribute);
+ if (aFound == myAttributeMap.end())
+ return true; // attribute not found, nothing to delete
+
+ EntityWrapperPtr anEntity = aFound->second;
+ myAttributeMap.erase(aFound);
+
+ // Check if the attribute is not used by constraints and features, remove it
+ if (!anEntity || (!isUsed(theAttribute) && remove(anEntity)))
+ return true;
+
+ // attribute is not removed, revert operation
+ myAttributeMap[theAttribute] = anEntity;
+ update(anEntity);
+ return false;
+}
+
+
+bool SketchSolver_Storage::remove(ConstraintWrapperPtr theConstraint)
+{
+ bool isFullyRemoved = true;
+ std::list<EntityWrapperPtr>::const_iterator anIt = theConstraint->entities().begin();
+ for (; anIt != theConstraint->entities().end(); ++anIt) {
+ FeaturePtr aBaseFeature = (*anIt)->baseFeature();
+ if (aBaseFeature)
+ isFullyRemoved = SketchSolver_Storage::removeEntity(aBaseFeature) && isFullyRemoved;
+ else
+ isFullyRemoved = SketchSolver_Storage::removeEntity((*anIt)->baseAttribute()) && isFullyRemoved;
+ }
+ return isFullyRemoved;
+}
+
+bool SketchSolver_Storage::remove(EntityWrapperPtr theEntity)
+{
+ bool isFullyRemoved = true;
+ std::list<EntityWrapperPtr>::const_iterator anEntIt = theEntity->subEntities().begin();
+ for (; anEntIt != theEntity->subEntities().end(); ++anEntIt) {
+ FeaturePtr aBaseFeature = (*anEntIt)->baseFeature();
+ if (aBaseFeature)
+ isFullyRemoved = SketchSolver_Storage::removeEntity(aBaseFeature) && isFullyRemoved;
+ else
+ isFullyRemoved = SketchSolver_Storage::removeEntity((*anEntIt)->baseAttribute()) && isFullyRemoved;
+ }
+
+ std::list<ParameterWrapperPtr>::const_iterator aParIt = theEntity->parameters().begin();
+ for (; aParIt != theEntity->parameters().end(); ++aParIt)
+ isFullyRemoved = remove(*aParIt) && isFullyRemoved;
+ return isFullyRemoved;
+}
+
+
bool SketchSolver_Storage::isInteract(const FeaturePtr& theFeature) const
{
if (!theFeature)
if (!theAttribute)
return false;
+ AttributeRefListPtr aRefList =
+ std::dynamic_pointer_cast<ModelAPI_AttributeRefList>(theAttribute);
+ if (aRefList) {
+ std::list<ObjectPtr> anObjects = aRefList->list();
+ std::list<ObjectPtr>::iterator anObjIt = anObjects.begin();
+ for (; anObjIt != anObjects.end(); ++anObjIt) {
+ FeaturePtr aFeature = ModelAPI_Feature::feature(*anObjIt);
+ if (isInteract(aFeature))
+ return true;
+ }
+ return false;
+ }
+
AttributeRefAttrPtr aRefAttr =
std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(theAttribute);
if (!aRefAttr)
if ((*anEntIt)->group() != myGroupID)
return true;
}
+
+ std::map<ConstraintPtr, std::list<ConstraintWrapperPtr> >::const_iterator aCIt = myConstraintMap.begin();
+ std::list<ConstraintWrapperPtr>::const_iterator aCWIt;
+ for (; aCIt != myConstraintMap.end(); ++aCIt) {
+ if (aCIt->second.empty())
+ continue;
+ aCWIt = aCIt->second.begin();
+ if ((*aCWIt)->type() != CONSTRAINT_FIXED)
+ continue;
+ for (; aCWIt != aCIt->second.end(); ++aCIt)
+ if ((theEntity->baseAttribute() && (*aCWIt)->isUsed(theEntity->baseAttribute())) ||
+ (theEntity->baseFeature() && (*aCWIt)->isUsed(theEntity->baseFeature())))
+ return true;
+ }
+
return false;
}
std::map<FeaturePtr, EntityWrapperPtr>::const_iterator aFIt = myFeatureMap.begin();
for (; aFIt != myFeatureMap.end(); ++aFIt)
- if (aFIt->second->type() == ENTITY_SKETCH)
+ if (aFIt->second && aFIt->second->type() == ENTITY_SKETCH)
break;
if (aFIt == myFeatureMap.end())
return aDummySketch;
addEntity(FeaturePtr(), theSketch);
}
-void SketchSolver_Storage::blockEvents(bool isBlocked) const
+void SketchSolver_Storage::processArcs()
{
+ myExistArc = false;
+ std::map<FeaturePtr, EntityWrapperPtr>::iterator aFIt = myFeatureMap.begin();
+ for (; aFIt != myFeatureMap.end(); ++aFIt)
+ if (!aFIt->second && aFIt->first->getKind() == SketchPlugin_Arc::ID()) {
+ // Additional checking the attributes are initialized
+ if (aFIt->first->attribute(SketchPlugin_Arc::CENTER_ID())->isInitialized() &&
+ aFIt->first->attribute(SketchPlugin_Arc::START_ID())->isInitialized() &&
+ aFIt->first->attribute(SketchPlugin_Arc::END_ID())->isInitialized())
+ update(aFIt->first);
+ else
+ myExistArc = true;
+ }
+}
+
+void SketchSolver_Storage::blockEvents(bool isBlocked)
+{
+ if (isBlocked == myEventsBlocked)
+ return;
+
std::map<ConstraintPtr, std::list<ConstraintWrapperPtr> >::const_iterator
aCIter = myConstraintMap.begin();
for (; aCIter != myConstraintMap.end(); aCIter++)
if (anAtIter->first->owner() && anAtIter->first->owner()->data() &&
anAtIter->first->owner()->data()->isValid())
anAtIter->first->owner()->data()->blockSendAttributeUpdated(isBlocked);
+ myEventsBlocked = isBlocked;
}
+std::set<ObjectPtr> SketchSolver_Storage::getConflictingConstraints(SolverPtr theSolver) const
+{
+ std::set<ObjectPtr> aConflicting;
+ std::map<ConstraintPtr, std::list<ConstraintWrapperPtr> >::const_iterator
+ aConstrIt = myConstraintMap.begin();
+ for (; aConstrIt != myConstraintMap.end(); ++aConstrIt) {
+ std::list<ConstraintWrapperPtr>::const_iterator anIt = aConstrIt->second.begin();
+ for (; anIt != aConstrIt->second.end(); ++anIt)
+ if (theSolver->isConflicting((*anIt)->id())) {
+ aConflicting.insert(aConstrIt->first);
+ break;
+ }
+ }
+ return aConflicting;
+}