OCC22357 Hidden face selection

src/AIS/AIS_InteractiveContext_2.cxx

@@ -20,8 +20,6 @@
 #include <Graphic3d_MapIteratorOfMapOfStructure.hxx>
 #include <AIS_Selection.hxx>
 
-
-static TColStd_ListIteratorOfListOfInteger ItL;
 //=======================================================================
 //function : OpenLocalContext
 //purpose  : 
@@ -64,22 +62,14 @@ OpenLocalContext(const Standard_Boolean UseDisplayedObjects,
                                                           UseDisplayedObjects,
                                                           AllowShapeDecomposition,
                                                           AcceptEraseOfTemporary);
-  
+  NewLocal->MainSelector()->Set ((myLocalContexts.Extent() > 0)
-  // rob 16/04/97 pour les Pbs d'ordres asynchrones
+    ? myLocalContexts (untilnow)->MainSelector()->Projector()
-  if(myLocalContexts.Extent()>0){
+    : myMainSel->Projector());
-    const Select3D_Projector& Prj = myLocalContexts(untilnow)->MainSelector()->Projector();
-    NewLocal->MainSelector()->Set(Prj);
-  }
-  else{
-    const Select3D_Projector& Prj = myMainSel->Projector();
-    NewLocal->MainSelector()->Set(Prj);
-  }
 
   NewLocal->MainSelector()->UpdateConversion();
 
   myLocalContexts.Bind(myCurLocalIndex,NewLocal);
 
