[occt.git] / src / BRepTopAdaptor / BRepTopAdaptor_FClass2d.cxx

// Created on: 1995-03-22
// Created by: Laurent BUCHARD
// Copyright (c) 1995-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.

#define AFFICHAGE 0

#define No_Standard_OutOfRange


#include <BRep_Tool.hxx>
#include <BRepAdaptor_Curve.hxx>
#include <BRepAdaptor_Curve2d.hxx>
#include <BRepAdaptor_HSurface.hxx>
#include <BRepClass_FaceClassifier.hxx>
#include <BRepTools_WireExplorer.hxx>
#include <BRepTopAdaptor_FClass2d.hxx>
#include <CSLib_Class2d.hxx>
#include <ElCLib.hxx>
#include <Geom2dInt_Geom2dCurveTool.hxx>
#include <GeomAbs_SurfaceType.hxx>
#include <gp_Pnt.hxx>
#include <gp_Pnt2d.hxx>
#include <Precision.hxx>
#include <TColgp_Array1OfPnt2d.hxx>
#include <TColgp_SequenceOfPnt2d.hxx>
#include <TopAbs_Orientation.hxx>
#include <TopExp.hxx>
#include <TopExp_Explorer.hxx>
#include <TopoDS.hxx>
#include <TopoDS_Edge.hxx>
#include <TopoDS_Face.hxx>

#ifdef _MSC_VER
#include <stdio.h>
#endif


#ifdef OCCT_DEBUG
#define LBRCOMPT 0
#else
#define LBRCOMPT 0
#endif


#if LBRCOMPT  
class StatistiquesFClass2d { 
public:
  long unsigned NbConstrShape;
  long unsigned NbPerformInfinitePoint;
  long unsigned NbPerform;
  long unsigned NbTestOnRestriction;
  long unsigned NbDestroy;
public:
  StatistiquesFClass2d() { 
    NbConstrShape=NbPerform=NbPerformInfinitePoint=NbDestroy=0;
  }
  ~StatistiquesFClass2d() { 
    printf("\n--- Statistiques BRepTopAdaptor:\n");
    printf("\nConstructeur(Shape) : %10lu",NbConstrShape);
    printf("\nPerformInfinitePoint: %10lu",NbPerformInfinitePoint);
    printf("\nTestOnRestriction   : %10lu",NbTestOnRestriction);
    printf("\nPerform(pnt2d)      : %10lu",NbPerform);
    printf("\nDestroy             : %10lu",NbDestroy);
  }
};

static StatistiquesFClass2d STAT;
#endif


