[occt.git] / src / IntTools / IntTools_TopolTool.cxx

// 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.


#include <Adaptor3d_HSurface.hxx>
#include <ElSLib.hxx>
#include <Geom_BezierSurface.hxx>
#include <Geom_BSplineSurface.hxx>
#include <gp_Circ.hxx>
#include <gp_Cone.hxx>
#include <gp_Pnt.hxx>
#include <gp_Pnt2d.hxx>
#include <IntTools_TopolTool.hxx>
#include <Precision.hxx>
#include <Standard_DomainError.hxx>
#include <Standard_NotImplemented.hxx>
#include <Standard_Type.hxx>
#include <TColgp_Array2OfPnt.hxx>
#include <TColStd_HArray1OfReal.hxx>

IMPLEMENT_STANDARD_RTTIEXT(IntTools_TopolTool,Adaptor3d_TopolTool)

static void Analyse(const TColgp_Array2OfPnt& array2,
		    Standard_Integer&         theNbSamplesU,
		    Standard_Integer&         theNbSamplesV);

// =====================================================================================
// function: Constructor
// purpose:
// =====================================================================================
IntTools_TopolTool::IntTools_TopolTool()
{
  myNbSmplU = 0;
  myNbSmplV = 0;
  myDU = 1.;
  myDV = 1.;
}

// =====================================================================================
// function: Constructor
// purpose:
// =====================================================================================
IntTools_TopolTool::IntTools_TopolTool(const Handle(Adaptor3d_HSurface)& theSurface)
{
  Initialize(theSurface);
  myNbSmplU = 0;
  myNbSmplV = 0;
  myDU = 1.;
  myDV = 1.;
}

// =====================================================================================
// function: Initialize
// purpose:
// =====================================================================================
void IntTools_TopolTool::Initialize() 
{
  throw Standard_NotImplemented("IntTools_TopolTool::Initialize ()");
}

// =====================================================================================
// function: Initialize
// purpose:
// =====================================================================================
void IntTools_TopolTool::Initialize(const Handle(Adaptor3d_HSurface)& theSurface) 
{
  Adaptor3d_TopolTool::Initialize(theSurface);
  //myS = theSurface;
  myNbSmplU = 0;
  myNbSmplV = 0;
  myDU = 1.;
  myDV = 1.;
}

