X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FSketchPlugin%2FSketchPlugin_Arc.cpp;h=312297733b333c670c75677006ee0d191e121d0e;hb=66859c0ae6411d853ce27be9502d3b2f9d9bd5d1;hp=ec9d227deec81d97d63e91b2eec985cee2d73a7b;hpb=29083ee3765ce3f564eb4fa6c93620084acfb067;p=modules%2Fshaper.git

diff --git a/src/SketchPlugin/SketchPlugin_Arc.cpp b/src/SketchPlugin/SketchPlugin_Arc.cpp
index ec9d227de..312297733 100644
--- a/src/SketchPlugin/SketchPlugin_Arc.cpp
+++ b/src/SketchPlugin/SketchPlugin_Arc.cpp
@@ -1,3 +1,5 @@
+// Copyright (C) 2014-20xx CEA/DEN, EDF R&D -->
+
 // File:        SketchPlugin_Arc.cpp
 // Created:     26 Apr 2014
 // Author:      Artem ZHIDKOV
@@ -8,133 +10,190 @@
 #include <ModelAPI_ResultConstruction.h>
 #include <ModelAPI_AttributeSelection.h>
 #include <ModelAPI_Validator.h>
+#include <ModelAPI_Session.h>
 
 #include <GeomAPI_Circ2d.h>
+#include <GeomAPI_Circ.h>
 #include <GeomAPI_Pnt2d.h>
 #include <GeomDataAPI_Point2D.h>
 #include <GeomDataAPI_Dir.h>
 #include <GeomAlgoAPI_PointBuilder.h>
 #include <GeomAlgoAPI_EdgeBuilder.h>
 #include <GeomAlgoAPI_CompoundBuilder.h>
+// for sqrt on Linux
+#include <math.h>
 
 const double tolerance = 1e-7;
 
 SketchPlugin_Arc::SketchPlugin_Arc()