BRepTopAdaptor_FClass2d::BRepTopAdaptor_FClass2d(const TopoDS_Face& aFace,const Standard_Real TolUV) 
: Toluv(TolUV), Face(aFace)  { 
  
#if LBRCOMPT 
  STAT.NbConstrShape++;
#endif

  //-- dead end on surfaces defined on more than one period

  Face.Orientation(TopAbs_FORWARD);
  Handle(BRepAdaptor_HSurface) surf = new BRepAdaptor_HSurface();
  surf->ChangeSurface().Initialize(aFace,Standard_False);
  
  TopoDS_Edge  edge;
  TopAbs_Orientation Or;
  Standard_Real u,du,Tole = 0.0,Tol=0.0;
  BRepTools_WireExplorer WireExplorer;
  TopExp_Explorer FaceExplorer;

  Umin = Vmin = 0.0; //RealLast();
  Umax = Vmax = -Umin;

  Standard_Integer BadWire=0;
  for( FaceExplorer.Init(Face,TopAbs_WIRE); (FaceExplorer.More() && BadWire==0); FaceExplorer.Next() )
    {
      Standard_Integer nbpnts = 0;
      TColgp_SequenceOfPnt2d SeqPnt2d;
      Standard_Integer firstpoint = 1;
      Standard_Real FlecheU = 0.0;
      Standard_Real FlecheV = 0.0;
      Standard_Boolean WireIsNotEmpty = Standard_False;
      Standard_Integer NbEdges = 0;

      TopExp_Explorer Explorer;
      for( Explorer.Init(FaceExplorer.Current(),TopAbs_EDGE); Explorer.More(); Explorer.Next() ) NbEdges++;
        
      gp_Pnt Ancienpnt3d(0,0,0);
      Standard_Boolean Ancienpnt3dinitialise = Standard_False;

      for( WireExplorer.Init(TopoDS::Wire(FaceExplorer.Current()),Face); WireExplorer.More(); WireExplorer.Next() )
	{
	  
	  NbEdges--;
	  edge = WireExplorer.Current();
	  Or = edge.Orientation();
	  if(Or == TopAbs_FORWARD || Or == TopAbs_REVERSED)
	    {
	      Standard_Real pfbid,plbid;
	      if(BRep_Tool::CurveOnSurface(edge,Face,pfbid,plbid).IsNull()) return;
	      BRepAdaptor_Curve2d C(edge,Face);
	
	      //-- ----------------------------------------
	      Standard_Boolean degenerated=Standard_False;
	      if(BRep_Tool::Degenerated(edge))   degenerated=Standard_True;
	      if(BRep_Tool::IsClosed(edge,Face)) degenerated=Standard_True;
	      TopoDS_Vertex Va,Vb;
	      TopExp::Vertices(edge,Va,Vb);
	      Standard_Real TolVertex1=0.,TolVertex=0.;
	      if (Va.IsNull()) degenerated=Standard_True;
	      else TolVertex1=BRep_Tool::Tolerance(Va);
	      if (Vb.IsNull()) degenerated=Standard_True;
	      else TolVertex=BRep_Tool::Tolerance(Vb);
	      if(TolVertex<TolVertex1) TolVertex=TolVertex1;
	      BRepAdaptor_Curve C3d;
	
	      if(Abs(plbid-pfbid) < 1.e-9) continue;

	      //if(degenerated==Standard_False)
	      //  C3d.Initialize(edge,Face);

	      //-- Check cases when it was forgotten to code degenerated :  PRO17410 (janv 99)
	      if(degenerated == Standard_False)
		{
		  C3d.Initialize(edge,Face);
		  du=(plbid-pfbid)*0.1;
		  u=pfbid+du;
		  gp_Pnt P3da=C3d.Value(u);
		  degenerated=Standard_True;
		  u+=du;
		  do
		    {
		      
		      gp_Pnt P3db=C3d.Value(u);
		      // 		      if(P3da.SquareDistance(P3db)) { degenerated=Standard_False; break; }
		      if(P3da.SquareDistance(P3db) > Precision::Confusion()) { degenerated=Standard_False; break; }
		      u+=du;
		    }
		  while(u<plbid);
		}
	      
	      //-- ----------------------------------------

	      Tole = BRep_Tool::Tolerance(edge);
	      if(Tole>Tol) Tol=Tole;
	      
	      //Standard_Integer nbs = 1 + Geom2dInt_Geom2dCurveTool::NbSamples(C);
	      Standard_Integer nbs = Geom2dInt_Geom2dCurveTool::NbSamples(C);
	      //-- Attention to rational bsplines of degree 3. (ends of circles among others)
	      if (nbs > 2) nbs*=4;
	      du = (plbid-pfbid)/(Standard_Real)(nbs-1);

	      if(Or==TopAbs_FORWARD) u = pfbid;
	      else { u = plbid; du=-du;	}
	
	      //-- ------------------------------------------------------------
	      //-- Check distance uv between the start point of the edge
	      //-- and the last point registered in SeqPnt2d
	      //-- Try to remote the first point of the current edge 
	      //-- from the last saved point
#ifdef OCCT_DEBUG
	      gp_Pnt2d Pnt2dDebutEdgeCourant = C.Value(u); (void)Pnt2dDebutEdgeCourant;
#endif

	      //Standard_Real Baillement2dU=0;
	      //Standard_Real Baillement2dV=0;
#if AFFICHAGE
	      if(nbpnts>1) printf("\nTolVertex %g ",TolVertex);
#endif

	      if(firstpoint==2) u+=du;
	      Standard_Integer Avant = nbpnts;
	      for(Standard_Integer e = firstpoint; e<=nbs; e++)
		{
		  gp_Pnt2d P2d = C.Value(u);
		  if(P2d.X()<Umin) Umin = P2d.X();
		  if(P2d.X()>Umax) Umax = P2d.X();
		  if(P2d.Y()<Vmin) Vmin = P2d.Y();
		  if(P2d.Y()>Vmax) Vmax = P2d.Y();
	  
		  Standard_Real dist3dptcourant_ancienpnt=1e+20;//RealLast();
		  gp_Pnt P3d;
		  if(degenerated==Standard_False)
		    {
		      P3d=C3d.Value(u);
		      if(nbpnts>1 && Ancienpnt3dinitialise) dist3dptcourant_ancienpnt = P3d.Distance(Ancienpnt3d);
		    }
		  Standard_Boolean IsRealCurve3d = Standard_True; //patch
		  if(dist3dptcourant_ancienpnt < Precision::Confusion())
		    {
		      gp_Pnt MidP3d = C3d.Value( u-du/2. );
		      if (P3d.Distance( MidP3d ) < Precision::Confusion()) IsRealCurve3d = Standard_False;
		    }
		  if(IsRealCurve3d)
		    {
		      if(degenerated==Standard_False) { Ancienpnt3d=P3d;  Ancienpnt3dinitialise=Standard_True; }
		      nbpnts++;
		      SeqPnt2d.Append(P2d);
		    }
#if AFFICHAGE
                  else { static int mm=0; printf("\npoint p%d  %g %g %g",++mm,P3d.X(),P3d.Y(),P3d.Z());	}
#endif
		  u+=du;
		  Standard_Integer ii = nbpnts;
		  //-- printf("\n nbpnts:%4d  u=%7.5g   FlecheU=%7.5g  FlecheV=%7.5g  ii=%3d  Avant=%3d ",nbpnts,u,FlecheU,FlecheV,ii,Avant);
// 		  if(ii>(Avant+4))
//  Modified by Sergey KHROMOV - Fri Apr 19 09:46:12 2002 Begin
		  if(ii>(Avant+4) && SeqPnt2d(ii-2).SquareDistance(SeqPnt2d(ii)))
//  Modified by Sergey KHROMOV - Fri Apr 19 09:46:13 2002 End
		    {
		      gp_Lin2d Lin(SeqPnt2d(ii-2),gp_Dir2d(gp_Vec2d(SeqPnt2d(ii-2),SeqPnt2d(ii))));
		      Standard_Real ul = ElCLib::Parameter(Lin,SeqPnt2d(ii-1));
		      gp_Pnt2d Pp = ElCLib::Value(ul,Lin);
		      Standard_Real dU = Abs(Pp.X()-SeqPnt2d(ii-1).X());
		      Standard_Real dV = Abs(Pp.Y()-SeqPnt2d(ii-1).Y());
		      //-- printf(" (du=%7.5g   dv=%7.5g)",dU,dV);
		      if(dU>FlecheU) FlecheU = dU;
		      if(dV>FlecheV) FlecheV = dV;
		    }
		}//for(e=firstpoint
	      if(firstpoint==1) firstpoint=2;
	      WireIsNotEmpty = Standard_True;
	    }//if(Or==FORWARD,REVERSED
	} //-- Edges -> for(Ware.Explorer

      if(NbEdges)
	{ //-- on compte ++ with a normal explorer and with the Wire Explorer
/*
#ifdef OCCT_DEBUG

	  cout << endl;
	  cout << "*** BRepTopAdaptor_Fclass2d  ** Wire Probablement FAUX **" << endl;
	  cout << "*** WireExplorer does not find all edges " << endl;
	  cout << "*** Connect old classifier" << endl;
#endif
*/
	  TColgp_Array1OfPnt2d PClass(1,2);
	  //// modified by jgv, 28.04.2009 ////
	  PClass.Init(gp_Pnt2d(0.,0.));
	  /////////////////////////////////////
	  TabClass.Append((void *)new CSLib_Class2d(PClass,FlecheU,FlecheV,Umin,Vmin,Umax,Vmax));
	  BadWire=1;
	  TabOrien.Append(-1);
	}
      else if(WireIsNotEmpty)
	{
	  //Standard_Real anglep=0,anglem=0;
	  TColgp_Array1OfPnt2d PClass(1,nbpnts);
	  Standard_Real square = 0.0;

	  //-------------------------------------------------------------------
	  //-- ** The mode of calculation was somewhat changed 
	  //-- Before Oct 31 97 , the total angle of  
	  //-- rotation of the wire was evaluated on all angles except for the last 
	  //-- ** Now, exactly the angle of rotation is evaluated
	  //-- If a value remote from 2PI or -2PI is found, it means that there is 
	  //-- an uneven number of loops

	  if(nbpnts>3)
	    {
//	      Standard_Integer im2=nbpnts-2;
	      Standard_Integer im1=nbpnts-1;
	      Standard_Integer im0=1;
//	      PClass(im2)=SeqPnt2d.Value(im2);
	      PClass(im1)=SeqPnt2d.Value(im1);
	      PClass(nbpnts)=SeqPnt2d.Value(nbpnts);


//	      for(Standard_Integer ii=1; ii<nbpnts; ii++,im0++,im1++,im2++)
	      for(Standard_Integer ii=1; ii<nbpnts; ii++,im0++,im1++)
		{ 
//		  if(im2>=nbpnts) im2=1;
		  if(im1>=nbpnts) im1=1;
		  PClass(ii)=SeqPnt2d.Value(ii);
//		  gp_Vec2d A(PClass(im2),PClass(im1));
//		  gp_Vec2d B(PClass(im1),PClass(im0));
//		  Standard_Real N = A.Magnitude() * B.Magnitude();

		  square += (PClass(im0).X()-PClass(im1).X())*(PClass(im0).Y()+PClass(im1).Y())*.5; 

//		  if(N>1e-16){ Standard_Real a=A.Angle(B); angle+=a; }
		}

      
	      //-- FlecheU*=10.0;
	      //-- FlecheV*=10.0;
	      if(FlecheU<Toluv) FlecheU = Toluv;
	      if(FlecheV<Toluv) FlecheV = Toluv;
	      //-- cout<<" U:"<<FlecheU<<" V:"<<FlecheV<<endl;
	      TabClass.Append((void *)new CSLib_Class2d(PClass,FlecheU,FlecheV,Umin,Vmin,Umax,Vmax));

//	      if((angle<2 && angle>-2)||(angle>10)||(angle<-10))
//		{
//		  BadWire=1;
//		  TabOrien.Append(-1);
//#ifdef OCCT_DEBUG
//		  cout << endl;
//		  cout << "*** BRepTopAdaptor_Fclass2d  ** Wire Probably FALSE **" << endl;
//		  cout << "*** Total rotation angle of the wire : " << angle << endl;
//		  cout << "*** Connect the old classifier" << endl;
//#endif
//		} 
//	      else TabOrien.Append(((angle>0.0)? 1 : 0));
	      TabOrien.Append(((square < 0.0)? 1 : 0));
	    }//if(nbpoints>3
	  else
	    { 
#ifdef OCCT_DEBUG
	      cout << endl;
	      cout << "*** BRepTopAdaptor_Fclass2d  ** Wire Probably FALSE **" << endl;
	      cout << "*** The sample wire contains less than 3 points" << endl;
	      cout << "*** Connect the old classifier" << endl;
#endif       
	      BadWire=1;
	      TabOrien.Append(-1);
	      TColgp_Array1OfPnt2d xPClass(1,2);
	      xPClass(1) = SeqPnt2d(1); 
	      xPClass(2) = SeqPnt2d(2);
	      TabClass.Append((void *)new CSLib_Class2d(xPClass,FlecheU,FlecheV,Umin,Vmin,Umax,Vmax));
	    }
	}//else if(WareIsNotEmpty
  }//for(FaceExplorer

  Standard_Integer nbtabclass = TabClass.Length();

  if(nbtabclass>0)
    {
      //-- If an error was detected on a wire: set all TabOrien to -1
      if(BadWire) TabOrien(1)=-1;

      if(   surf->GetType()==GeomAbs_Cone
	 || surf->GetType()==GeomAbs_Cylinder
	 || surf->GetType()==GeomAbs_Torus
	 || surf->GetType()==GeomAbs_Sphere
	 || surf->GetType()==GeomAbs_SurfaceOfRevolution)
	
	{
	  Standard_Real uuu=M_PI+M_PI-(Umax-Umin);
	  if(uuu<0) uuu=0;
	  U1 = 0.0;  // modified by NIZHNY-OFV  Thu May 31 14:24:10 2001 ---> //Umin-uuu*0.5;
	  U2 = 2*M_PI; // modified by NIZHNY-OFV  Thu May 31 14:24:35 2001 ---> //U1+M_PI+M_PI;
	}
      else { U1=U2=0.0; } 
    
      if(surf->GetType()==GeomAbs_Torus)
	{ 
	  Standard_Real uuu=M_PI+M_PI-(Vmax-Vmin);
	  if(uuu<0) uuu=0;
	  V1 = 0.0;  // modified by NIZHNY-OFV  Thu May 31 14:24:55 2001 ---> //Vmin-uuu*0.5;
	  V2 = 2*M_PI; // modified by NIZHNY-OFV  Thu May 31 14:24:59 2001 ---> //V1+M_PI+M_PI;
	}
      else { V1=V2=0.0; }   
    }
}

