src/SketchPlugin/SketchPlugin_ConstraintRadius.cpp

   1 // File:    SketchPlugin_ConstraintRadius.cpp
   2 // Created: 26 May 2014
   3 // Author:  Artem ZHIDKOV
   4
   5 #include "SketchPlugin_ConstraintRadius.h"
   6
   7 #include <SketchPlugin_Arc.h>
   8 #include <SketchPlugin_Circle.h>
   9 #include <SketchPlugin_Point.h>
  10
  11 #include <ModelAPI_AttributeDouble.h>
  12 #include <ModelAPI_Data.h>
  13
  14 #include <GeomAPI_Pnt2d.h>
  15 #include <GeomAPI_Circ.h>
  16 #include <GeomAPI_Circ2d.h>
  17 #include <GeomAPI_Dir.h>
  18 #include <GeomAPI_XYZ.h>
  19 #include <GeomDataAPI_Point2D.h>
  20 #include <GeomDataAPI_Dir.h>
  21
  22 #include <Config_PropManager.h>
  23
  24 SketchPlugin_ConstraintRadius::SketchPlugin_ConstraintRadius()
  25 {
  26 }
  27
  28 void SketchPlugin_ConstraintRadius::initAttributes()
  29 {
  30   data()->addAttribute(SketchPlugin_Constraint::VALUE(), ModelAPI_AttributeDouble::type());
  31   data()->addAttribute(SketchPlugin_Constraint::ENTITY_A(), ModelAPI_AttributeRefAttr::type());
  32   data()->addAttribute(SketchPlugin_Constraint::FLYOUT_VALUE_PNT(), GeomDataAPI_Point2D::type());
  33 }
  34
  35 void SketchPlugin_ConstraintRadius::execute()
  36 {
  37   std::shared_ptr<ModelAPI_AttributeRefAttr> aRef = std::dynamic_pointer_cast<
  38       ModelAPI_AttributeRefAttr>(data()->attribute(SketchPlugin_Constraint::ENTITY_A()));
  39   FeaturePtr aFeature = ModelAPI_Feature::feature(aRef->object());
  40   if (aFeature) {
  41     double aRadius = 0;
  42     std::shared_ptr<ModelAPI_Data> aData = aFeature->data();
  43     if (aFeature->getKind() == SketchPlugin_Circle::ID()) {
  44       AttributeDoublePtr anAttribute = std::dynamic_pointer_cast<ModelAPI_AttributeDouble>(
  45           aData->attribute(SketchPlugin_Circle::RADIUS_ID()));
  46       if (anAttribute)
  47         aRadius = anAttribute->value();
  48     } else if (aFeature->getKind() == SketchPlugin_Arc::ID()) {
  49       std::shared_ptr<GeomDataAPI_Point2D> aCenterAttr = std::dynamic_pointer_cast<
  50           GeomDataAPI_Point2D>(aData->attribute(SketchPlugin_Arc::CENTER_ID()));
  51       std::shared_ptr<GeomDataAPI_Point2D> aStartAttr = std::dynamic_pointer_cast<
  52           GeomDataAPI_Point2D>(aData->attribute(SketchPlugin_Arc::START_ID()));
  53       if (aCenterAttr && aStartAttr)
  54         aRadius = aCenterAttr->pnt()->distance(aStartAttr->pnt());
  55     }
  56     //std::shared_ptr<ModelAPI_AttributeDouble> aValueAttr = std::dynamic_pointer_cast<
  57     //    ModelAPI_AttributeDouble>(data()->attribute(SketchPlugin_Constraint::VALUE()));
  58     //if(!aValueAttr->isInitialized()) {
  59     //  aValueAttr->setValue(aRadius);
  60     //}
  61   }
  62 }
  63
  64 double SketchPlugin_ConstraintRadius::circleRadius(std::shared_ptr<ModelAPI_Feature>& theCirc)
  65 {
  66   static const double kErrorResult = -1.;
  67   if (!sketch())
  68     return kErrorResult;
  69
  70   std::shared_ptr<ModelAPI_Data> aData = data();
  71   std::shared_ptr<ModelAPI_AttributeRefAttr> anAttr = std::dynamic_pointer_cast<
  72       ModelAPI_AttributeRefAttr>(aData->attribute(SketchPlugin_Constraint::ENTITY_A()));
  73   if (!anAttr)
  74     return kErrorResult;
  75   theCirc = ModelAPI_Feature::feature(anAttr->object());
  76   std::string aKind = theCirc ? theCirc->getKind() : "";
  77   if (aKind != SketchPlugin_Circle::ID() && aKind != SketchPlugin_Arc::ID())
  78     return kErrorResult;
  79
  80   DataPtr aCircData = theCirc->data();
  81   std::shared_ptr<GeomDataAPI_Point2D> aCenterAttr;
  82   if (aKind == SketchPlugin_Circle::ID()) {
  83     AttributeDoublePtr aCircRadius = std::dynamic_pointer_cast<ModelAPI_AttributeDouble>(
  84         aCircData->attribute(SketchPlugin_Circle::RADIUS_ID()));
  85     return aCircRadius->value();
  86   } else {
  87     aCenterAttr = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
  88         aCircData->attribute(SketchPlugin_Arc::CENTER_ID()));
  89     std::shared_ptr<GeomDataAPI_Point2D> aStartAttr = std::dynamic_pointer_cast<
  90         GeomDataAPI_Point2D>(aCircData->attribute(SketchPlugin_Arc::START_ID()));
  91     return aCenterAttr->pnt()->distance(aStartAttr->pnt());
  92   }
  93   return kErrorResult;
  94 }
  95
  96 AISObjectPtr SketchPlugin_ConstraintRadius::getAISObject(AISObjectPtr thePrevious)
  97 {
  98   std::shared_ptr<ModelAPI_Feature> aCyrcFeature;
  99   double aRadius = circleRadius(aCyrcFeature);
 100   if (aRadius < 0)
 101     return thePrevious; // can not create a good presentation
 102
 103   // Flyout point
 104   std::shared_ptr<GeomDataAPI_Point2D> aFlyoutAttr = std::dynamic_pointer_cast<
 105       GeomDataAPI_Point2D>(data()->attribute(SketchPlugin_Constraint::FLYOUT_VALUE_PNT()));
 106   std::shared_ptr<GeomAPI_Pnt> aFlyoutPnt;
 107   if (aFlyoutAttr->isInitialized()) {
 108     aFlyoutPnt = sketch()->to3D(aFlyoutAttr->x(), aFlyoutAttr->y());
 109   }
 110
 111   // Prepare a circle
 112   std::shared_ptr<GeomDataAPI_Point2D> aCenterAttr;
 113   if (aCyrcFeature->getKind() == SketchPlugin_Circle::ID()) { // circle
 114     aCenterAttr = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 115         aCyrcFeature->data()->attribute(SketchPlugin_Circle::CENTER_ID()));
 116     if (!aFlyoutPnt) {
 117       double aShift = aRadius * 1.1;
 118       std::shared_ptr<GeomAPI_Pnt2d> aPnt = aCenterAttr->pnt();
 119       std::shared_ptr<GeomAPI_Pnt2d> aFPnt =
 120         std::shared_ptr<GeomAPI_Pnt2d>(new GeomAPI_Pnt2d(aPnt->x() + aShift, aPnt->y() + aShift));
 121       aFlyoutAttr->setValue(aFPnt);
 122       aFlyoutPnt = sketch()->to3D(aFPnt->x(), aFPnt->y());
 123     }
 124   } else { // arc
 125     aCenterAttr = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 126         aCyrcFeature->data()->attribute(SketchPlugin_Arc::CENTER_ID()));
 127     if (!aFlyoutPnt) {
 128       std::shared_ptr<GeomDataAPI_Point2D> aStartAttr = std::dynamic_pointer_cast<
 129         GeomDataAPI_Point2D>(aCyrcFeature->data()->attribute(SketchPlugin_Arc::START_ID()));
 130       aFlyoutAttr->setValue(aStartAttr->pnt());
 131       aFlyoutPnt = sketch()->to3D(aStartAttr->pnt()->x(), aStartAttr->pnt()->y());
 132     }
 133   }
 134
 135   std::shared_ptr<GeomAPI_Pnt> aCenter = sketch()->to3D(aCenterAttr->x(), aCenterAttr->y());
 136   std::shared_ptr<GeomDataAPI_Dir> aNDir = std::dynamic_pointer_cast<GeomDataAPI_Dir>(
 137       sketch()->data()->attribute(SketchPlugin_Sketch::NORM_ID()));
 138   std::shared_ptr<GeomAPI_Dir> aNormal = aNDir->dir();
 139   std::shared_ptr<GeomAPI_Circ> aCircle(new GeomAPI_Circ(aCenter, aNormal, aRadius));
 140
 141   // Value
 142   std::shared_ptr<ModelAPI_AttributeDouble> aValueAttr = std::dynamic_pointer_cast<
 143       ModelAPI_AttributeDouble>(data()->attribute(SketchPlugin_Constraint::VALUE()));
 144   if (aValueAttr->isInitialized())
 145     aRadius = aValueAttr->value();
 146   AISObjectPtr anAIS = thePrevious;
 147   if (!anAIS)
 148     anAIS = AISObjectPtr(new GeomAPI_AISObject);
 149   anAIS->createRadius(aCircle, aFlyoutPnt, aRadius);
 150
 151   // Set color from preferences
 152   std::vector<int> aRGB = Config_PropManager::color("Visualization", "radius_color", RADIUS_COLOR);
 153   anAIS->setColor(aRGB[0], aRGB[1], aRGB[2]);
 154   return anAIS;
 155 }
 156
 157 void SketchPlugin_ConstraintRadius::move(double theDeltaX, double theDeltaY)
 158 {
 159   std::shared_ptr<ModelAPI_Data> aData = data();
 160   if (!aData->isValid())
 161     return;
 162
 163   std::shared_ptr<ModelAPI_AttributeRefAttr> aRef = std::dynamic_pointer_cast<
 164       ModelAPI_AttributeRefAttr>(data()->attribute(SketchPlugin_Constraint::ENTITY_A()));
 165   FeaturePtr aFeature = ModelAPI_Feature::feature(aRef->object());
 166   if (!aFeature)
 167     return;
 168   std::string aCenterAttrName;
 169   if (aFeature->getKind() == SketchPlugin_Circle::ID())
 170     aCenterAttrName = SketchPlugin_Circle::CENTER_ID();
 171   else if (aFeature->getKind() == SketchPlugin_Arc::ID())
 172     aCenterAttrName = SketchPlugin_Arc::CENTER_ID();
 173   std::shared_ptr<GeomDataAPI_Point2D> aCenterAttr = std::dynamic_pointer_cast<
 174       GeomDataAPI_Point2D>(aFeature->data()->attribute(aCenterAttrName));
 175   std::shared_ptr<GeomAPI_Pnt2d> aCenter = aCenterAttr->pnt();
 176
 177   // The specified delta applied on the circle curve,
 178   // so it will be scaled due to distance between flyout and center points
 179   std::shared_ptr<GeomDataAPI_Point2D> aFlyoutAttr = std::dynamic_pointer_cast<
 180       GeomDataAPI_Point2D>(aData->attribute(SketchPlugin_Constraint::FLYOUT_VALUE_PNT()));
 181   std::shared_ptr<GeomAPI_Pnt2d> aFlyout = aFlyoutAttr->pnt();
 182
 183   std::shared_ptr<ModelAPI_AttributeDouble> aRadius = std::dynamic_pointer_cast<
 184       ModelAPI_AttributeDouble>(aData->attribute(SketchPlugin_Constraint::VALUE()));
 185   double aScale = aFlyout->distance(aCenter) / aRadius->value();
 186
 187   std::shared_ptr<GeomAPI_Circ2d> aCircle(new GeomAPI_Circ2d(aCenter, aFlyout));
 188   aFlyout->setX(aFlyout->x() + aScale * theDeltaX);
 189   aFlyout->setY(aFlyout->y() + aScale * theDeltaY);
 190   aFlyout = aCircle->project(aFlyout);
 191
 192   aFlyoutAttr->setValue(aFlyout->x(), aFlyout->y());
 193 }
 194
 195 void SketchPlugin_ConstraintRadius::attributeChanged(const std::string& theID) {
 196   if (theID == SketchPlugin_Constraint::ENTITY_A()) {
 197     std::shared_ptr<ModelAPI_AttributeDouble> aValueAttr = std::dynamic_pointer_cast<
 198         ModelAPI_AttributeDouble>(data()->attribute(SketchPlugin_Constraint::VALUE()));
 199     if (!aValueAttr->isInitialized()) { // only if it is not initialized, try to compute the current value
 200       std::shared_ptr<ModelAPI_Feature> aCyrcFeature;
 201       double aRadius = circleRadius(aCyrcFeature);
 202       if (aRadius > 0) { // set as value the radius of updated reference to another circle
 203         aValueAttr->setValue(aRadius);
 204       }
 205     }
 206   }
 207 }