0022554: Application hangs on selection
authorAAA <>
Wed, 22 Feb 2012 13:01:33 +0000 (13:01 +0000)
committerbugmaster <bugmaster@opencascade.com>
Mon, 5 Mar 2012 15:33:08 +0000 (19:33 +0400)
15 files changed:
src/Select3D/FILES
src/Select3D/Select3D.cdl
src/Select3D/Select3D_PointData.hxx [new file with mode: 0644]
src/Select3D/Select3D_SensitiveCircle.cdl
src/Select3D/Select3D_SensitiveCircle.cxx
src/Select3D/Select3D_SensitiveCurve.cdl
src/Select3D/Select3D_SensitiveCurve.cxx
src/Select3D/Select3D_SensitiveFace.cdl
src/Select3D/Select3D_SensitiveFace.cxx
src/Select3D/Select3D_SensitivePoly.cdl
src/Select3D/Select3D_SensitivePoly.cxx
src/Select3D/Select3D_SensitivePoly.lxx
src/Select3D/Select3D_SensitiveTriangle.cdl
src/Select3D/Select3D_SensitiveTriangle.cxx
src/ViewerTest/ViewerTest_ObjectCommands.cxx

index 138063b..866330e 100755 (executable)
@@ -1,4 +1,5 @@
 Select3D_Pnt.hxx
 Select3D_Pnt2d.hxx
 Select3D_Box2d.hxx
-Select3D_Macro.hxx
\ No newline at end of file
+Select3D_Macro.hxx
+Select3D_PointData.hxx
\ No newline at end of file
index e2133ef..a0c9eb4 100755 (executable)
@@ -80,5 +80,6 @@ is
     imported Pnt;
     imported Pnt2d;
     imported Box2d;
+    imported PointData;
 
 end Select3D;
diff --git a/src/Select3D/Select3D_PointData.hxx b/src/Select3D/Select3D_PointData.hxx
new file mode 100644 (file)
index 0000000..aa92ad6
--- /dev/null
@@ -0,0 +1,105 @@
+#ifndef _Select3D_PointData_HeaderFile
+#define _Select3D_PointData_HeaderFile
+
+#include <Select3D_Pnt.hxx>
+#include <Select3D_Pnt2d.hxx>
+
+// A framework for safe management of Select3D_SensitivePoly polygons of 3D and 2D points
+class Select3D_PointData {
+
+public:
+
+  // Constructs internal arrays of 2D and 3D points defined
+  // by number of points theNbPoints
+  Select3D_PointData (const Standard_Integer theNbPoints)
+  {
+    if (theNbPoints <= 0)
+      Standard_ConstructionError::Raise("Select3D_PointData");
+
+    mynbpoints = theNbPoints;
+    mypolyg3d = new Select3D_Pnt[mynbpoints];
+    mypolyg2d = new Select3D_Pnt2d[mynbpoints];
+  }
+
+  // Destructor
+  ~Select3D_PointData ()
+  {
+    delete [] mypolyg3d;
+    delete [] mypolyg2d;
+  }
+
+  // Sets Select3D_Pnt to internal array
+  // of 3D points if theIndex is valid
+  void SetPnt (const Standard_Integer theIndex,
+               const Select3D_Pnt& theValue)
+  {
+    if (theIndex < 0 || theIndex >= mynbpoints)
+      Standard_OutOfRange::Raise("Select3D_PointData::SetPnt");
+    mypolyg3d[theIndex] = theValue;
+  }
+
+  // Sets gp_Pnt to internal array
+  // of 3D points if theIndex is valid
+  void SetPnt (const Standard_Integer theIndex,
+               const gp_Pnt& theValue)
+  {
+    if (theIndex < 0 || theIndex >= mynbpoints)
+      Standard_OutOfRange::Raise("Select3D_PointData::SetPnt");
+    mypolyg3d[theIndex] = theValue;
+  }
+
+  // Sets Select3D_Pnt2d to internal array
+  // of 2D points if theIndex is valid
+  void SetPnt2d (const Standard_Integer theIndex,
+                 const Select3D_Pnt2d& theValue)
+  {
+    if (theIndex < 0 || theIndex >= mynbpoints)
+      Standard_OutOfRange::Raise("Select3D_PointData::SetPnt2d");
+    mypolyg2d[theIndex] = theValue;
+  }
+
+  // Sets gp_Pnt2d to internal array
+  // of 2D points if theIndex is valid
+  void SetPnt2d (const Standard_Integer theIndex,
+                 const gp_Pnt2d& theValue)
+  {
+    if (theIndex < 0 || theIndex >= mynbpoints)
+      Standard_OutOfRange::Raise("Select3D_PointData::SetPnt2d");
+    mypolyg2d[theIndex] = theValue;
+  }
+
+  // Returns 3D point from internal array
+  // if theIndex is valid
+  Select3D_Pnt Pnt (const Standard_Integer theIndex) const
+  {
+    if (theIndex < 0 || theIndex >= mynbpoints)
+      Standard_OutOfRange::Raise("Select3D_PointData::Pnt");
+    return mypolyg3d[theIndex];
+  }
+
+  // Returns 2D point from internal array
+  // if theIndex is valid
+  Select3D_Pnt2d Pnt2d (const Standard_Integer theIndex) const
+  {
+    if (theIndex < 0 || theIndex >= mynbpoints)
+      Standard_OutOfRange::Raise("Select3D_PointData::Pnt2d");
+    return mypolyg2d[theIndex];
+  }
+
+  // Returns size of internal arrays
+  const Standard_Integer Size () const
+  {
+    return mynbpoints;
+  }
+
+private:
+
+  // Default constructor
+  Select3D_PointData () {};
+
+  Select3D_Pnt*    mypolyg3d;
+  Select3D_Pnt2d*  mypolyg2d;
+  Standard_Integer mynbpoints;
+};
+
+#endif
index 869c195..42e64dd 100755 (executable)
@@ -10,6 +10,8 @@ class SensitiveCircle from Select3D
 inherits SensitivePoly from Select3D
 
     ---Purpose: A framework to define sensitive 3D arcs and circles. 
+    -- In some cases this class can raise Standard_ConstructionError and 
+    -- Standard_OutOfRange exceptions. For more details see Select3D_SensitivePoly.
 uses
     Pnt             from gp,
     Pnt2d           from gp,
@@ -29,6 +31,10 @@ uses
     SensitiveEntity from Select3D, 
     Circle          from Geom
 
