X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FSketcherPrs%2FSketcherPrs_PositionMgr.cpp;h=22d9837129720d09cd36def4c13187900df73568;hb=54722f01656c4e5c67a3cdc04aa57ef614b6a446;hp=5237b18e2b038f8c6d8300320ddbcc02037a6435;hpb=ec6aaa4d8bd3609b04ea85683e1b1175b6632238;p=modules%2Fshaper.git

diff --git a/src/SketcherPrs/SketcherPrs_PositionMgr.cpp b/src/SketcherPrs/SketcherPrs_PositionMgr.cpp
index 5237b18e2..22d983712 100644
--- a/src/SketcherPrs/SketcherPrs_PositionMgr.cpp
+++ b/src/SketcherPrs/SketcherPrs_PositionMgr.cpp
@@ -5,14 +5,16 @@
 // Author:      Vitaly SMETANNIKOV
 
 #include "SketcherPrs_PositionMgr.h"
+#include "SketcherPrs_Tools.h"
 
 #include <GeomAPI_Edge.h>
-
-static const int MyStep = 20;
+#include <GeomAPI_Curve.h>
+#include <GeomAPI_Vertex.h>
+#include <GeomAPI_Dir.h>
 
 static SketcherPrs_PositionMgr* MyPosMgr = NULL;
 
-
+// The class is implemented as a singlton
 SketcherPrs_PositionMgr* SketcherPrs_PositionMgr::get()
 {
   if (MyPosMgr == NULL) 
@@ -25,46 +27,79 @@ SketcherPrs_PositionMgr::SketcherPrs_PositionMgr()
 }
 
 
