]> SALOME platform Git repositories - modules/shaper.git/blob - src/SketchPlugin/SketchPlugin_Tools.cpp
Salome HOME
Issue #2387: Sketcher conservation of constraints in fillet feature
[modules/shaper.git] / src / SketchPlugin / SketchPlugin_Tools.cpp
1 // Copyright (C) 2014-2017  CEA/DEN, EDF R&D
2 //
3 // This library is free software; you can redistribute it and/or
4 // modify it under the terms of the GNU Lesser General Public
5 // License as published by the Free Software Foundation; either
6 // version 2.1 of the License, or (at your option) any later version.
7 //
8 // This library is distributed in the hope that it will be useful,
9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
11 // Lesser General Public License for more details.
12 //
13 // You should have received a copy of the GNU Lesser General Public
14 // License along with this library; if not, write to the Free Software
15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16 //
17 // See http://www.salome-platform.org/ or
18 // email : webmaster.salome@opencascade.com<mailto:webmaster.salome@opencascade.com>
19 //
20
21 #include "SketchPlugin_Tools.h"
22
23 #include "SketchPlugin_ConstraintCoincidence.h"
24 #include "SketchPlugin_ConstraintLength.h"
25 #include "SketchPlugin_ConstraintTangent.h"
26 #include "SketchPlugin_Line.h"
27 #include "SketchPlugin_Point.h"
28 #include "SketchPlugin_SketchEntity.h"
29
30 #include <SketcherPrs_Tools.h>
31
32 #include <ModelAPI_AttributeDouble.h>
33
34 #include <GeomAPI_Dir2d.h>
35 #include <GeomAPI_Pnt2d.h>
36 #include <GeomAPI_XY.h>
37
38 #include <GeomDataAPI_Point.h>
39 #include <GeomDataAPI_Point2D.h>
40
41 #ifdef DEBUG_TRIM
42 #include <iostream>
43 #endif
44
45 namespace SketchPlugin_Tools {
46
47 void clearExpressions(AttributeDoublePtr theAttribute)
48 {
49   theAttribute->setText(std::string());
50 }
51
52 void clearExpressions(AttributePointPtr theAttribute)
53 {
54   theAttribute->setText(std::string(), std::string(), std::string());
55 }
56
57 void clearExpressions(AttributePoint2DPtr theAttribute)
58 {
59   theAttribute->setText(std::string(), std::string());
60 }
61
62 void clearExpressions(AttributePtr theAttribute)
63 {
64   // Double
65   AttributeDoublePtr anAttributeDouble =
66       std::dynamic_pointer_cast<ModelAPI_AttributeDouble>(theAttribute);
67   if (anAttributeDouble.get())
68     clearExpressions(anAttributeDouble);
69   // Point
70   AttributePointPtr anAttributePoint =
71       std::dynamic_pointer_cast<GeomDataAPI_Point>(theAttribute);
72   if (anAttributePoint.get())
73     clearExpressions(anAttributePoint);
74   // Point2D
75   AttributePoint2DPtr anAttributePoint2D =
76       std::dynamic_pointer_cast<GeomDataAPI_Point2D>(theAttribute);
77   if (anAttributePoint2D.get())
78     clearExpressions(anAttributePoint2D);
79 }
80
81 void clearExpressions(FeaturePtr theFeature)
82 {
83   if (!theFeature.get())
84     return;
85
86   std::list<AttributePtr> anAttributes = theFeature->data()->attributes(std::string());
87   std::list<AttributePtr>::iterator anAttributeIt = anAttributes.begin();
88   for (; anAttributeIt != anAttributes.end(); ++anAttributeIt) {
89     clearExpressions(*anAttributeIt);
90   }
91 }
92
93 std::shared_ptr<GeomAPI_Pnt2d> getCoincidencePoint(const FeaturePtr theStartCoin)
94 {
95   std::shared_ptr<GeomAPI_Pnt2d> aPnt = SketcherPrs_Tools::getPoint(theStartCoin.get(),
96                                                           SketchPlugin_Constraint::ENTITY_A());
97   if (aPnt.get() == NULL)
98     aPnt = SketcherPrs_Tools::getPoint(theStartCoin.get(), SketchPlugin_Constraint::ENTITY_B());
99   return aPnt;
100 }
101
102 std::set<FeaturePtr> findCoincidentConstraints(const FeaturePtr& theFeature)
103 {
104   std::set<FeaturePtr> aCoincident;
105   const std::set<AttributePtr>& aRefsList = theFeature->data()->refsToMe();
106   std::set<AttributePtr>::const_iterator aIt;
107   for (aIt = aRefsList.cbegin(); aIt != aRefsList.cend(); ++aIt) {
108     FeaturePtr aConstrFeature = std::dynamic_pointer_cast<ModelAPI_Feature>((*aIt)->owner());
109     if (aConstrFeature->getKind() == SketchPlugin_ConstraintCoincidence::ID())
110       aCoincident.insert(aConstrFeature);
111   }
112   return aCoincident;
113 }
114
115 void findCoincidences(const FeaturePtr theStartCoin,
116                       const std::string& theAttr,
117                       std::set<FeaturePtr>& theList,
118                       const bool theIsAttrOnly)
119 {
120   AttributeRefAttrPtr aPnt = theStartCoin->refattr(theAttr);
121   if(!aPnt) {
122     return;
123   }
124   FeaturePtr aObj = ModelAPI_Feature::feature(aPnt->object());
125   if(theList.find(aObj) == theList.end()) {
126     std::shared_ptr<GeomAPI_Pnt2d> aOrig = getCoincidencePoint(theStartCoin);
127     if(aOrig.get() == NULL) {
128       return;
129     }
130     if(!theIsAttrOnly || !aPnt->isObject()) {
131       theList.insert(aObj);
132     }
133     std::set<FeaturePtr> aCoincidences = findCoincidentConstraints(aObj);
134     std::set<FeaturePtr>::const_iterator aCIt = aCoincidences.begin();
135     for (; aCIt != aCoincidences.end(); ++aCIt) {
136       FeaturePtr aConstrFeature = *aCIt;
137       std::shared_ptr<GeomAPI_Pnt2d> aPnt = getCoincidencePoint(aConstrFeature);
138       if(aPnt.get() && aOrig->isEqual(aPnt)) {
139         findCoincidences(aConstrFeature, SketchPlugin_ConstraintCoincidence::ENTITY_A(),
140                          theList, theIsAttrOnly);
141         findCoincidences(aConstrFeature, SketchPlugin_ConstraintCoincidence::ENTITY_B(),
142                          theList, theIsAttrOnly);
143       }
144     }
145   }
146 }
147
148 std::set<FeaturePtr> findFeaturesCoincidentToPoint(const AttributePoint2DPtr& thePoint)
149 {
150   std::set<FeaturePtr> aCoincidentFeatures;
151
152   FeaturePtr anOwner = ModelAPI_Feature::feature(thePoint->owner());
153   aCoincidentFeatures.insert(anOwner);
154
155   std::set<FeaturePtr> aCoincidences = findCoincidentConstraints(anOwner);
156   std::set<FeaturePtr>::const_iterator aCIt = aCoincidences.begin();
157   for (; aCIt != aCoincidences.end(); ++aCIt) {
158     bool isPointUsedInCoincidence = false;
159     AttributeRefAttrPtr anOtherCoincidentAttr;
160     for (int i = 0; i < CONSTRAINT_ATTR_SIZE; ++i) {
161       AttributeRefAttrPtr aRefAttr = (*aCIt)->refattr(SketchPlugin_Constraint::ATTRIBUTE(i));
162       if (!aRefAttr)
163         continue;
164       if (!aRefAttr->isObject() && aRefAttr->attr() == thePoint)
165         isPointUsedInCoincidence = true;
166       else
167         anOtherCoincidentAttr = aRefAttr;
168     }
169
170     if (isPointUsedInCoincidence) {
171       ObjectPtr anObj;
172       if (anOtherCoincidentAttr->isObject())
173         anObj = anOtherCoincidentAttr->object();
174       else
175         anObj = anOtherCoincidentAttr->attr()->owner();
176       aCoincidentFeatures.insert(ModelAPI_Feature::feature(anObj));
177     }
178   }
179
180   return aCoincidentFeatures;
181 }
182
183 // Container for point-point coincidences.
184 // Useful to find points coincident to a given point.
185 class CoincidentPoints
186 {
187 public:
188   void addCoincidence(const AttributePoint2DPtr& thePoint1,
189                       const AttributePoint2DPtr& thePoint2 = AttributePoint2DPtr())
190   {
191     std::list< std::set<AttributePoint2DPtr> >::iterator aFound1 = find(thePoint1);
192     std::list< std::set<AttributePoint2DPtr> >::iterator aFound2 = find(thePoint2);
193     if (aFound1 == myCoincidentPoints.end()) {
194       std::set<AttributePoint2DPtr> aNewSet;
195       aNewSet.insert(thePoint1);
196       if (thePoint2)
197         aNewSet.insert(thePoint2);
198       myCoincidentPoints.push_back(aNewSet);
199     } else if (aFound2 == myCoincidentPoints.end()) {
200       if (thePoint2)
201         aFound1->insert(thePoint2);
202     } else {
203       aFound1->insert(aFound2->begin(), aFound2->end());
204       myCoincidentPoints.erase(aFound2);
205     }
206   }
207
208   std::set<AttributePoint2DPtr> coincidentPoints(const AttributePoint2DPtr& thePoint)
209   {
210     std::list< std::set<AttributePoint2DPtr> >::iterator aFound = find(thePoint);
211     if (aFound == myCoincidentPoints.end())
212       return std::set<AttributePoint2DPtr>();
213     return *aFound;
214   }
215
216 private:
217   std::list< std::set<AttributePoint2DPtr> >::iterator find(const AttributePoint2DPtr& thePoint)
218   {
219     std::list< std::set<AttributePoint2DPtr> >::iterator aSeek = myCoincidentPoints.begin();
220     for (; aSeek != myCoincidentPoints.end(); ++aSeek)
221       if (aSeek->find(thePoint) != aSeek->end())
222         return aSeek;
223     return myCoincidentPoints.end();
224   }
225
226 private:
227   std::list< std::set<AttributePoint2DPtr> > myCoincidentPoints;
228 };
229
230 std::set<AttributePoint2DPtr> findPointsCoincidentToPoint(const AttributePoint2DPtr& thePoint)
231 {
232   CoincidentPoints aCoincidentPoints;
233   AttributePoint2DPtr aPoints[2];
234
235   FeaturePtr anOwner = ModelAPI_Feature::feature(thePoint->owner());
236   std::set<FeaturePtr> aCoincidences = findCoincidentConstraints(anOwner);
237   std::set<FeaturePtr>::const_iterator aCIt = aCoincidences.begin();
238   for (; aCIt != aCoincidences.end(); ++aCIt) {
239     aPoints[0] = AttributePoint2DPtr();
240     aPoints[1] = AttributePoint2DPtr();
241     for (int i = 0, aPtInd = 0; i < CONSTRAINT_ATTR_SIZE; ++i) {
242       AttributeRefAttrPtr aRefAttr = (*aCIt)->refattr(SketchPlugin_Constraint::ATTRIBUTE(i));
243       if (!aRefAttr)
244         continue;
245       if (!aRefAttr->isObject())
246         aPoints[aPtInd++] = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(aRefAttr->attr());
247     }
248
249     if (aPoints[0])
250       aCoincidentPoints.addCoincidence(aPoints[0], aPoints[1]);
251   }
252
253   return aCoincidentPoints.coincidentPoints(thePoint);
254 }
255
256 void resetAttribute(SketchPlugin_Feature* theFeature,
257                     const std::string& theId)
258 {
259   AttributePtr anAttr = theFeature->attribute(theId);
260   if(anAttr.get()) {
261     anAttr->reset();
262   }
263 }
264
265 void createCoincidenceOrTangency(SketchPlugin_Feature* theFeature,
266                                  const std::string& theId,
267                                  const AttributePtr theAttr,
268                                  const ObjectPtr theObject,
269                                  const bool theIsCanBeTangent)
270 {
271   AttributeRefAttrPtr aRefAttr = theFeature->refattr(theId);
272   if(aRefAttr.get() && aRefAttr->isInitialized()) {
273     FeaturePtr aConstraint;
274     if(!theIsCanBeTangent) {
275       aConstraint = theFeature->sketch()
276                               ->addFeature(SketchPlugin_ConstraintCoincidence::ID());
277     } else {
278       if(aRefAttr->isObject()) {
279         ObjectPtr anObject = aRefAttr->object();
280         FeaturePtr aFeature = ModelAPI_Feature::feature(anObject);
281         if(aFeature->getKind() == SketchPlugin_Point::ID()) {
282           aConstraint = theFeature->sketch()
283                                   ->addFeature(SketchPlugin_ConstraintCoincidence::ID());
284         } else {
285           aConstraint = theFeature->sketch()
286                                   ->addFeature(SketchPlugin_ConstraintTangent::ID());
287         }
288       } else {
289         aConstraint = theFeature->sketch()
290                                 ->addFeature(SketchPlugin_ConstraintCoincidence::ID());
291       }
292     }
293     AttributeRefAttrPtr aRefAttrA = aConstraint->refattr(SketchPlugin_Constraint::ENTITY_A());
294     aRefAttr->isObject() ? aRefAttrA->setObject(aRefAttr->object())
295                          : aRefAttrA->setAttr(aRefAttr->attr());
296     AttributeRefAttrPtr aRefAttrB = aConstraint->refattr(SketchPlugin_Constraint::ENTITY_B());
297     if(theObject.get()) {
298       aRefAttrB->setObject(theObject);
299     } else if(theAttr.get()) {
300       aRefAttrB->setAttr(theAttr);
301     }
302   }
303 }
304
305 void convertRefAttrToPointOrTangentCurve(const AttributeRefAttrPtr&      theRefAttr,
306                                          const AttributePtr&             theDefaultAttr,
307                                          std::shared_ptr<GeomAPI_Shape>& theTangentCurve,
308                                          std::shared_ptr<GeomAPI_Pnt2d>& thePassingPoint)
309 {
310   AttributePtr anAttr = theDefaultAttr;
311   if (theRefAttr->isObject()) {
312     FeaturePtr aTgFeature = ModelAPI_Feature::feature(theRefAttr->object());
313     if (aTgFeature) {
314       if (aTgFeature->getKind() != SketchPlugin_Point::ID()) {
315         theTangentCurve = aTgFeature->lastResult()->shape();
316         return;
317       }
318       anAttr = aTgFeature->attribute(SketchPlugin_Point::COORD_ID());
319     }
320   } else
321     anAttr = theRefAttr->attr();
322
323   thePassingPoint = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(anAttr)->pnt();
324 }
325
326
327 FeaturePtr createConstraintAttrAttr(SketchPlugin_Sketch* theSketch,
328                                     const std::string& theConstraintId,
329                                     const AttributePtr& theFirstAttribute,
330                                     const AttributePtr& theSecondAttribute)
331 {
332   FeaturePtr aConstraint = theSketch->addFeature(theConstraintId);
333   AttributeRefAttrPtr aRefAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(
334                                  aConstraint->attribute(SketchPlugin_Constraint::ENTITY_A()));
335   aRefAttr->setAttr(theFirstAttribute);
336
337   aRefAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(
338                                  aConstraint->attribute(SketchPlugin_Constraint::ENTITY_B()));
339   aRefAttr->setAttr(theSecondAttribute);
340
341 #if defined(DEBUG_TRIM) || defined(DEBUG_SPLIT)
342   std::cout << "<createConstraint to attribute> :"
343             << " first attribute - " << theFirstAttribute->id()
344             << " second attribute - " << theSecondAttribute->id()
345             << std::endl;
346 #endif
347
348   return aConstraint;
349 }
350
351 FeaturePtr createConstraintAttrObject(SketchPlugin_Sketch* theSketch,
352                                       const std::string& theConstraintId,
353                                       const AttributePtr& theFirstAttribute,
354                                       const ObjectPtr& theSecondObject)
355 {
356   FeaturePtr aConstraint = theSketch->addFeature(theConstraintId);
357   AttributeRefAttrPtr aRefAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(
358                                  aConstraint->attribute(SketchPlugin_Constraint::ENTITY_A()));
359   aRefAttr->setAttr(theFirstAttribute);
360
361   aRefAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(
362                                  aConstraint->attribute(SketchPlugin_Constraint::ENTITY_B()));
363   aRefAttr->setObject(theSecondObject);
364
365 #if defined(DEBUG_TRIM) || defined(DEBUG_SPLIT)
366   std::cout << "<createConstraint to attribute> :"
367             << " first attribute - " << theFirstAttribute->id()
368             << " second object - " << ModelAPI_Feature::feature(theSecondObject)->getKind()
369             << std::endl;
370 #endif
371
372   return aConstraint;
373 }
374
375 FeaturePtr createConstraintObjectObject(SketchPlugin_Sketch* theSketch,
376                                         const std::string& theConstraintId,
377                                         const ObjectPtr& theFirstObject,
378                                         const ObjectPtr& theSecondObject)
379 {
380   FeaturePtr aConstraint = theSketch->addFeature(theConstraintId);
381   AttributeRefAttrPtr aRefAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(
382                                  aConstraint->attribute(SketchPlugin_Constraint::ENTITY_A()));
383   aRefAttr->setObject(theFirstObject);
384
385   aRefAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(
386                                  aConstraint->attribute(SketchPlugin_Constraint::ENTITY_B()));
387   aRefAttr->setObject(theSecondObject);
388
389 #if defined(DEBUG_TRIM) || defined(DEBUG_SPLIT)
390   std::cout << "<createConstraint to attribute> :"
391             << " first object - " << ModelAPI_Feature::feature(theFirstObject)->getKind()
392             << " second object - " << ModelAPI_Feature::feature(theSecondObject)->getKind()
393             << std::endl;
394 #endif
395
396   return aConstraint;
397 }
398
399 GeomPnt2dPtr flyoutPointCoordinates(const ConstraintPtr& theConstraint)
400 {
401   // currently process Length constraints only
402   if (theConstraint->getKind() != SketchPlugin_ConstraintLength::ID())
403     return GeomPnt2dPtr();
404
405   AttributeRefAttrPtr aLineAttr = theConstraint->refattr(SketchPlugin_Constraint::ENTITY_A());
406   if (!aLineAttr || !aLineAttr->isObject())
407     return GeomPnt2dPtr();
408   FeaturePtr aLine = ModelAPI_Feature::feature(aLineAttr->object());
409   if (!aLine || aLine->getKind() != SketchPlugin_Line::ID())
410     return GeomPnt2dPtr();
411
412   std::shared_ptr<GeomAPI_XY> aStartPnt = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
413       aLine->attribute(SketchPlugin_Line::START_ID()))->pnt()->xy();
414   std::shared_ptr<GeomAPI_XY> aEndPnt = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
415       aLine->attribute(SketchPlugin_Line::END_ID()))->pnt()->xy();
416
417   std::shared_ptr<GeomDataAPI_Point2D> aFlyoutAttr =
418       std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
419       theConstraint->attribute(SketchPlugin_Constraint::FLYOUT_VALUE_PNT()));
420   std::shared_ptr<GeomAPI_Pnt2d> aFltPnt = aFlyoutAttr->pnt();
421
422   std::shared_ptr<GeomAPI_Dir2d> aLineDir(new GeomAPI_Dir2d(aEndPnt->decreased(aStartPnt)));
423
424   double X = aStartPnt->x() + aFltPnt->x() * aLineDir->x() - aFltPnt->y() * aLineDir->y();
425   double Y = aStartPnt->y() + aFltPnt->x() * aLineDir->y() + aFltPnt->y() * aLineDir->x();
426
427   return GeomPnt2dPtr(new GeomAPI_Pnt2d(X, Y));
428 }
429
430 } // namespace SketchPlugin_Tools