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

0024981: IntTools_FaceFace enters to infinite loop on the attached case

Browse Source 
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
This commit is contained in:
emv 2014-06-11 10:41:15 +04:00 committed by apn
parent a4e383e1b8
commit 655fddc854
9 changed files with 2464 additions and 2536 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

62
src/BOPTools/BOPTools_AlgoTools2D.cxx
View File

@ -70,6 +70,7 @@
#include <BOPCol_IndexedMapOfShape.hxx>
#include <BOPTools.hxx>
#include <IntTools_Tools.hxx>
static
Standard_Boolean CheckEdgeLength (const TopoDS_Edge& );
@ -296,10 +297,9 @@ void BOPTools_AlgoTools2D::AdjustPCurveOnFace
const Handle(Geom2d_Curve)& aC2D,
Handle(Geom2d_Curve)& aC2DA)
{
Standard_Boolean mincond, maxcond, decalu, decalv;
Standard_Integer k, iCnt;
Standard_Boolean mincond, maxcond;
Standard_Real UMin, UMax, VMin, VMax, aT, u2, v2, du, dv, aDelta;
Standard_Real aUPeriod, aUP2, aUP1, aUNew, aDif, aUx;
Standard_Real aUPeriod;
//
aDelta=Precision::PConfusion();
@ -317,65 +317,24 @@ void BOPTools_AlgoTools2D::AdjustPCurveOnFace
du = 0.;
if (aBAS.IsUPeriodic()) {
aUPeriod=aBAS.UPeriod();
mincond = (u2 < UMin-aDelta);
maxcond = (u2 > UMax+aDelta);
decalu = mincond || maxcond;
if (decalu) {
//du = ( mincond ) ? UPeriod : -UPeriod;
//
iCnt=1;
aUP2=aUPeriod+aUPeriod+aDelta;
aUP1=aUPeriod+aDelta;
//
if (u2 > aUP2) {
k=1;
do {
aUx=u2-k*aUPeriod;
iCnt = k++;
} while (aUx >= aUP1);
}
else if (u2 < -aUP2) {
k=1;
do {
aUx=u2+k*aUPeriod;
iCnt = (k++) + 1;
} while (aUx <= -aUP1);
}
du = ( mincond ) ? aUPeriod : -aUPeriod;
du=iCnt*du;
}
Standard_Real newu;
aUPeriod = aBAS.UPeriod();
//
aUNew=u2+du;
if (aUNew<(UMin-aDelta) ||
aUNew>(UMax+aDelta)) {
// So previous correction was wrong.
// Try to be closer to UMin or UMax.
du=0.;
if (u2>UMax){
aDif=u2-UMax;
if (aDif < 4.e-7) {
du=-aDif;
}
}
}
} // if (BAHS->IsUPeriodic())
//
IntTools_Tools::AdjustPeriodic(u2, UMin, UMax, aUPeriod, newu, du);
}
// dv
dv = 0.;
if (aBAS.IsVPeriodic()) {
Standard_Real aVPeriod, aVm, aVr, aVmid, dVm, dVr;
//
aVPeriod=aBAS.VPeriod();
aVPeriod = aBAS.VPeriod();
mincond = (VMin - v2 > aDelta);
maxcond = (v2 - VMax > aDelta);
decalv = mincond || maxcond;
if (decalv) {
//
if (mincond || maxcond) {
dv = ( mincond ) ? aVPeriod : -aVPeriod;
}
//
//xf
if ((VMax-VMin<aVPeriod) && dv) {
aVm=v2;
aVr=v2+dv;
@ -386,7 +345,6 @@ void BOPTools_AlgoTools2D::AdjustPCurveOnFace
dv=0.;
}
}
//xt
}
//
{

67
src/IntTools/IntTools_BeanFaceIntersector.cxx
View File

@ -58,12 +58,6 @@
#include <ElCLib.hxx>
#include <ElSLib.hxx>
static Standard_Boolean AdjustPeriodic(const Standard_Real U,
const Standard_Real UFirst,
const Standard_Real ULast,
const Standard_Real Period,
Standard_Real& UResult);
static Standard_Boolean SetEmptyResultRange(const Standard_Real theParameter,
IntTools_MarkedRangeSet& theMarkedRange);
@ -645,37 +639,39 @@ void IntTools_BeanFaceIntersector::ComputeAroundExactIntersection()
Standard_Real V = aPoint.V();
if(UIsNotValid || VIsNotValid) {
// modified by NIZHNY-MKK Thu Jun 17 12:50:39 2004
Standard_Boolean bUCorrected = Standard_True;
if(UIsNotValid) {
// modified by NIZHNY-MKK Thu Jun 17 12:50:37 2004
bUCorrected = Standard_False;
solutionIsValid = Standard_False;
//
if(mySurface.IsUPeriodic()) {
Standard_Real aNewU = U;
if(AdjustPeriodic(U, myUMinParameter, myUMaxParameter, mySurface.UPeriod(), aNewU)) {
solutionIsValid = Standard_True;
// modified by NIZHNY-MKK Thu Jun 17 12:51:01 2004
bUCorrected = Standard_True;
U = aNewU;
}
Standard_Real aNewU, aUPeriod, aEps, du;
//
aUPeriod = mySurface.UPeriod();
aEps = Epsilon(aUPeriod);
//
IntTools_Tools::AdjustPeriodic(U, myUMinParameter, myUMaxParameter,
aUPeriod, aNewU, du, aEps);
solutionIsValid = Standard_True;
bUCorrected = Standard_True;
U = aNewU;
}
}
// modified by NIZHNY-MKK Thu Jun 17 12:51:03 2004
// if(solutionIsValid && VIsNotValid) {
if(bUCorrected && VIsNotValid) {
solutionIsValid = Standard_False;
//
if(mySurface.IsVPeriodic()) {
Standard_Real aNewV = V;
if(AdjustPeriodic(V, myVMinParameter, myVMaxParameter, mySurface.VPeriod(), aNewV)) {
solutionIsValid = Standard_True;
V = aNewV;
}
Standard_Real aNewV, aVPeriod, aEps, dv;
//
aVPeriod = mySurface.VPeriod();
aEps = Epsilon(aVPeriod);
//
IntTools_Tools::AdjustPeriodic(V, myVMinParameter, myVMaxParameter,
aVPeriod, aNewV, dv, aEps);
solutionIsValid = Standard_True;
V = aNewV;
}
}
}
@ -1388,27 +1384,6 @@ void IntTools_BeanFaceIntersector::ComputeRangeFromStartPoint(const Standard_Boo
}
}
// ---------------------------------------------------------------------------------
// static function: AdjustPeriodic
// purpose:
// ---------------------------------------------------------------------------------
static Standard_Boolean AdjustPeriodic(const Standard_Real U,
const Standard_Real UFirst,
const Standard_Real ULast,
const Standard_Real Period,
Standard_Real& UResult) {
UResult = U;
Standard_Real u = U;
Standard_Real Eps = Epsilon(Period);
while (Eps < (UFirst-u)) u += Period;
while (Eps > (ULast -u)) u -= Period;
if ( u < UFirst)
return Standard_False;
UResult = u;
return Standard_True;
}
// ---------------------------------------------------------------------------------
// static function: SetEmptyResultRange
// purpose:

