OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-04-04 18:06:22 +03:00
Code Packages Releases Activity
occt/src/IntTools/IntTools_FClass2d.cxx
emv 655fddc854 0024981: IntTools_FaceFace enters to infinite loop on the attached case 
class IntTools_Tools
method
  Standard_Boolean IntTools_Tools::AdjustPeriodic
      (const Standard_Real thePar,
       const Standard_Real theParMin,
       const Standard_Real theParMax,
       const Standard_Real thePeriod,
       Standard_Real &theNewPar,
       Standard_Real &theOffset,
       const Standard_Real theEps)
The new function has been implemented for fast adjustment of pcurves to the range of surface.
Test case correction for issue CR24981
2014-06-11 10:41:58 +04:00

784 lines
22 KiB
C++
Raw Blame History

// 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.
#include <IntTools_FClass2d.ixx>
#include <stdio.h>
#include <Precision.hxx>
#include <gp_Pnt.hxx>
#include <ElCLib.hxx>
#include <Geom2dInt_Geom2dCurveTool.hxx>
#include <GeomAbs_SurfaceType.hxx>
#include <BRep_Tool.hxx>
#include <BRepTools_WireExplorer.hxx>
#include <BRepClass_FaceClassifier.hxx>
#include <CSLib_Class2d.hxx>
#include <BRepAdaptor_HSurface.hxx>
#include <BRepAdaptor_Curve.hxx>
#include <BRepAdaptor_Curve2d.hxx>
#include <TopoDS.hxx>
#include <TopoDS_Edge.hxx>
#include <TopExp.hxx>
#include <TopAbs_Orientation.hxx>
#include <TopExp_Explorer.hxx>
#include <TColgp_SequenceOfPnt2d.hxx>
#include <TColgp_Array1OfPnt2d.hxx>
#include <TopoDS_Wire.hxx>
#include <TColStd_DataMapOfIntegerInteger.hxx>
#include <TColgp_SequenceOfVec2d.hxx>
#include <IntTools_Tools.hxx>
//=======================================================================
//function : IntTools_FClass2d:IntTools:_FClass2d
//purpose :
//=======================================================================
IntTools_FClass2d::IntTools_FClass2d()
{
}
//=======================================================================
//function : IntTools_FClass2d::IntTools_FClass2d
//purpose :
//=======================================================================
IntTools_FClass2d::IntTools_FClass2d(const TopoDS_Face& aFace,
const Standard_Real TolUV)
: Toluv(TolUV), Face(aFace)
{
Init(Face, Toluv);
}
//=======================================================================
//function : IsHole
//purpose :
//=======================================================================
Standard_Boolean IntTools_FClass2d::IsHole() const
{
return myIsHole;
}
//=======================================================================
//function : Init
//purpose :
//=======================================================================
void IntTools_FClass2d::Init(const TopoDS_Face& aFace,
const Standard_Real TolUV)
{
Standard_Boolean WireIsNotEmpty, Ancienpnt3dinitialise, degenerated;
Standard_Integer nbpnts, firstpoint, NbEdges;
Standard_Integer iX, aNbs1, nbs, Avant, BadWire;
Standard_Real u, du, Tole, Tol, pfbid, plbid;
Standard_Real FlecheU, FlecheV, TolVertex1, TolVertex;
Standard_Real uFirst, uLast;
Standard_Real aPrCf, aPrCf2;
//
TopoDS_Edge edge;
TopoDS_Vertex Va,Vb;
TopAbs_Orientation Or;
BRepTools_WireExplorer aWExp;
TopExp_Explorer aExpF, aExp;
Handle(Geom2d_Curve) aC2D;
gp_Pnt Ancienpnt3d;
TColgp_SequenceOfPnt2d SeqPnt2d;
TColStd_DataMapOfIntegerInteger anIndexMap;
TColgp_SequenceOfVec2d aD1Prev;
TColgp_SequenceOfVec2d aD1Next;
//
aPrCf=Precision::Confusion();
aPrCf2=aPrCf*aPrCf;
myIsHole=Standard_True;
//
Toluv=TolUV;
Face=aFace;
Face.Orientation(TopAbs_FORWARD);
Handle(BRepAdaptor_HSurface) surf = new BRepAdaptor_HSurface();
surf->ChangeSurface().Initialize(aFace, Standard_False);
//
Tole = 0.;
Tol=0.;
Umin = Vmin = RealLast();
Umax = Vmax = -Umin;
BadWire=0;
//
//if face has several wires and one of them is bad,
//it is necessary to process all of them for correct
//calculation of Umin, Umax, Vmin, Vmax - ifv, 23.08.06
//
aExpF.Init(Face,TopAbs_WIRE);
for(; aExpF.More(); aExpF.Next()) {
const TopoDS_Wire& aW=*((TopoDS_Wire*)&aExpF.Current());
//
nbpnts = 0;
firstpoint =1;
FlecheU = 0.;
FlecheV = 0.;
TolVertex1=0.;
TolVertex=0.;
WireIsNotEmpty = Standard_False;
Ancienpnt3dinitialise=Standard_False;
Ancienpnt3d.SetCoord(0.,0.,0.);
//
SeqPnt2d.Clear();
anIndexMap.Clear();
aD1Prev.Clear();
aD1Next.Clear();
//
// NbEdges
NbEdges=0;
aExp.Init(aW, TopAbs_EDGE);
for(; aExp.More(); aExp.Next()) {
NbEdges++;
}
//
aWExp.Init(aW, Face);
for(;aWExp.More(); aWExp.Next()) {
NbEdges--;
edge = aWExp.Current();
Or = edge.Orientation();
if(!(Or==TopAbs_FORWARD || Or==TopAbs_REVERSED)) {
continue;
}
//
aC2D=BRep_Tool::CurveOnSurface(edge, Face, pfbid, plbid);
if (aC2D.IsNull()) {
return;
}
//
BRepAdaptor_Curve2d C(edge,Face);
BRepAdaptor_Curve C3d;
//------------------------------------------
degenerated=Standard_False;
if(BRep_Tool::Degenerated(edge) ||
BRep_Tool::IsClosed(edge, Face)) {
degenerated=Standard_True;
}
//
TopExp::Vertices(edge,Va,Vb);
//
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;
}
//
//-- Verification of cases when forgotten to code degenereted
if(!degenerated) {
// check that whole curve is located in vicinity of its middle point
// (within sphere of Precision::Confusion() diameter)
C3d.Initialize (edge, Face);
gp_Pnt P3da = C3d.Value (0.5 * (pfbid + plbid));
du = plbid - pfbid;
const int NBSTEPS = 10;
Standard_Real aPrec2 = 0.25 * Precision::Confusion() * Precision::Confusion();
degenerated = Standard_True;
for (Standard_Integer i=0; i <= NBSTEPS; i++)
{
Standard_Real u = pfbid + i * du / NBSTEPS;
gp_Pnt P3db = C3d.Value (u);
Standard_Real aR2 = P3da.SquareDistance (P3db);
if (aR2 > aPrec2) {
degenerated = Standard_False;
break;
}
}
}//if(!degenerated)
//-- ----------------------------------------
Tole = BRep_Tool::Tolerance(edge);
if(Tole>Tol) {
Tol=Tole;
}
//
// NbSamples +> nbs
nbs = Geom2dInt_Geom2dCurveTool::NbSamples(C);
if (nbs > 2) {
nbs*=4;
}
du = (plbid-pfbid)/(Standard_Real)(nbs-1);
//
if(Or==TopAbs_FORWARD) {
u = pfbid;
uFirst=pfbid;
uLast=plbid;
}
else {
u = plbid;
uFirst=plbid;
uLast=pfbid;
du=-du;
}
//
// aPrms
aNbs1=nbs+1;
TColStd_Array1OfReal aPrms(1, aNbs1);
//
if (nbs==2) {
Standard_Real aCoef=0.0025;
aPrms(1)=uFirst;
aPrms(2)=uFirst+aCoef*(uLast-uFirst);
aPrms(3)=uLast;
}
else if (nbs>2) {
aNbs1=nbs;
aPrms(1)=uFirst;
for (iX=2; iX<aNbs1; ++iX) {
aPrms(iX)=u+(iX-1)*du;
}
aPrms(aNbs1)=uLast;
}
//
//-- ------------------------------------------------------------
//-- Check distance uv between the start point of the edge
//-- and the last point saved in SeqPnt2d
//-- To to set the first point of the current
//-- afar from the last saved point
Avant = nbpnts;
for(iX=firstpoint; iX<=aNbs1; iX++) {
Standard_Boolean IsRealCurve3d;
Standard_Integer ii;
Standard_Real aDstX;
gp_Pnt2d P2d;
gp_Pnt P3d;
//
u=aPrms(iX);
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();
//
aDstX=RealLast();
if(degenerated==Standard_False) {
P3d=C3d.Value(u);
if(nbpnts>1) {
if(Ancienpnt3dinitialise) {
aDstX=P3d.SquareDistance(Ancienpnt3d);
}
}
}
//
IsRealCurve3d = Standard_True;
if (aDstX < aPrCf2) {
if(iX>1) {
Standard_Real aDstX1;
gp_Pnt MidP3d;
//
MidP3d = C3d.Value(0.5*(u+aPrms(iX-1)));
aDstX1=P3d.SquareDistance( MidP3d );
if (aDstX1 < aPrCf2){
IsRealCurve3d = Standard_False;
}
}
}
//
if (IsRealCurve3d) {
if(degenerated==Standard_False) {
Ancienpnt3d=P3d;
Ancienpnt3dinitialise=Standard_True;
}
nbpnts++;
SeqPnt2d.Append(P2d);
}
//
ii=nbpnts;
if(ii>(Avant+4)) {
Standard_Real ul, dU, dV;
gp_Pnt2d Pp;
//
gp_Lin2d Lin(SeqPnt2d(ii-2),gp_Dir2d(gp_Vec2d(SeqPnt2d(ii-2),SeqPnt2d(ii))));
ul = ElCLib::Parameter(Lin,SeqPnt2d(ii-1));
Pp = ElCLib::Value(ul,Lin);
dU = Abs(Pp.X()-SeqPnt2d(ii-1).X());
dV = Abs(Pp.Y()-SeqPnt2d(ii-1).Y());
if(dU>FlecheU) {
FlecheU = dU;
}
if(dV>FlecheV) {
FlecheV = dV;
}
}
}// for(iX=firstpoint; iX<=aNbs1; iX++) {
//
if(BadWire) {
continue; //if face has several wires and one of them is bad,
//it is necessary to process all of them for correct
//calculation of Umin, Umax, Vmin, Vmax - ifv, 23.08.06
}
//
if(firstpoint==1) firstpoint=2;
WireIsNotEmpty = Standard_True;
// Append the derivative of the first parameter.
Standard_Real aU = aPrms(1);
gp_Pnt2d aP;
gp_Vec2d aV;
C.D1(aU, aP, aV);
if(Or == TopAbs_REVERSED)
aV.Reverse();
aD1Next.Append(aV);
// Append the derivative of the last parameter.
aU = aPrms(aNbs1);
C.D1(aU, aP, aV);
if(Or == TopAbs_REVERSED)
aV.Reverse();
if (NbEdges > 0)
aD1Prev.Append(aV);
else
aD1Prev.Prepend(aV);
// Fill the map anIndexMap.
if (Avant > 0)
anIndexMap.Bind(Avant, aD1Next.Length());
else
anIndexMap.Bind(1, aD1Next.Length());
} //for(;aWExp.More(); aWExp.Next()) {
// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
//
if(NbEdges) {
//-- count ++ with normal explorer and -- with Wire Explorer
TColgp_Array1OfPnt2d PClass(1,2);
gp_Pnt2d anInitPnt(0., 0.);
//
PClass.Init(anInitPnt);
TabClass.Append((void *)new CSLib_Class2d(PClass,FlecheU,FlecheV,Umin,Vmin,Umax,Vmax));
BadWire=1;
TabOrien.Append(-1);
}
//
else if(WireIsNotEmpty) {
TColgp_Array1OfPnt2d PClass(1,nbpnts);
gp_Pnt2d anInitPnt(0., 0.);
//
PClass.Init(anInitPnt);
if(nbpnts>3) {
Standard_Integer im2=nbpnts-2;
Standard_Integer im1=nbpnts-1;
Standard_Integer im0=1;
Standard_Integer ii;
Standard_Real angle = 0.0;
Standard_Real aX0, aY0, aX1, aY1, aS;
//
aS=0.;
//
Standard_Integer iFlag=1;
PClass(im2)=SeqPnt2d.Value(im2);
PClass(im1)=SeqPnt2d.Value(im1);
PClass(nbpnts)=SeqPnt2d.Value(nbpnts);
for(ii=1; ii<nbpnts; ii++,im0++,im1++,im2++) {
if(im2>=nbpnts) im2=1;
if(im1>=nbpnts) im1=1;
PClass(ii)=SeqPnt2d.Value(ii);
//
const gp_Pnt2d& aP2D1=PClass(im1);
const gp_Pnt2d& aP2D0=PClass(im0);
//aP2D0 is next to aP2D1
aP2D0.Coord(aX0, aY0);
aP2D1.Coord(aX1, aY1);
aS=aS+(aY0+aY1)*(aX1-aX0);
gp_Vec2d A(PClass(im2),PClass(im1));
gp_Vec2d B(PClass(im1),PClass(im0));
Standard_Real N = A.Magnitude() * B.Magnitude();
if(N>1e-16) {
Standard_Real a=A.Angle(B);
//
if (anIndexMap.IsBound(im1)) {
Standard_Integer anInd = anIndexMap.Find(im1);
const gp_Vec2d &aVPrev = aD1Prev.Value(anInd);
const gp_Vec2d &aVNext = aD1Next.Value(anInd);
Standard_Real aN = aVPrev.Magnitude() * aVNext.Magnitude();
if(aN > 1e-16) {
Standard_Real aDerivAngle = aVPrev.Angle(aVNext);
//ifv 23.08.06
if(Abs(aDerivAngle) <= Precision::Angular()) aDerivAngle = 0.;
//ifv 23.08.06 : if edges continuity > G1, |aDerivAngle| ~0,
//but can has wrong sign and causes condition aDerivAngle * a < 0.
//that is wrong in such situation
if (iFlag && aDerivAngle * a < 0.) {
iFlag=0;
// Bad case.
angle = 0.;
}
}
}
angle+=a;
}
}//for(ii=1; ii<nbpnts; ii++,im0++,im1++,im2++) {
if (!iFlag) {
angle = 0.;
}
if(aS>0.){
myIsHole=Standard_False;
}
//
if(FlecheU<Toluv)
FlecheU = Toluv;
if(FlecheV<Toluv)
FlecheV = Toluv;
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);
}
else {
TabOrien.Append((angle>0.0)? 1 : 0);
}
}
else {
BadWire=1;
TabOrien.Append(-1);
TColgp_Array1OfPnt2d PPClass(1,2);
PPClass.Init(anInitPnt);
TabClass.Append((void *)new CSLib_Class2d(PPClass,FlecheU,FlecheV,Umin,Vmin,Umax,Vmax));
}
}// else if(WireIsNotEmpty)
} // for(; aExpF.More(); aExpF.Next()) {
//
Standard_Integer nbtabclass = TabClass.Length();
//
if(nbtabclass>0) {
//-- if an error on a wire was detected : all TabOrien set 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 = Umin-uuu*0.5;
U2 = 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 = Vmin-uuu*0.5;
V2 = V1+M_PI+M_PI;
}
else {
V1=V2=0.0;
}
}
}
//=======================================================================
//function : PerformInfinitePoint
//purpose :
//=======================================================================
TopAbs_State IntTools_FClass2d::PerformInfinitePoint() const
{
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));
}
//=======================================================================
//function : Perform
//purpose :
//=======================================================================
TopAbs_State IntTools_FClass2d::Perform(const gp_Pnt2d& _Puv,
const Standard_Boolean RecadreOnPeriodic) const
{
Standard_Integer nbtabclass = TabClass.Length();
if (nbtabclass == 0)
{
return TopAbs_IN;
}
//-- U1 is the First Param and U2 is in this case U1+Period
Standard_Real u = _Puv.X();
Standard_Real v = _Puv.Y();
Standard_Real uu = u;
Standard_Real vv = v;
TopAbs_State Status = TopAbs_UNKNOWN;
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;
Standard_Boolean urecadre, vrecadre, bUseClassifier;
Standard_Integer dedans = 1;
//
urecadre = Standard_False;
vrecadre = Standard_False;
//
if (RecadreOnPeriodic) {
Standard_Real du, dv;
if (IsUPer) {
IntTools_Tools::AdjustPeriodic(uu, Umin, Umax, uperiod, uu, du);
}// if (IsUPer) {
//
if (IsVPer) {
IntTools_Tools::AdjustPeriodic(vv, Vmin, Vmax, vperiod, vv, dv);
}//if (IsVPer) {
}
//
for(;;) {
dedans = 1;
gp_Pnt2d Puv(u,v);
bUseClassifier = (TabOrien(1) == -1);
if(!bUseClassifier) {
Standard_Integer n, cur, TabOrien_n ;
for(n=1; n<=nbtabclass; n++) {
cur = ((CSLib_Class2d *)TabClass(n))->SiDans(Puv);
TabOrien_n=TabOrien(n);
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;
}
} // for(n=1; n<=nbtabclass; n++)
if(dedans==0) {
bUseClassifier = Standard_True;
}
else {
Status = (dedans == 1) ? TopAbs_IN : TopAbs_OUT;
}
} // if(TabOrien(1)!=-1) {
//compute state of the point using face classifier
if (bUseClassifier) {
//compute tolerance to use in face classifier
Standard_Real aURes, aVRes, aFCTol;
Standard_Boolean bUIn, bVIn;
//
aURes = surf->UResolution(Toluv);
aVRes = surf->VResolution(Toluv);
//
bUIn = (u >= Umin) && (u <= Umax);
bVIn = (v >= Vmin) && (v <= Vmax);
//
aFCTol = (bUIn==bVIn) ? Max(aURes, aVRes) :
(!bUIn ? aURes : aVRes);
//
BRepClass_FaceClassifier aClassifier;
aClassifier.Perform(Face,Puv,aFCTol);
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;
}
}
} //while (1)
}
//=======================================================================
//function : TestOnRestriction
//purpose :
//=======================================================================
TopAbs_State IntTools_FClass2d::TestOnRestriction(const gp_Pnt2d& _Puv,
const Standard_Real Tol,
const Standard_Boolean RecadreOnPeriodic) const
{
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;
Standard_Integer dedans = 1;
if (RecadreOnPeriodic) {
Standard_Real du, dv;
if (IsUPer) {
IntTools_Tools::AdjustPeriodic(uu, Umin, Umax, uperiod, uu, du);
}// if (IsUPer) {
//
if (IsVPer) {
IntTools_Tools::AdjustPeriodic(vv, Vmin, Vmax, vperiod, vv, dv);
}//if (IsVPer) {
}
//
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 Wrong 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 (;;)
}
//=======================================================================
//function : Destroy
//purpose :
//=======================================================================
void IntTools_FClass2d::Destroy()
{
Standard_Integer nbtabclass = TabClass.Length();
for(Standard_Integer d=1; d<=nbtabclass;d++) {
if(TabClass(d)) {
delete ((CSLib_Class2d *)TabClass(d));
TabClass(d)=NULL;
}
}
}
View Git Blame Copy Permalink