src/BRepTopAdaptor/BRepTopAdaptor_FClass2d.cxx

   1 // Created on: 1995-03-22
   2 // Created by: Laurent BUCHARD
   3 // Copyright (c) 1995-1999 Matra Datavision
   4 // Copyright (c) 1999-2014 OPEN CASCADE SAS
   5 //
   6 // This file is part of Open CASCADE Technology software library.
   7 //
   8 // This library is free software; you can redistribute it and/or modify it under
   9 // the terms of the GNU Lesser General Public License version 2.1 as published
  10 // by the Free Software Foundation, with special exception defined in the file
  11 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
  12 // distribution for complete text of the license and disclaimer of any warranty.
  13 //
  14 // Alternatively, this file may be used under the terms of Open CASCADE
  15 // commercial license or contractual agreement.
  16
  17 #define AFFICHAGE 0
  18
  19 #define No_Standard_OutOfRange
  20
  21
  22 #include <BRep_Tool.hxx>
  23 #include <BRepAdaptor_Curve.hxx>
  24 #include <BRepAdaptor_Curve2d.hxx>
  25 #include <BRepAdaptor_HSurface.hxx>
  26 #include <BRepClass_FaceClassifier.hxx>
  27 #include <BRepTools_WireExplorer.hxx>
  28 #include <BRepTopAdaptor_FClass2d.hxx>
  29 #include <CSLib_Class2d.hxx>
  30 #include <ElCLib.hxx>
  31 #include <Geom2dInt_Geom2dCurveTool.hxx>
  32 #include <GeomAbs_SurfaceType.hxx>
  33 #include <gp_Pnt.hxx>
  34 #include <gp_Pnt2d.hxx>
  35 #include <Precision.hxx>
  36 #include <TColgp_Array1OfPnt2d.hxx>
  37 #include <TColgp_SequenceOfPnt2d.hxx>
  38 #include <TopAbs_Orientation.hxx>
  39 #include <TopExp.hxx>
  40 #include <TopExp_Explorer.hxx>
  41 #include <TopoDS.hxx>
  42 #include <TopoDS_Edge.hxx>
  43 #include <TopoDS_Face.hxx>
  44
  45 #ifdef _MSC_VER
  46 #include <stdio.h>
  47 #endif
  48
  49
  50 #ifdef OCCT_DEBUG
  51 #define LBRCOMPT 0
  52 #else
  53 #define LBRCOMPT 0
  54 #endif
  55
  56
  57 #if LBRCOMPT
  58 class StatistiquesFClass2d {
  59 public:
  60   long unsigned NbConstrShape;
  61   long unsigned NbPerformInfinitePoint;
  62   long unsigned NbPerform;
  63   long unsigned NbTestOnRestriction;
  64   long unsigned NbDestroy;
  65 public:
  66   StatistiquesFClass2d() {
  67     NbConstrShape=NbPerform=NbPerformInfinitePoint=NbDestroy=0;
  68   }
  69   ~StatistiquesFClass2d() {
  70     printf("\n--- Statistiques BRepTopAdaptor:\n");
  71     printf("\nConstructeur(Shape) : %10lu",NbConstrShape);
  72     printf("\nPerformInfinitePoint: %10lu",NbPerformInfinitePoint);
  73     printf("\nTestOnRestriction   : %10lu",NbTestOnRestriction);
  74     printf("\nPerform(pnt2d)      : %10lu",NbPerform);
  75     printf("\nDestroy             : %10lu",NbDestroy);
  76   }
  77 };
  78
  79 static StatistiquesFClass2d STAT;
  80 #endif
  81
  82
  83
  84
  85 BRepTopAdaptor_FClass2d::BRepTopAdaptor_FClass2d(const TopoDS_Face& aFace,const Standard_Real TolUV)
  86 : Toluv(TolUV), Face(aFace)  {
  87
  88 #if LBRCOMPT
  89   STAT.NbConstrShape++;
  90 #endif
  91
  92   //-- dead end on surfaces defined on more than one period
  93
  94   Face.Orientation(TopAbs_FORWARD);
  95   Handle(BRepAdaptor_HSurface) surf = new BRepAdaptor_HSurface();
  96   surf->ChangeSurface().Initialize(aFace,Standard_False);
  97
  98   TopoDS_Edge  edge;
  99   TopAbs_Orientation Or;
 100   Standard_Real u,du,Tole = 0.0,Tol=0.0;
 101   BRepTools_WireExplorer WireExplorer;
 102   TopExp_Explorer FaceExplorer;
 103
 104   Umin = Vmin = 0.0; //RealLast();
 105   Umax = Vmax = -Umin;
 106
 107   Standard_Integer BadWire=0;
 108   for( FaceExplorer.Init(Face,TopAbs_WIRE); (FaceExplorer.More() && BadWire==0); FaceExplorer.Next() )
 109     {
 110       Standard_Integer nbpnts = 0;
 111       TColgp_SequenceOfPnt2d SeqPnt2d;
 112       Standard_Integer firstpoint = 1;
 113       Standard_Real FlecheU = 0.0;
 114       Standard_Real FlecheV = 0.0;
 115       Standard_Boolean WireIsNotEmpty = Standard_False;
 116       Standard_Integer NbEdges = 0;
 117
 118       TopExp_Explorer Explorer;
 119       for( Explorer.Init(FaceExplorer.Current(),TopAbs_EDGE); Explorer.More(); Explorer.Next() ) NbEdges++;
 120
 121       gp_Pnt Ancienpnt3d(0,0,0);
 122       Standard_Boolean Ancienpnt3dinitialise = Standard_False;
 123
 124       for( WireExplorer.Init(TopoDS::Wire(FaceExplorer.Current()),Face); WireExplorer.More(); WireExplorer.Next() )
 125         {
 126
 127           NbEdges--;
 128           edge = WireExplorer.Current();
 129           Or = edge.Orientation();
 130           if(Or == TopAbs_FORWARD || Or == TopAbs_REVERSED)
 131             {
 132               Standard_Real pfbid,plbid;
 133               if(BRep_Tool::CurveOnSurface(edge,Face,pfbid,plbid).IsNull()) return;
 134               BRepAdaptor_Curve2d C(edge,Face);
 135
 136               //-- ----------------------------------------
 137               Standard_Boolean degenerated=Standard_False;
 138               if(BRep_Tool::Degenerated(edge))   degenerated=Standard_True;
 139               if(BRep_Tool::IsClosed(edge,Face)) degenerated=Standard_True;
 140               TopoDS_Vertex Va,Vb;
 141               TopExp::Vertices(edge,Va,Vb);
 142               Standard_Real TolVertex1=0.,TolVertex=0.;
 143               if (Va.IsNull()) degenerated=Standard_True;
 144               else TolVertex1=BRep_Tool::Tolerance(Va);
 145               if (Vb.IsNull()) degenerated=Standard_True;
 146               else TolVertex=BRep_Tool::Tolerance(Vb);
 147               if(TolVertex<TolVertex1) TolVertex=TolVertex1;
 148               BRepAdaptor_Curve C3d;
 149
 150               if(Abs(plbid-pfbid) < 1.e-9) continue;
 151
 152               //if(degenerated==Standard_False)
 153               //  C3d.Initialize(edge,Face);
 154
 155               //-- Check cases when it was forgotten to code degenerated :  PRO17410 (janv 99)
 156               if(degenerated == Standard_False)
 157                 {
 158                   C3d.Initialize(edge,Face);
 159                   du=(plbid-pfbid)*0.1;
 160                   u=pfbid+du;
 161                   gp_Pnt P3da=C3d.Value(u);
 162                   degenerated=Standard_True;
 163                   u+=du;
 164                   do
 165                     {
 166
 167                       gp_Pnt P3db=C3d.Value(u);
 168                       //                      if(P3da.SquareDistance(P3db)) { degenerated=Standard_False; break; }
 169                       if(P3da.SquareDistance(P3db) > Precision::Confusion()) { degenerated=Standard_False; break; }
 170                       u+=du;
 171                     }
 172                   while(u<plbid);
 173                 }
 174
 175               //-- ----------------------------------------
 176
 177               Tole = BRep_Tool::Tolerance(edge);
 178               if(Tole>Tol) Tol=Tole;
 179
 180               //Standard_Integer nbs = 1 + Geom2dInt_Geom2dCurveTool::NbSamples(C);
 181               Standard_Integer nbs = Geom2dInt_Geom2dCurveTool::NbSamples(C);
 182               //-- Attention to rational bsplines of degree 3. (ends of circles among others)
 183               if (nbs > 2) nbs*=4;
 184               du = (plbid-pfbid)/(Standard_Real)(nbs-1);
 185
 186               if(Or==TopAbs_FORWARD) u = pfbid;
 187               else { u = plbid; du=-du; }
 188
 189               //-- ------------------------------------------------------------
 190               //-- Check distance uv between the start point of the edge
 191               //-- and the last point registered in SeqPnt2d
 192               //-- Try to remote the first point of the current edge
 193               //-- from the last saved point
 194 #ifdef OCCT_DEBUG
 195               gp_Pnt2d Pnt2dDebutEdgeCourant = C.Value(u); (void)Pnt2dDebutEdgeCourant;
 196 #endif
 197
 198               //Standard_Real Baillement2dU=0;
 199               //Standard_Real Baillement2dV=0;
 200 #if AFFICHAGE
 201               if(nbpnts>1) printf("\nTolVertex %g ",TolVertex);
 202 #endif
 203
 204               if(firstpoint==2) u+=du;
 205               Standard_Integer Avant = nbpnts;
 206               for(Standard_Integer e = firstpoint; e<=nbs; e++)
 207                 {
 208                   gp_Pnt2d P2d = C.Value(u);
 209                   if(P2d.X()<Umin) Umin = P2d.X();
 210                   if(P2d.X()>Umax) Umax = P2d.X();
 211                   if(P2d.Y()<Vmin) Vmin = P2d.Y();
 212                   if(P2d.Y()>Vmax) Vmax = P2d.Y();
 213
 214                   Standard_Real dist3dptcourant_ancienpnt=1e+20;//RealLast();
 215                   gp_Pnt P3d;
 216                   if(degenerated==Standard_False)
 217                     {
 218                       P3d=C3d.Value(u);
 219                       if(nbpnts>1 && Ancienpnt3dinitialise) dist3dptcourant_ancienpnt = P3d.Distance(Ancienpnt3d);
 220                     }
 221                   Standard_Boolean IsRealCurve3d = Standard_True; //patch
 222                   if(dist3dptcourant_ancienpnt < Precision::Confusion())
 223                     {
 224                       gp_Pnt MidP3d = C3d.Value( u-du/2. );
 225                       if (P3d.Distance( MidP3d ) < Precision::Confusion()) IsRealCurve3d = Standard_False;
 226                     }
 227                   if(IsRealCurve3d)
 228                     {
 229                       if(degenerated==Standard_False) { Ancienpnt3d=P3d;  Ancienpnt3dinitialise=Standard_True; }
 230                       nbpnts++;
 231                       SeqPnt2d.Append(P2d);
 232                     }
 233 #if AFFICHAGE
 234                   else { static int mm=0; printf("\npoint p%d  %g %g %g",++mm,P3d.X(),P3d.Y(),P3d.Z()); }
 235 #endif
 236                   u+=du;
 237                   Standard_Integer ii = nbpnts;
 238                   //-- printf("\n nbpnts:%4d  u=%7.5g   FlecheU=%7.5g  FlecheV=%7.5g  ii=%3d  Avant=%3d ",nbpnts,u,FlecheU,FlecheV,ii,Avant);
 239 //                if(ii>(Avant+4))
 240 //  Modified by Sergey KHROMOV - Fri Apr 19 09:46:12 2002 Begin
 241                   if(ii>(Avant+4) && SeqPnt2d(ii-2).SquareDistance(SeqPnt2d(ii)))
 242 //  Modified by Sergey KHROMOV - Fri Apr 19 09:46:13 2002 End
 243                     {
 244                       gp_Lin2d Lin(SeqPnt2d(ii-2),gp_Dir2d(gp_Vec2d(SeqPnt2d(ii-2),SeqPnt2d(ii))));
 245                       Standard_Real ul = ElCLib::Parameter(Lin,SeqPnt2d(ii-1));
 246                       gp_Pnt2d Pp = ElCLib::Value(ul,Lin);
 247                       Standard_Real dU = Abs(Pp.X()-SeqPnt2d(ii-1).X());
 248                       Standard_Real dV = Abs(Pp.Y()-SeqPnt2d(ii-1).Y());
 249                       //-- printf(" (du=%7.5g   dv=%7.5g)",dU,dV);
 250                       if(dU>FlecheU) FlecheU = dU;
 251                       if(dV>FlecheV) FlecheV = dV;
 252                     }
 253                 }//for(e=firstpoint
 254               if(firstpoint==1) firstpoint=2;
 255               WireIsNotEmpty = Standard_True;
 256             }//if(Or==FORWARD,REVERSED
 257         } //-- Edges -> for(Ware.Explorer
 258
 259       if(NbEdges)
 260         { //-- on compte ++ with a normal explorer and with the Wire Explorer
 261 /*
 262 #ifdef OCCT_DEBUG
 263
 264           cout << endl;
 265           cout << "*** BRepTopAdaptor_Fclass2d  ** Wire Probablement FAUX **" << endl;
 266           cout << "*** WireExplorer does not find all edges " << endl;
 267           cout << "*** Connect old classifier" << endl;
 268 #endif
 269 */
 270           TColgp_Array1OfPnt2d PClass(1,2);
 271           //// modified by jgv, 28.04.2009 ////
 272           PClass.Init(gp_Pnt2d(0.,0.));
 273           /////////////////////////////////////
 274           TabClass.Append((void *)new CSLib_Class2d(PClass,FlecheU,FlecheV,Umin,Vmin,Umax,Vmax));
 275           BadWire=1;
 276           TabOrien.Append(-1);
 277         }
 278       else if(WireIsNotEmpty)
 279         {
 280           //Standard_Real anglep=0,anglem=0;
 281           TColgp_Array1OfPnt2d PClass(1,nbpnts);
 282           Standard_Real square = 0.0;
 283
 284           //-------------------------------------------------------------------
 285           //-- ** The mode of calculation was somewhat changed
 286           //-- Before Oct 31 97 , the total angle of
 287           //-- rotation of the wire was evaluated on all angles except for the last
 288           //-- ** Now, exactly the angle of rotation is evaluated
 289           //-- If a value remote from 2PI or -2PI is found, it means that there is
 290           //-- an uneven number of loops
 291
 292           if(nbpnts>3)
 293             {
 294 //            Standard_Integer im2=nbpnts-2;
 295               Standard_Integer im1=nbpnts-1;
 296               Standard_Integer im0=1;
 297 //            PClass(im2)=SeqPnt2d.Value(im2);
 298               PClass(im1)=SeqPnt2d.Value(im1);
 299               PClass(nbpnts)=SeqPnt2d.Value(nbpnts);
 300
 301
 302 //            for(Standard_Integer ii=1; ii<nbpnts; ii++,im0++,im1++,im2++)
 303               for(Standard_Integer ii=1; ii<nbpnts; ii++,im0++,im1++)
 304                 {
 305 //                if(im2>=nbpnts) im2=1;
 306                   if(im1>=nbpnts) im1=1;
 307                   PClass(ii)=SeqPnt2d.Value(ii);
 308 //                gp_Vec2d A(PClass(im2),PClass(im1));
 309 //                gp_Vec2d B(PClass(im1),PClass(im0));
 310 //                Standard_Real N = A.Magnitude() * B.Magnitude();
 311
 312                   square += (PClass(im0).X()-PClass(im1).X())*(PClass(im0).Y()+PClass(im1).Y())*.5;
 313
 314 //                if(N>1e-16){ Standard_Real a=A.Angle(B); angle+=a; }
 315                 }
 316
 317
 318               //-- FlecheU*=10.0;
 319               //-- FlecheV*=10.0;
 320               if(FlecheU<Toluv) FlecheU = Toluv;
 321               if(FlecheV<Toluv) FlecheV = Toluv;
 322               //-- cout<<" U:"<<FlecheU<<" V:"<<FlecheV<<endl;
 323               TabClass.Append((void *)new CSLib_Class2d(PClass,FlecheU,FlecheV,Umin,Vmin,Umax,Vmax));
 324
 325 //            if((angle<2 && angle>-2)||(angle>10)||(angle<-10))
 326 //              {
 327 //                BadWire=1;
 328 //                TabOrien.Append(-1);
 329 //#ifdef OCCT_DEBUG
 330 //                cout << endl;
 331 //                cout << "*** BRepTopAdaptor_Fclass2d  ** Wire Probably FALSE **" << endl;
 332 //                cout << "*** Total rotation angle of the wire : " << angle << endl;
 333 //                cout << "*** Connect the old classifier" << endl;
 334 //#endif
 335 //              }
 336 //            else TabOrien.Append(((angle>0.0)? 1 : 0));
 337               TabOrien.Append(((square < 0.0)? 1 : 0));
 338             }//if(nbpoints>3
 339           else
 340             {
 341 #ifdef OCCT_DEBUG
 342               cout << endl;
 343               cout << "*** BRepTopAdaptor_Fclass2d  ** Wire Probably FALSE **" << endl;
 344               cout << "*** The sample wire contains less than 3 points" << endl;
 345               cout << "*** Connect the old classifier" << endl;
 346 #endif
 347               BadWire=1;
 348               TabOrien.Append(-1);
 349               TColgp_Array1OfPnt2d xPClass(1,2);
 350               xPClass(1) = SeqPnt2d(1);
 351               xPClass(2) = SeqPnt2d(2);
 352               TabClass.Append((void *)new CSLib_Class2d(xPClass,FlecheU,FlecheV,Umin,Vmin,Umax,Vmax));
 353             }
 354         }//else if(WareIsNotEmpty
 355   }//for(FaceExplorer
 356
 357   Standard_Integer nbtabclass = TabClass.Length();
 358
 359   if(nbtabclass>0)
 360     {
 361       //-- If an error was detected on a wire: set all TabOrien to -1
 362       if(BadWire) TabOrien(1)=-1;
 363
 364       if(   surf->GetType()==GeomAbs_Cone
 365          || surf->GetType()==GeomAbs_Cylinder
 366          || surf->GetType()==GeomAbs_Torus
 367          || surf->GetType()==GeomAbs_Sphere
 368          || surf->GetType()==GeomAbs_SurfaceOfRevolution)
 369
 370         {
 371           Standard_Real uuu=M_PI+M_PI-(Umax-Umin);
 372           if(uuu<0) uuu=0;
 373           U1 = 0.0;  // modified by NIZHNY-OFV  Thu May 31 14:24:10 2001 ---> //Umin-uuu*0.5;
 374           U2 = 2*M_PI; // modified by NIZHNY-OFV  Thu May 31 14:24:35 2001 ---> //U1+M_PI+M_PI;
 375         }
 376       else { U1=U2=0.0; }
 377
 378       if(surf->GetType()==GeomAbs_Torus)
 379         {
 380           Standard_Real uuu=M_PI+M_PI-(Vmax-Vmin);
 381           if(uuu<0) uuu=0;
 382           V1 = 0.0;  // modified by NIZHNY-OFV  Thu May 31 14:24:55 2001 ---> //Vmin-uuu*0.5;
 383           V2 = 2*M_PI; // modified by NIZHNY-OFV  Thu May 31 14:24:59 2001 ---> //V1+M_PI+M_PI;
 384         }
 385       else { V1=V2=0.0; }
 386     }
 387 }
 388
 389 TopAbs_State BRepTopAdaptor_FClass2d::PerformInfinitePoint() const {
 390 #if LBRCOMPT
 391   STAT.NbPerformInfinitePoint++;
 392 #endif
 393
 394   if(Umax==-RealLast() || Vmax==-RealLast() || Umin==RealLast() || Vmin==RealLast()) {
 395     return(TopAbs_IN);
 396   }
 397   gp_Pnt2d P(Umin-(Umax-Umin),Vmin-(Vmax-Vmin));
 398   return(Perform(P,Standard_False));
 399 }
 400
 401 TopAbs_State BRepTopAdaptor_FClass2d::Perform(const gp_Pnt2d& _Puv,
 402                                               const Standard_Boolean RecadreOnPeriodic) const
 403 {
 404 #if LBRCOMPT
 405   STAT.NbPerform++;
 406 #endif
 407
 408   Standard_Integer dedans;
 409   Standard_Integer nbtabclass = TabClass.Length();
 410
 411   if(nbtabclass==0) {
 412     return(TopAbs_IN);
 413   }
 414
 415   //-- U1 is the First Param and U2 in this case is U1+Period
 416   Standard_Real u=_Puv.X();
 417   Standard_Real v=_Puv.Y();
 418   Standard_Real uu = u, vv = v;
 419
 420   Handle(BRepAdaptor_HSurface) surf = new BRepAdaptor_HSurface();
 421   surf->ChangeSurface().Initialize( Face, Standard_False );
 422   const Standard_Boolean IsUPer  = surf->IsUPeriodic();
 423   const Standard_Boolean IsVPer  = surf->IsVPeriodic();
 424   const Standard_Real    uperiod = IsUPer ? surf->UPeriod() : 0.0;
 425   const Standard_Real    vperiod = IsVPer ? surf->VPeriod() : 0.0;
 426   TopAbs_State Status = TopAbs_UNKNOWN;
 427   Standard_Boolean urecadre = Standard_False, vrecadre = Standard_False;
 428
 429   if (RecadreOnPeriodic)
 430     {
 431       if (IsUPer)
 432         {
 433           if (uu < Umin)
 434             while (uu < Umin)
 435               uu += uperiod;
 436           else
 437             {
 438               while (uu >= Umin)
 439                 uu -= uperiod;
 440               uu += uperiod;
 441             }
 442         }
 443       if (IsVPer)
 444         {
 445           if (vv < Vmin)
 446             while (vv < Vmin)
 447               vv += vperiod;
 448           else
 449             {
 450               while (vv >= Vmin)
 451                 vv -= vperiod;
 452               vv += vperiod;
 453             }
 454         }
 455     }
 456
 457   for (;;)
 458     {
 459       dedans = 1;
 460       gp_Pnt2d Puv(u,v);
 461
 462       if(TabOrien(1)!=-1) {
 463         for(Standard_Integer n=1; n<=nbtabclass; n++) {
 464           Standard_Integer cur = ((CSLib_Class2d *)TabClass(n))->SiDans(Puv);
 465           if(cur==1) {
 466             if(TabOrien(n)==0) {
 467               dedans = -1;
 468               break;
 469             }
 470           }
 471           else if(cur==-1) {
 472             if(TabOrien(n)==1) {
 473               dedans = -1;
 474               break;
 475             }
 476           }
 477           else {
 478             dedans = 0;
 479             break;
 480           }
 481         }
 482         if(dedans==0) {
 483           BRepClass_FaceClassifier aClassifier;
 484           Standard_Real m_Toluv = (Toluv > 4.0) ? 4.0 : Toluv;
 485           //aClassifier.Perform(Face,Puv,Toluv);
 486           aClassifier.Perform(Face,Puv,m_Toluv);
 487           Status = aClassifier.State();
 488         }
 489         if(dedans == 1) {
 490           Status = TopAbs_IN;
 491         }
 492         if(dedans == -1) {
 493           Status = TopAbs_OUT;
 494         }
 495       }
 496       else {  //-- TabOrien(1)=-1    False Wire
 497         BRepClass_FaceClassifier aClassifier;
 498         aClassifier.Perform(Face,Puv,Toluv);
 499         Status = aClassifier.State();
 500       }
 501
 502       if (!RecadreOnPeriodic || (!IsUPer && !IsVPer))
 503         return Status;
 504       if (Status == TopAbs_IN || Status == TopAbs_ON)
 505         return Status;
 506
 507       if (!urecadre)
 508         {
 509           u = uu;
 510           urecadre = Standard_True;
 511         }
 512       else
 513         if (IsUPer)
 514           u += uperiod;
 515       if (u > Umax || !IsUPer)
 516         {
 517           if (!vrecadre)
 518             {
 519               v = vv;
 520               vrecadre = Standard_True;
 521             }
 522           else
 523             if (IsVPer)
 524               v += vperiod;
 525
 526           u = uu;
 527
 528           if (v > Vmax || !IsVPer)
 529             return Status;
 530         }
 531     } //for (;;)
 532 }
 533
 534 TopAbs_State BRepTopAdaptor_FClass2d::TestOnRestriction(const gp_Pnt2d& _Puv,
 535                                                         const Standard_Real Tol,
 536                                                         const Standard_Boolean RecadreOnPeriodic) const
 537 {
 538 #if LBRCOMPT
 539   STAT.NbConstrShape++;
 540 #endif
 541
 542   Standard_Integer dedans;
 543   Standard_Integer nbtabclass = TabClass.Length();
 544
 545   if(nbtabclass==0) {
 546     return(TopAbs_IN);
 547   }
 548
 549   //-- U1 is the First Param and U2 in this case is U1+Period
 550   Standard_Real u=_Puv.X();
 551   Standard_Real v=_Puv.Y();
 552   Standard_Real uu = u, vv = v;
 553
 554   Handle(BRepAdaptor_HSurface) surf = new BRepAdaptor_HSurface();
 555   surf->ChangeSurface().Initialize( Face, Standard_False );
 556   const Standard_Boolean IsUPer  = surf->IsUPeriodic();
 557   const Standard_Boolean IsVPer  = surf->IsVPeriodic();
 558   const Standard_Real    uperiod = IsUPer ? surf->UPeriod() : 0.0;
 559   const Standard_Real    vperiod = IsVPer ? surf->VPeriod() : 0.0;
 560   TopAbs_State Status = TopAbs_UNKNOWN;
 561   Standard_Boolean urecadre = Standard_False, vrecadre = Standard_False;
 562
 563   if (RecadreOnPeriodic)
 564     {
 565       if (IsUPer)
 566         {
 567           if (uu < Umin)
 568             while (uu < Umin)
 569               uu += uperiod;
 570           else
 571             {
 572               while (uu >= Umin)
 573                 uu -= uperiod;
 574               uu += uperiod;
 575             }
 576         }
 577       if (IsVPer)
 578         {
 579           if (vv < Vmin)
 580             while (vv < Vmin)
 581               vv += vperiod;
 582           else
 583             {
 584               while (vv >= Vmin)
 585                 vv -= vperiod;
 586               vv += vperiod;
 587             }
 588         }
 589     }
 590
 591   for (;;)
 592     {
 593       dedans = 1;
 594       gp_Pnt2d Puv(u,v);
 595
 596       if(TabOrien(1)!=-1) {
 597         for(Standard_Integer n=1; n<=nbtabclass; n++) {
 598           Standard_Integer cur = ((CSLib_Class2d *)TabClass(n))->SiDans_OnMode(Puv,Tol);
 599           if(cur==1) {
 600             if(TabOrien(n)==0) {
 601               dedans = -1;
 602               break;
 603             }
 604           }
 605           else if(cur==-1) {
 606             if(TabOrien(n)==1) {
 607               dedans = -1;
 608               break;
 609             }
 610           }
 611           else {
 612             dedans = 0;
 613             break;
 614           }
 615         }
 616         if(dedans==0) {
 617           Status = TopAbs_ON;
 618         }
 619         if(dedans == 1) {
 620           Status = TopAbs_IN;
 621         }
 622         if(dedans == -1) {
 623           Status = TopAbs_OUT;
 624         }
 625       }
 626       else {  //-- TabOrien(1)=-1    False Wire
 627         BRepClass_FaceClassifier aClassifier;
 628         aClassifier.Perform(Face,Puv,Tol);
 629         Status = aClassifier.State();
 630       }
 631
 632       if (!RecadreOnPeriodic || (!IsUPer && !IsVPer))
 633         return Status;
 634       if (Status == TopAbs_IN || Status == TopAbs_ON)
 635         return Status;
 636
 637       if (!urecadre)
 638         {
 639           u = uu;
 640           urecadre = Standard_True;
 641         }
 642       else
 643         if (IsUPer)
 644           u += uperiod;
 645       if (u > Umax || !IsUPer)
 646         {
 647           if (!vrecadre)
 648             {
 649               v = vv;
 650               vrecadre = Standard_True;
 651             }
 652           else
 653             if (IsVPer)
 654               v += vperiod;
 655
 656           u = uu;
 657
 658           if (v > Vmax || !IsVPer)
 659             return Status;
 660         }
 661     } //for (;;)
 662 }
 663
 664
 665 void BRepTopAdaptor_FClass2d::Destroy() {
 666 #if LBRCOMPT
 667   STAT.NbDestroy++;
 668 #endif
 669
 670   Standard_Integer nbtabclass = TabClass.Length();
 671   for(Standard_Integer d=1; d<=nbtabclass;d++) {
 672     if(TabClass(d)) {
 673       delete ((CSLib_Class2d *)TabClass(d));
 674       TabClass(d)=NULL;
 675     }
 676   }
 677 }
 678
 679
 680
 681 #include <Standard_ConstructionError.hxx>
 682
 683
 684 //const BRepTopAdaptor_FClass2d &  BRepTopAdaptor_FClass2d::Copy(const BRepTopAdaptor_FClass2d& Other) const {
 685 const BRepTopAdaptor_FClass2d &  BRepTopAdaptor_FClass2d::Copy(const BRepTopAdaptor_FClass2d& ) const {
 686 #ifdef OCCT_DEBUG
 687   cerr<<"Copy not allowed in BRepTopAdaptor_FClass2d"<<endl;
 688 #endif
 689   Standard_ConstructionError::Raise();
 690   return(*this);
 691 }