// =====================================================================================
// function: ComputeSamplePoints
// purpose:
// =====================================================================================
void IntTools_TopolTool::ComputeSamplePoints() 
{
  Standard_Real uinf, usup, vinf, vsup;
  uinf = myS->FirstUParameter();  
  usup = myS->LastUParameter();
  vinf = myS->FirstVParameter();  
  vsup = myS->LastVParameter();
  const Standard_Integer aMaxNbSample = 50;

  if (usup < uinf) { Standard_Real temp = uinf; uinf = usup; usup = temp; }
  if (vsup < vinf) { Standard_Real temp = vinf; vinf = vsup; vsup = temp; }
  Standard_Boolean isbiguinf, isbigusup, isbigvinf, isbigvsup;
  isbiguinf = Precision::IsNegativeInfinite(uinf);
  isbigusup = Precision::IsPositiveInfinite(usup);
  isbigvinf = Precision::IsNegativeInfinite(vinf);
  isbigvsup = Precision::IsPositiveInfinite(vsup);

  if(isbiguinf && isbigusup) {uinf = -1.e5; usup = 1.e5;}
  else if(isbiguinf) {uinf = usup - 2.e5;}
  else if(isbigusup) {usup = uinf + 2.e5;}

  if(isbigvinf && isbigvsup) {vinf = -1.e5; vsup = 1.e5;}
  else if(isbigvinf) {vinf = vsup - 2.e5;}
  else if(isbigvsup) {vsup = vinf + 2.e5;}
  myU0 = uinf;
  myV0 = vinf;

  Standard_Integer nbsu = 0,nbsv = 0;
  GeomAbs_SurfaceType typS = myS->GetType();

  switch(typS) {
  case GeomAbs_Plane: { 
    nbsu = 10; nbsv = 10;
  }
    break;
  case GeomAbs_Cylinder: {
    Standard_Real aRadius = myS->Cylinder().Radius();
    Standard_Real aMaxAngle = M_PI * 0.5;
    Standard_Real aDeflection = 1.e-02;

    if(aRadius > aDeflection) {
      aMaxAngle = ACos(1. - aDeflection / aRadius) * 2.;
    }
    if(aMaxAngle > Precision::Angular()) {
      nbsu = Standard_Integer((usup-uinf) / aMaxAngle);
    }
    nbsv = (Standard_Integer)(vsup-vinf);
    nbsv /= 10;

    if(nbsu < 2) nbsu = 2;
    if(nbsv < 2) nbsv = 2;

//    if(nbsu < 10) nbsu = 10;
//    if(nbsv < 10) nbsv = 10;
    if(nbsu > aMaxNbSample) nbsu = aMaxNbSample;
    if(nbsv > aMaxNbSample) nbsv = aMaxNbSample;
  }
    break;
  case GeomAbs_Cone: {
    gp_Cone aCone = myS->Cone();
    gp_Circ aCircle = ElSLib::ConeVIso(aCone.Position(), aCone.RefRadius(), aCone.SemiAngle(), vinf);
    Standard_Real aRadius = aCircle.Radius();
    aCircle = ElSLib::ConeVIso(aCone.Position(), aCone.RefRadius(), aCone.SemiAngle(), vsup);

    if(aRadius < aCircle.Radius())
      aRadius = aCircle.Radius();
    Standard_Real aMaxAngle = M_PI * 0.5;
    Standard_Real aDeflection = 1.e-02;

    if(aRadius > aDeflection) {
      aMaxAngle = ACos(1. - aDeflection / aRadius) * 2.;
    }

    if(aMaxAngle > Precision::Angular()) {
      nbsu = Standard_Integer((usup - uinf) / aMaxAngle);
    }
    nbsv = (Standard_Integer)(vsup - vinf);
    nbsv /= 10;

//     if(nbsu < 2) nbsu = 2;
//     if(nbsv < 2) nbsv = 2;

    if(nbsu < 10) nbsu = 10;
    if(nbsv < 10) nbsv = 10;
    if(nbsu > aMaxNbSample) nbsu = aMaxNbSample;
    if(nbsv > aMaxNbSample) nbsv = aMaxNbSample;
  }
    break;
  case GeomAbs_Sphere:
  case GeomAbs_Torus: {
    gp_Circ aCircle;
    Standard_Real aRadius1, aRadius2;

    if(typS == GeomAbs_Torus) {
      gp_Torus aTorus = myS->Torus();
      aCircle = ElSLib::TorusUIso(aTorus.Position(), aTorus.MajorRadius(), aTorus.MinorRadius(), uinf);
      aRadius2 = aCircle.Radius();
      aCircle = ElSLib::TorusUIso(aTorus.Position(), aTorus.MajorRadius(), aTorus.MinorRadius(), usup);
      aRadius2 = (aRadius2 < aCircle.Radius()) ? aCircle.Radius() : aRadius2;
      
      aCircle = ElSLib::TorusVIso(aTorus.Position(), aTorus.MajorRadius(), aTorus.MinorRadius(), vinf);
      aRadius1 = aCircle.Radius();
      aCircle = ElSLib::TorusVIso(aTorus.Position(), aTorus.MajorRadius(), aTorus.MinorRadius(), vsup);
      aRadius1 = (aRadius1 < aCircle.Radius()) ? aCircle.Radius() : aRadius1;
    }
    else {
      gp_Sphere aSphere = myS->Sphere();
      aRadius1 = aSphere.Radius();
      aRadius2 = aSphere.Radius();
    }
    Standard_Real aMaxAngle = M_PI * 0.5;
    Standard_Real aDeflection = 1.e-02;
    
    if(aRadius1 > aDeflection) {
      aMaxAngle = ACos(1. - aDeflection / aRadius1) * 2.;
    }
    
    if(aMaxAngle > Precision::Angular()) {
      nbsu = Standard_Integer((usup - uinf) / aMaxAngle);
    }
    aMaxAngle = M_PI * 0.5;

    if(aRadius2 > aDeflection) {
      aMaxAngle = ACos(1. - aDeflection / aRadius2) * 2.;
    }
    
    if(aMaxAngle > Precision::Angular()) {
      nbsv = Standard_Integer((vsup - vinf) / aMaxAngle);
    }
    if(nbsu < 10) nbsu = 10;
    if(nbsv < 10) nbsv = 10;
    if(nbsu > aMaxNbSample) nbsu = aMaxNbSample;
    if(nbsv > aMaxNbSample) nbsv = aMaxNbSample;
  }
    break;
  case GeomAbs_BezierSurface: {
    nbsv = 3 + myS->NbVPoles(); 
    nbsu = 3 + myS->NbUPoles();

    if(nbsu > 10 || nbsv > 10) {
      TColgp_Array2OfPnt array2(1, myS->NbUPoles(), 1, myS->NbVPoles());
      myS->Bezier()->Poles(array2);
      Analyse(array2, nbsu, nbsv);
    }

    if(nbsu < 10) nbsu = 10;
    if(nbsv < 10) nbsv = 10;
  }
    break;
  case GeomAbs_BSplineSurface: {
    nbsv = myS->NbVKnots();     nbsv *= myS->VDegree();     if(nbsv < 4) nbsv=4;    
    nbsu = myS->NbUKnots();     nbsu *= myS->UDegree();     if(nbsu < 4) nbsu=4;
    
    if(nbsu > 10 || nbsv > 10) {
      TColgp_Array2OfPnt array2(1, myS->NbUPoles(), 1, myS->NbVPoles());
      myS->BSpline()->Poles(array2);
      Analyse(array2, nbsu, nbsv);
    }
    if(nbsu < 10) nbsu = 10;
    if(nbsv < 10) nbsv = 10;
    // Check anisotropy
    Standard_Real anULen = (usup - uinf) / myS->UResolution(1.);
    Standard_Real anVLen = (vsup - vinf) / myS->VResolution(1.);
    Standard_Real aRatio = anULen / anVLen;
    if (aRatio >= 10.)
    {
      nbsu *= 2;
      nbsu = Min(nbsu, aMaxNbSample);
    }
    else if (aRatio <= 0.1 )
    {
      nbsv *= 2;
      nbsv = Min(nbsv, aMaxNbSample);
    }
  }
    break;
  case GeomAbs_SurfaceOfExtrusion: {
    nbsu = 15;
    nbsv = (Standard_Integer)(vsup - vinf);
    nbsv /= 10;
    if(nbsv < 15) nbsv = 15;
    if(nbsv > aMaxNbSample) nbsv = aMaxNbSample;
  }
    break;
  case GeomAbs_SurfaceOfRevolution: {
    nbsv = 15; nbsu = 15;
  }
    break;
  default: {
    nbsu = 10; nbsv = 10;
  }
    break;
  }
  myNbSmplU = nbsu;
  myNbSmplV = nbsv;

  myNbSamplesU = myNbSmplU;
  myNbSamplesV = myNbSmplV;

  myDU = (usup - uinf)/(myNbSmplU + 1);
  myDV = (vsup - vinf)/(myNbSmplV + 1);
}

