-// Copyright (C) 2014-20xx CEA/DEN, EDF R&D
-
-// File: SolveSpaceSolver_Storage.cpp
-// Created: 18 Mar 2015
-// Author: Artem ZHIDKOV
+// Copyright (C) 2014-2019 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
+// 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 <SolveSpaceSolver_Storage.h>
#include <SolveSpaceSolver_ConstraintWrapper.h>
#include <ModelAPI_AttributeDouble.h>
#include <ModelAPI_AttributeRefAttr.h>
#include <SketchPlugin_Arc.h>
-#include <SketchPlugin_ConstraintCoincidence.h>
+#include <SketchPlugin_ConstraintMiddle.h>
/** \brief Search the entity/parameter with specified ID in the list of elements
* \param[in] theEntityID unique ID of the element
/// \brief Compare two entities to be different
static bool IsNotEqual(const Slvs_Entity& theEntity1, const Slvs_Entity& theEntity2);
/// \brief Compare two constraints to be different
-static bool IsNotEqual(const Slvs_Constraint& theConstraint1, const Slvs_Constraint& theConstraint2);
+static bool IsNotEqual(const Slvs_Constraint& theConstraint1,
+ const Slvs_Constraint& theConstraint2);
SolveSpaceSolver_Storage::SolveSpaceSolver_Storage(const GroupID& theGroup)
std::list<EntityWrapperPtr>::iterator anIt = anEntities.begin();
for (; anIt != anEntities.end(); ++anIt) {
isUpdated = update(*anIt) || isUpdated;
- // do not update constrained entities for Multi constraints
- if (aSlvsConstr.type == SLVS_C_MULTI_ROTATION || aSlvsConstr.type == SLVS_C_MULTI_TRANSLATION)
+ // do not update constrained entities for Multi constraints,
+ // and for middle point constraint translated to equal lines
+ ConstraintPtr aBaseConstraint = theConstraint->baseConstraint();
+ if (aSlvsConstr.type == SLVS_C_MULTI_ROTATION || aSlvsConstr.type == SLVS_C_MULTI_TRANSLATION ||
+ (aBaseConstraint && aBaseConstraint->getKind() == SketchPlugin_ConstraintMiddle::ID() &&
+ aSlvsConstr.type != SLVS_C_AT_MIDPOINT))
continue;
Slvs_hEntity anID = (Slvs_hEntity)(*anIt)->id();
bool SolveSpaceSolver_Storage::update(EntityWrapperPtr theEntity)
{
bool isUpdated = false;
- std::shared_ptr<SolveSpaceSolver_EntityWrapper> anEntity =
+ std::shared_ptr<SolveSpaceSolver_EntityWrapper> anEntity =
std::dynamic_pointer_cast<SolveSpaceSolver_EntityWrapper>(theEntity);
Slvs_Entity aSlvsEnt = getEntity((Slvs_hEntity)anEntity->id());
if (aSlvsEnt.h == SLVS_E_UNKNOWN)
bool SolveSpaceSolver_Storage::update(ParameterWrapperPtr theParameter)
{
- std::shared_ptr<SolveSpaceSolver_ParameterWrapper> aParameter =
+ std::shared_ptr<SolveSpaceSolver_ParameterWrapper> aParameter =
std::dynamic_pointer_cast<SolveSpaceSolver_ParameterWrapper>(theParameter);
const Slvs_Param& aParam = getParameter((Slvs_hParam)aParameter->id());
if (aParam.h != SLVS_E_UNKNOWN && fabs(aParam.val - aParameter->value()) < tolerance)
return false;
Slvs_Param aParamToUpd = aParameter->parameter();
if (aParamToUpd.group == SLVS_G_UNKNOWN)
- aParamToUpd.group = aParameter->isParametric() ? (Slvs_hGroup)GID_OUTOFGROUP : (Slvs_hGroup)myGroupID;
+ aParamToUpd.group = aParameter->isParametric() ? (Slvs_hGroup)GID_OUTOFGROUP :
+ (Slvs_hGroup)myGroupID;
Slvs_hParam anID = updateParameter(aParamToUpd);
if (aParam.h == SLVS_E_UNKNOWN) // new parameter
aParameter->changeParameter() = getParameter(anID);
void SolveSpaceSolver_Storage::storeWorkplane(EntityWrapperPtr theSketch)
{
- myWorkplaneID = (Slvs_hEntity)theSketch->id();
+ mySketchID = theSketch->id();
+ myWorkplaneID = (Slvs_hEntity)mySketchID;
// Update sub-entities of the sketch
std::list<EntityWrapperPtr> aSubEntities = theSketch->subEntities();
for (; aSIt != aSubs.end(); ++aSIt)
changeGroup(*aSIt, theGroup);
- if (theEntity->group() != theGroup) {
- theEntity->setGroup(theGroup);
- int aPos = Search((Slvs_hEntity)theEntity->id(), myEntities);
- if (aPos >= 0 && aPos < (int)myEntities.size()) {
- myEntities[aPos].group = (Slvs_hGroup)theGroup;
+ theEntity->setGroup(theGroup);
+ int aPos = Search((Slvs_hEntity)theEntity->id(), myEntities);
+ if (aPos >= 0 && aPos < (int)myEntities.size()) {
+ if (myEntities[aPos].group != (Slvs_hGroup)theGroup)
setNeedToResolve(true);
- }
+ myEntities[aPos].group = (Slvs_hGroup)theGroup;
}
}
if (theMaster->id() != theSlave->id())
removeEntity((Slvs_hEntity)theSlave->id());
- std::shared_ptr<SolveSpaceSolver_EntityWrapper> aPointMaster =
+ std::shared_ptr<SolveSpaceSolver_EntityWrapper> aPointMaster =
std::dynamic_pointer_cast<SolveSpaceSolver_EntityWrapper>(theMaster);
- std::shared_ptr<SolveSpaceSolver_EntityWrapper> aPointSlave =
+ std::shared_ptr<SolveSpaceSolver_EntityWrapper> aPointSlave =
std::dynamic_pointer_cast<SolveSpaceSolver_EntityWrapper>(theSlave);
aPointSlave->changeEntity() = aPointMaster->entity();
aPointSlave->setParameters(aPointMaster->parameters());
addSameConstraints(*aCIt2, aWrapper);
break;
}
- } else
+ } else
aConstr.h = updateConstraint(aConstr);
aWrapper->changeConstraint() = aConstr;
theX = anArcPoint[0][0] + anArcPoint[2][0];
theY = anArcPoint[0][1] + anArcPoint[2][1];
} else {
- std::shared_ptr<GeomAPI_Dir2d> aStartDir(new GeomAPI_Dir2d(anArcPoint[1][0], anArcPoint[1][1]));
- std::shared_ptr<GeomAPI_Dir2d> aEndDir(new GeomAPI_Dir2d(anArcPoint[2][0], anArcPoint[2][1]));
+ std::shared_ptr<GeomAPI_Dir2d>
+ aStartDir(new GeomAPI_Dir2d(anArcPoint[1][0], anArcPoint[1][1]));
+ std::shared_ptr<GeomAPI_Dir2d>
+ aEndDir(new GeomAPI_Dir2d(anArcPoint[2][0], anArcPoint[2][1]));
double anAngle = aStartDir->angle(aEndDir);
if (anAngle < 0)
anAngle += 2.0 * PI;
myEntities.erase(myEntities.begin() + aPos);
myEntityMaxID = myEntities.empty() ? SLVS_E_UNKNOWN : myEntities.back().h;
if (anEntity.distance != SLVS_E_UNKNOWN)
- aResult = aResult && removeParameter(anEntity.distance);
+ aResult = aResult && removeEntity(anEntity.distance);
for (int i = 0; i < 4; i++)
if (anEntity.param[i] != SLVS_E_UNKNOWN)
aResult = removeParameter(anEntity.param[i]) && aResult;
Slvs_Entity aNewLine2 = Slvs_MakeLineSegment(SLVS_E_UNKNOWN, (Slvs_hGroup)myGroupID,
myWorkplaneID, aLine.point[1], aConstraint.ptA);
aNewLine2.h = addEntity(aNewLine2);
- aConstraint = Slvs_MakeConstraint(SLVS_E_UNKNOWN, (Slvs_hGroup)myGroupID, SLVS_C_EQUAL_LENGTH_LINES,
+ aConstraint = Slvs_MakeConstraint(SLVS_E_UNKNOWN, (Slvs_hGroup)myGroupID,
+ SLVS_C_EQUAL_LENGTH_LINES,
myWorkplaneID, 0.0, SLVS_E_UNKNOWN, SLVS_E_UNKNOWN, aNewLine1.h, aNewLine2.h);
}
}
return true;
}
-const Slvs_Constraint& SolveSpaceSolver_Storage::getConstraint(const Slvs_hConstraint& theConstraintID) const
+const Slvs_Constraint& SolveSpaceSolver_Storage::
+ getConstraint(const Slvs_hConstraint& theConstraintID) const
{
int aPos = Search(theConstraintID, myConstraints);
if (aPos >= 0 && aPos < (int)myConstraints.size())
}
-bool SolveSpaceSolver_Storage::removeCoincidence(ConstraintWrapperPtr theConstraint)
-{
- std::list<EntityWrapperPtr> aPoints = theConstraint->entities();
- std::list<EntityWrapperPtr>::const_iterator aPIt;
-
- CoincidentPointsMap::iterator aPtPtIt = myCoincidentPoints.begin();
- for (; aPtPtIt != myCoincidentPoints.end(); ++aPtPtIt) {
- for (aPIt = aPoints.begin(); aPIt != aPoints.end(); ++aPIt)
- if (aPtPtIt->first == *aPIt ||
- aPtPtIt->second.find(*aPIt) != aPtPtIt->second.end())
- break;
- if (aPIt != aPoints.end())
- break;
- }
-
- if (aPtPtIt == myCoincidentPoints.end())
- return true; // already removed
-
- // Create new copies of coincident points
- BuilderPtr aBuilder = SolveSpaceSolver_Builder::getInstance();
- std::list<EntityWrapperPtr> aNewPoints;
- for (aPIt = aPoints.begin(); aPIt != aPoints.end(); ++aPIt)
- aNewPoints.push_back(aBuilder->createAttribute(
- (*aPIt)->baseAttribute(), myGroupID, myWorkplaneID));
-
- // Find all points fallen out of group of coincident points
- std::map<EntityWrapperPtr, EntityWrapperPtr> aNotCoinc;
- aNotCoinc[aPtPtIt->first] = EntityWrapperPtr();
- std::set<EntityWrapperPtr>::const_iterator aTempIt = aPtPtIt->second.begin();
- for (; aTempIt != aPtPtIt->second.end(); ++aTempIt)
- aNotCoinc[*aTempIt] = EntityWrapperPtr();
- std::map<ConstraintPtr, std::list<ConstraintWrapperPtr> >::iterator
- aConstrIt = myConstraintMap.begin();
- for (; aConstrIt != myConstraintMap.end(); ++aConstrIt)
- if (aConstrIt->first->getKind() == SketchPlugin_ConstraintCoincidence::ID()) {
- AttributeRefAttrPtr aRefAttrA = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(
- aConstrIt->first->attribute(SketchPlugin_Constraint::ENTITY_A()));
- AttributeRefAttrPtr aRefAttrB = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(
- aConstrIt->first->attribute(SketchPlugin_Constraint::ENTITY_B()));
- AttributePtr anAttrA, anAttrB;
- if (aConstrIt->first->data()->isValid()) {
- if (!aRefAttrA || !aRefAttrB || aRefAttrA->isObject() || aRefAttrB->isObject())
- continue;
- anAttrA = aRefAttrA->attr();
- anAttrB = aRefAttrB->attr();
- } else {
- // obtain attributes from the constraint wrapper
- ConstraintWrapperPtr aWrapper = aConstrIt->second.front();
- anAttrA = aWrapper->entities().front()->baseAttribute();
- anAttrB = aWrapper->entities().back()->baseAttribute();
- }
- std::map<AttributePtr, EntityWrapperPtr>::iterator
- aFound = myAttributeMap.find(anAttrA);
- if (aFound != myAttributeMap.end())
- aNotCoinc.erase(aFound->second);
- aFound = myAttributeMap.find(anAttrB);
- if (aFound != myAttributeMap.end())
- aNotCoinc.erase(aFound->second);
- }
- if (aNotCoinc.empty())
- 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 coincident points
- std::map<EntityWrapperPtr, EntityWrapperPtr>::iterator aNotCIt;
- std::set<EntityWrapperPtr> anUpdFeatures;
- 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 || !aFIt->second->isUsed(aNotCIt->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 = aNotCIt->second;
- isUpd = true;
- }
- if (isUpd) {
- aFIt->second->setSubEntities(aSubs);
- anUpdFeatures.insert(aFIt->second);
- }
- }
- }
- // update features
- 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 SolveSpaceSolver_Storage::remove(ConstraintWrapperPtr theConstraint)
{
std::shared_ptr<SolveSpaceSolver_ConstraintWrapper> aConstraint =
}
}
- std::shared_ptr<SolveSpaceSolver_EntityWrapper> anEntity =
+ std::shared_ptr<SolveSpaceSolver_EntityWrapper> anEntity =
std::dynamic_pointer_cast<SolveSpaceSolver_EntityWrapper>(theEntity);
bool isFullyRemoved = isCoincide ? true : removeEntity((Slvs_hEntity)anEntity->id());
return (SketchSolver_Storage::remove(theEntity) || isCoincide) && isFullyRemoved;
for (; anIt != myAttributeMap.end(); ++anIt) {
if (!anIt->second)
continue;
- // the external feature always should keep the up to date values, so,
+ // the external feature always should keep the up to date values, so,
// refresh from the solver is never needed
if (anIt->first.get()) {
- std::shared_ptr<SketchPlugin_Feature> aSketchFeature =
+ std::shared_ptr<SketchPlugin_Feature> aSketchFeature =
std::dynamic_pointer_cast<SketchPlugin_Feature>(anIt->first->owner());
if (aSketchFeature.get() && aSketchFeature->isExternal())
continue;
bool isUpd[3] = {false};
int i = 0;
for (aParIt = aParams.begin(); i < 3 && aParIt != aParams.end(); ++aParIt, ++i) {
- std::shared_ptr<SolveSpaceSolver_ParameterWrapper> aWrapper =
+ std::shared_ptr<SolveSpaceSolver_ParameterWrapper> aWrapper =
std::dynamic_pointer_cast<SolveSpaceSolver_ParameterWrapper>(*aParIt);
if (!theFixedOnly || aWrapper->group() == GID_OUTOFGROUP || aWrapper->isParametric()) {
aWrapper->changeParameter().val = getParameter((Slvs_hParam)aWrapper->id()).val;
aPoint2D->setValue(aCoords[0], aCoords[1]);
// Find points coincident with this one (probably not in GID_OUTOFGROUP)
std::map<AttributePtr, EntityWrapperPtr>::const_iterator aLocIt;
- if (theFixedOnly)
+ if (theFixedOnly)
aLocIt = myAttributeMap.begin();
else {
aLocIt = anIt;
for (; aLocIt != myAttributeMap.end(); ++aLocIt) {
if (!aLocIt->second)
continue;
- std::shared_ptr<SketchPlugin_Feature> aSketchFeature =
+ std::shared_ptr<SketchPlugin_Feature> aSketchFeature =
std::dynamic_pointer_cast<SketchPlugin_Feature>(aLocIt->first->owner());
if (aSketchFeature && aSketchFeature->isExternal())
continue;
if (i > 0) {
anArcPoints[i][0] -= anArcPoints[0][0];
anArcPoints[i][1] -= anArcPoints[0][1];
- aDist[i] = sqrt(anArcPoints[i][0] * anArcPoints[i][0] +
+ aDist[i] = sqrt(anArcPoints[i][0] * anArcPoints[i][0] +
anArcPoints[i][1] * anArcPoints[i][1]);
}
}
