1 #include <SketchSolver_ConstraintMultiTranslation.h>
2 #include <SketchSolver_Group.h>
3 #include <SketchSolver_Error.h>
5 #include <SketchPlugin_Arc.h>
6 #include <SketchPlugin_MultiTranslation.h>
8 #include <ModelAPI_AttributeDouble.h>
9 #include <ModelAPI_AttributeInteger.h>
10 #include <ModelAPI_AttributeRefAttr.h>
11 #include <ModelAPI_AttributeRefList.h>
12 #include <ModelAPI_ResultConstruction.h>
13 #include <ModelAPI_Data.h>
15 #include <GeomAPI_Dir2d.h>
16 #include <GeomAPI_XY.h>
21 void SketchSolver_ConstraintMultiTranslation::getAttributes(
22 Slvs_hEntity& theStartPoint, Slvs_hEntity& theEndPoint,
23 std::vector< std::vector<Slvs_hEntity> >& thePoints,
24 std::vector< std::vector<Slvs_hEntity> >& theEntities)
26 DataPtr aData = myBaseConstraint->data();
27 AttributePtr aStartPointAttr = aData->attribute(SketchPlugin_MultiTranslation::START_POINT_ID());
28 AttributePtr aEndPointAttr = aData->attribute(SketchPlugin_MultiTranslation::END_POINT_ID());
29 if (!aStartPointAttr || !aStartPointAttr->isInitialized() ||
30 !aEndPointAttr || !aEndPointAttr->isInitialized()) {
31 myErrorMsg = SketchSolver_Error::NOT_INITIALIZED();
35 int aType = SLVS_E_UNKNOWN; // type of created entity
36 Slvs_hEntity anEntityID = myGroup->getAttributeId(aStartPointAttr);
37 if (anEntityID == SLVS_E_UNKNOWN)
38 anEntityID = changeEntity(aStartPointAttr, aType);
39 theStartPoint = anEntityID;
40 anEntityID = myGroup->getAttributeId(aEndPointAttr);
41 if (anEntityID == SLVS_E_UNKNOWN)
42 anEntityID = changeEntity(aEndPointAttr, aType);
43 theEndPoint = anEntityID;
45 // Lists of objects and number of copies
46 AttributeRefListPtr anInitialRefList = std::dynamic_pointer_cast<ModelAPI_AttributeRefList>(
47 aData->attribute(SketchPlugin_Constraint::ENTITY_A()));
48 myNumberOfObjects = anInitialRefList->size();
49 myNumberOfCopies = (size_t) aData->integer(SketchPlugin_MultiTranslation::NUMBER_OF_COPIES_ID())->value();
50 AttributeRefListPtr aRefList = std::dynamic_pointer_cast<ModelAPI_AttributeRefList>(
51 myBaseConstraint->attribute(SketchPlugin_Constraint::ENTITY_B()));
53 myErrorMsg = SketchSolver_Error::INCORRECT_ATTRIBUTE();
57 // Obtain all points of initial features and store them into separate lists
58 // containing their translated copies.
59 // Also all circles and arc collected too, because they will be constrained by equal radii.
61 ResultConstructionPtr aRC;
62 static const size_t MAX_POINTS = 3;
63 std::vector<Slvs_hEntity> aPoints[MAX_POINTS]; // lists of points of features
64 std::vector<Slvs_hEntity> anEntities; // list of translated entities
65 std::list<ObjectPtr> anObjectList = aRefList->list();
66 std::list<ObjectPtr>::iterator anObjectIter = anObjectList.begin();
67 while (anObjectIter != anObjectList.end()) {
68 for (size_t i = 0; i < MAX_POINTS; i++)
72 for (size_t i = 0; i <= myNumberOfCopies && anObjectIter != anObjectList.end(); i++, anObjectIter++) {
73 aFeature = ModelAPI_Feature::feature(*anObjectIter);
76 anEntityID = changeEntity(aFeature, aType);
77 anEntities.push_back(anEntityID);
78 Slvs_Entity anEntity = myStorage->getEntity(anEntityID);
80 case SLVS_E_POINT_IN_2D:
81 case SLVS_E_POINT_IN_3D:
82 aPoints[0].push_back(anEntityID);
84 case SLVS_E_LINE_SEGMENT:
85 aPoints[0].push_back(anEntity.point[0]); // start point of line
86 aPoints[1].push_back(anEntity.point[1]); // end point of line
89 aPoints[0].push_back(anEntity.point[0]); // center of circle
91 case SLVS_E_ARC_OF_CIRCLE:
92 aPoints[0].push_back(anEntity.point[0]); // center of arc
93 aPoints[1].push_back(anEntity.point[1]); // start point of arc
94 aPoints[2].push_back(anEntity.point[2]); // end point of arc
97 myErrorMsg = SketchSolver_Error::INCORRECT_ATTRIBUTE();
102 for (size_t i = 0; i < MAX_POINTS; ++i)
103 if (!aPoints[i].empty())
104 thePoints.push_back(aPoints[i]);
105 if (!anEntities.empty())
106 theEntities.push_back(anEntities);
110 void SketchSolver_ConstraintMultiTranslation::process()
113 if (!myBaseConstraint || !myStorage || myGroup == 0) {
114 /// TODO: Put error message here
117 if (!mySlvsConstraints.empty()) // some data is changed, update constraint
118 update(myBaseConstraint);
120 Slvs_hEntity aStartPoint, aEndPoint;
121 std::vector<std::vector<Slvs_hEntity> > anEntitiesAndCopies;
122 getAttributes(aStartPoint, aEndPoint, myPointsAndCopies, anEntitiesAndCopies);
123 if (!myErrorMsg.empty())
126 // Create translation line
127 if (myTranslationLine == SLVS_E_UNKNOWN) {
128 Slvs_Entity aTranslationLine = Slvs_MakeLineSegment(SLVS_E_UNKNOWN, myGroup->getId(),
129 myGroup->getWorkplaneId(), aStartPoint, aEndPoint);
130 aTranslationLine.h = myStorage->addEntity(aTranslationLine);
131 myTranslationLine = aTranslationLine.h;
133 Slvs_Entity aTranslationLine = myStorage->getEntity(myTranslationLine);
134 if (aTranslationLine.point[0] != aStartPoint || aTranslationLine.point[1] != aEndPoint) {
135 aTranslationLine.point[0] = aStartPoint;
136 aTranslationLine.point[1] = aEndPoint;
137 myStorage->updateEntity(aTranslationLine);
141 // Keep all objects unchanged (only initial object may be changed by user)
142 myCircsAndCopies.clear();
143 std::vector<std::vector<Slvs_hEntity> >::const_iterator anEntIt = anEntitiesAndCopies.begin();
144 std::vector<Slvs_hEntity>::const_iterator aCpIt;
145 for (; anEntIt != anEntitiesAndCopies.end(); ++anEntIt) {
146 std::vector<Slvs_hEntity> aCircs;
147 aCpIt = anEntIt->begin();
148 // Obtain initial points
149 Slvs_Entity anInitial = myStorage->getEntity(*aCpIt);
150 if (anInitial.type == SLVS_E_POINT_IN_2D || anInitial.type == SLVS_E_POINT_IN_3D)
151 myInitialPoints.insert(anInitial.h);
153 for (int i = 0; i < 4 && anInitial.point[i] != SLVS_E_UNKNOWN; i++)
154 myInitialPoints.insert(anInitial.point[i]);
158 for (++aCpIt; aCpIt != anEntIt->end(); ++aCpIt) {
159 const Slvs_Entity& anEntity = myStorage->getEntity(*aCpIt);
160 std::vector<Slvs_hConstraint> aNewConstr;
161 if (anEntity.type == SLVS_E_CIRCLE) {
162 aCircs.push_back(anEntity.distance);
163 // for circles we fix only center
164 aNewConstr = myStorage->fixEntity(anEntity.point[0]);
166 aNewConstr = myStorage->fixEntity(*aCpIt);
167 if (anEntity.type == SLVS_E_ARC_OF_CIRCLE)
168 aCircs.push_back(anEntity.h);
169 mySlvsConstraints.insert(mySlvsConstraints.end(), aNewConstr.begin(), aNewConstr.end());
172 if (!aCircs.empty()) {
173 if (anInitial.type == SLVS_E_CIRCLE)
174 aCircs.insert(aCircs.begin(), anInitial.distance);
176 aCircs.insert(aCircs.begin(), anInitial.h);
177 myCircsAndCopies.push_back(aCircs);
184 void SketchSolver_ConstraintMultiTranslation::update(ConstraintPtr theConstraint)
187 if (!theConstraint || theConstraint == myBaseConstraint) {
188 AttributeRefListPtr anInitialRefList = std::dynamic_pointer_cast<ModelAPI_AttributeRefList>(
189 myBaseConstraint->attribute(SketchPlugin_Constraint::ENTITY_A()));
190 AttributeIntegerPtr aNbCopies = myBaseConstraint->integer(SketchPlugin_MultiTranslation::NUMBER_OF_COPIES_ID());
191 if (anInitialRefList->size() != myNumberOfObjects ||
192 (size_t)aNbCopies->value() != myNumberOfCopies) {
193 remove(myBaseConstraint);
198 SketchSolver_Constraint::update();
201 bool SketchSolver_ConstraintMultiTranslation::remove(ConstraintPtr theConstraint)
204 if (theConstraint && theConstraint != myBaseConstraint)
206 bool isFullyRemoved = true;
207 std::vector<Slvs_hEntity>::iterator aCIter = mySlvsConstraints.begin();
208 for (; aCIter != mySlvsConstraints.end(); aCIter++)
209 isFullyRemoved = myStorage->removeConstraint(*aCIter) && isFullyRemoved;
210 mySlvsConstraints.clear();
212 std::map<FeaturePtr, Slvs_hEntity>::iterator aFeatIt = myFeatureMap.begin();
213 for (; aFeatIt != myFeatureMap.end(); aFeatIt++)
214 myStorage->removeEntity(aFeatIt->second);
216 std::map<FeaturePtr, Slvs_hEntity> aFeatureMapCopy = myFeatureMap;
218 if (isFullyRemoved) {
219 myFeatureMap.clear();
220 myAttributeMap.clear();
223 cleanRemovedEntities();
225 // Restore initial features
226 std::map<FeaturePtr, Slvs_hEntity>::iterator aFIter = aFeatureMapCopy.begin();
227 for (; aFIter != aFeatureMapCopy.end(); ++aFIter)
229 if (myFeatureMap.find(aFIter->first) != myFeatureMap.end())
230 continue; // the feature was not removed
231 Slvs_hEntity anEntity = myGroup->getFeatureId(aFIter->first);
232 if (anEntity != SLVS_E_UNKNOWN)
233 myFeatureMap[aFIter->first] = anEntity;
239 void SketchSolver_ConstraintMultiTranslation::addFeature(FeaturePtr theFeature)
241 SketchSolver_Constraint::addFeature(theFeature);
243 std::map<FeaturePtr, Slvs_hEntity>::iterator aFeatIt = myFeatureMap.find(theFeature);
244 if (aFeatIt == myFeatureMap.end())
247 // store list of points of the feature
248 const Slvs_Entity& theEntity = myStorage->getEntity(aFeatIt->second);
249 for (int i = 0; i < 4; i++)
250 if (theEntity.point[i] != SLVS_E_UNKNOWN)
251 myPointsJustUpdated.insert(theEntity.point[i]);
254 void SketchSolver_ConstraintMultiTranslation::adjustConstraint()
256 Slvs_Entity aTranslationLine = myStorage->getEntity(myTranslationLine);
257 Slvs_hConstraint aFixed; // temporary variable
258 // Set the translation line unchanged during constraint recalculation
259 for (int i = 0; i < 2; i++) {
260 if (myStorage->isPointFixed(aTranslationLine.point[i], aFixed, true))
262 Slvs_Constraint aConstraint = Slvs_MakeConstraint(
263 SLVS_E_UNKNOWN, myGroup->getId(), SLVS_C_WHERE_DRAGGED, myGroup->getWorkplaneId(), 0.0,
264 aTranslationLine.point[i], SLVS_E_UNKNOWN, SLVS_E_UNKNOWN, SLVS_E_UNKNOWN);
265 aConstraint.h = myStorage->addConstraint(aConstraint);
266 myStorage->addTemporaryConstraint(aConstraint.h);
269 // Check if the distance between point is 0, no need to resolve constraints (just wait another values)
271 for (int i = 0; i < 2; i++) {
272 Slvs_Entity aPnt = myStorage->getEntity(aTranslationLine.point[i]);
273 aXY[2*i] = myStorage->getParameter(aPnt.param[0]).val;
274 aXY[2*i+1] = myStorage->getParameter(aPnt.param[1]).val;
276 double aDelta[2] = {aXY[2] - aXY[0], aXY[3] - aXY[1]};
277 if (fabs(aDelta[0]) + fabs(aDelta[1]) < tolerance) {
278 myStorage->setNeedToResolve(false);
282 std::list<Slvs_Constraint> aCoincident = myStorage->getConstraintsByType(SLVS_C_POINTS_COINCIDENT);
283 std::list<Slvs_Constraint>::const_iterator aCoIt;
287 // Update positions of all points to satisfy distances
288 std::vector< std::vector<Slvs_hEntity> >::const_iterator aPointsIter = myPointsAndCopies.begin();
289 std::vector<Slvs_hEntity>::const_iterator aCopyIter;
290 for (; aPointsIter != myPointsAndCopies.end(); ++aPointsIter) {
291 aCopyIter = aPointsIter->begin();
292 const Slvs_Entity& anInitial = myStorage->getEntity(*aCopyIter);
293 for (int i = 0; i < 2; i++)
294 aCoord[i] = myStorage->getParameter(anInitial.param[i]).val;
296 // if the point is coincident with another one which is temporary fixed (moved by user),
297 // we will update its position correspondingly
298 Slvs_hConstraint aFixed;
299 for (aCoIt = aCoincident.begin(); aCoIt != aCoincident.end(); ++aCoIt) {
300 if ((aCoIt->ptA == anInitial.h && myInitialPoints.find(aCoIt->ptB) != myInitialPoints.end()) ||
301 (aCoIt->ptB == anInitial.h && myInitialPoints.find(aCoIt->ptA) != myInitialPoints.end())) {
302 Slvs_hEntity anOtherId = aCoIt->ptA == anInitial.h ? aCoIt->ptB : aCoIt->ptA;
303 if (!myStorage->isTemporary(aFixed) &&
304 myPointsJustUpdated.find(anOtherId) == myPointsJustUpdated.end())
305 continue; // nothing to change
307 const Slvs_Entity& anOtherPnt = myStorage->getEntity(anOtherId);
308 for (int i = 0; i < 2; i++) {
309 Slvs_Param anInitParam = myStorage->getParameter(anInitial.param[i]);
310 const Slvs_Param& anOtherParam = myStorage->getParameter(anOtherPnt.param[i]);
311 anInitParam.val = anOtherParam.val;
312 myStorage->updateParameter(anInitParam);
313 aCoord[i] = anOtherParam.val;
318 // update copied points
319 aCopyIter = aPointsIter->begin();
320 for (++aCopyIter; aCopyIter != aPointsIter->end(); ++aCopyIter) {
322 aCoord[0] += aDelta[0];
323 aCoord[1] += aDelta[1];
325 const Slvs_Entity& aTarget = myStorage->getEntity(*aCopyIter);
326 for (int i = 0; i < 2; i++) {
327 Slvs_Param aParam = myStorage->getParameter(aTarget.param[i]);
328 aParam.val = aCoord[i];
329 myStorage->updateParameter(aParam);
334 std::list<Slvs_Constraint> aDiamConstr;
335 for (aPointsIter = myCircsAndCopies.begin(); aPointsIter != myCircsAndCopies.end(); ++aPointsIter) {
336 aCopyIter = aPointsIter->begin();
337 const Slvs_Entity& anInitial = myStorage->getEntity(*aCopyIter);
338 if (anInitial.type == SLVS_E_DISTANCE) {
339 const Slvs_Param& anInitRad = myStorage->getParameter(anInitial.param[0]);
340 for (++aCopyIter; aCopyIter != aPointsIter->end(); ++aCopyIter) {
341 const Slvs_Entity& aCopy = myStorage->getEntity(*aCopyIter);
342 Slvs_Param aCopyRad = myStorage->getParameter(aCopy.param[0]);
343 aCopyRad.val = anInitRad.val;
344 myStorage->updateParameter(aCopyRad);
346 } else if (anInitial.type == SLVS_E_ARC_OF_CIRCLE) {
347 const Slvs_Entity& aCenterEnt = myStorage->getEntity(anInitial.point[0]);
348 const Slvs_Entity& aStartEnt = myStorage->getEntity(anInitial.point[1]);
350 if (aDiamConstr.empty())
351 aDiamConstr = myStorage->getConstraintsByType(SLVS_C_DIAMETER);
352 // Calculate diameter of initial arc
354 for (int i = 0; i < 2; i++) {
355 double d = myStorage->getParameter(aStartEnt.param[i]).val -
356 myStorage->getParameter(aCenterEnt.param[i]).val;
359 aDiam = sqrt(aDiam) * 2.0;
360 // Update the Diameter constraints of copied arcs
361 for (++aCopyIter; aCopyIter != aPointsIter->end(); ++aCopyIter) {
362 std::list<Slvs_Constraint>::iterator aDCIt = aDiamConstr.begin();
363 for (; aDCIt != aDiamConstr.end(); ++aDCIt)
364 if (aDCIt->entityA == *aCopyIter) {
366 myStorage->updateConstraint(*aDCIt);
367 aDiamConstr.erase(aDCIt);
374 myPointsJustUpdated.clear();