// =====================================================================================
// function: NbSamplesU
// purpose:
// =====================================================================================
Standard_Integer IntTools_TopolTool::NbSamplesU() 
{
  if(myNbSmplU <= 0) {
    ComputeSamplePoints();
  }
  return myNbSmplU;
}

// =====================================================================================
// function: NbSamplesV
// purpose:
// =====================================================================================
Standard_Integer IntTools_TopolTool::NbSamplesV() 
{
  if(myNbSmplV <= 0) {
    ComputeSamplePoints();
  }
  return myNbSmplV;
}

// =====================================================================================
// function: NbSamples
// purpose:
// =====================================================================================
Standard_Integer IntTools_TopolTool::NbSamples() 
{
  if(myNbSmplU <= 0) { 
    ComputeSamplePoints();    
  }
  return(myNbSmplU * myNbSmplV);
}

// =====================================================================================
// function: SamplePoint
// purpose:
// =====================================================================================
void IntTools_TopolTool::SamplePoint(const Standard_Integer Index,
				     gp_Pnt2d&              P2d,
				     gp_Pnt&                P3d) 
{
  if (myUPars.IsNull())
    {
      if(myNbSmplU <= 0) { 
	ComputeSamplePoints();    
      }
      Standard_Integer iv = 1 + Index / myNbSmplU;
      Standard_Integer iu = 1 + Index - (iv - 1) * myNbSmplU;
      Standard_Real u = myU0 + iu * myDU;
      Standard_Real v = myV0 + iv * myDV;
      P2d.SetCoord(u, v);
      P3d = myS->Value(u, v);
    }
  else
    Adaptor3d_TopolTool::SamplePoint(Index, P2d, P3d);
}


