X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FHYDROCurveCreator%2FCurveCreator_Utils.cxx;h=1fcc4084030de42aba451f7fe357f77c117470e8;hb=65c66988575cb4fc8de7d838cde08b4731a6e54b;hp=e237e6ee69c3ec77f69f2da87834ae1db8124fc3;hpb=ccba842d3f399476c64ddc0bebc191e3c1daebd0;p=modules%2Fhydro.git

diff --git a/src/HYDROCurveCreator/CurveCreator_Utils.cxx b/src/HYDROCurveCreator/CurveCreator_Utils.cxx
index e237e6ee..1fcc4084 100644
--- a/src/HYDROCurveCreator/CurveCreator_Utils.cxx
+++ b/src/HYDROCurveCreator/CurveCreator_Utils.cxx
@@ -36,14 +36,18 @@
 #include <AIS_Shape.hxx>
 #include <AIS_Line.hxx>
 #include <AIS_Trihedron.hxx>
+#include <AIS_LocalContext.hxx>
 
 #include <Geom_Point.hxx>
 #include <Geom_BSplineCurve.hxx>
 #include <Geom_Line.hxx>
 
+#include <TopExp.hxx>
 #include <TopExp_Explorer.hxx>
 #include <GeomAPI_ProjectPointOnCurve.hxx>
 #include <SelectMgr_EntityOwner.hxx>
+#include <SelectMgr_Selection.hxx>
+#include <Select3D_SensitivePoint.hxx>
 
 #include <BRep_Tool.hxx>
 #include <BRep_Builder.hxx>
@@ -57,10 +61,13 @@
 #include <ProjLib.hxx>
 #include <ElSLib.hxx>
 
+#include <math.h>
+
 #include "CurveCreator_ICurve.hxx"
 
 const double LOCAL_SELECTION_TOLERANCE = 0.0001;
-const int    SCENE_PIXEL_TOLERANCE = 10;
+const int    SCENE_PIXEL_PROJECTION_TOLERANCE = 10;
+const int    SCENE_PIXEL_POINT_TOLERANCE = 5;
 
 //=======================================================================
 // function : ConvertClickToPoint()
@@ -204,18 +211,77 @@ void CurveCreator_Utils::getSelectedPoints( Handle(AIS_InteractiveContext) theCo
   }
 }
 