TopAbs_State BRepTopAdaptor_FClass2d::PerformInfinitePoint() const { 
#if LBRCOMPT 
  STAT.NbPerformInfinitePoint++;
#endif
  
  if(Umax==-RealLast() || Vmax==-RealLast() || Umin==RealLast() || Vmin==RealLast()) { 
    return(TopAbs_IN);
  }
  gp_Pnt2d P(Umin-(Umax-Umin),Vmin-(Vmax-Vmin));
  return(Perform(P,Standard_False));
}

TopAbs_State BRepTopAdaptor_FClass2d::Perform(const gp_Pnt2d& _Puv,
					      const Standard_Boolean RecadreOnPeriodic) const
{ 
#if LBRCOMPT 
  STAT.NbPerform++;
#endif
  
  Standard_Integer dedans;
  Standard_Integer nbtabclass = TabClass.Length();
  
  if(nbtabclass==0) { 
    return(TopAbs_IN);
  }
  
  //-- U1 is the First Param and U2 in this case is U1+Period
  Standard_Real u=_Puv.X();
  Standard_Real v=_Puv.Y();
  Standard_Real uu = u, vv = v;

  Handle(BRepAdaptor_HSurface) surf = new BRepAdaptor_HSurface();
  surf->ChangeSurface().Initialize( Face, Standard_False );
  const Standard_Boolean IsUPer  = surf->IsUPeriodic();
  const Standard_Boolean IsVPer  = surf->IsVPeriodic();
  const Standard_Real    uperiod = IsUPer ? surf->UPeriod() : 0.0;
  const Standard_Real    vperiod = IsVPer ? surf->VPeriod() : 0.0;
  TopAbs_State Status = TopAbs_UNKNOWN;
  Standard_Boolean urecadre = Standard_False, vrecadre = Standard_False;

  if (RecadreOnPeriodic)
    {
      if (IsUPer)
	{
	  if (uu < Umin)
	    while (uu < Umin)
	      uu += uperiod;
	  else
	    {
	      while (uu >= Umin)
		uu -= uperiod;
	      uu += uperiod;
	    }
	}
      if (IsVPer)
	{
	  if (vv < Vmin)
	    while (vv < Vmin)
	      vv += vperiod;
	  else
	    {
	      while (vv >= Vmin)
		vv -= vperiod;
	      vv += vperiod;
	    }
	}
    }

  for (;;)
    {
      dedans = 1;
      gp_Pnt2d Puv(u,v);
      
      if(TabOrien(1)!=-1) { 
	for(Standard_Integer n=1; n<=nbtabclass; n++) { 
	  Standard_Integer cur = ((CSLib_Class2d *)TabClass(n))->SiDans(Puv);
	  if(cur==1) { 
	    if(TabOrien(n)==0) { 
	      dedans = -1; 
	      break;
	    }
	  }
	  else if(cur==-1) { 
	    if(TabOrien(n)==1) {  
	      dedans = -1; 
	      break;
	    }
	  }
	  else { 
	    dedans = 0;
	    break;
	  }
	}
	if(dedans==0) { 
	  BRepClass_FaceClassifier aClassifier;
	  Standard_Real m_Toluv = (Toluv > 4.0) ? 4.0 : Toluv;
	  //aClassifier.Perform(Face,Puv,Toluv);
	  aClassifier.Perform(Face,Puv,m_Toluv);
	  Status = aClassifier.State();
	}
	if(dedans == 1) { 
	  Status = TopAbs_IN;
	}
	if(dedans == -1) {
	  Status = TopAbs_OUT;
	}
      }
      else {  //-- TabOrien(1)=-1    False Wire
	BRepClass_FaceClassifier aClassifier;
	aClassifier.Perform(Face,Puv,Toluv);
	Status = aClassifier.State();
      }

      if (!RecadreOnPeriodic || (!IsUPer && !IsVPer))
	return Status;
      if (Status == TopAbs_IN || Status == TopAbs_ON)
	return Status;

      if (!urecadre)
	{
	  u = uu;
	  urecadre = Standard_True;
	}
      else
	if (IsUPer)
	  u += uperiod;
      if (u > Umax || !IsUPer)
	{
	  if (!vrecadre)
	    {
	      v = vv;
	      vrecadre = Standard_True;
	    }
	  else
	    if (IsVPer)
	      v += vperiod;

	  u = uu;

	  if (v > Vmax || !IsVPer)
	    return Status;
	}
    } //for (;;)
}

