0024422: Wrong result done by FaceClassifier algorithm
authornbv <nbv@opencascade.com>
Wed, 4 Dec 2013 11:07:25 +0000 (15:07 +0400)
committerabv <abv@opencascade.com>
Thu, 12 Dec 2013 15:36:46 +0000 (19:36 +0400)
Control of out of boundaries by finding circle-point extrema.

src/BRepClass/BRepClass_Intersector.cxx
src/BRepOffsetAPI/BRepOffsetAPI_MakeOffset.cxx
src/BRepTest/BRepTest_CurveCommands.cxx
src/Extrema/Extrema_ExtPElC2d.cxx
tests/bugs/modalg_5/bug24422 [new file with mode: 0644]

index 5e14adb..e1aa985 100755 (executable)
 #include <IntRes2d_IntersectionPoint.hxx>
 
 static 
-  void RefineTolerance(const TopoDS_Face& aF,
-                      const BRepAdaptor_Curve2d& aC,
-                      const Standard_Real aT,
-                      Standard_Real& aTolZ);
+void RefineTolerance(const TopoDS_Face& aF,
+                     const BRepAdaptor_Curve2d& aC,
+                     const Standard_Real aT,
+                     Standard_Real& aTolZ);
 
 //=======================================================================
 //function : BRepClass_Intersector