508
src/IntTools/IntTools_FClass2d.cxx
View File

@ -44,6 +44,7 @@
#include <TopoDS_Wire.hxx>
#include <TColStd_DataMapOfIntegerInteger.hxx>
#include <TColgp_SequenceOfVec2d.hxx>
#include <IntTools_Tools.hxx>
//=======================================================================
//function : IntTools_FClass2d:IntTools:_FClass2d
@ -57,7 +58,7 @@ IntTools_FClass2d::IntTools_FClass2d()
//purpose :
//=======================================================================
IntTools_FClass2d::IntTools_FClass2d(const TopoDS_Face& aFace,
const Standard_Real TolUV)
const Standard_Real TolUV)
: Toluv(TolUV), Face(aFace)
{
Init(Face, Toluv);
@ -75,7 +76,7 @@ IntTools_FClass2d::IntTools_FClass2d()
//purpose :
//=======================================================================
void IntTools_FClass2d::Init(const TopoDS_Face& aFace,
const Standard_Real TolUV)
const Standard_Real TolUV)
{
Standard_Boolean WireIsNotEmpty, Ancienpnt3dinitialise, degenerated;
Standard_Integer nbpnts, firstpoint, NbEdges;
@ -149,12 +150,12 @@ IntTools_FClass2d::IntTools_FClass2d()
edge = aWExp.Current();
Or = edge.Orientation();
if(!(Or==TopAbs_FORWARD || Or==TopAbs_REVERSED)) {
continue;
continue;
}
//
aC2D=BRep_Tool::CurveOnSurface(edge, Face, pfbid, plbid);
if (aC2D.IsNull()) {
return;
return;
}
//
BRepAdaptor_Curve2d C(edge,Face);
@ -162,8 +163,8 @@ IntTools_FClass2d::IntTools_FClass2d()
//------------------------------------------
degenerated=Standard_False;
if(BRep_Tool::Degenerated(edge) ||
BRep_Tool::IsClosed(edge, Face)) {
degenerated=Standard_True;
BRep_Tool::IsClosed(edge, Face)) {
degenerated=Standard_True;
}
//
TopExp::Vertices(edge,Va,Vb);
@ -171,21 +172,21 @@ IntTools_FClass2d::IntTools_FClass2d()
TolVertex1=0.;
TolVertex=0.;
if (Va.IsNull()) {
degenerated=Standard_True;
}
degenerated=Standard_True;
}
else {
TolVertex1=BRep_Tool::Tolerance(Va);
TolVertex1=BRep_Tool::Tolerance(Va);
}
if (Vb.IsNull()){
degenerated=Standard_True;
}
degenerated=Standard_True;
}
else {
TolVertex=BRep_Tool::Tolerance(Vb);
TolVertex=BRep_Tool::Tolerance(Vb);
}
//
//
if(TolVertex<TolVertex1) {
TolVertex=TolVertex1;
}
TolVertex=TolVertex1;
}
//
//-- Verification of cases when forgotten to code degenereted
if(!degenerated) {
@ -211,26 +212,26 @@ IntTools_FClass2d::IntTools_FClass2d()
//-- ----------------------------------------
Tole = BRep_Tool::Tolerance(edge);
if(Tole>Tol) {
Tol=Tole;
Tol=Tole;
}
//
// NbSamples +> nbs
nbs = Geom2dInt_Geom2dCurveTool::NbSamples(C);
if (nbs > 2) {
nbs*=4;
nbs*=4;
}
du = (plbid-pfbid)/(Standard_Real)(nbs-1);
//
if(Or==TopAbs_FORWARD) {
u = pfbid;
uFirst=pfbid;
uLast=plbid;
u = pfbid;
uFirst=pfbid;
uLast=plbid;
}
else {
u = plbid;
uFirst=plbid;
uLast=pfbid;
du=-du;
u = plbid;
uFirst=plbid;
uLast=pfbid;
du=-du;
}
//
// aPrms
@ -238,18 +239,18 @@ IntTools_FClass2d::IntTools_FClass2d()
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;
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;
aNbs1=nbs;
aPrms(1)=uFirst;
for (iX=2; iX<aNbs1; ++iX) {
aPrms(iX)=u+(iX-1)*du;
}
aPrms(aNbs1)=uLast;
}
//
//-- ------------------------------------------------------------
@ -259,75 +260,75 @@ IntTools_FClass2d::IntTools_FClass2d()
//-- 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;
}
}
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
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;
@ -340,7 +341,7 @@ IntTools_FClass2d::IntTools_FClass2d()
C.D1(aU, aP, aV);
if(Or == TopAbs_REVERSED)
aV.Reverse();
aV.Reverse();
aD1Next.Append(aV);
@ -349,18 +350,18 @@ IntTools_FClass2d::IntTools_FClass2d()
C.D1(aU, aP, aV);
if(Or == TopAbs_REVERSED)
aV.Reverse();
aV.Reverse();
if (NbEdges > 0)
aD1Prev.Append(aV);
aD1Prev.Append(aV);
else
aD1Prev.Prepend(aV);
aD1Prev.Prepend(aV);
// Fill the map anIndexMap.
if (Avant > 0)
anIndexMap.Bind(Avant, aD1Next.Length());
anIndexMap.Bind(Avant, aD1Next.Length());
else
anIndexMap.Bind(1, aD1Next.Length());
anIndexMap.Bind(1, aD1Next.Length());
} //for(;aWExp.More(); aWExp.Next()) {
// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
//
@ -381,91 +382,91 @@ IntTools_FClass2d::IntTools_FClass2d()
//
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 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);
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));
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 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;
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;
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);
}
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));
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()) {
@ -551,31 +552,13 @@ IntTools_FClass2d::IntTools_FClass2d()
vrecadre = Standard_False;
//
if (RecadreOnPeriodic) {
Standard_Real du, dv;
if (IsUPer) {
if (uu < Umin)
while (uu < Umin) {
uu += uperiod;
}
else {
while (uu >= Umin){
uu -= uperiod;
}
uu += uperiod;
}
IntTools_Tools::AdjustPeriodic(uu, Umin, Umax, uperiod, uu, du);
}// if (IsUPer) {
//
if (IsVPer) {
if (vv < Vmin)
while (vv < Vmin){
vv += vperiod;
}
else {
while (vv >= Vmin) {
vv -= vperiod;
}
vv += vperiod;
}
IntTools_Tools::AdjustPeriodic(vv, Vmin, Vmax, vperiod, vv, dv);
}//if (IsVPer) {
}
//
@ -675,8 +658,8 @@ IntTools_FClass2d::IntTools_FClass2d()
//purpose :
//=======================================================================
TopAbs_State IntTools_FClass2d::TestOnRestriction(const gp_Pnt2d& _Puv,
const Standard_Real Tol,
const Standard_Boolean RecadreOnPeriodic) const
const Standard_Real Tol,
const Standard_Boolean RecadreOnPeriodic) const
{
Standard_Integer nbtabclass = TabClass.Length();
if (nbtabclass == 0)
@ -699,66 +682,49 @@ IntTools_FClass2d::IntTools_FClass2d()
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;
}
}
}
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;
}
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;
Status = TopAbs_ON;
}
if(dedans == 1) {
Status = TopAbs_IN;
Status = TopAbs_IN;
}
if(dedans == -1) {
Status = TopAbs_OUT;
Status = TopAbs_OUT;
}
}
else { //-- TabOrien(1)=-1 Wrong Wire
@ -774,27 +740,27 @@ IntTools_FClass2d::IntTools_FClass2d()
if (!urecadre)
{
u = uu;
urecadre = Standard_True;
u = uu;
urecadre = Standard_True;
}
else
if (IsUPer)
u += uperiod;
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;
if (!vrecadre)
{
v = vv;
vrecadre = Standard_True;
}
else
if (IsVPer)
v += vperiod;
u = uu;
if (v > Vmax || !IsVPer)
return Status;
}
} //for (;;)
}