TopAbs_State BRepTopAdaptor_FClass2d::TestOnRestriction(const gp_Pnt2d& _Puv,
							const Standard_Real Tol,
							const Standard_Boolean RecadreOnPeriodic) const
{ 
#if LBRCOMPT 
  STAT.NbConstrShape++;
#endif
  
  Standard_Integer dedans;
  Standard_Integer nbtabclass = TabClass.Length();
  
  if(nbtabclass==0) { 
    return(TopAbs_IN);
  }
  
  //-- U1 is the First Param and U2 in this case is U1+Period
  Standard_Real u=_Puv.X();
  Standard_Real v=_Puv.Y();
  Standard_Real uu = u, vv = v;
  
  Handle(BRepAdaptor_HSurface) surf = new BRepAdaptor_HSurface();
  surf->ChangeSurface().Initialize( Face, Standard_False );
  const Standard_Boolean IsUPer  = surf->IsUPeriodic();
  const Standard_Boolean IsVPer  = surf->IsVPeriodic();
  const Standard_Real    uperiod = IsUPer ? surf->UPeriod() : 0.0;
  const Standard_Real    vperiod = IsVPer ? surf->VPeriod() : 0.0;
  TopAbs_State Status = TopAbs_UNKNOWN;
  Standard_Boolean urecadre = Standard_False, vrecadre = Standard_False;
  
  if (RecadreOnPeriodic)
    {
      if (IsUPer)
	{
	  if (uu < Umin)
	    while (uu < Umin)
	      uu += uperiod;
	  else
	    {
	      while (uu >= Umin)
		uu -= uperiod;
	      uu += uperiod;
	    }
	}
      if (IsVPer)
	{
	  if (vv < Vmin)
	    while (vv < Vmin)
	      vv += vperiod;
	  else
	    {
	      while (vv >= Vmin)
		vv -= vperiod;
	      vv += vperiod;
	    }
	}
    }
  
  for (;;)
    {
      dedans = 1;
      gp_Pnt2d Puv(u,v);
      
      if(TabOrien(1)!=-1) { 
	for(Standard_Integer n=1; n<=nbtabclass; n++) { 
	  Standard_Integer cur = ((CSLib_Class2d *)TabClass(n))->SiDans_OnMode(Puv,Tol);
	  if(cur==1) { 
	    if(TabOrien(n)==0) { 
	      dedans = -1; 
	      break;
	    }
	  }
	  else if(cur==-1) { 
	    if(TabOrien(n)==1) {  
	      dedans = -1; 
	      break;
	    }
	  }
	  else { 
	    dedans = 0;
	    break;
	  }
	}
	if(dedans==0) {
	  Status = TopAbs_ON;
	}
	if(dedans == 1) {
	  Status = TopAbs_IN;
	}
	if(dedans == -1) {
	  Status = TopAbs_OUT;
	}
      }
      else {  //-- TabOrien(1)=-1    False Wire
	BRepClass_FaceClassifier aClassifier;
	aClassifier.Perform(Face,Puv,Tol);
	Status = aClassifier.State();
      }
      
      if (!RecadreOnPeriodic || (!IsUPer && !IsVPer))
	return Status;
      if (Status == TopAbs_IN || Status == TopAbs_ON)
	return Status;
      
      if (!urecadre)
	{
	  u = uu;
	  urecadre = Standard_True;
	}
      else
	if (IsUPer)
	  u += uperiod;
      if (u > Umax || !IsUPer)
	{
	  if (!vrecadre)
	    {
	      v = vv;
	      vrecadre = Standard_True;
	    }
	  else
	    if (IsVPer)
	      v += vperiod;
	  
	  u = uu;
	  
	  if (v > Vmax || !IsVPer)
	    return Status;
	}
    } //for (;;)
}


