X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FPartSet%2FPartSet_Tools.cpp;h=916a31a71f2a4e958e3ddbf706eb0ce35df99548;hb=94ba553e7b92f11a936e027b49bbd1d501eeee44;hp=f301c8e0abdf482bda1b8f1188f77fb6f3359412;hpb=489132d99e1d417d5c7ce93fed8fb8ee138befbc;p=modules%2Fshaper.git

diff --git a/src/PartSet/PartSet_Tools.cpp b/src/PartSet/PartSet_Tools.cpp
index f301c8e0a..916a31a71 100644
--- a/src/PartSet/PartSet_Tools.cpp
+++ b/src/PartSet/PartSet_Tools.cpp
@@ -8,6 +8,7 @@
 #include <ModelAPI_AttributeDouble.h>
 #include <ModelAPI_AttributeRefList.h>
 #include <ModelAPI_Document.h>
+#include <ModelAPI_Session.h>
 
 #include <GeomDataAPI_Point.h>
 #include <GeomDataAPI_Dir.h>
@@ -25,16 +26,23 @@
 #include <SketchPlugin_ConstraintDistance.h>
 #include <SketchPlugin_ConstraintLength.h>
 #include <SketchPlugin_ConstraintRadius.h>
+#include <SketchPlugin_ConstraintRigid.h>
 #include <SketchPlugin_Constraint.h>
+#include <SketchPlugin_Circle.h>
+#include <SketchPlugin_Arc.h>
+#include <SketchPlugin_Line.h>
 
 #include <ModuleBase_ViewerPrs.h>
 
 #include <V3d_View.hxx>
 #include <gp_Pln.hxx>
+#include <gp_Circ.hxx>
 #include <ProjLib.hxx>
 #include <ElSLib.hxx>
 #include <Geom_Line.hxx>
 #include <GeomAPI_ProjectPointOnCurve.hxx>
+#include <BRep_Tool.hxx>
+#include <TopoDS.hxx>
 
 #ifdef _DEBUG
 #include <QDebug>