//=======================================================================
// function : Analyse
// purpose  : 
//=======================================================================
void Analyse(const TColgp_Array2OfPnt& array2,
	     Standard_Integer&         theNbSamplesU,
	     Standard_Integer&         theNbSamplesV) 
{ 
  gp_Vec Vi,Vip1;
  Standard_Integer sh,nbch,i,j;
  const Standard_Integer nbup = array2.UpperRow() - array2.LowerRow() + 1;
  const Standard_Integer nbvp = array2.UpperCol() - array2.LowerCol() + 1;
  
  sh = 1;
  nbch = 0;
  if(nbvp>2) {

    for(i = array2.LowerRow(); i <= array2.UpperRow(); i++) {
      const gp_Pnt& A=array2.Value(i,1);
      const gp_Pnt& B=array2.Value(i,2);
      const gp_Pnt& C=array2.Value(i,3);
      Vi.SetCoord(C.X()-B.X()-B.X()+A.X(),
		  C.Y()-B.Y()-B.Y()+A.Y(),
		  C.Z()-B.Z()-B.Z()+A.Z());
      Standard_Integer locnbch=0;

      for(j = array2.LowerCol() + 2; j < array2.UpperCol();j++) {  //-- essai
	const gp_Pnt& Ax=array2.Value(i,j-1);
	const gp_Pnt& Bx=array2.Value(i,j);
	const gp_Pnt& Cx=array2.Value(i,j+1);
	Vip1.SetCoord(Cx.X()-Bx.X()-Bx.X()+Ax.X(),
		      Cx.Y()-Bx.Y()-Bx.Y()+Ax.Y(),
		      Cx.Z()-Bx.Z()-Bx.Z()+Ax.Z());
	Standard_Real pd = Vi.Dot(Vip1);
	Vi=Vip1;
	if(pd>1.0e-7 || pd<-1.0e-7) {  
	  if(pd>0) {  if(sh==-1) {   sh=1; locnbch++; 	}  }
	  else { 	if(sh==1) {  sh=-1; locnbch++; 	}  }
	}
      }
      if(locnbch>nbch) { 
	nbch=locnbch; 
      }
    }
  }
  theNbSamplesV = nbch+5;
  

  nbch=0;
  if(nbup > 2) { 
    for(j = array2.LowerCol(); j <= array2.UpperCol(); j++) { 
      const gp_Pnt& A=array2.Value(array2.LowerRow(),     j);
      const gp_Pnt& B=array2.Value(array2.LowerRow() + 1, j);
      const gp_Pnt& C=array2.Value(array2.LowerRow() + 2, j);
      Vi.SetCoord(C.X()-B.X()-B.X()+A.X(),
		  C.Y()-B.Y()-B.Y()+A.Y(),
		  C.Z()-B.Z()-B.Z()+A.Z());
      Standard_Integer locnbch=0;

      for(i = array2.LowerRow() + 2; i < array2.UpperRow(); i++) {  //-- essai
	const gp_Pnt& Ax=array2.Value(i-1,j);
	const gp_Pnt& Bx=array2.Value(i,j);
	const gp_Pnt& Cx=array2.Value(i+1,j);
	Vip1.SetCoord(Cx.X()-Bx.X()-Bx.X()+Ax.X(),
		    Cx.Y()-Bx.Y()-Bx.Y()+Ax.Y(),
		    Cx.Z()-Bx.Z()-Bx.Z()+Ax.Z());
	Standard_Real pd = Vi.Dot(Vip1);
	Vi=Vip1;
	if(pd>1.0e-7 || pd<-1.0e-7) {  
	  if(pd>0) {  if(sh==-1) {   sh=1; locnbch++; 	}  }
	  else { 	if(sh==1) {  sh=-1; locnbch++; 	}  }
	}
      }
      if(locnbch>nbch) nbch=locnbch;
    }  
  }
  theNbSamplesU = nbch+5;
}

//Modified IFV
//=======================================================================
//function : SamplePnts
//purpose  : 
//=======================================================================

void IntTools_TopolTool::SamplePnts(const Standard_Real theDefl, 
				    const Standard_Integer theNUmin,
				    const Standard_Integer theNVmin)
{ 
  Adaptor3d_TopolTool::SamplePnts(theDefl, theNUmin, theNVmin);

  myNbSmplU = Adaptor3d_TopolTool::NbSamplesU();
  myNbSmplV = Adaptor3d_TopolTool::NbSamplesV();

  myU0 = myUPars->Value(1);
  myV0 = myVPars->Value(1);

  myDU = (myUPars->Value(myNbSmplU) - myU0)/(myNbSmplU-1);  
  myDV = (myVPars->Value(myNbSmplV) - myU0)/(myNbSmplV-1);
}
Commit	Line	Data
973c2be1	1	// Copyright (c) 1999-2014 OPEN CASCADE SAS
b311480e	2	//
973c2be1	3	// This file is part of Open CASCADE Technology software library.
b311480e	4	//
d5f74e42	5	// This library is free software; you can redistribute it and/or modify it under
d5f74e42	6	// the terms of the GNU Lesser General Public License version 2.1 as published
973c2be1	7	// by the Free Software Foundation, with special exception defined in the file
	8	// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
	9	// distribution for complete text of the license and disclaimer of any warranty.
b311480e	10	//
973c2be1	11	// Alternatively, this file may be used under the terms of Open CASCADE
973c2be1	12	// commercial license or contractual agreement.
b311480e	13
7fd59977	14
42cf5bc1	15	#include <Adaptor3d_HSurface.hxx>
42cf5bc1	16	#include <ElSLib.hxx>
7fd59977	17	#include <Geom_BezierSurface.hxx>
42cf5bc1	18	#include <Geom_BSplineSurface.hxx>
7fd59977	19	#include <gp_Circ.hxx>
7fd59977	20	#include <gp_Cone.hxx>
42cf5bc1	21	#include <gp_Pnt.hxx>
	22	#include <gp_Pnt2d.hxx>
	23	#include <IntTools_TopolTool.hxx>
	24	#include <Precision.hxx>
	25	#include <Standard_DomainError.hxx>
	26	#include <Standard_NotImplemented.hxx>
	27	#include <Standard_Type.hxx>
	28	#include <TColgp_Array2OfPnt.hxx>