void BRepTopAdaptor_FClass2d::Destroy() { 
#if LBRCOMPT
  STAT.NbDestroy++;
#endif
  
  Standard_Integer nbtabclass = TabClass.Length(); 
  for(Standard_Integer d=1; d<=nbtabclass;d++) {
    if(TabClass(d)) { 
      delete ((CSLib_Class2d *)TabClass(d));
      TabClass(d)=NULL;
    }
  }
}


#include <Standard_ConstructionError.hxx>


//const BRepTopAdaptor_FClass2d &  BRepTopAdaptor_FClass2d::Copy(const BRepTopAdaptor_FClass2d& Other) const { 
const BRepTopAdaptor_FClass2d &  BRepTopAdaptor_FClass2d::Copy(const BRepTopAdaptor_FClass2d& ) const { 
#ifdef OCCT_DEBUG
  cerr<<"Copy not allowed in BRepTopAdaptor_FClass2d"<<endl;
#endif
  throw Standard_ConstructionError();
}
Commit	Line	Data
b311480e	1	// Created on: 1995-03-22
	2	// Created by: Laurent BUCHARD
	3	// Copyright (c) 1995-1999 Matra Datavision
973c2be1	4	// Copyright (c) 1999-2014 OPEN CASCADE SAS
b311480e	5	//
973c2be1	6	// This file is part of Open CASCADE Technology software library.
b311480e	7	//
d5f74e42	8	// This library is free software; you can redistribute it and/or modify it under
d5f74e42	9	// the terms of the GNU Lesser General Public License version 2.1 as published
973c2be1	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.
b311480e	13	//
973c2be1	14	// Alternatively, this file may be used under the terms of Open CASCADE
973c2be1	15	// commercial license or contractual agreement.
7fd59977	16
	17	#define AFFICHAGE 0
	18
	19	#define No_Standard_OutOfRange
	20
