#include <SketchPlugin_Circle.h>
#include <SketchPlugin_ConstraintRigid.h>
#include <SketchPlugin_Line.h>
+#include <SketchPlugin_Point.h>
#include <GeomAPI_Pnt2d.h>
#include <GeomAPI_XY.h>
#include <GeomDataAPI_Point2D.h>
#include <ModelAPI_AttributeDouble.h>
+#include <math.h>
+
SketchSolver_ConstraintRigid::SketchSolver_ConstraintRigid(FeaturePtr theFeature)
: SketchSolver_Constraint(),
myBaseFeature(theFeature)
double aValue;
std::vector<Slvs_hEntity> anEntities;
getAttributes(aValue, anEntities);
- if (!myErrorMsg.empty() || myFeatureMap.empty())
+ if (!myErrorMsg.empty() || (myFeatureMap.empty() && myAttributeMap.empty()))
+ return;
+ fixFeature();
+}
+
+void SketchSolver_ConstraintRigid::fixFeature()
+{
+ Slvs_hEntity anEntID;
+ if (!myFeatureMap.empty())
+ anEntID = myFeatureMap.begin()->second;
+ else
+ anEntID = myAttributeMap.begin()->second;
+ if (myStorage->isEntityFixed(anEntID, true)) {
+ myErrorMsg = SketchSolver_Error::ALREADY_FIXED();
return;
+ }
- if (myFeatureMap.begin()->first->getKind() == SketchPlugin_Line::ID()) {
- Slvs_Entity aLine = myStorage->getEntity(myFeatureMap.begin()->second);
+ std::string aKind;
+ if (!myFeatureMap.empty())
+ aKind = myFeatureMap.begin()->first->getKind();
+ else
+ aKind = myAttributeMap.begin()->first->attributeType();
+
+ if (aKind == SketchPlugin_Line::ID()) {
+ Slvs_Entity aLine = myStorage->getEntity(anEntID);
fixLine(aLine);
}
- else if (myFeatureMap.begin()->first->getKind() == SketchPlugin_Arc::ID()) {
- Slvs_Entity anArc = myStorage->getEntity(myFeatureMap.begin()->second);
+ else if (aKind == SketchPlugin_Arc::ID()) {
+ Slvs_Entity anArc = myStorage->getEntity(anEntID);
fixArc(anArc);
}
- else if (myFeatureMap.begin()->first->getKind() == SketchPlugin_Circle::ID()) {
- Slvs_Entity aCirc = myStorage->getEntity(myFeatureMap.begin()->second);
- fixArc(aCirc);
+ else if (aKind == SketchPlugin_Circle::ID()) {
+ Slvs_Entity aCirc = myStorage->getEntity(anEntID);
+ fixCircle(aCirc);
+ }
+ else if (aKind == SketchPlugin_Point::ID() || aKind == GeomDataAPI_Point2D::typeId()) {
+ fixPoint(anEntID);
}
}
return;
Slvs_Constraint aConstraint;
- Slvs_hConstraint aConstrID = myStorage->isPointFixed(thePointID);
- bool isForceUpdate = (aConstrID != SLVS_E_UNKNOWN && !myBaseConstraint &&
+ Slvs_hConstraint aConstrID = SLVS_E_UNKNOWN;
+ bool isFixed = myStorage->isPointFixed(thePointID, aConstrID, true);
+ bool isForceUpdate = (isFixed && !myBaseConstraint &&
myStorage->isTemporary(aConstrID));
if (!isForceUpdate) { // create new constraint
- if (aConstrID != SLVS_E_UNKNOWN)
- return; // the coincident point is already fixed
+ if (isFixed) return;
aConstraint = Slvs_MakeConstraint(SLVS_E_UNKNOWN, myGroup->getId(), getType(), myGroup->getWorkplaneId(),
0.0, thePointID, SLVS_E_UNKNOWN, SLVS_E_UNKNOWN, SLVS_E_UNKNOWN);
aConstraint.h = myStorage->addConstraint(aConstraint);
if (!myBaseConstraint)
myStorage->addConstraintWhereDragged(aConstraint.h);
} else { // update already existent constraint
- if (aConstrID == SLVS_E_UNKNOWN || myBaseConstraint)
+ if (!isFixed || aConstrID == SLVS_E_UNKNOWN || myBaseConstraint)
return;
aConstraint = myStorage->getConstraint(aConstrID);
aConstraint.ptA = thePointID;
void SketchSolver_ConstraintRigid::fixLine(const Slvs_Entity& theLine)
{
Slvs_Constraint anEqual;
- if (isUsedInEqual(theLine, anEqual)) {
+ if (isAxisParallel(theLine)) {
+ // Fix one point and a line length
+ Slvs_hConstraint aFixed;
+ if (!myStorage->isPointFixed(theLine.point[0], aFixed, true) &&
+ !myStorage->isPointFixed(theLine.point[1], aFixed, true))
+ fixPoint(theLine.point[0]);
+ if (!isUsedInEqual(theLine, anEqual)) {
+ // Check the distance is not set yet
+ std::list<Slvs_Constraint> aDistConstr = myStorage->getConstraintsByType(SLVS_C_PT_PT_DISTANCE);
+ std::list<Slvs_Constraint>::const_iterator aDIt = aDistConstr.begin();
+ for (; aDIt != aDistConstr.end(); aDIt++)
+ if ((aDIt->ptA == theLine.point[0] && aDIt->ptB == theLine.point[1]) ||
+ (aDIt->ptA == theLine.point[1] && aDIt->ptB == theLine.point[0]))
+ return;
+ // Calculate distance between points on the line
+ double aCoords[4];
+ for (int i = 0; i < 2; i++) {
+ Slvs_Entity aPnt = myStorage->getEntity(theLine.point[i]);
+ for (int j = 0; j < 2; j++) {
+ Slvs_Param aParam = myStorage->getParameter(aPnt.param[j]);
+ aCoords[2*i+j] = aParam.val;
+ }
+ }
+ double aLength = sqrt((aCoords[2] - aCoords[0]) * (aCoords[2] - aCoords[0]) +
+ (aCoords[3] - aCoords[1]) * (aCoords[3] - aCoords[1]));
+ // fix line length
+ Slvs_Constraint aDistance = Slvs_MakeConstraint(SLVS_E_UNKNOWN, myGroup->getId(),
+ SLVS_C_PT_PT_DISTANCE, myGroup->getWorkplaneId(), aLength,
+ theLine.point[0], theLine.point[1], SLVS_E_UNKNOWN, SLVS_E_UNKNOWN);
+ aDistance.h = myStorage->addConstraint(aDistance);
+ mySlvsConstraints.push_back(aDistance.h);
+ }
+ return;
+ }
+ else if (isUsedInEqual(theLine, anEqual)) {
// Check another entity of Equal is already fixed
Slvs_hEntity anOtherEntID = anEqual.entityA == theLine.h ? anEqual.entityB : anEqual.entityA;
- Slvs_Entity anOtherEntity = myStorage->getEntity(anOtherEntID);
- if (isFixed(anOtherEntity)) {
+ if (myStorage->isEntityFixed(anOtherEntID, true)) {
// Fix start point of the line (if end point is not fixed yet) ...
- Slvs_hConstraint anEndFixedID = myStorage->isPointFixed(theLine.point[1]);
- if (anEndFixedID == SLVS_E_UNKNOWN)
+ Slvs_hConstraint anEndFixedID = SLVS_E_UNKNOWN;
+ bool isFixed = myStorage->isPointFixed(theLine.point[1], anEndFixedID, true);
+ if (isFixed == SLVS_E_UNKNOWN)
fixPoint(theLine.point[0]);
// ... and create fixed point lying on this line
Slvs_hEntity aPointToCopy = anEndFixedID == SLVS_E_UNKNOWN ? theLine.point[1] : theLine.point[0];
std::list<Slvs_Constraint>::const_iterator aPLIter = aPonLineList.begin();
for (; aPLIter != aPonLineList.end() && !isPonLineFixed; aPLIter++)
if (aPLIter->entityA == theLine.h) {
- isPonLineFixed = (myStorage->isPointFixed(aPLIter->ptA) != SLVS_E_UNKNOWN);
+ isPonLineFixed = myStorage->isPointFixed(aPLIter->ptA, anEndFixedID);
aFixedPoint = aPLIter->ptA;
}
if (isUsedInEqual(theCircle, anEqual)) {
// Check another entity of Equal is already fixed
Slvs_hEntity anOtherEntID = anEqual.entityA == theCircle.h ? anEqual.entityB : anEqual.entityA;
- Slvs_Entity anOtherEntity = myStorage->getEntity(anOtherEntID);
- if (isFixed(anOtherEntity))
+ if (myStorage->isEntityFixed(anOtherEntID, true))
isFixRadius = false;
}
fixPoint(theCircle.point[0]);
if (isFixRadius) {
+ // Search the radius is already fixed
+ std::list<Slvs_Constraint> aDiamConstr = myStorage->getConstraintsByType(SLVS_C_DIAMETER);
+ std::list<Slvs_Constraint>::const_iterator aDiamIter = aDiamConstr.begin();
+ for (; aDiamIter != aDiamConstr.end(); aDiamIter++)
+ if (aDiamIter->entityA == theCircle.h)
+ return;
+
// Fix radius of a circle
AttributeDoublePtr aRadiusAttr = std::dynamic_pointer_cast<ModelAPI_AttributeDouble>(
myFeatureMap.begin()->first->attribute(SketchPlugin_Circle::RADIUS_ID()));
if (isUsedInEqual(theArc, anEqual)) {
// Check another entity of Equal is already fixed
Slvs_hEntity anOtherEntID = anEqual.entityA == theArc.h ? anEqual.entityB : anEqual.entityA;
- Slvs_Entity anOtherEntity = myStorage->getEntity(anOtherEntID);
- if (isFixed(anOtherEntity)) {
+ if (myStorage->isEntityFixed(anOtherEntID, true)) {
isFixRadius = false;
+ Slvs_Entity anOtherEntity = myStorage->getEntity(anOtherEntID);
if (anOtherEntity.type == SLVS_E_LINE_SEGMENT) {
aPointsToFix.pop_back();
aPointsToFix.push_back(theArc.point[0]);
}
}
- Slvs_hConstraint aConstrID = myStorage->isPointFixed(theArc.point[0]);
+ Slvs_hConstraint aConstrID;
int aNbPointsToFix = 2; // number of fixed points for the arc
- if (aConstrID != SLVS_E_UNKNOWN)
+ if (myStorage->isPointFixed(theArc.point[0], aConstrID, true))
aNbPointsToFix--;
// Radius of the arc
std::list<Slvs_Constraint> aDiamConstraints = myStorage->getConstraintsByType(SLVS_C_DIAMETER);
std::list<Slvs_Constraint>::iterator anIt = aDiamConstraints.begin();
for (; anIt != aDiamConstraints.end() && !isExists; anIt++)
- if (anIt->entityA == myFeatureMap.begin()->second)
+ if (anIt->entityA == theArc.h)
isExists = true;
if (!isExists) {
Slvs_Constraint aFixedR = Slvs_MakeConstraint(SLVS_E_UNKNOWN, myGroup->getId(), SLVS_C_DIAMETER,
return false;
}
-bool SketchSolver_ConstraintRigid::isFixed(const Slvs_Entity& theEntity) const
+bool SketchSolver_ConstraintRigid::isAxisParallel(const Slvs_Entity& theEntity) const
{
- if (theEntity.type == SLVS_E_POINT_IN_2D)
- return myStorage->isPointFixed(theEntity.h) != SLVS_E_UNKNOWN;
-
- // Check all the points of entity are fixed
- int aNbFixed = 0;
- for (int i = 0; i < 4; i++) {
- if (theEntity.point[i] != SLVS_E_UNKNOWN &&
- myStorage->isPointFixed(theEntity.point[i]) != SLVS_E_UNKNOWN)
- aNbFixed++;
- }
+ std::list<Slvs_Constraint> aConstr = myStorage->getConstraintsByType(SLVS_C_HORIZONTAL);
+ std::list<Slvs_Constraint> aVert = myStorage->getConstraintsByType(SLVS_C_VERTICAL);
+ aConstr.insert(aConstr.end(), aVert.begin(), aVert.end());
- switch (theEntity.type) {
- case SLVS_E_LINE_SEGMENT:
- case SLVS_E_ARC_OF_CIRCLE:
- if (aNbFixed == 2) return true;
- case SLVS_E_CIRCLE:
- if (aNbFixed == 1) return true;
- }
+ std::list<Slvs_Constraint>::const_iterator anIter = aConstr.begin();
+ for (; anIter != aConstr.end(); anIter++)
+ if (anIter->entityA == theEntity.h)
+ return true;
return false;
}
-