#1017 Can build lines through several created points

#1035 Sketcher : polyline creation through existing points

diff --git a/src/PartSet/PartSet_MenuMgr.cpp b/src/PartSet/PartSet_MenuMgr.cpp
index 28013c9df0d51abdfbe71b16c82de80c221718d2..b840d7b373f8a7b5d7aceeebcaec3ab49a5517a3 100644 (file)
--- a/src/PartSet/PartSet_MenuMgr.cpp
+++ b/src/PartSet/PartSet_MenuMgr.cpp
@@ -149,28 +149,7 @@ bool PartSet_MenuMgr::addViewerMenu(QMenu* theMenu, const QMap<QString, QAction*
         // Find coincident in these coordinates
         ObjectPtr aObj = aPrsList.first().object();
         FeaturePtr aFeature = ModelAPI_Feature::feature(aObj);
         // Find coincident in these coordinates
         ObjectPtr aObj = aPrsList.first().object();
         FeaturePtr aFeature = ModelAPI_Feature::feature(aObj);

-        const std::set<AttributePtr>& aRefsList = aFeature->data()->refsToMe();
-        std::set<AttributePtr>::const_iterator aIt;
-        FeaturePtr aCoincident;
-        for (aIt = aRefsList.cbegin(); aIt != aRefsList.cend(); ++aIt) {
-          std::shared_ptr<ModelAPI_Attribute> aAttr = (*aIt);
-          FeaturePtr aConstrFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(aAttr->owner());
-          if (aConstrFeature->getKind() == SketchPlugin_ConstraintCoincidence::ID()) { 
-            std::shared_ptr<GeomAPI_Pnt2d> a2dPnt = 
-              PartSet_Tools::getPoint(aConstrFeature, SketchPlugin_ConstraintCoincidence::ENTITY_A());
-            if (a2dPnt.get() && aSelPnt->isEqual(a2dPnt)) { 
-              aCoincident = aConstrFeature;
-              break;
-            } else {
-              a2dPnt = PartSet_Tools::getPoint(aConstrFeature,
-                                               SketchPlugin_ConstraintCoincidence::ENTITY_B());
-              if (a2dPnt.get() && aSelPnt->isEqual(a2dPnt)) { 
-                aCoincident = aConstrFeature;
-                break;
-              }
-            }
-          }
-        }
+        FeaturePtr aCoincident = PartSet_Tools::findFirstCoincidence(aFeature, aSelPnt);

         // If we have coincidence then add Detach menu
         if (aCoincident.get() != NULL) {
           mySelectedFeature = aCoincident;
         // If we have coincidence then add Detach menu
         if (aCoincident.get() != NULL) {
           mySelectedFeature = aCoincident;

diff --git a/src/PartSet/PartSet_Tools.cpp b/src/PartSet/PartSet_Tools.cpp
index ed69af84a7e5a813b6d50583aa0d06d3d8939f6c..f9dfb6c0b4bb4b847906bd3207bafa9586045eb6 100755 (executable)
--- a/src/PartSet/PartSet_Tools.cpp
+++ b/src/PartSet/PartSet_Tools.cpp
@@ -728,6 +728,35 @@ std::shared_ptr<GeomAPI_Pnt2d> PartSet_Tools::getPoint(std::shared_ptr<ModelAPI_
   return std::shared_ptr<GeomAPI_Pnt2d>();
 }
 
   return std::shared_ptr<GeomAPI_Pnt2d>();
 }
 

+FeaturePtr PartSet_Tools::findFirstCoincidence(const FeaturePtr& theFeature,
+                                               std::shared_ptr<GeomAPI_Pnt2d> thePoint)
+{
+  FeaturePtr aCoincident;
+
+  const std::set<AttributePtr>& aRefsList = theFeature->data()->refsToMe();
+  std::set<AttributePtr>::const_iterator aIt;
+  for (aIt = aRefsList.cbegin(); aIt != aRefsList.cend(); ++aIt) {
+    std::shared_ptr<ModelAPI_Attribute> aAttr = (*aIt);
+    FeaturePtr aConstrFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(aAttr->owner());
+    if (aConstrFeature->getKind() == SketchPlugin_ConstraintCoincidence::ID()) { 
+      std::shared_ptr<GeomAPI_Pnt2d> a2dPnt = 
+        PartSet_Tools::getPoint(aConstrFeature, SketchPlugin_ConstraintCoincidence::ENTITY_A());
+      if (a2dPnt.get() && thePoint->isEqual(a2dPnt)) { 
+        aCoincident = aConstrFeature;
+        break;
+      } else {
+        a2dPnt = PartSet_Tools::getPoint(aConstrFeature,
+                                          SketchPlugin_ConstraintCoincidence::ENTITY_B());
+        if (a2dPnt.get() && thePoint->isEqual(a2dPnt)) { 
+          aCoincident = aConstrFeature;
+          break;
+        }
+      }
+    }
+  }
+  return aCoincident;
+}
+

 void PartSet_Tools::findCoincidences(FeaturePtr theStartCoin, QList<FeaturePtr>& theList,
                                      std::string theAttr)
 {
 void PartSet_Tools::findCoincidences(FeaturePtr theStartCoin, QList<FeaturePtr>& theList,
                                      std::string theAttr)
 {

diff --git a/src/PartSet/PartSet_Tools.h b/src/PartSet/PartSet_Tools.h
index 438135840c698b4fcb7aac3faefe039fa99d38fd..195de10b5f74e976c244a721d36a37559771d38c 100755 (executable)
--- a/src/PartSet/PartSet_Tools.h
+++ b/src/PartSet/PartSet_Tools.h
@@ -199,6 +199,15 @@ class PARTSET_EXPORT PartSet_Tools
   static std::shared_ptr<GeomAPI_Pnt2d> getPoint(std::shared_ptr<ModelAPI_Feature>& theFeature,
                                                  const std::string& theAttribute);
 
   static std::shared_ptr<GeomAPI_Pnt2d> getPoint(std::shared_ptr<ModelAPI_Feature>& theFeature,
                                                  const std::string& theAttribute);
 

+  /**
+  * Gets all references to the feature, take coincidence constraint features, get point 2d attributes
+  * and compare the point value to be equal with the given. Returns the first feature, which has
+  * equal points.
+  * \return the coincidence feature or null
+  */
+  static FeaturePtr findFirstCoincidence(const FeaturePtr& theFeature,
+                                         std::shared_ptr<GeomAPI_Pnt2d> thePoint);
+

   /**
   * Returns list of features connected in a councedence feature point
   * \param theStartCoin the coincidence feature
   /**
   * Returns list of features connected in a councedence feature point
   * \param theStartCoin the coincidence feature

diff --git a/src/PartSet/PartSet_WidgetPoint2d.cpp b/src/PartSet/PartSet_WidgetPoint2d.cpp
index 66a67efc418a917d2d4085aa1e9ad7452db47f02..53b403e60a361c7903d76371ac0c02c5e219de84 100644 (file)
--- a/src/PartSet/PartSet_WidgetPoint2d.cpp
+++ b/src/PartSet/PartSet_WidgetPoint2d.cpp
@@ -336,8 +336,10 @@ void PartSet_WidgetPoint2D::onMouseRelease(ModuleBase_IViewWindow* theWnd, QMous
         else {
           if (getPoint2d(aView, aShape, aX, aY))
             setPoint(aX, aY);
         else {
           if (getPoint2d(aView, aShape, aX, aY))
             setPoint(aX, aY);

+          bool anOrphanPoint = isOrphanPoint(aSelectedFeature, mySketch);

           setConstraintWith(aObject);
           setConstraintWith(aObject);

-          emit vertexSelected();
+          if (!anOrphanPoint)
+            emit vertexSelected();

           emit focusOutWidget(this);
         }
       }
           emit focusOutWidget(this);
         }
       }


@@ -351,6 +353,7 @@ void PartSet_WidgetPoint2D::onMouseRelease(ModuleBase_IViewWindow* theWnd, QMous
         setPoint(aX, aY);
       }
       else {
         setPoint(aX, aY);
       }
       else {

+        bool anOrphanPoint = isOrphanPoint(aSelectedFeature, mySketch);

         // do not set a coincidence constraint in the attribute if the feature contains a point
         // with the same coordinates. It is important for line creation in order to do not set
         // the same constraints for the same points, oterwise the result line has zero length.
         // do not set a coincidence constraint in the attribute if the feature contains a point
         // with the same coordinates. It is important for line creation in order to do not set
         // the same constraints for the same points, oterwise the result line has zero length.


@@ -369,7 +372,8 @@ void PartSet_WidgetPoint2D::onMouseRelease(ModuleBase_IViewWindow* theWnd, QMous
         // points of the line becomes less than the tolerance. Validator of the line returns
         // false, the line will be aborted, but sketch stays valid.
         updateObject(feature());
         // points of the line becomes less than the tolerance. Validator of the line returns
         // false, the line will be aborted, but sketch stays valid.
         updateObject(feature());

-        emit vertexSelected();
+        if (!anOrphanPoint)
+          emit vertexSelected();

         emit focusOutWidget(this);
       }
     }
         emit focusOutWidget(this);
       }
     }


@@ -476,3 +480,43 @@ bool PartSet_WidgetPoint2D::processEnter()
   }
   return isModified;
 }
   }
   return isModified;
 }

+
+bool PartSet_WidgetPoint2D::isOrphanPoint(const FeaturePtr& theFeature,
+                                          const CompositeFeaturePtr& theSketch)
+{
+  bool anOrphanPoint = false;
+  if (theFeature.get()) {
+    std::shared_ptr<GeomDataAPI_Point2D> aPointAttr;
+    std::string aFeatureKind = theFeature->getKind();
+    if (aFeatureKind == SketchPlugin_Point::ID())
+      aPointAttr = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
+                                       theFeature->attribute(SketchPlugin_Point::COORD_ID()));
+    else if (aFeatureKind == SketchPlugin_Circle::ID())
+      aPointAttr = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
+                                       theFeature->attribute(SketchPlugin_Circle::CENTER_ID()));
+
+    else if (aFeatureKind == SketchPlugin_Arc::ID())
+      aPointAttr = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
+                                       theFeature->attribute(SketchPlugin_Arc::CENTER_ID()));
+
+    if (aPointAttr.get()) {
+      std::shared_ptr<GeomAPI_Pnt2d> aPoint = aPointAttr->pnt();
+      FeaturePtr aCoincidence = PartSet_Tools::findFirstCoincidence(theFeature, aPoint);
+      anOrphanPoint = true;
+      // if there is at least one concident line to the point, the point is not an orphant
+      if (aCoincidence.get()) {
+        QList<FeaturePtr> aCoinsideLines;
+        PartSet_Tools::findCoincidences(aCoincidence, aCoinsideLines,
+                                        SketchPlugin_ConstraintCoincidence::ENTITY_A());
+        PartSet_Tools::findCoincidences(aCoincidence, aCoinsideLines,
+                                        SketchPlugin_ConstraintCoincidence::ENTITY_B());
+        QList<FeaturePtr>::const_iterator anIt = aCoinsideLines.begin(),
+                                          aLast = aCoinsideLines.end();
+        for (; anIt != aLast && anOrphanPoint; anIt++) {
+          anOrphanPoint = (*anIt)->getKind() != SketchPlugin_Line::ID();
+        }
+      }
+    }
+  }
+  return anOrphanPoint;
+}

diff --git a/src/PartSet/PartSet_WidgetPoint2d.h b/src/PartSet/PartSet_WidgetPoint2d.h
index a2dd6673c783492ce5e9d9d699ab5a1cbe3d602b..eb277a88338c9db4da414c5db8a270efe3b0470a 100755 (executable)
--- a/src/PartSet/PartSet_WidgetPoint2d.h
+++ b/src/PartSet/PartSet_WidgetPoint2d.h
@@ -141,6 +141,13 @@ protected:
    /// \theObject a result object
    void setConstraintWith(const ObjectPtr& theObject);
 
    /// \theObject a result object
    void setConstraintWith(const ObjectPtr& theObject);
 

+   /// Returns if the feature is an orphan point, circle or an arc. Returns true if it
+   /// has no a coincident to other lines. In Circle and arc only center points are processed.
+   /// \param theFeature a checked feature
+   /// \param theSketch a sketch
+   /// \return boolean result
+   static bool isOrphanPoint(const FeaturePtr& theFeature, const CompositeFeaturePtr& theSketch);
+

 protected:
   ModuleBase_IWorkshop* myWorkshop; ///< workshop
 
 protected:
   ModuleBase_IWorkshop* myWorkshop; ///< workshop