+void CurveCreator_Utils::setSelectedPoints( Handle(AIS_InteractiveContext) theContext,
+                                            const CurveCreator_ICurve* theCurve,
+                                            const CurveCreator_ICurve::SectionToPointList& thePoints )
+{
+  if ( !theCurve )
+    return;
+
+  Handle(AIS_InteractiveObject) anAIS = theCurve->getAISObject();
+  if ( anAIS.IsNull() )
+    return;
+  Handle(AIS_Shape) anAISShape = Handle(AIS_Shape)::DownCast( anAIS );
+  if ( anAISShape.IsNull() )
+    return;
+
+  //ASL: we convert list of point indices to list of points coordinates
+  int aSize = thePoints.size();
+  std::vector<gp_Pnt> aPntsToSelect( aSize );
+
+  CurveCreator_ICurve::SectionToPointList::const_iterator
+                     aPIt = thePoints.begin(), aPLast = thePoints.end();
+  CurveCreator_ICurve::SectionToPoint aSToPoint;
+  for( int i=0; aPIt != aPLast; aPIt++, i++ )
+  {
+    gp_Pnt aPntToSelect;
+    CurveCreator_UtilsICurve::getPoint( theCurve, aPIt->first, aPIt->second, aPntToSelect );
+    aPntsToSelect[i] = aPntToSelect;
+  }
+
+  theContext->ClearSelected( Standard_False );
+  //ASL: we switch off automatic highlight to improve performance of selection
+  theContext->SetAutomaticHilight( Standard_False );
+
+  Handle_SelectMgr_Selection aSelection = anAISShape->Selection( AIS_Shape::SelectionMode( TopAbs_VERTEX ) );
+  for( aSelection->Init(); aSelection->More(); aSelection->Next() )
+  {
+    Handle_SelectBasics_SensitiveEntity aSenEntity = aSelection->Sensitive();
+    Handle_Select3D_SensitivePoint aSenPnt = Handle_Select3D_SensitivePoint::DownCast( aSenEntity );
+
+    gp_Pnt anOwnerPnt = aSenPnt->Point();
+    Handle_SelectMgr_EntityOwner anOwner = Handle_SelectMgr_EntityOwner::DownCast( aSenPnt->OwnerId() );
+
+
+    CurveCreator_ICurve::SectionToPointList::const_iterator anIt = thePoints.begin(),
+                                                                   aLast = thePoints.end();
+    bool isFound = false;
+    for( int i=0; i<aSize; i++ )
+    {
+      bool isIntersect = fabs( aPntsToSelect[i].X() - anOwnerPnt.X() ) < LOCAL_SELECTION_TOLERANCE &&
+                         fabs( aPntsToSelect[i].Y() - anOwnerPnt.Y() ) < LOCAL_SELECTION_TOLERANCE;
+      if( isIntersect )
+      {
+        theContext->AddOrRemoveSelected( anOwner, Standard_False );
+        break;
+      }
+    }
+  }
+
+  //ASL: we switch on again automatic highlight (otherwise selection will not be shown)
+  //     and call HilightPicked to draw selected owners
+  theContext->SetAutomaticHilight( Standard_True );
+  theContext->LocalContext()->HilightPicked( Standard_True );
+}
+
 //=======================================================================
 // function : setLocalPointContext
 // purpose  : Open/close the viewer local context
 //=======================================================================
-//#define USE_GLOBAL_SELECTION
-void CurveCreator_Utils::setLocalPointContext(
-                                              Handle(AIS_InteractiveContext) theContext,
-                                              const bool theOpen )
+void CurveCreator_Utils::setLocalPointContext( const CurveCreator_ICurve* theCurve,
+                                               Handle(AIS_InteractiveContext) theContext,
+                                               const bool theOpen )
 {
-#ifdef USE_GLOBAL_SELECTION
-  return;
-#endif
   if ( !theContext )
     return;
 
@@ -225,30 +291,15 @@ void CurveCreator_Utils::setLocalPointContext(
       theContext->ClearCurrents( false );
       theContext->OpenLocalContext( false/*use displayed objects*/, true/*allow shape decomposition*/ );
     }
-    AIS_ListOfInteractive aList;
-    theContext->DisplayedObjects( aList );
-    int aLSize = 0;
-    for ( AIS_ListIteratorOfListOfInteractive it( aList ); it.More(); it.Next() )
-      aLSize++;
-
-    for ( AIS_ListIteratorOfListOfInteractive it( aList ); it.More(); it.Next() )
+    // load the curve AIS object to the local context with the point selection
+    Handle(AIS_InteractiveObject) anAIS = theCurve->getAISObject();
+    if ( !anAIS.IsNull() )
     {
-      Handle(AIS_InteractiveObject) anAIS = it.Value();
-      if ( !anAIS.IsNull() )
+      if ( anAIS->IsKind( STANDARD_TYPE( AIS_Shape ) ) )
       {
-        if ( anAIS->IsKind( STANDARD_TYPE( AIS_Shape ) ) )
-        {
-          theContext->Load( anAIS, -1/*selection mode*/, true/*allow decomposition*/ );
-          //theContext->Activate( anAIS, AIS_Shape::SelectionMode( (TopAbs_ShapeEnum)TopAbs_WIRE ) );
-          theContext->Activate( anAIS, AIS_Shape::SelectionMode( (TopAbs_ShapeEnum)TopAbs_VERTEX ) );
-        }
-        else if ( anAIS->DynamicType() != STANDARD_TYPE(AIS_Trihedron) )
-        {
-          theContext->Load( anAIS, -1/*selection mode*/, false/*allow decomposition*/ );
-          theContext->Activate( anAIS, TopAbs_VERTEX );
-        }
+        theContext->Load( anAIS, -1/*selection mode*/, true/*allow decomposition*/ );
+        theContext->Activate( anAIS, AIS_Shape::SelectionMode( (TopAbs_ShapeEnum)TopAbs_VERTEX ) );
       }
-      continue;
     }
   }
   else {
@@ -257,113 +308,104 @@ void CurveCreator_Utils::setLocalPointContext(
   }
 }
 