7fd59977	21
7fd59977	22	#include <BRep_Tool.hxx>
42cf5bc1	23	#include <BRepAdaptor_Curve.hxx>
7fd59977	24	#include <BRepAdaptor_Curve2d.hxx>
42cf5bc1	25	#include <BRepAdaptor_HSurface.hxx>
7fd59977	26	#include <BRepClass_FaceClassifier.hxx>
42cf5bc1	27	#include <BRepTools_WireExplorer.hxx>
42cf5bc1	28	#include <BRepTopAdaptor_FClass2d.hxx>
7fd59977	29	#include <CSLib_Class2d.hxx>
42cf5bc1	30	#include <ElCLib.hxx>
42cf5bc1	31	#include <Geom2dInt_Geom2dCurveTool.hxx>
7fd59977	32	#include <GeomAbs_SurfaceType.hxx>
7fd59977	33	#include <gp_Pnt.hxx>
42cf5bc1	34	#include <gp_Pnt2d.hxx>
7fd59977	35	#include <Precision.hxx>
42cf5bc1	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>
7fd59977	44
57c28b61	45	#ifdef _MSC_VER
7fd59977	46	#include <stdio.h>
	47	#endif
	48
	49
0797d9d3	50	#ifdef OCCT_DEBUG
7fd59977	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
0d969553	92	//-- dead end on surfaces defined on more than one period
7fd59977	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
0d969553	155	//-- Check cases when it was forgotten to code degenerated : PRO17410 (janv 99)
7fd59977	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);
0d969553	182	//-- Attention to rational bsplines of degree 3. (ends of circles among others)
7fd59977	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	//-- ------------------------------------------------------------
0d969553 Y	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
0797d9d3	194	#ifdef OCCT_DEBUG
76363522	195	gp_Pnt2d Pnt2dDebutEdgeCourant = C.Value(u); (void)Pnt2dDebutEdgeCourant;
7fd59977	196	#endif
7fd59977	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)
0d969553	260	{ //-- on compte ++ with a normal explorer and with the Wire Explorer
7fd59977	261	/*
0797d9d3	262	#ifdef OCCT_DEBUG
7fd59977	263
	264	cout << endl;
	265	cout << "* BRepTopAdaptor_Fclass2d Wire Probablement FAUX **" << endl;
0d969553 Y	266	cout << "*** WireExplorer does not find all edges " << endl;
0d969553 Y	267	cout << "*** Connect old classifier" << endl;
7fd59977	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);
6e6cd5d9	282	Standard_Real square = 0.0;
7fd59977	283
7fd59977	284	//-------------------------------------------------------------------
0d969553 Y	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
7fd59977	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);
0797d9d3	329	//#ifdef OCCT_DEBUG
7fd59977	330	// cout << endl;
0d969553 Y	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;
7fd59977	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	{
0797d9d3	341	#ifdef OCCT_DEBUG
7fd59977	342	cout << endl;
0d969553 Y	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;
7fd59977	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	{
0d969553	361	//-- If an error was detected on a wire: set all TabOrien to -1
7fd59977	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	{
c6541a0c	371	Standard_Real uuu=M_PI+M_PI-(Umax-Umin);
7fd59977	372	if(uuu<0) uuu=0;
7fd59977	373	U1 = 0.0; // modified by NIZHNY-OFV Thu May 31 14:24:10 2001 ---> //Umin-uuu*0.5;
c6541a0c	374	U2 = 2*M_PI; // modified by NIZHNY-OFV Thu May 31 14:24:35 2001 ---> //U1+M_PI+M_PI;
7fd59977	375	}
	376	else { U1=U2=0.0; }
	377
	378	if(surf->GetType()==GeomAbs_Torus)
	379	{
c6541a0c	380	Standard_Real uuu=M_PI+M_PI-(Vmax-Vmin);
7fd59977	381	if(uuu<0) uuu=0;
7fd59977	382	V1 = 0.0; // modified by NIZHNY-OFV Thu May 31 14:24:55 2001 ---> //Vmin-uuu*0.5;
c6541a0c	383	V2 = 2*M_PI; // modified by NIZHNY-OFV Thu May 31 14:24:59 2001 ---> //V1+M_PI+M_PI;
7fd59977	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
0d969553	415	//-- U1 is the First Param and U2 in this case is U1+Period
7fd59977	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 );
773f53f1	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;
7fd59977	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	}
0d969553	496	else { //-- TabOrien(1)=-1 False Wire
7fd59977	497	BRepClass_FaceClassifier aClassifier;
	498	aClassifier.Perform(Face,Puv,Toluv);
	499	Status = aClassifier.State();
	500	}
	501
0ebaa4db	502	if (!RecadreOnPeriodic \|\| (!IsUPer && !IsVPer))
7fd59977	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
0d969553	549	//-- U1 is the First Param and U2 in this case is U1+Period
7fd59977	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 );
773f53f1	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;
7fd59977	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	}
0d969553	626	else { //-- TabOrien(1)=-1 False Wire
7fd59977	627	BRepClass_FaceClassifier aClassifier;
	628	aClassifier.Perform(Face,Puv,Tol);
	629	Status = aClassifier.State();
	630	}
	631
0ebaa4db	632	if (!RecadreOnPeriodic \|\| (!IsUPer && !IsVPer))
7fd59977	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 {
0797d9d3	686	#ifdef OCCT_DEBUG
7fd59977	687	cerr<<"Copy not allowed in BRepTopAdaptor_FClass2d"<<endl;
63c629aa	688	#endif
9775fa61	689	throw Standard_ConstructionError();
7fd59977	690	}