@@ -60,16 +60,16 @@ BRepClass_Intersector::BRepClass_Intersector()
 //purpose  : 
 //=======================================================================
 void  BRepClass_Intersector::Perform(const gp_Lin2d& L, 
-                                    const Standard_Real P, 
-                                    const Standard_Real Tol, 
-                                    const BRepClass_Edge& E)
+                                     const Standard_Real P, 
+                                     const Standard_Real Tol, 
+                                     const BRepClass_Edge& E)
 {
-  Standard_Real deb, fin, aTolZ;
+  Standard_Real deb = 0.0, fin = 0.0, aTolZ = Tol;
   Handle(Geom2d_Curve) aC2D;
   //
-  aTolZ=Tol;
   const TopoDS_Edge& EE = E.Edge();
   const TopoDS_Face& F = E.Face();
+
   //
   aC2D=BRep_Tool::CurveOnSurface(EE, F, deb, fin);
   if (aC2D.IsNull()) {
@@ -84,24 +84,30 @@ void  BRepClass_Intersector::Perform(const gp_Lin2d& L,
   //
   // Case of "ON": direct check of belonging to edge
   // taking into account the tolerance
-  Extrema_ExtPC2d theExtPC2d(L.Location(), C);
+  Extrema_ExtPC2d anExtPC2d(L.Location(), C);
   Standard_Real MinDist = RealLast(), aDist;
   Standard_Integer MinInd = 0, i;
-  if (theExtPC2d.IsDone()) {
-    for (i = 1; i <= theExtPC2d.NbExt(); ++i) {
-      aDist = theExtPC2d.SquareDistance(i);
-      if (aDist < MinDist) {
-       MinDist = aDist;
-       MinInd = i;
+  if (anExtPC2d.IsDone())
+  {
+    const Standard_Integer aNbPnts = anExtPC2d.NbExt();
+    for (i = 1; i <= aNbPnts; ++i)
+    {
+      aDist = anExtPC2d.SquareDistance(i);
+
+      if (aDist < MinDist)
+      {
+        MinDist = aDist;
+        MinInd = i;
       }
     }
   }
+
   if (MinInd) {
     MinDist = sqrt(MinDist);
   }
   if (MinDist <= aTolZ) {
-    gp_Pnt2d pnt_exact = (theExtPC2d.Point(MinInd)).Value();
-    Standard_Real par = (theExtPC2d.Point(MinInd)).Parameter();
+    gp_Pnt2d pnt_exact = (anExtPC2d.Point(MinInd)).Value();
+    Standard_Real par = (anExtPC2d.Point(MinInd)).Parameter();
     //
     RefineTolerance(F, C, par, aTolZ);
     //
@@ -109,16 +115,16 @@ void  BRepClass_Intersector::Perform(const gp_Lin2d& L,
       IntRes2d_Transition tr_on_lin(IntRes2d_Head);
       IntRes2d_Position pos_on_curve = IntRes2d_Middle;
       if (Abs(par - deb) <= Precision::Confusion()) {
-       pos_on_curve = IntRes2d_Head;
+        pos_on_curve = IntRes2d_Head;
       }
       else if (Abs(par - fin) <= Precision::Confusion()) {
-       pos_on_curve = IntRes2d_End;
+        pos_on_curve = IntRes2d_End;
       }
       //
       IntRes2d_Transition tr_on_curve(pos_on_curve);
       IntRes2d_IntersectionPoint pnt_inter(pnt_exact, 0., par,
-                                          tr_on_lin, tr_on_curve, 
-                                          Standard_False);
+        tr_on_lin, tr_on_curve, 
+        Standard_False);
       //
       Append(pnt_inter);
       done = Standard_True;
@@ -130,7 +136,7 @@ void  BRepClass_Intersector::Perform(const gp_Lin2d& L,
   C.D0(deb,pdeb);
   C.D0(fin,pfin);
   Standard_Real toldeb = 1.e-5, tolfin = 1.e-5;
+
   IntRes2d_Domain DL;
   //
   if(P!=RealLast()) {
@@ -139,21 +145,21 @@ void  BRepClass_Intersector::Perform(const gp_Lin2d& L,
   else { 
     DL.SetValues(L.Location(),0.,aTolZ,Standard_True);
   }
+
   IntRes2d_Domain DE(pdeb,deb,toldeb,pfin,fin,tolfin);
   // temporary periodic domain
   if (C.Curve()->IsPeriodic()) {
     DE.SetEquivalentParameters(C.FirstParameter(),
-                              C.FirstParameter() + 
-                              C.Curve()->LastParameter() -
-                              C.Curve()->FirstParameter());
+      C.FirstParameter() + 
+      C.Curve()->LastParameter() -
+      C.Curve()->FirstParameter());
   }
-  
+
   Handle(Geom2d_Line) GL= new Geom2d_Line(L);
   Geom2dAdaptor_Curve CGA(GL);
   Geom2dInt_GInter Inter(CGA,DL,C,DE,
-                        Precision::PConfusion(),
-                        Precision::PIntersection());
+    Precision::PConfusion(),
+    Precision::PIntersection());
   //
   SetValues(Inter);
 }
@@ -163,14 +169,14 @@ void  BRepClass_Intersector::Perform(const gp_Lin2d& L,
 //purpose  : 
 //=======================================================================
 void  BRepClass_Intersector::LocalGeometry(const BRepClass_Edge& E, 
-                                          const Standard_Real U, 
-                                          gp_Dir2d& Tang, 
-                                          gp_Dir2d& Norm, 
-                                          Standard_Real& C) const 
+                                           const Standard_Real U, 
+                                           gp_Dir2d& Tang, 
+                                           gp_Dir2d& Norm, 
+                                           Standard_Real& C) const 
 {
   Standard_Real f,l;
   Geom2dLProp_CLProps2d Prop(BRep_Tool::CurveOnSurface(E.Edge(),E.Face(),f,l),
-                            U,2,Precision::PConfusion());
+    U,2,Precision::PConfusion());
   Prop.Tangent(Tang);
   C = Prop.Curvature();
   if (C > Precision::PConfusion())
@@ -184,9 +190,9 @@ void  BRepClass_Intersector::LocalGeometry(const BRepClass_Edge& E,
 //purpose  : 
 //=======================================================================
 void RefineTolerance(const TopoDS_Face& aF,
-                    const BRepAdaptor_Curve2d& aC,
-                    const Standard_Real aT,
-                    Standard_Real& aTolZ)
+                     const BRepAdaptor_Curve2d& aC,
+                     const Standard_Real aT,
+                     Standard_Real& aTolZ)
 {
   GeomAbs_SurfaceType aTypeS;
   //
index 9b291f3..680596c 100755 (executable)
@@ -60,7 +60,7 @@ BRepOffsetAPI_MakeOffset::BRepOffsetAPI_MakeOffset()
 //=======================================================================
 
 BRepOffsetAPI_MakeOffset::BRepOffsetAPI_MakeOffset(const TopoDS_Face& Spine, 
-                                      const GeomAbs_JoinType Join)
+  const GeomAbs_JoinType Join)
 {
   Init(Spine, Join);
 }
@@ -72,7 +72,7 @@ BRepOffsetAPI_MakeOffset::BRepOffsetAPI_MakeOffset(const TopoDS_Face& Spine,
 //=======================================================================
 
 void BRepOffsetAPI_MakeOffset::Init(const TopoDS_Face&     Spine,
-                             const GeomAbs_JoinType Join)
+  const GeomAbs_JoinType Join)
 {
   myFace          = Spine;
   myIsInitialized = Standard_True;
@@ -89,7 +89,7 @@ void BRepOffsetAPI_MakeOffset::Init(const TopoDS_Face&     Spine,
 //=======================================================================
 
 BRepOffsetAPI_MakeOffset::BRepOffsetAPI_MakeOffset(const TopoDS_Wire& Spine, 
-                                       const GeomAbs_JoinType Join)
+  const GeomAbs_JoinType Join)
 {
   myWires.Append(Spine);
   myIsInitialized = Standard_True;
@@ -105,14 +105,14 @@ void BRepOffsetAPI_MakeOffset::Init(const GeomAbs_JoinType Join)
 {
   myJoin = Join;
 }
+
 //=======================================================================
 //function : BRepOffsetAPI_MakeOffset
 //purpose  : 
 //=======================================================================
 
 void BRepOffsetAPI_MakeOffset::AddWire(const TopoDS_Wire& Spine)
-                                           
+
 {
   myIsInitialized = Standard_True;
   myWires.Append(Spine);
@@ -124,10 +124,10 @@ void BRepOffsetAPI_MakeOffset::AddWire(const TopoDS_Wire& Spine)
 //=======================================================================
 
 static void BuildDomains(TopoDS_Face&               myFace,
-                        TopTools_ListOfShape&      WorkWires,
-                        BRepFill_ListOfOffsetWire& myAlgos,
-                        GeomAbs_JoinType           myJoin,
-                        Standard_Boolean           isPositive)
+  TopTools_ListOfShape&      WorkWires,
+  BRepFill_ListOfOffsetWire& myAlgos,
+  GeomAbs_JoinType           myJoin,
+  Standard_Boolean           isPositive)
 {
   BRepAlgo_FaceRestrictor  FR;
   TopoDS_Vertex            VF,VL;
@@ -146,14 +146,14 @@ static void BuildDomains(TopoDS_Face&               myFace,
   if (anExp.More()) {
     aWire2 = anExp.Current();
     if ((aWire1.Orientation() == aWire2.Orientation() && isPositive) ||
-       (aWire1.Orientation() == TopAbs::Complement(aWire2.Orientation()) && !isPositive)) {
-      TopTools_ListOfShape LWires;
-      TopTools_ListIteratorOfListOfShape itl;
-      for (itl.Initialize(WorkWires); itl.More(); itl.Next()) {
-       const TopoDS_Shape& W = itl.Value();
-       LWires.Append(W.Reversed());
-      }
-      WorkWires = LWires;
+      (aWire1.Orientation() == TopAbs::Complement(aWire2.Orientation()) && !isPositive)) {
+        TopTools_ListOfShape LWires;
+        TopTools_ListIteratorOfListOfShape itl;
+        for (itl.Initialize(WorkWires); itl.More(); itl.Next()) {
+          const TopoDS_Shape& W = itl.Value();
+          LWires.Append(W.Reversed());
+        }
+        WorkWires = LWires;
     }
   }
 //  Modified by Sergey KHROMOV - Thu Apr 26 16:04:44 2001 End
@@ -200,7 +200,7 @@ static void BuildDomains(TopoDS_Face&               myFace,
     myAlgos.Append(Algo);
     return;
   }
-  
+
   //====================================================
   // Classification of open wires.
   //====================================================  
@@ -227,21 +227,21 @@ static void BuildDomains(TopoDS_Face&               myFace,
       Standard_Real     Dist2Min = Precision::Infinite();
       Standard_Real     Found   = Standard_False;
       for (Standard_Integer ie = 1; ie <= ExtPS.NbExt(); ie++) {
-       Standard_Real X,Y;
-       if (ExtPS.SquareDistance(ie) < Dist2Min) {
-         Dist2Min = ExtPS.SquareDistance(ie);
-         Found   = Standard_True;
-         ExtPS.Point(ie).Parameter(X,Y);
-         PV.SetCoord(X,Y);
-       }
+        Standard_Real X,Y;
+        if (ExtPS.SquareDistance(ie) < Dist2Min) {
+          Dist2Min = ExtPS.SquareDistance(ie);
+          Found   = Standard_True;
+          ExtPS.Point(ie).Parameter(X,Y);
+          PV.SetCoord(X,Y);
+        }
       }
       if ( Found && (CL.Perform(PV) == TopAbs_IN)) {
-       // The face that contains a wire is found and it is removed from the list
-       B.Add(F,W);
-       LOW.Remove(itW);
+        // The face that contains a wire is found and it is removed from the list
+        B.Add(F,W);
+        LOW.Remove(itW);
       }
       else {
-       itW.Next();
+        itW.Next();
       }
     }
   }
@@ -260,68 +260,68 @@ static void BuildDomains(TopoDS_Face&               myFace,
 //=======================================================================
 
 void BRepOffsetAPI_MakeOffset::Perform( const Standard_Real Offset,
-                                       const Standard_Real Alt)
-  {
+  const Standard_Real Alt)
+{
   StdFail_NotDone_Raise_if ( !myIsInitialized,
-                         "BRepOffsetAPI_MakeOffset : Perform without Init");
+    "BRepOffsetAPI_MakeOffset : Perform without Init");
 
   try
-    {
+  {
     Standard_Integer i = 1;
     BRepFill_ListIteratorOfListOfOffsetWire itOW;
     TopoDS_Compound Res;
     BRep_Builder    B;
     B.MakeCompound (Res);
     myLastIsLeft = (Offset <= 0);
-    
+
     if( Offset <= 0. )
-      {
+    {
       if( myLeft.IsEmpty() )
-        {
+      {
         //  Modified by Sergey KHROMOV - Fri Apr 27 14:35:26 2001 Begin
         BuildDomains(myFace,myWires,myLeft,myJoin, Standard_False);
         //  Modified by Sergey KHROMOV - Fri Apr 27 14:35:26 2001 End
-        }
+      }
 
       for (itOW.Initialize(myLeft); itOW.More(); itOW.Next())
-        {
+      {
         BRepFill_OffsetWire& Algo = itOW.Value();
         Algo.Perform(Abs(Offset),Alt);
         if (Algo.IsDone() && !Algo.Shape().IsNull())
-          {
+        {
           B.Add(Res,Algo.Shape());
           if (i == 1)
             myShape = Algo.Shape();
 
           i++;
-          }
         }
       }
+    }
     else
-      {
+    {
       if (myRight.IsEmpty())
-        {
+      {
         //  Modified by Sergey KHROMOV - Fri Apr 27 14:35:28 2001 Begin
         BuildDomains(myFace,myWires,myRight,myJoin, Standard_True);
         //  Modified by Sergey KHROMOV - Fri Apr 27 14:35:35 2001 End
-        }
+      }
 
       for(itOW.Initialize(myRight); itOW.More(); itOW.Next())
-        {
+      {
         BRepFill_OffsetWire& Algo = itOW.Value();
         Algo.Perform(Offset,Alt);
-        
+
         if (Algo.IsDone() && !Algo.Shape().IsNull())
-          {
+        {
           B.Add(Res,Algo.Shape());
 
           if (i == 1)
             myShape = Algo.Shape();
 
           i++;
-          }
         }
       }
+    }
 
     if( i > 2 )
       myShape = Res;
@@ -330,16 +330,16 @@ void BRepOffsetAPI_MakeOffset::Perform( const Standard_Real Offset,
       NotDone();
     else
       Done();
-    }
+  }
   catch(...) //Every exception was caught.
-    {
+  {
     cout<<"An exception was caught in BRepOffsetAPI_MakeOffset::Perform : ";
     Standard_ConstructionError::Caught()->Print(cout); 
     cout<<endl;
     NotDone();
     myShape.Nullify();
-    }
   }
+}
 
 //=======================================================================
 //function : Build
@@ -358,7 +358,7 @@ void BRepOffsetAPI_MakeOffset::Build()
 //=======================================================================
 
 const TopTools_ListOfShape& BRepOffsetAPI_MakeOffset::Generated
-(const TopoDS_Shape& S)
+  (const TopoDS_Shape& S)
 {
   myGenerated.Clear();
   BRepFill_ListIteratorOfListOfOffsetWire itOW;
index 9a771eb..3baf7de 100755 (executable)
@@ -87,8 +87,8 @@ static Standard_Integer vertex(Draw_Interpretor& , Standard_Integer n, const cha
   if (n < 4) return 1;
   if (n >= 5) {
     DBRep::Set(a[1],
-              BRepBuilderAPI_MakeVertex(gp_Pnt(Draw::Atof(a[2]),Draw::Atof(a[3]),Draw::Atof(a[4]))));
-    }
+      BRepBuilderAPI_MakeVertex(gp_Pnt(Draw::Atof(a[2]),Draw::Atof(a[3]),Draw::Atof(a[4]))));
+  }
   else {
     TopoDS_Shape S = DBRep::Get(a[3]);
     if (S.IsNull()) return 0;
@@ -248,7 +248,7 @@ static Standard_Integer wire(Draw_Interpretor& di, Standard_Integer n, const cha
 static Standard_Integer mkedge(Draw_Interpretor& di, Standard_Integer n, const char** a)
 {
   if (n < 3) return 1;
-  
+
   Handle(Geom_Curve)   C   = DrawTrSurf::GetCurve(a[2]);
   Handle(Geom2d_Curve) C2d = DrawTrSurf::GetCurve2d(a[2]);
   if (C.IsNull() && C2d.IsNull()) {
@@ -256,7 +256,7 @@ static Standard_Integer mkedge(Draw_Interpretor& di, Standard_Integer n, const c
     di << a[2] << " is not a curve" << "\n";
     return 1;
   }
-  
+
   TopoDS_Edge edge;
 
   if (n == 3) {
@@ -275,23 +275,23 @@ static Standard_Integer mkedge(Draw_Interpretor& di, Standard_Integer n, const c
 //    TopoDS_Vertex V1 = TopoDS::Vertex(DBRep::Get(a[3+i],TopAbs_VERTEX));
     if (n == 5+i) {
       if (V1.IsNull()) {
-       if (!C.IsNull())   
-         edge = BRepBuilderAPI_MakeEdge(C,Draw::Atof(a[3]),Draw::Atof(a[4]));
-       else if (S.IsNull())              
-         edge = BRepBuilderAPI_MakeEdge2d(C2d,Draw::Atof(a[3]),Draw::Atof(a[4]));
-       else
-         edge = BRepBuilderAPI_MakeEdge(C2d,S,Draw::Atof(a[4]),Draw::Atof(a[5]));
+        if (!C.IsNull())   
+          edge = BRepBuilderAPI_MakeEdge(C,Draw::Atof(a[3]),Draw::Atof(a[4]));
+        else if (S.IsNull())              
+          edge = BRepBuilderAPI_MakeEdge2d(C2d,Draw::Atof(a[3]),Draw::Atof(a[4]));
+        else
+          edge = BRepBuilderAPI_MakeEdge(C2d,S,Draw::Atof(a[4]),Draw::Atof(a[5]));
       }
       else {
-       aLocalShape = DBRep::Get(a[4+i],TopAbs_VERTEX);
-       TopoDS_Vertex V2 = TopoDS::Vertex(aLocalShape);
-//     TopoDS_Vertex V2 = TopoDS::Vertex(DBRep::Get(a[4+i],TopAbs_VERTEX));
-       if (!C.IsNull())   
-         edge = BRepBuilderAPI_MakeEdge(C,V1,V2);
-       else if (S.IsNull())              
-         edge = BRepBuilderAPI_MakeEdge2d(C2d,V1,V2);
-       else
-         edge = BRepBuilderAPI_MakeEdge(C2d,S,V1,V2);
+        aLocalShape = DBRep::Get(a[4+i],TopAbs_VERTEX);
+        TopoDS_Vertex V2 = TopoDS::Vertex(aLocalShape);
+//  TopoDS_Vertex V2 = TopoDS::Vertex(DBRep::Get(a[4+i],TopAbs_VERTEX));
+        if (!C.IsNull())   
+          edge = BRepBuilderAPI_MakeEdge(C,V1,V2);
+        else if (S.IsNull())              
+          edge = BRepBuilderAPI_MakeEdge2d(C2d,V1,V2);
+        else
+          edge = BRepBuilderAPI_MakeEdge(C2d,S,V1,V2);
       }
     }  
     else if (n == 7+i) {
@@ -299,11 +299,11 @@ static Standard_Integer mkedge(Draw_Interpretor& di, Standard_Integer n, const c
       TopoDS_Vertex V2 = TopoDS::Vertex(aLocalShape);
 //      TopoDS_Vertex V2 = TopoDS::Vertex(DBRep::Get(a[5+i],TopAbs_VERTEX));
       if (!C.IsNull())   
-       edge = BRepBuilderAPI_MakeEdge(C,V1,V2,Draw::Atof(a[4]),Draw::Atof(a[6]));
+        edge = BRepBuilderAPI_MakeEdge(C,V1,V2,Draw::Atof(a[4]),Draw::Atof(a[6]));
       else if (S.IsNull())         
-       edge = BRepBuilderAPI_MakeEdge2d(C2d,V1,V2,Draw::Atof(a[4]),Draw::Atof(a[6]));
+        edge = BRepBuilderAPI_MakeEdge2d(C2d,V1,V2,Draw::Atof(a[4]),Draw::Atof(a[6]));
       else              
-       edge = BRepBuilderAPI_MakeEdge(C2d,S,V1,V2,Draw::Atof(a[5]),Draw::Atof(a[7]));
+        edge = BRepBuilderAPI_MakeEdge(C2d,S,V1,V2,Draw::Atof(a[5]),Draw::Atof(a[7]));
     }
     else
       return 1;
@@ -338,9 +338,9 @@ static Standard_Integer mkcurve(Draw_Interpretor& di, Standard_Integer n, const
     return 1;
   }
   C = new Geom_TrimmedCurve(C,f,l);
-  
+
   Draw_Color col,savecol;
-  
+
   if ( DispOrientation) {
     DBRep_WriteColorOrientation ();
     col = DBRep_ColorOrientation(TopoDS::Edge(S).Orientation());
@@ -360,7 +360,7 @@ static Standard_Integer mkcurve(Draw_Interpretor& di, Standard_Integer n, const
 //=======================================================================
 
 static Standard_Integer mkpoint(Draw_Interpretor& , 
-                               Standard_Integer n, const char** a)
+  Standard_Integer n, const char** a)
 {
   if (n < 3) return 1;
 
@@ -368,7 +368,7 @@ static Standard_Integer mkpoint(Draw_Interpretor& ,
   if ( S.IsNull()) return 1;
 
   TopoDS_Vertex V = TopoDS::Vertex(S);
-  
+
   gp_Pnt P = BRep_Tool::Pnt(V);
   DrawTrSurf::Set(a[1],P);
 
@@ -380,7 +380,7 @@ static Standard_Integer mkpoint(Draw_Interpretor& ,
 //=======================================================================
 
 static Standard_Integer mk2dcurve(Draw_Interpretor& di, 
-                                 Standard_Integer na, const char** a)
+  Standard_Integer na, const char** a)
 {
   if (na < 3) return 1;
 
@@ -392,7 +392,7 @@ static Standard_Integer mk2dcurve(Draw_Interpretor& di,
   Standard_Real f = 0., l = 0.;
   Handle(Geom2d_Curve) C;
   Handle(Geom_Surface) Surf;
-  
+
   if ( na == 3 ) {
     // get the first PCurve connected to edge E
     BRep_Tool::CurveOnSurface(E,C,Surf,L,f,l);
@@ -427,7 +427,7 @@ static Standard_Integer edge(Draw_Interpretor& , Standard_Integer n, const char*
   TopoDS_Shape V2 = DBRep::Get(a[3],TopAbs_VERTEX);
   if (V1.IsNull() || V2.IsNull()) return 1;
   TopoDS_Edge E = BRepBuilderAPI_MakeEdge(TopoDS::Vertex(V1),
-                                  TopoDS::Vertex(V2));
+    TopoDS::Vertex(V2));
   DBRep::Set(a[1],E);
   return 0;
 }
@@ -451,14 +451,14 @@ static Standard_Integer isoedge(Draw_Interpretor& , Standard_Integer n, const ch
   Standard_Real UMin,UMax,VMin,VMax;
   BRepTools::UVBounds(TopoDS::Face(Sh),UMin,UMax,VMin,VMax);
   if (uiso) {
-     VMin = Min (VMin , Min (p1,p2));
-     VMax = Max (VMax , Max (p1,p2));
-   }
+    VMin = Min (VMin , Min (p1,p2));
+    VMax = Max (VMax , Max (p1,p2));
+  }
   else{
-     UMin = Min (UMin , Min (p1,p2));
-     UMax = Max (VMax , Max (p1,p2));
-   }
-    
+    UMin = Min (UMin , Min (p1,p2));
+    UMax = Max (VMax , Max (p1,p2));
+  }
+
   Handle(Geom_RectangularTrimmedSurface) TS = new Geom_RectangularTrimmedSurface(S,UMin,UMax,VMin,VMax);
   Handle(Geom_Curve) C;
   Handle(Geom2d_Line) L;
@@ -491,7 +491,7 @@ static Standard_Integer transfert(Draw_Interpretor& , Standard_Integer n, const
   TopoDS_Shape E1 = DBRep::Get(a[1],TopAbs_EDGE);
   TopoDS_Shape E2 = DBRep::Get(a[2],TopAbs_EDGE);
   if (E1.IsNull() || E2.IsNull()) return 1;
-  
+
   BRep_Builder B;
   B.Transfert(TopoDS::Edge(E1),TopoDS::Edge(E2));
   return 0;
@@ -503,8 +503,8 @@ static Standard_Integer transfert(Draw_Interpretor& , Standard_Integer n, const
 //=======================================================================
 
 static Standard_Integer profile(Draw_Interpretor& di,
-                               Standard_Integer n,
-                               const char** a)
+  Standard_Integer n,
+  const char** a)
 {
   // this command build a profile
   // from a moving point
@@ -599,8 +599,8 @@ static Standard_Integer profile(Draw_Interpretor& di,
       i += 2;
       if (i >= n) goto badargs;
       if (!first) {
-       di << "profile: The F instruction must precede all moves";
-       return 1;
+        di << "profile: The F instruction must precede all moves";
+        return 1;
       }
       x0 = x = Draw::Atof(a[i-1]);
       y0 = y = Draw::Atof(a[i]);
@@ -620,18 +620,18 @@ static Standard_Integer profile(Draw_Interpretor& di,
       i += 6;
       if (i >= n) goto badargs;
       {
-       gp_Vec vn(Draw::Atof(a[i-5]),Draw::Atof(a[i-4]),Draw::Atof(a[i-3]));
-       gp_Vec vx(Draw::Atof(a[i-2]),Draw::Atof(a[i-1]),Draw::Atof(a[i]));
-       if (vn.Magnitude() <= Precision::Confusion()) {
-         di << "profile : null direction";
-         return 1;
-       }
-       if (vx.Magnitude() <= Precision::Confusion()) {
-         di << "profile : null direction";
-         return 1;
-       }
-       gp_Ax2 ax(P.Location(),vn,vx);
-       P.SetPosition(ax);
+        gp_Vec vn(Draw::Atof(a[i-5]),Draw::Atof(a[i-4]),Draw::Atof(a[i-3]));
+        gp_Vec vx(Draw::Atof(a[i-2]),Draw::Atof(a[i-1]),Draw::Atof(a[i]));
+        if (vn.Magnitude() <= Precision::Confusion()) {
+          di << "profile : null direction";
+          return 1;
+        }
+        if (vx.Magnitude() <= Precision::Confusion()) {
+          di << "profile : null direction";
+          return 1;
+        }
+        gp_Ax2 ax(P.Location(),vn,vx);
+        P.SetPosition(ax);
       }
       stayfirst = Standard_True;
       break;
@@ -641,20 +641,20 @@ static Standard_Integer profile(Draw_Interpretor& di,
       i += 1;
       if (i >= n) goto badargs;
       {
-       TopoDS_Shape aLocalShape(DBRep::Get(a[i],TopAbs_FACE));
-       TopoDS_Face Face = TopoDS::Face(aLocalShape);
-//     TopoDS_Face Face = TopoDS::Face(DBRep::Get(a[i],TopAbs_FACE));
-       if (Face.IsNull()) {
-         di << "profile : no face found";
-         return 1;
-       }
-       Surface = BRep_Tool::Surface(Face,TheLocation);
-       Handle(Geom_Plane) Plane = Handle(Geom_Plane)::DownCast(Surface);
-       if ( Plane.IsNull()) {
-         isplanar = Standard_False;
-       }
-       else 
-         P = Plane->Pln();
+        TopoDS_Shape aLocalShape(DBRep::Get(a[i],TopAbs_FACE));
+        TopoDS_Face Face = TopoDS::Face(aLocalShape);
+//  TopoDS_Face Face = TopoDS::Face(DBRep::Get(a[i],TopAbs_FACE));
+        if (Face.IsNull()) {
+          di << "profile : no face found";
+          return 1;
+        }
+        Surface = BRep_Tool::Surface(Face,TheLocation);
+        Handle(Geom_Plane) Plane = Handle(Geom_Plane)::DownCast(Surface);
+        if ( Plane.IsNull()) {
+          isplanar = Standard_False;
+        }
+        else 
+          P = Plane->Pln();
       }
       stayfirst = Standard_True;
       break;
@@ -665,24 +665,24 @@ static Standard_Integer profile(Draw_Interpretor& di,
       if (i >= n) goto badargs;
       length = Draw::Atof(a[i]);
       if ((a[i-1][1] == 'X') || (a[i-1][1] == 'x')) {
-       length -= x;
+        length -= x;
       }
       dx = 1; dy = 0;
       move = line;
       break;
-      
+
     case 'Y':
     case 'y':
       i++;
       if (i >= n) goto badargs;
       length = Draw::Atof(a[i]);
       if ((a[i-1][1] == 'Y') || (a[i-1][1] == 'y')) {
-       length -= y;
+        length -= y;
       }
       dx = 0; dy = 1;
       move = line;
       break;
-      
+
     case 'L':
     case 'l':
       i++;
@@ -696,18 +696,18 @@ static Standard_Integer profile(Draw_Interpretor& di,
       i += 2;
       if (i >= n) goto badargs;
       {
-       Standard_Real vx = Draw::Atof(a[i-1]);
-       Standard_Real vy = Draw::Atof(a[i]);
-       if ((a[i-2][1] == 'T') || (a[i-2][1] == 't')) {
-         vx -= x;
-         vy -= y;
-       }
-       length = Sqrt(vx*vx+vy*vy);
-       if (length > Precision::Confusion()) {
-         move = line;
-         dx = vx / length;
-         dy = vy / length;
-       }
+        Standard_Real vx = Draw::Atof(a[i-1]);
+        Standard_Real vy = Draw::Atof(a[i]);
+        if ((a[i-2][1] == 'T') || (a[i-2][1] == 't')) {
+          vx -= x;
+          vy -= y;
+        }
+        length = Sqrt(vx*vx+vy*vy);
+        if (length > Precision::Confusion()) {
+          move = line;
+          dx = vx / length;
+          dy = vy / length;
+        }
       }
       break;
 
@@ -717,15 +717,15 @@ static Standard_Integer profile(Draw_Interpretor& di,
       if (i >= n) goto badargs;
       angle = Draw::Atof(a[i]) * (M_PI / 180.0);
       if ((a[i-1][1] == 'R') || (a[i-1][1] == 'r')) {
-       dx = Cos(angle);
-       dy = Sin(angle);
+        dx = Cos(angle);
+        dy = Sin(angle);
       }
       else {
-       Standard_Real c = Cos(angle);
-       Standard_Real s = Sin(angle);
-       Standard_Real t = c * dx - s * dy;
-       dy = s * dx + c * dy;
-       dx = t;
+        Standard_Real c = Cos(angle);
+        Standard_Real s = Sin(angle);
+        Standard_Real t = c * dx - s * dy;
+        dy = s * dx + c * dy;
+        dx = t;
       }
       break;
 
@@ -734,14 +734,14 @@ static Standard_Integer profile(Draw_Interpretor& di,
       i += 2;
       if (i >= n) goto badargs;
       {
-       Standard_Real vx = Draw::Atof(a[i-1]);
-       Standard_Real vy = Draw::Atof(a[i]);
-       length = Sqrt(vx*vx+vy*vy);
-       if (length > Precision::Confusion()) {
-         // move = line; DUB
-         dx = vx / length;
-         dy = vy / length;
-       }
+        Standard_Real vx = Draw::Atof(a[i-1]);
+        Standard_Real vy = Draw::Atof(a[i]);
+        length = Sqrt(vx*vx+vy*vy);
+        if (length > Precision::Confusion()) {
+          // move = line; DUB
+          dx = vx / length;
+          dy = vy / length;
+        }
       }
       break;
 
@@ -751,8 +751,8 @@ static Standard_Integer profile(Draw_Interpretor& di,
       if (i >= n) goto badargs;
       radius = Draw::Atof(a[i-1]);
       if (Abs(radius) > Precision::Confusion()) {
-       angle = Draw::Atof(a[i]) * (M_PI / 180.0);
-       move = circle;
+        angle = Draw::Atof(a[i]) * (M_PI / 180.0);
+        move = circle;
       }
       break;
 
@@ -762,29 +762,29 @@ static Standard_Integer profile(Draw_Interpretor& di,
       if (i >= n) goto badargs;
       length = Draw::Atof(a[i]);
       if ((a[i-1][1] == 'X') || (a[i-1][1] == 'x')) {
-       if (Abs(dx) < Precision::Confusion()) {
-         di << "Profile : cannot intersect, arg " << i-1;
-         return 1;
-       }
-       length = (length - x) / dx;
-       move = line;
+        if (Abs(dx) < Precision::Confusion()) {
+          di << "Profile : cannot intersect, arg " << i-1;
+          return 1;
+        }
+        length = (length - x) / dx;
+        move = line;
       }
       else if ((a[i-1][1] == 'Y') || (a[i-1][1] == 'y')) {
-       if (Abs(dy) < Precision::Confusion()) {
-         di << "Profile : cannot intersect, arg " << i-1;
-         return 1;
-       }
-       length = (length - y) / dy;
-       move = line;
+        if (Abs(dy) < Precision::Confusion()) {
+          di << "Profile : cannot intersect, arg " << i-1;
+          return 1;
+        }
+        length = (length - y) / dy;
+        move = line;
       }
-     
+
       break;
 
     case 'W':
     case 'w':
       face = Standard_False;
       if ((a[i][1] == 'W') || (a[i][1] == 'w')) {
-       close = Standard_False;
+        close = Standard_False;
       }
       i = n-1;
       break;
@@ -794,54 +794,54 @@ static Standard_Integer profile(Draw_Interpretor& di,
       return 1;
     }
 
-  again:
+again:
 
     switch (move) {
-      
+
     case line :
       {
-       if (length < 0) {
-         length = -length;
-         dx = -dx;
-         dy = -dy;
-       }
-       Handle(Geom2d_Line) l = 
-         new Geom2d_Line(gp_Pnt2d(x,y),gp_Dir2d(dx,dy));
-       if (isplanar)
-         MW.Add(BRepBuilderAPI_MakeEdge(GeomAPI::To3d(l,P),0,length));
-       else 
-         MW.Add(BRepBuilderAPI_MakeEdge(l,Surface,0,length));
-       x += length*dx;
-       y += length*dy;
+        if (length < 0) {
+          length = -length;
+          dx = -dx;
+          dy = -dy;
+        }
+        Handle(Geom2d_Line) l = 
+          new Geom2d_Line(gp_Pnt2d(x,y),gp_Dir2d(dx,dy));
+        if (isplanar)
+          MW.Add(BRepBuilderAPI_MakeEdge(GeomAPI::To3d(l,P),0,length));
+        else 
+          MW.Add(BRepBuilderAPI_MakeEdge(l,Surface,0,length));
+        x += length*dx;
+        y += length*dy;
       }
       break;
 
     case circle :
       {
-       Standard_Boolean sense = Standard_True;
-       if (radius < 0) {
-         radius = -radius;
-         sense = !sense;
-         dx = -dx;
-         dy = -dy;
-       }
-       gp_Ax2d ax(gp_Pnt2d(x-radius*dy,y+radius*dx),gp_Dir2d(dy,-dx));
-       if (angle < 0) {
-         angle = -angle;
-         sense = !sense;
-       }
-       Handle(Geom2d_Circle) c = new Geom2d_Circle(ax,radius,sense);
-       if (isplanar)
-         MW.Add(BRepBuilderAPI_MakeEdge(GeomAPI::To3d(c,P),0,angle));
-       else
-         MW.Add(BRepBuilderAPI_MakeEdge(c,Surface,0,angle));
-       gp_Pnt2d p;
-       gp_Vec2d v;
-       c->D1(angle,p,v);
-       x = p.X();
-       y = p.Y();
-       dx = v.X() / radius;
-       dy = v.Y() / radius;
+        Standard_Boolean sense = Standard_True;
+        if (radius < 0) {
+          radius = -radius;
+          sense = !sense;
+          dx = -dx;
+          dy = -dy;
+        }
+        gp_Ax2d ax(gp_Pnt2d(x-radius*dy,y+radius*dx),gp_Dir2d(dy,-dx));
+        if (angle < 0) {
+          angle = -angle;
+          sense = !sense;
+        }
+        Handle(Geom2d_Circle) c = new Geom2d_Circle(ax,radius,sense);
+        if (isplanar)
+          MW.Add(BRepBuilderAPI_MakeEdge(GeomAPI::To3d(c,P),0,angle));
+        else
+          MW.Add(BRepBuilderAPI_MakeEdge(c,Surface,0,angle));
+        gp_Pnt2d p;
+        gp_Vec2d v;
+        c->D1(angle,p,v);
+        x = p.X();
+        y = p.Y();
+        dx = v.X() / radius;
+        dy = v.Y() / radius;
       }
       break;
 
@@ -861,10 +861,10 @@ static Standard_Integer profile(Draw_Interpretor& di,
       dy = y0-y;
       length = Sqrt(dx*dx+dy*dy);
       if (length > Precision::Confusion()) {
-       move = line;
-       dx = dx / length;
-       dy = dy / length;
-       goto again;
+        move = line;
+        dx = dx / length;
+        dy = dy / length;
+        goto again;
       }
     }
   }
@@ -885,7 +885,7 @@ static Standard_Integer profile(Draw_Interpretor& di,
   else {
     S = MW;
   }
-  
+
   if (!TheLocation.IsIdentity())
     S.Move(TheLocation);
 
@@ -898,7 +898,7 @@ static Standard_Integer profile(Draw_Interpretor& di,
 
   return 0;
 
- badargs:
+badargs:
   di << "profile : bad number of arguments";
   return 1;
 }
@@ -908,8 +908,8 @@ static Standard_Integer profile(Draw_Interpretor& di,
 //=======================================================================
 
 static Standard_Integer bsplineprof(Draw_Interpretor& di,
-                                   Standard_Integer n,
-                                   const char** a)
+  Standard_Integer n,
+  const char** a)
 {
   // this command build a profile
   // from a moving point
@@ -939,11 +939,11 @@ static Standard_Integer bsplineprof(Draw_Interpretor& di,
   }
 
   gp_Pnt2d last_point(0.0e0,
-                    0.0e0) ;
+    0.0e0) ;
   gp_Pnt2d first_point(0.0e0,
-                      0.0e0) ;
+    0.0e0) ;
   Standard_Integer i = 2,
-  wait = 1 ;
+    wait = 1 ;
 //  Standard_Real x0 = 0, y0 = 0, x = 0, y = 0, dx = 1, dy = 0;
   Standard_Real x = 0, y = 0, dx = 1, dy = 0;
   BRepBuilderAPI_MakeWire MW;
@@ -960,44 +960,44 @@ static Standard_Integer bsplineprof(Draw_Interpretor& di,
   Handle(Geom_Surface) Surface;
   if (n > 2) {
     while (i < n) {
-      
+
       switch (a[i][0]) {
-       
+
       case 'S':
       case 's':
-       i += 1;
-       {
-         TopoDS_Shape aLocalShape(DBRep::Get(a[i],TopAbs_FACE));
-         TopoDS_Face Face = TopoDS::Face(aLocalShape);
-//       TopoDS_Face Face = TopoDS::Face(DBRep::Get(a[i],TopAbs_FACE));
-         if (Face.IsNull()) {
-           di << "profile : no face found";
-           return 1;
-         }
-         Surface = BRep_Tool::Surface(Face,TheLocation);
-         Handle(Geom_Plane) Plane = Handle(Geom_Plane)::DownCast(Surface);
-         if ( Plane.IsNull()) {
-           isplanar = Standard_False;
-         }
-         else 
-           P = Plane->Pln();
-       }
-       stayfirst = Standard_True;
+        i += 1;
+        {
+          TopoDS_Shape aLocalShape(DBRep::Get(a[i],TopAbs_FACE));
+          TopoDS_Face Face = TopoDS::Face(aLocalShape);
+//    TopoDS_Face Face = TopoDS::Face(DBRep::Get(a[i],TopAbs_FACE));
+          if (Face.IsNull()) {
+            di << "profile : no face found";
+            return 1;
+          }
+          Surface = BRep_Tool::Surface(Face,TheLocation);
+          Handle(Geom_Plane) Plane = Handle(Geom_Plane)::DownCast(Surface);
+          if ( Plane.IsNull()) {
+            isplanar = Standard_False;
+          }
+          else 
+            P = Plane->Pln();
+        }
+        stayfirst = Standard_True;
         i += 1 ;
-       break;
-       
+        break;
+
       case 'W':
       case 'w':
-       face = Standard_False;
-       if ((a[i][1] == 'W') || (a[i][1] == 'w')) {
-         close = Standard_False;
-       }
-       i = n-1;
-       break;
+        face = Standard_False;
+        if ((a[i][1] == 'W') || (a[i][1] == 'w')) {
+          close = Standard_False;
+        }
+        i = n-1;
+        break;
 
       default:
-       di <<"profile : unknown code " << a[i];
-       return 1;
+        di <<"profile : unknown code " << a[i];
+        return 1;
       }
     }
   }
@@ -1005,109 +1005,109 @@ static Standard_Integer bsplineprof(Draw_Interpretor& di,
 //  to be done : close the profile using the first point of the contour
 //               and the point taken with mouse button 3 
 //
- Handle(Geom2d_BSplineCurve) C ;
- Handle(Geom_Curve) curve3d_ptr ;
- Standard_Integer id, ii;
- Standard_Integer X,Y,b, not_done;
- Standard_Integer num_points = 0  ;
- gp_Pnt2d a_point(  0.0e0,
-                  0.0e0) ;
+  Handle(Geom2d_BSplineCurve) C ;
+  Handle(Geom_Curve) curve3d_ptr ;
+  Standard_Integer id, ii;
+  Standard_Integer X,Y,b, not_done;
+  Standard_Integer num_points = 0  ;
+  gp_Pnt2d a_point(  0.0e0,
+    0.0e0) ;
   Handle(TColgp_HArray1OfPnt2d) points_array_ptr = 
     new TColgp_HArray1OfPnt2d(1, 1);               
   Handle(TColgp_HArray1OfPnt2d) new_points_array_ptr ;
 
   not_done = 1 ;
   while (not_done) {
-   
-   dout.Select(id,X,Y,b,wait);
-   Standard_Real z = dout.Zoom(id);
-   a_point.SetCoord(1,(Standard_Real)X /z) ;
-   a_point.SetCoord(2,(Standard_Real)Y /z) ;
-   if (num_points == 0) {
-     points_array_ptr = 
-       new TColgp_HArray1OfPnt2d(1, 1); 
-     points_array_ptr->ChangeArray1()(1) = a_point ;
-     first_point = a_point ;
-
-   }
-   num_points += 1 ;
-   if (num_points >= 2) {
-     new_points_array_ptr = 
-     new TColgp_HArray1OfPnt2d(1, num_points);
-     for (ii = 1 ; ii <= num_points -1 ; ii++) {
-       new_points_array_ptr->ChangeArray1()(ii) =
-        points_array_ptr->Array1()(ii) ;
-     }
-     new_points_array_ptr->ChangeArray1()(num_points) = a_point ;
-     Geom2dAPI_Interpolate    a2dInterpolator(new_points_array_ptr,
-                                             Standard_False,
-                                             1.0e-5) ;
-     a2dInterpolator.Perform() ;
-     if (a2dInterpolator.IsDone()) { 
-           C = a2dInterpolator.Curve() ;
-            curve3d_ptr =
-            GeomAPI::To3d(C,P) ;
-           DrawTrSurf::Set(a[1], curve3d_ptr);
-           dout.RepaintView(id);
-     }
-     points_array_ptr = new_points_array_ptr ;
-
-   }
-       
-   if (b == 2 || b == 3) {
-     if (num_points == 2)  {
+
+    dout.Select(id,X,Y,b,wait);
+    Standard_Real z = dout.Zoom(id);
+    a_point.SetCoord(1,(Standard_Real)X /z) ;
+    a_point.SetCoord(2,(Standard_Real)Y /z) ;
+    if (num_points == 0) {
+      points_array_ptr = 
+        new TColgp_HArray1OfPnt2d(1, 1); 
+      points_array_ptr->ChangeArray1()(1) = a_point ;
+      first_point = a_point ;
+
+    }
+    num_points += 1 ;
+    if (num_points >= 2) {
+      new_points_array_ptr = 
+        new TColgp_HArray1OfPnt2d(1, num_points);
+      for (ii = 1 ; ii <= num_points -1 ; ii++) {
+        new_points_array_ptr->ChangeArray1()(ii) =
+          points_array_ptr->Array1()(ii) ;
+      }
+      new_points_array_ptr->ChangeArray1()(num_points) = a_point ;
+      Geom2dAPI_Interpolate    a2dInterpolator(new_points_array_ptr,
+        Standard_False,
+        1.0e-5) ;
+      a2dInterpolator.Perform() ;
+      if (a2dInterpolator.IsDone()) { 
+        C = a2dInterpolator.Curve() ;
+        curve3d_ptr =
+          GeomAPI::To3d(C,P) ;
+        DrawTrSurf::Set(a[1], curve3d_ptr);
+        dout.RepaintView(id);
+      }
+      points_array_ptr = new_points_array_ptr ;
+
+    }
+
+    if (b == 2 || b == 3) {
+      if (num_points == 2)  {
         x = last_point.Coord(1) ;
         y = last_point.Coord(2) ;
         dx = a_point.Coord(1) - x ;
         dy = a_point.Coord(2) - y ;
         gp_Vec2d a_vector(dx,
-                          dy) ;
+          dy) ;
         length = a_vector.Magnitude() ;
-       Handle(Geom2d_Line) l = 
-         new Geom2d_Line(gp_Pnt2d(x,y),gp_Dir2d(dx,dy));
-       if (isplanar) {
-         MW.Add(BRepBuilderAPI_MakeEdge(GeomAPI::To3d(l,P),0,length));
+        Handle(Geom2d_Line) l = 
+          new Geom2d_Line(gp_Pnt2d(x,y),gp_Dir2d(dx,dy));
+        if (isplanar) {
+          MW.Add(BRepBuilderAPI_MakeEdge(GeomAPI::To3d(l,P),0,length));
         }
-       else { 
-         MW.Add(BRepBuilderAPI_MakeEdge(l,Surface,0,length));
+        else { 
+          MW.Add(BRepBuilderAPI_MakeEdge(l,Surface,0,length));
         }
 
       }
-    else if (num_points > 2) {
+      else if (num_points > 2) {
         if (isplanar) {
-         MW.Add(BRepBuilderAPI_MakeEdge(curve3d_ptr,
-                                  curve3d_ptr->FirstParameter(),
-                                  curve3d_ptr->LastParameter()));
+          MW.Add(BRepBuilderAPI_MakeEdge(curve3d_ptr,
+            curve3d_ptr->FirstParameter(),
+            curve3d_ptr->LastParameter()));
         }
-       else { 
-         MW.Add(BRepBuilderAPI_MakeEdge(C,
-                                  Surface,
-                                  C->FirstParameter(),
-                                  C->LastParameter()));
+        else { 
+          MW.Add(BRepBuilderAPI_MakeEdge(C,
+            Surface,
+            C->FirstParameter(),
+            C->LastParameter()));
         }
       }
-     if (num_points >= 2) {
-       last_point = a_point ;
-       points_array_ptr->ChangeArray1()(1) = a_point ;
-       num_points = 1 ;
-       DBRep::Set(a[1], MW.Wire()) ;
-     }      
-    
-  
-   }
-   if (b == 3) {
-     not_done = 0 ; 
-   }
- }
+      if (num_points >= 2) {
+        last_point = a_point ;
+        points_array_ptr->ChangeArray1()(1) = a_point ;
+        num_points = 1 ;
+        DBRep::Set(a[1], MW.Wire()) ;
+      }      
+
+
+    }
+    if (b == 3) {
+      not_done = 0 ; 
+    }
+  }
   a_point = first_point ;
   if (close) {
-    
+
     x = last_point.Coord(1) ;
     y = last_point.Coord(2) ;
     dx = a_point.Coord(1) - x ;
     dy = a_point.Coord(2) - y ;
     gp_Vec2d a_vector(dx,
-                     dy) ;
+      dy) ;
     length = a_vector.Magnitude() ;
     Handle(Geom2d_Line) l = 
       new Geom2d_Line(gp_Pnt2d(x,y),gp_Dir2d(dx,dy));
@@ -1129,17 +1129,17 @@ static Standard_Integer bsplineprof(Draw_Interpretor& di,
   else {
     S = MW;
   }
-  
+
   if (!TheLocation.IsIdentity())
     S.Move(TheLocation);
-  
+
   if ( !isplanar) {
     Standard_Real Tol = 1.e-5;
     BRepLib::BuildCurves3d(S,Tol);
   }
-  
+
   DBRep::Set(a[1],S);
-  
+
   return 0;
 }
 
@@ -1151,8 +1151,8 @@ static Standard_Integer bsplineprof(Draw_Interpretor& di,
 //=======================================================================
 
 static Standard_Integer profile2d(Draw_Interpretor& di, 
-                                 Standard_Integer n, 
-                                 const char** a)
+  Standard_Integer n, 
+  const char** a)
 {
   // this command build a profile with 2d curves.
   // from a moving point
@@ -1233,8 +1233,8 @@ static Standard_Integer profile2d(Draw_Interpretor& di,
       i += 2;
       if (i >= n) goto badargs;
       if (!first) {
-       di << "profile: The F instruction must precede all moves";
-       return 1;
+        di << "profile: The F instruction must precede all moves";
+        return 1;
       }
       x0 = x = Draw::Atof(a[i-1]);
       y0 = y = Draw::Atof(a[i]);
@@ -1247,24 +1247,24 @@ static Standard_Integer profile2d(Draw_Interpretor& di,
       if (i >= n) goto badargs;
       length = Draw::Atof(a[i]);
       if ((a[i-1][1] == 'X') || (a[i-1][1] == 'x')) {
-       length -= x;
+        length -= x;
       }
       dx = 1; dy = 0;
       move = line;
       break;
-      
+
     case 'Y':
     case 'y':
       i++;
       if (i >= n) goto badargs;
       length = Draw::Atof(a[i]);
       if ((a[i-1][1] == 'Y') || (a[i-1][1] == 'y')) {
-       length -= y;
+        length -= y;
       }
       dx = 0; dy = 1;
       move = line;
       break;
-      
+
     case 'L':
     case 'l':
       i++;
@@ -1278,18 +1278,18 @@ static Standard_Integer profile2d(Draw_Interpretor& di,
       i += 2;
       if (i >= n) goto badargs;
       {
-       Standard_Real vx = Draw::Atof(a[i-1]);
-       Standard_Real vy = Draw::Atof(a[i]);
-       if ((a[i-2][1] == 'T') || (a[i-2][1] == 't')) {
-         vx -= x;
-         vy -= y;
-       }
-       length = Sqrt(vx*vx+vy*vy);
-       if (length > Precision::Confusion()) {
-         move = line;
-         dx = vx / length;
-         dy = vy / length;
-       }
+        Standard_Real vx = Draw::Atof(a[i-1]);
+        Standard_Real vy = Draw::Atof(a[i]);
+        if ((a[i-2][1] == 'T') || (a[i-2][1] == 't')) {
+          vx -= x;
+          vy -= y;
+        }
+        length = Sqrt(vx*vx+vy*vy);
+        if (length > Precision::Confusion()) {
+          move = line;
+          dx = vx / length;
+          dy = vy / length;
+        }
       }
       break;
 
@@ -1299,15 +1299,15 @@ static Standard_Integer profile2d(Draw_Interpretor& di,
       if (i >= n) goto badargs;
       angle = Draw::Atof(a[i]) * (M_PI / 180.0);
       if ((a[i-1][1] == 'R') || (a[i-1][1] == 'r')) {
-       dx = Cos(angle);
-       dy = Sin(angle);
+        dx = Cos(angle);
+        dy = Sin(angle);
       }
       else {
-       Standard_Real c = Cos(angle);
-       Standard_Real s = Sin(angle);
-       Standard_Real t = c * dx - s * dy;
-       dy = s * dx + c * dy;
-       dx = t;
+        Standard_Real c = Cos(angle);
+        Standard_Real s = Sin(angle);
+        Standard_Real t = c * dx - s * dy;
+        dy = s * dx + c * dy;
+        dx = t;
       }
       break;
 
@@ -1316,14 +1316,14 @@ static Standard_Integer profile2d(Draw_Interpretor& di,
       i += 2;
       if (i >= n) goto badargs;
       {
-       Standard_Real vx = Draw::Atof(a[i-1]);
-       Standard_Real vy = Draw::Atof(a[i]);
-       length = Sqrt(vx*vx+vy*vy);
-       if (length > Precision::Confusion()) {
-         // move = line; DUB
-         dx = vx / length;
-         dy = vy / length;
-       }
+        Standard_Real vx = Draw::Atof(a[i-1]);
+        Standard_Real vy = Draw::Atof(a[i]);
+        length = Sqrt(vx*vx+vy*vy);
+        if (length > Precision::Confusion()) {
+          // move = line; DUB
+          dx = vx / length;
+          dy = vy / length;
+        }
       }
       break;
 
@@ -1333,8 +1333,8 @@ static Standard_Integer profile2d(Draw_Interpretor& di,
       if (i >= n) goto badargs;
       radius = Draw::Atof(a[i-1]);
       if (Abs(radius) > Precision::Confusion()) {
-       angle = Draw::Atof(a[i]) * (M_PI / 180.0);
-       move = circle;
+        angle = Draw::Atof(a[i]) * (M_PI / 180.0);
+        move = circle;
       }
       break;
 
@@ -1344,22 +1344,22 @@ static Standard_Integer profile2d(Draw_Interpretor& di,
       if (i >= n) goto badargs;
       length = Draw::Atof(a[i]);
       if ((a[i-1][1] == 'X') || (a[i-1][1] == 'x')) {
-       if (Abs(dx) < Precision::Confusion()) {
-         di << "Profile : cannot intersect, arg " << i-1;
-         return 1;
-       }
-       length = (length - x) / dx;
-       move = line;
+        if (Abs(dx) < Precision::Confusion()) {
+          di << "Profile : cannot intersect, arg " << i-1;
+          return 1;
+        }
+        length = (length - x) / dx;
+        move = line;
       }
       else if ((a[i-1][1] == 'Y') || (a[i-1][1] == 'y')) {
-       if (Abs(dy) < Precision::Confusion()) {
-         di << "Profile : cannot intersect, arg " << i-1;
-         return 1;
-       }
-       length = (length - y) / dy;
-       move = line;
+        if (Abs(dy) < Precision::Confusion()) {
+          di << "Profile : cannot intersect, arg " << i-1;
+          return 1;
+        }
+        length = (length - y) / dy;
+        move = line;
       }
-     
+
       break;
 
     case 'W':
@@ -1367,63 +1367,63 @@ static Standard_Integer profile2d(Draw_Interpretor& di,
       close = Standard_False;
       i = n-1;
       break;
-      
+
     default:
       di <<"profile : unknown code " << a[i];
       return 1;
     }
 
-  again:
-    
+again:
+
     switch (move) {
-      
+
     case line :
       {
-       if (length < 0) {
-         length = -length;
-         dx = -dx;
-         dy = -dy;
-       }
-       Handle(Geom2d_Line) l = new Geom2d_Line(gp_Pnt2d(x,y),gp_Dir2d(dx,dy));
-       Handle(Geom2d_TrimmedCurve) ct = 
-         new Geom2d_TrimmedCurve(l,0,length);
-       NbCurves++;
-       Sprintf(name,"%s_%d",a[1],NbCurves);
-       DrawTrSurf::Set(name,ct);
-       di.AppendElement(name);
-       x += length*dx;
-       y += length*dy;
+        if (length < 0) {
+          length = -length;
+          dx = -dx;
+          dy = -dy;
+        }
+        Handle(Geom2d_Line) l = new Geom2d_Line(gp_Pnt2d(x,y),gp_Dir2d(dx,dy));
+        Handle(Geom2d_TrimmedCurve) ct = 
+          new Geom2d_TrimmedCurve(l,0,length);
+        NbCurves++;
+        Sprintf(name,"%s_%d",a[1],NbCurves);
+        DrawTrSurf::Set(name,ct);
+        di.AppendElement(name);
+        x += length*dx;
+        y += length*dy;
       }
       break;
 
     case circle :
       {
-       Standard_Boolean sense = Standard_True;
-       if (radius < 0) {
-         radius = -radius;
-         sense = !sense;
-         dx = -dx;
-         dy = -dy;
-       }
-       gp_Ax2d ax(gp_Pnt2d(x-radius*dy,y+radius*dx),gp_Dir2d(dy,-dx));
-       if (angle < 0) {
-         angle = -angle;
-         sense = !sense;
-       }
-       Handle(Geom2d_Circle) c = new Geom2d_Circle(ax,radius,sense);
-       Handle(Geom2d_TrimmedCurve) ct = 
-         new Geom2d_TrimmedCurve(c,0,angle);
-       NbCurves++;
-       Sprintf(name,"%s_%d",a[1],NbCurves);
-       DrawTrSurf::Set(name,ct);       
-       di.AppendElement(name);
-       gp_Pnt2d p;
-       gp_Vec2d v;
-       c->D1(angle,p,v);
-       x = p.X();
-       y = p.Y();
-       dx = v.X() / radius;
-       dy = v.Y() / radius;
+        Standard_Boolean sense = Standard_True;
+        if (radius < 0) {
+          radius = -radius;
+          sense = !sense;
+          dx = -dx;
+          dy = -dy;
+        }
+        gp_Ax2d ax(gp_Pnt2d(x-radius*dy,y+radius*dx),gp_Dir2d(dy,-dx));
+        if (angle < 0) {
+          angle = -angle;
+          sense = !sense;
+        }
+        Handle(Geom2d_Circle) c = new Geom2d_Circle(ax,radius,sense);
+        Handle(Geom2d_TrimmedCurve) ct = 
+          new Geom2d_TrimmedCurve(c,0,angle);
+        NbCurves++;
+        Sprintf(name,"%s_%d",a[1],NbCurves);
+        DrawTrSurf::Set(name,ct);      
+        di.AppendElement(name);
+        gp_Pnt2d p;
+        gp_Vec2d v;
+        c->D1(angle,p,v);
+        x = p.X();
+        y = p.Y();
+        dx = v.X() / radius;
+        dy = v.Y() / radius;
       }
       break;
 
@@ -1443,10 +1443,10 @@ static Standard_Integer profile2d(Draw_Interpretor& di,
       dy = y0-y;
       length = Sqrt(dx*dx+dy*dy);
       if (length > Precision::Confusion()) {
-       move = line;
-       dx = dx / length;
-       dy = dy / length;
-       goto again;
+        move = line;
+        dx = dx / length;
+        dy = dy / length;
+        goto again;
       }
     }
   }
@@ -1462,7 +1462,7 @@ static Standard_Integer profile2d(Draw_Interpretor& di,
 
   return 0;
 
- badargs:
+badargs:
   di << "profile : bad number of arguments";
   return 1;
 }
@@ -1475,7 +1475,7 @@ static Standard_Integer profile2d(Draw_Interpretor& di,
 //=======================================================================
 
 Standard_Integer mkoffset(Draw_Interpretor& di, 
-                         Standard_Integer n, const char** a)
+  Standard_Integer n, const char** a)
 {
   if (n < 5) return 1;
   char name[100];
@@ -1484,22 +1484,22 @@ Standard_Integer mkoffset(Draw_Interpretor& di,
   TopoDS_Shape Base = DBRep::Get(a[2],TopAbs_FACE);
 
   if ( Base.IsNull())
-    {
+  {
     Base = DBRep::Get(a[2]);
     if (Base.IsNull()) return 1;
     Paral.Init(GeomAbs_Arc);
     TopExp_Explorer exp;
     for (exp.Init(Base,TopAbs_WIRE); exp.More(); exp.Next())
-      {
+    {
       TopoDS_Wire aLocalShape = TopoDS::Wire(exp.Current());
       Paral.AddWire(aLocalShape);
-      }
     }
+  }
   else
-    {
+  {
     Base.Orientation(TopAbs_FORWARD);
     Paral.Init(TopoDS::Face(Base));
-    }
+  }
 
   Standard_Real U, dU;
   Standard_Integer Nb;
@@ -1513,25 +1513,25 @@ Standard_Integer mkoffset(Draw_Interpretor& di,
   Standard_Integer Compt = 1;
 
   for ( Standard_Integer i = 1; i <= Nb; i++)
-    {
+  {
     U = i * dU;
     Paral.Perform(U,Alt);
 
     if ( !Paral.IsDone())
-      {
+    {
       di << " Error: Offset is not done." << "\n";
       return 1;
-      }
+    }
     else
-      {
+    {
       Sprintf(name,"%s_%d", a[1], Compt++);
       char* temp = name; // portage WNT
       DBRep::Set(temp,Paral.Shape());
-      }
     }
+  }
 
   return 0;
-  }
+}
 
 //=======================================================================
 //function : pickface
@@ -1539,13 +1539,13 @@ Standard_Integer mkoffset(Draw_Interpretor& di,
 //=======================================================================
 
 Standard_Integer pickface(Draw_Interpretor& di, 
-                         Standard_Integer , const char** )
+  Standard_Integer , const char** )
 {
   Standard_CString pick_name=".";
-  
+
   TopoDS_Shape S = DBRep::Get(pick_name,TopAbs_FACE);
   if (S.IsNull()) return 1;
-  
+
   char* name = new char[100];
   Sprintf(name,"PickedFace %s",pick_name);
   DBRep::Set(name,S);
@@ -1555,7 +1555,7 @@ Standard_Integer pickface(Draw_Interpretor& di,
 
 
 Standard_Integer edgeintersector(Draw_Interpretor& di,
-                                Standard_Integer n, const char** a)
+  Standard_Integer n, const char** a)
 {
   if (n < 5) return 1;
 
@@ -1572,7 +1572,7 @@ Standard_Integer edgeintersector(Draw_Interpretor& di,
   TopoDS_Face F  = TopoDS::Face(aLocalShape);
 //  TopoDS_Face F  = TopoDS::Face(DBRep::Get(a[4],TopAbs_FACE));
   if ( F.IsNull()) return 1;
-  
+
   TopOpeBRep_EdgesIntersector EInter;
   char name[100];
   //------------------------------------------------------
@@ -1584,7 +1584,7 @@ Standard_Integer edgeintersector(Draw_Interpretor& di,
   EInter.ForceTolerances(TolInter,TolInter);
   Standard_Boolean reducesegments = Standard_True;
   EInter.Perform (E[0],E[1],reducesegments);
-  
+
   if (EInter.IsEmpty()) {
     //cout << " No intersection found" << endl;
     di << " No intersection found" << "\n";
@@ -1611,29 +1611,29 @@ Standard_Integer edgeintersector(Draw_Interpretor& di,
       // it is necessary to code it internally
       //---------------------------------------------------------------
       Standard_Real U = P2D.Parameter(i);
-      
+
       V.Orientation(TopAbs_INTERNAL);
       B.UpdateVertex(V,U,E[i-1],Tol);
-//      B.UpdateVertex(TopoDS::Vertex(V.Oriented(TopAbs_INTERNAL)),
-//                  U,E[i-1],Tol);
+      //      B.UpdateVertex(TopoDS::Vertex(V.Oriented(TopAbs_INTERNAL)),
+      //                    U,E[i-1],Tol);
       //---------------------------------------------------------------
       // Orientation of vertex in the transition.
       //---------------------------------------------------------------
       TopAbs_Orientation OO = TopAbs_REVERSED;
       if (P2D.IsVertex(i)) {
-       OO = P2D.Vertex(i).Orientation();
+        OO = P2D.Vertex(i).Orientation();
       }
       else if (P2D.Transition(i).Before() == TopAbs_OUT) {
-       OO = TopAbs_FORWARD;
+        OO = TopAbs_FORWARD;
       }
       //cout << " Orientation of vertex " << NbV << " on " << a[i+1] << ": ";
       di << " Orientation of vertex " << NbV << " on " << a[i+1] << ": ";
       if (OO == TopAbs_FORWARD) {
-       //cout << "FORWARD" << endl;
-       di << "FORWARD" << "\n";
+        //cout << "FORWARD" << endl;
+        di << "FORWARD" << "\n";
       } else {
-       //cout << "REVERSED" << endl;
-       di << "REVERSED" << "\n";
+        //cout << "REVERSED" << endl;
+        di << "REVERSED" << "\n";
       }
     }
   }
@@ -1650,12 +1650,12 @@ Standard_Integer edgeintersector(Draw_Interpretor& di,
 Standard_Integer concatC0wire(Draw_Interpretor&, Standard_Integer n, const char** c)
 {
   if ( n < 3 ) return 1;                               
-  
+
   TopoDS_Shape S = DBRep::Get(c[2],TopAbs_WIRE) ;
 
   if (S.IsNull())
     return 1;                            //test if the shape is empty
-  
+
   TopoDS_Wire W = TopoDS::Wire(S) ;
   TopoDS_Shape res;
 
@@ -1672,22 +1672,20 @@ Standard_Integer concatC0wire(Draw_Interpretor&, Standard_Integer n, const char*
 //=======================================================================
 
 static Standard_Integer concatwire(Draw_Interpretor&, Standard_Integer n, const char** c)
-{ GeomAbs_Shape Option=GeomAbs_C1;
+{
+  GeomAbs_Shape Option=GeomAbs_C1;
+  if ( n < 3 ) return 1;
 
-  if ( n < 3 ) return 1;                               
-  
   if(n==4)                                              //check if it's C1 or G1
-    if (! strcmp(c[3],"G1"))
-      Option=GeomAbs_G1;
-  
+  if (! strcmp(c[3],"G1"))
+    Option=GeomAbs_G1;
+
   TopoDS_Shape S = DBRep::Get(c[2],TopAbs_WIRE) ;
 
   if (S.IsNull()) return 1 ;                            //test if the shape is empty
   
   TopoDS_Wire W = TopoDS::Wire(S) ;
   TopoDS_Wire res;
-
-
   res=BRepAlgo::ConcatenateWire(W,Option);              //processing
   DBRep::Set(c[1],res);
   return 0;
@@ -1699,7 +1697,7 @@ static Standard_Integer concatwire(Draw_Interpretor&, Standard_Integer n, const
 //=======================================================================
 
 Standard_Integer  build3d(Draw_Interpretor& di, 
-                         Standard_Integer n, const char** a)
+  Standard_Integer n, const char** a)
 {
 
   if ( (n <2) || (n>3) ) {
@@ -1707,11 +1705,11 @@ Standard_Integer  build3d(Draw_Interpretor& di,
     di << " 1 or 2 arguments expected" << "\n";
     return 1;
   }
-    
+
   Standard_Boolean Ok;
   TopoDS_Shape S = DBRep::Get(a[1],TopAbs_FACE);
   if (S.IsNull()) return 1;
-  
+
   if (n==2) { Ok = BRepLib::BuildCurves3d(S); }
   else      { Ok = BRepLib::BuildCurves3d(S,Draw::Atof(a[2])); }
   //if (!Ok) {cout << " one of the computation failed" << endl;}
@@ -1726,7 +1724,7 @@ Standard_Integer  build3d(Draw_Interpretor& di,
 //=======================================================================
 
 Standard_Integer reducepcurves(Draw_Interpretor& di, 
-                               Standard_Integer n, const char** a)
+  Standard_Integer n, const char** a)
 {
   if (n < 2) return 1;
 
@@ -1740,7 +1738,7 @@ Standard_Integer reducepcurves(Draw_Interpretor& di,
     else
       BRepTools::RemoveUnusedPCurves(aShape);
   }
-  
+
   return 0;
 }
 
@@ -1761,110 +1759,110 @@ void  BRepTest::CurveCommands(Draw_Interpretor& theCommands)
   const char* g = "TOPOLOGY Curve topology commands";
 
   theCommands.Add("vertex",
-                 "vertex name [x y z / p edge]",__FILE__,
-                 vertex,g);
+    "vertex name [x y z / p edge]",__FILE__,
+    vertex,g);
 
   theCommands.Add("etrim",
-                 "etrim edge v1 [v2]",__FILE__,
-                 trim,g);
+    "etrim edge v1 [v2]",__FILE__,
+    trim,g);
 
   theCommands.Add("range",
-                 "range edge [face] first last",__FILE__,
-                 range,g);
+    "range edge [face] first last",__FILE__,
+    range,g);
 
   theCommands.Add("polyline",
-                 "polyline name x1 y1 z1 x2 y2 z2 ...",__FILE__,
-                 polyline,g);
+    "polyline name x1 y1 z1 x2 y2 z2 ...",__FILE__,
+    polyline,g);
 
   theCommands.Add("polyvertex",
-                 "polyvertex name v1 v2 ...",__FILE__,
-                 polyvertex,g);
+    "polyvertex name v1 v2 ...",__FILE__,
+    polyvertex,g);
 
   theCommands.Add("wire",
-                 "wire wirename e1/w1 [e2/w2 ...]",__FILE__,
-                 wire,g);
+    "wire wirename e1/w1 [e2/w2 ...]",__FILE__,
+    wire,g);
 
   theCommands.Add("profile",
-                 "profile, no args to get help",__FILE__,
-                 profile,g);
+    "profile, no args to get help",__FILE__,
+    profile,g);
 
   theCommands.Add("bsplineprof",
-                 "bsplineprof, no args to get help",__FILE__,
-                 bsplineprof,g);
+    "bsplineprof, no args to get help",__FILE__,
+    bsplineprof,g);
 
   theCommands.Add("2dprofile",
-                 "2dprofile, no args to get help",__FILE__,
-                 profile2d,g);
+    "2dprofile, no args to get help",__FILE__,
+    profile2d,g);
 
   theCommands.Add("mkoffset",
-                 "mkoffset result face/compound of wires  nboffset stepoffset [alt]",__FILE__,
-                 mkoffset);
+    "mkoffset result face/compound of wires  nboffset stepoffset [alt]",__FILE__,
+    mkoffset);
 
 
   theCommands.Add("mkedge",
-                 "mkedge edge curve [surface] [pfirst plast] [vfirst [pfirst] vlast [plast]] ",__FILE__,
-                 mkedge,g);
-  
+    "mkedge edge curve [surface] [pfirst plast] [vfirst [pfirst] vlast [plast]] ",__FILE__,
+    mkedge,g);
+
   theCommands.Add("mkcurve",
-                 "mkcurve curve edge",__FILE__,
-                 mkcurve,g);
+    "mkcurve curve edge",__FILE__,
+    mkcurve,g);
 
   theCommands.Add("mkoricurve",
-                 "mkoricurve curve edge: \n  the curve is colored according to the orientation of the edge",
-                 __FILE__,
-                 mkcurve,g);
+    "mkoricurve curve edge: \n  the curve is colored according to the orientation of the edge",
+    __FILE__,
+    mkcurve,g);
 
   theCommands.Add("mk2dcurve",
-                 "mk2dcurve curve edge [face]",__FILE__,
-                 mk2dcurve,g);
+    "mk2dcurve curve edge [face]",__FILE__,
+    mk2dcurve,g);
 
   theCommands.Add("mkpoint",
-                 "mkpoint point vertex",__FILE__,
-                 mkpoint,g);
+    "mkpoint point vertex",__FILE__,
+    mkpoint,g);
 
   theCommands.Add("uisoedge",
-                 "uisoedge edge face u v1 v2",__FILE__,
-                 isoedge,g);
-  
+    "uisoedge edge face u v1 v2",__FILE__,
+    isoedge,g);
+
   theCommands.Add("edge",
-                 "edge edgename v1 v2",__FILE__,
-                 edge,g);
-  
+    "edge edgename v1 v2",__FILE__,
+    edge,g);
+
   theCommands.Add("visoedge",
-                 "visoedge edge face v u1 u2",__FILE__,
-                 isoedge,g);
+    "visoedge edge face v u1 u2",__FILE__,
+    isoedge,g);
 
   theCommands.Add("transfert",
-                 "transfert edge1 edge2",__FILE__,
-                 transfert,g);
+    "transfert edge1 edge2",__FILE__,
+    transfert,g);
 
   theCommands.Add("pickface",
-                 "pickface",__FILE__,
-                 pickface,g);
+    "pickface",__FILE__,
+    pickface,g);
 
   theCommands.Add("edgeintersector",
-                 "edgeintersector r E1 E2 F [Tol]",__FILE__,
-                 edgeintersector,g);
+    "edgeintersector r E1 E2 F [Tol]",__FILE__,
+    edgeintersector,g);
 
   theCommands.Add("build3d",
-                 "build3d S [tol]",
-                 build3d, g);
+    "build3d S [tol]",
+    build3d, g);
 
   theCommands.Add("reducepcurves",
-                 "reducepcurves shape1 shape2 ...",
-                 reducepcurves, g);
+    "reducepcurves shape1 shape2 ...",
+    reducepcurves, g);
 
   theCommands.Add("concatC0wire",
-                 "concatC0wire result wire",
-                 __FILE__,
-                 concatC0wire,
-                 g);
+    "concatC0wire result wire",
+    __FILE__,
+    concatC0wire,
+    g);
 
   theCommands.Add("concatwire",
-                 "concatwire result wire [option](G1/C1)",
-                 __FILE__,
-                 concatwire,
-                 g);
+    "concatwire result wire [option](G1/C1)",
+    __FILE__,
+    concatwire,
+    g);
 }
 
 
index 96dfd41..d2e4a47 100755 (executable)
@@ -34,19 +34,19 @@ Extrema_ExtPElC2d::Extrema_ExtPElC2d () { myDone = Standard_False; }
 
 Extrema_ExtPElC2d::Extrema_ExtPElC2d 
   (const gp_Pnt2d&     P, 
-   const gp_Lin2d&     L,
-   const Standard_Real Tol,
-   const Standard_Real Uinf, 
-   const Standard_Real Usup)
+  const gp_Lin2d&     L,
+  const Standard_Real Tol,
+  const Standard_Real Uinf, 
+  const Standard_Real Usup)
 {
   Perform(P, L, Tol, Uinf, Usup);
 }
 
 void Extrema_ExtPElC2d::Perform(const gp_Pnt2d&     P, 
-                               const gp_Lin2d&     L,
-                               const Standard_Real Tol,
-                               const Standard_Real Uinf, 
-                               const Standard_Real Usup)
+  const gp_Lin2d&     L,
+  const Standard_Real Tol,
+  const Standard_Real Uinf, 
+  const Standard_Real Usup)
 {
   myDone = Standard_True;
   gp_Pnt2d OR, MyP;
@@ -57,13 +57,13 @@ void Extrema_ExtPElC2d::Perform(const gp_Pnt2d&     P,
   gp_Vec2d V(OR, P);
   Standard_Real Mydist = V1.Dot(V);
   if ((Mydist >= Uinf -Tol) && 
-      (Mydist <= Usup+ Tol)){ 
-    myNbExt = 1;
-    MyP = OR.Translated(Mydist*V1);
-    Extrema_POnCurv2d MyPOnCurve(Mydist, MyP);
-    mySqDist[0] = P.SquareDistance(MyP);
-    myPoint[0] = MyPOnCurve;
-    myIsMin[0] = Standard_True;
+    (Mydist <= Usup+ Tol)){ 
+      myNbExt = 1;
+      MyP = OR.Translated(Mydist*V1);
+      Extrema_POnCurv2d MyPOnCurve(Mydist, MyP);
+      mySqDist[0] = P.SquareDistance(MyP);
+      myPoint[0] = MyPOnCurve;
+      myIsMin[0] = Standard_True;
   }
 }
 
@@ -71,30 +71,32 @@ void Extrema_ExtPElC2d::Perform(const gp_Pnt2d&     P,
 
 Extrema_ExtPElC2d::Extrema_ExtPElC2d 
   (const gp_Pnt2d&     P, 
-   const gp_Circ2d&    C,
-   const Standard_Real Tol,
-   const Standard_Real Uinf, 
-   const Standard_Real Usup)
+  const gp_Circ2d&    C,
+  const Standard_Real Tol,
+  const Standard_Real Uinf, 
+  const Standard_Real Usup)
 {
   Perform(P, C, Tol, Uinf, Usup);
 }
 
 void Extrema_ExtPElC2d::Perform(const gp_Pnt2d&     P, 
-                               const gp_Circ2d&    C,
-                               const Standard_Real Tol,
-                               const Standard_Real Uinf, 
-                               const Standard_Real Usup)
+  const gp_Circ2d&    C,
+  const Standard_Real Tol,
+  const Standard_Real Uinf, 
+  const Standard_Real Usup)
 {
-  Standard_Real radius, U1, U2;
-//  gp_Pnt2d OC, P1, P2, OL;
-  gp_Pnt2d OC, P1, P2;
-  OC      = C.Location();
+  //  gp_Pnt2d OC, P1, P2, OL;
+  gp_Pnt2d OC(C.Location());
   myNbExt = 0;
-  
+
   if (OC.IsEqual(P, Precision::Confusion())) {
     myDone = Standard_False;
   }
-  else {
+  else
+  {
+    Standard_Real radius, U1, U2;
+    gp_Pnt2d P1, P2;
+
     myDone = Standard_True;
     gp_Dir2d V(gp_Vec2d(P, OC));
     radius = C.Radius();
@@ -105,18 +107,29 @@ void Extrema_ExtPElC2d::Perform(const gp_Pnt2d&     P,
     Standard_Real myuinf = Uinf;
     ElCLib::AdjustPeriodic(Uinf, Uinf+2*M_PI, Precision::PConfusion(), myuinf, U1);
     ElCLib::AdjustPeriodic(Uinf, Uinf+2*M_PI, Precision::PConfusion(), myuinf, U2);
-    if (((U1-2*M_PI-Uinf) < Tol) && ((U1-2*M_PI-Uinf) > -Tol)) U1 = Uinf;
-    if (((U2-2*M_PI-Uinf) < Tol) && ((U2-2*M_PI-Uinf) > -Tol)) U2 = Uinf;
+    if (((U1-2*M_PI-Uinf) < Tol) && ((U1-2*M_PI-Uinf) > -Tol))
+    {
+      U1 = Uinf;
+      P1 = OC.XY() + radius * (cos(U1) * C.XAxis().Direction().XY() + sin(U1) * C.YAxis().Direction().XY());
+    }
 
-    if (((Uinf-U1) < Tol) && ((U1-Usup) < Tol)) {
+    if (((U2-2*M_PI-Uinf) < Tol) && ((U2-2*M_PI-Uinf) > -Tol))
+    {
+      U2 = Uinf;
+      P2 = OC.XY() + radius * (cos(U2) * C.XAxis().Direction().XY() + sin(U2) * C.YAxis().Direction().XY());
+    }
+
+    if (((Uinf-U1) < Tol) && ((U1-Usup) < Tol))
+    {
       Extrema_POnCurv2d MyPOnCurve(U1, P1);
       mySqDist[0] = P.SquareDistance(P1);
       myPoint[0] = MyPOnCurve;
       myIsMin[0] = Standard_True;
       myNbExt++;
     }
-    
-    if (((Uinf-U2) < Tol) && ((U2-Usup) < Tol)) {
+
+    if (((Uinf-U2) < Tol) && ((U2-Usup) < Tol))
+    {
       Extrema_POnCurv2d MyPOnCurve(U2, P2);
       mySqDist[myNbExt] = P.SquareDistance(P2);
       myPoint[myNbExt] = MyPOnCurve;
@@ -130,10 +143,10 @@ void Extrema_ExtPElC2d::Perform(const gp_Pnt2d&     P,
 
 
 Extrema_ExtPElC2d::Extrema_ExtPElC2d (const gp_Pnt2d&     P, 
-                                     const gp_Elips2d&   E,
-                                     const Standard_Real Tol,
-                                     const Standard_Real Uinf, 
-                                     const Standard_Real Usup)
+  const gp_Elips2d&   E,
+  const Standard_Real Tol,
+  const Standard_Real Uinf, 
+  const Standard_Real Usup)
 {
   Perform(P, E, Tol, Uinf, Usup);
 }
@@ -141,23 +154,23 @@ Extrema_ExtPElC2d::Extrema_ExtPElC2d (const gp_Pnt2d&     P,
 
 
 void Extrema_ExtPElC2d::Perform (const gp_Pnt2d&     P, 
-                                const gp_Elips2d&   E,
-                                const Standard_Real Tol,
-                                const Standard_Real Uinf, 
-                                const Standard_Real Usup)
+  const gp_Elips2d&   E,
+  const Standard_Real Tol,
+  const Standard_Real Uinf, 
+  const Standard_Real Usup)
 {
-//  gp_Pnt2d OR, P1, P2;
+  //  gp_Pnt2d OR, P1, P2;
   gp_Pnt2d OR;
   OR = E.Location();
-  
+
   Standard_Integer NoSol, NbSol;
   Standard_Real A = E.MajorRadius();
   Standard_Real B = E.MinorRadius();
   gp_Vec2d V(OR,P);
 
   if (OR.IsEqual(P, Precision::Confusion()) &&
-      (Abs(A-B) <= Tol)) {
-    myDone = Standard_False;
+    (Abs(A-B) <= Tol)) {
+      myDone = Standard_False;
   }
   else {
     Standard_Real X = V.Dot(gp_Vec2d(E.XAxis().Direction()));
@@ -184,20 +197,20 @@ void Extrema_ExtPElC2d::Perform (const gp_Pnt2d&     P,
 //=============================================================================
 
 Extrema_ExtPElC2d::Extrema_ExtPElC2d (const gp_Pnt2d&     P, 
-                                     const gp_Hypr2d&    C,
-                                     const Standard_Real Tol,
-                                     const Standard_Real Uinf, 
-                                     const Standard_Real Usup)
+  const gp_Hypr2d&    C,
+  const Standard_Real Tol,
+  const Standard_Real Uinf, 
+  const Standard_Real Usup)
 {
   Perform(P, C, Tol, Uinf, Usup);
 }
 
 
 void Extrema_ExtPElC2d::Perform(const gp_Pnt2d&     P, 
-                               const gp_Hypr2d&    H,
-                               const Standard_Real Tol,
-                               const Standard_Real Uinf,
-                               const Standard_Real Usup)
+  const gp_Hypr2d&    H,
+  const Standard_Real Tol,
+  const Standard_Real Uinf,
+  const Standard_Real Usup)
 {
   gp_Pnt2d O = H.Location();
   myDone = Standard_False;
@@ -223,21 +236,21 @@ void Extrema_ExtPElC2d::Perform(const gp_Pnt2d&     P,
     if (Vs > 0.) {
       Us = Log(Vs);
       if ((Us >= Uinf) && (Us <= Usup)) {
-       Cu = ElCLib::Value(Us,H);
-       DejaEnr = Standard_False;
-       for (NoExt = 0; NoExt < myNbExt; NoExt++) {
-         if (TbExt[NoExt].SquareDistance(Cu) < Tol2) {
-           DejaEnr = Standard_True;
-           break;
-         }
-       }
-       if (!DejaEnr) {
-         TbExt[myNbExt] = Cu;
-         mySqDist[myNbExt] = Cu.SquareDistance(P);
-         myIsMin[myNbExt] = (NoSol == 0);
-         myPoint[myNbExt] = Extrema_POnCurv2d(Us,Cu);
-         myNbExt++;
-       }
+        Cu = ElCLib::Value(Us,H);
+        DejaEnr = Standard_False;
+        for (NoExt = 0; NoExt < myNbExt; NoExt++) {
+          if (TbExt[NoExt].SquareDistance(Cu) < Tol2) {
+            DejaEnr = Standard_True;
+            break;
+          }
+        }
+        if (!DejaEnr) {
+          TbExt[myNbExt] = Cu;
+          mySqDist[myNbExt] = Cu.SquareDistance(P);
+          myIsMin[myNbExt] = (NoSol == 0);
+          myPoint[myNbExt] = Extrema_POnCurv2d(Us,Cu);
+          myNbExt++;
+        }
       } // if ((Us >= Uinf) && (Us <= Usup))
     } // if (Vs > 0.)
   } // for (Standard_Integer NoSol = 1; ...
@@ -247,20 +260,20 @@ void Extrema_ExtPElC2d::Perform(const gp_Pnt2d&     P,
 //=============================================================================
 
 Extrema_ExtPElC2d::Extrema_ExtPElC2d (const gp_Pnt2d&     P, 
-                                     const gp_Parab2d&   C,
-                                     const Standard_Real Tol,
-                                     const Standard_Real Uinf, 
-                                     const Standard_Real Usup)
+  const gp_Parab2d&   C,
+  const Standard_Real Tol,
+  const Standard_Real Uinf, 
+  const Standard_Real Usup)
 {
   Perform(P, C, Tol, Uinf, Usup);
 }
 
 
 void Extrema_ExtPElC2d::Perform(const gp_Pnt2d&     P,
-                               const gp_Parab2d&   C,
-                               const Standard_Real Tol,
-                               const Standard_Real Uinf, 
-                               const Standard_Real Usup)
+  const gp_Parab2d&   C,
+  const Standard_Real Tol,
+  const Standard_Real Uinf, 
+  const Standard_Real Usup)
 {
   myDone = Standard_False;
   myNbExt = 0;
@@ -286,17 +299,17 @@ void Extrema_ExtPElC2d::Perform(const gp_Pnt2d&     P,
       Cu = ElCLib::Value(Us,C);
       DejaEnr = Standard_False;
       for (NoExt = 0; NoExt < myNbExt; NoExt++) {
-       if (TbExt[NoExt].SquareDistance(Cu) < Tol2) {
-         DejaEnr = Standard_True;
-         break;
-       }
+        if (TbExt[NoExt].SquareDistance(Cu) < Tol2) {
+          DejaEnr = Standard_True;
+          break;
+        }
       }
       if (!DejaEnr) {
-       TbExt[myNbExt] = Cu;
-       mySqDist[myNbExt] = Cu.SquareDistance(P);
-       myIsMin[myNbExt] = (NoSol == 0);
-       myPoint[myNbExt] = Extrema_POnCurv2d(Us,Cu);
-       myNbExt++;
+        TbExt[myNbExt] = Cu;
+        mySqDist[myNbExt] = Cu.SquareDistance(P);
+        myIsMin[myNbExt] = (NoSol == 0);
+        myPoint[myNbExt] = Extrema_POnCurv2d(Us,Cu);
+        myNbExt++;
       }
     } // if ((Us >= Uinf) && (Us <= Usup))
   } // for (Standard_Integer NoSol = 1; ...
diff --git a/tests/bugs/modalg_5/bug24422 b/tests/bugs/modalg_5/bug24422
new file mode 100644 (file)
index 0000000..c981ede
--- /dev/null
@@ -0,0 +1,27 @@
+puts "================"
+puts "OCC24422"
+puts "================"
+puts ""
+#######################################################################
+# Wrong result done by FaceClassifier algorythm
+#######################################################################
+
+restore [locate_data_file bug24422_Compound.brep] b 
+explode b f
+copy b_1 f
+
+point p 115.945392440981 106 230.000108990528
+point p_proj 230.00010899052799 1925.9453924409811
+set info [b2dclassify f p_proj]
+
+if { [regexp "The point is OUT of shape" $info] != 1  } {
+    puts "Error : point should be ON shape"
+} else {
+    puts "OK: point is OUT of shape"
+}
+
+axo
+fit
+set only_screen_axo 1
+
+