src/SketchPlugin/SketchPlugin_Tools.cpp

   1 // Copyright (C) 2014-20xx CEA/DEN, EDF R&D -->
   2
   3 // File:        SketchPlugin_Tools.cpp
   4 // Created:     07 July 2015
   5 // Author:      Sergey POKHODENKO
   6
   7 #include "SketchPlugin_Tools.h"
   8
   9 #include "SketchPlugin_ConstraintCoincidence.h"
  10 #include "SketchPlugin_ConstraintTangent.h"
  11 #include "SketchPlugin_Point.h"
  12 #include "SketchPlugin_SketchEntity.h"
  13
  14 #include <SketcherPrs_Tools.h>
  15
  16 #include <ModelAPI_AttributeDouble.h>
  17
  18 #include <GeomDataAPI_Point.h>
  19 #include <GeomDataAPI_Point2D.h>
  20
  21 namespace SketchPlugin_Tools {
  22
  23 void clearExpressions(AttributeDoublePtr theAttribute)
  24 {
  25   theAttribute->setText(std::string());
  26 }
  27
  28 void clearExpressions(AttributePointPtr theAttribute)
  29 {
  30   theAttribute->setText(std::string(), std::string(), std::string());
  31 }
  32
  33 void clearExpressions(AttributePoint2DPtr theAttribute)
  34 {
  35   theAttribute->setText(std::string(), std::string());
  36 }
  37
  38 void clearExpressions(AttributePtr theAttribute)
  39 {
  40   // Double
  41   AttributeDoublePtr anAttributeDouble =
  42       std::dynamic_pointer_cast<ModelAPI_AttributeDouble>(theAttribute);
  43   if (anAttributeDouble.get())
  44     clearExpressions(anAttributeDouble);
  45   // Point
  46   AttributePointPtr anAttributePoint =
  47       std::dynamic_pointer_cast<GeomDataAPI_Point>(theAttribute);
  48   if (anAttributePoint.get())
  49     clearExpressions(anAttributePoint);
  50   // Point2D
  51   AttributePoint2DPtr anAttributePoint2D =
  52       std::dynamic_pointer_cast<GeomDataAPI_Point2D>(theAttribute);
  53   if (anAttributePoint2D.get())
  54     clearExpressions(anAttributePoint2D);
  55 }
  56
  57 void clearExpressions(FeaturePtr theFeature)
  58 {
  59   if (!theFeature.get())
  60     return;
  61
  62   std::list<AttributePtr> anAttributes = theFeature->data()->attributes(std::string());
  63   std::list<AttributePtr>::iterator anAttributeIt = anAttributes.begin();
  64   for (; anAttributeIt != anAttributes.end(); ++anAttributeIt) {
  65     clearExpressions(*anAttributeIt);
  66   }
  67 }
  68
  69 std::shared_ptr<GeomAPI_Pnt2d> getCoincidencePoint(const FeaturePtr theStartCoin)
  70 {
  71   std::shared_ptr<GeomAPI_Pnt2d> aPnt = SketcherPrs_Tools::getPoint(theStartCoin.get(),
  72                                                           SketchPlugin_Constraint::ENTITY_A());
  73   if (aPnt.get() == NULL)
  74     aPnt = SketcherPrs_Tools::getPoint(theStartCoin.get(), SketchPlugin_Constraint::ENTITY_B());
  75   return aPnt;
  76 }
  77
  78 void findCoincidences(const FeaturePtr theStartCoin,
  79                       const std::string& theAttr,
  80                       std::set<FeaturePtr>& theList)
  81 {
  82   AttributeRefAttrPtr aPnt = theStartCoin->refattr(theAttr);
  83   if(!aPnt) {
  84     return;
  85   }
  86   FeaturePtr aObj = ModelAPI_Feature::feature(aPnt->object());
  87   if(theList.find(aObj) == theList.end()) {
  88     std::shared_ptr<GeomAPI_Pnt2d> aOrig = getCoincidencePoint(theStartCoin);
  89     if(aOrig.get() == NULL) {
  90       return;
  91     }
  92     theList.insert(aObj);
  93     const std::set<AttributePtr>& aRefsList = aObj->data()->refsToMe();
  94     std::set<AttributePtr>::const_iterator aIt;
  95     for(aIt = aRefsList.cbegin(); aIt != aRefsList.cend(); ++aIt) {
  96       std::shared_ptr<ModelAPI_Attribute> aAttr = (*aIt);
  97       FeaturePtr aConstrFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(aAttr->owner());
  98       if(aConstrFeature->getKind() == SketchPlugin_ConstraintCoincidence::ID()) {
  99         std::shared_ptr<GeomAPI_Pnt2d> aPnt = getCoincidencePoint(aConstrFeature);
 100         if(aPnt.get() && aOrig->isEqual(aPnt)) {
 101           findCoincidences(aConstrFeature, SketchPlugin_ConstraintCoincidence::ENTITY_A(), theList);
 102           findCoincidences(aConstrFeature, SketchPlugin_ConstraintCoincidence::ENTITY_B(), theList);
 103         }
 104       }
 105     }
 106   }
 107 }
 108
 109 void createConstraint(SketchPlugin_Feature* theFeature,
 110                       const std::string& theId,
 111                       const AttributePtr theAttr,
 112                       const ObjectPtr theObject,
 113                       const bool theIsCanBeTangent)
 114 {
 115   AttributeRefAttrPtr aRefAttr = theFeature->refattr(theId);
 116   if(aRefAttr.get() && aRefAttr->isInitialized()) {
 117     FeaturePtr aConstraint;
 118     if(!theIsCanBeTangent) {
 119       aConstraint = theFeature->sketch()
 120                               ->addFeature(SketchPlugin_ConstraintCoincidence::ID());
 121     } else {
 122       if(aRefAttr->isObject()) {
 123         ObjectPtr anObject = aRefAttr->object();
 124         FeaturePtr aFeature = ModelAPI_Feature::feature(anObject);
 125         if(aFeature->getKind() == SketchPlugin_Point::ID()) {
 126           aConstraint = theFeature->sketch()
 127                                   ->addFeature(SketchPlugin_ConstraintCoincidence::ID());
 128         } else {
 129           aConstraint = theFeature->sketch()
 130                                   ->addFeature(SketchPlugin_ConstraintTangent::ID());
 131         }
 132       } else {
 133         aConstraint = theFeature->sketch()
 134                                 ->addFeature(SketchPlugin_ConstraintCoincidence::ID());
 135       }
 136     }
 137     AttributeRefAttrPtr aRefAttrA = aConstraint->refattr(SketchPlugin_Constraint::ENTITY_A());
 138     aRefAttr->isObject() ? aRefAttrA->setObject(aRefAttr->object())
 139                          : aRefAttrA->setAttr(aRefAttr->attr());
 140     AttributeRefAttrPtr aRefAttrB = aConstraint->refattr(SketchPlugin_Constraint::ENTITY_B());
 141     if(theObject.get()) {
 142       aRefAttrB->setObject(theObject);
 143     } else if(theAttr.get()) {
 144       aRefAttrB->setAttr(theAttr);
 145     }
 146   }
 147 }
 148 } // namespace SketchPlugin_Tools