OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-04-05 18:16:23 +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

60
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;
Standard_Real newu;
aUPeriod = aBAS.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);
IntTools_Tools::AdjustPeriodic(u2, UMin, UMax, aUPeriod, newu, du);
}
else if (u2 < -aUP2) {
k=1;
do {
aUx=u2+k*aUPeriod;
iCnt = (k++) + 1;
} while (aUx <= -aUP1);
}
du = ( mincond ) ? aUPeriod : -aUPeriod;
du=iCnt*du;
}
//
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())
//
// 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
}
//
{

57
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,40 +639,42 @@ 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)) {
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;
// modified by NIZHNY-MKK Thu Jun 17 12:51:01 2004
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)) {
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;
}
}
}
}
if(!solutionIsValid)
continue;
@ -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:

64
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
@ -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) {
}
//
@ -699,34 +682,17 @@ 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 (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) {
}
}
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);

105
src/IntTools/IntTools_FaceFace.cxx
View File

@ -163,13 +163,6 @@ static
static
Handle(IntPatch_WLine) ComputePurgedWLine(const Handle(IntPatch_WLine)& theWLine);
static
Standard_Real AdjustPeriodic(const Standard_Real theParameter,
const Standard_Real parmin,
const Standard_Real parmax,
const Standard_Real thePeriod,
Standard_Real& theOffset);
static
Handle(Geom2d_BSplineCurve) MakeBSpline2d(const Handle(IntPatch_WLine)& theWLine,
const Standard_Integer ideb,
@ -2328,23 +2321,23 @@ static Standard_Boolean isTreatAnalityc(const TopoDS_Face& theF1,
//function : BuildPCurves
//purpose :
//=======================================================================
void BuildPCurves (Standard_Real f,
void BuildPCurves (Standard_Real f,
Standard_Real l,
Standard_Real& Tol,
const Handle (Geom_Surface)& S,
const Handle (Geom_Curve)& C,
Handle (Geom2d_Curve)& C2d)
{
if (!C2d.IsNull()) {
return;
}
//
Standard_Real umin,umax,vmin,vmax;
//
if (C2d.IsNull())
{
S->Bounds(umin, umax, vmin, vmax);
// in class ProjLib_Function the range of parameters is shrank by 1.e-09
if((l - f) > 2.e-09)
{
C2d = GeomProjLib::Curve2d(C,f,l,S,Tol);
if((l - f) > 2.e-09) {
C2d = GeomProjLib::Curve2d(C,f,l,S,umin,umax,vmin,vmax,Tol);
//
if (C2d.IsNull()) {
// proj. a circle that goes through the pole on a sphere to the sphere
@ -2352,10 +2345,8 @@ static Standard_Boolean isTreatAnalityc(const TopoDS_Face& theF1,
C2d = GeomProjLib::Curve2d(C,f,l,S,Tol);
}
}
else
{
if((l - f) > Epsilon(Abs(f)))
{
else {
if((l - f) > Epsilon(Abs(f))) {
GeomAPI_ProjectPointOnSurf aProjector1, aProjector2;
gp_Pnt P1 = C->Value(f);
gp_Pnt P2 = C->Value(l);
@ -2399,38 +2390,25 @@ static Standard_Boolean isTreatAnalityc(const TopoDS_Face& theF1,
}
}
//
S->Bounds(umin, umax, vmin, vmax);
if (S->IsUPeriodic() && !C2d.IsNull())
{
if (S->IsUPeriodic() && !C2d.IsNull()) {
// Recadre dans le domaine UV de la face
Standard_Real period, U0, du, aEps;
du =0.0;
aEps=Precision::PConfusion();
Standard_Real aTm, U0, aEps, period, du, U0x;
Standard_Boolean bAdjust;
//
aEps = Precision::PConfusion();
period = S->UPeriod();
gp_Pnt2d Pf = C2d->Value(f);
U0=Pf.X();
//
gp_Pnt2d Pl = C2d->Value(l);
U0 = Min(Pl.X(), U0);
// while(U0-umin<aEps) {
while(U0-umin<-aEps) {
U0+=period;
du+=period;
}
aTm = .5*(f + l);
gp_Pnt2d pm = C2d->Value(aTm);
U0 = pm.X();
//
while(U0-umax>aEps) {
U0-=period;
du-=period;
}
if (du != 0) {
gp_Vec2d T1(du,0.);
bAdjust =
IntTools_Tools::AdjustPeriodic(U0, umin, umax, period, U0x, du, aEps);
if (bAdjust) {
gp_Vec2d T1(du, 0.);
C2d->Translate(T1);
}
}
}
}
//=======================================================================
@ -3127,31 +3105,6 @@ void TolR3d(const TopoDS_Face& aF1,
}
}
//=======================================================================
//function : AdjustPeriodic
//purpose :
//=======================================================================
Standard_Real AdjustPeriodic(const Standard_Real theParameter,
const Standard_Real parmin,
const Standard_Real parmax,
const Standard_Real thePeriod,
Standard_Real& theOffset)
{
Standard_Real aresult;
//
theOffset = 0.;
aresult = theParameter;
while(aresult < parmin) {
aresult += thePeriod;
theOffset += thePeriod;
}
while(aresult > parmax) {
aresult -= thePeriod;
theOffset -= thePeriod;
}
return aresult;
}
//=======================================================================
//function : IsPointOnBoundary
//purpose :
//=======================================================================
@ -3692,11 +3645,11 @@ Standard_Boolean DecompositionOfWLine(const Handle(IntPatch_WLine)& theWLine,
aParameter=V;
}
anoffset = 0.;
anAdjustPar = AdjustPeriodic(aParameter,
IntTools_Tools::AdjustPeriodic(aParameter,
alowerboundary,
aupperboundary,
aPeriod,
anAdjustPar,
anoffset);
//
bIsOnFirstBoundary = Standard_True;// ?
@ -3828,8 +3781,9 @@ Standard_Boolean DecompositionOfWLine(const Handle(IntPatch_WLine)& theWLine,
}
else {
Standard_Real aPeriod = (parit == 0) ? aGASurface->UPeriod() : aGASurface->VPeriod();
Standard_Real anoffset = 0.;
Standard_Real anAdjustPar = AdjustPeriodic(aParameter, alowerboundary, aupperboundary, aPeriod, anoffset);
Standard_Real anoffset, anAdjustPar;
IntTools_Tools::AdjustPeriodic(aParameter, alowerboundary, aupperboundary,
aPeriod, anAdjustPar, anoffset);
bIsPointOnBoundary=
IsPointOnBoundary(anAdjustPar, alowerboundary, aupperboundary, aResolution, bIsOnFirstBoundary);
@ -3892,8 +3846,9 @@ Standard_Boolean DecompositionOfWLine(const Handle(IntPatch_WLine)& theWLine,
Standard_Real aupperboundary = (bIsUBoundary) ? umax : vmax;
Standard_Real aPeriod = (bIsUBoundary) ? aGASurface->UPeriod() : aGASurface->VPeriod();
Standard_Real aParameter = (bIsUBoundary) ? U : V;
Standard_Real anoffset = 0.;
Standard_Real anAdjustPar = AdjustPeriodic(aParameter, alowerboundary, aupperboundary, aPeriod, anoffset);
Standard_Real anoffset, anAdjustPar;
IntTools_Tools::AdjustPeriodic(aParameter, alowerboundary, aupperboundary,
aPeriod, anAdjustPar, anoffset);
Standard_Real adist = (bIsFirstBoundary) ? fabs(anAdjustPar - alowerboundary) : fabs(anAdjustPar - aupperboundary);
Standard_Real anotherPar = (bIsFirstBoundary) ? (aupperboundary - adist) : (alowerboundary + adist);

15
src/IntTools/IntTools_LineConstructor.cxx
View File

@ -41,6 +41,7 @@
#include <ElCLib.hxx>
#include <GeomAbs_SurfaceType.hxx>
#include <TColStd_IndexedMapOfInteger.hxx>
#include <IntTools_Tools.hxx>
static
void Parameters(const Handle(GeomAdaptor_HSurface)& myHS1,
@ -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);
}
}
//=======================================================================

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