1 #include <SketchSolver_Constraint.h>
2 #include <SketchSolver_Group.h>
3 #include <SketchSolver_Error.h>
5 #include <SketchPlugin_Arc.h>
6 #include <SketchPlugin_Circle.h>
7 #include <SketchPlugin_Line.h>
8 #include <SketchPlugin_Point.h>
10 #include <GeomDataAPI_Point.h>
11 #include <GeomDataAPI_Point2D.h>
12 #include <ModelAPI_AttributeDouble.h>
13 #include <ModelAPI_ResultConstruction.h>
16 SketchSolver_Constraint::SketchSolver_Constraint(
17 ConstraintPtr theConstraint)
18 : myBaseConstraint(theConstraint),
23 SketchSolver_Constraint::~SketchSolver_Constraint()
25 std::map<AttributePtr, Slvs_hParam>::const_iterator anIt1 = myValueMap.begin();
26 for (; anIt1 != myValueMap.end(); anIt1++)
27 myStorage->removeParameter(anIt1->second);
30 std::map<AttributePtr, Slvs_hEntity>::const_iterator anIt2 = myAttributeMap.begin();
31 for (; anIt2 != myAttributeMap.end(); anIt2++)
32 myStorage->removeEntity(anIt2->second);
33 myAttributeMap.clear();
35 std::map<FeaturePtr, Slvs_hEntity>::const_iterator anIt3 = myFeatureMap.begin();
36 for (; anIt3 != myFeatureMap.end(); anIt3++)
37 myStorage->removeEntity(anIt3->second);
40 std::vector<Slvs_hConstraint>::const_iterator anIt4 = mySlvsConstraints.begin();
41 for (; anIt4 != mySlvsConstraints.end(); anIt4++)
42 myStorage->removeConstraint(*anIt4);
43 mySlvsConstraints.clear();
46 void SketchSolver_Constraint::setStorage(StoragePtr theStorage)
48 myStorage = theStorage;
52 void SketchSolver_Constraint::setGroup(SketchSolver_Group* theGroup)
59 void SketchSolver_Constraint::process()
62 if (!myBaseConstraint || !myStorage || myGroup == 0) {
63 /// TODO: Put error message here
66 if (!mySlvsConstraints.empty()) // some data is changed, update constraint
67 update(myBaseConstraint);
69 int aConstrType = getType();
71 std::vector<Slvs_hEntity> anAttributes;
72 getAttributes(aValue, anAttributes);
73 if (!myErrorMsg.empty())
76 Slvs_hGroup aGroupID = myGroup->getId();
77 Slvs_hEntity aWorkplaneID = myGroup->getWorkplaneId();
78 Slvs_Constraint aConstraint;
79 if (mySlvsConstraints.empty())
80 aConstraint = Slvs_MakeConstraint(SLVS_C_UNKNOWN, aGroupID, aConstrType, aWorkplaneID,
81 aValue, anAttributes[0], anAttributes[1], anAttributes[2], anAttributes[3]);
83 aConstraint = myStorage->getConstraint(mySlvsConstraints[0]);
84 aConstraint.valA = aValue;
85 static const int aNbAttrs = 6;
86 Slvs_hEntity* aConstrAttrs[aNbAttrs] = {
87 &aConstraint.ptA, &aConstraint.ptB,
88 &aConstraint.entityA, &aConstraint.entityB,
89 &aConstraint.entityC, &aConstraint.entityD};
90 std::vector<Slvs_hEntity>::const_iterator anIter = anAttributes.begin();
91 for (int i = 0; i < aNbAttrs && anIter != anAttributes.end(); i++, anIter++)
92 *(aConstrAttrs[i]) = *anIter;
95 Slvs_hConstraint anID = myStorage->addConstraint(aConstraint);
96 if (mySlvsConstraints.empty())
97 mySlvsConstraints.push_back(anID);
99 mySlvsConstraints[0] = anID;
102 void SketchSolver_Constraint::update(ConstraintPtr theConstraint)
105 if (theConstraint && theConstraint != myBaseConstraint) {
106 if (theConstraint->getKind() != myBaseConstraint->getKind())
108 remove(myBaseConstraint);
109 myBaseConstraint = theConstraint;
114 std::map<FeaturePtr, Slvs_hEntity>::iterator aFeatIter = myFeatureMap.begin();
115 for (; aFeatIter != myFeatureMap.end(); aFeatIter++)
116 aFeatIter->second = changeEntity(aFeatIter->first, aType);
117 std::map<AttributePtr, Slvs_hEntity>::iterator anAttrIter = myAttributeMap.begin();
118 for (; anAttrIter != myAttributeMap.end(); anAttrIter++)
119 anAttrIter->second = changeEntity(anAttrIter->first, aType);
122 bool SketchSolver_Constraint::remove(ConstraintPtr theConstraint)
125 if (theConstraint && theConstraint != myBaseConstraint)
127 bool isFullyRemoved = myStorage->removeConstraint(mySlvsConstraints.front());
128 if (isFullyRemoved) {
129 myFeatureMap.clear();
130 myAttributeMap.clear();
133 cleanRemovedEntities();
137 void SketchSolver_Constraint::cleanRemovedEntities()
139 std::set<Slvs_hParam> aRemovedParams;
140 std::set<Slvs_hEntity> aRemovedEntities;
141 std::set<Slvs_hConstraint> aRemovedConstraints;
142 myStorage->getRemoved(aRemovedParams, aRemovedEntities, aRemovedConstraints);
143 std::map<FeaturePtr, Slvs_hEntity>::iterator aFeatIt = myFeatureMap.begin();
144 while (aFeatIt != myFeatureMap.end()) {
145 if (aRemovedEntities.find(aFeatIt->second) == aRemovedEntities.end()) {
149 std::map<FeaturePtr, Slvs_hEntity>::iterator aTmpIter = aFeatIt++;
150 myFeatureMap.erase(aTmpIter);
152 std::map<AttributePtr, Slvs_hEntity>::iterator anAttrIt = myAttributeMap.begin();
153 while (anAttrIt != myAttributeMap.end()) {
154 if (aRemovedEntities.find(anAttrIt->second) == aRemovedEntities.end()) {
158 std::map<AttributePtr, Slvs_hEntity>::iterator aTmpIter = anAttrIt++;
159 myAttributeMap.erase(aTmpIter);
161 std::map<AttributePtr, Slvs_hParam>::iterator aValIt = myValueMap.begin();
162 while (aValIt != myValueMap.end()) {
163 if (aRemovedParams.find(aValIt->second) == aRemovedParams.end()) {
167 std::map<AttributePtr, Slvs_hParam>::iterator aTmpIter = aValIt++;
168 myValueMap.erase(aTmpIter);
172 void SketchSolver_Constraint::getAttributes(
174 std::vector<Slvs_hEntity>& theAttributes)
176 static const int anInitNbOfAttr = 4;
177 theAttributes.assign(anInitNbOfAttr, SLVS_E_UNKNOWN);
179 DataPtr aData = myBaseConstraint->data();
181 AttributeDoublePtr aValueAttr = std::dynamic_pointer_cast<ModelAPI_AttributeDouble>(
182 aData->attribute(SketchPlugin_Constraint::VALUE()));
183 theValue = aValueAttr ? aValueAttr->value() : 0.0;
185 int aPtInd = 0; // index of first point in the list of attributes
186 int aEntInd = 2; // index of first antity in the list of attributes
187 std::list<AttributePtr> aConstrAttrs = aData->attributes(ModelAPI_AttributeRefAttr::typeId());
188 std::list<AttributePtr>::iterator anIter = aConstrAttrs.begin();
189 for (; anIter != aConstrAttrs.end(); anIter++) {
190 AttributeRefAttrPtr aRefAttr =
191 std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(*anIter);
192 if (!aRefAttr || !aRefAttr->isInitialized()) {
193 myErrorMsg = SketchSolver_Error::NOT_INITIALIZED();
197 int aType = SLVS_E_UNKNOWN; // type of created entity
198 Slvs_hEntity anEntity = myGroup->getAttributeId(aRefAttr);
199 if (anEntity == SLVS_E_UNKNOWN)
200 anEntity = changeEntity(aRefAttr, aType);
202 Slvs_Entity anEnt = myStorage->getEntity(anEntity);
206 if (aType == SLVS_E_UNKNOWN)
208 else if (aType == SLVS_E_POINT_IN_2D || aType == SLVS_E_POINT_IN_3D)
209 theAttributes[aPtInd++] = anEntity; // the point is created
210 else { // another entity (not a point) is created
211 if (aEntInd < anInitNbOfAttr)
212 theAttributes[aEntInd] = anEntity;
214 theAttributes.push_back(anEntity);
220 Slvs_hEntity SketchSolver_Constraint::changeEntity(AttributeRefAttrPtr theAttribute, int& theType)
222 // Convert the object of the attribute to the feature
224 if (theAttribute->isObject() && theAttribute->object()) {
225 ResultConstructionPtr aRC = std::dynamic_pointer_cast<ModelAPI_ResultConstruction>(
226 theAttribute->object());
228 myErrorMsg = SketchSolver_Error::NOT_INITIALIZED();
229 return SLVS_E_UNKNOWN;
231 std::shared_ptr<ModelAPI_Document> aDoc = aRC->document();
232 aFeature = aDoc->feature(aRC);
234 return changeEntity(aFeature, theType);
237 return changeEntity(theAttribute->attr(), theType);
240 Slvs_hEntity SketchSolver_Constraint::changeEntity(AttributePtr theEntity, int& theType)
242 Slvs_hEntity aResult = SLVS_E_UNKNOWN;
243 if (!theEntity->isInitialized())
244 return SLVS_E_UNKNOWN;
246 // If the entity is already in the group, try to find it
247 std::map<std::shared_ptr<ModelAPI_Attribute>, Slvs_hEntity>::const_iterator anEntIter =
248 myAttributeMap.find(theEntity);
249 Slvs_Entity aCurrentEntity;
250 aCurrentEntity.h = SLVS_E_UNKNOWN;
251 if (anEntIter != myAttributeMap.end())
252 aCurrentEntity = myStorage->getEntity(anEntIter->second);
254 aResult = myGroup->getAttributeId(theEntity);
255 if (aResult != SLVS_E_UNKNOWN) {
256 Slvs_Entity anEnt = myStorage->getEntity(aResult);
257 theType = anEnt.type;
262 Slvs_hGroup aGroupID = myGroup->getId();
264 std::shared_ptr<GeomDataAPI_Point> aPoint =
265 std::dynamic_pointer_cast<GeomDataAPI_Point>(theEntity);
267 double aXYZ[3] = {aPoint->x(), aPoint->y(), aPoint->z()};
268 Slvs_hParam aParams[3];
269 for (int i = 0; i < 3; i++) {
270 Slvs_Param aPar = aCurrentEntity.h != SLVS_E_UNKNOWN ?
271 myStorage->getParameter(aCurrentEntity.param[i]) :
272 Slvs_MakeParam(SLVS_E_UNKNOWN, aGroupID, 0.0);
274 aParams[i] = myStorage->addParameter(aPar);
277 if (aCurrentEntity.h == SLVS_E_UNKNOWN) // New entity
278 aCurrentEntity = Slvs_MakePoint3d(SLVS_E_UNKNOWN, aGroupID, aParams[0], aParams[1], aParams[2]);
279 else { // update entity data
280 for (int i = 0; i < 3; i++)
281 aCurrentEntity.param[i] = aParams[i];
283 aResult = myStorage->addEntity(aCurrentEntity);
285 // All entities except 3D points are created on workplane. So, if there is no workplane yet, then error
286 Slvs_hEntity aWorkplaneID = myGroup->getWorkplaneId();
287 if (aWorkplaneID == SLVS_E_UNKNOWN)
288 return SLVS_E_UNKNOWN;
291 std::shared_ptr<GeomDataAPI_Point2D> aPoint2D =
292 std::dynamic_pointer_cast<GeomDataAPI_Point2D>(theEntity);
294 double aXY[2] = {aPoint2D->x(), aPoint2D->y()};
295 Slvs_hParam aParams[2];
296 for (int i = 0; i < 2; i++) {
297 Slvs_Param aPar = aCurrentEntity.h != SLVS_E_UNKNOWN ?
298 myStorage->getParameter(aCurrentEntity.param[i]) :
299 Slvs_MakeParam(SLVS_E_UNKNOWN, aGroupID, 0.0);
301 aParams[i] = myStorage->addParameter(aPar);
304 if (aCurrentEntity.h == SLVS_E_UNKNOWN) // New entity
305 aCurrentEntity = Slvs_MakePoint2d(SLVS_E_UNKNOWN, aGroupID, aWorkplaneID, aParams[0], aParams[1]);
306 else { // update entity data
307 for (int i = 0; i < 2; i++)
308 aCurrentEntity.param[i] = aParams[i];
310 aResult = myStorage->addEntity(aCurrentEntity);
312 // Scalar value (used for the distance entities)
313 AttributeDoublePtr aScalar = std::dynamic_pointer_cast<ModelAPI_AttributeDouble>(theEntity);
315 Slvs_Param aParam = aCurrentEntity.h != SLVS_E_UNKNOWN ?
316 myStorage->getParameter(aCurrentEntity.param[0]) :
317 Slvs_MakeParam(SLVS_E_UNKNOWN, aGroupID, 0.0);
318 aParam.val = aScalar->value();
319 Slvs_hParam aValue = myStorage->addParameter(aParam);
321 if (aCurrentEntity.h == SLVS_E_UNKNOWN) // New entity
322 aCurrentEntity = Slvs_MakeDistance(SLVS_E_UNKNOWN, aGroupID, aWorkplaneID, aValue);
324 aCurrentEntity.param[0] = aValue;
325 aResult = myStorage->addEntity(aCurrentEntity);
330 myAttributeMap[theEntity] = aResult;
331 theType = aCurrentEntity.type;
335 Slvs_hEntity SketchSolver_Constraint::changeEntity(FeaturePtr theEntity, int& theType)
337 Slvs_hEntity aResult = SLVS_E_UNKNOWN;
338 if (!theEntity->data()->isValid())
339 return SLVS_E_UNKNOWN;
340 // If the entity is already in the group, try to find it
341 std::map<FeaturePtr, Slvs_hEntity>::const_iterator anEntIter = myFeatureMap.find(theEntity);
342 Slvs_Entity aCurrentEntity;
343 aCurrentEntity.h = SLVS_E_UNKNOWN;
344 if (anEntIter != myFeatureMap.end())
345 aCurrentEntity = myStorage->getEntity(anEntIter->second);
347 aResult = myGroup->getFeatureId(theEntity);
348 if (aResult != SLVS_E_UNKNOWN) {
349 Slvs_Entity anEnt = myStorage->getEntity(aResult);
350 theType = anEnt.type;
355 Slvs_hGroup aGroupID = myGroup->getId();
356 Slvs_hEntity aWorkplaneID = myGroup->getWorkplaneId();
357 // SketchPlugin features
358 std::shared_ptr<SketchPlugin_Feature> aFeature = std::dynamic_pointer_cast<
359 SketchPlugin_Feature>(theEntity);
360 if (aFeature) { // Verify the feature by its kind
361 const std::string& aFeatureKind = aFeature->getKind();
362 AttributePtr anAttribute;
366 if (aFeatureKind.compare(SketchPlugin_Line::ID()) == 0) {
367 anAttribute = aFeature->data()->attribute(SketchPlugin_Line::START_ID());
368 if (!anAttribute->isInitialized()) return SLVS_E_UNKNOWN;
369 Slvs_hEntity aStart = changeEntity(anAttribute, anAttrType);
371 anAttribute = aFeature->data()->attribute(SketchPlugin_Line::END_ID());
372 if (!anAttribute->isInitialized()) return SLVS_E_UNKNOWN;
373 Slvs_hEntity aEnd = changeEntity(anAttribute, anAttrType);
375 if (aCurrentEntity.h == SLVS_E_UNKNOWN) // New entity
376 aCurrentEntity = Slvs_MakeLineSegment(SLVS_E_UNKNOWN, aGroupID, aWorkplaneID, aStart, aEnd);
378 aCurrentEntity.point[0] = aStart;
379 aCurrentEntity.point[1] = aEnd;
381 aResult = myStorage->addEntity(aCurrentEntity);
384 else if (aFeatureKind.compare(SketchPlugin_Circle::ID()) == 0) {
385 anAttribute = aFeature->data()->attribute(SketchPlugin_Circle::CENTER_ID());
386 if (!anAttribute->isInitialized()) return SLVS_E_UNKNOWN;
387 Slvs_hEntity aCenter = changeEntity(anAttribute, anAttrType);
389 anAttribute = aFeature->data()->attribute(SketchPlugin_Circle::RADIUS_ID());
390 if (!anAttribute->isInitialized()) return SLVS_E_UNKNOWN;
391 Slvs_hEntity aRadius = changeEntity(anAttribute, anAttrType);
393 if (aCurrentEntity.h == SLVS_E_UNKNOWN) { // New entity
394 Slvs_Entity aWorkplane = myStorage->getEntity(aWorkplaneID);
395 aCurrentEntity = Slvs_MakeCircle(SLVS_E_UNKNOWN, aGroupID, aWorkplaneID,
396 aCenter, aWorkplane.normal, aRadius);
398 aCurrentEntity.point[0] = aCenter;
399 aCurrentEntity.distance = aRadius;
401 aResult = myStorage->addEntity(aCurrentEntity);
404 else if (aFeatureKind.compare(SketchPlugin_Arc::ID()) == 0) {
405 anAttribute = aFeature->data()->attribute(SketchPlugin_Arc::CENTER_ID());
406 if (!anAttribute->isInitialized()) return SLVS_E_UNKNOWN;
407 Slvs_hEntity aCenter = changeEntity(anAttribute, anAttrType);
409 anAttribute = aFeature->data()->attribute(SketchPlugin_Arc::START_ID());
410 if (!anAttribute->isInitialized()) return SLVS_E_UNKNOWN;
411 Slvs_hEntity aStart = changeEntity(anAttribute, anAttrType);
413 anAttribute = aFeature->data()->attribute(SketchPlugin_Arc::END_ID());
414 if (!anAttribute->isInitialized()) return SLVS_E_UNKNOWN;
415 Slvs_hEntity aEnd = changeEntity(anAttribute, anAttrType);
417 if (aCurrentEntity.h == SLVS_E_UNKNOWN) { // New entity
418 Slvs_Entity aWorkplane = myStorage->getEntity(aWorkplaneID);
419 aCurrentEntity = Slvs_MakeArcOfCircle(SLVS_E_UNKNOWN, aGroupID, aWorkplaneID,
420 aWorkplane.normal, aCenter, aStart, aEnd);
422 aCurrentEntity.point[0] = aCenter;
423 aCurrentEntity.point[1] = aStart;
424 aCurrentEntity.point[2] = aEnd;
426 aResult = myStorage->addEntity(aCurrentEntity);
428 // Point (it has low probability to be an attribute of constraint, so it is checked at the end)
429 else if (aFeatureKind.compare(SketchPlugin_Point::ID()) == 0) {
430 anAttribute = aFeature->data()->attribute(SketchPlugin_Point::COORD_ID());
431 if (!anAttribute->isInitialized()) return SLVS_E_UNKNOWN;
432 // Both the sketch point and its attribute (coordinates) link to the same SolveSpace point identifier
433 aResult = changeEntity(anAttribute, anAttrType);
434 aCurrentEntity.type = SLVS_E_POINT_IN_3D;
438 myFeatureMap[theEntity] = aResult;
439 theType = aCurrentEntity.type;
443 std::list<ConstraintPtr> SketchSolver_Constraint::constraints() const
445 std::list<ConstraintPtr> aConstraints;
446 aConstraints.push_back(myBaseConstraint);
450 void SketchSolver_Constraint::refresh()
453 std::map<AttributePtr, Slvs_hEntity>::iterator anAttrIter = myAttributeMap.begin();
454 for (; anAttrIter != myAttributeMap.end(); anAttrIter++) {
455 std::shared_ptr<GeomDataAPI_Point> aPoint =
456 std::dynamic_pointer_cast<GeomDataAPI_Point>(anAttrIter->first);
458 Slvs_Entity anEntity = myStorage->getEntity(anAttrIter->second);
460 for (int i = 0; i < 3; i++) {
461 Slvs_Param aPar = myStorage->getParameter(anEntity.param[i]);
464 aPoint->setValue(aXYZ[0], aXYZ[1], aXYZ[2]);
467 std::shared_ptr<GeomDataAPI_Point2D> aPoint2D =
468 std::dynamic_pointer_cast<GeomDataAPI_Point2D>(anAttrIter->first);
470 Slvs_Entity anEntity = myStorage->getEntity(anAttrIter->second);
472 for (int i = 0; i < 2; i++) {
473 Slvs_Param aPar = myStorage->getParameter(anEntity.param[i]);
476 aPoint2D->setValue(aXYZ[0], aXYZ[1]);
478 // Scalar value (used for the distance entities)
479 AttributeDoublePtr aScalar =
480 std::dynamic_pointer_cast<ModelAPI_AttributeDouble>(anAttrIter->first);
482 Slvs_Entity anEntity = myStorage->getEntity(anAttrIter->second);
483 Slvs_Param aPar = myStorage->getParameter(anEntity.param[0]);
484 aScalar->setValue(aPar.val);
490 std::map<AttributePtr, Slvs_hParam>::iterator aValIter = myValueMap.begin();
491 for (; aValIter != myValueMap.end(); aValIter++) {
492 AttributeDoublePtr aScalar =
493 std::dynamic_pointer_cast<ModelAPI_AttributeDouble>(anAttrIter->first);
495 Slvs_Param aPar = myStorage->getParameter(anAttrIter->second);
496 aScalar->setValue(aPar.val);
501 Slvs_hEntity SketchSolver_Constraint::getId(FeaturePtr theFeature) const
503 std::map<FeaturePtr, Slvs_hEntity>::const_iterator aFIter = myFeatureMap.find(theFeature);
504 if (aFIter == myFeatureMap.end())
505 return SLVS_E_UNKNOWN;
506 return aFIter->second;
509 Slvs_hEntity SketchSolver_Constraint::getId(AttributePtr theAttribute) const
511 std::map<AttributePtr, Slvs_hEntity>::const_iterator anAttrIter = myAttributeMap.find(theAttribute);
512 if (anAttrIter == myAttributeMap.end())
513 return SLVS_E_UNKNOWN;
514 return anAttrIter->second;