-int SketcherPrs_PositionMgr::getPositionIndex(std::shared_ptr<GeomAPI_Shape> theLine, 
-                                              Handle(SketcherPrs_SymbolPrs) thePrs)
+int SketcherPrs_PositionMgr::getPositionIndex(ObjectPtr theLine, 
+                                              const SketcherPrs_SymbolPrs* thePrs)
 {
   if (myShapes.count(theLine) == 1) {
+    // Find the map and add new [Presentation - Index] pair
     PositionsMap& aPosMap = myShapes[theLine];
-    if (aPosMap.count(thePrs.Access()) == 1) {
-      return aPosMap[thePrs.Access()];
+    if (aPosMap.count(thePrs) == 1) {
+      // return existing index
+      return aPosMap[thePrs];
     } else {
-      int aInd = aPosMap.size();
-      aPosMap[thePrs.Access()] = aInd;
+      // Add a new [Presentation - Index] pair
+      int aInd = int(aPosMap.size());
+      aPosMap[thePrs] = aInd;
       return aInd;
     }
   } else {
+    // Create a new map with initial index
     PositionsMap aPosMap;
-    aPosMap[thePrs.Access()] = 0;
+    aPosMap[thePrs] = 0;
     myShapes[theLine] = aPosMap;
     return 0;
   }
 }
 
-gp_Pnt SketcherPrs_PositionMgr::getPosition(std::shared_ptr<GeomAPI_Shape> theLine, 
-                                            Handle(SketcherPrs_SymbolPrs) thePrs)
+gp_Pnt SketcherPrs_PositionMgr::getPosition(ObjectPtr theShape, 
+                                            const SketcherPrs_SymbolPrs* thePrs,
+                                            double theStep)
 {
-  std::shared_ptr<GeomAPI_Edge> aEdge = 
-    std::shared_ptr<GeomAPI_Edge>(new GeomAPI_Edge(theLine));
+  std::shared_ptr<GeomAPI_Shape> aShape = SketcherPrs_Tools::getShape(theShape);
+  gp_Pnt aP; // Central point
+  gp_Vec aVec1; // main vector
+  if (aShape->isEdge()) {
+    std::shared_ptr<GeomAPI_Curve> aCurve = std::shared_ptr<GeomAPI_Curve>(new GeomAPI_Curve(aShape));
+    std::shared_ptr<GeomAPI_Pnt> aPnt1; // Start point of main vector
+    std::shared_ptr<GeomAPI_Pnt> aPnt2; // End point of main vector
+    if (aCurve->isLine()) {
+      std::shared_ptr<GeomAPI_Edge> aEdge = 
+        std::shared_ptr<GeomAPI_Edge>(new GeomAPI_Edge(aShape));
+
+      aPnt1 = aEdge->firstPoint();
+      aPnt2 = aEdge->lastPoint();
+
+      // Find the middle point
+      aP = gp_Pnt((aPnt1->x() + aPnt2->x())/2.,
+                  (aPnt1->y() + aPnt2->y())/2.,
+                  (aPnt1->z() + aPnt2->z())/2.);
 
-  std::shared_ptr<GeomAPI_Pnt> aPnt1 = aEdge->firstPoint();
-  std::shared_ptr<GeomAPI_Pnt> aPnt2 = aEdge->lastPoint();
+    } else {
+      // this is a circle or arc
+      double aMidParam = (aCurve->startParam() + aCurve->endParam()) / 2.;
+      std::shared_ptr<GeomAPI_Pnt> aPnt = aCurve->getPoint(aMidParam);
+      aP = aPnt->impl<gp_Pnt>();
 
-  // Find the middle point
-  gp_Pnt aP((aPnt1->x() + aPnt2->x())/2.,
-            (aPnt1->y() + aPnt2->y())/2.,
-            (aPnt1->z() + aPnt2->z())/2.);
+      aPnt1 = aCurve->getPoint((aMidParam + aCurve->endParam()) / 2.);
+      aPnt2 = aCurve->getPoint((aMidParam + aCurve->startParam()) / 2.);
+    }
+    aVec1 = gp_Vec(aPnt1->impl<gp_Pnt>(), aPnt2->impl<gp_Pnt>());
+  } else {
+    // This is a point
+    std::shared_ptr<GeomAPI_Vertex> aVertex = std::shared_ptr<GeomAPI_Vertex>(new GeomAPI_Vertex(aShape));
+    std::shared_ptr<GeomAPI_Pnt> aPnt = aVertex->point();
+    aP = aPnt->impl<gp_Pnt>();
 
-  gp_Vec aVec1(aPnt1->impl<gp_Pnt>(), aPnt2->impl<gp_Pnt>());
-  gp_Vec aShift = aVec1.Crossed(thePrs->plane()->norm()->impl<gp_Dir>());
+    std::shared_ptr<GeomAPI_Dir> aDir = thePrs->plane()->dirX();
+    aVec1 = gp_Vec(aDir->impl<gp_Dir>());
+  }
+  // Compute shifting vector for a one symbol
+  gp_Vec aShift = aVec1.Crossed(thePrs->plane()->normal()->impl<gp_Dir>());
   aShift.Normalize();
-  aShift.Multiply(MyStep);
+  aShift.Multiply(theStep * 0.8);
 
-  int aPos = getPositionIndex(theLine, thePrs);
+  // Shift the position coordinate according to position index
+  int aPos = getPositionIndex(theShape, thePrs);
   int aM = 1;
   if ((aPos % 2) == 0) {
     // Even position
@@ -79,7 +114,7 @@ gp_Pnt SketcherPrs_PositionMgr::getPosition(std::shared_ptr<GeomAPI_Shape> theLi
     // Odd position
     aP.Translate(-aShift);
     if (aPos > 1) {
-      if (aPos % 4 == 0) 
+      if ((aPos - 1) % 4 == 0) 
         aM = (aPos - 1) / 4;
       else
         aM = -(aPos + 1) / 4;
@@ -88,24 +123,36 @@ gp_Pnt SketcherPrs_PositionMgr::getPosition(std::shared_ptr<GeomAPI_Shape> theLi
   if (aPos > 1) {
     // Normalize vector along the line
     aVec1.Normalize();
-    aVec1.Multiply(MyStep);
+    aVec1.Multiply(theStep);
     aP.Translate(aVec1.Multiplied(aM));
   }
   return aP;
 }
 
-void SketcherPrs_PositionMgr::deleteConstraint(Handle(SketcherPrs_SymbolPrs) thePrs)
+void SketcherPrs_PositionMgr::deleteConstraint(const SketcherPrs_SymbolPrs* thePrs)
 {
-  std::map<std::shared_ptr<GeomAPI_Shape>, PositionsMap>::iterator aIt;
+  std::map<ObjectPtr, PositionsMap>::iterator aIt;
+  std::list<ObjectPtr> aToDel;
+  // Clear map for deleted presentation
   for (aIt = myShapes.begin(); aIt != myShapes.end(); ++aIt) {
     PositionsMap& aPosMap = aIt->second;
-    if (aPosMap.count(thePrs.Access()) > 0) 
-      aPosMap.erase(aPosMap.find(thePrs.Access()));
-  }
-  for (aIt = myShapes.begin(); aIt != myShapes.end(); ++aIt) {
-    if (aIt->second.size() == 0) {
-      myShapes.erase(aIt);
-      aIt = myShapes.begin();
+    if (aPosMap.count(thePrs) > 0) {
+      // Erase index
+      aPosMap.erase(aPosMap.find(thePrs));
+      if (aPosMap.size() == 0)
+        // Delete the map
+        aToDel.push_back(aIt->first);
+      else {
+        // Reindex objects positions in order to avoid spaces
+        PositionsMap::iterator aIt;
+        int i = 0;
+        for (aIt = aPosMap.begin(); aIt != aPosMap.end(); aIt++, i++)
+          aIt->second = i;
+      }
     }
   }
+  std::list<ObjectPtr>::const_iterator aListIt;
+  for (aListIt = aToDel.cbegin(); aListIt != aToDel.cend(); ++aListIt) {
+    myShapes.erase(*aListIt);
+  }
 }