@@ -138,21 +146,17 @@ void PartSet_Tools::convertTo3D(const double theX, const double theY, FeaturePtr
 
 FeaturePtr PartSet_Tools::nearestFeature(QPoint thePoint, Handle_V3d_View theView,
                                          FeaturePtr theSketch,
-                                         const std::list<ModuleBase_ViewerPrs>& theFeatures)
+                                         const QList<ModuleBase_ViewerPrs>& theFeatures)
 {
   double aX, anY;
   gp_Pnt aPoint = PartSet_Tools::convertClickToPoint(thePoint, theView);
   PartSet_Tools::convertTo2D(aPoint, theSketch, theView, aX, anY);
 
   FeaturePtr aFeature;
-  std::list<ModuleBase_ViewerPrs>::const_iterator anIt = theFeatures.begin(), aLast = theFeatures
-      .end();
-
   FeaturePtr aDeltaFeature;
   double aMinDelta = -1;
   ModuleBase_ViewerPrs aPrs;
-  for (; anIt != aLast; anIt++) {
-    aPrs = *anIt;
+  foreach (ModuleBase_ViewerPrs aPrs, theFeatures) {
     if (!aPrs.object())
       continue;
     boost::shared_ptr<SketchPlugin_Feature> aSketchFeature = boost::dynamic_pointer_cast<
@@ -171,19 +175,27 @@ FeaturePtr PartSet_Tools::nearestFeature(QPoint thePoint, Handle_V3d_View theVie
 
 boost::shared_ptr<ModelAPI_Document> PartSet_Tools::document()
 {
-  return ModelAPI_Session::get()->rootDocument();
+  return ModelAPI_Session::get()->moduleDocument();
 }
 
-void PartSet_Tools::setFeaturePoint(FeaturePtr theFeature, double theX, double theY,
-                                    const std::string& theAttribute)
+boost::shared_ptr<GeomDataAPI_Point2D> PartSet_Tools::getFeaturePoint(FeaturePtr theFeature,
+                                                                      double theX, double theY)
 {
-  if (!theFeature)
-    return;
-  boost::shared_ptr<ModelAPI_Data> aData = theFeature->data();
-  boost::shared_ptr<GeomDataAPI_Point2D> aPoint = boost::dynamic_pointer_cast<GeomDataAPI_Point2D>(
-      aData->attribute(theAttribute));
-  if (aPoint)
-    aPoint->setValue(theX, theY);
+  boost::shared_ptr<GeomAPI_Pnt2d> aClickedPoint = boost::shared_ptr<GeomAPI_Pnt2d>(
+                                                                 new GeomAPI_Pnt2d(theX, theY));
+  std::list<boost::shared_ptr<ModelAPI_Attribute> > anAttiributes =
+                                    theFeature->data()->attributes(GeomDataAPI_Point2D::type());
+  std::list<boost::shared_ptr<ModelAPI_Attribute> >::const_iterator anIt = anAttiributes.begin(),
+                                                                    aLast = anAttiributes.end();
+  boost::shared_ptr<GeomDataAPI_Point2D> aFPoint;
+  for (; anIt != aLast && !aFPoint; anIt++) {
+    boost::shared_ptr<GeomDataAPI_Point2D> aCurPoint = boost::dynamic_pointer_cast<
+        GeomDataAPI_Point2D>(*anIt);
+    if (aCurPoint && aCurPoint->pnt()->distance(aClickedPoint) < Precision::Confusion())
+      aFPoint = aCurPoint;
+  }
+
+  return aFPoint;
 }
 
 void PartSet_Tools::setFeatureValue(FeaturePtr theFeature, double theValue,
@@ -234,17 +246,16 @@ FeaturePtr PartSet_Tools::feature(FeaturePtr theFeature, const std::string& theA
   return aFeature;
 }
 
-void PartSet_Tools::createConstraint(FeaturePtr theSketch,
+void PartSet_Tools::createConstraint(CompositeFeaturePtr theSketch,
                                      boost::shared_ptr<GeomDataAPI_Point2D> thePoint1,
                                      boost::shared_ptr<GeomDataAPI_Point2D> thePoint2)
 {
-  boost::shared_ptr<ModelAPI_Document> aDoc = document();
-  FeaturePtr aFeature = aDoc->addFeature(SketchPlugin_ConstraintCoincidence::ID());
-
+  FeaturePtr aFeature;
   if (theSketch) {
-    boost::shared_ptr<SketchPlugin_Feature> aSketch = boost::dynamic_pointer_cast<
-        SketchPlugin_Feature>(theSketch);
-    aSketch->addSub(aFeature);
+    aFeature = theSketch->addFeature(SketchPlugin_ConstraintCoincidence::ID());
+  } else {
+    boost::shared_ptr<ModelAPI_Document> aDoc = document();
+    aFeature = aDoc->addFeature(SketchPlugin_ConstraintCoincidence::ID());
   }
 
   boost::shared_ptr<ModelAPI_Data> aData = aFeature->data();
@@ -261,7 +272,7 @@ void PartSet_Tools::createConstraint(FeaturePtr theSketch,
     aFeature->execute();
 }
 
-void PartSet_Tools::setConstraints(FeaturePtr theSketch, FeaturePtr theFeature,
+void PartSet_Tools::setConstraints(CompositeFeaturePtr theSketch, FeaturePtr theFeature,
                                    const std::string& theAttribute, double theClickedX,
                                    double theClickedY)
 {
@@ -301,7 +312,7 @@ void PartSet_Tools::setConstraints(FeaturePtr theSketch, FeaturePtr theFeature,
   }
 }
 
-boost::shared_ptr<GeomAPI_Pln> PartSet_Tools::sketchPlane(FeaturePtr theSketch)
+boost::shared_ptr<GeomAPI_Pln> PartSet_Tools::sketchPlane(CompositeFeaturePtr theSketch)
 {
   boost::shared_ptr<GeomAPI_Pln> aPlane;
   double aA, aB, aC, aD;
@@ -321,7 +332,7 @@ boost::shared_ptr<GeomAPI_Pln> PartSet_Tools::sketchPlane(FeaturePtr theSketch)
 }
 
 boost::shared_ptr<GeomAPI_Pnt> PartSet_Tools::point3D(boost::shared_ptr<GeomAPI_Pnt2d> thePoint2D,
-                                                      FeaturePtr theSketch)
+                                                      CompositeFeaturePtr theSketch)
 {
   boost::shared_ptr<GeomAPI_Pnt> aPoint;
   if (!theSketch || !thePoint2D)
@@ -341,5 +352,79 @@ bool PartSet_Tools::isConstraintFeature(const std::string& theKind)
 {
   return theKind == SketchPlugin_ConstraintDistance::ID()
       || theKind == SketchPlugin_ConstraintLength::ID()
-      || theKind == SketchPlugin_ConstraintRadius::ID();
+      || theKind == SketchPlugin_ConstraintRadius::ID()
+      || theKind == SketchPlugin_ConstraintRigid::ID();
+}
+
+ResultPtr PartSet_Tools::createFixedObjectByEdge(const ModuleBase_ViewerPrs& thePrs, CompositeFeaturePtr theSketch)
+{
+  TopoDS_Shape aShape = thePrs.shape();
+  if (aShape.ShapeType() != TopAbs_EDGE)
+    return ResultPtr();
+
+  Standard_Real aStart, aEnd;
+  Handle(V3d_View) aNullView;
+  FeaturePtr aMyFeature;
+
+  Handle(Geom_Curve) aCurve = BRep_Tool::Curve(TopoDS::Edge(aShape), aStart, aEnd);
+  GeomAdaptor_Curve aAdaptor(aCurve);
+  if (aAdaptor.GetType() == GeomAbs_Line) {
+    // Create line
+    aMyFeature = theSketch->addFeature(SketchPlugin_Line::ID());
+
+    //DataPtr aData = myFeature->data();
+    //boost::shared_ptr<GeomDataAPI_Point2D> anEndAttr = 
+    //  boost::dynamic_pointer_cast<GeomDataAPI_Point2D>(aData->attribute(SketchPlugin_Line::END_ID()));
+
+    //double aX, aY;
+    //gp_Pnt Pnt1 = aAdaptor.Value(aStart);
+    //convertTo2D(Pnt1, theSketch, aNullView, aX, aY);
+    //setFeaturePoint(myFeature, aX, aY, SketchPlugin_Line::START_ID());
+
+    //gp_Pnt Pnt2 = aAdaptor.Value(aEnd);
+    //convertTo2D(Pnt2, theSketch, aNullView, aX, aY);
+    //setFeaturePoint(myFeature, aX, aY, SketchPlugin_Line::END_ID());
+  } else if (aAdaptor.GetType() == GeomAbs_Circle) {
+    if (aAdaptor.IsClosed()) {
+      // Create circle
+      aMyFeature = theSketch->addFeature(SketchPlugin_Circle::ID());
+      //gp_Circ aCirc = aAdaptor.Circle();
+      //gp_Pnt aCenter = aCirc.Location();
+
+      //double aX, aY;
+      //convertTo2D(aCenter, theSketch, aNullView, aX, aY);
+      //setFeaturePoint(myFeature, aX, aY, SketchPlugin_Circle::CENTER_ID());
+      //setFeatureValue(myFeature, aCirc.Radius(), SketchPlugin_Circle::RADIUS_ID());
+    } else {
+      // Create arc
+      aMyFeature = theSketch->addFeature(SketchPlugin_Arc::ID());
+    }
+  }
+  if (aMyFeature) {
+    DataPtr aData = aMyFeature->data();
+    AttributeSelectionPtr anAttr = 
+      boost::dynamic_pointer_cast<ModelAPI_AttributeSelection>
+      (aData->attribute(SketchPlugin_Feature::EXTERNAL_ID()));
+
+    ResultPtr aRes = boost::dynamic_pointer_cast<ModelAPI_Result>(thePrs.object());
+    if (anAttr && aRes) {
+      boost::shared_ptr<GeomAPI_Shape> anEdge(new GeomAPI_Shape);
+      anEdge->setImpl(new TopoDS_Shape(aShape));
+
+      anAttr->setValue(aRes, anEdge);
+      aMyFeature->execute();
+      return aMyFeature->lastResult();
+    }
+  }
+  return ResultPtr();
+}
+
+bool PartSet_Tools::isContainPresentation(const QList<ModuleBase_ViewerPrs>& theSelected,
+                                          const ModuleBase_ViewerPrs& thePrs)
+{
+  foreach (ModuleBase_ViewerPrs aPrs, theSelected) {
+    if (aPrs.object() == thePrs.object())
+      return true;
+  }
+  return false;
 }