-    : SketchPlugin_Feature()
+    : SketchPlugin_SketchEntity()
 {
+  myStartUpdate = false;
+  myEndUpdate = false;
+  // default values
+  myXEndBefore = 0;
+  myYEndBefore = 0;
 }
 
 void SketchPlugin_Arc::initAttributes()
 {
-  data()->addAttribute(CENTER_ID(), GeomDataAPI_Point2D::type());
-  data()->addAttribute(START_ID(), GeomDataAPI_Point2D::type());
-  data()->addAttribute(END_ID(), GeomDataAPI_Point2D::type());
-  data()->addAttribute(EXTERNAL_ID(), ModelAPI_AttributeSelection::type());
+  SketchPlugin_SketchEntity::initAttributes();
+
+  data()->addAttribute(CENTER_ID(), GeomDataAPI_Point2D::typeId());
+  data()->addAttribute(START_ID(), GeomDataAPI_Point2D::typeId());
+  std::shared_ptr<GeomDataAPI_Point2D> anEndAttr = std::dynamic_pointer_cast<
+    GeomDataAPI_Point2D>(data()->addAttribute(END_ID(), GeomDataAPI_Point2D::typeId()));
+  data()->addAttribute(EXTERNAL_ID(), ModelAPI_AttributeSelection::typeId());
   ModelAPI_Session::get()->validators()->registerNotObligatory(getKind(), EXTERNAL_ID());
+
+  // get the initial values
+  if (anEndAttr->isInitialized()) {
+    myXEndBefore = anEndAttr->x();
+    myYEndBefore = anEndAttr->y();
+  }
 }
 
 void SketchPlugin_Arc::execute()
 {
   SketchPlugin_Sketch* aSketch = sketch();
-  if (aSketch) {
-    std::list<boost::shared_ptr<GeomAPI_Shape> > aShapes;
-
+  // result for the arc is set only when all obligatory attributes are initialized,
+  // otherwise AIS object is used to visualize the arc's preview
+  if (aSketch && isFeatureValid()) {
     // compute a circle point in 3D view
-    boost::shared_ptr<GeomDataAPI_Point2D> aCenterAttr = boost::dynamic_pointer_cast<
-        GeomDataAPI_Point2D>(data()->attribute(SketchPlugin_Arc::CENTER_ID()));
+    std::shared_ptr<GeomDataAPI_Point2D> aCenterAttr = std::dynamic_pointer_cast<
+        GeomDataAPI_Point2D>(data()->attribute(CENTER_ID()));
     // compute the arc start point
-    boost::shared_ptr<GeomDataAPI_Point2D> aStartAttr = boost::dynamic_pointer_cast<
-        GeomDataAPI_Point2D>(data()->attribute(SketchPlugin_Arc::START_ID()));
-    if (aCenterAttr->isInitialized() && aStartAttr->isInitialized()) {
-      boost::shared_ptr<GeomAPI_Pnt> aCenter(aSketch->to3D(aCenterAttr->x(), aCenterAttr->y()));
-      // make a visible point
-      boost::shared_ptr<GeomAPI_Shape> aCenterPointShape = GeomAlgoAPI_PointBuilder::point(aCenter);
-      //aShapes.push_back(aCenterPointShape);
-      boost::shared_ptr<ModelAPI_ResultConstruction> aConstr1 = document()->createConstruction(
-          data(), 0);
-      aConstr1->setShape(aCenterPointShape);
-      aConstr1->setIsInHistory(false);
-      setResult(aConstr1, 0);
-
-      // make a visible circle
-      boost::shared_ptr<GeomDataAPI_Dir> aNDir = boost::dynamic_pointer_cast<GeomDataAPI_Dir>(
-          aSketch->data()->attribute(SketchPlugin_Sketch::NORM_ID()));
-      bool aHasPlane = aNDir && !(aNDir->x() == 0 && aNDir->y() == 0 && aNDir->z() == 0);
-      if (aHasPlane) {
-        boost::shared_ptr<GeomAPI_Dir> aNormal = aNDir->dir();
-        boost::shared_ptr<GeomAPI_Pnt> aStartPoint(aSketch->to3D(aStartAttr->x(), aStartAttr->y()));
-
-        // compute and change the arc end point
-        boost::shared_ptr<GeomDataAPI_Point2D> anEndAttr = boost::dynamic_pointer_cast<
-            GeomDataAPI_Point2D>(data()->attribute(SketchPlugin_Arc::END_ID()));
-        if (anEndAttr->isInitialized()) {
-          boost::shared_ptr<GeomAPI_Circ2d> aCircleForArc(
-              new GeomAPI_Circ2d(aCenterAttr->pnt(), aStartAttr->pnt()));
-          boost::shared_ptr<GeomAPI_Pnt2d> aProjection = aCircleForArc->project(anEndAttr->pnt());
-          if (aProjection && anEndAttr->pnt()->distance(aProjection) > tolerance)
-            anEndAttr->setValue(aProjection);
-        }
-        boost::shared_ptr<GeomAPI_Pnt> aEndPoint(aSketch->to3D(anEndAttr->x(), anEndAttr->y()));
-
-        boost::shared_ptr<GeomAPI_Shape> aCircleShape = GeomAlgoAPI_EdgeBuilder::lineCircleArc(
-            aCenter, aStartPoint, aEndPoint, aNormal);
-        if (aCircleShape) {
-          boost::shared_ptr<ModelAPI_ResultConstruction> aConstr2 = document()->createConstruction(
-              data(), 1);
-          aConstr2->setShape(aCircleShape);
-          aConstr2->setIsInHistory(false);
-          setResult(aConstr2, 1);
-          //aShapes.push_back(aCircleShape);
+    std::shared_ptr<GeomDataAPI_Point2D> aStartAttr = std::dynamic_pointer_cast<
+        GeomDataAPI_Point2D>(data()->attribute(START_ID()));
+
+    std::shared_ptr<GeomAPI_Pnt> aCenter(aSketch->to3D(aCenterAttr->x(), aCenterAttr->y()));
+    // make a visible point
+    std::shared_ptr<GeomAPI_Shape> aCenterPointShape = GeomAlgoAPI_PointBuilder::point(aCenter);
+    std::shared_ptr<ModelAPI_ResultConstruction> aConstr1 = document()->createConstruction(
+        data(), 0);
+    aConstr1->setShape(aCenterPointShape);
+    aConstr1->setIsInHistory(false);
+    setResult(aConstr1, 0);
+
+    // make a visible circle
+    std::shared_ptr<GeomDataAPI_Dir> aNDir = std::dynamic_pointer_cast<GeomDataAPI_Dir>(
+        aSketch->data()->attribute(SketchPlugin_Sketch::NORM_ID()));
+    std::shared_ptr<GeomAPI_Dir> aNormal = aNDir->dir();
+    std::shared_ptr<GeomAPI_Pnt> aStartPoint(aSketch->to3D(aStartAttr->x(), aStartAttr->y()));
+
+    // compute and change the arc end point
+    std::shared_ptr<GeomDataAPI_Point2D> anEndAttr = std::dynamic_pointer_cast<
+        GeomDataAPI_Point2D>(data()->attribute(END_ID()));
+    /* must be automatically done in attributeChanged
+    std::shared_ptr<GeomAPI_Circ2d> aCircleForArc(
+        new GeomAPI_Circ2d(aCenterAttr->pnt(), aStartAttr->pnt()));
+    std::shared_ptr<GeomAPI_Pnt2d> aProjection = aCircleForArc->project(anEndAttr->pnt());
+    if (aProjection && anEndAttr->pnt()->distance(aProjection) > tolerance)
+      anEndAttr->setValue(aProjection);
+    */
+    std::shared_ptr<GeomAPI_Pnt> aEndPoint(aSketch->to3D(anEndAttr->x(), anEndAttr->y()));
+
+    std::shared_ptr<GeomAPI_Shape> aCircleShape = GeomAlgoAPI_EdgeBuilder::lineCircleArc(
+        aCenter, aStartPoint, aEndPoint, aNormal);
+    if (aCircleShape) {
+      std::shared_ptr<ModelAPI_ResultConstruction> aConstr2 = document()->createConstruction(
+          data(), 1);
+      aConstr2->setShape(aCircleShape);
+      aConstr2->setIsInHistory(false);
+      setResult(aConstr2, 1);
+    }
+  }
+}
+
+AISObjectPtr SketchPlugin_Arc::getAISObject(AISObjectPtr thePrevious)
+{
+  SketchPlugin_Sketch* aSketch = sketch();
+  if (aSketch) {
+    // if the feature is valid, the execute() method should be performed, AIS object is empty
+    if (!isFeatureValid()) {
+      // compute a circle point in 3D view
+      std::shared_ptr<GeomDataAPI_Point2D> aCenterAttr = std::dynamic_pointer_cast<
+          GeomDataAPI_Point2D>(data()->attribute(CENTER_ID()));
+      if (aCenterAttr->isInitialized()) {
+        std::shared_ptr<GeomAPI_Pnt> aCenter(aSketch->to3D(aCenterAttr->x(), aCenterAttr->y()));
+
+        std::shared_ptr<GeomDataAPI_Point2D> aStartAttr = std::dynamic_pointer_cast<
+            GeomDataAPI_Point2D>(data()->attribute(SketchPlugin_Arc::START_ID()));
+        if (aStartAttr->isInitialized()) {
+          // make a visible circle
+          std::shared_ptr<GeomDataAPI_Dir> aNDir = std::dynamic_pointer_cast<GeomDataAPI_Dir>(
+              aSketch->data()->attribute(SketchPlugin_Sketch::NORM_ID()));
+          bool aHasPlane = aNDir && !(aNDir->x() == 0 && aNDir->y() == 0 && aNDir->z() == 0);
+          if (aHasPlane) {
+            std::shared_ptr<GeomAPI_Dir> aNormal = aNDir->dir();
+            std::shared_ptr<GeomAPI_Pnt> aStartPoint(aSketch->to3D(aStartAttr->x(), aStartAttr->y()));
+            std::shared_ptr<GeomAPI_Shape> aCircleShape = GeomAlgoAPI_EdgeBuilder::lineCircleArc(
+                                                            aCenter, aStartPoint, aStartPoint, aNormal);
+            if (aCircleShape) {
+              std::list<std::shared_ptr<GeomAPI_Shape> > aShapes;
+              // make a visible point
+              std::shared_ptr<GeomAPI_Shape> aCenterPointShape = GeomAlgoAPI_PointBuilder::point(aCenter);
+              aShapes.push_back(aCenterPointShape);
+
+              aShapes.push_back(aCircleShape);
+              if (!aShapes.empty())
+              {
+                std::shared_ptr<GeomAPI_Shape> aCompound = GeomAlgoAPI_CompoundBuilder::compound(aShapes);
+                AISObjectPtr anAIS = thePrevious;
+                if (!anAIS)
+                  anAIS = AISObjectPtr(new GeomAPI_AISObject);
+                anAIS->createShape(aCompound);
+                anAIS->setWidth(3);
+                return anAIS;
+              }
+            }
+          }
         }
       }
-      /*
-       boost::shared_ptr<GeomAPI_Shape> aCompound = GeomAlgoAPI_CompoundBuilder::compound(aShapes);
-       // store the result
-       boost::shared_ptr<ModelAPI_ResultConstruction> aConstr = 
-       document()->createConstruction(data());
-       aConstr->setShape(aCompound);
-       aConstr->setIsInHistory(false);
-       setResult(aConstr);
-       */
     }
   }
+  return AISObjectPtr();
 }
 
 void SketchPlugin_Arc::move(double theDeltaX, double theDeltaY)
 {
-  boost::shared_ptr<ModelAPI_Data> aData = data();
+  std::shared_ptr<ModelAPI_Data> aData = data();
   if (!aData->isValid())
     return;
 
-  boost::shared_ptr<GeomDataAPI_Point2D> aPoint1 = boost::dynamic_pointer_cast<GeomDataAPI_Point2D>(
-      aData->attribute(SketchPlugin_Arc::CENTER_ID()));
-  aPoint1->setValue(aPoint1->x() + theDeltaX, aPoint1->y() + theDeltaY);
-
-  boost::shared_ptr<GeomDataAPI_Point2D> aPoint2 = boost::dynamic_pointer_cast<GeomDataAPI_Point2D>(
+  myStartUpdate = true;
+  myEndUpdate = true;
+  std::shared_ptr<GeomDataAPI_Point2D> aPoint2 = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
       aData->attribute(SketchPlugin_Arc::START_ID()));
-  aPoint2->setValue(aPoint2->x() + theDeltaX, aPoint2->y() + theDeltaY);
+  aPoint2->move(theDeltaX, theDeltaY);
 
-  boost::shared_ptr<GeomDataAPI_Point2D> aPoint3 = boost::dynamic_pointer_cast<GeomDataAPI_Point2D>(
+  std::shared_ptr<GeomDataAPI_Point2D> aPoint3 = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
       aData->attribute(SketchPlugin_Arc::END_ID()));
-  aPoint3->setValue(aPoint3->x() + theDeltaX, aPoint3->y() + theDeltaY);
+  aPoint3->move(theDeltaX, theDeltaY);
+  myStartUpdate = false;
+  myEndUpdate = false;
+
+  std::shared_ptr<GeomDataAPI_Point2D> aPoint1 = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
+      aData->attribute(SketchPlugin_Arc::CENTER_ID()));
+  aPoint1->move(theDeltaX, theDeltaY);
 }
 
-double SketchPlugin_Arc::distanceToPoint(const boost::shared_ptr<GeomAPI_Pnt2d>& thePoint)
+double SketchPlugin_Arc::distanceToPoint(const std::shared_ptr<GeomAPI_Pnt2d>& thePoint)
 {
   double aDelta = 0;
-  boost::shared_ptr<ModelAPI_Data> aData = data();
+  std::shared_ptr<ModelAPI_Data> aData = data();
 
-  boost::shared_ptr<GeomDataAPI_Point2D> aPoint1 = boost::dynamic_pointer_cast<GeomDataAPI_Point2D>(
+  std::shared_ptr<GeomDataAPI_Point2D> aPoint1 = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
       aData->attribute(SketchPlugin_Arc::CENTER_ID()));
   aDelta = aPoint1->pnt()->distance(thePoint);
 
-  boost::shared_ptr<GeomDataAPI_Point2D> aPoint2 = boost::dynamic_pointer_cast<GeomDataAPI_Point2D>(
+  std::shared_ptr<GeomDataAPI_Point2D> aPoint2 = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
       aData->attribute(SketchPlugin_Arc::START_ID()));
   double aDistance = aPoint2->pnt()->distance(thePoint);
   if (aDelta < aDistance)
     aDelta = aDistance;
 
-  boost::shared_ptr<GeomDataAPI_Point2D> aPoint3 = boost::dynamic_pointer_cast<GeomDataAPI_Point2D>(
+  std::shared_ptr<GeomDataAPI_Point2D> aPoint3 = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
       aData->attribute(SketchPlugin_Arc::END_ID()));
   aDistance = aPoint3->pnt()->distance(thePoint);
   if (aDelta < aDistance)
@@ -144,5 +203,108 @@ double SketchPlugin_Arc::distanceToPoint(const boost::shared_ptr<GeomAPI_Pnt2d>&
 }
 
 bool SketchPlugin_Arc::isFixed() {
-  return data()->selection(EXTERNAL_ID())->context();
+  return data()->selection(EXTERNAL_ID())->context().get() != NULL;
+}
+
+bool SketchPlugin_Arc::isFeatureValid()
+{
+  std::shared_ptr<GeomDataAPI_Point2D> aCenterAttr = std::dynamic_pointer_cast<
+      GeomDataAPI_Point2D>(data()->attribute(SketchPlugin_Arc::CENTER_ID()));
+  std::shared_ptr<GeomDataAPI_Point2D> aStartAttr = std::dynamic_pointer_cast<
+      GeomDataAPI_Point2D>(data()->attribute(SketchPlugin_Arc::START_ID()));
+  std::shared_ptr<GeomDataAPI_Point2D> anEndAttr = std::dynamic_pointer_cast<
+      GeomDataAPI_Point2D>(data()->attribute(SketchPlugin_Arc::END_ID()));
+
+  return aCenterAttr->isInitialized() && aStartAttr->isInitialized() && anEndAttr->isInitialized();
+}
+
+void SketchPlugin_Arc::attributeChanged(const std::string& theID)
+{
+  std::shared_ptr<GeomDataAPI_Point2D> aCenterAttr = std::dynamic_pointer_cast<
+      GeomDataAPI_Point2D>(data()->attribute(CENTER_ID()));
+  std::shared_ptr<GeomDataAPI_Point2D> aStartAttr = std::dynamic_pointer_cast<
+      GeomDataAPI_Point2D>(data()->attribute(START_ID()));
+  std::shared_ptr<GeomDataAPI_Point2D> anEndAttr = std::dynamic_pointer_cast<
+      GeomDataAPI_Point2D>(data()->attribute(END_ID()));
+  // the second condition for unability to move external segments anywhere
+  if (theID == EXTERNAL_ID() || isFixed()) {
+    std::shared_ptr<GeomAPI_Shape> aSelection = data()->selection(EXTERNAL_ID())->value();
+    // update arguments due to the selection value
+    if (aSelection && !aSelection->isNull() && aSelection->isEdge()) {
+      std::shared_ptr<GeomAPI_Edge> anEdge( new GeomAPI_Edge(aSelection));
+      std::shared_ptr<GeomAPI_Circ> aCirc = anEdge->circle();
+      if (aCirc.get()) {
+        aStartAttr->setValue(sketch()->to2D(anEdge->firstPoint()));
+        anEndAttr->setValue(sketch()->to2D(anEdge->lastPoint()));
+        aCenterAttr->setValue(sketch()->to2D(aCirc->center()));
+      }
+    }
+    return;
+  }
+  if (!aCenterAttr->isInitialized())
+    return;
+  if (!aStartAttr->isInitialized())
+    return;
+  if (!anEndAttr->isInitialized())
+    return;
+
+  // update the points in accordance to the changed point changes
+  if (theID == END_ID() && !myEndUpdate) {
+    myEndUpdate = true;
+    // compute and change the arc end point
+    std::shared_ptr<GeomAPI_Circ2d> aCircleForArc(
+        new GeomAPI_Circ2d(aCenterAttr->pnt(), aStartAttr->pnt()));
+    std::shared_ptr<GeomAPI_Pnt2d> aProjection = aCircleForArc->project(anEndAttr->pnt());
+    if (aProjection && anEndAttr->pnt()->distance(aProjection) > tolerance) {
+      // issue #855: trying to update only not-updated coordinate if it is possible
+      if (abs(myXEndBefore - anEndAttr->x()) < 1.e-10) { // keep Y unchanged
+        double aVy = aCenterAttr->y() - anEndAttr->y();
+        double aVy2 = aVy * aVy;
+        double aR2 = aCircleForArc->radius() * aCircleForArc->radius();
+        if (aVy2 <= aR2) {
+          double aDX = sqrt(aR2 - aVy * aVy);
+          if (anEndAttr->x() > aCenterAttr->x())
+            aProjection->setX(aCenterAttr->x() + aDX);
+          else 
+            aProjection->setX(aCenterAttr->x() - aDX);
+          aProjection->setY(anEndAttr->y());
+        }
+      } else if (abs(myYEndBefore - anEndAttr->y()) < 1.e-10) { // keep X unchanged
+        double aVx = aCenterAttr->x() - anEndAttr->x();
+        double aVx2 = aVx * aVx;
+        double aR2 = aCircleForArc->radius() * aCircleForArc->radius();
+        if (aVx2 <= aR2) {
+          double aDY = sqrt(aR2 - aVx * aVx);
+          if (anEndAttr->y() > aCenterAttr->y())
+            aProjection->setY(aCenterAttr->y() + aDY);
+          else 
+            aProjection->setY(aCenterAttr->y() - aDY);
+          aProjection->setX(anEndAttr->x());
+        }
+      }
+
+      anEndAttr->setValue(aProjection);
+    }
+    myXEndBefore = anEndAttr->x();
+    myYEndBefore = anEndAttr->y();
+    myEndUpdate = false;
+  } else if (theID == START_ID() && !myStartUpdate) {
+    myStartUpdate = true;
+    // compute and change the arc start point
+    std::shared_ptr<GeomAPI_Circ2d> aCircleForArc(
+        new GeomAPI_Circ2d(aCenterAttr->pnt(), anEndAttr->pnt()));
+    std::shared_ptr<GeomAPI_Pnt2d> aProjection = aCircleForArc->project(aStartAttr->pnt());
+    if (aProjection && aStartAttr->pnt()->distance(aProjection) > tolerance)
+      aStartAttr->setValue(aProjection);
+    myStartUpdate = false;
+  } else if (theID == CENTER_ID() && !myEndUpdate) {
+    myEndUpdate = true;
+    // compute and change the arc end point
+    std::shared_ptr<GeomAPI_Circ2d> aCircleForArc(
+        new GeomAPI_Circ2d(aCenterAttr->pnt(), aStartAttr->pnt()));
+    std::shared_ptr<GeomAPI_Pnt2d> aProjection = aCircleForArc->project(anEndAttr->pnt());
+    if (aProjection && anEndAttr->pnt()->distance(aProjection) > tolerance)
+      anEndAttr->setValue(aProjection);
+    myEndUpdate = false;
+  }
 }