1 #include <SketchSolver_ConstraintMirror.h>
2 #include <SketchSolver_Group.h>
3 #include <SketchSolver_Error.h>
5 #include <ModelAPI_AttributeDouble.h>
6 #include <ModelAPI_AttributeRefAttr.h>
7 #include <ModelAPI_AttributeRefList.h>
8 #include <ModelAPI_ResultConstruction.h>
10 #include <GeomAPI_Dir2d.h>
11 #include <GeomAPI_XY.h>
14 void SketchSolver_ConstraintMirror::getAttributes(
15 Slvs_Entity& theMirrorLine,
16 std::vector<Slvs_Entity>& theBaseEntities,
17 std::vector<Slvs_Entity>& theMirrorEntities)
19 DataPtr aData = myBaseConstraint->data();
20 AttributeRefAttrPtr aMirLineAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(
21 myBaseConstraint->attribute(SketchPlugin_Constraint::ENTITY_A()));
22 if (!aMirLineAttr || !aMirLineAttr->isInitialized() || !aMirLineAttr->isObject()) {
23 myErrorMsg = SketchSolver_Error::NOT_INITIALIZED();
26 int aType = SLVS_E_UNKNOWN; // type of created entity
27 Slvs_hEntity anEntity = myGroup->getAttributeId(aMirLineAttr);
28 if (anEntity == SLVS_E_UNKNOWN)
29 anEntity = changeEntity(aMirLineAttr, aType);
30 theMirrorLine = myStorage->getEntity(anEntity);
32 // Create SolveSpace entity for all features
33 AttributeRefListPtr aBaseRefList = std::dynamic_pointer_cast<ModelAPI_AttributeRefList>(
34 myBaseConstraint->attribute(SketchPlugin_Constraint::ENTITY_B()));
35 AttributeRefListPtr aMirroredRefList = std::dynamic_pointer_cast<ModelAPI_AttributeRefList>(
36 myBaseConstraint->attribute(SketchPlugin_Constraint::ENTITY_C()));
37 myNumberOfObjects = aMirroredRefList->size();
38 if (!aBaseRefList || !aMirroredRefList) {
39 myErrorMsg = SketchSolver_Error::INCORRECT_MIRROR_ATTRIBUTE();
43 std::list<ObjectPtr> aBaseList = aBaseRefList->list();
44 std::list<ObjectPtr> aMirroredList = aMirroredRefList->list();
47 ResultConstructionPtr aRC;
48 for (int i = 0; i < 2; i++) {
49 std::list<ObjectPtr>::iterator anIter = i == 0 ? aBaseList.begin() : aMirroredList.begin();
50 std::list<ObjectPtr>::iterator aEndIter = i == 0 ? aBaseList.end() : aMirroredList.end();
51 std::vector<Slvs_Entity>* aList = i == 0 ? &theBaseEntities : & theMirrorEntities;
52 for ( ; anIter != aEndIter; anIter++) {
53 aRC = std::dynamic_pointer_cast<ModelAPI_ResultConstruction>(*anIter);
54 aFeature = aRC ? aRC->document()->feature(aRC) :
55 std::dynamic_pointer_cast<ModelAPI_Feature>(*anIter);
59 anEntity = changeEntity(aFeature, aType);
60 // Sort entities by their type
61 std::vector<Slvs_Entity>::iterator anIt = aList->begin();
62 for (; anIt != aList->end(); anIt++)
63 if (aType < anIt->type)
65 // aList->push_back(myStorage->getEntity(anEntity));
66 aList->insert(anIt, myStorage->getEntity(anEntity));
70 if (theBaseEntities.size() > theMirrorEntities.size())
71 myErrorMsg = SketchSolver_Error::NOT_INITIALIZED();
74 void SketchSolver_ConstraintMirror::process()
77 if (!myBaseConstraint || !myStorage || myGroup == 0) {
78 /// TODO: Put error message here
81 if (!mySlvsConstraints.empty()) // some data is changed, update constraint
82 update(myBaseConstraint);
84 Slvs_Entity aMirrorLine;
85 std::vector<Slvs_Entity> aBaseList;
86 std::vector<Slvs_Entity> aMirrorList;
87 getAttributes(aMirrorLine, aBaseList, aMirrorList);
88 if (!myErrorMsg.empty())
91 if (aBaseList.size() != aMirrorList.size()) {
92 myErrorMsg = SketchSolver_Error::INCORRECT_MIRROR_ATTRIBUTE();
96 Slvs_Constraint aConstraint;
97 // Get coordinates of mirror line points for speed up
99 for (int i = 0; i < 2; i++) {
100 Slvs_Entity aPoint = myStorage->getEntity(aMirrorLine.point[i]);
101 for (int j = 0; j < 2; j++)
102 aStartEnd[2*i+j] = myStorage->getParameter(aPoint.param[j]).val;
105 std::vector<Slvs_Entity>::iterator aBaseIter = aBaseList.begin();
106 std::vector<Slvs_Entity>::iterator aMirrorIter = aMirrorList.begin();
107 for (; aBaseIter != aBaseList.end(); aBaseIter++, aMirrorIter++) {
108 // Make aMirrorEnt parameters to be symmetric with aBaseEnt
109 makeMirrorEntity(*aBaseIter, *aMirrorIter, aStartEnd);
111 if (aBaseIter->type == SLVS_E_POINT_IN_2D) {
112 aConstraint = Slvs_MakeConstraint(
113 SLVS_E_UNKNOWN, myGroup->getId(), getType(), myGroup->getWorkplaneId(),
114 0.0, aBaseIter->h, aMirrorIter->h, aMirrorLine.h, SLVS_E_UNKNOWN);
115 aConstraint.h = myStorage->addConstraint(aConstraint);
116 mySlvsConstraints.push_back(aConstraint.h);
117 } else if (aBaseIter->type == SLVS_E_LINE_SEGMENT) {
118 for (int i = 0; i < 2; i++) {
119 aConstraint = Slvs_MakeConstraint(
120 SLVS_E_UNKNOWN, myGroup->getId(), getType(), myGroup->getWorkplaneId(), 0.0,
121 aBaseIter->point[i], aMirrorIter->point[i], aMirrorLine.h, SLVS_E_UNKNOWN);
122 aConstraint.h = myStorage->addConstraint(aConstraint);
123 mySlvsConstraints.push_back(aConstraint.h);
125 } else if (aBaseIter->type == SLVS_E_CIRCLE) {
126 aConstraint = Slvs_MakeConstraint(
127 SLVS_E_UNKNOWN, myGroup->getId(), getType(), myGroup->getWorkplaneId(), 0.0,
128 aBaseIter->point[0], aMirrorIter->point[0], aMirrorLine.h, SLVS_E_UNKNOWN);
129 aConstraint.h = myStorage->addConstraint(aConstraint);
130 mySlvsConstraints.push_back(aConstraint.h);
131 // Additional constraint for equal radii
132 Slvs_Constraint anEqRadConstr = Slvs_MakeConstraint(
133 SLVS_E_UNKNOWN, myGroup->getId(), SLVS_C_EQUAL_RADIUS, myGroup->getWorkplaneId(),
134 0.0, SLVS_E_UNKNOWN, SLVS_E_UNKNOWN, aBaseIter->h, aMirrorIter->h);
135 anEqRadConstr.h = myStorage->addConstraint(anEqRadConstr);
136 mySlvsConstraints.push_back(anEqRadConstr.h);
137 } else if (aBaseIter->type == SLVS_E_ARC_OF_CIRCLE) {
138 // Workaround to avoid problems in SolveSpace.
139 // The symmetry of two arcs will be done using symmetry of three points on these arcs:
140 // start point, end point, and any other point on the arc
141 Slvs_hEntity aBaseArcPoints[3] = {
145 Slvs_hEntity aMirrorArcPoints[3] = { // indices of points of arc, center corresponds center, first point corresponds last point
146 aMirrorIter->point[2],
147 aMirrorIter->point[1],
150 Slvs_Entity aBothArcs[2] = {*aBaseIter, *aMirrorIter};
151 Slvs_hEntity aBothMiddlePoints[2];
152 for (int i = 0; i < 2; i++) {
154 calculateMiddlePoint(aBothArcs[i], 0.5, x, y);
155 Slvs_Param aParamX = Slvs_MakeParam(SLVS_E_UNKNOWN, myGroup->getId(), x);
156 Slvs_Param aParamY = Slvs_MakeParam(SLVS_E_UNKNOWN, myGroup->getId(), y);
157 aParamX.h = myStorage->addParameter(aParamX);
158 aParamY.h = myStorage->addParameter(aParamY);
159 Slvs_Entity aPoint = Slvs_MakePoint2d(SLVS_E_UNKNOWN, myGroup->getId(),
160 myGroup->getWorkplaneId(), aParamX.h, aParamY.h);
161 aBothMiddlePoints[i] = myStorage->addEntity(aPoint);
162 // additional constraint point-on-curve
163 Slvs_Constraint aPonCircConstr = Slvs_MakeConstraint(
164 SLVS_E_UNKNOWN, myGroup->getId(), SLVS_C_PT_ON_CIRCLE, myGroup->getWorkplaneId(),
165 0.0, aBothMiddlePoints[i], SLVS_E_UNKNOWN, aBothArcs[i].h, SLVS_E_UNKNOWN);
166 aPonCircConstr.h = myStorage->addConstraint(aPonCircConstr);
167 mySlvsConstraints.push_back(aPonCircConstr.h);
169 // additional constraint for the point to be in the middle of a base arc
170 Slvs_Entity aLine1 = Slvs_MakeLineSegment(SLVS_E_UNKNOWN, myGroup->getId(),
171 myGroup->getWorkplaneId(), aBothArcs[i].point[1], aBothMiddlePoints[i]);
172 aLine1.h = myStorage->addEntity(aLine1);
173 Slvs_Entity aLine2 = Slvs_MakeLineSegment(SLVS_E_UNKNOWN, myGroup->getId(),
174 myGroup->getWorkplaneId(), aBothArcs[i].point[2], aBothMiddlePoints[i]);
175 aLine2.h = myStorage->addEntity(aLine2);
176 Slvs_Constraint aMiddleConstr = Slvs_MakeConstraint(SLVS_E_UNKNOWN, myGroup->getId(),
177 SLVS_C_EQUAL_LENGTH_LINES, myGroup->getWorkplaneId(),
178 0.0, SLVS_E_UNKNOWN, SLVS_E_UNKNOWN, aLine1.h, aLine2.h);
179 aMiddleConstr.h = myStorage->addConstraint(aMiddleConstr);
180 mySlvsConstraints.push_back(aMiddleConstr.h);
184 aBaseArcPoints[2] = aBothMiddlePoints[0];
185 aMirrorArcPoints[2] = aBothMiddlePoints[1];
186 for (int ind = 0; ind < 3; ind++) {
187 Slvs_Constraint aConstraint = Slvs_MakeConstraint(
188 SLVS_E_UNKNOWN, myGroup->getId(), getType(), myGroup->getWorkplaneId(), 0.0,
189 aBaseArcPoints[ind], aMirrorArcPoints[ind], aMirrorLine.h, SLVS_E_UNKNOWN);
190 aConstraint.h = myStorage->addConstraint(aConstraint);
191 mySlvsConstraints.push_back(aConstraint.h);
196 // Set the mirror line unchanged during constraint recalculation
197 for (int i = 0; i < 2; i++) {
198 if (myStorage->isPointFixed(aMirrorLine.point[i], aConstraint.h, true))
200 aConstraint = Slvs_MakeConstraint(
201 SLVS_E_UNKNOWN, myGroup->getId(), SLVS_C_WHERE_DRAGGED, myGroup->getWorkplaneId(), 0.0,
202 aMirrorLine.point[i], SLVS_E_UNKNOWN, SLVS_E_UNKNOWN, SLVS_E_UNKNOWN);
203 aConstraint.h = myStorage->addConstraint(aConstraint);
204 mySlvsConstraints.push_back(aConstraint.h);
209 void SketchSolver_ConstraintMirror::update(ConstraintPtr theConstraint)
212 if (!theConstraint || theConstraint == myBaseConstraint) {
213 AttributeRefListPtr aMirroredRefList = std::dynamic_pointer_cast<ModelAPI_AttributeRefList>(
214 myBaseConstraint->attribute(SketchPlugin_Constraint::ENTITY_C()));
215 if (aMirroredRefList->size() != myNumberOfObjects) {
216 remove(myBaseConstraint);
221 SketchSolver_Constraint::update();
224 bool SketchSolver_ConstraintMirror::remove(ConstraintPtr theConstraint)
227 if (theConstraint && theConstraint != myBaseConstraint)
229 bool isFullyRemoved = true;
230 std::vector<Slvs_hEntity>::iterator aCIter = mySlvsConstraints.begin();
231 for (; aCIter != mySlvsConstraints.end(); aCIter++)
232 isFullyRemoved = myStorage->removeConstraint(*aCIter) && isFullyRemoved;
233 mySlvsConstraints.clear();
235 std::map<FeaturePtr, Slvs_hEntity>::iterator aFeatIt = myFeatureMap.begin();
236 for (; aFeatIt != myFeatureMap.end(); aFeatIt++)
237 myStorage->removeEntity(aFeatIt->second);
239 if (isFullyRemoved) {
240 myFeatureMap.clear();
241 myAttributeMap.clear();
244 cleanRemovedEntities();
248 bool SketchSolver_ConstraintMirror::checkAttributesChanged(ConstraintPtr theConstraint)
250 // First of all, check the mirror line is changed.
251 // It may be changed to one of mirrored lines, which is already in this constraint
252 // (this case is not marked as attribute changing)
253 ConstraintPtr aConstraint = theConstraint ? theConstraint : myBaseConstraint;
254 AttributeRefAttrPtr aRefAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(
255 aConstraint->attribute(SketchPlugin_Constraint::ENTITY_A()));
256 if (!aRefAttr || !aRefAttr->isObject() || !aRefAttr->object())
258 FeaturePtr aMirrorLine = ModelAPI_Feature::feature(aRefAttr->object());
262 std::map<FeaturePtr, Slvs_hEntity>::iterator aMirrorIter = myFeatureMap.find(aMirrorLine);
263 if (aMirrorIter == myFeatureMap.end())
266 // Check the entity is not used as mirror line
267 std::vector<Slvs_hConstraint>::iterator aCIter = mySlvsConstraints.begin();
268 for (; aCIter != mySlvsConstraints.end(); aCIter++) {
269 Slvs_Constraint aMirrorConstr = myStorage->getConstraint(*aCIter);
270 if (aMirrorConstr.type != SLVS_C_SYMMETRIC_LINE)
272 if (aMirrorConstr.entityA != aMirrorIter->second)
274 else break; // check just one symmetric constraint
278 return SketchSolver_Constraint::checkAttributesChanged(theConstraint);
281 void SketchSolver_ConstraintMirror::makeMirrorEntity(
282 const Slvs_Entity& theBase,
283 const Slvs_Entity& theMirror,
284 const double theMirrorLine[]) const
286 Slvs_hEntity aBasePoint[4];
287 Slvs_hEntity aMirrorPoint[4];
288 for (int i = 0; i < 4; i++) {
289 aBasePoint[i] = theBase.point[i];
290 aMirrorPoint[i] = theMirror.point[i];
292 if (theBase.type == SLVS_E_ARC_OF_CIRCLE) {
293 Slvs_hEntity aTmp = aMirrorPoint[2];
294 aMirrorPoint[2] = aMirrorPoint[1];
295 aMirrorPoint[1] = aTmp;
297 if (theBase.type == SLVS_E_POINT_IN_2D || theBase.type == SLVS_E_POINT_IN_3D) {
298 aBasePoint[0] = theBase.h;
299 aMirrorPoint[0] = theMirror.h;
302 // Mirror line parameters
303 std::shared_ptr<GeomAPI_XY> aLinePoints[2];
304 for (int i = 0; i < 2; i++)
305 aLinePoints[i] = std::shared_ptr<GeomAPI_XY>(
306 new GeomAPI_XY(theMirrorLine[2*i], theMirrorLine[2*i+1]));
307 // direction of a mirror line
308 std::shared_ptr<GeomAPI_Dir2d> aDir = std::shared_ptr<GeomAPI_Dir2d>(
309 new GeomAPI_Dir2d(aLinePoints[1]->added(aLinePoints[0]->multiplied(-1.0))));
310 // orthogonal direction
311 aDir = std::shared_ptr<GeomAPI_Dir2d>(new GeomAPI_Dir2d(aDir->y(), -aDir->x()));
313 for (int i = 0; i < 4; i++) {
314 if (aBasePoint[i] == SLVS_E_UNKNOWN || aMirrorPoint[i] == SLVS_E_UNKNOWN)
316 Slvs_Entity aPointEnt = myStorage->getEntity(aBasePoint[i]);
317 double aBaseX = myStorage->getParameter(aPointEnt.param[0]).val;
318 double aBaseY = myStorage->getParameter(aPointEnt.param[1]).val;
319 std::shared_ptr<GeomAPI_XY> aPoint = std::shared_ptr<GeomAPI_XY>(new GeomAPI_XY(aBaseX, aBaseY));
321 std::shared_ptr<GeomAPI_XY> aVec = std::shared_ptr<GeomAPI_XY>(
322 new GeomAPI_XY(aPoint->x() - aLinePoints[0]->x(), aPoint->y() - aLinePoints[0]->y()));
323 double aDist = aVec->dot(aDir->xy());
324 aPoint = aPoint->added(aDir->xy()->multiplied(-2.0 * aDist));
326 Slvs_Entity aMirrorEnt = myStorage->getEntity(aMirrorPoint[i]);
327 Slvs_Param aParam = Slvs_MakeParam(aMirrorEnt.param[0], myGroup->getId(), aPoint->x());
328 myStorage->updateParameter(aParam);
329 aParam = Slvs_MakeParam(aMirrorEnt.param[1], myGroup->getId(), aPoint->y());
330 myStorage->updateParameter(aParam);
334 void SketchSolver_ConstraintMirror::adjustConstraint()
336 // Search mirror between middle points on the arcs and recompute their coordinates
337 std::list<Slvs_Constraint> aPonCirc = myStorage->getConstraintsByType(SLVS_C_PT_ON_CIRCLE);
338 if (aPonCirc.empty())
341 AttributeRefAttrPtr aMirLineAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(
342 myBaseConstraint->attribute(SketchPlugin_Constraint::ENTITY_A()));
343 if (!aMirLineAttr || !aMirLineAttr->isInitialized() || !aMirLineAttr->isObject()) {
344 myErrorMsg = SketchSolver_Error::NOT_INITIALIZED();
347 ResultConstructionPtr aRC =
348 std::dynamic_pointer_cast<ModelAPI_ResultConstruction>(aMirLineAttr->object());
349 FeaturePtr aFeature = aRC ? aRC->document()->feature(aRC) :
350 std::dynamic_pointer_cast<ModelAPI_Feature>(aMirLineAttr->object());
351 std::map<FeaturePtr, Slvs_hEntity>::iterator aMirLineIter = myFeatureMap.find(aFeature);
352 if (aMirLineIter == myFeatureMap.end())
354 Slvs_Entity aMirrorLine = myStorage->getEntity(aMirLineIter->second);
357 for (int i = 0; i < 2; i++) {
358 Slvs_Entity aPoint = myStorage->getEntity(aMirrorLine.point[i]);
359 for (int j = 0; j < 2; j++)
360 aStartEnd[2*i+j] = myStorage->getParameter(aPoint.param[j]).val;
363 Slvs_Constraint aMirror;
364 std::vector<Slvs_hConstraint>::iterator aConstrIter = mySlvsConstraints.begin();
365 for (; aConstrIter != mySlvsConstraints.end(); aConstrIter++) {
366 aMirror = myStorage->getConstraint(*aConstrIter);
367 if (aMirror.type != SLVS_C_SYMMETRIC_LINE)
369 Slvs_Constraint aPonCircA, aPonCircB;
370 aPonCircA.h = SLVS_E_UNKNOWN;
371 aPonCircB.h = SLVS_E_UNKNOWN;
372 std::list<Slvs_Constraint>::iterator aPtIter = aPonCirc.begin();
373 for (; aPtIter != aPonCirc.end(); aPtIter++) {
374 if (aMirror.ptA == aPtIter->ptA)
375 aPonCircA = *aPtIter;
376 if (aMirror.ptB == aPtIter->ptA)
377 aPonCircB = *aPtIter;
379 if (aPonCircA.h == SLVS_E_UNKNOWN || aPonCircB.h == SLVS_E_UNKNOWN)
382 bool aNeedToResolve = myStorage->isNeedToResolve();
383 // Calculate middle point for base arc and mirrored point on mirror arc
384 Slvs_Entity aBaseArc = myStorage->getEntity(aPonCircA.entityA);
385 Slvs_Entity aBasePoint = myStorage->getEntity(aPonCircA.ptA);
386 Slvs_Param aParamX = myStorage->getParameter(aBasePoint.param[0]);
387 Slvs_Param aParamY = myStorage->getParameter(aBasePoint.param[1]);
388 calculateMiddlePoint(aBaseArc, 0.5, aParamX.val, aParamY.val);
389 myStorage->updateParameter(aParamX);
390 myStorage->updateParameter(aParamY);
391 Slvs_Entity aMirrorArc = myStorage->getEntity(aPonCircB.entityA);
392 Slvs_Entity aMirrorPoint = myStorage->getEntity(aPonCircB.ptA);
393 aParamX = myStorage->getParameter(aMirrorPoint.param[0]);
394 aParamY = myStorage->getParameter(aMirrorPoint.param[1]);
395 calculateMiddlePoint(aMirrorArc, 0.5, aParamX.val, aParamY.val);
396 myStorage->updateParameter(aParamX);
397 myStorage->updateParameter(aParamY);
398 // To avoid looped recalculations of sketch
399 myStorage->setNeedToResolve(aNeedToResolve);