7fd59977	29	#include <TColStd_HArray1OfReal.hxx>
7fd59977	30
92efcf78	31	IMPLEMENT_STANDARD_RTTIEXT(IntTools_TopolTool,Adaptor3d_TopolTool)
92efcf78	32
7fd59977	33	static void Analyse(const TColgp_Array2OfPnt& array2,
	34	Standard_Integer& theNbSamplesU,
	35	Standard_Integer& theNbSamplesV);
	36
	37	// =====================================================================================
	38	// function: Constructor
	39	// purpose:
	40	// =====================================================================================
	41	IntTools_TopolTool::IntTools_TopolTool()
	42	{
	43	myNbSmplU = 0;
	44	myNbSmplV = 0;
	45	myDU = 1.;
	46	myDV = 1.;
	47	}
	48
	49	// =====================================================================================
	50	// function: Constructor
	51	// purpose:
	52	// =====================================================================================
	53	IntTools_TopolTool::IntTools_TopolTool(const Handle(Adaptor3d_HSurface)& theSurface)
	54	{
	55	Initialize(theSurface);
	56	myNbSmplU = 0;
	57	myNbSmplV = 0;
	58	myDU = 1.;
	59	myDV = 1.;
	60	}
	61
	62	// =====================================================================================
	63	// function: Initialize
	64	// purpose:
	65	// =====================================================================================
	66	void IntTools_TopolTool::Initialize()
	67	{
9775fa61	68	throw Standard_NotImplemented("IntTools_TopolTool::Initialize ()");
7fd59977	69	}
	70
	71	// =====================================================================================
	72	// function: Initialize
	73	// purpose:
	74	// =====================================================================================
	75	void IntTools_TopolTool::Initialize(const Handle(Adaptor3d_HSurface)& theSurface)
	76	{
	77	Adaptor3d_TopolTool::Initialize(theSurface);
	78	//myS = theSurface;
	79	myNbSmplU = 0;
	80	myNbSmplV = 0;
	81	myDU = 1.;
	82	myDV = 1.;
	83	}
	84
	85	// =====================================================================================
	86	// function: ComputeSamplePoints
	87	// purpose:
	88	// =====================================================================================
	89	void IntTools_TopolTool::ComputeSamplePoints()
	90	{
	91	Standard_Real uinf, usup, vinf, vsup;
	92	uinf = myS->FirstUParameter();
	93	usup = myS->LastUParameter();
	94	vinf = myS->FirstVParameter();
	95	vsup = myS->LastVParameter();
	96	const Standard_Integer aMaxNbSample = 50;
	97
	98	if (usup < uinf) { Standard_Real temp = uinf; uinf = usup; usup = temp; }
	99	if (vsup < vinf) { Standard_Real temp = vinf; vinf = vsup; vsup = temp; }
	100	Standard_Boolean isbiguinf, isbigusup, isbigvinf, isbigvsup;
	101	isbiguinf = Precision::IsNegativeInfinite(uinf);
	102	isbigusup = Precision::IsPositiveInfinite(usup);
	103	isbigvinf = Precision::IsNegativeInfinite(vinf);
	104	isbigvsup = Precision::IsPositiveInfinite(vsup);
	105
	106	if(isbiguinf && isbigusup) {uinf = -1.e5; usup = 1.e5;}
	107	else if(isbiguinf) {uinf = usup - 2.e5;}
	108	else if(isbigusup) {usup = uinf + 2.e5;}
	109
	110	if(isbigvinf && isbigvsup) {vinf = -1.e5; vsup = 1.e5;}
	111	else if(isbigvinf) {vinf = vsup - 2.e5;}
	112	else if(isbigvsup) {vsup = vinf + 2.e5;}
	113	myU0 = uinf;
	114	myV0 = vinf;
	115
5cbfdb41	116	Standard_Integer nbsu = 0,nbsv = 0;
7fd59977	117	GeomAbs_SurfaceType typS = myS->GetType();
	118
	119	switch(typS) {
	120	case GeomAbs_Plane: {
	121	nbsu = 10; nbsv = 10;
	122	}
	123	break;
	124	case GeomAbs_Cylinder: {
	125	Standard_Real aRadius = myS->Cylinder().Radius();
c6541a0c	126	Standard_Real aMaxAngle = M_PI * 0.5;
7fd59977	127	Standard_Real aDeflection = 1.e-02;
	128
	129	if(aRadius > aDeflection) {
	130	aMaxAngle = ACos(1. - aDeflection / aRadius) * 2.;
	131	}
	132	if(aMaxAngle > Precision::Angular()) {
	133	nbsu = Standard_Integer((usup-uinf) / aMaxAngle);
	134	}
	135	nbsv = (Standard_Integer)(vsup-vinf);
	136	nbsv /= 10;
	137
	138	if(nbsu < 2) nbsu = 2;
	139	if(nbsv < 2) nbsv = 2;
	140
	141	// if(nbsu < 10) nbsu = 10;
	142	// if(nbsv < 10) nbsv = 10;
	143	if(nbsu > aMaxNbSample) nbsu = aMaxNbSample;
	144	if(nbsv > aMaxNbSample) nbsv = aMaxNbSample;
	145	}
	146	break;
	147	case GeomAbs_Cone: {
	148	gp_Cone aCone = myS->Cone();
	149	gp_Circ aCircle = ElSLib::ConeVIso(aCone.Position(), aCone.RefRadius(), aCone.SemiAngle(), vinf);
	150	Standard_Real aRadius = aCircle.Radius();
	151	aCircle = ElSLib::ConeVIso(aCone.Position(), aCone.RefRadius(), aCone.SemiAngle(), vsup);
	152
	153	if(aRadius < aCircle.Radius())
	154	aRadius = aCircle.Radius();
c6541a0c	155	Standard_Real aMaxAngle = M_PI * 0.5;
7fd59977	156	Standard_Real aDeflection = 1.e-02;
	157
	158	if(aRadius > aDeflection) {
	159	aMaxAngle = ACos(1. - aDeflection / aRadius) * 2.;
	160	}
	161
	162	if(aMaxAngle > Precision::Angular()) {
	163	nbsu = Standard_Integer((usup - uinf) / aMaxAngle);
	164	}
	165	nbsv = (Standard_Integer)(vsup - vinf);
	166	nbsv /= 10;
	167
	168	// if(nbsu < 2) nbsu = 2;
	169	// if(nbsv < 2) nbsv = 2;
	170
	171	if(nbsu < 10) nbsu = 10;
	172	if(nbsv < 10) nbsv = 10;
	173	if(nbsu > aMaxNbSample) nbsu = aMaxNbSample;
	174	if(nbsv > aMaxNbSample) nbsv = aMaxNbSample;
	175	}
	176	break;
	177	case GeomAbs_Sphere:
	178	case GeomAbs_Torus: {
	179	gp_Circ aCircle;
	180	Standard_Real aRadius1, aRadius2;
	181
	182	if(typS == GeomAbs_Torus) {
	183	gp_Torus aTorus = myS->Torus();
	184	aCircle = ElSLib::TorusUIso(aTorus.Position(), aTorus.MajorRadius(), aTorus.MinorRadius(), uinf);
	185	aRadius2 = aCircle.Radius();
	186	aCircle = ElSLib::TorusUIso(aTorus.Position(), aTorus.MajorRadius(), aTorus.MinorRadius(), usup);
	187	aRadius2 = (aRadius2 < aCircle.Radius()) ? aCircle.Radius() : aRadius2;
	188
	189	aCircle = ElSLib::TorusVIso(aTorus.Position(), aTorus.MajorRadius(), aTorus.MinorRadius(), vinf);
	190	aRadius1 = aCircle.Radius();
	191	aCircle = ElSLib::TorusVIso(aTorus.Position(), aTorus.MajorRadius(), aTorus.MinorRadius(), vsup);
	192	aRadius1 = (aRadius1 < aCircle.Radius()) ? aCircle.Radius() : aRadius1;
	193	}
	194	else {
	195	gp_Sphere aSphere = myS->Sphere();
	196	aRadius1 = aSphere.Radius();
	197	aRadius2 = aSphere.Radius();
	198	}
c6541a0c	199	Standard_Real aMaxAngle = M_PI * 0.5;
7fd59977	200	Standard_Real aDeflection = 1.e-02;
	201
	202	if(aRadius1 > aDeflection) {
	203	aMaxAngle = ACos(1. - aDeflection / aRadius1) * 2.;
	204	}
	205
	206	if(aMaxAngle > Precision::Angular()) {
	207	nbsu = Standard_Integer((usup - uinf) / aMaxAngle);
	208	}
c6541a0c	209	aMaxAngle = M_PI * 0.5;
7fd59977	210
	211	if(aRadius2 > aDeflection) {
	212	aMaxAngle = ACos(1. - aDeflection / aRadius2) * 2.;
	213	}
	214
	215	if(aMaxAngle > Precision::Angular()) {
	216	nbsv = Standard_Integer((vsup - vinf) / aMaxAngle);
	217	}
	218	if(nbsu < 10) nbsu = 10;
	219	if(nbsv < 10) nbsv = 10;
	220	if(nbsu > aMaxNbSample) nbsu = aMaxNbSample;
	221	if(nbsv > aMaxNbSample) nbsv = aMaxNbSample;
	222	}
	223	break;
	224	case GeomAbs_BezierSurface: {
	225	nbsv = 3 + myS->NbVPoles();
	226	nbsu = 3 + myS->NbUPoles();
	227
	228	if(nbsu > 10 \|\| nbsv > 10) {
	229	TColgp_Array2OfPnt array2(1, myS->NbUPoles(), 1, myS->NbVPoles());
	230	myS->Bezier()->Poles(array2);
	231	Analyse(array2, nbsu, nbsv);
	232	}
	233
	234	if(nbsu < 10) nbsu = 10;
	235	if(nbsv < 10) nbsv = 10;
	236	}
	237	break;
	238	case GeomAbs_BSplineSurface: {
	239	nbsv = myS->NbVKnots(); nbsv *= myS->VDegree(); if(nbsv < 4) nbsv=4;
	240	nbsu = myS->NbUKnots(); nbsu *= myS->UDegree(); if(nbsu < 4) nbsu=4;
	241
	242	if(nbsu > 10 \|\| nbsv > 10) {
	243	TColgp_Array2OfPnt array2(1, myS->NbUPoles(), 1, myS->NbVPoles());
	244	myS->BSpline()->Poles(array2);
	245	Analyse(array2, nbsu, nbsv);
	246	}
	247	if(nbsu < 10) nbsu = 10;
	248	if(nbsv < 10) nbsv = 10;
79e9ba31	249	// Check anisotropy
	250	Standard_Real anULen = (usup - uinf) / myS->UResolution(1.);
	251	Standard_Real anVLen = (vsup - vinf) / myS->VResolution(1.);
	252	Standard_Real aRatio = anULen / anVLen;
	253	if (aRatio >= 10.)
	254	{
	255	nbsu *= 2;
	256	nbsu = Min(nbsu, aMaxNbSample);
	257	}
	258	else if (aRatio <= 0.1 )
	259	{
	260	nbsv *= 2;
	261	nbsv = Min(nbsv, aMaxNbSample);
	262	}
7fd59977	263	}
	264	break;
	265	case GeomAbs_SurfaceOfExtrusion: {
	266	nbsu = 15;
	267	nbsv = (Standard_Integer)(vsup - vinf);
	268	nbsv /= 10;
	269	if(nbsv < 15) nbsv = 15;
	270	if(nbsv > aMaxNbSample) nbsv = aMaxNbSample;
	271	}
	272	break;
	273	case GeomAbs_SurfaceOfRevolution: {
	274	nbsv = 15; nbsu = 15;
	275	}
	276	break;
	277	default: {
	278	nbsu = 10; nbsv = 10;
	279	}
	280	break;
	281	}
	282	myNbSmplU = nbsu;
	283	myNbSmplV = nbsv;
	284
	285	myNbSamplesU = myNbSmplU;
	286	myNbSamplesV = myNbSmplV;
	287
	288	myDU = (usup - uinf)/(myNbSmplU + 1);
	289	myDV = (vsup - vinf)/(myNbSmplV + 1);
	290	}
	291
	292	// =====================================================================================
	293	// function: NbSamplesU
	294	// purpose:
	295	// =====================================================================================
	296	Standard_Integer IntTools_TopolTool::NbSamplesU()
	297	{
	298	if(myNbSmplU <= 0) {
	299	ComputeSamplePoints();
	300	}
	301	return myNbSmplU;
	302	}
	303
	304	// =====================================================================================
	305	// function: NbSamplesV
	306	// purpose:
	307	// =====================================================================================
	308	Standard_Integer IntTools_TopolTool::NbSamplesV()
	309	{
	310	if(myNbSmplV <= 0) {
	311	ComputeSamplePoints();
	312	}
	313	return myNbSmplV;
	314	}
	315
	316	// =====================================================================================
	317	// function: NbSamples
	318	// purpose:
	319	// =====================================================================================
	320	Standard_Integer IntTools_TopolTool::NbSamples()
	321	{
	322	if(myNbSmplU <= 0) {
	323	ComputeSamplePoints();
	324	}
	325	return(myNbSmplU * myNbSmplV);
	326	}