3797
src/IntTools/IntTools_FaceFace.cxx
View File

File diff suppressed because it is too large Load Diff

489
src/IntTools/IntTools_LineConstructor.cxx
View File

@ -41,33 +41,34 @@
#include <ElCLib.hxx>
#include <GeomAbs_SurfaceType.hxx>
#include <TColStd_IndexedMapOfInteger.hxx>
#include <IntTools_Tools.hxx>
static
void Parameters(const Handle(GeomAdaptor_HSurface)& myHS1,
const gp_Pnt& Ptref,
Standard_Real& U1,
Standard_Real& V1);
const gp_Pnt& Ptref,
Standard_Real& U1,
Standard_Real& V1);
static
void Parameters(const Handle(GeomAdaptor_HSurface)& myHS1,
const Handle(GeomAdaptor_HSurface)& myHS2,
const gp_Pnt& Ptref,
Standard_Real& U1,
Standard_Real& V1,
Standard_Real& U2,
Standard_Real& V2);
const Handle(GeomAdaptor_HSurface)& myHS2,
const gp_Pnt& Ptref,
Standard_Real& U1,
Standard_Real& V1,
Standard_Real& U2,
Standard_Real& V2);
static
void GLinePoint(const IntPatch_IType typl,
const Handle(IntPatch_GLine)& GLine,
const Standard_Real aT,
gp_Pnt& aP);
const Handle(IntPatch_GLine)& GLine,
const Standard_Real aT,
gp_Pnt& aP);
static
void Recadre(const Handle(GeomAdaptor_HSurface)& myHS1,
const Handle(GeomAdaptor_HSurface)& myHS2,
Standard_Real& u1,
Standard_Real& v1,
Standard_Real& u2,
Standard_Real& v2);
const Handle(GeomAdaptor_HSurface)& myHS2,
Standard_Real& u1,
Standard_Real& v1,
Standard_Real& u2,
Standard_Real& v2);
//=======================================================================
//function : Perform
@ -89,18 +90,18 @@ void IntTools_LineConstructor::Perform(const Handle(IntPatch_Line)& L)
firstp = GeomInt_LineTool::Vertex(L,i).ParameterOnLine();
lastp = GeomInt_LineTool::Vertex(L,i+1).ParameterOnLine();
if(firstp!=lastp) {
const Standard_Real pmid = (firstp+lastp)*0.5;
const gp_Pnt Pmid = ALine->Value(pmid);
Parameters(myHS1,myHS2,Pmid,u1,v1,u2,v2);
Recadre(myHS1,myHS2,u1,v1,u2,v2);
const TopAbs_State in1 = myDom1->Classify(gp_Pnt2d(u1,v1),Tol);
if(in1 != TopAbs_OUT) {
const TopAbs_State in2 = myDom2->Classify(gp_Pnt2d(u2,v2),Tol);
if(in2 != TopAbs_OUT) {
seqp.Append(firstp);
seqp.Append(lastp);
}
}
const Standard_Real pmid = (firstp+lastp)*0.5;
const gp_Pnt Pmid = ALine->Value(pmid);
Parameters(myHS1,myHS2,Pmid,u1,v1,u2,v2);
Recadre(myHS1,myHS2,u1,v1,u2,v2);
const TopAbs_State in1 = myDom1->Classify(gp_Pnt2d(u1,v1),Tol);
if(in1 != TopAbs_OUT) {
const TopAbs_State in2 = myDom2->Classify(gp_Pnt2d(u2,v2),Tol);
if(in2 != TopAbs_OUT) {
seqp.Append(firstp);
seqp.Append(lastp);
}
}
}
}
done = Standard_True;
@ -115,42 +116,42 @@ void IntTools_LineConstructor::Perform(const Handle(IntPatch_Line)& L)
firstp = GeomInt_LineTool::Vertex(L,i).ParameterOnLine();
lastp = GeomInt_LineTool::Vertex(L,i+1).ParameterOnLine();
if(firstp!=lastp) {
if(lastp != firstp+1) {
const Standard_Integer pmid = (Standard_Integer )( (firstp+lastp)/2);
const IntSurf_PntOn2S& Pmid = WLine->Point(pmid);
Pmid.Parameters(u1,v1,u2,v2);
Recadre(myHS1,myHS2,u1,v1,u2,v2);
const TopAbs_State in1 = myDom1->Classify(gp_Pnt2d(u1,v1),Tol);
if(in1 != TopAbs_OUT) {
const TopAbs_State in2 = myDom2->Classify(gp_Pnt2d(u2,v2),Tol);
if(in2 != TopAbs_OUT) {
seqp.Append(firstp);
seqp.Append(lastp);
}
}
}
else {
const IntSurf_PntOn2S& Pfirst = WLine->Point((Standard_Integer)(firstp));
Pfirst.Parameters(u1,v1,u2,v2);
Recadre(myHS1,myHS2,u1,v1,u2,v2);
TopAbs_State in1 = myDom1->Classify(gp_Pnt2d(u1,v1),Tol);
if(in1 != TopAbs_OUT) { //-- !=ON donne Pb
TopAbs_State in2 = myDom2->Classify(gp_Pnt2d(u2,v2),Tol);
if(in2 != TopAbs_OUT) { //-- !=ON
const IntSurf_PntOn2S& Plast = WLine->Point((Standard_Integer)(lastp));
Plast.Parameters(u1,v1,u2,v2);
Recadre(myHS1,myHS2,u1,v1,u2,v2);
in1 = myDom1->Classify(gp_Pnt2d(u1,v1),Tol);
if(in1 != TopAbs_OUT) { //-- !=ON donne Pb
in2 = myDom2->Classify(gp_Pnt2d(u2,v2),Tol);
if(in2 != TopAbs_OUT) {
seqp.Append(firstp);
seqp.Append(lastp);
}
}
}
}
}
if(lastp != firstp+1) {
const Standard_Integer pmid = (Standard_Integer )( (firstp+lastp)/2);
const IntSurf_PntOn2S& Pmid = WLine->Point(pmid);
Pmid.Parameters(u1,v1,u2,v2);
Recadre(myHS1,myHS2,u1,v1,u2,v2);
const TopAbs_State in1 = myDom1->Classify(gp_Pnt2d(u1,v1),Tol);
if(in1 != TopAbs_OUT) {
const TopAbs_State in2 = myDom2->Classify(gp_Pnt2d(u2,v2),Tol);
if(in2 != TopAbs_OUT) {
seqp.Append(firstp);
seqp.Append(lastp);
}
}
}
else {
const IntSurf_PntOn2S& Pfirst = WLine->Point((Standard_Integer)(firstp));
Pfirst.Parameters(u1,v1,u2,v2);
Recadre(myHS1,myHS2,u1,v1,u2,v2);
TopAbs_State in1 = myDom1->Classify(gp_Pnt2d(u1,v1),Tol);
if(in1 != TopAbs_OUT) { //-- !=ON donne Pb
TopAbs_State in2 = myDom2->Classify(gp_Pnt2d(u2,v2),Tol);
if(in2 != TopAbs_OUT) { //-- !=ON
const IntSurf_PntOn2S& Plast = WLine->Point((Standard_Integer)(lastp));
Plast.Parameters(u1,v1,u2,v2);
Recadre(myHS1,myHS2,u1,v1,u2,v2);
in1 = myDom1->Classify(gp_Pnt2d(u1,v1),Tol);
if(in1 != TopAbs_OUT) { //-- !=ON donne Pb
in2 = myDom2->Classify(gp_Pnt2d(u2,v2),Tol);
if(in2 != TopAbs_OUT) {
seqp.Append(firstp);
seqp.Append(lastp);
}
}
}
}
}
}
}
//
@ -173,47 +174,47 @@ void IntTools_LineConstructor::Perform(const Handle(IntPatch_Line)& L)
//
bCond=Standard_False;
if (aST1==GeomAbs_Plane) {
if (aST2==GeomAbs_SurfaceOfExtrusion ||
aST2==GeomAbs_SurfaceOfRevolution) {//+zft
bCond=!bCond;
}
if (aST2==GeomAbs_SurfaceOfExtrusion ||
aST2==GeomAbs_SurfaceOfRevolution) {//+zft
bCond=!bCond;
}
}
else if (aST2==GeomAbs_Plane) {
if (aST1==GeomAbs_SurfaceOfExtrusion ||
aST1==GeomAbs_SurfaceOfRevolution) {//+zft
bCond=!bCond;
}
if (aST1==GeomAbs_SurfaceOfExtrusion ||
aST1==GeomAbs_SurfaceOfRevolution) {//+zft
bCond=!bCond;
}
}
//
if (bCond) {
Standard_Integer aNb, anIndex, aNbTmp, jx;
TColStd_IndexedMapOfInteger aMap;
TColStd_SequenceOfReal aSeqTmp;
//
aNb=seqp.Length();
for(i=1; i<=aNb; ++i) {
lastp =seqp(i);
anIndex=(Standard_Integer)lastp;
if (!aMap.Contains(anIndex)){
aMap.Add(anIndex);
aSeqTmp.Append(lastp);
}
else {
aNbTmp=aSeqTmp.Length();
aSeqTmp.Remove(aNbTmp);
}
}
//
seqp.Clear();
//
aNb=aSeqTmp.Length()/2;
for(i=1; i<=aNb;++i) {
jx=2*i;
firstp=aSeqTmp(jx-1);
lastp =aSeqTmp(jx);
seqp.Append(firstp);
seqp.Append(lastp);
}
Standard_Integer aNb, anIndex, aNbTmp, jx;
TColStd_IndexedMapOfInteger aMap;
TColStd_SequenceOfReal aSeqTmp;
//
aNb=seqp.Length();
for(i=1; i<=aNb; ++i) {
lastp =seqp(i);
anIndex=(Standard_Integer)lastp;
if (!aMap.Contains(anIndex)){
aMap.Add(anIndex);
aSeqTmp.Append(lastp);
}
else {
aNbTmp=aSeqTmp.Length();
aSeqTmp.Remove(aNbTmp);
}
}
//
seqp.Clear();
//
aNb=aSeqTmp.Length()/2;
for(i=1; i<=aNb;++i) {
jx=2*i;
firstp=aSeqTmp(jx-1);
lastp =aSeqTmp(jx);
seqp.Append(firstp);
seqp.Append(lastp);
}
}//if (bCond) {
}
done = Standard_True;
@ -241,21 +242,21 @@ void IntTools_LineConstructor::Perform(const Handle(IntPatch_Line)& L)
firstp = GeomInt_LineTool::Vertex(L,i).ParameterOnLine();
lastp = GeomInt_LineTool::Vertex(L,i+1).ParameterOnLine();
if(Abs(firstp-lastp)>Precision::PConfusion()) {
intrvtested = Standard_True;
const Standard_Real pmid = (firstp+lastp)*0.5;
gp_Pnt Pmid;
GLinePoint(typl, GLine, pmid, Pmid);
//
Parameters(myHS1,myHS2,Pmid,u1,v1,u2,v2);
Recadre(myHS1,myHS2,u1,v1,u2,v2);
const TopAbs_State in1 = myDom1->Classify(gp_Pnt2d(u1,v1),Tol);
if(in1 != TopAbs_OUT) {
const TopAbs_State in2 = myDom2->Classify(gp_Pnt2d(u2,v2),Tol);
if(in2 != TopAbs_OUT) {
seqp.Append(firstp);
seqp.Append(lastp);
}
}
intrvtested = Standard_True;
const Standard_Real pmid = (firstp+lastp)*0.5;
gp_Pnt Pmid;
GLinePoint(typl, GLine, pmid, Pmid);
//
Parameters(myHS1,myHS2,Pmid,u1,v1,u2,v2);
Recadre(myHS1,myHS2,u1,v1,u2,v2);
const TopAbs_State in1 = myDom1->Classify(gp_Pnt2d(u1,v1),Tol);
if(in1 != TopAbs_OUT) {
const TopAbs_State in2 = myDom2->Classify(gp_Pnt2d(u2,v2),Tol);
if(in2 != TopAbs_OUT) {
seqp.Append(firstp);
seqp.Append(lastp);
}
}
}
}
//
@ -315,38 +316,38 @@ void IntTools_LineConstructor::Perform(const Handle(IntPatch_Line)& L)
Standard_Boolean inserted = Standard_False;
for (Standard_Integer j=1; j<=nbinserted;j++) {
if (Abs(prm-seqpss(j).Parameter()) <= Tol) {
// accumulate
GeomInt_ParameterAndOrientation& valj = seqpss.ChangeValue(j);
if (or1 != TopAbs_INTERNAL) {
if (valj.Orientation1() != TopAbs_INTERNAL) {
if (or1 != valj.Orientation1()) {
valj.SetOrientation1(TopAbs_INTERNAL);
}
}
else {
valj.SetOrientation1(or1);
}
}
if (or2 != TopAbs_INTERNAL) {
if (valj.Orientation2() != TopAbs_INTERNAL) {
if (or2 != valj.Orientation2()) {
valj.SetOrientation2(TopAbs_INTERNAL);
}
}
else {
valj.SetOrientation2(or2);
}
}
inserted = Standard_True;
break;
// accumulate
GeomInt_ParameterAndOrientation& valj = seqpss.ChangeValue(j);
if (or1 != TopAbs_INTERNAL) {
if (valj.Orientation1() != TopAbs_INTERNAL) {
if (or1 != valj.Orientation1()) {
valj.SetOrientation1(TopAbs_INTERNAL);
}
}
else {
valj.SetOrientation1(or1);
}
}
if (or2 != TopAbs_INTERNAL) {
if (valj.Orientation2() != TopAbs_INTERNAL) {
if (or2 != valj.Orientation2()) {
valj.SetOrientation2(TopAbs_INTERNAL);
}
}
else {
valj.SetOrientation2(or2);
}
}
inserted = Standard_True;
break;
}
if (prm < seqpss(j).Parameter()-Tol ) {
// insert before position j
seqpss.InsertBefore(j,GeomInt_ParameterAndOrientation(prm,or1,or2));
inserted = Standard_True;
break;
// insert before position j
seqpss.InsertBefore(j,GeomInt_ParameterAndOrientation(prm,or1,or2));
inserted = Standard_True;
break;
}
}
@ -374,12 +375,12 @@ void IntTools_LineConstructor::Perform(const Handle(IntPatch_Line)& L)
Standard_Real U,V;
for (i=1; i<=GeomInt_LineTool::NbVertex(L); i++ ) {
if (!GeomInt_LineTool::Vertex(L,i).IsOnDomS1() ) {
GeomInt_LineTool::Vertex(L,i).ParametersOnS1(U,V);
gp_Pnt2d PPCC(U,V);
if (myDom1->Classify(PPCC,Tol) == TopAbs_OUT) {
done = Standard_True;
return;
}
GeomInt_LineTool::Vertex(L,i).ParametersOnS1(U,V);
gp_Pnt2d PPCC(U,V);
if (myDom1->Classify(PPCC,Tol) == TopAbs_OUT) {
done = Standard_True;
return;
}
break;
}
}
@ -399,11 +400,11 @@ void IntTools_LineConstructor::Perform(const Handle(IntPatch_Line)& L)
Standard_Real U,V;
for (i=1; i<=GeomInt_LineTool::NbVertex(L); i++ ) {
if (!GeomInt_LineTool::Vertex(L,i).IsOnDomS2() ) {
GeomInt_LineTool::Vertex(L,i).ParametersOnS2(U,V);
if (myDom2->Classify(gp_Pnt2d(U,V),Tol) == TopAbs_OUT) {
done = Standard_True;
return;
}
GeomInt_LineTool::Vertex(L,i).ParametersOnS2(U,V);
if (myDom2->Classify(gp_Pnt2d(U,V),Tol) == TopAbs_OUT) {
done = Standard_True;
return;
}
break;
}
}
@ -428,49 +429,49 @@ void IntTools_LineConstructor::Perform(const Handle(IntPatch_Line)& L)
or2 = seqpss(i).Orientation2();
if (dansS1 && dansS2) {
if (or1 == TopAbs_REVERSED){
dansS1 = Standard_False;
dansS1 = Standard_False;
}
if (or2 == TopAbs_REVERSED){
dansS2 = Standard_False;
dansS2 = Standard_False;
}
if (!dansS1 || !dansS2) {
lastp = seqpss(i).Parameter();
Standard_Real stofirst = Max(firstp, thefirst);
Standard_Real stolast = Min(lastp, thelast) ;
lastp = seqpss(i).Parameter();
Standard_Real stofirst = Max(firstp, thefirst);
Standard_Real stolast = Min(lastp, thelast) ;
if (stolast > stofirst) {
seqp.Append(stofirst);
seqp.Append(stolast);
}
if (lastp > thelast) {
break;
}
if (stolast > stofirst) {
seqp.Append(stofirst);
seqp.Append(stolast);
}
if (lastp > thelast) {
break;
}
}
}
else {
if (dansS1) {
if (or1 == TopAbs_REVERSED) {
dansS1 = Standard_False;
}
if (or1 == TopAbs_REVERSED) {
dansS1 = Standard_False;
}
}
else {
if (or1 == TopAbs_FORWARD){
dansS1 = Standard_True;
}
if (or1 == TopAbs_FORWARD){
dansS1 = Standard_True;
}
}
if (dansS2) {
if (or2 == TopAbs_REVERSED) {
dansS2 = Standard_False;
}
if (or2 == TopAbs_REVERSED) {
dansS2 = Standard_False;
}
}
else {
if (or2 == TopAbs_FORWARD){
dansS2 = Standard_True;
}
if (or2 == TopAbs_FORWARD){
dansS2 = Standard_True;
}
}
if (dansS1 && dansS2){
firstp = seqpss(i).Parameter();
firstp = seqpss(i).Parameter();
}
}
}
@ -491,11 +492,11 @@ void IntTools_LineConstructor::Perform(const Handle(IntPatch_Line)& L)
//purpose :
//=======================================================================
void Recadre(const Handle(GeomAdaptor_HSurface)& myHS1,
const Handle(GeomAdaptor_HSurface)& myHS2,
Standard_Real& u1,
Standard_Real& v1,
Standard_Real& u2,
Standard_Real& v2)
const Handle(GeomAdaptor_HSurface)& myHS2,
Standard_Real& u1,
Standard_Real& v1,
Standard_Real& u2,
Standard_Real& v2)
{
Standard_Boolean myHS1IsUPeriodic,myHS1IsVPeriodic;
const GeomAbs_SurfaceType typs1 = myHS1->GetType();
@ -545,33 +546,31 @@ void Recadre(const Handle(GeomAdaptor_HSurface)& myHS1,
break;
}
}
Standard_Real du, dv;
//
if(myHS1IsUPeriodic) {
const Standard_Real lmf = M_PI+M_PI; //-- myHS1->UPeriod();
const Standard_Real f = myHS1->FirstUParameter();
const Standard_Real l = myHS1->LastUParameter();
while(u1 < f) { u1+=lmf; }
while(u1 > l) { u1-=lmf; }
IntTools_Tools::AdjustPeriodic(u1, f, l, lmf, u1, du);
}
if(myHS1IsVPeriodic) {
const Standard_Real lmf = M_PI+M_PI; //-- myHS1->VPeriod();
const Standard_Real f = myHS1->FirstVParameter();
const Standard_Real l = myHS1->LastVParameter();
while(v1 < f) { v1+=lmf; }
while(v1 > l) { v1-=lmf; }
IntTools_Tools::AdjustPeriodic(v1, f, l, lmf, v1, dv);
}
if(myHS2IsUPeriodic) {
const Standard_Real lmf = M_PI+M_PI; //-- myHS2->UPeriod();
const Standard_Real f = myHS2->FirstUParameter();
const Standard_Real l = myHS2->LastUParameter();
while(u2 < f) { u2+=lmf; }
while(u2 > l) { u2-=lmf; }
IntTools_Tools::AdjustPeriodic(u2, f, l, lmf, u2, du);
}
if(myHS2IsVPeriodic) {
const Standard_Real lmf = M_PI+M_PI; //-- myHS2->VPeriod();
const Standard_Real f = myHS2->FirstVParameter();
const Standard_Real l = myHS2->LastVParameter();
while(v2 < f) { v2+=lmf; }
while(v2 > l) { v2-=lmf; }
IntTools_Tools::AdjustPeriodic(v2, f, l, lmf, v2, dv);
}
}
//=======================================================================
@ -579,12 +578,12 @@ void Recadre(const Handle(GeomAdaptor_HSurface)& myHS1,
//purpose :
//=======================================================================
void Parameters(const Handle(GeomAdaptor_HSurface)& myHS1,
const Handle(GeomAdaptor_HSurface)& myHS2,
const gp_Pnt& Ptref,
Standard_Real& U1,
Standard_Real& V1,
Standard_Real& U2,
Standard_Real& V2)
const Handle(GeomAdaptor_HSurface)& myHS2,
const gp_Pnt& Ptref,
Standard_Real& U1,
Standard_Real& V1,
Standard_Real& U2,
Standard_Real& V2)
{
Parameters(myHS1, Ptref, U1, V1);
Parameters(myHS2, Ptref, U2, V2);
@ -627,9 +626,9 @@ void Parameters(const Handle(GeomAdaptor_HSurface)& myHS1,
//purpose :
//=======================================================================
void GLinePoint(const IntPatch_IType typl,
const Handle(IntPatch_GLine)& GLine,
const Standard_Real aT,
gp_Pnt& aP)
const Handle(IntPatch_GLine)& GLine,
const Standard_Real aT,
gp_Pnt& aP)
{
switch (typl) {
case IntPatch_Lin:
@ -695,32 +694,32 @@ class IntTools_RealWithFlag {
//------------
static
void SortShell(const Standard_Integer,
IntTools_RealWithFlag *);
IntTools_RealWithFlag *);
static
void RejectDuplicates(Standard_Integer& aNbVtx,
IntTools_RealWithFlag *pVtx,
Standard_Real aTolPrm);
IntTools_RealWithFlag *pVtx,
Standard_Real aTolPrm);
static
void RejectNearBeacons(Standard_Integer& aNbVtx,
IntTools_RealWithFlag *pVtx,
Standard_Real aTolPC1,
const GeomAbs_SurfaceType aTS1,
const GeomAbs_SurfaceType aTS2);
IntTools_RealWithFlag *pVtx,
Standard_Real aTolPC1,
const GeomAbs_SurfaceType aTS1,
const GeomAbs_SurfaceType aTS2);
static
Standard_Real AdjustOnPeriod(const Standard_Real aTr,
const Standard_Real aPeriod);
const Standard_Real aPeriod);
static
Standard_Boolean RejectMicroCircle(const Handle(IntPatch_GLine)& aGLine,
const IntPatch_IType aType,
const Standard_Real aTol3D);
const IntPatch_IType aType,
const Standard_Real aTol3D);
//
//=======================================================================
//function : TreatCircle
//purpose :
//=======================================================================
void IntTools_LineConstructor::TreatCircle(const Handle(IntPatch_Line)& aLine,
const Standard_Real aTol)
const Standard_Real aTol)
{
Standard_Boolean bRejected;
IntPatch_IType aType;
@ -780,8 +779,8 @@ void IntTools_LineConstructor::TreatCircle(const Handle(IntPatch_Line)& aLine,
for(i=1; i<=aNbVtxWas; ++i) {
aT=GeomInt_LineTool::Vertex(aLine, i).ParameterOnLine();
if (fabs(aT) < aTolPC1 || fabs(aT-aTwoPI) < aTolPC1) {
bFound=!bFound;
break;
bFound=!bFound;
break;
}
}
if (!bFound) {
@ -789,8 +788,8 @@ void IntTools_LineConstructor::TreatCircle(const Handle(IntPatch_Line)& aLine,
pVtx[aNbVtx-1].SetValue(aT);
//
for(i=0; i<aNbVtx; ++i) {
aT=pVtx[i+1].Value();
pVtx[i].SetValue(aT);
aT=pVtx[i+1].Value();
pVtx[i].SetValue(aT);
}
--aNbVtx;
}
@ -811,8 +810,8 @@ void IntTools_LineConstructor::TreatCircle(const Handle(IntPatch_Line)& aLine,
aP2D.SetCoord(aU2, aV2);
aIn2=myDom2->Classify(aP2D, aTol);
if(aIn2 != TopAbs_OUT) {
seqp.Append(aT1);
seqp.Append(aT2);
seqp.Append(aT1);
seqp.Append(aT2);
}
}
}
@ -826,10 +825,10 @@ void IntTools_LineConstructor::TreatCircle(const Handle(IntPatch_Line)& aLine,
// chl/930/B5 B8 C2 C5 E2 E5 E8 F2 G8 H2 H5 H8
//=======================================================================
void RejectNearBeacons(Standard_Integer& aNbVtx,
IntTools_RealWithFlag *pVtx,
Standard_Real aTolPC1,
const GeomAbs_SurfaceType aTS1,
const GeomAbs_SurfaceType aTS2)
IntTools_RealWithFlag *pVtx,
Standard_Real aTolPC1,
const GeomAbs_SurfaceType aTS1,
const GeomAbs_SurfaceType aTS2)
{
Standard_Integer i, j, iBcn;
Standard_Real aT, aBcn[2];
@ -841,33 +840,33 @@ void RejectNearBeacons(Standard_Integer& aNbVtx,
for (j=0; j<2; ++j) {
iBcn=-1;
for(i=0; i<aNbVtx; ++i) {
aT=pVtx[i].Value();
if (aT==aBcn[j]) {
iBcn=i;
break;
}
aT=pVtx[i].Value();
if (aT==aBcn[j]) {
iBcn=i;
break;
}
}
//
if (iBcn<0) {
// The beacon is not found
continue;
// The beacon is not found
continue;
}
//
for(i=0; i<aNbVtx; ++i) {
if (i!=iBcn) {
aT=pVtx[i].Value();
if (fabs(aT-aBcn[j]) < aTolPC1) {
pVtx[i].SetFlag(0);
}
}
if (i!=iBcn) {
aT=pVtx[i].Value();
if (fabs(aT-aBcn[j]) < aTolPC1) {
pVtx[i].SetFlag(0);
}
}
}
}// for (j=0; j<2; ++j) {
//------------------------------------------
j=0;
for(i=0; i<aNbVtx; ++i) {
if (pVtx[i].Flag()) {
pVtx[j]=pVtx[i];
++j;
pVtx[j]=pVtx[i];
++j;
}
}
aNbVtx=j;
@ -879,8 +878,8 @@ void RejectNearBeacons(Standard_Integer& aNbVtx,
//purpose :
//=======================================================================
void RejectDuplicates(Standard_Integer& aNbVtx,
IntTools_RealWithFlag *pVtx,
Standard_Real aTolPC)
IntTools_RealWithFlag *pVtx,
Standard_Real aTolPC)
{
Standard_Integer i, j;
Standard_Real dX, aT1, aT2;
@ -908,7 +907,7 @@ void RejectDuplicates(Standard_Integer& aNbVtx,
//purpose :
//=======================================================================
Standard_Real AdjustOnPeriod(const Standard_Real aTr,
const Standard_Real aPeriod)
const Standard_Real aPeriod)
{
Standard_Integer k;
Standard_Real aT;
@ -931,8 +930,8 @@ Standard_Real AdjustOnPeriod(const Standard_Real aTr,
//purpose :
//=======================================================================
Standard_Boolean RejectMicroCircle(const Handle(IntPatch_GLine)& aGLine,
const IntPatch_IType aType,
const Standard_Real aTol3D)
const IntPatch_IType aType,
const Standard_Real aTol3D)
{
Standard_Boolean bRet;
Standard_Real aR;
@ -954,7 +953,7 @@ Standard_Boolean RejectMicroCircle(const Handle(IntPatch_GLine)& aGLine,
// purpose :
//=======================================================================
void SortShell(const Standard_Integer n,
IntTools_RealWithFlag *a)
IntTools_RealWithFlag *a)
{
Standard_Integer nd, i, j, l, d=1;
IntTools_RealWithFlag x;

10
src/IntTools/IntTools_Tools.cdl
View File

@ -237,5 +237,15 @@ is
theTmax :out Real from Standard)
returns Integer from Standard;
AdjustPeriodic(myclass;
thePar : Real from Standard;
theParMin : Real from Standard;
theParMax : Real from Standard;
thePeriod : Real from Standard;
theNewPar : out Real from Standard;
theOffset : out Real from Standard;
theEps : Real from Standard = 0.0)
returns Boolean from Standard;
---Purpose: Adjusts the parameter <thePar> to the range [theParMin, theParMax]
end Tools;

32
src/IntTools/IntTools_Tools.cxx
View File

@ -778,3 +778,35 @@ Standard_Integer IntTools_Tools::SegPln(const gp_Lin& theLin,
return iRet;
}
//=======================================================================
//function : AdjustPeriodic
//purpose :
//=======================================================================
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)
{
Standard_Boolean bMin, bMax;
//
theOffset = 0.;
theNewPar = thePar;
bMin = theParMin - thePar > theEps;
bMax = thePar - theParMax > theEps;
//
if (bMin || bMax) {
Standard_Real dp, aNbPer;
//
dp = (bMin) ? (theParMax - thePar) : (theParMin - thePar);
modf(dp / thePeriod, &aNbPer);
//
theOffset = aNbPer * thePeriod;
theNewPar += theOffset;
}
//
return (theOffset > 0.);
}

2
tests/bugs/modalg_4/bug6272_6
View File

@ -1,4 +1,4 @@
puts "TODO OCC11111 ALL: Error : The square of result shape is"
puts "TODO ?OCC11111 ALL: Error : The square of result shape is"
puts "TODO ?OCC11111 ALL: Error : Result shape is WRONG"
puts "============"

33
tests/bugs/modalg_5/bug24981 Normal file
View File

@ -0,0 +1,33 @@
puts "========="
puts "OCC24981"
puts "========="
puts ""
###########################################################
# IntTools_FaceFace enters to infinite loop on the attached case
###########################################################
restore [locate_data_file bug24981_shapes.brep] a
restore [locate_data_file bug24981_tools.brep] b
explode a So
explode b So
bclearobjects
bcleartools
baddobjects a_1
baddtools b_1 b_2 b_3 b_4 b_5 b_6 b_7 b_8 b_9 b_10 b_11 b_12 b_13 b_14 b_15 b_16 b_17 b_18 b_19 b_20 b_21 b_22 b_23 b_24 b_25
bfillds
bbuild result
set nb_v_good 122
set nb_e_good 220
set nb_w_good 243
set nb_f_good 195
set nb_sh_good 75
set nb_sol_good 75
set nb_compsol_good 0
set nb_compound_good 1
set nb_shape_good 931
set 2dviewer 1