-
 #ifdef DEB
   cout<<"\tOpen Local Context No "<<myCurLocalIndex<<endl;
   if(UseDisplayedObjects){
@@ -93,7 +83,6 @@ OpenLocalContext(const Standard_Boolean UseDisplayedObjects,
     cout<<"\t\tNo Objects Were Loaded "<<endl;
 #endif
   return myCurLocalIndex;
-  
 }
 
 //=======================================================================
@@ -268,6 +257,7 @@ Deactivate(const Handle(AIS_InteractiveObject)& anIObj)
 {
   if(!HasOpenedContext()){
     if(!myObjects.IsBound(anIObj)) return;
+    TColStd_ListIteratorOfListOfInteger ItL;
     for(ItL.Initialize(myObjects(anIObj)->SelectionModes());
         ItL.More();
         ItL.Next()){
@@ -312,9 +302,9 @@ void AIS_InteractiveContext::
 ActivatedModes(const Handle(AIS_InteractiveObject)& anIObj, 
                TColStd_ListOfInteger& theList) const 
 {
+  TColStd_ListIteratorOfListOfInteger ItL;
   if(!HasOpenedContext()){
     if(myObjects.IsBound(anIObj)){
-      //ItL est une variable statique... 
       for(ItL.Initialize(myObjects(anIObj)->SelectionModes());
           ItL.More();
           ItL.Next())
@@ -393,6 +383,7 @@ SubIntensityOn(const Handle(AIS_InteractiveObject)& anIObj,
     if(myObjects.IsBound(anIObj)){
       const Handle(AIS_GlobalStatus)& STAT = myObjects(anIObj);
       STAT->SubIntensityOn();
+      TColStd_ListIteratorOfListOfInteger ItL;
       for (ItL.Initialize(STAT->DisplayedModes());ItL.More();ItL.Next())
         myMainPM->Color(anIObj,mySubIntensity,ItL.Value());
     }
@@ -446,6 +437,7 @@ SubIntensityOff(const Handle(AIS_InteractiveObject)& anIObj,
     if(myObjects.IsBound(anIObj)){
       const Handle(AIS_GlobalStatus)& STAT = myObjects(anIObj);
       STAT->SubIntensityOff();
+      TColStd_ListIteratorOfListOfInteger ItL;
       for (ItL.Initialize(STAT->DisplayedModes());ItL.More();ItL.Next())
         myMainPM->Unhighlight(anIObj,ItL.Value());
       if(STAT->IsHilighted())
@@ -489,11 +481,10 @@ void AIS_InteractiveContext::SubIntensityOn(const Standard_Boolean updateviewer)
 //=======================================================================
 void AIS_InteractiveContext::SubIntensityOff(const Standard_Boolean updateviewer)
 {
-  
   if(!HasOpenedContext()) return;
 
   AIS_DataMapIteratorOfDataMapOfIOStatus It (myObjects);
-  
+  TColStd_ListIteratorOfListOfInteger ItL;
   for(;It.More();It.Next()){
     const Handle(AIS_GlobalStatus)& STAT = It.Value();
     if(STAT->IsSubIntensityOn())

src/AIS/AIS_LocalContext.cxx

@@ -660,18 +660,21 @@ void AIS_LocalContext::RemoveFilter(const Handle(SelectMgr_Filter)& aFilter)
 
 
 
-Standard_Boolean AIS_LocalContext::HasSameProjector(const Select3D_Projector& aPrj) const
+Standard_Boolean AIS_LocalContext::HasSameProjector(const Handle(Select3D_Projector)& thePrj) const
 {
-  const Select3D_Projector& CurPrj = myMainVS->Projector();
+  const Handle(Select3D_Projector)& aCurPrj = myMainVS->Projector();
-  if(CurPrj.Perspective()!=aPrj.Perspective()) return Standard_False;  
+  if (aCurPrj->Perspective() != thePrj->Perspective())
-  if(CurPrj.Perspective())
+    return Standard_False;  
-    if(CurPrj.Focus()!=aPrj.Focus()) return Standard_False;
+  if (aCurPrj->Perspective() && aCurPrj->Focus() != thePrj->Focus())
-  gp_GTrsf CurTrsf(CurPrj.Transformation());
+    return Standard_False;
-  gp_GTrsf PrjTrsf(aPrj.Transformation());
+  const gp_GTrsf& aCurTrsf = aCurPrj->Transformation();
+  const gp_GTrsf& aPrjTrsf = thePrj->Transformation();
 
-  for(Standard_Integer i=1;i<=3;i++){
+  for (Standard_Integer i = 1; i <= 3; ++i)
-    for(Standard_Integer j=1;j<=3;j++){
+  {
-      if(CurTrsf.Value(i,j)!=PrjTrsf.Value(i,j)) 
+    for (Standard_Integer j = 1; j <= 3 ; ++j)
+    {
+      if (aCurTrsf.Value (i, j) != aPrjTrsf.Value (i, j))
         return Standard_False;
     }
   }

src/MeshVS/MeshVS_SensitiveFace.cxx

@@ -31,13 +31,13 @@ MeshVS_SensitiveFace::MeshVS_SensitiveFace (
 // name    : MeshVS_SensitiveFace::Project
 // Purpose :
 //=======================================================================
-void MeshVS_SensitiveFace::Project( const Select3D_Projector& aProj )
+void MeshVS_SensitiveFace::Project( const Handle(Select3D_Projector)& aProj )
 {
   Select3D_SensitiveFace::Project( aProj );
   if ( HasLocation() )
-    aProj.Project( myCentre.Transformed( Location().Transformation() ), myProjCentre );
+    aProj->Project( myCentre.Transformed( Location().Transformation() ), myProjCentre );
   else
-    aProj.Project( myCentre, myProjCentre );
+    aProj->Project( myCentre, myProjCentre );
 }
 
 //=======================================================================

src/MeshVS/MeshVS_SensitiveMesh.cxx

@@ -139,14 +139,14 @@ Handle(Select3D_SensitiveEntity) MeshVS_SensitiveMesh::GetConnected( const TopLo
 //=======================================================================
 Standard_Real MeshVS_SensitiveMesh::ComputeDepth( const gp_Lin& /*EyeLine*/ ) const
 {
-  return 0.;
+  return Precision::Infinite();
 }
 
 //==================================================
 // Function: ProjectOneCorner
 // Purpose :
 //==================================================
-void MeshVS_SensitiveMesh::ProjectOneCorner(const Select3D_Projector& theProj,
+void MeshVS_SensitiveMesh::ProjectOneCorner(const Handle(Select3D_Projector)& theProj,
 					    const Standard_Real theX, 
 					    const Standard_Real theY, 
 					    const Standard_Real theZ)
@@ -154,9 +154,9 @@ void MeshVS_SensitiveMesh::ProjectOneCorner(const Select3D_Projector& theProj,
   gp_Pnt aPnt( theX, theY, theZ );  
   gp_Pnt2d aProjPnt;
   if( HasLocation() )
-    theProj.Project( aPnt.Transformed(Location().Transformation()), aProjPnt );
+    theProj->Project( aPnt.Transformed(Location().Transformation()), aProjPnt );
   else 
-    theProj.Project( aPnt, aProjPnt );
+    theProj->Project( aPnt, aProjPnt );
   mybox2d.Add( aProjPnt );
 }
 
@@ -164,7 +164,7 @@ void MeshVS_SensitiveMesh::ProjectOneCorner(const Select3D_Projector& theProj,
 // Function: Project
 // Purpose :
 //==================================================
-void MeshVS_SensitiveMesh::Project(const Select3D_Projector& aProj)
+void MeshVS_SensitiveMesh::Project(const Handle(Select3D_Projector)& aProj)
 {
   Select3D_SensitiveEntity::Project(aProj); // to set the field last proj...
 

src/MeshVS/MeshVS_SensitivePolyhedron.cxx

@@ -34,7 +34,7 @@ MeshVS_SensitivePolyhedron( const Handle( SelectBasics_EntityOwner )& Owner,
 // Function : Project
 // Purpose  :
 //================================================================
-void MeshVS_SensitivePolyhedron::Project( const Select3D_Projector& aProjector )
+void MeshVS_SensitivePolyhedron::Project( const Handle(Select3D_Projector)& aProjector )
 {
   Select3D_SensitiveEntity::Project( aProjector );
 
@@ -55,9 +55,9 @@ void MeshVS_SensitivePolyhedron::Project( const Select3D_Projector& aProjector )
   {
     pnt = myNodes->Value( i );
     if( !hasLoc )
-      aProjector.Project( pnt, proj );
+      aProjector->Project( pnt, proj );
     else
-      aProjector.Project( pnt.Transformed( Location().Transformation() ), proj );
+      aProjector->Project( pnt.Transformed( Location().Transformation() ), proj );
 
     myNodes2d->SetValue( i, proj.XY() );
     myCenter += proj.XY();
@@ -161,9 +161,10 @@ Standard_Boolean MeshVS_SensitivePolyhedron::Matches( const Standard_Real X,
   }
 
   if( inside )
-    Select3D_SensitiveEntity::Matches( X, Y, aTol, DMin );
+  {
-
+    return Select3D_SensitiveEntity::Matches( X, Y, aTol, DMin );
-  return inside;
+  }
+  return Standard_False;
 }
 
 //================================================================

src/MeshVS/MeshVS_SensitiveSegment.cxx

@@ -27,13 +27,13 @@ MeshVS_SensitiveSegment::MeshVS_SensitiveSegment (
 // name    : MeshVS_SensitiveSegment::Project
 // Purpose :
 //=======================================================================
-void MeshVS_SensitiveSegment::Project( const Select3D_Projector& aProj )
+void MeshVS_SensitiveSegment::Project( const Handle(Select3D_Projector)& aProj )
 {
   Select3D_SensitiveSegment::Project( aProj );
   if ( HasLocation() )
-    aProj.Project( myCentre.Transformed( Location().Transformation() ), myProjCentre );
+    aProj->Project( myCentre.Transformed( Location().Transformation() ), myProjCentre );
   else
-    aProj.Project( myCentre, myProjCentre );
+    aProj->Project( myCentre, myProjCentre );
 }
 
 //=======================================================================

src/OpenGl/OpenGl_togl_begin_immediat_mode.cxx

@@ -286,23 +286,19 @@ void EXPORT call_togl_clear_immediat_mode (
     call_subr_displayCB(aview,OCC_REDRAW_WINDOW);
 #endif
     call_func_redraw_all_structs_end (aview->WsId, aFlush);
-    /*
+    // After a redraw,
-    After a redraw,
+    // Made the back identical to the front buffer.
-    Made the back identical to the front buffer
+    // Always perform full copy (partial update optimization is useless on mordern hardware)!
-    */
+    if (retainmode)
-    if( retainmode && (partial >= 0) )
+      TelCopyBuffers (aview->WsId, GL_FRONT, GL_BACK, xm, ym, zm, XM, YM, ZM, 0);
-      TelCopyBuffers (aview->WsId, GL_FRONT, GL_BACK,
-      xm, ym, zm, XM, YM, ZM, partial);
 #ifdef TRACE
     printf(" $$$ REDRAW\n");
 #endif
     TelSetBackBufferRestored (TOn);
   } else if( partial >= 0 ) {
-    /*
+    // Restore pixels from the back buffer.
-    Restore pixels from the back buffer.
+    // Always perform full copy (partial update optimization is useless on mordern hardware)!
-    */
+    TelCopyBuffers (aview->WsId, GL_BACK, GL_FRONT, xm, ym, zm, XM, YM, ZM, 0);
-    TelCopyBuffers (aview->WsId, GL_BACK, GL_FRONT,
-      xm, ym, zm, XM, YM, ZM, partial);
   }
 
   TsmGetWSAttri (aview->WsId, WSTransient, &data);

src/Poly/Poly.cdl

@@ -1,5 +1,4 @@
-
+-- File:        Poly.cdl
--- -- File:        Poly.cdl
 -- Created:     Mon Mar  6 09:38:50 1995
 -- Author:      Laurent PAINNOT
 --              <lpa@metrox>
@@ -161,4 +160,17 @@ is
         ---Purpose: Compute node normals for face triangulation
         --  as mean normal of surrounding triangles
 
+    PointOnTriangle(P1, P2, P3, P: XY from gp; UV: out XY from gp)
+    returns Real;
+        ---Purpose: Computes parameters of the point P on triangle
+        --          defined by points P1, P2, and P3, in 2d.
+        --          The parameters U and V are defined so that
+        --          P = P1 + U * (P2 - P1) + V * (P3 - P1),
+        --          with U >= 0, V >= 0, U + V <= 1.
+        --          If P is located outside of triangle, or triangle
+        --          is degenerated, the returned parameters correspond
+        --          to closest point, and returned value is square of
+        --          the distance from original point to triangle (0 if
+        --          point is inside).
+
 end Poly;

src/Poly/Poly.cxx

@@ -25,8 +25,7 @@
 //purpose  : Join several triangulations to one new triangulation object
 //=======================================================================
 
-Handle(Poly_Triangulation) Poly::Catenate
+Handle(Poly_Triangulation) Poly::Catenate (const Poly_ListOfTriangulation& lstTri)
-                        (const Poly_ListOfTriangulation& lstTri)
 {
   Standard_Integer nNodes(0);
   Standard_Integer nTrian(0);
@@ -493,3 +492,107 @@ void  Poly::ComputeNormals(const Handle(Poly_Triangulation)& Tri)
 
   Tri->SetNormals(Normals);
 }
+
+//=======================================================================
+//function : PointOnTriangle
+//purpose  : 
+//=======================================================================
+
+Standard_Real Poly::PointOnTriangle (const gp_XY& theP1, const gp_XY& theP2, const gp_XY& theP3, 
+			             const gp_XY& theP, gp_XY& theUV)
+{
+  gp_XY aDP = theP  - theP1;
+  gp_XY aDU = theP2 - theP1;
+  gp_XY aDV = theP3 - theP1;
+  Standard_Real aDet = aDU ^ aDV;
+
+  // case of non-degenerated triangle
+  if ( Abs (aDet) > gp::Resolution() )
+  {
+    Standard_Real aU =  (aDP ^ aDV) / aDet;
+    Standard_Real aV = -(aDP ^ aDU) / aDet;
+
+    // if point is inside triangle, just return parameters
+    if ( aU > -gp::Resolution() &&
+         aV > -gp::Resolution() &&
+         1. - aU - aV > -gp::Resolution() ) 
+    {
+      theUV.SetCoord (aU, aV);
+      return 0.;
+    }
+
+    // else find closest point on triangle sides; note that in general case  
+    // triangle can be very distorted and it is necessary to check 
+    // projection on all sides regardless of values of computed parameters
+
+    // project on side U=0
+    aU = 0.;
+    aV = Min (1., Max (0., (aDP * aDV) / aDV.SquareModulus()));
+    Standard_Real aD = (aV * aDV - aDP).SquareModulus();
+
+    // project on side V=0
+    Standard_Real u = Min (1., Max (0., (aDP * aDU) / aDU.SquareModulus()));
+    Standard_Real d = (u * aDU - aDP).SquareModulus();
+    if ( d < aD )
+    {
+      aU = u;
+      aV = 0.;
+      aD = d;
+    }
+
+    // project on side U+V=1
+    gp_XY aDUV = aDV - aDU;
+    Standard_Real v = Min (1., Max (0., ((aDP - aDU) * aDUV) / aDUV.SquareModulus()));
+    d = (theP2 + v * aDUV - theP).SquareModulus();
+    if ( d < aD )
+    {
+      aU = 1. - v;
+      aV = v;
+      aD = d;
+    }
+
+    theUV.SetCoord (aU, aV);
+    return aD;
+  }
+
+  // degenerated triangle
+  Standard_Real aL2U = aDU.SquareModulus();
+  Standard_Real aL2V = aDV.SquareModulus();
+  if ( aL2U < gp::Resolution() ) // side 1-2 is degenerated
+  {
+    if ( aL2V < gp::Resolution() ) // whole triangle is degenerated to point
+    {
+      theUV.SetCoord (0., 0.);
+      return (theP - theP1).SquareModulus();
+    }
+    else
+    {
+      theUV.SetCoord (0., (aDP * aDV) / aL2V);
+      return (theP - (theP1 + theUV.Y() * aDV)).SquareModulus();
+    }
+  }
+  else if ( aL2V < gp::Resolution() ) // side 1-3 is degenerated
+  {
+    theUV.SetCoord ((aDP * aDU) / aL2U, 0.);
+    return (theP - (theP1 + theUV.X() * aDU)).SquareModulus();
+  }
+  else // sides 1-2 and 1-3 are collinear
+  {
+    // select parameter on one of sides so as to have points closer to picked
+    Standard_Real aU = Min (1., Max (0., (aDP * aDU) / aL2U));
+    Standard_Real aV = Min (1., Max (0., (aDP * aDV) / aL2V));
+    Standard_Real aD1 = (aDP - aU * aDU).SquareModulus();
+    Standard_Real aD2 = (aDP - aV * aDV).SquareModulus();
+    if ( aD1 < aD2 )
+    {
+      theUV.SetCoord ((aDP * aDU) / aL2U, 0.);
+      return aD1;
+    }
+    else
+    {
+      theUV.SetCoord (0., (aDP * aDV) / aL2V);
+      return aD2;
+    }
+  }
+}
+

src/QABUC/QABUC.cxx

@@ -758,7 +758,8 @@ static Standard_Integer BUC60698(Draw_Interpretor& di, Standard_Integer argc, co
   gp_Pln thegpPln = gce_MakePln(gp_Pnt(0.5,0.5,0.5),gp_Dir(0,0,1));
   Standard_Real A,B,C,D;
   thegpPln.Coefficients(A,B,C,D);
-  Handle_V3d_Plane thePlane = new V3d_Plane(myAISContext->CurrentViewer(),A,B,C,D);
+  Handle_V3d_Plane thePlane = new V3d_Plane(A,B,C,D);
+  myAISContext->CurrentViewer()->AddPlane (thePlane); // add to defined planes list
   for (myAISContext->CurrentViewer()->InitActiveViews();
        myAISContext->CurrentViewer()->MoreActiveViews ();
        myAISContext->CurrentViewer()->NextActiveViews ()) {

src/Select3D/Select3D_Projector.cdl

@@ -4,7 +4,7 @@
 --        <cma@sdsun2> copie quasi exacte de HLRAlgo_Projector
 ---Copyright:     Matra Datavision 1992
 
-class Projector from Select3D
+class Projector from Select3D inherits Transient from Standard
     ---Purpose: A framework to define 3D projectors.
 uses
     Real    from Standard,
@@ -59,17 +59,14 @@ is
     ---Purpose: build a Projector with automatic minmax directions.
     returns Projector from Select3D;
 
-    Delete(me:out) is virtual;
+    Set (me : mutable;
-    	---C++: alias "Standard_EXPORT virtual ~Select3D_Projector(){Delete() ; }"
-    
-    Set (me: in out ;
          T         : Trsf    from gp;
          Persp     : Boolean from Standard;
          Focus     : Real    from Standard)
     is static;
 
 
-    SetView(me:in out ; V : View from V3d);
+    SetView(me : mutable; V : View from V3d);
     ---Purpose: Sets the 3D view V used at the time of construction.
 
     View(me) returns any View from V3d;
@@ -82,7 +79,7 @@ is
     ---C++: inline
     is virtual;
 
-    Scaled(me : in out; On : Boolean from Standard = Standard_False)
+    Scaled(me : mutable; On : Boolean from Standard = Standard_False)
     ---Purpose: to compute with the given scale and translation.
     is virtual;
 
@@ -152,7 +149,24 @@ is
     --          2d point <X,Y>.
     is virtual;
 
-    SetDirection(me: in out) 
+    DepthMin(me) returns Real from Standard;
+    ---Purpose: Returns the minimum depth value (if clipping plane defined).
+    ---         Should be used when call ::Shoot() to compute eyeline.
+    ---C++: inline
+
+    DepthMax(me) returns Real from Standard;
+    ---Purpose: Returns the maximum depth value (if clipping plane defined).
+    ---         Should be used when call ::Shoot() to compute eyeline.
+    ---C++: inline
+
+    DepthMinMax(me : mutable;
+                theDepthMin : in Real from Standard;
+                theDepthMax : in Real from Standard);
+    ---Purpose: Setup the min/max depth values (doesn't affect
+    ---         projection functionality itself).
+    ---         Should be used when call ::Shoot() to compute eyeline.
+
+    SetDirection(me : mutable)
     is static private;
 
     Transform(me; P : in out Pnt from gp;
@@ -177,7 +191,8 @@ fields
     myD2         : Vec2d   from gp is protected;
     myD3         : Vec2d   from gp is protected;
 
-
     myView       : View    from V3d;
+    myDepthMin   : Real    from Standard;
+    myDepthMax   : Real    from Standard;
 
 end Projector;

src/Select3D/Select3D_Projector.cxx

@@ -25,14 +25,15 @@
 //purpose  :
 //=======================================================================
 
-
+Select3D_Projector::Select3D_Projector(const Handle(V3d_View)& aViou)
-Select3D_Projector::Select3D_Projector(const Handle(V3d_View)& aViou):
+: myPersp(aViou->Type()==V3d_PERSPECTIVE),
-myPersp(aViou->Type()==V3d_PERSPECTIVE),
   myFocus(aViou->Focale()),
   myD1(1,0),
   myD2(0,1),
   myD3(1,1),
-myView(aViou)
+  myView(aViou),
+  myDepthMin(-Precision::Infinite()),
+  myDepthMax( Precision::Infinite())
 {
   Standard_Real Xat,Yat,Zat,XUp,YUp,ZUp,DX,DY,DZ;
   //Standard_Boolean Pers=Standard_False;
@@ -51,8 +52,19 @@ myView(aViou)
 
 }
 
-Select3D_Projector::Select3D_Projector () :
+//=======================================================================
-myPersp(Standard_False),myFocus(0),myD1(1,0),myD2(0,1),myD3(1,1)
+//function : Select3D_Projector
+//purpose  :
+//=======================================================================
+
+Select3D_Projector::Select3D_Projector()
+: myPersp(Standard_False),
+  myFocus(0),
+  myD1(1,0),
+  myD2(0,1),
+  myD3(1,1),
+  myDepthMin(-Precision::Infinite()),
+  myDepthMax( Precision::Infinite())
 {
   Scaled();
   SetDirection();
@@ -63,9 +75,11 @@ myPersp(Standard_False),myFocus(0),myD1(1,0),myD2(0,1),myD3(1,1)
 //purpose  :
 //=======================================================================
 
-Select3D_Projector::Select3D_Projector 
+Select3D_Projector::Select3D_Projector (const gp_Ax2& CS)
-  (const gp_Ax2& CS) :
+: myPersp(Standard_False),
-  myPersp(Standard_False), myFocus(0)
+  myFocus(0),
+  myDepthMin(-Precision::Infinite()),
+  myDepthMax( Precision::Infinite())
 {
   myScaledTrsf.SetTransformation(CS);
   myGTrsf.SetTrsf(myScaledTrsf);
@@ -78,29 +92,32 @@ Select3D_Projector::Select3D_Projector
 //purpose  :
 //=======================================================================
 
-Select3D_Projector::Select3D_Projector 
+Select3D_Projector::Select3D_Projector (const gp_Ax2& CS,
-  (const gp_Ax2& CS, 
+                                        const Standard_Real Focus)
-   const Standard_Real Focus) :
+: myPersp(Standard_True),
-  myPersp(Standard_True), myFocus(Focus)
-{
-  myScaledTrsf.SetTransformation(CS);
-  myGTrsf.SetTrsf(myScaledTrsf);
-  Scaled();
-  SetDirection();
-}
-
-//=======================================================================
-//function : Select3D_Projector
-//purpose  : 
-//=======================================================================
-
-Select3D_Projector::Select3D_Projector 
-  (const gp_Trsf& T, 
-   const Standard_Boolean Persp,
-   const Standard_Real Focus) :
-  myPersp(Persp),
   myFocus(Focus),
-  myScaledTrsf(T)
+  myDepthMin(-Precision::Infinite()),
+  myDepthMax( Precision::Infinite())
+{
+  myScaledTrsf.SetTransformation(CS);
+  myGTrsf.SetTrsf(myScaledTrsf);
+  Scaled();
+  SetDirection();
+}
+
+//=======================================================================
+//function : Select3D_Projector
+//purpose  :
+//=======================================================================
+
+Select3D_Projector::Select3D_Projector (const gp_Trsf& T,
+                                        const Standard_Boolean Persp,
+                                        const Standard_Real Focus)
+: myPersp(Persp),
+  myFocus(Focus),
+  myScaledTrsf(T),
+  myDepthMin(-Precision::Infinite()),
+  myDepthMax( Precision::Infinite())
 {
   myGTrsf.SetTrsf(myScaledTrsf);
   Scaled();
@@ -112,19 +129,20 @@ Select3D_Projector::Select3D_Projector
 //purpose  :
 //=======================================================================
 
-Select3D_Projector::Select3D_Projector 
+Select3D_Projector::Select3D_Projector (const gp_Trsf& T,
-  (const gp_Trsf& T, 
                                         const Standard_Boolean Persp,
                                         const Standard_Real Focus,
                                         const gp_Vec2d& v1,
                                         const gp_Vec2d& v2,
-   const gp_Vec2d& v3) :
+                                        const gp_Vec2d& v3)
-  myPersp(Persp),
+: myPersp(Persp),
   myFocus(Focus),
   myScaledTrsf(T),
   myD1(v1),
   myD2(v2),
-  myD3(v3)
+  myD3(v3),
+  myDepthMin(-Precision::Infinite()),
+  myDepthMax( Precision::Infinite())
 {
   myGTrsf.SetTrsf(myScaledTrsf);
   Scaled();
@@ -135,21 +153,19 @@ Select3D_Projector::Select3D_Projector
 //purpose  :
 //=======================================================================
 
-Select3D_Projector::Select3D_Projector 
+Select3D_Projector::Select3D_Projector (const gp_GTrsf& GT,
-  (const gp_GTrsf& GT, 
                                         const Standard_Boolean Persp,
-   const Standard_Real Focus) :
+                                        const Standard_Real Focus)
-  myPersp(Persp),
+: myPersp(Persp),
   myFocus(Focus),
-  myGTrsf(GT)
+  myGTrsf(GT),
+  myDepthMin(-Precision::Infinite()),
+  myDepthMax( Precision::Infinite())
 {
   Scaled();
   SetDirection();
 }
 
-void Select3D_Projector::Delete()
-{}
-
 //=======================================================================
 //function : Set
 //purpose  :
@@ -504,3 +520,10 @@ void Select3D_Projector::SetView(const Handle(V3d_View)& aViou)
   Scaled();
 
 }
+
+void Select3D_Projector::DepthMinMax (const Standard_Real theDepthMin,
+                                      const Standard_Real theDepthMax)
+{
+  myDepthMin = theDepthMin;
+  myDepthMax = theDepthMax;
+}

src/Select3D/Select3D_Projector.lxx

@@ -124,4 +124,12 @@ inline void Select3D_Projector::Transform (gp_Pnt& Pnt, const gp_GTrsf& T) const
   Pnt = gp_Pnt(xyz);
 }
 
+inline Standard_Real Select3D_Projector::DepthMin() const
+{
+  return myDepthMin;
+}
 
+inline Standard_Real Select3D_Projector::DepthMax() const
+{
+  return myDepthMax;
+}

src/Select3D/Select3D_SensitiveBox.cxx

@@ -49,7 +49,7 @@ Select3D_SensitiveEntity(OwnerId)
 // Purpose :
 //==================================================
 void Select3D_SensitiveBox::
-Project(const Select3D_Projector& aProj)
+Project(const Handle(Select3D_Projector)& aProj)
 {
   Select3D_SensitiveEntity::Project(aProj); // to set the field last proj...
 
@@ -164,7 +164,7 @@ void Select3D_SensitiveBox::Dump(Standard_OStream& S,const Standard_Boolean Full
 //purpose  : 
 //=======================================================================
 
-void Select3D_SensitiveBox::ProjectBox(const Select3D_Projector& aPrj,
+void Select3D_SensitiveBox::ProjectBox(const Handle(Select3D_Projector)& aPrj,
 				       const Bnd_Box& aBox) 
 {
   mybox2d.SetVoid();
@@ -172,21 +172,21 @@ void Select3D_SensitiveBox::ProjectBox(const Select3D_Projector& aPrj,
   Standard_Real XMin,YMin,ZMin,XMax,YMax,ZMax;
   aBox.Get(XMin,YMin,ZMin,XMax,YMax,ZMax);
 
-  aPrj.Project(gp_Pnt(XMin,YMin,ZMin),curp2d);
+  aPrj->Project(gp_Pnt(XMin,YMin,ZMin),curp2d);
   mybox2d.Update(curp2d.X(),curp2d.Y());
-  aPrj.Project(gp_Pnt(XMax,YMin,ZMin),curp2d);
+  aPrj->Project(gp_Pnt(XMax,YMin,ZMin),curp2d);
   mybox2d.Update(curp2d.X(),curp2d.Y());
-  aPrj.Project(gp_Pnt(XMax,YMax,ZMin),curp2d);
+  aPrj->Project(gp_Pnt(XMax,YMax,ZMin),curp2d);
   mybox2d.Update(curp2d.X(),curp2d.Y());
-  aPrj.Project(gp_Pnt(XMin,YMax,ZMin),curp2d);
+  aPrj->Project(gp_Pnt(XMin,YMax,ZMin),curp2d);
   mybox2d.Update(curp2d.X(),curp2d.Y());
-  aPrj.Project(gp_Pnt(XMin,YMin,ZMax),curp2d);
+  aPrj->Project(gp_Pnt(XMin,YMin,ZMax),curp2d);
   mybox2d.Update(curp2d.X(),curp2d.Y());
-  aPrj.Project(gp_Pnt(XMax,YMin,ZMax),curp2d);
+  aPrj->Project(gp_Pnt(XMax,YMin,ZMax),curp2d);
   mybox2d.Update(curp2d.X(),curp2d.Y());
-  aPrj.Project(gp_Pnt(XMax,YMax,ZMax),curp2d);
+  aPrj->Project(gp_Pnt(XMax,YMax,ZMax),curp2d);
   mybox2d.Update(curp2d.X(),curp2d.Y());
-  aPrj.Project(gp_Pnt(XMin,YMax,ZMax),curp2d);
+  aPrj->Project(gp_Pnt(XMin,YMax,ZMax),curp2d);
   mybox2d.Update(curp2d.X(),curp2d.Y());
 }
 

src/Select3D/Select3D_SensitiveCurve.cxx

@@ -64,16 +64,18 @@ Standard_Boolean Select3D_SensitiveCurve
   Standard_Integer Rank;
   TColgp_Array1OfPnt2d aArrayOf2dPnt(1, mynbpoints);
   Points2D(aArrayOf2dPnt);
-  Standard_Boolean KK = SelectBasics_BasicTool::MatchPolyg2d(aArrayOf2dPnt,
+  if (SelectBasics_BasicTool::MatchPolyg2d (aArrayOf2dPnt,
                                             X, Y,
                                             aTol,
                                             DMin,
-                                 Rank);
+                                            Rank))
-  if(KK){
+  {
-    Select3D_SensitiveEntity::Matches(X,Y,aTol,DMin);
     mylastseg = Rank;
+    // compute and validate the depth (::Depth()) along the eyeline
+    return Select3D_SensitiveEntity::Matches (X, Y, aTol, DMin);
+    
   }
-  return KK;
+  return Standard_False;
 
 }
 //==================================================

src/Select3D/Select3D_SensitiveEntity.cdl

@@ -146,7 +146,7 @@ is
 
 fields
 
-    mylastprj     : Address   from Standard  is protected;
+    mylastprj     : Projector from Select3D  is protected;
     mylastdepth   : ShortReal from Standard;
 end SensitiveEntity;
 

src/Select3D/Select3D_SensitiveEntity.cxx

@@ -19,8 +19,8 @@
 
 Select3D_SensitiveEntity::Select3D_SensitiveEntity(const Handle(SelectBasics_EntityOwner)& OwnerId):
 SelectBasics_SensitiveEntity(OwnerId),
-mylastprj(NULL),
+mylastprj(),
-mylastdepth(0.0)
+mylastdepth(ShortRealLast())
 {}
 
 //=======================================================================
@@ -28,9 +28,9 @@ mylastdepth(0.0)
 //purpose  : 
 //=======================================================================
 
-void Select3D_SensitiveEntity::Project(const Select3D_Projector& aPrj)
+void Select3D_SensitiveEntity::Project(const Handle(Select3D_Projector)& aPrj)
 {
-  mylastprj = (Standard_Address*)&aPrj;
+  mylastprj = aPrj;
 }
 
 //=======================================================================
@@ -43,12 +43,17 @@ Standard_Boolean Select3D_SensitiveEntity::Matches(const Standard_Real X,
 						   const Standard_Real aTol,
 						   Standard_Real&  DMin)
 {
-  gp_Lin L;
+  if (!mylastprj.IsNull())
-  if(mylastprj!=NULL)
+  {
-    L = (* ((Select3D_Projector*) mylastprj)).Shoot(X,Y);
+    gp_Lin L = mylastprj->Shoot (X, Y);
     SetLastDepth (ComputeDepth (L));
-
+    return (mylastdepth > mylastprj->DepthMin()) && (mylastdepth < mylastprj->DepthMax());
-  return (Abs(mylastdepth)>Precision::Confusion());
+  }
+  else
+  {
+    SetLastDepth (ComputeDepth (gp_Lin())); // how we determine depth without eyeline here?
+    return (mylastdepth > ShortRealFirst()) && (mylastdepth < ShortRealLast());
+  }
 }
 
 //=======================================================================
@@ -184,8 +189,10 @@ gp_Lin Select3D_SensitiveEntity::GetEyeLine(const Standard_Real X,
 					    const Standard_Real Y) const
 {
   gp_Lin L;
-  if(mylastprj!=NULL)
+  if (!mylastprj.IsNull())
-    L = (* ((Select3D_Projector*) mylastprj)).Shoot(X,Y);
+  {
+    L = mylastprj->Shoot (X, Y);
+  }
   return L;
 }
 
@@ -202,8 +209,8 @@ Standard_Integer Select3D_SensitiveEntity::MaxBoxes() const
 //purpose  : 
 //=======================================================================
 
-void Select3D_SensitiveEntity::SetLastPrj(const Select3D_Projector& aprj)
+void Select3D_SensitiveEntity::SetLastPrj(const Handle(Select3D_Projector)& aprj)
-{ mylastprj = (Standard_Address*)& aprj;}
+{ mylastprj = aprj; }
 
 
 //=======================================================================

src/Select3D/Select3D_SensitiveFace.cxx

@@ -8,6 +8,7 @@
 //Modif on jul-21-97 : changement en harray1 pour eventuelles connexions ...
 
 #include <Select3D_SensitiveFace.ixx>
+#include <Select3D_Projector.hxx>
 #include <SelectBasics_BasicTool.hxx>
 #include <gp_Pnt2d.hxx>
 #include <gp_Pnt.hxx>
@@ -117,11 +118,9 @@ Matches(const Standard_Real X,
     Standard_Real valtst = PlaneTest^V1;
     if(isplane2d && Abs(valtst)>aTol) isplane2d=Standard_False;
   }
-
+  if (isplane2d)
-  if(isplane2d) {
+  {
-    Select3D_SensitiveEntity::Matches(X,Y,aTol,DMin);
+    return Select3D_SensitiveEntity::Matches(X,Y,aTol,DMin);
-    
-    return Standard_True;
   }
   //detection d'une auto - intersection dans le polygon 2D; si oui on sort
 //    if (!AutoComputeFlag(myautointer)) {
@@ -152,9 +151,10 @@ Matches(const Standard_Real X,
     }
   }
   if (res)
-    Select3D_SensitiveEntity::Matches(X,Y,aTol,DMin);
+  {
-    
+    return Select3D_SensitiveEntity::Matches(X,Y,aTol,DMin);
-  return res;
+  }
+  return Standard_False;
 }
 
 //=======================================================================
@@ -230,8 +230,17 @@ void Select3D_SensitiveFace::Dump(Standard_OStream& S,const Standard_Boolean Ful
 //=======================================================================
 Standard_Real Select3D_SensitiveFace::ComputeDepth(const gp_Lin& EyeLine) const
 {
-  Standard_Real val(Precision::Infinite());
+  Standard_Real aDepth = Precision::Infinite();
+  Standard_Real aDepthMin = !mylastprj.IsNull() ? mylastprj->DepthMin() : -Precision::Infinite();
+  Standard_Real aDepthMax = !mylastprj.IsNull() ? mylastprj->DepthMax() :  Precision::Infinite();
+  Standard_Real aDepthTest;
   for (Standard_Integer i = 0; i < mynbpoints - 1; i++)
-    val = Min(val,ElCLib::Parameter(EyeLine,((Select3D_Pnt*)mypolyg3d)[i]));
+  {
-  return val;
+    aDepthTest = ElCLib::Parameter (EyeLine, ((Select3D_Pnt* )mypolyg3d)[i]);
+    if (aDepthTest < aDepth && (aDepthTest > aDepthMin) && (aDepthTest < aDepthMax))
+    {
+      aDepth = aDepthTest;
+    }
+  }
+  return aDepth;
 }

src/Select3D/Select3D_SensitiveGroup.cxx

@@ -89,7 +89,7 @@ void Select3D_SensitiveGroup::Clear()
 //purpose  : 
 //=======================================================================
 
-void Select3D_SensitiveGroup::Project(const Select3D_Projector& aProjector) 
+void Select3D_SensitiveGroup::Project(const Handle(Select3D_Projector)& aProjector) 
 {
   Select3D_SensitiveEntity::Project(aProjector); // to set the field last proj...
 
@@ -180,16 +180,16 @@ Standard_Boolean Select3D_SensitiveGroup::Matches(const Standard_Real X,
   myLastTol = aTol;
   for(Select3D_ListIteratorOfListOfSensitive It(myList);It.More();It.Next()){
     myLastRank++;
-    if(It.Value()->Matches(X,Y,aTol,DMin)){
+    if (It.Value()->Matches (X, Y, aTol, DMin))
+    {
       myX = X; myY = Y; myLastTol = aTol;
-      SetLastDepth( Precision::Infinite() );
+      // compute and validate the depth (will call ::ComputeDepth())
-      
+      return Select3D_SensitiveEntity::Matches (X, Y, aTol, DMin);
-      Select3D_SensitiveEntity::Matches(X,Y,aTol,DMin);
-      return Standard_True;
     }
   }
+  // no match
   myLastRank = 0;
-  SetLastDepth(0.0);
+  SetLastDepth (ShortRealLast());
   return Standard_False;
 }
 
@@ -258,18 +258,25 @@ Matches (const TColgp_Array1OfPnt2d& aPoly,
 //=======================================================================
 Standard_Real Select3D_SensitiveGroup::ComputeDepth(const gp_Lin& EyeLine) const
 {
-  Standard_Integer currank(0);
+  Standard_Integer currank = 0;
   Standard_Real DMin, thedepth (Precision::Infinite());
-  for(Select3D_ListIteratorOfListOfSensitive It(myList);It.More();It.Next()){
+  for (Select3D_ListIteratorOfListOfSensitive It(myList);It.More();It.Next())
+  {
     currank++;
-    if(currank>=myLastRank){
+    if (currank >= myLastRank)
-      if(It.Value()->Matches(myX,myY,myLastTol,DMin)){
+    {
+      // this recomputes and validates the depth for the entity
+      if (It.Value()->Matches (myX, myY, myLastTol, DMin))
+      {
         It.Value()->ComputeDepth (EyeLine);
-	thedepth = Min(Depth(),
+        if (It.Value()->Depth() < thedepth)
-		       It.Value()->Depth());
+        {
+          // search for topmost entity
+          thedepth = It.Value()->Depth();
+          //myLastRank = currank; // can not do this here...
+        }
       }
     }
-    
   }
   return thedepth;
 }
@@ -287,7 +294,7 @@ Standard_Integer Select3D_SensitiveGroup::MaxBoxes() const
   return nbboxes;
 }
 
-void Select3D_SensitiveGroup::SetLastPrj(const Select3D_Projector& Prj)
+void Select3D_SensitiveGroup::SetLastPrj(const Handle(Select3D_Projector)& Prj)
 {
   Select3D_SensitiveEntity::SetLastPrj(Prj);
   for(Select3D_ListIteratorOfListOfSensitive It(myList);It.More();It.Next())

src/Select3D/Select3D_SensitivePoint.cxx

@@ -32,15 +32,15 @@ Select3D_SensitiveEntity(anOwner)
 // Purpose :
 //==================================================
 void Select3D_SensitivePoint
-::Project (const Select3D_Projector& aProj)
+::Project (const Handle(Select3D_Projector)& aProj)
 {
   Select3D_SensitiveEntity::Project(aProj); // to set the field last proj...
   gp_Pnt2d aPoint2d;
   if(!HasLocation())
-    aProj.Project(mypoint, aPoint2d);
+    aProj->Project(mypoint, aPoint2d);
   else{
     gp_Pnt aP(mypoint.x, mypoint.y, mypoint.z);
-    aProj.Project(aP.Transformed(Location().Transformation()), aPoint2d);
+    aProj->Project(aP.Transformed(Location().Transformation()), aPoint2d);
   }
   myprojpt = aPoint2d;
 }
@@ -69,9 +69,10 @@ Standard_Boolean Select3D_SensitivePoint
 	  Standard_Real& DMin)
 {
   DMin = gp_Pnt2d(X,Y).Distance(myprojpt);
-  if(DMin<=aTol*SensitivityFactor()) {
+  if(DMin<=aTol*SensitivityFactor())
-    Select3D_SensitiveEntity::Matches(X,Y,aTol,DMin);
+  {
-    return Standard_True;
+    // compute and validate the depth (::Depth()) along the eyeline
+    return Select3D_SensitiveEntity::Matches(X,Y,aTol,DMin);
   }
   return Standard_False;
 }

src/Select3D/Select3D_SensitivePoly.cxx

@@ -61,7 +61,7 @@ Select3D_SensitiveEntity(OwnerId)
 // Purpose :
 //==================================================
 
-void Select3D_SensitivePoly::Project(const Select3D_Projector& aProj)
+void Select3D_SensitivePoly::Project(const Handle(Select3D_Projector)& aProj)
 {
   Select3D_SensitiveEntity::Project(aProj); // to set the field last proj...
   mybox2d.SetVoid();
@@ -71,11 +71,14 @@ void Select3D_SensitivePoly::Project(const Select3D_Projector& aProj)
   for(Standard_Integer i=0;i<mynbpoints;i++)
     {
       gp_Pnt aPnt(((Select3D_Pnt*)mypolyg3d)[i].x, ((Select3D_Pnt*)mypolyg3d)[i].y, ((Select3D_Pnt*)mypolyg3d)[i].z);
-      if(hasloc){
+      if (hasloc)
-	aProj.Project(aPnt.Transformed(Location().Transformation()),aPnt2d);
+      {
+        aProj->Project(aPnt.Transformed(Location().Transformation()),aPnt2d);
       }
       else
-	aProj.Project(aPnt,aPnt2d);
+      {
+        aProj->Project(aPnt,aPnt2d);
+      }
       mybox2d.Update(aPnt2d);
       ((Select3D_Pnt2d*)mypolyg2d)[i] = aPnt2d;
     }

src/Select3D/Select3D_SensitiveSegment.cxx

@@ -45,7 +45,7 @@ mymaxrect(MaxRect)
 // Purpose  :
 //=====================================================
 void Select3D_SensitiveSegment
-::Project(const Select3D_Projector& aProj)
+::Project(const Handle(Select3D_Projector)& aProj)
 {
   Select3D_SensitiveEntity::Project(aProj); // to set the field last proj...
   gp_Pnt2d aPoint2dStart;
@@ -54,12 +54,12 @@ void Select3D_SensitiveSegment
   if(HasLocation()){
     gp_Pnt aStart(mystart.x, mystart.y, mystart.z);
     gp_Pnt aEnd(myend.x, myend.y, myend.z);
-    aProj.Project(aStart.Transformed(Location().Transformation()),aPoint2dStart);
+    aProj->Project(aStart.Transformed(Location().Transformation()),aPoint2dStart);
-    aProj.Project(aEnd.Transformed(Location().Transformation()),aPoint2dEnd);
+    aProj->Project(aEnd.Transformed(Location().Transformation()),aPoint2dEnd);
   }
   else{
-    aProj.Project(mystart,aPoint2dStart);
+    aProj->Project(mystart,aPoint2dStart);
-    aProj.Project(myend,aPoint2dEnd);
+    aProj->Project(myend,aPoint2dEnd);
   }
   myprojstart = aPoint2dStart;
   myprojend = aPoint2dEnd;
@@ -124,8 +124,7 @@ Standard_Boolean Select3D_SensitiveSegment
   gp_Pnt2d aPEnd(myprojend.x,myprojend.y);
   if ( ! SelectBasics_BasicTool::MatchSegment (aPStart, aPEnd, X, Y, aTol, DMin) )
     return Standard_False;
-  Select3D_SensitiveEntity::Matches (X, Y, aTol, DMin); // to compute depth
+  return Select3D_SensitiveEntity::Matches (X, Y, aTol, DMin); // compute and validate depth
-  return Standard_True;
 }
 
 Standard_Boolean Select3D_SensitiveSegment::

src/Select3D/Select3D_SensitiveTriangulation.cxx

@@ -11,6 +11,7 @@
 
 #include <Select3D_SensitiveTriangulation.ixx>
 #include <gp_Pnt2d.hxx>
+#include <Poly.hxx>
 #include <Poly_Connect.hxx>
 #include <CSLib_Class2d.hxx>
 #include <TColStd_Array1OfInteger.hxx>
@@ -185,7 +186,7 @@ myDetectedTr(-1)
 //purpose  :
 //=======================================================================
 
-void Select3D_SensitiveTriangulation::Project(const Select3D_Projector& aPrj) 
+void Select3D_SensitiveTriangulation::Project(const Handle(Select3D_Projector)& aPrj)
 {
   Select3D_SensitiveEntity::Project(aPrj); // to set the field last proj...
 
@@ -196,15 +197,15 @@ void Select3D_SensitiveTriangulation::Project(const Select3D_Projector& aPrj)
 
   for(Standard_Integer I=1;I<=myTriangul->NbNodes();I++){
     if(myTrsf.Form()!=gp_Identity)
-      aPrj.Project(Nodes(I).Transformed(myTrsf),ProjPT);
+      aPrj->Project(Nodes(I).Transformed(myTrsf),ProjPT);
     else
-      aPrj.Project(Nodes(I),ProjPT);
+      aPrj->Project(Nodes(I),ProjPT);
 
     myNodes2d.SetValue(I,ProjPT);
     mybox2d.Add(ProjPT);
   }
 
-  aPrj.Project(myCDG3D,myCDG2D);
+  aPrj->Project(myCDG3D,myCDG2D);
 }
 
 //=======================================================================
@@ -217,59 +218,6 @@ void Select3D_SensitiveTriangulation::Areas(SelectBasics_ListOfBox2d& boxes)
   boxes.Append(mybox2d);
 }
 
-//=======================================================================
-//function : getUV
-//purpose  : compute parameters of the picked point on triangle in 2d
-//     Note: parameters of point P on triangle (P1, P2, P3) are defined 
-//           as U and V such that P = P1 + U * (P2 - P1) + V * (P3 - P1);
-//    Range: U >= 0, V >= 0, U + V <= 1
-//=======================================================================
-
-static gp_XY getUV (const gp_XY& aP2d1, const gp_XY& aP2d2, const gp_XY& aP2d3,
-                    const gp_XY& aPick)
-{
-  gp_XY aDU = aP2d2 - aP2d1;
-  gp_XY aDV = aP2d3 - aP2d1;
-  Standard_Real aDet = aDU ^ aDV;
-
-  // case of non-degenerated triangle
-  gp_XY aDP = aPick - aP2d1;
-  if ( Abs (aDet) > gp::Resolution() )
-  {
-    Standard_Real aU =  (aDP ^ aDV) / aDet;
-    Standard_Real aV = -(aDP ^ aDU) / aDet;
-    if ( aU < 0. ) aU = 0.;
-    if ( aV < 0. ) aV = 0.;
-    if ( aU + aV > 1. ) { Standard_Real aD = aU + aV; aU /= aD; aV /= aD; }
-    return gp_XY (aU, aV);
-  }
-
-  // degenerated case (in 2d projection)
-  Standard_Real aL2U = aDU.SquareModulus();
-  Standard_Real aL2V = aDV.SquareModulus();
-  if ( aL2U < gp::Resolution() ) // side 1-2 is degenerated 
-  {
-    if ( aL2V < gp::Resolution() ) // whole triangle is degenerated to point
-      return gp_XY (0., 0.);
-    else
-      return gp_XY (0., (aDP * aDV) / aL2V);
-  }
-  else if ( aL2V < gp::Resolution() ) // side 1-3 is degenerated
-    return gp_XY ((aDP * aDU) / aL2U, 0.);
-  else // sides 1-2 and 1-3 are collinear
-  {
-    // select parameter on one of sides so as to have points closer to picked
-    Standard_Real aU = Min (1., Max (0., (aDP * aDU) / aL2U));
-    Standard_Real aV = Min (1., Max (0., (aDP * aDV) / aL2V));
-    gp_XY aP2dU = aP2d1 + aU * aDU;
-    gp_XY aP2dV = aP2d1 + aV * aDV;
-    if ( (aPick - aP2dU).SquareModulus() < (aPick - aP2dV).SquareModulus() )
-      return gp_XY ((aDP * aDU) / aL2U, 0.);
-    else
-      return gp_XY (0., (aDP * aDV) / aL2V);
-  }
-}
-
 //=======================================================================
 //function : Matches
 //purpose  :
@@ -280,7 +228,7 @@ Standard_Boolean Select3D_SensitiveTriangulation::Matches(const Standard_Real X,
 							  Standard_Real& DMin)
 {
   // get view direction (necessary for calculation of depth) from field mylastprj of the base class
-  if ( ! mylastprj )
+  if (mylastprj.IsNull())
     return Standard_False;
 
   DMin = Precision::Infinite();
@@ -291,7 +239,7 @@ Standard_Boolean Select3D_SensitiveTriangulation::Matches(const Standard_Real X,
   // on regarde si on est a l'interieur d'1 triangle 2d.
   if(myIntFlag)
   {
-    gp_Lin EyeLine = (*((Select3D_Projector*)mylastprj)).Shoot(X,Y);
+    gp_Lin EyeLine = mylastprj->Shoot(X,Y);
     if ( myTrsf.Form()!=gp_Identity )
       EyeLine.Transform (myTrsf.Inverted());
 
@@ -304,24 +252,26 @@ Standard_Boolean Select3D_SensitiveTriangulation::Matches(const Standard_Real X,
       const gp_XY& aPnt2d1 = myNodes2d(n1).XY();
       const gp_XY& aPnt2d2 = myNodes2d(n2).XY();
       const gp_XY& aPnt2d3 = myNodes2d(n3).XY();
-      Standard_Real DD = 0.;
+      gp_XY aUV;
-      if (Status (BidPoint, aPnt2d1, aPnt2d2, aPnt2d3, aTol, DD) == 2)
+      Standard_Real aDistSquare = Poly::PointOnTriangle (aPnt2d1, aPnt2d2, aPnt2d3, BidPoint, aUV);
+      if ( aDistSquare > aTol * aTol )
         continue;
 
       // compute depth on this triangle
-      gp_XY aUV = getUV (aPnt2d1, aPnt2d2, aPnt2d3, BidPoint);
       Standard_Real aDepth1 = ElCLib::Parameter (EyeLine, Nodes(n1));
       Standard_Real aDepth2 = ElCLib::Parameter (EyeLine, Nodes(n2));
       Standard_Real aDepth3 = ElCLib::Parameter (EyeLine, Nodes(n3));
       Standard_Real aDepth = aDepth1 + aUV.X() * (aDepth2 - aDepth1) +
                                        aUV.Y() * (aDepth3 - aDepth1);
 
-      // take triangle with lowest depth
+      // take triangle with lowest depth and within defined depth interval
-      if ( aDepth < aMinDepth )
+      if (aDepth < aMinDepth &&
+          aDepth > mylastprj->DepthMin() &&
+          aDepth < mylastprj->DepthMax())
       {
         aMinDepth = aDepth;
         myDetectedTr = itr;
-        DMin = DD;
+        DMin = Sqrt (aDistSquare);
       }
     }
   }
@@ -359,8 +309,9 @@ Standard_Boolean Select3D_SensitiveTriangulation::Matches(const Standard_Real X,
   }
   if ( myDetectedTr <= 0 )
     return Standard_False;
-  Select3D_SensitiveEntity::Matches(X,Y,aTol,DMin);
+
-  return Standard_True;
+  // compute and validate the depth (::Depth()) along the eyeline
+  return Select3D_SensitiveEntity::Matches(X,Y,aTol,DMin);
 }
 
 

src/Select3D/Select3D_SensitiveWire.cxx

@@ -94,7 +94,7 @@ void Select3D_SensitiveWire::ResetLocation()
 // Purpose  :
 //=====================================================
 void Select3D_SensitiveWire
-::Project(const Select3D_Projector& aProj)
+::Project(const Handle(Select3D_Projector)& aProj)
 {
   for ( Standard_Integer i=1; i<=mysensitive.Length(); i++)
     mysensitive(i)->Project(aProj);
@@ -144,9 +144,11 @@ Standard_Boolean Select3D_SensitiveWire
       }
     }
   }
-//  Select3D_SensitiveEntity::Matches(X,Y,aTol,DMin);
+  if ( ! IsTouched )
+    return Standard_False;
 
-  return IsTouched;
+  // compute and validate the depth (::Depth()) along the eyeline
+  return Select3D_SensitiveEntity::Matches(X,Y,aTol,DMin);
 }
 
 //=====================================================
@@ -253,7 +255,7 @@ Standard_Real Select3D_SensitiveWire::ComputeDepth(const gp_Lin& EyeLine) const
 //function : SetLastPrj
 //purpose  :
 //=======================================================================
-void Select3D_SensitiveWire::SetLastPrj(const Select3D_Projector& Prj)
+void Select3D_SensitiveWire::SetLastPrj(const Handle(Select3D_Projector)& Prj)
 {
   Select3D_SensitiveEntity::SetLastPrj(Prj);
   for(Standard_Integer i=1;i<=mysensitive.Length();i++)

src/StdSelect/StdSelect.cxx

@@ -4,8 +4,6 @@
 // Author:	Robert COUBLANC
 //		<rob>
 
-
-
 #include <StdSelect.ixx>
 #include <SelectMgr_Selection.hxx>
 #include <Graphic3d_StructureManager.hxx>
@@ -24,12 +22,8 @@
 #include <gp_Ax3.hxx>
 #include <V3d_PerspectiveView.hxx>
 #include <StdSelect_BRepOwner.hxx>
-//#include <.hxx>
 
-
+Handle(Select3D_Projector) StdSelect::GetProjector(const Handle(V3d_View)& aViou)
-
-
-Select3D_Projector  StdSelect::GetProjector(const Handle(V3d_View)& aViou)
 {
   Standard_Real Focale=0.,Xat,Yat,Zat,XUp,YUp,ZUp,DX,DY,DZ;
   Standard_Boolean Pers=Standard_False;
@@ -48,7 +42,7 @@ Select3D_Projector  StdSelect::GetProjector(const Handle(V3d_View)& aViou)
   gp_Ax3 Axe (At, Zpers, Xpers);
   gp_Trsf T;
   T.SetTransformation(Axe);
-  return Select3D_Projector(T,Pers,Focale);
+  return new Select3D_Projector(T,Pers,Focale);
   
 }
 

src/StdSelect/StdSelect_ViewerSelector3d.cxx

@@ -15,6 +15,7 @@
 #include <gp_Ax3.hxx>
 #include <gp_GTrsf.hxx>
 #include <V3d_PerspectiveView.hxx>
+#include <V3d_Plane.hxx>
 #include <Select3D_SensitiveEntity.hxx>
 #include <Graphic3d_Array1OfVertex.hxx>
 #include <SelectMgr_DataMapIteratorOfDataMapOfIntegerSensitive.hxx>
@@ -83,6 +84,7 @@ static Standard_Boolean StdSelectDebugModeOn()
 
 StdSelect_ViewerSelector3d
 ::StdSelect_ViewerSelector3d():
+myprj(new Select3D_Projector()),
 mylastzoom(0.0),
 mypixtol(2),
 myupdatetol(Standard_True)
@@ -98,7 +100,7 @@ myupdatetol(Standard_True)
 //==================================================
 
 StdSelect_ViewerSelector3d
-::StdSelect_ViewerSelector3d(const Select3D_Projector& aProj):
+::StdSelect_ViewerSelector3d(const Handle(Select3D_Projector)& aProj):
 myprj(aProj),
 mylastzoom(0.0),
 mypixtol(2),
@@ -147,7 +149,7 @@ void StdSelect_ViewerSelector3d
 //==================================================
 
 void StdSelect_ViewerSelector3d
-::Set(const Select3D_Projector& aProj)
+::Set(const Handle(Select3D_Projector)& aProj)
 {
   myprj = aProj;
   toupdate=Standard_True;
@@ -167,7 +169,53 @@ void StdSelect_ViewerSelector3d
   Standard_Real Xr3d,Yr3d,Zr3d;
   gp_Pnt2d P2d;
   aView->Convert(XPix,YPix,Xr3d,Yr3d,Zr3d);
-  myprj.Project(gp_Pnt(Xr3d,Yr3d,Zr3d),P2d);
+  myprj->Project(gp_Pnt(Xr3d,Yr3d,Zr3d),P2d);
+
+  // compute depth limits if clipping plane(s) enabled
+  gp_Lin anEyeLine = myprj->Shoot (P2d.X(), P2d.Y());
+  Standard_Real aPlaneA, aPlaneB, aPlaneC, aPlaneD;
+  Standard_Real aDepthFrom = ShortRealFirst();
+  Standard_Real aDepthTo   = ShortRealLast();
+  for (aView->InitActivePlanes(); aView->MoreActivePlanes(); aView->NextActivePlanes())
+  {
+    aView->ActivePlane()->Plane (aPlaneA, aPlaneB, aPlaneC, aPlaneD);
+    const gp_Dir& anEyeLineDir  = anEyeLine.Direction();
+    gp_Dir aPlaneNormal (aPlaneA, aPlaneB, aPlaneC);
+
+    Standard_Real aDotProduct = anEyeLineDir.Dot (aPlaneNormal);
+    Standard_Real aDirection = -(aPlaneD + anEyeLine.Location().XYZ().Dot (aPlaneNormal.XYZ()));
+    if (Abs (aDotProduct) < Precision::Angular())
+    {
+      // eyeline parallel to the clipping plane
+      if (aDirection > 0.0)
+      {
+        // invalidate the interval
+        aDepthTo   = ShortRealFirst();
+        aDepthFrom = ShortRealFirst();
+        break;
+      }
+      // just ignore this plane
+      continue;
+    }
+
+    // compute distance along the eyeline from eyeline location to intersection with clipping plane
+    Standard_Real aDepth = aDirection / aDotProduct;
+
+    // reduce depth limits
+    if (aDotProduct < 0.0)
+    {
+      if (aDepth < aDepthTo)
+      {
+        aDepthTo = aDepth;
+      }
+    }
+    else if (aDepth > aDepthFrom)
+    {
+      aDepthFrom = aDepth;
+    }
+  }
+  myprj->DepthMinMax (aDepthFrom, aDepthTo);
+
   InitSelect(P2d.X(),P2d.Y());
 }
 
@@ -195,8 +243,8 @@ void StdSelect_ViewerSelector3d
   gp_Pnt2d P2d_1,P2d_2;
   aView->Convert(XPMin,YPMin,x1,y1,z1);
   aView->Convert(XPMax,YPMax,x2,y2,z2);
-  myprj.Project(gp_Pnt(x1,y1,z1),P2d_1);
+  myprj->Project(gp_Pnt(x1,y1,z1),P2d_1);
-  myprj.Project(gp_Pnt(x2,y2,z2),P2d_2);
+  myprj->Project(gp_Pnt(x2,y2,z2),P2d_2);
 
   InitSelect (Min(P2d_1.X(),P2d_2.X()),
               Min(P2d_1.Y(),P2d_2.Y()),
@@ -236,7 +284,7 @@ void StdSelect_ViewerSelector3d
     gp_Pnt2d Pnt2d;
 
     aView->Convert (XP, YP, x, y, z);
-    myprj.Project (gp_Pnt (x, y, z), Pnt2d);
+    myprj->Project (gp_Pnt (x, y, z), Pnt2d);
 
     P2d->SetValue (i, Pnt2d);
   }
@@ -272,8 +320,8 @@ DisplayAreas(const Handle(V3d_View)& aView)
   }
 
   SelectMgr_DataMapIteratorOfDataMapOfIntegerSensitive It(myentities);
-  Select3D_Projector prj = StdSelect::GetProjector(aView);
+  Handle(Select3D_Projector) prj = StdSelect::GetProjector(aView);
-  prj.SetView(aView);
+  prj->SetView(aView);
 
 
   Graphic3d_Array1OfVertex Av1 (1,5);
@@ -291,23 +339,23 @@ DisplayAreas(const Handle(V3d_View)& aView)
       itb.Value().Get (xmin, ymin, xmax, ymax);
 
       Pbid.SetCoord (xmin - mytolerance, ymin - mytolerance, 0.0);
-      prj.Transform (Pbid, prj.InvertedTransformation());
+      prj->Transform (Pbid, prj->InvertedTransformation());
       Av1.SetValue (1, Graphic3d_Vertex (Pbid.X(), Pbid.Y(), Pbid.Z()));
 
       Pbid.SetCoord (xmax + mytolerance, ymin - mytolerance, 0.0);
-      prj.Transform (Pbid, prj.InvertedTransformation());
+      prj->Transform (Pbid, prj->InvertedTransformation());
       Av1.SetValue (2, Graphic3d_Vertex (Pbid.X(), Pbid.Y(), Pbid.Z()));
 
       Pbid.SetCoord (xmax + mytolerance, ymax + mytolerance, 0.0);
-      prj.Transform (Pbid, prj.InvertedTransformation());
+      prj->Transform (Pbid, prj->InvertedTransformation());
       Av1.SetValue (3, Graphic3d_Vertex (Pbid.X(), Pbid.Y(), Pbid.Z()));
 
       Pbid.SetCoord (xmin - mytolerance, ymax + mytolerance, 0.0);
-      prj.Transform (Pbid, prj.InvertedTransformation());
+      prj->Transform (Pbid, prj->InvertedTransformation());
       Av1.SetValue (4,Graphic3d_Vertex (Pbid.X(), Pbid.Y(), Pbid.Z()));
 
       Pbid.SetCoord (xmin - mytolerance, ymin - mytolerance, 0.0);
-      prj.Transform (Pbid, prj.InvertedTransformation());
+      prj->Transform (Pbid, prj->InvertedTransformation());
       Av1.SetValue (5, Graphic3d_Vertex (Pbid.X(), Pbid.Y(), Pbid.Z()));
 
       myareagroup->Polyline (Av1);
@@ -421,14 +469,14 @@ UpdateProj(const Handle(V3d_View)& aView)
     GT.SetTranslationPart (loc);
     GT.SetVectorialPart (matrix);
 
-    myprj = Select3D_Projector (GT, Pers, mycoeff[9]);
+    myprj = new Select3D_Projector (GT, Pers, mycoeff[9]);
 
     // SAV 08/05/02 : fix for detection problem in a perspective view
     if (aView->Type() == V3d_PERSPECTIVE)
-      myprj.SetView (aView);
+      myprj->SetView (aView);
     // NKV 31/07/07 : fix for detection problem in case of custom matrix
     else if (aView->ViewOrientation().IsCustomMatrix())
-      myprj.SetView (aView);
+      myprj->SetView (aView);
   }
 
   if (Abs (aView->Scale() - mylastzoom) > 1.e-3)
@@ -1008,23 +1056,23 @@ ComputeAreasPrs (const Handle(SelectMgr_Selection)& Sel)
       itb.Value().Get (xmin, ymin, xmax, ymax);
 
       Pbid.SetCoord (xmin - mytolerance, ymin - mytolerance, 0.0);
-      myprj.Transform (Pbid, myprj.InvertedTransformation());
+      myprj->Transform (Pbid, myprj->InvertedTransformation());
       Av1.SetValue (1, Graphic3d_Vertex (Pbid.X(), Pbid.Y(), Pbid.Z()));
 
       Pbid.SetCoord (xmax + mytolerance, ymin - mytolerance, 0.0);
-      myprj.Transform (Pbid, myprj.InvertedTransformation());
+      myprj->Transform (Pbid, myprj->InvertedTransformation());
       Av1.SetValue (2, Graphic3d_Vertex (Pbid.X(), Pbid.Y(), Pbid.Z()));
 
       Pbid.SetCoord (xmax + mytolerance, ymax + mytolerance, 0.0);
-      myprj.Transform (Pbid, myprj.InvertedTransformation());
+      myprj->Transform (Pbid, myprj->InvertedTransformation());
       Av1.SetValue (3, Graphic3d_Vertex (Pbid.X(), Pbid.Y(), Pbid.Z()));
 
       Pbid.SetCoord (xmin - mytolerance, ymax + mytolerance, 0.0);
-      myprj.Transform (Pbid, myprj.InvertedTransformation());
+      myprj->Transform (Pbid, myprj->InvertedTransformation());
       Av1.SetValue (4, Graphic3d_Vertex (Pbid.X(), Pbid.Y(), Pbid.Z()));
 
       Pbid.SetCoord (xmin - mytolerance, ymin - mytolerance, 0.0);
-      myprj.Transform (Pbid, myprj.InvertedTransformation());
+      myprj->Transform (Pbid, myprj->InvertedTransformation());
       Av1.SetValue (5, Graphic3d_Vertex (Pbid.X(), Pbid.Y(), Pbid.Z()));
 
       myareagroup->Polyline (Av1);

src/StdSelect/StdSelect_ViewerSelector3d.lxx

@@ -1,2 +1,4 @@
-inline const Select3D_Projector& StdSelect_ViewerSelector3d::
+inline const Handle(Select3D_Projector)& StdSelect_ViewerSelector3d::Projector() const
-Projector() const {return myprj;}
+{
+  return myprj;
+}

src/V3d/V3d_Plane.cdl

@@ -20,7 +20,6 @@ inherits
 
 uses
 
-	Viewer from V3d,
 	View from V3d,
 	ClipPlane from Visual3d,
 	Structure from Graphic3d,
@@ -38,7 +37,7 @@ is
         -- The methods :
         --
 
-	Create ( VM : Viewer ; A: Parameter = 0.0; 
+	Create (A: Parameter = 0.0;
 	        B: Parameter = 0.0;
 	        C: Parameter = 1.0;
 	        D: Parameter = 0.0

src/V3d/V3d_Plane.cxx

@@ -14,19 +14,22 @@
 
 //-Language     C++ 2.1
 
-// for the class
 #include <V3d.hxx>
 #include <V3d_Plane.ixx>
 #include <Viewer_BadValue.hxx>
 
+#include <Graphic3d_Group.hxx>
+#include <Graphic3d_Array1OfVertex.hxx>
+#include <Graphic3d_AspectFillArea3d.hxx>
+#include <gp_Pln.hxx>
+
 //-Constructors
 
-V3d_Plane::V3d_Plane(const Handle(V3d_Viewer)& VM, const Standard_Real A, const Standard_Real B, const Standard_Real C, const Standard_Real D) {
+V3d_Plane::V3d_Plane(const Standard_Real A, const Standard_Real B, const Standard_Real C, const Standard_Real D) {
 
   Viewer_BadValue_Raise_if( sqrt(A*A + B*B + C*C) <= 0., "V3d_Plane::V3d_Plane, bad plane coefficients");
 
   MyPlane = new Visual3d_ClipPlane(A,B,C,D) ;
-  VM->AddPlane(this) ;
 }
 
 //-Methods, in order
@@ -42,9 +45,6 @@ void V3d_Plane::SetPlane( const Standard_Real A, const Standard_Real B, const St
   }
 }
 
-#include <Graphic3d_Group.hxx>
-#include <Graphic3d_Array1OfVertex.hxx> 
-#include <Graphic3d_AspectFillArea3d.hxx>
 void V3d_Plane::Display(const Handle(V3d_View)& aView,
 			const Quantity_Color& aColor) {
     Handle(V3d_Viewer) theViewer = aView->Viewer();
@@ -96,7 +96,6 @@ Standard_Boolean V3d_Plane::IsDisplayed() const {
   return MyGraphicStructure->IsDisplayed();
 }
 
-#include <gp_Pln.hxx>
 void V3d_Plane::Update() {
 
   if( !MyGraphicStructure.IsNull() ) {

src/V3d/V3d_Viewer.cdl

@@ -32,7 +32,6 @@ inherits
 
 uses
 
---        GraphicDevice from Graphic3d,
         GraphicDevice from Aspect,
         TypeOfUpdate from V3d,
         TypeOfVisualization from V3d,
@@ -69,14 +68,12 @@ uses
         GridDrawMode from Aspect,
         GradientFillMethod from Aspect
 
-	
 raises
 
         BadValue from Viewer
 
 is
 
---    	Create ( Device	        : GraphicDevice from Graphic3d;
         Create ( Device     : GraphicDevice from Aspect;
              aName          : ExtString from Standard;
              aDomain        : CString from Standard = "";
@@ -425,6 +422,12 @@ is
         DefinedLight(me) returns Light from V3d;
         ---Level:   Advanced
 
+        AddPlane( me: mutable; MyPlane : Plane from V3d);
+        ---Purpose: Adds Plane in Sequence Of Planes.
+
+        DelPlane( me: mutable; MyPlane : Plane from V3d);
+        ---Purpose: Delete Plane in Sequence Of Planes.
+
         InitDefinedPlanes(me: mutable);
         ---Level:   Advanced
         ---Purpose: initializes an iteration on the Defined Planes.
@@ -635,12 +638,6 @@ is
         AddLight( me: mutable; MyLight : Light from V3d) is private;
         ---Purpose: Adds Light in Sequence Of Lights.
 
-	AddPlane( me: mutable; MyPlane : Plane from V3d) is private ;
-	---Purpose: Adds Plane in Sequence Of Planes.
-
-	DelPlane( me: mutable; MyPlane : Plane from V3d) is private;
-	---Purpose: Delete Plane in Sequence Of Planes.
-
         SetDefaultLights(me: mutable);
         ---Purpose: defines default lights  -
         --          positional-light 0.3 0. 0.
@@ -659,7 +656,6 @@ is
         ---Purpose:
         -- Display grid echo at requested point in the view.
 
-	
 fields
 
         MyViewer:               ViewManager from Visual3d ;

src/ViewerTest/ViewerTest.cxx

@@ -305,12 +305,12 @@ void ViewerTest::SetAISContext (const Handle(AIS_InteractiveContext)& aCtx)
 
 Handle(V3d_Viewer) ViewerTest::GetViewerFromContext()
 {
-  return TheAISContext()->CurrentViewer();
+  return !TheAISContext().IsNull() ? TheAISContext()->CurrentViewer() : Handle(V3d_Viewer)();
 }
 
 Handle(V3d_Viewer) ViewerTest::GetCollectorFromContext()
 {
-  return TheAISContext()->CurrentViewer();
+  return !TheAISContext().IsNull() ? TheAISContext()->CurrentViewer() : Handle(V3d_Viewer)();
 }
 
 
@@ -2066,7 +2066,7 @@ static int VPerf(Draw_Interpretor& di, Standard_Integer , const char** argv) {
 // Function : VAnimation
 //==================================================================================
 static int VAnimation (Draw_Interpretor& di, Standard_Integer argc, const char** argv) {
-  if (argc != 5) {
+  if (argc =! 5) {
     di<<"Use: "<<argv[0]<<" CrankArmFile CylinderHeadFile PropellerFile EngineBlockFile"<<"\n";
     return 1;
   }

src/ViewerTest/ViewerTest_ObjectCommands.cxx

@@ -26,8 +26,10 @@
 
 #include <OSD_Chronometer.hxx>
 #include <TCollection_AsciiString.hxx>
+#include <Visual3d_View.hxx>
 #include <V3d_Viewer.hxx>
 #include <V3d_View.hxx>
+#include <V3d_Plane.hxx>
 #include <V3d.hxx>
 
 #include <AIS_Shape.hxx>
@@ -2556,6 +2558,180 @@ static int VDrawSphere (Draw_Interpretor& di, Standard_Integer argc, const char*
   return 0;
 }
 
+//===============================================================================================
+//function : VClipPlane
+//purpose  :
+//===============================================================================================
+static int VClipPlane (Draw_Interpretor& di, Standard_Integer argc, const char** argv)
+{
+  Handle(V3d_Viewer) aViewer = ViewerTest::GetViewerFromContext();
+  Handle(V3d_View) aView = ViewerTest::CurrentView();
+  Standard_Real coeffA, coeffB, coeffC, coeffD;
+  if (aViewer.IsNull() || aView.IsNull())
+  {
+    std::cout << "Viewer not initialized!\n";
+    return 1;
+  }
+
+  // count an active planes count
+  Standard_Integer aNewPlaneId = 1;
+  Standard_Integer anActivePlanes = 0;
+  for (aViewer->InitDefinedPlanes(); aViewer->MoreDefinedPlanes(); aViewer->NextDefinedPlanes(), ++aNewPlaneId)
+  {
+    Handle(V3d_Plane) aPlaneV3d = aViewer->DefinedPlane();
+    if (aView->IsActivePlane (aPlaneV3d))
+    {
+      ++anActivePlanes;
+    }
+  }
+
+  if (argc == 1)
+  {
+    // just show info about existing planes
+    Standard_Integer aPlaneId = 1;
+    std::cout << "Active planes: " << anActivePlanes << " from maximal " << aView->View()->PlaneLimit() << "\n";
+    for (aViewer->InitDefinedPlanes(); aViewer->MoreDefinedPlanes(); aViewer->NextDefinedPlanes(), ++aPlaneId)
+    {
+      Handle(V3d_Plane) aPlaneV3d = aViewer->DefinedPlane();
+      aPlaneV3d->Plane (coeffA, coeffB, coeffC, coeffD);
+      gp_Pln aPlane (coeffA, coeffB, coeffC, coeffD);
+      const gp_Pnt& aLoc = aPlane.Location();
+      const gp_Dir& aNor = aPlane.Axis().Direction();
+      Standard_Boolean isActive = aView->IsActivePlane (aPlaneV3d);
+      std::cout << "Plane #" << aPlaneId
+        << " " << aLoc.X() << " " << aLoc.Y() << " " << aLoc.Z()
+        << " " << aNor.X() << " " << aNor.Y() << " " << aNor.Z()
+        << (isActive ? " on" : " off")
+        << (aPlaneV3d->IsDisplayed() ? ", displayed" : ", hidden")
+        << "\n";
+    }
+    if (aPlaneId == 1)
+    {
+      std::cout << "No defined clipping planes\n";
+    }
+    return 0;
+  }
+  else if (argc == 2 || argc == 3)
+  {
+    Standard_Integer aPlaneIdToOff = (argc == 3) ? atoi (argv[1]) : 1;
+    Standard_Boolean toIterateAll = (argc == 2);
+    TCollection_AsciiString isOnOffStr ((argc == 3) ? argv[2] : argv[1]);
+    isOnOffStr.LowerCase();
+    Standard_Integer aPlaneId = 1;
+    for (aViewer->InitDefinedPlanes(); aViewer->MoreDefinedPlanes(); aViewer->NextDefinedPlanes(), ++aPlaneId)
+    {
+      if (aPlaneIdToOff == aPlaneId || toIterateAll)
+      {
+        Handle(V3d_Plane) aPlaneV3d = aViewer->DefinedPlane();
+        if (isOnOffStr.Search ("off") >= 0)
+        {
+          aView->SetPlaneOff (aPlaneV3d);
+          std::cout << "Clipping plane #" << aPlaneId << " was disabled\n";
+        }
+        else if (isOnOffStr.Search ("on") >= 0)
+        {
+          // avoid z-fighting glitches
+          aPlaneV3d->Erase();
+          if (!aView->IsActivePlane (aPlaneV3d))
+          {
+            if (anActivePlanes < aView->View()->PlaneLimit())
+            {
+              aView->SetPlaneOn (aPlaneV3d);
+              std::cout << "Clipping plane #" << aPlaneId << " was enabled\n";
+            }
+            else
+            {
+              std::cout << "Maximal active planes limit exceeded (" << anActivePlanes << ")\n"
+                        << "You should disable or remove some existing plane to activate this one\n";
+            }
+          }
+          else
+          {
+            std::cout << "Clipping plane #" << aPlaneId << " was already enabled\n";
+          }
+        }
+        else if (isOnOffStr.Search ("del") >= 0 || isOnOffStr.Search ("rem") >= 0)
+        {
+          aPlaneV3d->Erase(); // not performed on destructor!!!
+          aView->SetPlaneOff (aPlaneV3d);
+          aViewer->DelPlane (aPlaneV3d);
+          std::cout << "Clipping plane #" << aPlaneId << " was removed\n";
+          if (toIterateAll)
+          {
+            for (aViewer->InitDefinedPlanes(); aViewer->MoreDefinedPlanes(); aViewer->InitDefinedPlanes(), ++aPlaneId)
+            {
+              aPlaneV3d = aViewer->DefinedPlane();
+              aPlaneV3d->Erase(); // not performed on destructor!!!
+              aView->SetPlaneOff (aPlaneV3d);
+              aViewer->DelPlane (aPlaneV3d);
+              std::cout << "Clipping plane #" << aPlaneId << " was removed\n";
+            }
+            break;
+          }
+          else
+          {
+            break;
+          }
+        }
+        else if (isOnOffStr.Search ("disp") >= 0 || isOnOffStr.Search ("show") >= 0)
+        {
+          // avoid z-fighting glitches
+          aView->SetPlaneOff (aPlaneV3d);
+          aPlaneV3d->Display (aView);
+          std::cout << "Clipping plane #" << aPlaneId << " was shown and disabled\n";
+        }
+        else if (isOnOffStr.Search ("hide") >= 0)
+        {
+          aPlaneV3d->Erase();
+          std::cout << "Clipping plane #" << aPlaneId << " was hidden\n";
+        }
+        else
+        {
+          std::cout << "Usage: " << argv[0] << " [x y z dx dy dz] [planeId {on/off/del/display/hide}]\n";
+          return 1;
+        }
+      }
+    }
+    if (aPlaneIdToOff >= aPlaneId && !toIterateAll)
+    {
+      std::cout << "Clipping plane with id " << aPlaneIdToOff << " not found!\n";
+      return 1;
+    }
+    aView->Update();
+    return 0;
+  }
+  else if (argc != 7)
+  {
+    std::cout << "Usage: " << argv[0] << " [x y z dx dy dz] [planeId {on/off/del/display/hide}]\n";
+    return 1;
+  }
+
+  Standard_Real aLocX = atof (argv[1]);
+  Standard_Real aLocY = atof (argv[2]);
+  Standard_Real aLocZ = atof (argv[3]);
+  Standard_Real aNormDX = atof (argv[4]);
+  Standard_Real aNormDY = atof (argv[5]);
+  Standard_Real aNormDZ = atof (argv[6]);
+
+  Handle(V3d_Plane) aPlaneV3d = new V3d_Plane();
+  gp_Pln aPlane (gp_Pnt (aLocX, aLocY, aLocZ), gp_Dir (aNormDX, aNormDY, aNormDZ));
+  aPlane.Coefficients (coeffA, coeffB, coeffC, coeffD);
+  aPlaneV3d->SetPlane(coeffA, coeffB, coeffC, coeffD);
+
+  aViewer->AddPlane (aPlaneV3d); // add to defined planes list
+  std::cout << "Added clipping plane #" << aNewPlaneId << "\n";
+  if (anActivePlanes < aView->View()->PlaneLimit())
+  {
+    aView->SetPlaneOn (aPlaneV3d); // add to enabled planes list
+    aView->Update();    
+  }
+  else
+  {
+    std::cout << "Maximal active planes limit exceeded (" << anActivePlanes << ")\n"
+              << "You should disable or remove some existing plane to activate the new one\n";
+  }
+  return 0;
+}
 
 //=======================================================================
 //function : ObjectsCommands
@@ -2625,4 +2801,8 @@ void ViewerTest::ObjectCommands(Draw_Interpretor& theCommands)
     "vdrawsphere: vdrawsphere shapeName Fineness [X=0.0 Y=0.0 Z=0.0] [Radius=100.0] [ToEnableVBO=1] [NumberOfViewerUpdate=1] [ToShowEdges=0]\n",
     __FILE__,VDrawSphere,group);
 
+  theCommands.Add("vclipplane",
+    "vclipplane : vclipplane [x y z dx dy dz] [planeId {on/off/del/display/hide}]",
+    __FILE__,VClipPlane,group);
+
 }