327
328	// =====================================================================================
329	// function: SamplePoint
330	// purpose:
331	// =====================================================================================
332	void IntTools_TopolTool::SamplePoint(const Standard_Integer Index,
333	gp_Pnt2d& P2d,
334	gp_Pnt& P3d)
335	{
336	if (myUPars.IsNull())
337	{
338	if(myNbSmplU <= 0) {
339	ComputeSamplePoints();
340	}
341	Standard_Integer iv = 1 + Index / myNbSmplU;
342	Standard_Integer iu = 1 + Index - (iv - 1) * myNbSmplU;
343	Standard_Real u = myU0 + iu * myDU;
344	Standard_Real v = myV0 + iv * myDV;
345	P2d.SetCoord(u, v);
346	P3d = myS->Value(u, v);
347	}
348	else
349	Adaptor3d_TopolTool::SamplePoint(Index, P2d, P3d);
350	}
351
352
353	//=======================================================================
354	// function : Analyse
355	// purpose :
356	//=======================================================================
357	void Analyse(const TColgp_Array2OfPnt& array2,
358	Standard_Integer& theNbSamplesU,
359	Standard_Integer& theNbSamplesV)
360	{
361	gp_Vec Vi,Vip1;
362	Standard_Integer sh,nbch,i,j;
363	const Standard_Integer nbup = array2.UpperRow() - array2.LowerRow() + 1;
364	const Standard_Integer nbvp = array2.UpperCol() - array2.LowerCol() + 1;
365
366	sh = 1;
367	nbch = 0;
368	if(nbvp>2) {
369
370	for(i = array2.LowerRow(); i <= array2.UpperRow(); i++) {
371	const gp_Pnt& A=array2.Value(i,1);
372	const gp_Pnt& B=array2.Value(i,2);
373	const gp_Pnt& C=array2.Value(i,3);
374	Vi.SetCoord(C.X()-B.X()-B.X()+A.X(),
375	C.Y()-B.Y()-B.Y()+A.Y(),
376	C.Z()-B.Z()-B.Z()+A.Z());
377	Standard_Integer locnbch=0;
378
379	for(j = array2.LowerCol() + 2; j < array2.UpperCol();j++) { //-- essai
380	const gp_Pnt& Ax=array2.Value(i,j-1);
381	const gp_Pnt& Bx=array2.Value(i,j);
382	const gp_Pnt& Cx=array2.Value(i,j+1);
383	Vip1.SetCoord(Cx.X()-Bx.X()-Bx.X()+Ax.X(),
384	Cx.Y()-Bx.Y()-Bx.Y()+Ax.Y(),
385	Cx.Z()-Bx.Z()-Bx.Z()+Ax.Z());
386	Standard_Real pd = Vi.Dot(Vip1);
387	Vi=Vip1;
388	if(pd>1.0e-7 \|\| pd<-1.0e-7) {
389	if(pd>0) { if(sh==-1) { sh=1; locnbch++; } }
390	else { if(sh==1) { sh=-1; locnbch++; } }
391	}
392	}
393	if(locnbch>nbch) {
394	nbch=locnbch;
395	}
396	}
397	}
398	theNbSamplesV = nbch+5;
399
400
401	nbch=0;
402	if(nbup > 2) {
403	for(j = array2.LowerCol(); j <= array2.UpperCol(); j++) {
404	const gp_Pnt& A=array2.Value(array2.LowerRow(), j);
405	const gp_Pnt& B=array2.Value(array2.LowerRow() + 1, j);
406	const gp_Pnt& C=array2.Value(array2.LowerRow() + 2, j);
407	Vi.SetCoord(C.X()-B.X()-B.X()+A.X(),
408	C.Y()-B.Y()-B.Y()+A.Y(),
409	C.Z()-B.Z()-B.Z()+A.Z());
410	Standard_Integer locnbch=0;
411
412	for(i = array2.LowerRow() + 2; i < array2.UpperRow(); i++) { //-- essai
413	const gp_Pnt& Ax=array2.Value(i-1,j);
414	const gp_Pnt& Bx=array2.Value(i,j);
415	const gp_Pnt& Cx=array2.Value(i+1,j);
416	Vip1.SetCoord(Cx.X()-Bx.X()-Bx.X()+Ax.X(),
417	Cx.Y()-Bx.Y()-Bx.Y()+Ax.Y(),
418	Cx.Z()-Bx.Z()-Bx.Z()+Ax.Z());
419	Standard_Real pd = Vi.Dot(Vip1);
420	Vi=Vip1;
421	if(pd>1.0e-7 \|\| pd<-1.0e-7) {
422	if(pd>0) { if(sh==-1) { sh=1; locnbch++; } }
423	else { if(sh==1) { sh=-1; locnbch++; } }
424	}
425	}
426	if(locnbch>nbch) nbch=locnbch;
427	}
428	}
429	theNbSamplesU = nbch+5;
430	}
431
432	//Modified IFV
433	//=======================================================================
434	//function : SamplePnts
435	//purpose :
436	//=======================================================================
437
438	void IntTools_TopolTool::SamplePnts(const Standard_Real theDefl,
439	const Standard_Integer theNUmin,
440	const Standard_Integer theNVmin)
441	{
442	Adaptor3d_TopolTool::SamplePnts(theDefl, theNUmin, theNVmin);
443
444	myNbSmplU = Adaptor3d_TopolTool::NbSamplesU();
445	myNbSmplV = Adaptor3d_TopolTool::NbSamplesV();
446
447	myU0 = myUPars->Value(1);
448	myV0 = myVPars->Value(1);
449
450	myDU = (myUPars->Value(myNbSmplU) - myU0)/(myNbSmplU-1);
451	myDV = (myVPars->Value(myNbSmplV) - myU0)/(myNbSmplV-1);
452	}