#include <SketchPlugin_ConstraintCoincidence.h>
#include <SketchPlugin_ConstraintMirror.h>
#include <SketchPlugin_ConstraintRigid.h>
+#include <SketchPlugin_Projection.h>
/// \brief Verify two vectors of constraints are equal.
static bool isEqual(const std::list<ConstraintWrapperPtr>& theCVec1,
const std::list<ConstraintWrapperPtr>& theCVec2);
+/// \brief Convert result to feature or attribute
+static void resultToFeatureOrAttribute(const ObjectPtr& theResult,
+ FeaturePtr& theFeature, AttributePtr& theAttribute);
+
void SketchSolver_Storage::addConstraint(ConstraintPtr theConstraint,
ConstraintWrapperPtr theSolverConstraint)
static std::list<AttributePtr> pointAttributes(FeaturePtr theFeature)
{
std::list<AttributePtr> aPoints;
+ if (!theFeature->data() || !theFeature->data()->isValid())
+ return aPoints;
if (theFeature->getKind() == SketchPlugin_Arc::ID()) {
aPoints.push_back(theFeature->attribute(SketchPlugin_Arc::CENTER_ID()));
aPoints.push_back(theFeature->attribute(SketchPlugin_Arc::START_ID()));
void SketchSolver_Storage::addEntity(AttributePtr theAttribute,
EntityWrapperPtr theSolverEntity)
{
- std::map<AttributePtr, EntityWrapperPtr>::const_iterator aFound = myAttributeMap.find(theAttribute);
+ std::map<AttributePtr, EntityWrapperPtr>::const_iterator aFound =
+ myAttributeMap.find(theAttribute);
if (aFound == myAttributeMap.end() || !aFound->second ||
(theSolverEntity && !aFound->second->isEqual(theSolverEntity)))
setNeedToResolve(true); // the entity is new or modified
return false;
bool aResult = theFeature->isCopy();
if (aResult) {
- std::map<ConstraintPtr, std::list<ConstraintWrapperPtr> >::const_iterator
- anIt = theConstraints.begin();
- for (; anIt != theConstraints.end() && aResult; ++anIt) {
- if (anIt->first->getKind() != SketchPlugin_ConstraintMirror::ID())
- continue;
- AttributeRefListPtr aRefList = std::dynamic_pointer_cast<ModelAPI_AttributeRefList>(
- anIt->first->attribute(SketchPlugin_Constraint::ENTITY_C()));
- std::list<ObjectPtr> aMirroredList = aRefList->list();
- std::list<ObjectPtr>::const_iterator aMIt = aMirroredList.begin();
- for (; aMIt != aMirroredList.end() && aResult; ++aMIt) {
- FeaturePtr aFeat = ModelAPI_Feature::feature(*aMIt);
- if (aFeat == theFeature)
- aResult = false;
- }
+ const std::set<AttributePtr>& aRefs = theFeature->data()->refsToMe();
+ for (std::set<AttributePtr>::const_iterator aRefIt = aRefs.begin();
+ aRefIt != aRefs.end() && aResult; ++aRefIt) {
+ FeaturePtr anOwner = ModelAPI_Feature::feature((*aRefIt)->owner());
+ if ((anOwner->getKind() == SketchPlugin_ConstraintMirror::ID() &&
+ (*aRefIt)->id() == SketchPlugin_Constraint::ENTITY_C()) ||
+ (anOwner->getKind() == SketchPlugin_Projection::ID()))
+ aResult = false;
}
}
return aResult;
bool isUpdated = false;
EntityWrapperPtr aRelated = entity(theFeature);
if (!aRelated) { // Feature is not exist, create it
- std::shared_ptr<SketchPlugin_Feature> aSketchFeature =
+ std::shared_ptr<SketchPlugin_Feature> aSketchFeature =
std::dynamic_pointer_cast<SketchPlugin_Feature>(theFeature);
bool isCopy = isCopyInMulti(aSketchFeature, myConstraintMap);
+ // the feature is a copy in "Multi" constraint and does not used in other constraints
if (!theForce && isCopy && myFeatureMap.find(theFeature) == myFeatureMap.end())
- return false; // the feature is a copy in "Multi" constraint and does not used in other constraints
+ return false;
std::list<EntityWrapperPtr> aSubs;
// Reserve the feature in the map of features (do not want to add several copies of it)
std::list<AttributePtr> anAttrs = pointAttributes(theFeature);
std::list<AttributePtr>::const_iterator anIt = anAttrs.begin();
for (; anIt != anAttrs.end(); ++anIt) {
+ if (!(*anIt)->isInitialized())
+ return false;
isUpdated = update(*anIt, theGroup, theForce) || isUpdated;
aSubs.push_back(entity(*anIt));
}
bool SketchSolver_Storage::update(AttributePtr theAttribute, const GroupID& theGroup, bool theForce)
{
+ if (!theAttribute->isInitialized())
+ return false;
+
AttributePtr anAttribute = theAttribute;
AttributeRefAttrPtr aRefAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(anAttribute);
if (aRefAttr) {
if (aRefAttr->isObject()) {
- FeaturePtr aFeature = ModelAPI_Feature::feature(aRefAttr->object());
- return update(aFeature, theGroup, theForce);
- } else
+ FeaturePtr aFeature;
+ resultToFeatureOrAttribute(aRefAttr->object(), aFeature, anAttribute);
+ if (aFeature)
+ return update(aFeature, theGroup, theForce);
+ } else {
anAttribute = aRefAttr->attr();
+ if (!anAttribute->isInitialized())
+ return false;
+ }
}
EntityWrapperPtr aRelated = entity(anAttribute);
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() &&
+ 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, theGroup, theForce);
} else {
BuilderPtr aBuilder = SketchSolver_Manager::instance()->builder();
GroupID aGroup = theGroup != GID_UNKNOWN ? theGroup : myGroupID;
// Check attribute of external features
- std::shared_ptr<SketchPlugin_Feature> aSketchFeature =
+ std::shared_ptr<SketchPlugin_Feature> aSketchFeature =
std::dynamic_pointer_cast<SketchPlugin_Feature>(anAttribute->owner());
- if (aSketchFeature && (aSketchFeature->isExternal() || isCopyInMulti(aSketchFeature, myConstraintMap)))
+ if (aSketchFeature && (aSketchFeature->isExternal() ||
+ isCopyInMulti(aSketchFeature, myConstraintMap)))
aGroup = GID_OUTOFGROUP;
aRelated = aBuilder->createAttribute(anAttribute, aGroup);
if (!aRelated)
std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(theAttribute);
if (aRefAttr) {
if (aRefAttr->isObject()) {
- FeaturePtr aFeature = ModelAPI_Feature::feature(aRefAttr->object());
- return entity(aFeature);
+ FeaturePtr aFeature;
+ AttributePtr anAttribute;
+ resultToFeatureOrAttribute(aRefAttr->object(), aFeature, anAttribute);
+ if (aFeature)
+ return entity(aFeature);
+ else
+ return entity(anAttribute);
} else
return entity(aRefAttr->attr());
}
return false;
}
+// Merge groups containing given entities
+static void mergeGroups(std::list<std::set<EntityWrapperPtr> >& theGroups,
+ const EntityWrapperPtr& theEntity1, const EntityWrapperPtr& theEntity2)
+{
+ std::list<std::set<EntityWrapperPtr> >::iterator aFound1 = theGroups.end();
+ std::list<std::set<EntityWrapperPtr> >::iterator aFound2 = theGroups.end();
+ std::list<std::set<EntityWrapperPtr> >::iterator anIt = theGroups.begin();
+ for (; anIt != theGroups.end() && (aFound1 == theGroups.end() || aFound2 == theGroups.end());
+ ++anIt) {
+ if (anIt->find(theEntity1) != anIt->end())
+ aFound1 = anIt;
+ if (anIt->find(theEntity2) != anIt->end())
+ aFound2 = anIt;
+ }
+
+ if (aFound1 == aFound2 || aFound1 == theGroups.end() || aFound2 == theGroups.end())
+ return; // nothing to merge
+
+ aFound1->insert(aFound2->begin(), aFound2->end());
+ theGroups.erase(aFound2);
+}
bool SketchSolver_Storage::removeCoincidence(ConstraintWrapperPtr theConstraint)
{
if (aPtPtIt == myCoincidentPoints.end())
return true; // already removed
- // Create new copies of coincident points
- BuilderPtr aBuilder = SketchSolver_Manager::instance()->builder();
- std::list<EntityWrapperPtr> aNewPoints;
- for (aPIt = aPoints.begin(); aPIt != aPoints.end(); ++aPIt)
- aNewPoints.push_back(aBuilder->createAttribute(
- (*aPIt)->baseAttribute(), myGroupID, mySketchID));
-
- // Find all points fallen out of group of coincident points
- std::map<EntityWrapperPtr, EntityWrapperPtr> aNotCoinc;
- aNotCoinc[aPtPtIt->first] = EntityWrapperPtr();
+ // Removing of coincidence may split this group of coincident point to several groups.
+ // Find all of them and also the points which become alone.
+ std::list< std::set<EntityWrapperPtr> > aCoincGroups;
+ std::set<EntityWrapperPtr> aGroup;
+ aGroup.insert(aPtPtIt->first);
+ aCoincGroups.push_back(aGroup);
std::set<EntityWrapperPtr>::const_iterator aTempIt = aPtPtIt->second.begin();
- for (; aTempIt != aPtPtIt->second.end(); ++aTempIt)
- aNotCoinc[*aTempIt] = EntityWrapperPtr();
+ for (; aTempIt != aPtPtIt->second.end(); ++aTempIt) {
+ aGroup.clear();
+ aGroup.insert(*aTempIt);
+ aCoincGroups.push_back(aGroup);
+ }
+
std::map<ConstraintPtr, std::list<ConstraintWrapperPtr> >::iterator
aConstrIt = myConstraintMap.begin();
- for (; aConstrIt != myConstraintMap.end(); ++aConstrIt)
- if (aConstrIt->first->getKind() == SketchPlugin_ConstraintCoincidence::ID()) {
- AttributeRefAttrPtr aRefAttr[2] = {
- aConstrIt->first->refattr(SketchPlugin_Constraint::ENTITY_A()),
- aConstrIt->first->refattr(SketchPlugin_Constraint::ENTITY_B())
- };
- AttributePtr anAttr[2];
- if (aConstrIt->first->data()->isValid()) {
- if (!aRefAttr[0] || !aRefAttr[1])
- continue;
-
- for (int i = 0; i < 2; ++i) {
- if (aRefAttr[i]->isObject()) {
- FeaturePtr aFeature = ModelAPI_Feature::feature(aRefAttr[i]->object());
- if (!aFeature || (aFeature->getKind() != SketchPlugin_Point::ID() &&
- aFeature->getKind() != SketchPlugin_IntersectionPoint::ID()))
- continue;
- anAttr[i] = aFeature->attribute(SketchPlugin_Point::COORD_ID());
- } else
- anAttr[i] = aRefAttr[i]->attr();
- }
- } else {
- // obtain attributes from the constraint wrapper
- ConstraintWrapperPtr aWrapper = aConstrIt->second.front();
- anAttr[0] = aWrapper->entities().front()->baseAttribute();
- anAttr[1] = aWrapper->entities().back()->baseAttribute();
- }
+ for (; aConstrIt != myConstraintMap.end(); ++aConstrIt) {
+ if (aConstrIt->first->getKind() != SketchPlugin_ConstraintCoincidence::ID())
+ continue;
+
+ AttributeRefAttrPtr aRefAttr[2] = {
+ aConstrIt->first->refattr(SketchPlugin_Constraint::ENTITY_A()),
+ aConstrIt->first->refattr(SketchPlugin_Constraint::ENTITY_B())
+ };
+ AttributePtr anAttr[2];
+ if (aConstrIt->first->data()->isValid()) {
+ if (!aRefAttr[0] || !aRefAttr[1])
+ continue;
+
for (int i = 0; i < 2; ++i) {
- std::map<AttributePtr, EntityWrapperPtr>::iterator
- aFound = myAttributeMap.find(anAttr[i]);
- if (aFound != myAttributeMap.end())
- aNotCoinc.erase(aFound->second);
+ if (aRefAttr[i]->isObject()) {
+ FeaturePtr aFeature = ModelAPI_Feature::feature(aRefAttr[i]->object());
+ if (!aFeature || (aFeature->getKind() != SketchPlugin_Point::ID() &&
+ aFeature->getKind() != SketchPlugin_IntersectionPoint::ID()))
+ continue;
+ anAttr[i] = aFeature->attribute(SketchPlugin_Point::COORD_ID());
+ } else
+ anAttr[i] = aRefAttr[i]->attr();
}
+ } else {
+ // obtain attributes from the constraint wrapper
+ // if SketchPlugin_Constraint has invalid data (already removed)
+ ConstraintWrapperPtr aWrapper = aConstrIt->second.front();
+ anAttr[0] = aWrapper->entities().front()->baseAttribute();
+ anAttr[1] = aWrapper->entities().back()->baseAttribute();
}
- if (aNotCoinc.empty())
+
+ EntityWrapperPtr anEntities[2];
+ for (int i = 0; i < 2; ++i) {
+ std::map<AttributePtr, EntityWrapperPtr>::iterator
+ aFound = myAttributeMap.find(anAttr[i]);
+ if (aFound != myAttributeMap.end())
+ anEntities[i] = aFound->second;
+ }
+ mergeGroups(aCoincGroups, anEntities[0], anEntities[1]);
+ }
+
+ // Collect alone points and build them new instances
+ std::list<EntityWrapperPtr> aShutOffList;
+ BuilderPtr aBuilder = SketchSolver_Manager::instance()->builder();
+ std::map<EntityWrapperPtr, EntityWrapperPtr> aNotCoinc;
+ std::list<std::set<EntityWrapperPtr> >::iterator aGroupIt = aCoincGroups.begin();
+ while (aGroupIt != aCoincGroups.end()) {
+ if (aGroupIt->size() == 1) {
+ EntityWrapperPtr aPoint = *aGroupIt->begin();
+ aShutOffList.push_back(aPoint);
+ aNotCoinc[aPoint] =
+ aBuilder->createAttribute(aPoint->baseAttribute(), myGroupID, mySketchID);
+ std::list<std::set<EntityWrapperPtr> >::iterator aRemoveIt = aGroupIt++;
+ aCoincGroups.erase(aRemoveIt);
+ } else // point is not alone
+ ++aGroupIt;
+ }
+
+ if (aNotCoinc.empty() && aCoincGroups.size() == 1)
return false;
- std::list<EntityWrapperPtr>::const_iterator aNewPIt;
- for (aPIt = aPoints.begin(), aNewPIt = aNewPoints.begin();
- aPIt != aPoints.end(); ++aPIt, ++aNewPIt) {
- if (aNotCoinc.find(*aPIt) != aNotCoinc.end())
- aNotCoinc[*aPIt] = *aNewPIt;
+
+ // Find all features and constraints uses non-coincident points
+ replaceEntities(aNotCoinc);
+
+ // Remove not coincident points and points in separated groups
+ if (!aCoincGroups.empty()) {
+ aGroupIt = aCoincGroups.begin();
+ for (++aGroupIt; aGroupIt != aCoincGroups.end(); ++aGroupIt)
+ aShutOffList.insert(aShutOffList.end(), aGroupIt->begin(), aGroupIt->end());
+ }
+ std::list<EntityWrapperPtr>::iterator aNotCIt = aShutOffList.begin();
+ for (; aNotCIt != aShutOffList.end(); ++aNotCIt) {
+ if (aPtPtIt->second.size() <= 1) {
+ myCoincidentPoints.erase(aPtPtIt);
+ break;
+ }
+ if (aPtPtIt->first == *aNotCIt) {
+ std::set<EntityWrapperPtr> aSlaves = aPtPtIt->second;
+ EntityWrapperPtr aNewMaster = *aSlaves.begin();
+ aSlaves.erase(aSlaves.begin());
+ myCoincidentPoints.erase(aPtPtIt);
+ myCoincidentPoints[aNewMaster] = aSlaves;
+ aPtPtIt = myCoincidentPoints.find(aNewMaster);
+ } else
+ aPtPtIt->second.erase(*aNotCIt);
+ }
+
+ // Create additional groups of coincident points
+ aGroupIt = aCoincGroups.begin();
+ if (!aCoincGroups.empty())
+ ++aGroupIt;
+ for (; aGroupIt != aCoincGroups.end(); ++aGroupIt) {
+ aNotCoinc.clear();
+ std::set<EntityWrapperPtr>::iterator anEntIt = aGroupIt->begin();
+ for (; anEntIt != aGroupIt->end(); ++anEntIt) {
+ aNotCoinc[*anEntIt] =
+ aBuilder->createAttribute((*anEntIt)->baseAttribute(), myGroupID, mySketchID);
+ }
+ // replace points by newly created
+ replaceEntities(aNotCoinc);
+ // set new group of coincident points
+ EntityWrapperPtr aMasterEnt = aNotCoinc.begin()->second;
+ std::map<EntityWrapperPtr, EntityWrapperPtr>::iterator aNCIt = aNotCoinc.begin();
+ for (++aNCIt; aNCIt != aNotCoinc.end(); ++aNCIt)
+ addCoincidentPoints(aMasterEnt, aNCIt->second);
}
- // Find all features and constraints uses coincident points
- std::map<EntityWrapperPtr, EntityWrapperPtr>::iterator aNotCIt;
+ return true;
+}
+
+void SketchSolver_Storage::replaceEntities(const std::map<EntityWrapperPtr,
+ EntityWrapperPtr>& theChange)
+{
std::set<EntityWrapperPtr> anUpdFeatures;
+ std::map<EntityWrapperPtr, EntityWrapperPtr>::const_iterator aSubIt;
std::map<FeaturePtr, EntityWrapperPtr>::iterator aFIt = myFeatureMap.begin();
for (; aFIt != myFeatureMap.end(); ++aFIt) {
if (!aFIt->second)
continue; // avoid not completed arcs
- for (aNotCIt = aNotCoinc.begin(); aNotCIt != aNotCoinc.end(); ++aNotCIt) {
- if (!aNotCIt->second || !::isUsed(aFIt->first, aNotCIt->first->baseAttribute()))
+ for (aSubIt = theChange.begin(); aSubIt != theChange.end(); ++aSubIt) {
+ if (!aSubIt->second || !::isUsed(aFIt->first, aSubIt->first->baseAttribute()))
continue;
std::list<EntityWrapperPtr> aSubs = aFIt->second->subEntities();
std::list<EntityWrapperPtr>::iterator aSIt = aSubs.begin();
bool isUpd = false;
for (; aSIt != aSubs.end(); ++aSIt)
- if (*aSIt == aNotCIt->first) {
- (*aSIt)->update(aNotCIt->second);
+ if (*aSIt == aSubIt->first) {
+ (*aSIt)->update(aSubIt->second);
(*aSIt)->setGroup(aFIt->second->group());
isUpd = true;
}
std::set<EntityWrapperPtr>::iterator anUpdIt = anUpdFeatures.begin();
for (; anUpdIt != anUpdFeatures.end(); ++anUpdIt)
update(EntityWrapperPtr(*anUpdIt));
-
- // remove not coincident points
- for (aNotCIt = aNotCoinc.begin(); aNotCIt != aNotCoinc.end(); ++aNotCIt) {
- if (aPtPtIt->second.size() <= 1) {
- myCoincidentPoints.erase(aPtPtIt);
- break;
- }
- if (aPtPtIt->first == aNotCIt->first) {
- std::set<EntityWrapperPtr> aSlaves = aPtPtIt->second;
- EntityWrapperPtr aNewMaster = *aSlaves.begin();
- aSlaves.erase(aSlaves.begin());
- myCoincidentPoints.erase(aPtPtIt);
- myCoincidentPoints[aNewMaster] = aSlaves;
- aPtPtIt = myCoincidentPoints.find(aNewMaster);
- } else
- aPtPtIt->second.erase(aNotCIt->first);
- }
- return true;
}
bool SketchSolver_Storage::remove(ConstraintWrapperPtr theConstraint)
if (aBaseFeature)
isFullyRemoved = SketchSolver_Storage::removeEntity(aBaseFeature) && isFullyRemoved;
else
- isFullyRemoved = SketchSolver_Storage::removeEntity((*anIt)->baseAttribute()) && isFullyRemoved;
+ isFullyRemoved =
+ SketchSolver_Storage::removeEntity((*anIt)->baseAttribute()) && isFullyRemoved;
}
return isFullyRemoved;
}
if (!theAttribute)
return false;
- AttributeRefListPtr aRefList =
+ AttributeRefListPtr aRefList =
std::dynamic_pointer_cast<ModelAPI_AttributeRefList>(theAttribute);
if (aRefList) {
std::list<ObjectPtr> anObjects = aRefList->list();
return true;
}
- std::map<ConstraintPtr, std::list<ConstraintWrapperPtr> >::const_iterator aCIt = myConstraintMap.begin();
+ 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())
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() &&
+ 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
}
return true;
}
+
+void resultToFeatureOrAttribute(const ObjectPtr& theResult,
+ FeaturePtr& theFeature, AttributePtr& theAttribute)
+{
+ FeaturePtr aFeature = ModelAPI_Feature::feature(theResult);
+ // if the feature has several results, we choose which one is referred
+ const std::list<ResultPtr>& aResults = aFeature->results();
+ if (aResults.size() > 1 && theResult != aFeature->lastResult()) {
+ // actually, the attribute refers to center of arc or circle,
+ // but not the edge, get correct attributes
+ std::string anAttrName;
+ if (aFeature->getKind() == SketchPlugin_Arc::ID())
+ anAttrName = SketchPlugin_Arc::CENTER_ID();
+ else if (aFeature->getKind() == SketchPlugin_Circle::ID())
+ anAttrName = SketchPlugin_Circle::CENTER_ID();
+ if (!anAttrName.empty()) {
+ theAttribute = aFeature->attribute(anAttrName);
+ aFeature = FeaturePtr();
+ }
+ }
+ theFeature = aFeature;
+}