-bool CurveCreator_Utils::getNeighbourPoints( Handle(AIS_InteractiveContext) theContext,
-                                             Handle(V3d_View) theView,
-                                             const int theX, const int theY,
-                                             gp_Pnt& thePoint, gp_Pnt& thePoint1,
-                                             gp_Pnt& thePoint2 )
-{
-  bool isFoundPoint = false;
-  if ( theContext.IsNull() )
-    return isFoundPoint;
-
-  for ( theContext->InitSelected(); theContext->MoreSelected() && !isFoundPoint;
-        theContext->NextSelected() ) {
-    TopoDS_Shape aTShape = theContext->SelectedShape();
-    if ( !aTShape.IsNull() && aTShape.ShapeType() == TopAbs_VERTEX )
-      continue;
-    else {
-      Handle(SelectMgr_EntityOwner) anOwner = theContext->SelectedOwner();
-      if ( anOwner.IsNull() )
-        continue;
-      const TopLoc_Location& aLocation = anOwner->Location();
-      Handle(AIS_InteractiveObject) anAIS =
-                        Handle(AIS_InteractiveObject)::DownCast( anOwner->Selectable() );
-      isFoundPoint = CurveCreator_Utils::pointOnObject( theView, anAIS, theX, theY, thePoint,
-                                                        thePoint1, thePoint2 );
-    }
-  }
-  return isFoundPoint;
-}
-
 bool CurveCreator_Utils::pointOnObject( Handle(V3d_View) theView,
                                         Handle(AIS_InteractiveObject) theObject,
                                         const int theX, const int theY,
                                         gp_Pnt& thePoint,
                                         gp_Pnt& thePoint1, gp_Pnt& thePoint2 )
 {
-  bool isFound = false;
+  bool isFullFound = false;
 
   if ( theObject.IsNull() || theView.IsNull() )
-    return isFound;
-
-  gp_Pnt aPoint;
+    return isFullFound;
+  Handle(AIS_Shape) aShape = Handle(AIS_Shape)::DownCast( theObject );
+  if ( aShape.IsNull() )
+    return isFullFound;
+  const TopoDS_Compound& aCompound = TopoDS::Compound( aShape->Shape() );
+  if ( aCompound.IsNull() )
+    return isFullFound;
+
+  gp_Pnt aCurPoint, aCurPoint1, aCurPoint2;
+  gp_Pnt aFoundPoint, aFoundPnt1, aFoundPnt2;
   Standard_Real aParameter;
-  gp_Pnt aPnt1, aPnt2;
-  Handle(AIS_Line) aLine = Handle(AIS_Line)::DownCast( theObject );
-  if ( !aLine.IsNull() ) {
-    const Handle(Geom_Line) aGLine = aLine->Line();
-    isFound = hasProjectPointOnCurve( theView, theX, theY, aGLine, aParameter );
-    if ( isFound ) {
-      aPoint = aGLine->Value( aParameter );
-
-      Handle(Geom_Point) aPStart;
-      Handle(Geom_Point) aPEnd;
-      aLine->Points( aPStart, aPEnd );
-      aPnt1 = aPStart->Pnt();
-      aPnt2 = aPEnd->Pnt();
-
-      // in case of Geom line a projection is performed to the infinite line,
-      // so it is necessary to bound it by the line size
-      Bnd_Box aLineBox;
-      aLineBox.Set( aPnt1, gp_Vec( aPnt1, aPnt2 ) );
-      isFound = !aLineBox.IsOut( aPoint );
-    }
-  }
-  else {
-    Handle(AIS_Shape) aShape = Handle(AIS_Shape)::DownCast( theObject );
-    if ( !aShape.IsNull() ) {
-      const TopoDS_Wire& aWire = TopoDS::Wire( aShape->Shape() );
-      if ( !aWire.IsNull() ) {
-        TopExp_Explorer anExp( aWire, TopAbs_EDGE );
-        for ( ; anExp.More(); anExp.Next())
-        {
-          const TopoDS_Edge& anEdge = TopoDS::Edge(anExp.Current());
-          if ( !anEdge.IsNull() ) {
-            Standard_Real aFirst, aLast;
-            Handle(Geom_Curve) aCurve = BRep_Tool::Curve( anEdge, aFirst, aLast );
-
-            if ( aCurve->IsKind( STANDARD_TYPE(Geom_BSplineCurve) ) ) {
-              Handle(Geom_BSplineCurve) aBSplineCurve = Handle(Geom_BSplineCurve)::DownCast( aCurve );
-              if ( !aBSplineCurve.IsNull() ) {
-                isFound = hasProjectPointOnCurve( theView, theX, theY, aCurve, aParameter );
-                if ( isFound ) {
-                  aPoint = aBSplineCurve->Value( aParameter );
-                  Standard_Integer anI1, anI2;
-                  aBSplineCurve->LocateU( aParameter, LOCAL_SELECTION_TOLERANCE, anI1, anI2 );
-
-                  aPnt1 = aBSplineCurve->Value( aBSplineCurve->Knot( anI1 ) );
-                  aPnt2 = aBSplineCurve->Value( aBSplineCurve->Knot( anI2 ) );
-                }
-              }
-            }
-          }
+  bool isFound = false;
+  int aDelta, aMinDelta = 2*SCENE_PIXEL_PROJECTION_TOLERANCE*SCENE_PIXEL_PROJECTION_TOLERANCE;
+  TopExp_Explorer anExp( aCompound, TopAbs_EDGE );
+  for ( ; anExp.More(); anExp.Next())
+  {
+    const TopoDS_Edge& anEdge = TopoDS::Edge(anExp.Current());
+    if ( anEdge.IsNull() )
+      continue;
+    Standard_Real aFirst, aLast;
+    Handle(Geom_Curve) aCurve = BRep_Tool::Curve( anEdge, aFirst, aLast );
+    if ( aCurve->IsKind( STANDARD_TYPE(Geom_BSplineCurve) ) ) {
+      Handle(Geom_BSplineCurve) aBSplineCurve =
+                          Handle(Geom_BSplineCurve)::DownCast( aCurve );
+      if ( !aBSplineCurve.IsNull() ) {
+        isFound = hasProjectPointOnCurve( theView, theX, theY, aBSplineCurve,
+                                          aParameter, aDelta );
+        if ( isFound ) {
+          aCurPoint = aBSplineCurve->Value( aParameter );
+          Standard_Integer anI1, anI2;
+          aBSplineCurve->LocateU( aParameter, LOCAL_SELECTION_TOLERANCE, anI1, anI2 );
+          aCurPoint1 = aBSplineCurve->Value( aBSplineCurve->Knot( anI1 ) );
+          aCurPoint2 = aBSplineCurve->Value( aBSplineCurve->Knot( anI2 ) );
         }
       }
     }
+    else { // a curve built on a polyline edge
+      Handle(Geom_Line) aGLine = Handle(Geom_Line)::DownCast( aCurve );
+      if ( aGLine.IsNull() )
+        continue;
+      isFound = hasProjectPointOnCurve( theView, theX, theY, aGLine, aParameter,
+                                        aDelta );
+      if ( isFound ) {
+        aCurPoint = aGLine->Value( aParameter );
+        TopoDS_Vertex V1, V2;
+        TopExp::Vertices( anEdge, V1, V2, Standard_True );
+        if ( V1.IsNull() || V2.IsNull() )
+          continue;
+        aCurPoint1 = BRep_Tool::Pnt(V1);
+        aCurPoint2 = BRep_Tool::Pnt(V2);
+
+        // check that the projected point is on the bounded curve
+        gp_Vec aVec1( aCurPoint1, aCurPoint );
+        gp_Vec aVec2( aCurPoint2, aCurPoint );
+        isFound = fabs( aVec1.Angle( aVec2 ) - M_PI ) < LOCAL_SELECTION_TOLERANCE;
+      }
+    }
+    if ( isFound && aMinDelta >= aDelta ) {
+      aMinDelta = aDelta;
+
+      isFullFound = true;
+      aFoundPnt1 = aCurPoint1;
+      aFoundPnt2 = aCurPoint2;
+      aFoundPoint = aCurPoint;
+    }
   }
-  if ( isFound ) {
-    thePoint = aPoint;
-    thePoint1 = aPnt1;
-    thePoint2 = aPnt2;
+  if ( isFullFound ) {
+    int aX, anY, aX1, anY1, aX2, anY2;
+    int aDelta;
+    CurveCreator_Utils::ConvertPointToClick( aFoundPoint, theView, aX, anY );
+    CurveCreator_Utils::ConvertPointToClick( aFoundPnt1, theView, aX1, anY1 );
+    CurveCreator_Utils::ConvertPointToClick( aFoundPnt2, theView, aX2, anY2 );
+
+    isFullFound = !isEqualPixels( aX, anY, aX1, anY1, SCENE_PIXEL_POINT_TOLERANCE, aDelta ) &&
+                  !isEqualPixels( aX, anY, aX2, anY2, SCENE_PIXEL_POINT_TOLERANCE, aDelta );
+    if ( isFullFound ) {
+      thePoint = aFoundPoint;
+      thePoint1 = aFoundPnt1;
+      thePoint2 = aFoundPnt2;
+    }
   }
-  return isFound;
+  return isFullFound;
 }
 
 bool CurveCreator_Utils::hasProjectPointOnCurve( Handle(V3d_View) theView,
                                                  const int theX, const int theY,
                                                  const Handle(Geom_Curve)& theCurve,
-                                                 Standard_Real& theParameter )
+                                                 Standard_Real& theParameter,
+                                                 int& theDelta )
 {
   bool isFound = false;
   if ( theView.IsNull() )
@@ -381,10 +423,19 @@ bool CurveCreator_Utils::hasProjectPointOnCurve( Handle(V3d_View) theView,
       int aX, anY;
       CurveCreator_Utils::ConvertPointToClick( aNewPoint, theView, aX, anY );
 
-      int aXDelta = abs( aX - theX );
-      int anYDelta = abs( anY - theY );
-      isFound = aXDelta < SCENE_PIXEL_TOLERANCE && anYDelta < SCENE_PIXEL_TOLERANCE;
+      isFound = isEqualPixels( aX, anY, theX, theY, SCENE_PIXEL_PROJECTION_TOLERANCE, theDelta );
     }
   }
   return isFound;
 }
+
+bool CurveCreator_Utils::isEqualPixels( const int theX, const int theY, const int theOtherX,
+                                        const int theOtherY, const double theTolerance, int& theDelta )
+{
+  int aXDelta = abs( theX - theOtherX );
+  int anYDelta = abs( theY - theOtherY );
+
+  theDelta = aXDelta*aXDelta + anYDelta*anYDelta;
+
+  return aXDelta < theTolerance && anYDelta < theTolerance;
+}