mirror of
https://github.com/Open-Cascade-SAS/OCCT.git
synced 2026-05-16 14:30:10 +08:00
d5f74e42d6
License statement text corrected; compiler warnings caused by Bison 2.41 disabled for MSVC; a few other compiler warnings on 54-bit Windows eliminated by appropriate type cast Wrong license statements corrected in several files. Copyright and license statements added in XSD and GLSL files. Copyright year updated in some files. Obsolete documentation files removed from DrawResources.
818 lines
21 KiB
C++
818 lines
21 KiB
C++
// 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>
|
|
|
|
//=======================================================================
|
|
//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) {
|
|
|
|
if (IsUPer) {
|
|
if (uu < Umin)
|
|
while (uu < Umin) {
|
|
uu += uperiod;
|
|
}
|
|
else {
|
|
while (uu >= Umin){
|
|
uu -= uperiod;
|
|
}
|
|
uu += uperiod;
|
|
}
|
|
}// if (IsUPer) {
|
|
|
|
if (IsVPer) {
|
|
if (vv < Vmin)
|
|
while (vv < Vmin){
|
|
vv += vperiod;
|
|
}
|
|
else {
|
|
while (vv >= Vmin) {
|
|
vv -= vperiod;
|
|
}
|
|
vv += vperiod;
|
|
}
|
|
}//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)
|
|
{
|
|
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 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;
|
|
}
|
|
}
|
|
}
|
|
|
|
|