+raises
+    ConstructionError from Standard,
+    OutOfRange from Standard
+
 is
     Create (OwnerId      : EntityOwner from SelectBasics;
             TheCircle    : Circle from Geom;
@@ -114,7 +120,7 @@ is
 
     Project(me: mutable;aProjector: Projector from Select3D) is redefined virtual;
 
-    ComputeCenter3D(me: mutable); 
+    ComputeCenter3D(me: mutable) is private; 
         ---Level: Internal 
         ---Purpose: Computes myCenter3D as the barycenter of points from mypolyg3d
 
index 5688792..d978bfd 100755 (executable)
 
 static Standard_Integer S3D_GetCircleNBPoints(const Handle(Geom_Circle)& C,
                                               const Standard_Integer anInputNumber)
-{ 
-  if(C->Radius()>Precision::Confusion())
+{
+  // Check if number of points is invalid.
+  // In this case mypolyg raises Standard_ConstructionError
+  // exception (look constructor bellow).
+  if (anInputNumber <= 0)
+    return 0;
+
+  if (C->Radius()>Precision::Confusion())
     return 2*anInputNumber+1;
+  // The radius is too small and circle degenerates into point
   return 1;
 }
 
 static Standard_Integer S3D_GetArcNBPoints(const Handle(Geom_Circle)& C,
                     const Standard_Integer anInputNumber)
-{ 
-  if(C->Radius()>Precision::Confusion())
+{
+  // There is no need to check number of points here.
+  // In case of invalid number of points this method returns
+  // -1 or smaller value.
+  if (C->Radius()>Precision::Confusion())
     return 2*anInputNumber-1;
+
+  // The radius is too small and circle degenerates into point
   return 1;
 }
 
@@ -44,12 +56,12 @@ Select3D_SensitiveCircle(const Handle(SelectBasics_EntityOwner)& OwnerId,
                          const Standard_Integer NbPoints):
 Select3D_SensitivePoly(OwnerId, S3D_GetCircleNBPoints(TheCircle,NbPoints)),
 myFillStatus(FilledCircle),
-myDetectedIndex(-1), 
-myCircle(TheCircle), 
-mystart(0), 
+myDetectedIndex(-1),
+myCircle(TheCircle),
+mystart(0),
 myend(0)
 {
-  if(mynbpoints!=1)
+  if (mypolyg.Size() != 1)
   {
     gp_Pnt p1,p2;
     gp_Vec v1;
@@ -58,30 +70,32 @@ myend(0)
     Standard_Real R = TheCircle->Radius();
     Standard_Integer rank = 1;
     Standard_Real curu =ustart;
-    for(Standard_Integer i=1;i<=NbPoints;i++) 
+    for(Standard_Integer anIndex=1;anIndex<=NbPoints;anIndex++)
     {
       TheCircle->D1(curu,p1,v1);
     
       v1.Normalize();
-      ((Select3D_Pnt*)mypolyg3d)[rank-1] = p1;
+      mypolyg.SetPnt(rank-1, p1);
       rank++;
       p2 = gp_Pnt(p1.X()+v1.X()*tan(du/2.)*R,
             p1.Y()+v1.Y()*tan(du/2.)*R,
             p1.Z()+v1.Z()*tan(du/2.)*R);
-      ((Select3D_Pnt*)mypolyg3d)[rank-1] = p2;
+      mypolyg.SetPnt(rank-1, p2);
       rank++;
       curu+=du;
     }
-    ((Select3D_Pnt*)mypolyg3d)[NbPoints*2] = ((Select3D_Pnt*)mypolyg3d)[0]; 
-    // Get myCenter3D 
+
+    // Copy the first point to the last point of mypolyg
+    mypolyg.SetPnt(NbPoints*2, mypolyg.Pnt(0));
+    // Get myCenter3D
     myCenter3D = TheCircle->Location();
   }
   // Radius = 0.0
   else
   {
-    ((Select3D_Pnt*)mypolyg3d)[0] = TheCircle->Location();
+    mypolyg.SetPnt(0, TheCircle->Location());
     // Get myCenter3D
-    myCenter3D = ((Select3D_Pnt*)mypolyg3d)[0];
+    myCenter3D = mypolyg.Pnt(0);
   }
 }
 
@@ -99,50 +113,50 @@ Select3D_SensitiveCircle(const Handle(SelectBasics_EntityOwner)& OwnerId,
                          const Standard_Integer NbPoints):
 Select3D_SensitivePoly(OwnerId, S3D_GetArcNBPoints(TheCircle,NbPoints)),
 myFillStatus(FilledCircle),
-myDetectedIndex(-1), 
-myCircle(TheCircle), 
-mystart(u1), 
+myDetectedIndex(-1),
+myCircle(TheCircle),
+mystart(u1),
 myend(u2)
 {
-  if(mynbpoints > 1)
+  if (mypolyg.Size() != 1)
   {
     gp_Pnt p1,p2;
     gp_Vec v1;
     
-    if (u1 > u2) 
+    if (u1 > u2)
     {
-      mystart = u2; 
+      mystart = u2;
       myend = u1;
     }
     
     Standard_Real du = (myend-mystart)/(NbPoints-1);
     Standard_Real R = TheCircle->Radius();
     Standard_Integer rank = 1;
-    Standard_Real curu = mystart; 
+    Standard_Real curu = mystart;
     
-    for(Standard_Integer i=1;i<=NbPoints-1;i++)
+    for(Standard_Integer anIndex=1;anIndex<=NbPoints-1;anIndex++)
     {
       TheCircle->D1(curu,p1,v1);
       v1.Normalize();
-      ((Select3D_Pnt*)mypolyg3d)[rank-1] = p1;
+      mypolyg.SetPnt(rank-1, p1);
       rank++;
       p2 = gp_Pnt(p1.X()+v1.X()*tan(du/2.)*R,
             p1.Y()+v1.Y()*tan(du/2.)*R,
             p1.Z()+v1.Z()*tan(du/2.)*R);
-      ((Select3D_Pnt*)mypolyg3d)[rank-1] = p2;            
+      mypolyg.SetPnt(rank-1, p2);
       rank++;
       curu+=du;
     }
     TheCircle->D0(myend,p1);
-    ((Select3D_Pnt*)mypolyg3d)[NbPoints*2-2] = p1; 
+    mypolyg.SetPnt(NbPoints*2-2, p1);
     // Get myCenter3D 
     myCenter3D = TheCircle->Location();
   }
   else
   {
-    ((Select3D_Pnt*)mypolyg3d)[0] = TheCircle->Location();  
+    mypolyg.SetPnt(0, TheCircle->Location());
     // Get myCenter3D
-    myCenter3D = ((Select3D_Pnt*)mypolyg3d)[0];
+    myCenter3D = mypolyg.Pnt(0);
   }
 }
 
@@ -156,14 +170,14 @@ Select3D_SensitiveCircle::Select3D_SensitiveCircle(const Handle(SelectBasics_Ent
                                                    const Standard_Boolean FilledCircle):
 Select3D_SensitivePoly(OwnerId, Thepolyg3d),
 myFillStatus(FilledCircle),
-myDetectedIndex(-1), 
-mystart(0), 
+myDetectedIndex(-1),
+mystart(0),
 myend(0)
 {
-  if (mynbpoints > 1) 
+  if (mypolyg.Size() != 1)
     ComputeCenter3D();
-  else 
-    myCenter3D = ((Select3D_Pnt*)mypolyg3d)[0];
+  else
+    myCenter3D = mypolyg.Pnt(0);
 }
 
 //=======================================================================
@@ -176,14 +190,14 @@ Select3D_SensitiveCircle::Select3D_SensitiveCircle(const Handle(SelectBasics_Ent
                                                    const Standard_Boolean FilledCircle):
 Select3D_SensitivePoly(OwnerId, Thepolyg3d),
 myFillStatus(FilledCircle),
-myDetectedIndex(-1), 
-mystart(0), 
+myDetectedIndex(-1),
+mystart(0),
 myend(0)
-{ 
-  if (mynbpoints > 1) 
+{
+  if (mypolyg.Size() != 1)
     ComputeCenter3D();
-  else 
-    myCenter3D = ((Select3D_Pnt*)mypolyg3d)[0];
+  else
+    myCenter3D = mypolyg.Pnt(0);
 }
 
 //=======================================================================
@@ -192,41 +206,42 @@ myend(0)
 //=======================================================================
 
 Standard_Boolean Select3D_SensitiveCircle::
-Matches(const Standard_Real X, 
-        const Standard_Real Y, 
-        const Standard_Real aTol, 
+Matches(const Standard_Real X,
+        const Standard_Real Y,
+        const Standard_Real aTol,
         Standard_Real& DMin)
 {
-  if(mynbpoints>1)
+  Standard_Integer aSize = mypolyg.Size();
+  if (aSize != 1)
   {
     Standard_Boolean Found = Standard_False;
-    Standard_Integer i = 0;
+    Standard_Integer anIndex = 0;
     
     if(!myFillStatus)
     {
-      while(i < mynbpoints-2 && !Found) 
-      { 
-        Standard_Integer TheStat = 
-          Select3D_SensitiveTriangle::Status(((Select3D_Pnt2d*)mypolyg2d)[i],
-                         ((Select3D_Pnt2d*)mypolyg2d)[i+1],
-                         ((Select3D_Pnt2d*)mypolyg2d)[i+2],
-                         gp_XY(X,Y),aTol,DMin); 
-        Found = (TheStat != 2); 
-        if(Found) myDetectedIndex = i; 
-        i += 2;
+      while(anIndex < aSize-2 && !Found)
+      {
+        Standard_Integer TheStat =
+          Select3D_SensitiveTriangle::Status(mypolyg.Pnt2d(anIndex),
+                                             mypolyg.Pnt2d(anIndex+1),
+                                             mypolyg.Pnt2d(anIndex+2),
+                                             gp_XY(X,Y),aTol,DMin);
+        Found = (TheStat != 2);
+        if(Found) myDetectedIndex = anIndex;
+        anIndex += 2;
       }
     }
-    else 
+    else
     {
       myDetectedIndex =-1;
       Standard_Real Xmin,Ymin,Xmax,Ymax;
 
       // Get coordinates of the bounding box
-      Bnd_Box2d(mybox2d).Get(Xmin,Ymin,Xmax,Ymax); 
-      TColgp_Array1OfPnt2d anArrayOf2dPnt(1, mynbpoints); 
-      
+      Bnd_Box2d(mybox2d).Get(Xmin,Ymin,Xmax,Ymax);
+      TColgp_Array1OfPnt2d anArrayOf2dPnt(1, aSize);
+
       // Fill anArrayOf2dPnt with points from mypolig2d
-      Points2D(anArrayOf2dPnt); 
+      Points2D(anArrayOf2dPnt);
       
       CSLib_Class2d anInOutTool(anArrayOf2dPnt,aTol,aTol,Xmin,Ymin,Xmax,Ymax);
 
@@ -235,23 +250,27 @@ Matches(const Standard_Real X,
       //  0 - the point is on the circle
       // -1 - the point is outside the circle
       Standard_Integer aStat = anInOutTool.SiDans(gp_Pnt2d(X,Y));
-      if(aStat != -1) 
+      if(aStat != -1)
       {
         // Compute DMin (a distance between the center and the point)
         DMin = gp_XY(myCenter2D.x - X, myCenter2D.y - Y).Modulus();
         Select3D_SensitiveEntity::Matches(X,Y,aTol,DMin); 
         return Standard_True;
       }
-      return Standard_False;  
+      return Standard_False;
     }
-    if(!Found) 
+    if(!Found)
       myDetectedIndex=-1;
     else
       Select3D_SensitiveEntity::Matches(X,Y,aTol,DMin);
-    
     return Found;
   }
-  return Standard_True;
+  // Circle degenerates into point
+  DMin = gp_Pnt2d(X, Y).Distance(mypolyg.Pnt2d(0));
+  if (DMin <= aTol*SensitivityFactor())
+    return Select3D_SensitiveEntity::Matches(X,Y,aTol,DMin);
+
+  return Standard_False;
 }
 
 //=======================================================================
@@ -270,9 +289,12 @@ Matches(const Standard_Real XMin,
   Bnd_Box2d abox;
   abox.Update(Min(XMin,XMax),Min(YMin,YMax),Max(XMin,XMax),Max(YMin,YMax));
   abox.Enlarge(aTol);
-  for(Standard_Integer i=0;i<mynbpoints;i++)
-    if(abox.IsOut(((Select3D_Pnt2d*)mypolyg2d)[i])) return Standard_False;
 
+  for(Standard_Integer anIndex=0;anIndex<mypolyg.Size();anIndex++)
+  {
+    if(abox.IsOut(mypolyg.Pnt2d(anIndex)))
+      return Standard_False;
+  }
   return Standard_True;
 }
 
@@ -285,18 +307,20 @@ Standard_Boolean Select3D_SensitiveCircle::
 Matches (const TColgp_Array1OfPnt2d& aPoly,
          const Bnd_Box2d& aBox,
          const Standard_Real aTol)
-{ 
+{
+  myDetectedIndex = -1;
   Standard_Real Umin,Vmin,Umax,Vmax;
   aBox.Get(Umin,Vmin,Umax,Vmax);
   Standard_Real Tolu,Tolv;
-  Tolu = 1e-7;
-  Tolv = 1e-7;
+  Tolu = Precision::Confusion();
+  Tolv = Precision::Confusion();
   CSLib_Class2d aClassifier2d(aPoly,aTol,aTol,Umin,Vmin,Umax,Vmax);
 
-  for(Standard_Integer j=1;j<=mynbpoints;j++)
+  for(Standard_Integer anIndex=0;anIndex<mypolyg.Size();++anIndex)
   {
-    Standard_Integer RES = aClassifier2d.SiDans(((Select3D_Pnt2d*)mypolyg2d)[j-1]);
-    if(RES!=1) return Standard_False;
+    Standard_Integer RES = aClassifier2d.SiDans(mypolyg.Pnt2d(anIndex));
+    if(RES!=1)
+      return Standard_False;
   }
   return Standard_True;
 }
@@ -310,8 +334,8 @@ void Select3D_SensitiveCircle::
 ArrayBounds(Standard_Integer & Low,
             Standard_Integer & Up) const
 {
-  Low = 0;
-  Up  = mynbpoints-1;
+    Low = 0;
+    Up = mypolyg.Size()-1;
 }
 
 //=======================================================================
@@ -322,9 +346,9 @@ ArrayBounds(Standard_Integer & Low,
 gp_Pnt Select3D_SensitiveCircle::
 GetPoint3d(const Standard_Integer Rank) const
 {
-  if(Rank>=0&& Rank<mynbpoints)
-    return ((Select3D_Pnt*)mypolyg3d)[Rank];
-  return ((Select3D_Pnt*)mypolyg3d)[0];
+  if(Rank>=0 && Rank<mypolyg.Size())
+    return mypolyg.Pnt(Rank);
+  return gp_Pnt();
 }
 
 
@@ -335,12 +359,11 @@ GetPoint3d(const Standard_Integer Rank) const
 
 void Select3D_SensitiveCircle::Dump(Standard_OStream& S,const Standard_Boolean FullDump) const
 {
-  //  Standard_Integer rank(1);
-  gp_XYZ CDG(0.,0.,0.);
+  Standard_Integer aSize = mypolyg.Size();
   
   S<<"\tSensitiveCircle 3D :";
   
-  Standard_Boolean isclosed = 1== mynbpoints;
+  Standard_Boolean isclosed = 1== aSize;
   if(isclosed)
     S<<"(Closed Circle)"<<endl;
   else
@@ -352,20 +375,11 @@ void Select3D_SensitiveCircle::Dump(Standard_OStream& S,const Standard_Boolean F
 
   if(FullDump)
   {
-    Standard_Integer EndIndex = isclosed? mynbpoints-2 : mynbpoints-1, nbpt(0);
-    for(Standard_Integer i=0;i<EndIndex;i+=2)
-    {
-      CDG +=((Select3D_Pnt*)mypolyg3d)[i];
-      nbpt++;
-    }
-    
-    CDG/=nbpt;
-    
-    Standard_Real R = (CDG-((Select3D_Pnt*)mypolyg3d)[0]).Modulus();
-    
-    S<<"\t\t Center : ("<<CDG.X()<<" , "<<CDG.Y()<<" , "<<CDG.Z()<<" )"<<endl;
+    gp_XYZ aCenter = myCenter3D;
+    Standard_Real R = (aCenter-mypolyg.Pnt(0)).Modulus();
+
+    S<<"\t\t Center : ("<<aCenter.X()<<" , "<<aCenter.Y()<<" , "<<aCenter.Z()<<" )"<<endl;
     S<<"\t\t Radius :"<<R<<endl;
-    
   }
 }
 
@@ -376,34 +390,25 @@ void Select3D_SensitiveCircle::Dump(Standard_OStream& S,const Standard_Boolean F
 
 Standard_Real Select3D_SensitiveCircle::ComputeDepth(const gp_Lin& EyeLine) const
 {
-  gp_Pnt CDG;
+  gp_XYZ aCDG;
   if(myDetectedIndex==-1)
   {
-    gp_XYZ CurCoord(((Select3D_Pnt*)mypolyg3d)[0]);
-    Standard_Boolean isclosed = 1==mynbpoints;
-    Standard_Integer EndIndex = isclosed ? mynbpoints-2 : mynbpoints-1, nbpt(0);
-    for(Standard_Integer i=1;i<EndIndex;i+=2)
-    {
-      CurCoord +=((Select3D_Pnt*)mypolyg3d)[i];
-      nbpt++;
-    }
-    CDG.SetXYZ(CurCoord);
+    aCDG = myCenter3D;
   }
   else
   {
-    gp_XYZ CurCoord(((Select3D_Pnt*)mypolyg3d)[myDetectedIndex]);
-    CurCoord+=((Select3D_Pnt*)mypolyg3d)[myDetectedIndex+1];
-    CurCoord+=((Select3D_Pnt*)mypolyg3d)[myDetectedIndex+2];
-    CDG.SetXYZ(CurCoord);
+    aCDG += mypolyg.Pnt(myDetectedIndex);
+    aCDG += mypolyg.Pnt(myDetectedIndex+1);
+    aCDG += mypolyg.Pnt(myDetectedIndex+2);
+    aCDG /= 3.;
   }
-
-  return  ElCLib::Parameter(EyeLine,CDG); 
+  return ElCLib::Parameter(EyeLine,gp_Pnt(aCDG));
 }
 
 //=======================================================================
 //function : GetConnected
 //purpose  : 
-//======================================================================= 
+//=======================================================================
 
 Handle(Select3D_SensitiveEntity) Select3D_SensitiveCircle::GetConnected(const TopLoc_Location& theLocation) 
 {
@@ -426,10 +431,11 @@ Handle(Select3D_SensitiveEntity) Select3D_SensitiveCircle::GetConnected(const To
   // this was constructed using TColgp_Array1OfPnt
   else 
   {
-    TColgp_Array1OfPnt aPolyg(1, mynbpoints);
-    for(Standard_Integer i = 1; i <= mynbpoints; ++i)
+    Standard_Integer aSize = mypolyg.Size();
+    TColgp_Array1OfPnt aPolyg(1, aSize);
+    for(Standard_Integer anIndex = 1; anIndex <= aSize; ++anIndex)
     {
-      aPolyg.SetValue(i, ((Select3D_Pnt*)mypolyg3d)[i-1]);
+      aPolyg.SetValue(anIndex, mypolyg.Pnt(anIndex-1));
     }
     aNewEntity = new Select3D_SensitiveCircle(myOwnerId, aPolyg, myFillStatus);
   }
@@ -447,10 +453,9 @@ Handle(Select3D_SensitiveEntity) Select3D_SensitiveCircle::GetConnected(const To
 //purpose  : 
 //=======================================================================
 
-void Select3D_SensitiveCircle::Project(const Handle_Select3D_Projector &aProjector) 
+void Select3D_SensitiveCircle::Project(const Handle_Select3D_Projector &aProjector)
 {
   Select3D_SensitivePoly::Project(aProjector); 
-  // Project the center of the circle 
   gp_Pnt2d aCenter;
   aProjector->Project(myCenter3D, aCenter);
   myCenter2D = aCenter;
@@ -461,30 +466,23 @@ void Select3D_SensitiveCircle::Project(const Handle_Select3D_Projector &aProject
 //purpose  : 
 //=======================================================================
 
-void Select3D_SensitiveCircle::ComputeCenter3D() 
+void Select3D_SensitiveCircle::ComputeCenter3D()
 {
-  gp_XYZ aCenter(0., 0., 0.);
-  if(mynbpoints > 1)
+  gp_XYZ aCenter;
+  Standard_Integer nbpoints = mypolyg.Size();
+  if (nbpoints != 1)
   {
     // The mass of points system
-    Standard_Integer aMass = mynbpoints - 1; 
+    Standard_Integer aMass = nbpoints - 1;
     // Find the circle barycenter
-    for(Standard_Integer i = 0; i < mynbpoints-1; ++i)
+    for (Standard_Integer anIndex = 0; anIndex < nbpoints-1; ++anIndex)
     {
-      aCenter += ((Select3D_Pnt*)mypolyg3d)[i];
+      aCenter += mypolyg.Pnt(anIndex);
     }
     myCenter3D = aCenter / aMass;
   }
-  else if (mynbpoints == 1)
-  {
-    myCenter3D = ((Select3D_Pnt*)mypolyg3d)[0];
-  }
-  // bad case! there are no points in mypolyg3d 
-  // It can lead to incorrect computation of 
-  // parameter DMin in method Matches. 
-  // In spite of this myCenter3D isn't left uninitialized
   else
   {
-    myCenter3D = aCenter;
+    myCenter3D = mypolyg.Pnt(0);
   }
 }
index 484d8c6..c30a2e5 100755 (executable)
@@ -11,6 +11,8 @@ class SensitiveCurve   from Select3D
 inherits SensitivePoly from Select3D
 
     ---Purpose: A framework to define a sensitive 3D curve.
+    -- In some cases this class can raise Standard_ConstructionError and 
+    -- Standard_OutOfRange exceptions. For more details see Select3D_SensitivePoly.
 
 uses
     Pnt             from gp,
@@ -26,6 +28,10 @@ uses
     Box2d           from Bnd,
     Location                 from TopLoc, 
     SensitiveEntity   from Select3D
+
+raises
+    ConstructionError from Standard,
+    OutOfRange from Standard
 is
 
 
index 231dd25..2b255f0 100755 (executable)
@@ -68,7 +68,7 @@ Standard_Boolean Select3D_SensitiveCurve
           Standard_Real& DMin)
 {
   Standard_Integer Rank;
-  TColgp_Array1OfPnt2d aArrayOf2dPnt(1, mynbpoints);
+  TColgp_Array1OfPnt2d aArrayOf2dPnt(1, mypolyg.Size());
   Points2D(aArrayOf2dPnt);
   if (SelectBasics_BasicTool::MatchPolyg2d (aArrayOf2dPnt,
                                             X, Y,
@@ -99,9 +99,10 @@ Matches (const Standard_Real XMin,
   Bnd_Box2d BoundBox;
   BoundBox.Update(XMin-aTol,YMin-aTol,XMax+aTol,YMax+aTol);
   
-  for(Standard_Integer j=0; j<mynbpoints; j++)
+  for(Standard_Integer anIndex=0; anIndex<mypolyg.Size(); ++anIndex)
     {
-      if(BoundBox.IsOut(((Select3D_Pnt2d*)mypolyg2d)[j])) return Standard_False;
+      if(BoundBox.IsOut(mypolyg.Pnt2d(anIndex)))
+        return Standard_False;
     }
   return Standard_True;
 }
@@ -123,10 +124,11 @@ Matches (const TColgp_Array1OfPnt2d& aPoly,
   Tolv = 1e-7;
   CSLib_Class2d aClassifier2d(aPoly,aTol,aTol,Umin,Vmin,Umax,Vmax);
 
-  for(Standard_Integer j=0;j<mynbpoints;j++)
+  for(Standard_Integer anIndex=0;anIndex<mypolyg.Size();++anIndex)
   {
-    Standard_Integer RES = aClassifier2d.SiDans(((Select3D_Pnt2d*)mypolyg2d)[j]);
-    if(RES!=1) return Standard_False;
+    Standard_Integer RES = aClassifier2d.SiDans(mypolyg.Pnt2d(anIndex));
+    if(RES!=1)
+      return Standard_False;
   }
   return Standard_True;
 }
@@ -144,11 +146,11 @@ void Select3D_SensitiveCurve
 
   Standard_Real Step = (aCurve->LastParameter()- aCurve->FirstParameter())/(NbP-1);
   Standard_Real Curparam = aCurve->FirstParameter();
-  for(Standard_Integer i=0;i<mynbpoints;i++)
-    {
-      ((Select3D_Pnt*)mypolyg3d)[i] = aCurve->Value(Curparam);
-      Curparam+=Step;
-    }
+  for(Standard_Integer anIndex=0;anIndex<mypolyg.Size();++anIndex)
+  {
+    mypolyg.SetPnt(anIndex, aCurve->Value(Curparam));
+    Curparam+=Step;
+  }
 }
 
 //=======================================================================
@@ -159,14 +161,13 @@ void Select3D_SensitiveCurve
 void Select3D_SensitiveCurve::Dump(Standard_OStream& S,const Standard_Boolean FullDump) const 
 {
   S<<"\tSensitiveCurve 3D :"<<endl;
-  if(HasLocation())
+  if (HasLocation())
     S<<"\t\tExisting Location"<<endl;
 
-  S<<"\t\tNumber Of Points :"<<mynbpoints<<endl;
+  S<<"\t\tNumber Of Points :"<<mypolyg.Size()<<endl;
 
   if(FullDump)
   {
-//    S<<"\t\t\tOwner:"<<myOwnerId<<endl;
     Select3D_SensitiveEntity::DumpBox(S,mybox2d);
   }
 }
@@ -178,11 +179,27 @@ void Select3D_SensitiveCurve::Dump(Standard_OStream& S,const Standard_Boolean Fu
 
 Standard_Real Select3D_SensitiveCurve::ComputeDepth(const gp_Lin& EyeLine) const
 {
-  if(mylastseg==0) return Precision::Infinite(); // non implemente actuellement...
-  gp_XYZ TheCDG(((Select3D_Pnt*)mypolyg3d)[mylastseg]);
-  TheCDG+=((Select3D_Pnt*)mypolyg3d)[mylastseg+1];
-  TheCDG/=2.;
-  return ElCLib::Parameter(EyeLine,gp_Pnt(TheCDG));
+  Standard_Real aDepth = Precision::Infinite();
+
+  // Not implemented
+  if(mylastseg==0)
+    return aDepth;
+
+  gp_XYZ aCDG;
+  // In case if mylastseg and mylastseg+1 are not valid
+  // the depth will be infinite
+  if (mylastseg < mypolyg.Size())
+  {
+    aCDG = mypolyg.Pnt(mylastseg);
+    if (mylastseg+1 < mypolyg.Size())
+    {
+      aCDG += mypolyg.Pnt(mylastseg+1);
+      aCDG /= 2.;
+    }
+    aDepth = ElCLib::Parameter(EyeLine,gp_Pnt(aCDG));
+  }
+
+  return aDepth;
 }
 
 //=======================================================================
@@ -202,13 +219,14 @@ Handle(Select3D_SensitiveEntity) Select3D_SensitiveCurve::GetConnected(const Top
   // this was constructed using TColgp_HArray1OfPnt
   else 
   {
-    Handle(TColgp_HArray1OfPnt) aPoints = new TColgp_HArray1OfPnt(1, mynbpoints);
+    Standard_Integer aSize = mypolyg.Size();
+    Handle(TColgp_HArray1OfPnt) aPoints = new TColgp_HArray1OfPnt(1, aSize);
     // Fill the array with points from mypolyg3d
-    for (Standard_Integer i = 1; i <= mynbpoints; ++i) 
+    for (Standard_Integer anIndex = 1; anIndex <= aSize; ++anIndex) 
     {
-      aPoints->SetValue(i, ((Select3D_Pnt*)mypolyg3d)[i-1]);
+      aPoints->SetValue(anIndex, mypolyg.Pnt(anIndex-1));
     }
-    aNewEntity = new Select3D_SensitiveCurve(myOwnerId, aPoints);
+     aNewEntity = new Select3D_SensitiveCurve(myOwnerId, aPoints);
   }
   
   if (HasLocation()) 
index 9821709..cbb1d67 100755 (executable)
@@ -9,6 +9,8 @@ class SensitiveFace from Select3D
 inherits SensitivePoly from Select3D
 
     ---Purpose: Sensitive Entity to make a face selectable.
+    -- In some cases this class can raise Standard_ConstructionError and 
+    -- Standard_OutOfRange exceptions. For more details see Select3D_SensitivePoly.
 
 uses
     EntityOwner       from SelectBasics,
@@ -23,6 +25,10 @@ uses
     Location          from TopLoc, 
     SensitiveEntity   from Select3D
 
+raises
+    ConstructionError from Standard,
+    OutOfRange from Standard
+
 is
 
     Create (OwnerId      : EntityOwner from SelectBasics;
index 833b801..145a745 100755 (executable)
@@ -88,28 +88,27 @@ Matches(const Standard_Real X,
   // then min. distance of the polyhedron or cdg...
 
   Standard_Real aTol2 = aTol*aTol;
-  gp_XY CDG(0.,0.);
-//  for(Standard_Integer I=1;I<=Nbp-1;I++){
-  Standard_Integer I;
-  for(I=1;I<mynbpoints-1;I++)
+  Standard_Integer aSize = mypolyg.Size(), anIndex;
+  gp_XY CDG;
+  for(anIndex=0;anIndex<aSize;++anIndex)
   {
-    CDG+=((Select3D_Pnt2d*)mypolyg2d)[I-1];
+    CDG+=mypolyg.Pnt2d(anIndex);
   }
-  
-  if(mynbpoints>1)
+
+  if(aSize>1)
   {
-    CDG/= (mynbpoints-1);
+    CDG/=(aSize-1);
   }
   DMin2=Min(DMin2,gp_XY(CDG.X()-X,CDG.Y()-Y).SquareModulus());
   DMin = Sqrt(DMin2);
-  
+
   Standard_Boolean isplane2d(Standard_True);
-  
-  for( I=1;I<mynbpoints-1;I++)
+
+  for(anIndex=1;anIndex<aSize;++anIndex)
   {
-    gp_XY V1(((Select3D_Pnt2d*)mypolyg2d)[I]),V(X,Y);
-    V1-=((Select3D_Pnt2d*)mypolyg2d)[I-1];
-    V-=((Select3D_Pnt2d*)mypolyg2d)[I-1];
+    gp_XY V1(mypolyg.Pnt2d(anIndex)),V(X,Y);
+    V1-=mypolyg.Pnt2d(anIndex-1);
+    V-=mypolyg.Pnt2d(anIndex-1);
     Standard_Real Vector = V1^V;
     Standard_Real V1V1 = V1.SquareModulus();
     DMin2 = 
@@ -117,7 +116,8 @@ Matches(const Standard_Real X,
     Min(DMin2,V.SquareModulus()): // if the segment is too small...
       Min(DMin2,Vector*Vector/V1V1);
     //cdg ...
-    gp_XY PlaneTest(CDG);PlaneTest-=((Select3D_Pnt2d*)mypolyg2d)[I-1];
+    gp_XY PlaneTest(CDG);
+    PlaneTest-=mypolyg.Pnt2d(anIndex-1);
     Standard_Real valtst = PlaneTest^V1;
     if(isplane2d && Abs(valtst)>aTol) isplane2d=Standard_False;
   }
@@ -127,11 +127,11 @@ Matches(const Standard_Real X,
   }
 
   //otherwise it is checked if the point is in the face...
-  TColgp_Array1OfPnt2d aArrayOf2dPnt(1, mynbpoints);
+  TColgp_Array1OfPnt2d aArrayOf2dPnt(1, aSize);
   Points2D(aArrayOf2dPnt);
   CSLib_Class2d TheInOutTool(aArrayOf2dPnt,aTol,aTol,Xmin,Ymin,Xmax,Ymax);
   Standard_Integer TheStat = TheInOutTool.SiDans(gp_Pnt2d(X,Y));
-  
+
   Standard_Boolean res(Standard_False);
   switch(TheStat)
   {
@@ -139,7 +139,7 @@ Matches(const Standard_Real X,
     res = Standard_True;
   case 1:
     {
-      if(mytype!=Select3D_TOS_BOUNDARY) 
+      if(mytype!=Select3D_TOS_BOUNDARY)
         res = Standard_True;
     }
   }
@@ -164,10 +164,11 @@ Matches (const Standard_Real XMin,
 {
   Bnd_Box2d BoundBox;
   BoundBox.Update(XMin-aTol,YMin-aTol,XMax+aTol,YMax+aTol);
-  
-  for(Standard_Integer j=1;j<=mynbpoints-1;j++)
+
+  for(Standard_Integer anIndex=0;anIndex<mypolyg.Size();++anIndex)
   {
-    if(BoundBox.IsOut(((Select3D_Pnt2d*)mypolyg2d)[j-1])) return Standard_False;
+    if(BoundBox.IsOut(mypolyg.Pnt2d(anIndex)))
+      return Standard_False;
   }
   return Standard_True;
 }
@@ -189,10 +190,12 @@ Matches (const TColgp_Array1OfPnt2d& aPoly,
   Tolv = 1e-7;
   CSLib_Class2d aClassifier2d(aPoly,aTol,aTol,Umin,Vmin,Umax,Vmax);
 
-  for(Standard_Integer j=1;j<=mynbpoints;j++)
+  gp_Pnt2d aPnt2d;
+  for(Standard_Integer anIndex=0;anIndex<mypolyg.Size();++anIndex)
   {
-    Standard_Integer RES = aClassifier2d.SiDans(((Select3D_Pnt2d*)mypolyg2d)[j-1]);
-    if(RES!=1) return Standard_False;
+    Standard_Integer RES = aClassifier2d.SiDans(mypolyg.Pnt2d(anIndex));
+    if(RES!=1)
+      return Standard_False;
   }
   return Standard_True;
 }
@@ -213,9 +216,7 @@ void Select3D_SensitiveFace::Dump(Standard_OStream& S,const Standard_Boolean Ful
   
   if(FullDump)
   {
-    S<<"\t\tNumber Of Points :"<<mynbpoints<<endl;
-    
-//    S<<"\t\t\tOwner:"<<myOwnerId<<endl;
+    S<<"\t\tNumber Of Points :"<<mypolyg.Size()<<endl;
     Select3D_SensitiveEntity::DumpBox(S,mybox2d);
   }
 }
@@ -228,12 +229,14 @@ void Select3D_SensitiveFace::Dump(Standard_OStream& S,const Standard_Boolean Ful
 Standard_Real Select3D_SensitiveFace::ComputeDepth(const gp_Lin& EyeLine) const
 {
   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++)
+
+  for (Standard_Integer anIndex = 0; anIndex < mypolyg.Size()-1; ++anIndex)
   {
-    aDepthTest = ElCLib::Parameter (EyeLine, ((Select3D_Pnt* )mypolyg3d)[i]);
+    aDepthTest = ElCLib::Parameter (EyeLine, mypolyg.Pnt(anIndex));
     if (aDepthTest < aDepth && (aDepthTest > aDepthMin) && (aDepthTest < aDepthMax))
     {
       aDepth = aDepthTest;
@@ -249,18 +252,19 @@ Standard_Real Select3D_SensitiveFace::ComputeDepth(const gp_Lin& EyeLine) const
 
 Handle(Select3D_SensitiveEntity) Select3D_SensitiveFace::GetConnected(const TopLoc_Location &theLocation) 
 {
-  // Create a copy of this 
-  TColgp_Array1OfPnt aPoints(1, mynbpoints);
-  for (Standard_Integer i = 1; i <= mynbpoints; ++i) 
+  // Create a copy of this
+  Standard_Integer aSize = mypolyg.Size();
+  TColgp_Array1OfPnt aPoints(1, aSize);
+  for (Standard_Integer anIndex = 1; anIndex <= aSize; ++anIndex)
   {
-    aPoints.SetValue(i, ((Select3D_Pnt*)mypolyg3d)[i-1]);
+    aPoints.SetValue(anIndex, mypolyg.Pnt(anIndex-1));
   }
 
-  Handle(Select3D_SensitiveEntity) aNewEntity = 
-    new Select3D_SensitiveFace(myOwnerId, aPoints, mytype); 
+  Handle(Select3D_SensitiveEntity) aNewEntity =
+    new Select3D_SensitiveFace(myOwnerId, aPoints, mytype);
 
-  if (HasLocation()) 
-    aNewEntity->SetLocation(Location()); 
+  if (HasLocation())
+    aNewEntity->SetLocation(Location());
 
   aNewEntity->UpdateLocation(theLocation);
 
index b086e9b..643bc82 100755 (executable)
@@ -2,6 +2,9 @@ deferred class SensitivePoly from Select3D
 inherits SensitiveEntity from Select3D
 
     ---Purpose: Sensitive Entity to make a face selectable.
+    -- In some cases this class can raise Standard_ConstructionError and 
+    -- Standard_OutOfRange exceptions from its member Select3D_PointData 
+    -- mypolyg.
 
 uses
     EntityOwner       from SelectBasics,
@@ -9,8 +12,13 @@ uses
     ListOfBox2d       from SelectBasics,
     Array1OfPnt       from TColgp,
     HArray1OfPnt      from TColgp,
-    Array1OfPnt2d   from TColgp,
-    Box2d             from Select3D
+    Array1OfPnt2d     from TColgp,
+    Box2d             from Select3D,
+    PointData         from Select3D
+
+raises    
+    ConstructionError from Standard,
+    OutOfRange        from Standard
 
 is
 
@@ -58,15 +66,8 @@ is
     ---Purpose: Returns the 2D points of the array used at construction time.
     ---C++: inline
 
-
-    Destroy(me: mutable);
-    ---C++: alias ~
-
-
 fields
  
-    mypolyg3d       : Address   from Standard is protected;
-    mypolyg2d       : Address   from Standard is protected;
     mybox2d         : Box2d     from Select3D is protected;
-    mynbpoints      : Integer   from Standard is protected;
+    mypolyg         : PointData from Select3D is protected;
 end SensitivePoly;
index b831e18..d7e0c44 100755 (executable)
 Select3D_SensitivePoly::
 Select3D_SensitivePoly(const Handle(SelectBasics_EntityOwner)& OwnerId,
                        const TColgp_Array1OfPnt& ThePoints):
-Select3D_SensitiveEntity(OwnerId)
+Select3D_SensitiveEntity(OwnerId),
+mypolyg(ThePoints.Upper()-ThePoints.Lower()+1)
 {
-  mynbpoints = ThePoints.Upper()-ThePoints.Lower()+1;
-  mypolyg3d = new Select3D_Pnt[mynbpoints];
-  mypolyg2d = new Select3D_Pnt2d[mynbpoints];
-  for(Standard_Integer i=0;i<mynbpoints;i++)
-    ((Select3D_Pnt*)mypolyg3d)[i] = ThePoints.Value(ThePoints.Lower()+i); 
+  for (Standard_Integer theIndex = 0 ; theIndex < mypolyg.Size(); ++theIndex)
+    mypolyg.SetPnt(theIndex, ThePoints.Value(ThePoints.Lower()+theIndex));
 }
 
 //==================================================
@@ -32,13 +30,11 @@ Select3D_SensitiveEntity(OwnerId)
 Select3D_SensitivePoly::
 Select3D_SensitivePoly(const Handle(SelectBasics_EntityOwner)& OwnerId,
                        const Handle(TColgp_HArray1OfPnt)& ThePoints):
-Select3D_SensitiveEntity(OwnerId)
+Select3D_SensitiveEntity(OwnerId),
+mypolyg(ThePoints->Upper()-ThePoints->Lower()+1)
 {
-  mynbpoints = ThePoints->Upper()-ThePoints->Lower()+1;
-  mypolyg3d = new Select3D_Pnt[mynbpoints];
-  mypolyg2d = new Select3D_Pnt2d[mynbpoints];
-  for(Standard_Integer i=0;i<mynbpoints;i++)
-    ((Select3D_Pnt*)mypolyg3d)[i] = ThePoints->Value(ThePoints->Lower()+i); 
+  for (Standard_Integer theIndex = 0; theIndex < mypolyg.Size(); theIndex++)
+    mypolyg.SetPnt(theIndex, ThePoints->Value(ThePoints->Lower()+theIndex));
 }
 
 //==================================================
@@ -49,11 +45,9 @@ Select3D_SensitiveEntity(OwnerId)
 Select3D_SensitivePoly::
 Select3D_SensitivePoly(const Handle(SelectBasics_EntityOwner)& OwnerId, 
                        const Standard_Integer NbPoints):
-Select3D_SensitiveEntity(OwnerId)
+Select3D_SensitiveEntity(OwnerId),
+mypolyg(NbPoints)
 {
-  mynbpoints = NbPoints;
-  mypolyg3d = new Select3D_Pnt[mynbpoints];
-  mypolyg2d = new Select3D_Pnt2d[mynbpoints];
 }
 
 //==================================================
@@ -63,25 +57,26 @@ Select3D_SensitiveEntity(OwnerId)
 
 void Select3D_SensitivePoly::Project(const Handle(Select3D_Projector)& aProj)
 {
-  Select3D_SensitiveEntity::Project(aProj); // to set the field last proj...
+  Select3D_SensitiveEntity:: Project (aProj); // to set the field last proj...
   mybox2d.SetVoid();
 
   Standard_Boolean hasloc = HasLocation();
   gp_Pnt2d aPnt2d;
-  for(Standard_Integer i=0;i<mynbpoints;i++)
+  gp_Pnt aPnt;
+  for (Standard_Integer theIndex = 0; theIndex < mypolyg.Size(); ++theIndex)
+  {
+    aPnt = mypolyg.Pnt(theIndex);
+    if (hasloc)
     {
-      gp_Pnt aPnt(((Select3D_Pnt*)mypolyg3d)[i].x, ((Select3D_Pnt*)mypolyg3d)[i].y, ((Select3D_Pnt*)mypolyg3d)[i].z);
-      if (hasloc)
-      {
-        aProj->Project(aPnt.Transformed(Location().Transformation()),aPnt2d);
-      }
-      else
-      {
-        aProj->Project(aPnt,aPnt2d);
-      }
-      mybox2d.Update(aPnt2d);
-      ((Select3D_Pnt2d*)mypolyg2d)[i] = aPnt2d;
+      aProj->Project(aPnt.Transformed(Location().Transformation()), aPnt2d);
     }
+    else
+    {
+      aProj->Project(aPnt, aPnt2d);
+    }
+    mybox2d.Update(aPnt2d);
+    mypolyg.SetPnt2d(theIndex, aPnt2d);
+  }
 }
 
 //==================================================
@@ -94,13 +89,3 @@ void Select3D_SensitivePoly
   aSeq.Append(mybox2d);
 }
 
-//==================================================
-// Function: Destroy
-// Purpose :
-//==================================================
-void Select3D_SensitivePoly::Destroy() 
-{
-  delete[] (Select3D_Pnt*)mypolyg3d;
-  delete[] (Select3D_Pnt2d*)mypolyg2d;
-}
-
index 3d31542..1656590 100755 (executable)
@@ -6,21 +6,20 @@
 inline void Select3D_SensitivePoly
 ::Points3D( Handle(TColgp_HArray1OfPnt)& theHArrayOfPnt )
 { 
-  theHArrayOfPnt = new TColgp_HArray1OfPnt(1,mynbpoints);
-  for(Standard_Integer i = 1; i <= mynbpoints; i++)
+  Standard_Integer aSize = mypolyg.Size();
+  theHArrayOfPnt = new TColgp_HArray1OfPnt(1,aSize);
+  for(Standard_Integer anIndex = 1; anIndex <= aSize; anIndex++)
   {
-    gp_Pnt aPnt(((Select3D_Pnt*)mypolyg3d)[i-1].x, ((Select3D_Pnt*)mypolyg3d)[i-1].y, ((Select3D_Pnt*)mypolyg3d)[i-1].z);
-    theHArrayOfPnt->SetValue(i, aPnt);
+    theHArrayOfPnt->SetValue(anIndex, mypolyg.Pnt(anIndex-1));
   }
 }
 
 inline void Select3D_SensitivePoly
 ::Points2D( TColgp_Array1OfPnt2d& aArrayOf2dPnt)
 {
-  for(Standard_Integer i = 1; i <= mynbpoints; i++)
+  for(Standard_Integer anIndex = 1; anIndex <= mypolyg.Size(); anIndex++)
   {
-    gp_Pnt2d aPnt2d(((Select3D_Pnt2d*)mypolyg2d)[i-1].x, ((Select3D_Pnt2d*)mypolyg2d)[i-1].y);
-    aArrayOf2dPnt.SetValue(i,aPnt2d);
+    aArrayOf2dPnt.SetValue(anIndex, mypolyg.Pnt2d(anIndex-1));
   }
 }
 
index 2cb6a83..3d44ab3 100755 (executable)
@@ -9,7 +9,9 @@ class SensitiveTriangle from Select3D
 inherits SensitivePoly from Select3D
 
     ---Purpose: A framework to define selection of triangles in a view.
-        -- This comes into play in the detection of meshing and triangulation in surfaces.
+    -- This comes into play in the detection of meshing and triangulation in surfaces.
+    -- In some cases this class can raise Standard_ConstructionError and 
+    -- Standard_OutOfRange exceptions. For more details see Select3D_SensitivePoly.
 
 uses
     EntityOwner      from SelectBasics,
@@ -24,6 +26,10 @@ uses
     Location          from TopLoc, 
     SensitiveEntity   from Select3D
 
+raises
+    ConstructionError from Standard,
+    OutOfRange from Standard
+
 is
     Create (OwnerId      : EntityOwner from SelectBasics;
             P1,P2,P3     : Pnt from gp;
index f5c7e51..6d9dd94 100755 (executable)
@@ -18,9 +18,6 @@
 
 #include <CSLib_Class2d.hxx>
 
-#define COORD(a,b) ((Select3D_Pnt*)mypolyg3d)[(a)].b
-#define COORD2d(a,b) ((Select3D_Pnt2d*)mypolyg2d)[(a)].b
-
 static Standard_Boolean S3D_Str_NearSegment (const gp_XY& p0, const gp_XY& p1, const gp_XY& TheP,
                                              const Standard_Real aTol, Standard_Real& aDMin)
 {
@@ -55,10 +52,10 @@ Select3D_SensitiveTriangle(const Handle(SelectBasics_EntityOwner)& OwnerId,
                            const Select3D_TypeOfSensitivity aType):
 Select3D_SensitivePoly(OwnerId,3),
 mytype (aType)
-{ 
-  ((Select3D_Pnt*)mypolyg3d)[0] = P0;
-  ((Select3D_Pnt*)mypolyg3d)[1] = P1;
-  ((Select3D_Pnt*)mypolyg3d)[2] = P2;
+{
+  mypolyg.SetPnt(0, P0);
+  mypolyg.SetPnt(1, P1);
+  mypolyg.SetPnt(2, P2);
 }
 
 //==================================================
@@ -76,7 +73,7 @@ Matches(const Standard_Real X,
   if(Bnd_Box2d(mybox2d).IsOut(gp_Pnt2d(X,Y))) return Standard_False;
 
   Standard_Integer Res;
-  switch (mytype) 
+  switch (mytype)
   {
   case Select3D_TOS_BOUNDARY:
     Res = Status(X,Y,aTol,DMin);
@@ -88,7 +85,7 @@ Matches(const Standard_Real X,
 #ifndef DEB
   default:
     break;
-#endif    
+#endif
   }
   return Standard_True;
 }
@@ -110,9 +107,9 @@ Matches (const Standard_Real XMin,
            Min(YMin,YMax)-aTol,
            Max(XMin,XMax)+aTol,
            Max(YMin,YMax)+aTol);
-  for(Standard_Integer i=0;i<=2;i++) 
+  for(Standard_Integer anIndex=0;anIndex<=2;++anIndex)
   {
-    if(B.IsOut(((Select3D_Pnt2d*)mypolyg2d)[i])) 
+    if(B.IsOut(mypolyg.Pnt2d(anIndex)))
       return Standard_False;
   }
   return Standard_True;
@@ -127,7 +124,7 @@ Standard_Boolean Select3D_SensitiveTriangle::
 Matches (const TColgp_Array1OfPnt2d& aPoly,
          const Bnd_Box2d& aBox,
          const Standard_Real aTol)
-{ 
+{
   Standard_Real Umin,Vmin,Umax,Vmax;
   aBox.Get(Umin,Vmin,Umax,Vmax);
   Standard_Real Tolu,Tolv;
@@ -135,10 +132,11 @@ Matches (const TColgp_Array1OfPnt2d& aPoly,
   Tolv = 1e-7;
   CSLib_Class2d aClassifier2d(aPoly,aTol,aTol,Umin,Vmin,Umax,Vmax);
 
-  for(Standard_Integer i=0;i<=2;i++) 
+  for(Standard_Integer anIndex=0;anIndex<=2;++anIndex)
   {
-    Standard_Integer RES = aClassifier2d.SiDans(((Select3D_Pnt2d*)mypolyg2d)[i]);
-    if(RES!=1) return Standard_False;
+    Standard_Integer RES = aClassifier2d.SiDans(mypolyg.Pnt2d(anIndex));
+    if(RES!=1)
+      return Standard_False;
   }
   return Standard_True;
 }
@@ -148,11 +146,11 @@ Matches (const TColgp_Array1OfPnt2d& aPoly,
 // Purpose :
 //==================================================
 
- void Select3D_SensitiveTriangle::Points3D(gp_Pnt& P0,gp_Pnt& P1,gp_Pnt& P2) const
+void Select3D_SensitiveTriangle::Points3D(gp_Pnt& P0,gp_Pnt& P1,gp_Pnt& P2) const
 {
-  P0 = ((Select3D_Pnt*)mypolyg3d)[0]; 
-  P1 = ((Select3D_Pnt*)mypolyg3d)[1]; 
-  P2 = ((Select3D_Pnt*)mypolyg3d)[2]; 
+  P0 = mypolyg.Pnt(0);
+  P1 = mypolyg.Pnt(1);
+  P2 = mypolyg.Pnt(2);
 }
 
 //==================================================
@@ -162,11 +160,11 @@ Matches (const TColgp_Array1OfPnt2d& aPoly,
 
 gp_Pnt Select3D_SensitiveTriangle::Center3D() const
 {
-  gp_XYZ CDG(((Select3D_Pnt*)mypolyg3d)[0]);
-  CDG += ((Select3D_Pnt*)mypolyg3d)[1];
-  CDG += ((Select3D_Pnt*)mypolyg3d)[2];
-  CDG /=3.;
-  return gp_Pnt(CDG);;
+  gp_XYZ aPnt1, aPnt2, aPnt3;
+  aPnt1 = mypolyg.Pnt(0);
+  aPnt2 = mypolyg.Pnt(1);
+  aPnt3 = mypolyg.Pnt(2);
+  return gp_Pnt((aPnt1+aPnt2+aPnt3)/3.);
 }
 
 //==================================================
@@ -176,8 +174,11 @@ gp_Pnt Select3D_SensitiveTriangle::Center3D() const
 
 gp_XY Select3D_SensitiveTriangle::Center2D() const
 {
-  return (gp_XY(((Select3D_Pnt2d*)mypolyg2d)[0])+gp_XY(((Select3D_Pnt2d*)mypolyg2d)[1])
-          +gp_XY(((Select3D_Pnt2d*)mypolyg2d)[2]))/3.;
+  gp_XY aPnt1, aPnt2, aPnt3;
+  aPnt1 = mypolyg.Pnt2d(0);
+  aPnt2 = mypolyg.Pnt2d(1);
+  aPnt3 = mypolyg.Pnt2d(2);
+  return (aPnt1+aPnt2+aPnt3)/3.;
 }
 
 //=======================================================================
@@ -188,10 +189,10 @@ gp_XY Select3D_SensitiveTriangle::Center2D() const
 Standard_Integer  Select3D_SensitiveTriangle::Status(const Standard_Real X,
                                                      const Standard_Real Y,
                                                      const Standard_Real aTol,
-                                                     Standard_Real& DMin) const 
-{ 
-  return Status(((Select3D_Pnt2d*)mypolyg2d)[0],((Select3D_Pnt2d*)mypolyg2d)[1],
-                ((Select3D_Pnt2d*)mypolyg2d)[2],gp_XY(X,Y),aTol,DMin);
+                                                     Standard_Real& DMin) const
+{
+  return Status(mypolyg.Pnt2d(0), mypolyg.Pnt2d(1), mypolyg.Pnt2d(2),
+                gp_XY(X,Y), aTol, DMin);
 }
 
 //=======================================================================
@@ -209,7 +210,7 @@ Standard_Integer  Select3D_SensitiveTriangle::Status(const gp_XY& p0,
   Bnd_Box2d B;
   B.Update(p0.X(),p0.Y());B.Update(p1.X(),p1.Y());B.Update(p2.X(),p2.Y());
   B.Enlarge(aTol);
-  if(B.IsOut(TheP)) return 2; 
+  if(B.IsOut(TheP)) return 2;
   
   // the point is classified corresponding to demi-spaces limited
   // by each side of the triangle (with tolerance)
@@ -220,7 +221,7 @@ Standard_Integer  Select3D_SensitiveTriangle::Status(const gp_XY& p0,
   Standard_Real TolTol = aTol*aTol;
 
   // check these particular cases...
-  // if one of vectors is almost null (2 points are mixed), 
+  // if one of vectors is almost null (2 points are mixed),
   // leave at once (it is already in the bounding box, which is good...)
   
   DMin = aTol;
@@ -305,23 +306,30 @@ Standard_Integer  Select3D_SensitiveTriangle::Status(const gp_XY& p0,
 void Select3D_SensitiveTriangle::Dump(Standard_OStream& S,const Standard_Boolean FullDump) const 
 {
   // general information....
-  
+
   S<<"\tSensitiveTriangle 3D :\n";
   if(HasLocation())
     S<<"\t\tExisting Location"<<endl;
 
-  S<<"\t\t P0 [ "<<COORD(0,x)<<" , "<<COORD(0,y) <<" , "<<COORD(0,z)<<" ]"<<endl;
-  S<<"\t\t P1 [ "<<COORD(1,x)<<" , "<<COORD(1,y) <<" , "<<COORD(1,z)<<" ]"<<endl;
-  S<<"\t\t P2 [ "<<COORD(2,x)<<" , "<<COORD(2,y) <<" , "<<COORD(2,z)<<" ]"<<endl;
+  gp_Pnt aPnt1, aPnt2, aPnt3;
+  aPnt1 = mypolyg.Pnt(0);
+  aPnt2 = mypolyg.Pnt(1);
+  aPnt3 = mypolyg.Pnt(2);
+  S<<"\t\t P0 [ "<<aPnt1.X()<<" , "<<aPnt1.Y()<<" , "<<aPnt1.Z()<<" ]"<<endl;
+  S<<"\t\t P1 [ "<<aPnt2.X()<<" , "<<aPnt2.Y()<<" , "<<aPnt2.Z()<<" ]"<<endl;
+  S<<"\t\t P2 [ "<<aPnt3.X()<<" , "<<aPnt3.Y()<<" , "<<aPnt3.Z()<<" ]"<<endl;
 
   if(FullDump) 
   {
     S<<"\t\tProjected Points"<<endl;
-    
-    S<<"\t\t  0.[ "<<COORD2d(0,x)<<" , "<<COORD2d(0,y)<<" ]"<<endl;
-    S<<"\t\t  1.[ "<<COORD2d(1,x)<<" , "<<COORD2d(1,y)<<" ]"<<endl;
-    S<<"\t\t  2.[ "<<COORD2d(2,x)<<" , "<<COORD2d(2,y)<<" ]"<<endl;
-//    S<<"\t\t\tOwner:"<<myOwnerId<<endl;
+
+    gp_Pnt2d aPnt1, aPnt2, aPnt3;
+    aPnt1 = mypolyg.Pnt2d(0);
+    aPnt2 = mypolyg.Pnt2d(1);
+    aPnt3 = mypolyg.Pnt2d(2);
+    S<<"\t\t  0.[ "<<aPnt1.X()<<" , "<<aPnt1.Y()<<" ]"<<endl;
+    S<<"\t\t  1.[ "<<aPnt2.X()<<" , "<<aPnt2.Y()<<" ]"<<endl;
+    S<<"\t\t  2.[ "<<aPnt3.X()<<" , "<<aPnt3.Y()<<" ]"<<endl;
     Select3D_SensitiveEntity::DumpBox(S,mybox2d);
   }
 }
@@ -333,9 +341,12 @@ void Select3D_SensitiveTriangle::Dump(Standard_OStream& S,const Standard_Boolean
 
 Standard_Real Select3D_SensitiveTriangle::ComputeDepth(const gp_Lin& EyeLine) const
 {
-  gp_Pnt P1 = ((Select3D_Pnt*)mypolyg3d)[0];
-  gp_Pnt P2 = ((Select3D_Pnt*)mypolyg3d)[1];
-  gp_Pnt P3 = ((Select3D_Pnt*)mypolyg3d)[2];
+  Standard_Real prof(Precision::Infinite());
+
+  gp_Pnt P1, P2, P3;
+  P1 = mypolyg.Pnt(0);
+  P2 = mypolyg.Pnt(1);
+  P3 = mypolyg.Pnt(2);
 
   gp_Trsf TheTrsf ;
   if(HasLocation()) 
@@ -348,7 +359,6 @@ Standard_Real Select3D_SensitiveTriangle::ComputeDepth(const gp_Lin& EyeLine) co
     P3.Transform(TheTrsf);
   }
   
-  Standard_Real prof(Precision::Infinite());
   // formula calculation of the point parameters on intersection
   // t = (P1P2 ^P1P3)* OP1  / ((P1P2^P1P3)*Dir)
   
@@ -385,11 +395,7 @@ GetConnected(const TopLoc_Location &theLocation)
 {
   // Create a copy of this 
   Handle(Select3D_SensitiveEntity) aNewEntity = 
-    new Select3D_SensitiveTriangle(myOwnerId,
-                                   ((Select3D_Pnt*)mypolyg3d)[0], 
-                                   ((Select3D_Pnt*)mypolyg3d)[1], 
-                                   ((Select3D_Pnt*)mypolyg3d)[2], 
-                                   mytype);
+    new Select3D_SensitiveTriangle(myOwnerId, mypolyg.Pnt(0), mypolyg.Pnt(1), mypolyg.Pnt(2), mytype);
 
   if (HasLocation()) 
     aNewEntity->SetLocation(Location()); 
index 589abbb..8fd4287 100755 (executable)
 #include <TColStd_ListOfInteger.hxx>
 #include <TColStd_ListIteratorOfListOfInteger.hxx>
 
+#include <Select3D_SensitiveTriangle.hxx>
+#include <Select3D_SensitiveCurve.hxx>
+#include <BRepAdaptor_Curve.hxx>
+#include <StdPrs_Curve.hxx>
+
+#include <BRepExtrema_ExtPC.hxx>
+#include <BRepExtrema_ExtPF.hxx>
+
 #ifdef HAVE_STRINGS_H
 #include <strings.h>
 #endif
@@ -856,7 +864,7 @@ static int VPointBuilder(Draw_Interpretor& di, Standard_Integer argc, const char
 }
 
 //==============================================================================
-// Fonction        1st click   2de click  3de click
+// Function        1st click   2de click  3de click
 // vplane          Vertex      Vertex     Vertex
 //                 Vertex      Edge
 //                 Edge        Vertex
@@ -869,651 +877,714 @@ static int VPointBuilder(Draw_Interpretor& di, Standard_Integer argc, const char
 
 //==============================================================================
 //function : VPlaneBuilder
-//purpose  : Build an AIS_Plane from selected entities or Named AIs components
+//purpose  : Build an AIS_Plane from selected entities or Named AIS components
 //Draw arg : vplane PlaneName [AxisName]  [PointName]
 //                            [PointName] [PointName] [PointName]
 //                            [PlaneName] [PointName]
 //==============================================================================
 
-#include <TopoDS_Edge.hxx>
-#include <TopoDS_Vertex.hxx>
-#include <TopoDS_Face.hxx>
-#include <TopExp.hxx>
-#include <AIS_Plane.hxx>
-#include <Geom_CartesianPoint.hxx>
-#include <Geom_Plane.hxx>
-#include <BRepExtrema_ExtPC.hxx>
-#include <BRepExtrema_ExtPF.hxx>
-#include <BRepAdaptor_Surface.hxx>
-#include <gp_Pln.hxx>
-#include <GC_MakePlane.hxx>
-
-static int VPlaneBuilder(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
+static Standard_Integer VPlaneBuilder (Draw_Interpretor& di,
+                                       Standard_Integer argc,
+                                       const char** argv)
 {
   // Declarations
-  Standard_Boolean HasArg;
-  TCollection_AsciiString name;
-  Standard_Integer myCurrentIndex;
+  Standard_Boolean hasArg;
+  TCollection_AsciiString aName;
+  Standard_Integer aCurrentIndex;
 
   // Verification
-  if (argc<2 || argc>5 ) {di<<" Syntaxe error"<<"\n";return 1;}
-  if (argc==5 || argc==4) HasArg=Standard_True;
-  else HasArg=Standard_False;
+  if (argc<2 || argc>5 )
+  {
+    std::cout<<" Syntax error\n";
+    return 1;
+  }
+  if (argc==5 || argc==4)
+    hasArg=Standard_True;
+  else 
+    hasArg=Standard_False;
 
-  name=argv[1];
-  // Fermeture des contextes
+  aName=argv[1];
+  // Close all contexts
   TheAISContext()->CloseAllContexts();
 
-
-  // Il y a des arguments
-  if (HasArg) {
-    if (!GetMapOfAIS().IsBound2(argv[2] ) ) {di<<"vplane: error 1st name doesn't exist in the GetMapOfAIS()."<<"\n";return 1;}
-    // on recupere la shape dans la map
-    Handle(AIS_InteractiveObject) theShapeA =
+  // There are some arguments
+  if (hasArg)
+  {
+    if (!GetMapOfAIS().IsBound2(argv[2] ))
+    {
+      std::cout<<"vplane: error 1st name doesn't exist in the GetMapOfAIS()\n";
+      return 1;
+    }
+    // Get shape from map
+    Handle(AIS_InteractiveObject) aShapeA =
       Handle(AIS_InteractiveObject)::DownCast (GetMapOfAIS().Find2(argv[2] ));
 
-    // Le premier argument est un AIS_Point 1
-    if (!theShapeA.IsNull() &&
-      theShapeA->Type()==AIS_KOI_Datum && theShapeA->Signature()==1) {
-        // le deuxieme argument doit etre un AIS_Point aussi
-        if (argc<5 || !GetMapOfAIS().IsBound2(argv[3] ) ) {di<<"vplane: error 2de name doesn't exist in the GetMapOfAIS()."<<"\n";return 1;}
-        // on recupere la shape dans la map
-        Handle(AIS_InteractiveObject) theShapeB =
+    // The first argument is an AIS_Point
+    if (!aShapeA.IsNull() &&
+        aShapeA->Type()==AIS_KOI_Datum &&
+        aShapeA->Signature()==1)
+    {
+        // The second argument must also be an AIS_Point
+        if (argc<5 || !GetMapOfAIS().IsBound2(argv[3]))
+        {
+          std::cout<<"vplane: error 2nd name doesn't exist in the GetMapOfAIS()\n";
+          return 1;
+        }
+        // Get shape from map
+        Handle(AIS_InteractiveObject) aShapeB =
           Handle(AIS_InteractiveObject)::DownCast (GetMapOfAIS().Find2(argv[3]));
-        // si B n'est pas un AIS_Point
-        if (theShapeB.IsNull() ||
-          (!(theShapeB->Type()==AIS_KOI_Datum && theShapeB->Signature()==1)))
+        // If B is not an AIS_Point
+        if (aShapeB.IsNull() ||
+          (!(aShapeB->Type()==AIS_KOI_Datum && aShapeB->Signature()==1)))
         {
-          di<<"vplane: error 2de object is expected to be an AIS_Point. "<<"\n";
+          std::cout<<"vplane: error 2nd object is expected to be an AIS_Point.\n";
           return 1;
         }
-        // le troisieme objet est un AIS_Point
-        if (!GetMapOfAIS().IsBound2(argv[4]) ) {di<<"vplane: error 3de name doesn't exist in the GetMapOfAIS()."<<"\n";return 1; }
-        // on recupere la shape dans la map
-        Handle(AIS_InteractiveObject) theShapeC =
+        // The third object is an AIS_Point
+        if (!GetMapOfAIS().IsBound2(argv[4]) ) 
+        {
+          std::cout<<"vplane: error 3d name doesn't exist in the GetMapOfAIS().\n";
+          return 1; 
+        }
+        // Get shape from map
+        Handle(AIS_InteractiveObject) aShapeC =
           Handle(AIS_InteractiveObject)::DownCast (GetMapOfAIS().Find2(argv[4]));
-        // si C n'est pas un AIS_Point
-        if (theShapeC.IsNull() ||
-          (!(theShapeC->Type()==AIS_KOI_Datum && theShapeC->Signature()==1)))
+        // If C is not an AIS_Point
+        if (aShapeC.IsNull() ||
+          (!(aShapeC->Type()==AIS_KOI_Datum && aShapeC->Signature()==1)))
         {
-          di<<"vplane: error 3de object is expected to be an AIS_Point. "<<"\n";
+          std::cout<<"vplane: error 3d object is expected to be an AIS_Point.\n";
           return 1;
         }
 
-        // Traitement des objets A,B,C
-        // Downcaste de AIS_IO en AIS_Point
-        Handle(AIS_Point) theAISPointA= *(Handle(AIS_Point)*)& theShapeA;
-        Handle(AIS_Point) theAISPointB= *(Handle(AIS_Point)*)& theShapeB;
-        Handle(AIS_Point) theAISPointC= *(Handle(AIS_Point)*)& theShapeC;
+        // Treatment of objects A, B, C
+        // Downcast an AIS_IO to AIS_Point
+        Handle(AIS_Point) anAISPointA = Handle(AIS_Point)::DownCast( aShapeA);
+        Handle(AIS_Point) anAISPointB = Handle(AIS_Point)::DownCast( aShapeB);
+        Handle(AIS_Point) anAISPointC = Handle(AIS_Point)::DownCast( aShapeC);
 
-        Handle(Geom_Point ) myGeomPointA=  theAISPointA->Component();
-        Handle(Geom_CartesianPoint ) myCartPointA= *((Handle(Geom_CartesianPoint)*)&  myGeomPointA);
-        //      Handle(Geom_CartesianPoint ) myCartPointA= *(Handle(Geom_CartesianPoint)*)& (theAISPointA->Component() ) ;
+        Handle(Geom_CartesianPoint ) aCartPointA = 
+          Handle(Geom_CartesianPoint)::DownCast( anAISPointA->Component());
 
-        Handle(Geom_Point ) myGeomPointB =  theAISPointB->Component();
-        Handle(Geom_CartesianPoint ) myCartPointB= *((Handle(Geom_CartesianPoint)*)&  theAISPointB);
-        //      Handle(Geom_CartesianPoint ) myCartPointB= *(Handle(Geom_CartesianPoint)*)& (theAISPointB->Component() ) ;
+        Handle(Geom_CartesianPoint ) aCartPointB = 
+          Handle(Geom_CartesianPoint)::DownCast( anAISPointB->Component());
 
-        Handle(Geom_Point ) myGeomPointBC=  theAISPointC->Component();
-        Handle(Geom_CartesianPoint ) myCartPointC= *((Handle(Geom_CartesianPoint)*)&  theAISPointC);
-        //      Handle(Geom_CartesianPoint ) myCartPointC= *(Handle(Geom_CartesianPoint)*)& (theAISPointC->Component() ) ;
+        Handle(Geom_CartesianPoint ) aCartPointC = 
+          Handle(Geom_CartesianPoint)::DownCast( anAISPointC->Component());
 
-        // Verification que les 3 points sont bien differents.
-        if (myCartPointB->X()==myCartPointA->X() && myCartPointB->Y()==myCartPointA->Y() && myCartPointB->Z()==myCartPointA->Z() ) {
+        // Verification that the three points are different
+        if(abs(aCartPointB->X()-aCartPointA->X())<=Precision::Confusion() &&
+           abs(aCartPointB->Y()-aCartPointA->Y())<=Precision::Confusion() &&
+           abs(aCartPointB->Z()-aCartPointA->Z())<=Precision::Confusion())
+        {
           // B=A
-          di<<"vplane error: same points"<<"\n";return 1;
+          std::cout<<"vplane error: same points"<<"\n";return 1;
         }
-        if (myCartPointC->X()==myCartPointA->X() && myCartPointC->Y()==myCartPointA->Y() && myCartPointC->Z()==myCartPointA->Z() ) {
+        if(abs(aCartPointC->X()-aCartPointA->X())<=Precision::Confusion() &&
+           abs(aCartPointC->Y()-aCartPointA->Y())<=Precision::Confusion() &&
+           abs(aCartPointC->Z()-aCartPointA->Z())<=Precision::Confusion())
+        {
           // C=A
-          di<<"vplane error: same points"<<"\n";return 1;
+          std::cout<<"vplane error: same points"<<"\n";return 1;
         }
-        if (myCartPointC->X()==myCartPointB->X() && myCartPointC->Y()==myCartPointB->Y() && myCartPointC->Z()==myCartPointB->Z() ) {
+        if(abs(aCartPointC->X()-aCartPointB->X())<=Precision::Confusion() &&
+           abs(aCartPointC->Y()-aCartPointB->Y())<=Precision::Confusion() &&
+           abs(aCartPointC->Z()-aCartPointB->Z())<=Precision::Confusion())
+        {
           // C=B
-          di<<"vplane error: same points"<<"\n";return 1;
+          std::cout<<"vplane error: same points"<<"\n";return 1;
         }
 
-        gp_Pnt A= myCartPointA->Pnt();
-        gp_Pnt B= myCartPointB->Pnt();
-        gp_Pnt C= myCartPointC->Pnt();
+        gp_Pnt A = aCartPointA->Pnt();
+        gp_Pnt B = aCartPointB->Pnt();
+        gp_Pnt C = aCartPointC->Pnt();
 
-        // Construction de l'AIS_Plane
+        // Construction of AIS_Plane
         GC_MakePlane MkPlane (A,B,C);
-        Handle(Geom_Plane) myGeomPlane = MkPlane.Value();
-        Handle(AIS_Plane)  myAISPlane = new AIS_Plane(myGeomPlane );
-        GetMapOfAIS().Bind (myAISPlane,name );
-        TheAISContext()->Display(myAISPlane);
+        Handle(Geom_Plane) aGeomPlane = MkPlane.Value();
+        Handle(AIS_Plane)  anAISPlane = new AIS_Plane(aGeomPlane );
+        GetMapOfAIS().Bind (anAISPlane,aName );
+        TheAISContext()->Display(anAISPlane);
       }
 
-      // si le premier argument est un AIS_Axis 2
-      // creation d'un plan orthogonal a l'axe passant par un point
-    else if (theShapeA->Type()==AIS_KOI_Datum && theShapeA->Signature()==2 ) {
-      // le deuxieme argument doit etre un AIS_Point
+      // The first argument is an AIS_Axis
+      // Creation of a plane orthogonal to the axis through a point
+    else if (aShapeA->Type()==AIS_KOI_Datum && aShapeA->Signature()==2 ) {
+      // The second argument should be an AIS_Point
       if (argc!=4 || !GetMapOfAIS().IsBound2(argv[3] ) )
       {
-        di<<"vplane: error 2de name doesn't exist in the GetMapOfAIS()."<<"\n";
+        std::cout<<"vplane: error 2d name doesn't exist in the GetMapOfAIS()\n";
         return 1;
       }
-      // on recupere la shape dans la map
-      Handle(AIS_InteractiveObject) theShapeB =
+      // Get shape from map
+      Handle(AIS_InteractiveObject) aShapeB =
         Handle(AIS_InteractiveObject)::DownCast (GetMapOfAIS().Find2(argv[3]));
-      // si B n'est pas un AIS_Point
-      if (theShapeB.IsNull() ||
-        (!(theShapeB->Type()==AIS_KOI_Datum && theShapeB->Signature()==1)))
+      // If B is not an AIS_Point
+      if (aShapeB.IsNull() ||
+        (!(aShapeB->Type()==AIS_KOI_Datum && aShapeB->Signature()==1)))
       {
-        di<<"vplane: error 2de object is expected to be an AIS_Point. "<<"\n";
+        std::cout<<"vplane: error 2d object is expected to be an AIS_Point\n";
         return 1;
       }
 
-      // Traitement des objets A et B
-      Handle(AIS_Axis) theAISAxisA= *(Handle(AIS_Axis)*)& theShapeA;
-      Handle(AIS_Point) theAISPointB= *(Handle(AIS_Point)*)& theShapeB;
-
-      Handle(Geom_Line ) myGeomLineA = theAISAxisA ->Component();
-      Handle(Geom_Point) myGeomPointB= theAISPointB->Component()  ;
+      // Treatment of objects A and B
+      Handle(AIS_Axis) anAISAxisA = Handle(AIS_Axis)::DownCast(aShapeA);
+      Handle(AIS_Point) anAISPointB = Handle(AIS_Point)::DownCast(aShapeB);
 
-      gp_Ax1 myAxis= myGeomLineA->Position();
-      Handle(Geom_CartesianPoint ) myCartPointB= *(Handle(Geom_CartesianPoint )*)& myGeomPointB;
+      Handle(Geom_Line ) aGeomLineA = anAISAxisA ->Component();
+      Handle(Geom_Point) aGeomPointB = anAISPointB->Component()  ;
 
-      // Pas de moyens de verifier que le point B n'est pas sur l'axe
+      gp_Ax1 anAxis = aGeomLineA->Position();
+      Handle(Geom_CartesianPoint) aCartPointB = 
+        Handle(Geom_CartesianPoint)::DownCast(aGeomPointB);
 
-      gp_Dir D=myAxis.Direction();
-      gp_Pnt B= myCartPointB->Pnt();
+      gp_Dir D =anAxis.Direction();
+      gp_Pnt B = aCartPointB->Pnt();
 
-      // Construction de l'AIS_Plane
-      Handle(Geom_Plane) myGeomPlane= new Geom_Plane(B,D);
-      Handle(AIS_Plane)  myAISPlane = new AIS_Plane(myGeomPlane,B );
-      GetMapOfAIS().Bind (myAISPlane,name );
-      TheAISContext()->Display(myAISPlane);
+      // Construction of AIS_Plane
+      Handle(Geom_Plane) aGeomPlane = new Geom_Plane(B,D);
+      Handle(AIS_Plane) anAISPlane = new AIS_Plane(aGeomPlane,B );
+      GetMapOfAIS().Bind (anAISPlane,aName );
+      TheAISContext()->Display(anAISPlane);
 
     }
-    // Si le premier argument est un AIS_Plane 7
-    // Creation d'un Plan parallele a ce plan passant par le point
-    else if (theShapeA->Type()==AIS_KOI_Datum && theShapeA->Signature()==7 ) {
-      // le deuxieme argument doit etre un AISPoint
-      if (argc!=4 || !GetMapOfAIS().IsBound2(argv[3] ) ) {
-        di<<"vplane: error 2de name doesn't exist in the GetMapOfAIS()."<<"\n";
+    // The first argumnet is an AIS_Plane
+    // Creation of a plane parallel to the plane passing through the point
+    else if (aShapeA->Type()==AIS_KOI_Datum && aShapeA->Signature()==7)
+    {
+      // The second argument should be an AIS_Point
+      if (argc!=4 || !GetMapOfAIS().IsBound2(argv[3]))
+      {
+        std::cout<<"vplane: error 2d name doesn't exist in the GetMapOfAIS()\n";
         return 1;
       }
-      // on recupere la shape dans la map
-      Handle(AIS_InteractiveObject) theShapeB =
+      // Get shape from map
+      Handle(AIS_InteractiveObject) aShapeB =
         Handle(AIS_InteractiveObject)::DownCast (GetMapOfAIS().Find2(argv[3]));
-      // si B n'est pas un AIS_Point
-      if (theShapeB.IsNull() ||
-        (!(theShapeB->Type()==AIS_KOI_Datum && theShapeB->Signature()==1)))
+      // B should be an AIS_Point
+      if (aShapeB.IsNull() ||
+         (!(aShapeB->Type()==AIS_KOI_Datum && aShapeB->Signature()==1)))
       {
-        di<<"vplane: error 2de object is expected to be an AIS_Point. "<<"\n";
+        std::cout<<"vplane: error 2d object is expected to be an AIS_Point\n";
         return 1;
       }
 
-      // Traitement des objets A et B
-      Handle(AIS_Plane) theAISPlaneA= *(Handle(AIS_Plane)*)& theShapeA;
-      Handle(AIS_Point) theAISPointB= *(Handle(AIS_Point)*)& theShapeB;
-
-      Handle (Geom_Plane) theNewGeomPlane= theAISPlaneA->Component();
-      Handle(Geom_Point) myGeomPointB= theAISPointB->Component()  ;
+      // Treatment of objects A and B
+      Handle(AIS_Plane) anAISPlaneA = Handle(AIS_Plane)::DownCast(aShapeA);
+      Handle(AIS_Point) anAISPointB = Handle(AIS_Point)::DownCast(aShapeB);
 
-      Handle(Geom_CartesianPoint ) myCartPointB= *(Handle(Geom_CartesianPoint )*)& myGeomPointB;
-      gp_Pnt B= myCartPointB->Pnt();
+      Handle(Geom_Plane) aNewGeomPlane= anAISPlaneA->Component();
+      Handle(Geom_Point) aGeomPointB = anAISPointB->Component();
 
-      // Construction de l'AIS_Plane
-      Handle(AIS_Plane)  myAISPlane = new AIS_Plane(theNewGeomPlane,B );
-      GetMapOfAIS().Bind (myAISPlane,name );
-      TheAISContext()->Display(myAISPlane);
+      Handle(Geom_CartesianPoint) aCartPointB = 
+        Handle(Geom_CartesianPoint)::DownCast(aGeomPointB);
+      gp_Pnt B= aCartPointB->Pnt();
 
+      // Construction of an AIS_Plane
+      Handle(AIS_Plane) anAISPlane = new AIS_Plane(aNewGeomPlane, B);
+      GetMapOfAIS().Bind (anAISPlane, aName);
+      TheAISContext()->Display(anAISPlane);
+    }
+    // Error
+    else
+    {
+      std::cout<<"vplane: error 1st object is not an AIS\n";
+      return 1;
     }
-    // Sinon erreur
-    else {di<<"vplane: error 1st object is not an AIS. "<<"\n";return 1;}
-
   }
-
-  // Il n'y a pas d'arguments
-  else {
-
-    // Fonction vplane
-    // Teste le constructeur AIS_Plane::AIS_Plane(Geom_Plane, Standard_Boolean )
-    if (!strcasecmp(argv[0] ,"vplane" ) ) {
+  // There are no arguments
+  else 
+  {
+    // Function vplane
+    // Test the constructor AIS_Plane::AIS_Plane(Geom_Plane, Standard_Boolean )
+    if (!strcasecmp(argv[0], "vplane"))
+    {
       TheAISContext()->OpenLocalContext();
-      myCurrentIndex=TheAISContext()->IndexOfCurrentLocal();
+      aCurrentIndex=TheAISContext()->IndexOfCurrentLocal();
 
-      // Active les modes Vertex, Edge et Face
-      TheAISContext()->ActivateStandardMode (AIS_Shape::SelectionType(1) );
-      TheAISContext()->ActivateStandardMode (AIS_Shape::SelectionType(2) );
-      TheAISContext()->ActivateStandardMode (AIS_Shape::SelectionType(4) );
-      di<<"Select a vertex, a face or an edge. "<<"\n";
+      // Active modes Vertex, Edge and Face
+      TheAISContext()->ActivateStandardMode (AIS_Shape::SelectionType(1));
+      TheAISContext()->ActivateStandardMode (AIS_Shape::SelectionType(2));
+      TheAISContext()->ActivateStandardMode (AIS_Shape::SelectionType(4));
+      std::cout<<"Select a vertex, a face or an edge\n";
 
-      // Boucle d'attente waitpick.
+      // Wait for picking
       Standard_Integer argcc = 5;
       const char *buff[] = { "VPick", "X", "VPickY","VPickZ", "VPickShape" };
       const char **argvv = (const char **) buff;
       while (ViewerMainLoop( argcc, argvv) ) { }
-      // fin de la boucle
+      // end of the loop
 
-      TopoDS_Shape ShapeA;
-      for(TheAISContext()->InitSelected() ;TheAISContext()->MoreSelected() ;TheAISContext()->NextSelected() ) {
-        ShapeA = TheAISContext()->SelectedShape();
+      TopoDS_Shape aShapeA;
+      for (TheAISContext()->InitSelected();
+           TheAISContext()->MoreSelected();
+           TheAISContext()->NextSelected())
+      {
+        aShapeA = TheAISContext()->SelectedShape();
       }
 
-      // ShapeA est un Vertex
-      if (ShapeA.ShapeType()==TopAbs_VERTEX ) {
-        TheAISContext()->DeactivateStandardMode (AIS_Shape::SelectionType(4) );
-        di<<" Select an edge or a different vertex."<<"\n";
+      // aShapeA is a Vertex
+      if (aShapeA.ShapeType()==TopAbs_VERTEX )
+      {
+        TheAISContext()->DeactivateStandardMode (AIS_Shape::SelectionType(4));
+        std::cout<<" Select an edge or a different vertex\n";
 
-        // Boucle d'attente waitpick.
+        // Wait for picking
         Standard_Integer argccc = 5;
         const char *bufff[] = { "VPick", "X", "VPickY","VPickZ", "VPickShape" };
         const char **argvvv = (const char **) bufff;
         while (ViewerMainLoop( argccc, argvvv) ) { }
-        // fin de la boucle
+        // end of the loop
 
-        TopoDS_Shape ShapeB;
-        for(TheAISContext()->InitSelected() ;TheAISContext()->MoreSelected() ;TheAISContext()->NextSelected() ) {
-          ShapeB = TheAISContext()->SelectedShape();
+        TopoDS_Shape aShapeB;
+        for (TheAISContext()->InitSelected();
+          TheAISContext()->MoreSelected();
+          TheAISContext()->NextSelected())
+        {
+          aShapeB = TheAISContext()->SelectedShape();
         }
-        // ShapeB est un Vertex
-        if (ShapeB.ShapeType()==TopAbs_VERTEX ) {
-          // Si A et B sont le meme point
-          if (ShapeB.IsSame(ShapeA) ) {di<<" vplane: error, same points selected"<<"\n";return 1; }
-          TheAISContext()->DeactivateStandardMode (AIS_Shape::SelectionType(2) );
-          di<<" Select a different vertex."<<"\n";
+        // aShapeB is a Vertex
+        if (aShapeB.ShapeType()==TopAbs_VERTEX)
+        {
+          // A and B are the same
+          if (aShapeB.IsSame(aShapeA))
+          {
+            std::cout<<" vplane: error, same points selected\n";
+            return 1;
+          }
+          TheAISContext()->DeactivateStandardMode (AIS_Shape::SelectionType(2));
+          std::cout<<" Select a different vertex\n";
 
-          // Boucle d'attente waitpick.
+          // Wait for picking
           Standard_Integer argcccc = 5;
           const char *buffff[] = { "VPick", "X", "VPickY","VPickZ", "VPickShape" };
           const char **argvvvv = (const char **) buffff;
           while (ViewerMainLoop( argcccc, argvvvv) ) { }
-          // fin de la boucle
+          // end of the loop
 
-          TopoDS_Shape ShapeC;
-          for(TheAISContext()->InitSelected() ;TheAISContext()->MoreSelected() ;TheAISContext()->NextSelected() ) {
-            ShapeC = TheAISContext()->SelectedShape();
+          TopoDS_Shape aShapeC;
+          for (TheAISContext()->InitSelected();
+               TheAISContext()->MoreSelected();
+               TheAISContext()->NextSelected())
+          {
+            aShapeC = TheAISContext()->SelectedShape();
+          }
+          // aShapeC is the same as A or B
+          if (aShapeC.IsSame(aShapeA)||aShapeC.IsSame(aShapeB))
+          {
+            std::cout<<" vplane: error, same points selected\n";
+            return 1;
           }
-          // ShapeC est aussi un vertex...
-          if (ShapeC.IsSame(ShapeA)||ShapeC.IsSame(ShapeB) ) {di<<" vplane: error, same points selected"<<"\n";return 1; }
-
-          // Fermeture du contexte local
-          TheAISContext()->CloseLocalContext(myCurrentIndex);
-
-          // Construction du plane
-          gp_Pnt A=BRep_Tool::Pnt(TopoDS::Vertex(ShapeA ) );
-          gp_Pnt B=BRep_Tool::Pnt(TopoDS::Vertex(ShapeB ) );
-          gp_Pnt C=BRep_Tool::Pnt(TopoDS::Vertex(ShapeC ) );
-          GC_MakePlane MkPlane(A,B,C);
-          Handle(Geom_Plane) theGeomPlane=MkPlane.Value();
-          Handle(AIS_Plane) myAISPlane=new AIS_Plane (theGeomPlane );
-          GetMapOfAIS().Bind (myAISPlane ,name );
-          TheAISContext()->Display(myAISPlane);
 
+          // Close the local context
+          TheAISContext()->CloseLocalContext(aCurrentIndex);
+
+          // Construction of plane
+          gp_Pnt A = BRep_Tool::Pnt(TopoDS::Vertex(aShapeA));
+          gp_Pnt B = BRep_Tool::Pnt(TopoDS::Vertex(aShapeB));
+          gp_Pnt C = BRep_Tool::Pnt(TopoDS::Vertex(aShapeC));
+          GC_MakePlane MkPlane(A, B, C);
+          Handle(Geom_Plane) aGeomPlane = MkPlane.Value();
+          Handle(AIS_Plane) anAISPlane = new AIS_Plane (aGeomPlane);
+          GetMapOfAIS().Bind (anAISPlane, aName);
+          TheAISContext()->Display(anAISPlane);
         }
-        // ShapeB est un edge
-        else  {
-          // il s'agit de verifier que le  vertex ShapeA n'est pas sur l'edge ShapeB
-          TopoDS_Edge EdgeB=TopoDS::Edge(ShapeB);
-          TopoDS_Vertex VertA=TopoDS::Vertex(ShapeA);
-
-          BRepExtrema_ExtPC OrthoProj (VertA, EdgeB );
-          if (OrthoProj.SquareDistance(1)<1e-6 ) {
-            // Le vertex est sur l'edge
-            di<<" vplane: error point is on the edge."<<"\n";return 1;
-          }
-          else {
-            // le vertex n'appartient pes a l'edge on peut construire le plane
-            // Fermeture du contexte local
-            TheAISContext()->CloseLocalContext(myCurrentIndex);
-            // Construction du plane
-            gp_Pnt A=BRep_Tool::Pnt(VertA );
-            TopoDS_Vertex VBa,VBb;
-            TopExp::Vertices(EdgeB ,VBa ,VBb );
-            gp_Pnt Ba=BRep_Tool::Pnt(VBa);
-            gp_Pnt Bb=BRep_Tool::Pnt(VBb);
-            GC_MakePlane MkPlane (A,Ba,Bb);
-            Handle(Geom_Plane) theGeomPlane=MkPlane.Value();
-            Handle(AIS_Plane) myAISPlane=new AIS_Plane (theGeomPlane );
-            GetMapOfAIS().Bind (myAISPlane ,name );
-            TheAISContext()->Display(myAISPlane);
+        // ShapeB is an edge
+        else
+        {
+          // Verify that the vertex is not on the edge ShapeB
+          TopoDS_Edge anEdgeB = TopoDS::Edge(aShapeB);
+          TopoDS_Vertex aVertA = TopoDS::Vertex(aShapeA);
 
+          BRepExtrema_ExtPC OrthoProj(aVertA, anEdgeB);
+          if (OrthoProj.SquareDistance(1)<Precision::Approximation())
+          {
+            // The vertex is on the edge
+            std::cout<<" vplane: error point is on the edge\n";
+            return 1;
+          }
+          else
+          {
+            // Close the local context
+            TheAISContext()->CloseLocalContext(aCurrentIndex);
+            // Construction of plane
+            gp_Pnt A = BRep_Tool::Pnt(aVertA);
+            TopoDS_Vertex aVBa, aVBb;
+            TopExp::Vertices(anEdgeB ,aVBa ,aVBb);
+            gp_Pnt aBa = BRep_Tool::Pnt(aVBa);
+            gp_Pnt aBb = BRep_Tool::Pnt(aVBb);
+            GC_MakePlane MkPlane (A, aBa, aBb);
+            Handle(Geom_Plane) aGeomPlane = MkPlane.Value();
+            Handle(AIS_Plane) anAISPlane = new AIS_Plane (aGeomPlane);
+            GetMapOfAIS().Bind (anAISPlane, aName);
+            TheAISContext()->Display(anAISPlane);
           }
-
         }
-
       }
-      // ShapeA est un edge
-      else if (ShapeA.ShapeType()==TopAbs_EDGE ) {
-
-        TheAISContext()->DeactivateStandardMode (AIS_Shape::SelectionType(4) );
-        TheAISContext()->DeactivateStandardMode (AIS_Shape::SelectionType(2) );
-        di<<" Select a vertex that don't belong to the edge."<<"\n";
+      // aShapeA is an edge
+      else if (aShapeA.ShapeType()==TopAbs_EDGE)
+      {
+        TheAISContext()->DeactivateStandardMode (AIS_Shape::SelectionType(4));
+        TheAISContext()->DeactivateStandardMode (AIS_Shape::SelectionType(2));
+        std::cout<<" Select a vertex that don't belong to the edge\n";
 
-        // Boucle d'attente waitpick.
+        // Wait for picking
         Standard_Integer argccc = 5;
         const char *bufff[] = { "VPick", "X", "VPickY","VPickZ", "VPickShape" };
         const char **argvvv = (const char **) bufff;
         while (ViewerMainLoop( argccc, argvvv) ) { }
-        // fin de la boucle
+        // end of the loop
 
-        TopoDS_Shape ShapeB;
-        for(TheAISContext()->InitSelected() ;TheAISContext()->MoreSelected() ;TheAISContext()->NextSelected() ) {
-          ShapeB = TheAISContext()->SelectedShape();
+        TopoDS_Shape aShapeB;
+        for (TheAISContext()->InitSelected();
+             TheAISContext()->MoreSelected();
+             TheAISContext()->NextSelected())
+        {
+          aShapeB = TheAISContext()->SelectedShape();
         }
-        // ShapeB est forcement un Vertex
-        // On verifie que le vertex ShapeB n'est pas sur l'edge ShapeA
-        TopoDS_Edge EdgeA=TopoDS::Edge(ShapeA);
-        TopoDS_Vertex VertB=TopoDS::Vertex(ShapeB);
-
-        BRepExtrema_ExtPC OrthoProj (VertB,EdgeA );
-        if (OrthoProj.SquareDistance(1)<1e-6) {
-          // Le vertex est sur l'edge
-          di<<" vplane: error point is on the edge."<<"\n";return 1;
+        // aShapeB should be a Vertex
+        // Check that the vertex aShapeB is not on the edge
+        TopoDS_Edge anEdgeA = TopoDS::Edge(aShapeA);
+        TopoDS_Vertex aVertB = TopoDS::Vertex(aShapeB);
+
+        BRepExtrema_ExtPC OrthoProj (aVertB, anEdgeA);
+        if (OrthoProj.SquareDistance(1)<Precision::Approximation())
+        {
+          // The vertex is on the edge
+          std::cout<<" vplane: error point is on the edge\n";
+          return 1;
         }
-        else {
-          // le vertex n'appartient pas a l'edge on peut construire le plane
-          // Fermeture du contexte local
-          TheAISContext()->CloseLocalContext(myCurrentIndex);
-          // Construction du plane
-          gp_Pnt B=BRep_Tool::Pnt(VertB );
-          TopoDS_Vertex VAa,VAb;
-          TopExp::Vertices(EdgeA ,VAa ,VAb );
-          gp_Pnt Aa=BRep_Tool::Pnt(VAa);
-          gp_Pnt Ab=BRep_Tool::Pnt(VAb);
+        else
+        {
+          // Close the local context
+          TheAISContext()->CloseLocalContext(aCurrentIndex);
+          // Construction of plane
+          gp_Pnt B = BRep_Tool::Pnt(aVertB);
+          TopoDS_Vertex aVAa, aVAb;
+          TopExp::Vertices(anEdgeA, aVAa, aVAb);
+          gp_Pnt Aa = BRep_Tool::Pnt(aVAa);
+          gp_Pnt Ab = BRep_Tool::Pnt(aVAb);
           GC_MakePlane MkPlane (B,Aa,Ab);
-          Handle(Geom_Plane) theGeomPlane=MkPlane.Value();
-          Handle(AIS_Plane) myAISPlane=new AIS_Plane (theGeomPlane );
-          GetMapOfAIS().Bind (myAISPlane ,name );
-          TheAISContext()->Display(myAISPlane);
-
+          Handle(Geom_Plane) aGeomPlane = MkPlane.Value();
+          Handle(AIS_Plane) anAISPlane = new AIS_Plane (aGeomPlane);
+          GetMapOfAIS().Bind (anAISPlane ,aName);
+          TheAISContext()->Display(anAISPlane);
         }
-
-
       }
-      // ShapeA est une Face
-      else {
-        // Fermeture du contexte local: Plus rien a selectionner
-        TheAISContext()->CloseLocalContext(myCurrentIndex);
-        // Construction du plane
-        TopoDS_Face myFace=TopoDS::Face(ShapeA);
-        BRepAdaptor_Surface mySurface (myFace, Standard_False );
-        if (mySurface.GetType()==GeomAbs_Plane ) {
-          gp_Pln myPlane=mySurface.Plane();
-          Handle(Geom_Plane) theGeomPlane=new Geom_Plane (myPlane );
-          Handle(AIS_Plane) myAISPlane=new AIS_Plane (theGeomPlane );
-          GetMapOfAIS().Bind (myAISPlane ,name );
-          TheAISContext()->Display(myAISPlane);
-
+      // aShapeA is a Face
+      else
+      {
+        // Close the local context: nothing to select
+        TheAISContext()->CloseLocalContext(aCurrentIndex);
+        // Construction of plane
+        TopoDS_Face aFace = TopoDS::Face(aShapeA);
+        BRepAdaptor_Surface aSurface (aFace, Standard_False);
+        if (aSurface.GetType()==GeomAbs_Plane)
+        {
+          gp_Pln aPlane = aSurface.Plane();
+          Handle(Geom_Plane) aGeomPlane = new Geom_Plane(aPlane);
+          Handle(AIS_Plane) anAISPlane = new AIS_Plane(aGeomPlane);
+          GetMapOfAIS().Bind (anAISPlane, aName);
+          TheAISContext()->Display(anAISPlane);
         }
-        else {
-          di<<" vplane: error"<<"\n";return 1;
+        else
+        {
+          std::cout<<" vplane: error\n";
+          return 1;
         }
-
       }
-
     }
 
-    // Fonction vPlanePara
+    // Function vPlanePara
     // ===================
-    // teste le constructeur AIS_Plane::AIS_Plane(Geom_Plane,gp_Pnt )
-    else if (!strcasecmp(argv[0] ,"vplanepara" )) {
-
+    // test the constructor AIS_Plane::AIS_Plane(Geom_Plane,gp_Pnt)
+    else if (!strcasecmp(argv[0], "vplanepara"))
+    {
       TheAISContext()->OpenLocalContext();
-      myCurrentIndex=TheAISContext()->IndexOfCurrentLocal();
+      aCurrentIndex = TheAISContext()->IndexOfCurrentLocal();
 
-      // Active les modes Vertex et Face
-      TheAISContext()->ActivateStandardMode (AIS_Shape::SelectionType(1) );
-      TheAISContext()->ActivateStandardMode (AIS_Shape::SelectionType(4) );
-      di<<" Select a vertex or a face."<<"\n";
+      // Activate modes Vertex and Face
+      TheAISContext()->ActivateStandardMode (AIS_Shape::SelectionType(1));
+      TheAISContext()->ActivateStandardMode (AIS_Shape::SelectionType(4));
+      std::cout<<" Select a vertex or a face\n";
 
-      // Boucle d'attente waitpick.
+      // Wait for picking
       Standard_Integer argcc = 5;
       const char *buff[] = { "VPick", "X", "VPickY","VPickZ", "VPickShape" };
       const char **argvv = (const char **) buff;
       while (ViewerMainLoop( argcc, argvv) ) { }
-      // fin de la boucle
+      // end of the loop
 
-      TopoDS_Shape ShapeA;
-      for(TheAISContext()->InitSelected() ;TheAISContext()->MoreSelected() ;TheAISContext()->NextSelected() ) {
-        ShapeA = TheAISContext()->SelectedShape();
+      TopoDS_Shape aShapeA;
+      for (TheAISContext()->InitSelected();
+           TheAISContext()->MoreSelected();
+           TheAISContext()->NextSelected())
+      {
+        aShapeA = TheAISContext()->SelectedShape();
       }
 
-      if (ShapeA.ShapeType()==TopAbs_VERTEX ) {
-        // ShapeA est un vertex
-        // On desactive le mode Vertex
-        TheAISContext()->DeactivateStandardMode (AIS_Shape::SelectionType(1) );
-        di<<" Select a face."<<"\n";
+      if (aShapeA.ShapeType()==TopAbs_VERTEX )
+      {
+        // aShapeA is a vertex
+        // Deactivate the mode Vertex
+        TheAISContext()->DeactivateStandardMode (AIS_Shape::SelectionType(1));
+        std::cout<<" Select a face\n";
 
-        // Boucle d'attente waitpick.
+        // Wait for picking
         Standard_Integer argccc = 5;
         const char *bufff[] = { "VPick", "X", "VPickY","VPickZ", "VPickShape" };
         const char **argvvv = (const char **) bufff;
         while (ViewerMainLoop( argccc, argvvv) ) { }
-        // fin de la boucle
+        // end of the loop
 
-        TopoDS_Shape ShapeB;
-        for(TheAISContext()->InitSelected() ;TheAISContext()->MoreSelected() ;TheAISContext()->NextSelected() ) {
-          // Le vertex ShapeA peut etre dans la Face ShapeB
-          ShapeB = TheAISContext()->SelectedShape();
+        TopoDS_Shape aShapeB;
+        for (TheAISContext()->InitSelected();
+             TheAISContext()->MoreSelected();
+             TheAISContext()->NextSelected())
+        {
+          // A vertex ShapeA can be on Face ShapeB
+          aShapeB = TheAISContext()->SelectedShape();
         }
 
-        // Fermeture du context local
-        TheAISContext()->CloseLocalContext(myCurrentIndex);
-
-        // Construction du plane
-        gp_Pnt A=BRep_Tool::Pnt(TopoDS::Vertex(ShapeA ) );
-
-        TopoDS_Face myFace=TopoDS::Face(ShapeB);
-        BRepAdaptor_Surface mySurface (myFace, Standard_False );
-        if (mySurface.GetType()==GeomAbs_Plane ) {
-          gp_Pln myPlane=mySurface.Plane();
-          // construit un plan parallele a theGeomPlane passant par A
-          myPlane.SetLocation(A);
-          Handle(Geom_Plane) theGeomPlane=new Geom_Plane (myPlane );
-          Handle(AIS_Plane) myAISPlane=new AIS_Plane (theGeomPlane ,A );
-          GetMapOfAIS().Bind (myAISPlane ,name );
-          TheAISContext()->Display(myAISPlane);
+        // Close the local context
+        TheAISContext()->CloseLocalContext(aCurrentIndex);
 
+        // Construction of plane
+        gp_Pnt A = BRep_Tool::Pnt(TopoDS::Vertex(aShapeA));
+
+        TopoDS_Face aFace = TopoDS::Face(aShapeB);
+        BRepAdaptor_Surface aSurface (aFace, Standard_False);
+        if (aSurface.GetType()==GeomAbs_Plane )
+        {
+          gp_Pln aPlane = aSurface.Plane();
+          // Construct a plane parallel to aGeomPlane through A
+          aPlane.SetLocation(A);
+          Handle(Geom_Plane) aGeomPlane = new Geom_Plane (aPlane);
+          Handle(AIS_Plane) aAISPlane = new AIS_Plane (aGeomPlane, A);
+          GetMapOfAIS().Bind (aAISPlane ,aName);
+          TheAISContext()->Display(aAISPlane);
         }
-        else {
-          di<<" vplane: error"<<"\n";return 1;
+        else
+        {
+          std::cout<<" vplanepara: error\n";
+          return 1;
         }
-
       }
-      else{
-        // ShapeA est une Face
-        // On desactive le mode Face
-        TheAISContext()->DeactivateStandardMode (AIS_Shape::SelectionType(4) );
-        di<<" Select a vertex."<<"\n";
+      else
+      {
+        // ShapeA is a Face
+        // Deactive the mode Face
+        TheAISContext()->DeactivateStandardMode (AIS_Shape::SelectionType(4));
+        std::cout<<" Select a vertex\n";
 
-        // Boucle d'attente waitpick.
+        // Wait for picking
         Standard_Integer argccc = 5;
         const char *bufff[] = { "VPick", "X", "VPickY","VPickZ", "VPickShape" };
         const char **argvvv = (const char **) bufff;
         while (ViewerMainLoop( argccc, argvvv) ) { }
-        // fin de la boucle
+        // end of the loop
 
-        TopoDS_Shape ShapeB;
-        for(TheAISContext()->InitSelected() ;TheAISContext()->MoreSelected() ;TheAISContext()->NextSelected() ) {
-          // Le vertex ShapeB peut etre dans la Face ShapeA
-          ShapeB = TheAISContext()->SelectedShape();
+        TopoDS_Shape aShapeB;
+        for (TheAISContext()->InitSelected();
+             TheAISContext()->MoreSelected();
+             TheAISContext()->NextSelected())
+        {
+          // A vertex ShapeB can be on Face ShapeA
+          aShapeB = TheAISContext()->SelectedShape();
         }
-        // Fermeture du context local
-        TheAISContext()->CloseLocalContext(myCurrentIndex);
-
-        // Construction du plane
-        gp_Pnt B=BRep_Tool::Pnt(TopoDS::Vertex(ShapeB ) );
-
-        TopoDS_Face myFace=TopoDS::Face(ShapeA);
-        BRepAdaptor_Surface mySurface (myFace, Standard_False );
-        if (mySurface.GetType()==GeomAbs_Plane ) {
-          gp_Pln myPlane=mySurface.Plane();
-          myPlane.SetLocation(B);
-          Handle(Geom_Plane) theGeomPlane=new Geom_Plane (myPlane );
-          // construit un plan parallele a theGeomPlane passant par B
-          Handle(AIS_Plane) myAISPlane=new AIS_Plane (theGeomPlane ,B );
-          GetMapOfAIS().Bind (myAISPlane ,name );
-          TheAISContext()->Display(myAISPlane);
+        // Close the local context
+        TheAISContext()->CloseLocalContext(aCurrentIndex);
 
+        // Construction of plane
+        gp_Pnt B = BRep_Tool::Pnt(TopoDS::Vertex(aShapeB));
+
+        TopoDS_Face aFace=TopoDS::Face(aShapeA);
+        BRepAdaptor_Surface aSurface (aFace, Standard_False);
+        if (aSurface.GetType()==GeomAbs_Plane )
+        {
+          gp_Pln aPlane = aSurface.Plane();
+          aPlane.SetLocation(B);
+          Handle(Geom_Plane) aGeomPlane = new Geom_Plane (aPlane);
+          // Construct a plane parallel to aGeomPlane through B
+          Handle(AIS_Plane) anAISPlane = new AIS_Plane (aGeomPlane, B);
+          GetMapOfAIS().Bind (anAISPlane, aName);
+          TheAISContext()->Display(anAISPlane);
         }
-        else {
-          di<<" vplane: error"<<"\n";return 1;
+        else
+        {
+          std::cout<<" vplanepara: error"<<"\n";return 1;
         }
-
       }
-
     }
 
-    // Fonction vplaneortho
+    // Function vplaneortho
     // ====================
-    // teste le constructeur AIS_Plane::AIS_Plane(Geom_Plane,gp_Pnt,gp_Pnt,gp_Pnt)
-    else {
-
+    // test the constructor AIS_Plane::AIS_Plane(Geom_Plane,gp_Pnt,gp_Pnt,gp_Pnt)
+    else
+    {
       TheAISContext()->OpenLocalContext();
-      myCurrentIndex=TheAISContext()->IndexOfCurrentLocal();
+      aCurrentIndex = TheAISContext()->IndexOfCurrentLocal();
 
-      // Active les modes Edge et Face
-      TheAISContext()->ActivateStandardMode (AIS_Shape::SelectionType(2) );
-      TheAISContext()->ActivateStandardMode (AIS_Shape::SelectionType(4) );
-      di<<" Select a face and an edge coplanar."<<"\n";
+      // Activate the modes Edge and Face
+      TheAISContext()->ActivateStandardMode (AIS_Shape::SelectionType(2));
+      TheAISContext()->ActivateStandardMode (AIS_Shape::SelectionType(4));
+      std::cout<<" Select a face and an edge coplanar\n";
 
-      // Boucle d'attente waitpick.
+      // Wait for picking
       Standard_Integer argcc = 5;
       const char *buff[] = { "VPick", "X", "VPickY","VPickZ", "VPickShape" };
       const char **argvv = (const char **) buff;
       while (ViewerMainLoop( argcc, argvv) ) { }
-      // fin de la boucle
+      // end of the loop
 
-      TopoDS_Shape ShapeA;
-      for(TheAISContext()->InitSelected() ;TheAISContext()->MoreSelected() ;TheAISContext()->NextSelected() ) {
-        ShapeA = TheAISContext()->SelectedShape();
+      TopoDS_Shape aShapeA;
+      for (TheAISContext()->InitSelected();
+           TheAISContext()->MoreSelected();
+           TheAISContext()->NextSelected())
+      {
+        aShapeA = TheAISContext()->SelectedShape();
       }
 
-      if (ShapeA.ShapeType()==TopAbs_EDGE ) {
-        // ShapeA est un edge, on desactive le mode edge...
-        TheAISContext()->DeactivateStandardMode (AIS_Shape::SelectionType(2) );
-        di<<" Select a face."<<"\n";
+      if (aShapeA.ShapeType()==TopAbs_EDGE )
+      {
+        // ShapeA is an edge, deactivate the mode Edge...
+        TheAISContext()->DeactivateStandardMode (AIS_Shape::SelectionType(2));
+        std::cout<<" Select a face\n";
 
-        // Boucle d'attente waitpick.
+        // Wait for picking
         Standard_Integer argccc = 5;
         const char *bufff[] = { "VPick", "X", "VPickY","VPickZ", "VPickShape" };
         const char **argvvv = (const char **) bufff;
         while (ViewerMainLoop( argccc, argvvv) ) { }
-        // fin de la boucle
+        // end of the loop
 
-        TopoDS_Shape ShapeB;
-        for(TheAISContext()->InitSelected() ;TheAISContext()->MoreSelected() ;TheAISContext()->NextSelected() ) {
-          // L'edge ShapeA peut etre dans la Face ShapeB
-          ShapeB = TheAISContext()->SelectedShape();
+        TopoDS_Shape aShapeB;
+        for (TheAISContext()->InitSelected();
+             TheAISContext()->MoreSelected();
+             TheAISContext()->NextSelected())
+        {
+          // Edge ShapeA can be on Face ShapeB
+          aShapeB = TheAISContext()->SelectedShape();
         }
 
-        // Fermeture du context local
-        TheAISContext()->CloseLocalContext(myCurrentIndex);
+        // Close the local context
+        TheAISContext()->CloseLocalContext(aCurrentIndex);
 
-        // Construction du plane
-        TopoDS_Edge  EdgeA=TopoDS::Edge(ShapeA);
-        TopoDS_Vertex VAa,VAb;
-        // vi
-        TopExp::Vertices(EdgeA ,VAa ,VAb );
-        gp_Pnt Aa=BRep_Tool::Pnt(VAa);
-        gp_Pnt Ab=BRep_Tool::Pnt(VAb);
-        gp_Vec ab  (Aa,Ab);
+        // Construction of plane
+        TopoDS_Edge anEdgeA = TopoDS::Edge(aShapeA);
+        TopoDS_Vertex aVAa, aVAb;
+        TopExp::Vertices(anEdgeA, aVAa, aVAb);
+        gp_Pnt Aa = BRep_Tool::Pnt(aVAa);
+        gp_Pnt Ab = BRep_Tool::Pnt(aVAb);
+        gp_Vec ab (Aa,Ab);
 
         gp_Dir Dab (ab);
-        // Creation de mon axe de rotation
-        gp_Ax1 myRotAxis (Aa,Dab);
-
-        TopoDS_Face myFace=TopoDS::Face(ShapeB);
-        // Il faut imperativement que l'edge soit parallele a la face
-        // vi
-        BRepExtrema_ExtPF myHauteurA (VAa , myFace );
-        BRepExtrema_ExtPF myHauteurB (VAb , myFace );
-        // on compare les deux hauteurs a la tolerance pres
-        if ( fabs(sqrt(myHauteurA.SquareDistance(1)) - sqrt (myHauteurB.SquareDistance(1)) )>0.1 ) {
-          // l'edge n'est pas parallele a la face
-          di<<" vplaneOrtho error: l'edge n'est pas parallele a la face."<<"\n";return 1;
+        // Creation of rotation axis
+        gp_Ax1 aRotAxis (Aa,Dab);
+
+        TopoDS_Face aFace = TopoDS::Face(aShapeB);
+        // The edge must be parallel to the face
+        BRepExtrema_ExtPF aHeightA (aVAa, aFace);
+        BRepExtrema_ExtPF aHeightB (aVAb, aFace);
+        // Compare to heights
+        if (fabs(sqrt(aHeightA.SquareDistance(1)) - sqrt(aHeightB.SquareDistance(1)))
+            >Precision::Confusion())
+        {
+          // the edge is not parallel to the face
+          std::cout<<" vplaneortho error: the edge is not parallel to the face\n";
+          return 1;
         }
-        // l'edge est OK
-        BRepAdaptor_Surface mySurface (myFace, Standard_False );
-        if (mySurface.GetType()==GeomAbs_Plane ) {
-          gp_Pln myPlane=mySurface.Plane();
-          // On effectue une rotation d'1/2 tour autour de l'axe de rotation
-          myPlane.Rotate(myRotAxis , M_PI/2 );
-
-          Handle(Geom_Plane) theGeomPlane=new Geom_Plane (myPlane );
-          // construit un plan parallele a theGeomPlane contenant l'edgeA (De centre le milieu de l'edgeA)
-          gp_Pnt theMiddle ((Aa.X()+Ab.X() )/2 ,(Aa.Y()+Ab.Y() )/2 ,(Aa.Z()+Ab.Z() )/2 );
-          Handle(AIS_Plane) myAISPlane=new AIS_Plane (theGeomPlane ,theMiddle );
-          GetMapOfAIS().Bind (myAISPlane ,name );
-          TheAISContext()->Display(myAISPlane);
-
+        // the edge is OK
+        BRepAdaptor_Surface aSurface (aFace, Standard_False);
+        if (aSurface.GetType()==GeomAbs_Plane)
+        {
+          gp_Pln aPlane = aSurface.Plane();
+          // It rotates a half turn round the axis of rotation
+          aPlane.Rotate(aRotAxis , M_PI/2);
+
+          Handle(Geom_Plane) aGeomPlane = new Geom_Plane (aPlane);
+          // constructed aGeomPlane parallel to a plane containing the edge (center mid-edge)
+          gp_Pnt aMiddle ((Aa.X()+Ab.X() )/2 ,(Aa.Y()+Ab.Y() )/2 ,(Aa.Z()+Ab.Z() )/2 );
+          Handle(AIS_Plane) anAISPlane = new AIS_Plane (aGeomPlane, aMiddle);
+          GetMapOfAIS().Bind (anAISPlane, aName);
+          TheAISContext()->Display(anAISPlane);
         }
-        else {
-          di<<" vplaneOrtho: error"<<"\n";return 1;
+        else
+        {
+          std::cout<<" vplaneortho: error\n";
+          return 1;
         }
-
       }
+      else
+      {
+        // ShapeA is a Face, deactive the mode Face.
+        TheAISContext()->DeactivateStandardMode (AIS_Shape::SelectionType(4));
+        std::cout<<" Select an edge\n";
 
-      else {
-        // ShapeA est une Face, on desactive le mode face.
-        TheAISContext()->DeactivateStandardMode (AIS_Shape::SelectionType(4) );
-        di<<" Select an edge."<<"\n";
-
-        // Boucle d'attente waitpick.
+        // Wait for picking
         Standard_Integer argccc = 5;
         const char *bufff[] = { "VPick", "X", "VPickY","VPickZ", "VPickShape" };
         const char **argvvv = (const char **) bufff;
         while (ViewerMainLoop( argccc, argvvv) ) { }
-        // fin de la boucle
+        // end of the loop
 
-        TopoDS_Shape ShapeB;
-        for(TheAISContext()->InitSelected() ;TheAISContext()->MoreSelected() ;TheAISContext()->NextSelected() ) {
-          // L'edge ShapeB peut etre dans la Face ShapeA
-          ShapeB = TheAISContext()->SelectedShape();
+        TopoDS_Shape aShapeB;
+        for (TheAISContext()->InitSelected();
+             TheAISContext()->MoreSelected();
+             TheAISContext()->NextSelected())
+        {
+          // Edge ShapeB can be on Face ShapeA
+          aShapeB = TheAISContext()->SelectedShape();
         }
-
-        // Fermeture du context local
-        TheAISContext()->CloseLocalContext(myCurrentIndex);
-
-        // Construction du plane
-        TopoDS_Edge  EdgeB=TopoDS::Edge(ShapeB);
-        TopoDS_Vertex VBa,VBb;
-        TopExp::Vertices(EdgeB ,VBa ,VBb );
-        gp_Pnt Ba=BRep_Tool::Pnt(VBa);
-        gp_Pnt Bb=BRep_Tool::Pnt(VBb);
-        gp_Vec ab  (Ba,Bb);
+        // Close the local context
+        TheAISContext()->CloseLocalContext(aCurrentIndex);
+
+        // Construction of plane
+        TopoDS_Edge anEdgeB = TopoDS::Edge(aShapeB);
+        TopoDS_Vertex aVBa, aVBb;
+        TopExp::Vertices(anEdgeB, aVBa, aVBb);
+        gp_Pnt aBa = BRep_Tool::Pnt(aVBa);
+        gp_Pnt aBb = BRep_Tool::Pnt(aVBb);
+        gp_Vec ab (aBa,aBb);
         gp_Dir Dab (ab);
-        // Creation de mon axe de rotation
-        gp_Ax1 myRotAxis (Ba,Dab);
-
-        TopoDS_Face myFace=TopoDS::Face(ShapeA);
-        // Il faut imperativement que l'edge soit parallele a la face
-        BRepExtrema_ExtPF myHauteurA (VBa , myFace );
-        BRepExtrema_ExtPF myHauteurB (VBb , myFace );
-        // on compare les deux hauteurs a la tolerance pres
-        if ( fabs(sqrt(myHauteurA.SquareDistance(1)) - sqrt(myHauteurB.SquareDistance(1)) )>0.1 ) {
-          // l'edge n'est pas parallele a la face
-          di<<" vplaneOrtho error: l'edge n'est pas parallele a la face."<<"\n";return 1;
+        // Creation of rotation axe
+        gp_Ax1 aRotAxis (aBa,Dab);
+
+        TopoDS_Face aFace = TopoDS::Face(aShapeA);
+        // The edge must be parallel to the face
+        BRepExtrema_ExtPF aHeightA (aVBa, aFace);
+        BRepExtrema_ExtPF aHeightB (aVBb, aFace);
+        // Comparing the two heights
+        if (fabs(sqrt(aHeightA.SquareDistance(1)) - sqrt(aHeightB.SquareDistance(1)))
+            >Precision::Confusion())
+        {
+          // the edge is not parallel to the face
+          std::cout<<" vplaneortho error: the edge is not parallel to the face\n";
+          return 1;
         }
-        // l'edge est OK
-        BRepAdaptor_Surface mySurface (myFace, Standard_False );
-        if (mySurface.GetType()==GeomAbs_Plane ) {
-          gp_Pln myPlane=mySurface.Plane();
-          // On effectue une rotation d'1/2 tour autour de l'axe de rotation
-          myPlane.Rotate(myRotAxis , M_PI/2  );
-          Handle(Geom_Plane) theGeomPlane=new Geom_Plane (myPlane );
-          // construit un plan parallele a theGeomPlane contenant l'edgeA (De centre le milieu de l'edgeA)
-          gp_Pnt theMiddle ((Ba.X()+Bb.X() )/2 , (Ba.Y()+Bb.Y() )/2 , (Ba.Z()+Bb.Z() )/2 );
-          Handle(AIS_Plane) myAISPlane=new AIS_Plane (theGeomPlane ,theMiddle );
-          GetMapOfAIS().Bind (myAISPlane ,name );
-          TheAISContext()->Display(myAISPlane);
-
+        // The edge is OK
+        BRepAdaptor_Surface aSurface (aFace, Standard_False);
+        if (aSurface.GetType()==GeomAbs_Plane)
+        {
+          gp_Pln aPlane = aSurface.Plane();
+          // It rotates a half turn round the axis of rotation
+          aPlane.Rotate(aRotAxis , M_PI/2);
+          Handle(Geom_Plane) aGeomPlane = new Geom_Plane (aPlane);
+          // constructed aGeomPlane parallel to a plane containing the edge theGeomPlane (center mid-edge)
+          gp_Pnt aMiddle ((aBa.X()+aBb.X() )/2 , (aBa.Y()+aBb.Y() )/2 , (aBa.Z()+aBb.Z() )/2 );
+          Handle(AIS_Plane) anAISPlane = new AIS_Plane (aGeomPlane, aMiddle);
+          GetMapOfAIS().Bind (anAISPlane ,aName);
+          TheAISContext()->Display(anAISPlane);
         }
-        else {
-          di<<" vplaneOrtho: error"<<"\n";return 1;
+        else
+        {
+          std::cout<<" vplaneortho: error\n";
+          return 1;
         }
-
       }
-
     }
-
   }
   return 0;
-
 }
 
 
@@ -1997,7 +2068,7 @@ static int VCircleBuilder(Draw_Interpretor& di, Standard_Integer argc, const cha
     // Activate selection mode for vertices and faces
     TheAISContext()->ActivateStandardMode (AIS_Shape::SelectionType(1) );
     TheAISContext()->ActivateStandardMode (AIS_Shape::SelectionType(4) );
-    std::cout << " Select a vertex or a face.\n";
+    std::cout << " Select a vertex or a face\n";
 
     // Wait for picking
     Standard_Integer argcc = 5;
@@ -2018,7 +2089,7 @@ static int VCircleBuilder(Draw_Interpretor& di, Standard_Integer argc, const cha
     if (ShapeA.ShapeType() == TopAbs_VERTEX ) 
     {
       TheAISContext()->DeactivateStandardMode (AIS_Shape::SelectionType(4) );
-      std::cout << " Select a different vertex.\n";
+      std::cout << " Select a different vertex\n";
 
       TopoDS_Shape ShapeB;
       do 
@@ -2039,7 +2110,7 @@ static int VCircleBuilder(Draw_Interpretor& di, Standard_Integer argc, const cha
       } while(ShapeB.IsSame(ShapeA) );
 
       // Selection of ShapeC
-      std::cout << " Select the last vertex.\n";
+      std::cout << " Select the last vertex\n";
       TopoDS_Shape ShapeC;
       do 
       {
@@ -2087,9 +2158,9 @@ static int VCircleBuilder(Draw_Interpretor& di, Standard_Integer argc, const cha
 
     }
     // Shape is a face
-    else  
+    else
     {
-      std::cout << " Select a vertex (in your face).\n";
+      std::cout << " Select a vertex (in your face)\n";
       TheAISContext()->DeactivateStandardMode (AIS_Shape::SelectionType(4) );
 
       TopoDS_Shape ShapeB;
@@ -2158,6 +2229,7 @@ static int VCircleBuilder(Draw_Interpretor& di, Standard_Integer argc, const cha
   return 0;
 }
 
+
 //===============================================================================================
 //function : VDrawText
 //author   : psn
@@ -3811,6 +3883,321 @@ static Standard_Integer VSetSelectionMode(Draw_Interpretor& di,
   return 0;
 }
 
+//==========================================================================
+//class   : Triangle 
+//purpose : creates Triangle based on AIS_InteractiveObject. 
+//          This class was implemented for testing Select3D_SensitiveTriangle
+//===========================================================================
+DEFINE_STANDARD_HANDLE(Triangle, AIS_InteractiveObject)
+class Triangle: public AIS_InteractiveObject 
+{
+public: 
+  // CASCADE RTTI
+  DEFINE_STANDARD_RTTI(FilledCircle); 
+  Triangle (const gp_Pnt& theP1, 
+            const gp_Pnt& theP2, 
+            const gp_Pnt& theP3);
+protected:
+  void Compute (  const Handle(PrsMgr_PresentationManager3d)& thePresentationManager,
+                  const Handle(Prs3d_Presentation)& thePresentation,
+                  const Standard_Integer theMode);
+
+  void ComputeSelection (  const Handle(SelectMgr_Selection)& theSelection, 
+                           const Standard_Integer theMode);
+private: 
+  gp_Pnt myPoint1;
+  gp_Pnt myPoint2;
+  gp_Pnt myPoint3;
+};
+IMPLEMENT_STANDARD_HANDLE(Triangle, AIS_InteractiveObject)
+IMPLEMENT_STANDARD_RTTIEXT(Triangle, AIS_InteractiveObject)
+
+Triangle::Triangle (const gp_Pnt& theP1,
+                    const gp_Pnt& theP2,
+                    const gp_Pnt& theP3)
+{
+  myPoint1 = theP1;
+  myPoint2 = theP2;
+  myPoint3 = theP3;
+}
+
+void Triangle::Compute(const Handle(PrsMgr_PresentationManager3d)& thePresentationManager,
+                       const Handle(Prs3d_Presentation)& thePresentation,
+                       const Standard_Integer theMode)
+{
+  thePresentation->Clear();
+
+  BRepBuilderAPI_MakeEdge anEdgeMaker1(myPoint1, myPoint2),
+                          anEdgeMaker2(myPoint2, myPoint3),
+                          anEdgeMaker3(myPoint3, myPoint1);
+
+  TopoDS_Edge anEdge1 = anEdgeMaker1.Edge(),
+              anEdge2 = anEdgeMaker2.Edge(),
+              anEdge3 = anEdgeMaker3.Edge();
+  if(anEdge1.IsNull() || anEdge2.IsNull() || anEdge3.IsNull())
+    return;
+
+  BRepBuilderAPI_MakeWire aWireMaker(anEdge1, anEdge2, anEdge3);
+  TopoDS_Wire aWire = aWireMaker.Wire();
+  if(aWire.IsNull()) return;
+
+  BRepBuilderAPI_MakeFace aFaceMaker(aWire);
+  TopoDS_Face aFace = aFaceMaker.Face();
+  if(aFace.IsNull()) return;
+
+  StdPrs_ShadedShape::Add(thePresentation, aFace, myDrawer);
+}
+
+void Triangle::ComputeSelection(const Handle(SelectMgr_Selection)& theSelection, 
+                                const Standard_Integer theMode)
+{
+  Handle(SelectMgr_EntityOwner) anEntityOwner = new SelectMgr_EntityOwner(this);
+  Handle(Select3D_SensitiveTriangle) aSensTriangle = 
+    new Select3D_SensitiveTriangle(anEntityOwner, myPoint1, myPoint2, myPoint3);
+  theSelection->Add(aSensTriangle);
+}
+
+//===========================================================================
+//function : VTriangle 
+//Draw arg : vtriangle Name PointName PointName PointName
+//purpose  : creates and displays Triangle
+//===========================================================================
+
+//function: IsPoint
+//purpose : checks if the object with theName is AIS_Point, 
+//          if yes initialize thePoint from MapOfAIS
+Standard_Boolean IsPoint (const TCollection_AsciiString& theName,
+                          Handle(AIS_Point)& thePoint)
+{
+  Handle(AIS_InteractiveObject) anObject = 
+    Handle(AIS_InteractiveObject)::DownCast(GetMapOfAIS().Find2(theName));
+  if(anObject.IsNull() || 
+     anObject->Type() != AIS_KOI_Datum || 
+     anObject->Signature() != 1)
+  {
+    return Standard_False;
+  }
+  thePoint = Handle(AIS_Point)::DownCast(anObject);
+  if(thePoint.IsNull())
+    return Standard_False;
+  return Standard_True;
+}
+
+//function: IsMatch
+//purpose: checks if thePoint1 is equal to thePoint2
+Standard_Boolean IsMatch (const Handle(Geom_CartesianPoint)& thePoint1,
+                          const Handle(Geom_CartesianPoint)& thePoint2)
+{
+  if(abs(thePoint1->X()-thePoint2->X()) <= Precision::Confusion() &&
+     abs(thePoint1->Y()-thePoint2->Y()) <= Precision::Confusion() &&
+     abs(thePoint1->Z()-thePoint2->Z()) <= Precision::Confusion())
+  {
+    return Standard_True;
+  }
+  return Standard_False;
+}
+
+static Standard_Integer VTriangle (Draw_Interpretor& di,
+                                   Standard_Integer argc,
+                                   const char ** argv)
+{
+  // Check arguments
+  if (argc != 5)
+  {
+    std::cout<<"vtriangle error: expects 4 argumnets\n";
+    return 1; // TCL_ERROR
+  }
+
+  TheAISContext()->CloseAllContexts();
+
+  // Get and check values
+  TCollection_AsciiString aName(argv[1]);
+
+  Handle(AIS_Point) aPoint1, aPoint2, aPoint3;
+  if (!IsPoint(argv[2], aPoint1))
+  {
+    std::cout<<"vtriangle error: the 2nd argument must be a point\n";
+    return 1; // TCL_ERROR
+  }
+  if (!IsPoint(argv[3], aPoint2))
+  {
+    std::cout<<"vtriangle error: the 3d argument must be a point\n";
+    return 1; // TCL_ERROR
+  }
+  if (!IsPoint(argv[4], aPoint3))
+  {
+    std::cout<<"vtriangle error: the 4th argument must be a point\n";
+    return 1; // TCL_ERROR
+  }
+
+  // Check that points are different
+  Handle(Geom_CartesianPoint) aCartPoint1 = 
+    Handle(Geom_CartesianPoint)::DownCast(aPoint1->Component());
+  Handle(Geom_CartesianPoint) aCartPoint2 = 
+    Handle(Geom_CartesianPoint)::DownCast(aPoint2->Component());
+  // Test aPoint1 = aPoint2
+  if (IsMatch(aCartPoint1, aCartPoint2))
+  {
+    std::cout<<"vtriangle error: the 1st and the 2nd points are equal\n";
+    return 1; // TCL_ERROR
+  }
+  // Test aPoint2 = aPoint3
+  Handle(Geom_CartesianPoint) aCartPoint3 = 
+    Handle(Geom_CartesianPoint)::DownCast(aPoint3->Component());
+  if (IsMatch(aCartPoint2, aCartPoint3))
+  {
+    std::cout<<"vtriangle error: the 2nd and the 3d points are equal\n";
+    return 1; // TCL_ERROR
+  }
+  // Test aPoint3 = aPoint1
+  if (IsMatch(aCartPoint1, aCartPoint3))
+  {
+    std::cout<<"vtriangle error: the 1st and the 3d points are equal\n";
+    return 1; // TCL_ERROR
+  }
+
+  // Create triangle
+  Handle(Triangle) aTriangle = new Triangle(aCartPoint1->Pnt(),
+                                            aCartPoint2->Pnt(),
+                                            aCartPoint3->Pnt());
+
+  // Check if there is an object with given name
+  // and remove it from context
+  if (GetMapOfAIS().IsBound2(aName))
+  {
+    Handle(Standard_Transient) anObj = GetMapOfAIS().Find2(aName);
+    Handle(AIS_InteractiveObject) anInterObj = 
+         Handle(AIS_InteractiveObject)::DownCast(anObj);
+    TheAISContext()->Remove(anInterObj, Standard_False);
+    GetMapOfAIS().UnBind2(aName);
+  }
+
+  // Bind triangle to its name
+  GetMapOfAIS().Bind(aTriangle, aName);
+
+  // Display triangle
+  TheAISContext()->Display(aTriangle);
+  return 0;
+}
+
+//class  : SegmentObject
+//purpose: creates segment based on AIS_InteractiveObject.
+//         This class was implemented for testing Select3D_SensitiveCurve
+DEFINE_STANDARD_HANDLE(SegmentObject, AIS_InteractiveObject)
+class SegmentObject: public AIS_InteractiveObject
+{
+public:
+  // CASCADE RTTI
+  DEFINE_STANDARD_RTTI(SegmentObject); 
+  SegmentObject (const gp_Pnt& thePnt1, const gp_Pnt& thePnt2);
+protected:
+  void Compute (const Handle(PrsMgr_PresentationManager3d)& thePresentationManager,
+                const Handle(Prs3d_Presentation)& thePresentation,
+                const Standard_Integer theMode);
+
+  void ComputeSelection (const Handle(SelectMgr_Selection)& theSelection, 
+                         const Standard_Integer theMode);
+private:
+  gp_Pnt myPoint1;
+  gp_Pnt myPoint2;
+};
+IMPLEMENT_STANDARD_HANDLE(SegmentObject, AIS_InteractiveObject)
+IMPLEMENT_STANDARD_RTTIEXT(SegmentObject, AIS_InteractiveObject)
+
+SegmentObject::SegmentObject (const gp_Pnt& thePnt1, const gp_Pnt& thePnt2)
+{
+  myPoint1 = thePnt1;
+  myPoint2 = thePnt2;
+}
+
+void SegmentObject::Compute (const Handle_PrsMgr_PresentationManager3d &thePresentationManager,
+                             const Handle_Prs3d_Presentation &thePresentation,
+                             const Standard_Integer theMode)
+{
+  thePresentation->Clear();
+  BRepBuilderAPI_MakeEdge anEdgeMaker(myPoint1, myPoint2);
+  TopoDS_Edge anEdge = anEdgeMaker.Edge();
+  if (anEdge.IsNull())
+    return;
+  BRepAdaptor_Curve aCurveAdaptor(anEdge);
+  StdPrs_Curve::Add(thePresentation, aCurveAdaptor, myDrawer);
+}
+
+void SegmentObject::ComputeSelection (const Handle_SelectMgr_Selection &theSelection,
+                                      const Standard_Integer theMode)
+{
+  Handle(SelectMgr_EntityOwner) anOwner = new SelectMgr_EntityOwner(this);
+  Handle(TColgp_HArray1OfPnt) anArray = new TColgp_HArray1OfPnt(1, 2);
+  anArray->SetValue(1, myPoint1);
+  anArray->SetValue(2, myPoint2);
+  Handle(Select3D_SensitiveCurve) aSensCurve = 
+    new Select3D_SensitiveCurve(anOwner, anArray);
+  theSelection->Add(aSensCurve);
+}
+
+//=======================================================================
+//function  : VSegment
+//Draw args : vsegment Name PointName PointName
+//purpose   : creates and displays Segment
+//=======================================================================
+static Standard_Integer VSegment (Draw_Interpretor& di,
+                                  Standard_Integer argc,
+                                  const char ** argv)
+{
+  // Check arguments
+  if(argc!=4)
+  {
+    std::cout<<"vsegment error: expects 3 arguments\n";
+    return 1; // TCL_ERROR
+  }
+
+  TheAISContext()->CloseAllContexts();
+
+  // Get and check arguments
+  TCollection_AsciiString aName(argv[1]);
+  Handle(AIS_Point) aPoint1, aPoint2;
+  if (!IsPoint(argv[2], aPoint1))
+  {
+    std::cout<<"vsegment error: the 2nd argument should be a point\n";
+    return 1; // TCL_ERROR
+  }
+  if (!IsPoint(argv[3], aPoint2))
+  {
+    std::cout<<"vsegment error: the 3d argument should be a point\n";
+    return 1; // TCL_ERROR
+  }
+  //Check that points are different
+  Handle(Geom_CartesianPoint) aCartPoint1 = 
+    Handle(Geom_CartesianPoint)::DownCast(aPoint1->Component());
+  Handle(Geom_CartesianPoint) aCartPoint2 = 
+    Handle(Geom_CartesianPoint)::DownCast(aPoint2->Component());
+  if(IsMatch(aCartPoint1, aCartPoint2))
+  {
+    std::cout<<"vsegment error: equal points\n";
+    return 1; // TCL_ERROR
+  }
+  
+  // Create segment
+  Handle(SegmentObject) aSegment = new SegmentObject(aCartPoint1->Pnt(), aCartPoint2->Pnt());
+  // Check if there is an object with given name
+  // and remove it from context
+  if (GetMapOfAIS().IsBound2(aName))
+  {
+    Handle(Standard_Transient) anObj = GetMapOfAIS().Find2(aName);
+    Handle(AIS_InteractiveObject) anInterObj = 
+         Handle(AIS_InteractiveObject)::DownCast(anObj);
+    TheAISContext()->Remove(anInterObj, Standard_False);
+    GetMapOfAIS().UnBind2(aName);
+  }
+
+  // Bind segment to its name
+  GetMapOfAIS().Bind(aSegment, aName);
+
+  // Display segment
+  TheAISContext()->Display(aSegment);
+  return 0;
+}
+
 //=======================================================================
 //function : ObjectsCommands
 //purpose  :
@@ -3907,4 +4294,12 @@ void ViewerTest::ObjectCommands(Draw_Interpretor& theCommands)
   theCommands.Add("vselmode", 
     "vselmode : [object] mode On/Off (1/0)", 
     __FILE__, VSetSelectionMode, group);
+
+  theCommands.Add("vtriangle",
+    "vtriangle Name PointName PointName PointName", 
+    __FILE__, VTriangle,group);
+
+  theCommands.Add("vsegment",
+    "vsegment Name PointName PointName", 
+    __FILE__, VSegment,group);
 }