OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-04-03 17:56:21 +03:00
Code Packages Releases Activity

0028222: Intersection of two cylinders fails

Browse Source 
1. The reason of exception has been eliminated.

2. Algorithm in IntPatch_WLineTool::JoinWLines(...) method has been modified in order to forbid join curves in the point where more than two intersection lines meet. More over, joining is forbidden if local curvature in the connection point is too big (see function CheckArgumentsToJoin(...) in the file IntPatch_WLineTool.cxx).

3. Interface of IntPatch_WLineTool::JoinWLines(...) method has been modified in order to reduce number of arguments.

4. Small corrections in IsSeamOrBound(...) static function has been made. Namely, check has been added if two boundaries are in the same period region but are too far each to other (see IntPatch_WLineTool.cxx, IsSeamOrBound(...) function, line # 532).

5. "Reversed" flag has been made local. Now, it is pure local characteristic: the algorithm decides itself, shall we reverse the argument order. This correction makes the algorithm more commutative (see issue #25404). However, IntPatch_WLineTool::JoinWLines(...) method can return non-commutative result.

6. Algorithm of searching small intersection curves has been improved.

7. New methods have been added in Bnd_Range class.

Some test cases have been adjusted according to their new behavior.

1. tests\bugs\modalg_6\bug26310_3
   tests\bugs\modalg_6\bug26310_4
   tests\bugs\moddata_2\bug235
   tests\perf\modalg\bug26310_1
   tests\bugs\modalg_5\bug24915

Logic of these cases has been changed. Mover over, additional check has been added in "bug26310_1" test case. Therefore, its performance will be slower than on the current MASTER.

2. tests\bugs\modalg_5\bug25292*

Scripts have been rewritten in order to make it more readable. Logic of these cases has not been changed.
This commit is contained in:
nbv 2016-12-15 17:22:00 +03:00 committed by bugmaster
parent 0609d8ee53
commit 261b7d9e8a
36 changed files with 1739 additions and 1426 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

140
src/Bnd/Bnd_Range.cxx
View File

@ -35,3 +35,143 @@ void Bnd_Range::Common(const Bnd_Range& theOther)
myFirst = Max(myFirst, theOther.myFirst);
myLast = Min(myLast, theOther.myLast);
}
//=======================================================================
//function : Union
//purpose :
//=======================================================================
Standard_Boolean Bnd_Range::Union(const Bnd_Range& theOther)
{
if (IsVoid() || theOther.IsVoid())
return Standard_False;
if (myLast < theOther.myFirst)
return Standard_False;
if (myFirst > theOther.myLast)
return Standard_False;
myFirst = Min(myFirst, theOther.myFirst);
myLast = Max(myLast, theOther.myLast);
return Standard_True;
}
//=======================================================================
//function : IsIntersected
//purpose :
//=======================================================================
Standard_Integer Bnd_Range::IsIntersected(const Standard_Real theVal,
const Standard_Real thePeriod) const
{
if (IsVoid())
return Standard_False;
const Standard_Real aPeriod = Abs(thePeriod);
const Standard_Real aDF = myFirst - theVal,
aDL = myLast - theVal;
if (aPeriod <= RealSmall())
{
const Standard_Real aDelta = aDF*aDL;
if (IsEqual(aDelta, 0.0))
return 2;
if (aDelta > 0.0)
return 0;
return 1;
}
//If <this> intersects theVal then there exists an integer
//number N such as
// (myFirst <= theVal+aPeriod*N <= myLast) <=>
// ((myFirst-theVal)/aPeriod <= N <= (myLast-theVal)/aPeriod).
//I.e. the interval [aDF/aPeriod, aDL/aPeriod] must contain at least one
//integer number.
//In this case, Floor(aDF/aPeriod) and Floor(aDL/aPeriod)
//return different values or aDF/aPeriod (aDL/aPeriod)
//is strictly integer number.
//Examples:
// 1. (aDF/aPeriod==2.8, aDL/aPeriod==3.5 =>
// Floor(aDF/aPeriod) == 2, Floor(aDL/aPeriod) == 3.
// 2. aDF/aPeriod==2.0, aDL/aPeriod==2.6 =>
// Floor(aDF/aPeriod) == Floor(aDL/aPeriod) == 2.
const Standard_Real aVal1 = aDF / aPeriod,
aVal2 = aDL / aPeriod;
const Standard_Integer aPar1 = static_cast<Standard_Integer>(Floor(aVal1));
const Standard_Integer aPar2 = static_cast<Standard_Integer>(Floor(aVal2));
if (aPar1 != aPar2)
{//Interval (myFirst, myLast] intersects seam-edge
if (IsEqual(aVal2, static_cast<Standard_Real>(aPar2)))
{//aVal2 is an integer number => myLast lies ON the "seam-edge"
return 2;
}
return 1;
}
//Here, aPar1 == aPar2.
if (IsEqual(aVal1, static_cast<Standard_Real>(aPar1)))
{//aVal1 is an integer number => myFirst lies ON the "seam-edge"
return 2;
}
#if 0
// This check is excess because always myFirst <= myLast.
// So, this condition is never satisfied.
if (IsEqual(aVal2, static_cast<Standard_Real>(aPar2)))
{//aVal2 is an integer number => myLast lies ON the "seam-edge"
return 2;
}
#endif
return 0;
}
//=======================================================================
//function : Split
//purpose :
//=======================================================================
void Bnd_Range::Split(const Standard_Real theVal,
NCollection_List<Bnd_Range>& theList,
const Standard_Real thePeriod) const
{
const Standard_Real aPeriod = Abs(thePeriod);
if (IsIntersected(theVal, aPeriod) != 1)
{
theList.Append(*this);
return;
}
const Standard_Boolean isPeriodic = (aPeriod > 0.0);
if (!isPeriodic)
{
theList.Append(Bnd_Range(myFirst, theVal));
theList.Append(Bnd_Range(theVal, myLast));
return;
}
Standard_Real aValPrev = theVal + aPeriod*Ceiling((myFirst - theVal) / aPeriod);
//Now, (myFirst <= aValPrev < myFirst+aPeriod).
if (aValPrev > myFirst)
{
theList.Append(Bnd_Range(myFirst, aValPrev));
}
for (Standard_Real aVal = aValPrev+aPeriod; aVal <= myLast; aVal += aPeriod)
{
theList.Append(Bnd_Range(aValPrev, aVal));
aValPrev = aVal;
}
if (aValPrev < myLast)
{
theList.Append(Bnd_Range(aValPrev, myLast));
}
}

69
src/Bnd/Bnd_Range.hxx
View File

@ -19,6 +19,8 @@
#include <Standard_Real.hxx>
#include <Standard_ConstructionError.hxx>
#include <NCollection_List.hxx>
//! This class describes a range in 1D space restricted
//! by two real values.
//! A range can be void indicating there is no point included in the range.
@ -42,6 +44,39 @@ public:
//! Replaces <this> with common-part of <this> and theOther
Standard_EXPORT void Common(const Bnd_Range& theOther);
//! Joins *this and theOther to one interval.
//! Replaces *this to the result.
//! Returns false if the operation cannot be done (e.g.
//! input arguments are empty or separated).
Standard_EXPORT Standard_Boolean Union(const Bnd_Range& theOther);
//! Splits <this> to several sub-ranges by theVal value
//! (e.g. range [3, 15] will be split by theVal==5 to the two
//! ranges: [3, 5] and [5, 15]). New ranges will be pushed to
//! theList (theList must be initialized correctly before
//! calling this method).
//! If thePeriod != 0.0 then at least one boundary of
//! new ranges (if <*this> intersects theVal+k*thePeriod) will be equal to
//! theVal+thePeriod*k, where k is an integer number (k = 0, +/-1, +/-2, ...).
//! (let thePeriod in above example be 4 ==> we will obtain
//! four ranges: [3, 5], [5, 9], [9, 13] and [13, 15].
Standard_EXPORT void Split(const Standard_Real theVal,
NCollection_List<Bnd_Range>& theList,
const Standard_Real thePeriod = 0.0) const;
//! Checks if <this> intersects values like
//! theVal+k*thePeriod, where k is an integer number (k = 0, +/-1, +/-2, ...).
//! Returns:
//! 0 - if <this> does not intersect the theVal+k*thePeriod.
//! 1 - if <this> intersects theVal+k*thePeriod.
//! 2 - if myFirst or/and myLast are equal to theVal+k*thePeriod.
//!
//! ATTENTION!!!
//! If (myFirst == myLast) then this function will return only either 0 or 2.
Standard_EXPORT Standard_Integer
IsIntersected(const Standard_Real theVal,
const Standard_Real thePeriod = 0.0) const;
//! Extends <this> to include theParameter
void Add(const Standard_Real theParameter)
@ -82,6 +117,21 @@ public:
return Standard_True;
}
//! Obtain first and last boundary of <this>.
//! If <this> is VOID the method returns false.
Standard_Boolean GetBounds(Standard_Real& theFirstPar,
Standard_Real& theLastPar) const
{
if(IsVoid())
{
return Standard_False;
}
theFirstPar = myFirst;
theLastPar = myLast;
return Standard_True;
}
//! Returns range value (MAX-MIN). Returns negative value for VOID range.
Standard_Real Delta() const
{
@ -113,6 +163,25 @@ public:
myLast += theDelta;
}
//! Returns the copy of <*this> shifted by theVal
Bnd_Range Shifted(const Standard_Real theVal) const
{
return Bnd_Range(myFirst + theVal, myLast + theVal);
}
//! Shifts <*this> by theVal
void Shift(const Standard_Real theVal)
{
myFirst += theVal;
myLast += theVal;
}
//! Returns TRUE if theOther is equal to <*this>
Standard_Boolean operator==(const Bnd_Range& theOther) const
{
return ((myFirst == theOther.myFirst) && (myLast == theOther.myLast));
}
private:
//! Start of range
Standard_Real myFirst;

16
src/ElCLib/ElCLib.cxx
View File

@ -49,6 +49,22 @@ static Standard_Real PIPI = M_PI + M_PI;
//=======================================================================
//function : InPeriod
//purpose : Value theULast is never returned.
// Example of some case (checked on WIN64 platform)
// with some surface having period 2*PI = 6.2831853071795862.
// Let theUFirst be equal to 6.1645624650899675. Then,
// theULast must be equal to
// 6.1645624650899675+6.2831853071795862=12.4477477722695537.
//
// However, real result is 12.447747772269555.
// Therefore, new period value to adjust will be equal to
// 12.447747772269555-6.1645624650899675=6.2831853071795871.
//
// As we can see, (6.2831853071795871 != 6.2831853071795862).
//
// According to above said, this method should be used carefully.
// In order to increase reliability of this method, input arguments
// needs to be replaced with following:
// (theU, theUFirst, thePeriod). theULast parameter is excess.
//=======================================================================
Standard_Real ElCLib::InPeriod(const Standard_Real theU,
const Standard_Real theUFirst,

1
src/IntPatch/IntPatch_ImpImpIntersection_1.gxx
View File

@ -77,7 +77,6 @@ static
const Standard_Real theTol2D,
const Bnd_Box2d& theUVSurf1,
const Bnd_Box2d& theUVSurf2,
const Standard_Boolean isTheReverse,
Standard_Boolean& isTheEmpty,
Standard_Boolean& isTheSameSurface,
Standard_Boolean& isTheMultiplePoint,

26
src/IntPatch/IntPatch_ImpImpIntersection_2.gxx
View File

@ -172,33 +172,13 @@ void IntPatch_ImpImpIntersection::Perform(const Handle(Adaptor3d_HSurface)& S1,
aBox2.Add(gp_Pnt2d(aU2l, S2->LastVParameter()));
// Resolution is too big if the cylinder radius is
// too small. Therefore, we shall bounde its value above.
// too small. Therefore, we shall bind its value above.
// Here, we use simple constant.
const Standard_Real a2DTol = Min(1.0e-4, Min( S1->UResolution(TolTang),
S2->UResolution(TolTang)));
//The bigger range the bigger nunber of points in Walking-line (WLine)
//we will be able to add and, consequently, we will obtain more
//precise intersection line.
//Every point of WLine is determined as function from U1-parameter,
//where U1 is U-parameter on 1st quadric.
//Therefore, we should use quadric with bigger range as 1st parameter
//in IntCyCy() function.
//On the other hand, there is no point in reversing in case of
//analytical intersection (when result is line, ellipse, point...).
//This result is independent of the arguments order.
Standard_Boolean isReversed = ((aU2l - aU2f) < (aU1l - aU1f));
if(isReversed)
{
myDone = IntCyCy(quad2, quad1, TolTang, a2DTol, aBox2, aBox1,
Standard_True, empt, SameSurf, multpoint, slin, spnt);
}
else
{
myDone = IntCyCy(quad1, quad2, TolTang, a2DTol, aBox1, aBox2,
Standard_False, empt, SameSurf, multpoint, slin, spnt);
}
myDone = IntCyCy(quad1, quad2, TolTang, a2DTol, aBox1, aBox2,
empt, SameSurf, multpoint, slin, spnt);
if (myDone == IntPatch_ImpImpIntersection::IntStatus_Fail)
{

1194
src/IntPatch/IntPatch_ImpImpIntersection_4.gxx
View File

File diff suppressed because it is too large Load Diff

14
src/IntPatch/IntPatch_Intersection.cxx
View File

@ -1405,19 +1405,7 @@ void IntPatch_Intersection::GeomGeomPerfom(const Handle(Adaptor3d_HSurface)& the
if((theTyps1 == GeomAbs_Cylinder) && (theTyps2 == GeomAbs_Cylinder))
{
IntPatch_WLineTool::JoinWLines( slin, spnt, TolTang,
theS1->IsUPeriodic()? theS1->UPeriod() : 0.0,
theS2->IsUPeriodic()? theS2->UPeriod() : 0.0,
theS1->IsVPeriodic()? theS1->VPeriod() : 0.0,
theS2->IsVPeriodic()? theS2->VPeriod() : 0.0,
theS1->FirstUParameter(),
theS1->LastUParameter(),
theS1->FirstVParameter(),
theS1->LastVParameter(),
theS2->FirstUParameter(),
theS2->LastUParameter(),
theS2->FirstVParameter(),
theS2->LastVParameter());
IntPatch_WLineTool::JoinWLines(slin, spnt, theS1, theS2, TolTang);
}
if(isWLExist)

636
src/IntPatch/IntPatch_WLineTool.cxx
View File

@ -15,9 +15,12 @@
#include <Adaptor3d_HSurface.hxx>
#include <Adaptor3d_TopolTool.hxx>
#include <Bnd_Range.hxx>
#include <ElCLib.hxx>
#include <ElSLib.hxx>
#include <IntPatch_SpecialPoints.hxx>
#include <NCollection_IncAllocator.hxx>
#include <TopAbs_State.hxx>
// It is pure empirical value.
const Standard_Real IntPatch_WLineTool::myMaxConcatAngle = M_PI/6;
@ -483,64 +486,6 @@ static Handle(IntPatch_WLine)
return MakeNewWLine(theWLine, aNewPointsHash);
}
//=======================================================================
//function : IsOnPeriod
//purpose : Checks, if [theU1, theU2] intersects the period-value
// (k*thePeriod, where k is an integer number (k = 0, +/-1, +/-2, ...).
//
// Returns:
// 0 - if interval [theU1, theU2] does not intersect the "period-value"
// or if thePeriod == 0.0;
// 1 - if interval (theU1, theU2) intersect the "period-value".
// 2 - if theU1 or/and theU2 lie ON the "period-value"
//
//ATTENTION!!!
// If (theU1 == theU2) then this function will return only both 0 or 2.
//=======================================================================
static Standard_Integer IsOnPeriod(const Standard_Real theU1,
const Standard_Real theU2,
const Standard_Real thePeriod)
{
if(thePeriod < RealSmall())
return 0;
//If interval [theU1, theU2] intersect seam-edge then there exists an integer
//number N such as
// (theU1 <= T*N <= theU2) <=> (theU1/T <= N <= theU2/T),
//where T is the period.
//I.e. the inerval [theU1/T, theU2/T] must contain at least one
//integer number. In this case, Floor(theU1/T) and Floor(theU2/T)
//return different values or theU1/T is strictly integer number.
//Examples:
// 1. theU1/T==2.8, theU2/T==3.5 => Floor(theU1/T) == 2, Floor(theU2/T) == 3.
// 2. theU1/T==2.0, theU2/T==2.6 => Floor(theU1/T) == Floor(theU2/T) == 2.
const Standard_Real aVal1 = theU1/thePeriod,
aVal2 = theU2/thePeriod;
const Standard_Integer aPar1 = static_cast<Standard_Integer>(Floor(aVal1));
const Standard_Integer aPar2 = static_cast<Standard_Integer>(Floor(aVal2));
if(aPar1 != aPar2)
{//Interval (theU1, theU2] intersects seam-edge
if(IsEqual(aVal2, static_cast<Standard_Real>(aPar2)))
{//aVal2 is an integer number => theU2 lies ON the "seam-edge"
return 2;
}
return 1;
}
//Here, aPar1 == aPar2.
if(IsEqual(aVal1, static_cast<Standard_Real>(aPar1)))
{//aVal1 is an integer number => theU1 lies ON the "seam-edge"
return 2;
}
//If aVal2 is a true integer number then always (aPar1 != aPar2).
return 0;
}
//=======================================================================
//function : IsSeamOrBound
//purpose : Returns TRUE if segment [thePtf, thePtl] intersects "seam-edge"
@ -550,129 +495,90 @@ static Standard_Integer IsOnPeriod(const Standard_Real theU1,
// If thePtmid match "seam-edge" or boundaries strictly
// (without any tolerance) then the function will return TRUE.
// See comments in function body for detail information.
//
// Arrays theArrPeriods, theFBound and theLBound must be filled
// as follows:
// [0] - U-parameter of 1st surface;
// [1] - V-parameter of 1st surface;
// [2] - U-parameter of 2nd surface;
// [3] - V-parameter of 2nd surface.
//=======================================================================
static Standard_Boolean IsSeamOrBound(const IntSurf_PntOn2S& thePtf,
const IntSurf_PntOn2S& thePtl,
const IntSurf_PntOn2S& thePtmid,
const Standard_Real theU1Period,
const Standard_Real theU2Period,
const Standard_Real theV1Period,
const Standard_Real theV2Period,
const Standard_Real theUfSurf1,
const Standard_Real theUlSurf1,
const Standard_Real theVfSurf1,
const Standard_Real theVlSurf1,
const Standard_Real theUfSurf2,
const Standard_Real theUlSurf2,
const Standard_Real theVfSurf2,
const Standard_Real theVlSurf2)
const Standard_Real theArrPeriods[4],
const Standard_Real theFBound[4],
const Standard_Real theLBound[4])
{
Standard_Real aU11 = 0.0, aU12 = 0.0, aV11 = 0.0, aV12 = 0.0;
Standard_Real aU21 = 0.0, aU22 = 0.0, aV21 = 0.0, aV22 = 0.0;
thePtf.Parameters(aU11, aV11, aU12, aV12);
thePtl.Parameters(aU21, aV21, aU22, aV22);
Standard_Real aParF[4] = { 0.0, 0.0, 0.0, 0.0 };
Standard_Real aParL[4] = { 0.0, 0.0, 0.0, 0.0 };
thePtf.Parameters(aParF[0], aParF[1], aParF[2], aParF[3]);
thePtl.Parameters(aParL[0], aParL[1], aParL[2], aParL[3]);
MinMax(aU11, aU21);
MinMax(aV11, aV21);
MinMax(aU12, aU22);
MinMax(aV12, aV22);
Bnd_Range aBndR[4];
if((aU11 - theUfSurf1)*(aU21 - theUfSurf1) < 0.0)
{//Interval [aU11, aU21] intersects theUfSurf1
return Standard_True;
for (Standard_Integer i = 0; i < 4; i++)
{
aBndR[i].Add(aParF[i]);
aBndR[i].Add(aParL[i]);
if (aBndR[i].IsIntersected(theFBound[i], theArrPeriods[i]) == 1)
return Standard_True;
if (aBndR[i].IsIntersected(theLBound[i], theArrPeriods[i]) == 1)
return Standard_True;
}
if((aU11 - theUlSurf1)*(aU21 - theUlSurf1) < 0.0)
{//Interval [aU11, aU21] intersects theUlSurf1
return Standard_True;
for (Standard_Integer i = 0; i < 4; i++)
{
if (theArrPeriods[i] == 0.0)
{
//Strictly equal
continue;
}
const Standard_Real aDelta = Abs(aParL[i] - aParF[i]);
if (2.0*aDelta > theArrPeriods[i])
{
//Most likely, seam is intersected.
return Standard_True;
}
if (aBndR[i].IsIntersected(0.0, theArrPeriods[i]) == 1)
return Standard_True;
}
if((aV11 - theVfSurf1)*(aV21 - theVfSurf1) < 0.0)
{//Interval [aV11, aV21] intersects theVfSurf1
return Standard_True;
//The segment [thePtf, thePtl] does not intersect the boundaries and
//the seam-edge of the surfaces.
//Nevertheless, following situation is possible:
// seam or
// bound
// |
// thePtf * |
// |
// * thePtmid
// thePtl * |
// |
//This case must be processed, too.
Standard_Real aMPar[4] = { 0.0, 0.0, 0.0, 0.0 };
thePtmid.Parameters(aMPar[0], aMPar[1], aMPar[2], aMPar[3]);
for (Standard_Integer i = 0; i < 4; i++)
{
const Bnd_Range aBR(aMPar[i], aMPar[i]);
if (aBR.IsIntersected(theFBound[i], theArrPeriods[i]))
return Standard_True;
if (aBR.IsIntersected(theLBound[i], theArrPeriods[i]))
return Standard_True;
if (aBR.IsIntersected(0.0, theArrPeriods[i]))
return Standard_True;
}
if((aV11 - theVlSurf1)*(aV21 - theVlSurf1) < 0.0)
{//Interval [aV11, aV21] intersects theVlSurf1
return Standard_True;
}
if((aU12 - theUfSurf2)*(aU22 - theUfSurf2) < 0.0)
{//Interval [aU12, aU22] intersects theUfSurf2
return Standard_True;
}
if((aU12 - theUlSurf2)*(aU22 - theUlSurf2) < 0.0)
{//Interval [aU12, aU22] intersects theUlSurf2
return Standard_True;
}
if((aV12 - theVfSurf2)*(aV22 - theVfSurf2) < 0.0)
{//Interval [aV12, aV22] intersects theVfSurf2
return Standard_True;
}
if((aV12 - theVlSurf2)*(aV22 - theVlSurf2) < 0.0)
{//Interval [aV12, aV22] intersects theVlSurf2
return Standard_True;
}
if(IsOnPeriod(aU11, aU21, theU1Period))
return Standard_True;
if(IsOnPeriod(aV11, aV21, theV1Period))
return Standard_True;
if(IsOnPeriod(aU12, aU22, theU2Period))
return Standard_True;
if(IsOnPeriod(aV12, aV22, theV2Period))
return Standard_True;
/*
The segment [thePtf, thePtl] does not intersect the boundaries and
the seam-edge of the surfaces.
Nevertheless, following situation is possible:
seam or
bound
|
thePtf * |
|
* thePtmid
thePtl * |
|
This case must be processed, too.
*/
Standard_Real aU1 = 0.0, aU2 = 0.0, aV1 = 0.0, aV2 = 0.0;
thePtmid.Parameters(aU1, aV1, aU2, aV2);
if(IsEqual(aU1, theUfSurf1) || IsEqual(aU1, theUlSurf1))
return Standard_True;
if(IsEqual(aU2, theUfSurf2) || IsEqual(aU2, theUlSurf2))
return Standard_True;
if(IsEqual(aV1, theVfSurf1) || IsEqual(aV1, theVlSurf1))
return Standard_True;
if(IsEqual(aV2, theVfSurf2) || IsEqual(aV2, theVlSurf2))
return Standard_True;
if(IsOnPeriod(aU1, aU1, theU1Period))
return Standard_True;
if(IsOnPeriod(aU2, aU2, theU2Period))
return Standard_True;
if(IsOnPeriod(aV1, aV1, theV1Period))
return Standard_True;
if(IsOnPeriod(aV2, aV2, theV2Period))
return Standard_True;
return Standard_False;
}
@ -919,59 +825,75 @@ static IntPatchWT_WLsConnectionType
thePtWL2.Parameters(aParWL2[0], aParWL2[1], aParWL2[2], aParWL2[3]);
theNewPoint.Parameters(aNewPar[0], aNewPar[1], aNewPar[2], aNewPar[3]);
Bnd_Range aR1, aR2;
Standard_Boolean isOnBoundary = Standard_False;
for(Standard_Integer i = 0; i < 4; i++)
{
if(IsOnPeriod(aParWL1[i] - aParLBC[i], aParWL2[i] - aParLBC[i], theArrPeriods[i]))
if (theArrPeriods[i] == 0.0)
{
//Strictly equal
continue;
}
aR1.SetVoid();
aR1.Add(aParWL1[i]);
aR1.Add(aParWL2[i]);
if (aR1.IsIntersected(aParLBC[i],theArrPeriods[i]))
{
//Check, if we intersect surface boundary when we will extend Wline1 or Wline2
//to theNewPoint
MinMax(aParWL1[i], aParWL2[i]);
if(theArrPeriods[i] > 0.0)
if(aNewPar[i] > aParWL2[i])
{
if(aNewPar[i] > aParWL2[i])
{
//Source situation:
//
//---*---------------*------------*-----
// aParWL1[i] aParWL2[i] aNewPar[i]
//
//After possible adjusting:
//
//---*---------------*------------*-----
// aParWL1[i] aNewPar[i] aParWL2[i]
//
//Now we will be able to extend every WLine to
//aNewPar[i] to make them close to each other.
//However, it is necessary to add check if we
//intersect boundary.
const Standard_Real aPar = aParWL1[i] +
//Source situation:
//
//---*---------------*------------*-----
// aParWL1[i] aParWL2[i] aNewPar[i]
//
//After possible adjusting:
//
//---*---------------*------------*-----
// aParWL1[i] aNewPar[i] aParWL2[i]
//
//Now we will be able to extend every WLine to
//aNewPar[i] to make them close to each other.
//However, it is necessary to add check if we
//intersect boundary.
const Standard_Real aPar = aParWL1[i] +
theArrPeriods[i]*Ceiling((aNewPar[i]-aParWL1[i])/theArrPeriods[i]);
aParWL1[i] = aParWL2[i];
aParWL2[i] = aPar;
}
else if(aNewPar[i] < aParWL1[i])
{
//See comments to main "if".
//Source situation:
//
//---*---------------*------------*-----
// aNewPar[i] aParWL1[i] aParWL2[i]
//
//After possible adjusting:
//
//---*---------------*------------*-----
// aParWL1[i] aNewPar[i] aParWL2[i]
aParWL1[i] = aParWL2[i];
aParWL2[i] = aPar;
}
else if(aNewPar[i] < aParWL1[i])
{
//See comments to main "if".
//Source situation:
//
//---*---------------*------------*-----
// aNewPar[i] aParWL1[i] aParWL2[i]
//
//After possible adjusting:
//
//---*---------------*------------*-----
// aParWL1[i] aNewPar[i] aParWL2[i]
const Standard_Real aPar = aParWL2[i] -
const Standard_Real aPar = aParWL2[i] -
theArrPeriods[i]*Ceiling((aParWL2[i]-aNewPar[i])/theArrPeriods[i]);
aParWL2[i] = aParWL1[i];
aParWL1[i] = aPar;
}
aParWL2[i] = aParWL1[i];
aParWL1[i] = aPar;
}
if( IsOnPeriod(aParWL1[i] - aParLBC[i], aNewPar[i] - aParLBC[i], theArrPeriods[i]) ||
IsOnPeriod(aNewPar[i] - aParLBC[i], aParWL2[i] - aParLBC[i], theArrPeriods[i]))
aR1.SetVoid();
aR2.SetVoid();
aR1.Add(aParWL1[i]);
aR1.Add(aNewPar[i]);
aR2.Add(aNewPar[i]);
aR2.Add(aParWL2[i]);
if (aR1.IsIntersected(aParLBC[i], theArrPeriods[i]) ||
aR2.IsIntersected(aParLBC[i], theArrPeriods[i]))
{
return IntPatchWT_NotConnected;
}
@ -995,13 +917,15 @@ static IntPatchWT_WLsConnectionType
//purpose : Check if joining is possible
// (see IntPatch_WLineTool::JoinWLines(...))
//=======================================================================
Standard_Boolean CheckArgumentsToJoin(const gp_Vec& theVec1,
const gp_Vec& theVec2)
Standard_Boolean CheckArgumentsToJoin(const Handle(Adaptor3d_HSurface)& theS1,
const Handle(Adaptor3d_HSurface)& theS2,
const IntSurf_PntOn2S& thePnt,
const Standard_Real theMinRad)
{
// [0, PI] - range
const Standard_Real anAngle = theVec1.Angle(theVec2);
const Standard_Real aRad =
IntPatch_PointLine::CurvatureRadiusOfIntersLine(theS1, theS2, thePnt);
return (anAngle < IntPatch_WLineTool::myMaxConcatAngle);
return (aRad > theMinRad);
}
//=======================================================================
@ -1415,33 +1339,38 @@ Handle(IntPatch_WLine) IntPatch_WLineTool::
return aResult;
}
//=======================================================================
//function : JoinWLines
//purpose :
//=======================================================================
void IntPatch_WLineTool::JoinWLines(IntPatch_SequenceOfLine& theSlin,
IntPatch_SequenceOfPoint& theSPnt,
const Standard_Real theTol3D,
const Standard_Real theU1Period,
const Standard_Real theU2Period,
const Standard_Real theV1Period,
const Standard_Real theV2Period,
const Standard_Real theUfSurf1,
const Standard_Real theUlSurf1,
const Standard_Real theVfSurf1,
const Standard_Real theVlSurf1,
const Standard_Real theUfSurf2,
const Standard_Real theUlSurf2,
const Standard_Real theVfSurf2,
const Standard_Real theVlSurf2)
Handle(Adaptor3d_HSurface) theS1,
Handle(Adaptor3d_HSurface) theS2,
const Standard_Real theTol3D)
{
if(theSlin.Length() == 0)
return;
for(Standard_Integer aNumOfLine1 = 1; aNumOfLine1 <= theSlin.Length(); aNumOfLine1++)
// For two cylindrical surfaces only
const Standard_Real aMinRad = 1.0e-3*Min(theS1->Cylinder().Radius(),
theS2->Cylinder().Radius());
const Standard_Real anArrPeriods[4] = {theS1->IsUPeriodic() ? theS1->UPeriod() : 0.0,
theS1->IsVPeriodic() ? theS1->VPeriod() : 0.0,
theS2->IsUPeriodic() ? theS2->UPeriod() : 0.0,
theS2->IsVPeriodic() ? theS2->VPeriod() : 0.0};
const Standard_Real anArrFBonds[4] = {theS1->FirstUParameter(), theS1->FirstVParameter(),
theS2->FirstUParameter(), theS2->FirstVParameter()};
const Standard_Real anArrLBonds[4] = {theS1->LastUParameter(), theS1->LastVParameter(),
theS2->LastUParameter(), theS2->LastVParameter()};
Handle(NCollection_IncAllocator) anAlloc = new NCollection_IncAllocator();
for(Standard_Integer aN1 = 1; aN1 <= theSlin.Length(); aN1++)
{
Handle(IntPatch_WLine) aWLine1 (Handle(IntPatch_WLine)::DownCast(theSlin.Value(aNumOfLine1)));
Handle(IntPatch_WLine) aWLine1(Handle(IntPatch_WLine)::DownCast(theSlin.Value(aN1)));
if(aWLine1.IsNull())
{//We must have failed to join not-point-lines
@ -1449,184 +1378,169 @@ void IntPatch_WLineTool::JoinWLines(IntPatch_SequenceOfLine& theSlin,
}
const Standard_Integer aNbPntsWL1 = aWLine1->NbPnts();
const IntSurf_PntOn2S& aPntFW1 = aWLine1->Point(1);
const IntSurf_PntOn2S& aPntLW1 = aWLine1->Point(aNbPntsWL1);
const IntSurf_PntOn2S& aPntFWL1 = aWLine1->Point(1);
const IntSurf_PntOn2S& aPntLWL1 = aWLine1->Point(aNbPntsWL1);
for(Standard_Integer aNPt = 1; aNPt <= theSPnt.Length(); aNPt++)
{
const IntSurf_PntOn2S aPntCur = theSPnt.Value(aNPt).PntOn2S();
if( aPntCur.IsSame(aPntFW1, Precision::Confusion()) ||
aPntCur.IsSame(aPntLW1, Precision::Confusion()))
if( aPntCur.IsSame(aPntFWL1, Precision::Confusion()) ||
aPntCur.IsSame(aPntLWL1, Precision::Confusion()))
{
theSPnt.Remove(aNPt);
aNPt--;
}
}
Standard_Boolean hasBeenRemoved = Standard_False;
for(Standard_Integer aNumOfLine2 = aNumOfLine1 + 1; aNumOfLine2 <= theSlin.Length(); aNumOfLine2++)
{
Handle(IntPatch_WLine) aWLine2 (Handle(IntPatch_WLine)::DownCast(theSlin.Value(aNumOfLine2)));
anAlloc->Reset();
NCollection_List<Standard_Integer> aListFC(anAlloc),
aListLC(anAlloc);
Standard_Boolean isFirstConnected = Standard_False, isLastConnected = Standard_False;
if(aWLine2.IsNull())
for (Standard_Integer aN2 = 1; aN2 <= theSlin.Length(); aN2++)
{
if (aN2 == aN1)
continue;
const Standard_Integer aNbPntsWL2 = aWLine2->NbPnts();
Handle(IntPatch_WLine) aWLine2(Handle(IntPatch_WLine)::DownCast(theSlin.Value(aN2)));
const IntSurf_PntOn2S& aPntFWL1 = aWLine1->Point(1);
const IntSurf_PntOn2S& aPntLWL1 = aWLine1->Point(aNbPntsWL1);
if (aWLine2.IsNull())
continue;
isFirstConnected = isLastConnected = Standard_False;
const Standard_Integer aNbPntsWL2 = aWLine2->NbPnts();
const IntSurf_PntOn2S& aPntFWL2 = aWLine2->Point(1);
const IntSurf_PntOn2S& aPntLWL2 = aWLine2->Point(aNbPntsWL2);
if(aPntFWL1.IsSame(aPntFWL2, Precision::Confusion()))
Standard_Real aSqDistF = aPntFWL1.Value().SquareDistance(aPntFWL2.Value());
Standard_Real aSqDistL = aPntFWL1.Value().SquareDistance(aPntLWL2.Value());
const Standard_Real aSqMinFDist = Min(aSqDistF, aSqDistL);
if (aSqMinFDist < Precision::SquareConfusion())
{
const IntSurf_PntOn2S& aPt1 = aWLine1->Point(2);
const IntSurf_PntOn2S& aPt2 = aWLine2->Point(2);
Standard_Boolean aCond =
CheckArgumentsToJoin(gp_Vec(aPntFWL1.Value(), aPt1.Value()),
gp_Vec(aPt2.Value(), aPntFWL2.Value()));
aCond = aCond && !IsSeamOrBound(aPt1, aPt2, aPntFWL1,
theU1Period, theU2Period,
theV1Period, theV2Period,
theUfSurf1, theUlSurf1,
theVfSurf1, theVlSurf1,
theUfSurf2, theUlSurf2,
theVfSurf2, theVlSurf2);
if(aCond)
if (CheckArgumentsToJoin(theS1, theS2, aPntFWL1, aMinRad))
{
aWLine1->ClearVertexes();
for(Standard_Integer aNPt = 1; aNPt <= aNbPntsWL2; aNPt++)
const Standard_Boolean isFM = (aSqDistF < aSqDistL);
const IntSurf_PntOn2S& aPt1 = aWLine1->Point(2);
const IntSurf_PntOn2S& aPt2 = isFM ? aWLine2->Point(2) :
aWLine2->Point(aNbPntsWL2 - 1);
if (!IsSeamOrBound(aPt1, aPt2, aPntFWL1,
anArrPeriods, anArrFBonds, anArrLBonds))
{
const IntSurf_PntOn2S& aPt = aWLine2->Point(aNPt);
aWLine1->Curve()->InsertBefore(1, aPt);
isFirstConnected = Standard_True;
}
aWLine1->ComputeVertexParameters(theTol3D);
theSlin.Remove(aNumOfLine2);
aNumOfLine2--;
hasBeenRemoved = Standard_True;
continue;
}
}
if(aPntFWL1.IsSame(aPntLWL2, Precision::Confusion()))
aSqDistF = aPntLWL1.Value().SquareDistance(aPntFWL2.Value());
aSqDistL = aPntLWL1.Value().SquareDistance(aPntLWL2.Value());
const Standard_Real aSqMinLDist = Min(aSqDistF, aSqDistL);
if (aSqMinLDist < Precision::SquareConfusion())
{
const IntSurf_PntOn2S& aPt1 = aWLine1->Point(2);
const IntSurf_PntOn2S& aPt2 = aWLine2->Point(aNbPntsWL2-1);
Standard_Boolean aCond =
CheckArgumentsToJoin(gp_Vec(aPntFWL1.Value(), aPt1.Value()),
gp_Vec(aPt2.Value(), aPntLWL2.Value()));
aCond = aCond && !IsSeamOrBound(aPt1, aPt2, aPntFWL1,
theU1Period, theU2Period,
theV1Period, theV2Period,
theUfSurf1, theUlSurf1,
theVfSurf1, theVlSurf1,
theUfSurf2, theUlSurf2,
theVfSurf2, theVlSurf2);
if(aCond)
if (CheckArgumentsToJoin(theS1, theS2, aPntLWL1, aMinRad))
{
aWLine1->ClearVertexes();
for(Standard_Integer aNPt = aNbPntsWL2; aNPt >= 1; aNPt--)
const Standard_Boolean isFM = (aSqDistF < aSqDistL);
const IntSurf_PntOn2S& aPt1 = aWLine1->Point(aNbPntsWL1 - 1);
const IntSurf_PntOn2S& aPt2 = isFM ? aWLine2->Point(2) :
aWLine2->Point(aNbPntsWL2 - 1);
if (!IsSeamOrBound(aPt1, aPt2, aPntLWL1,
anArrPeriods, anArrFBonds, anArrLBonds))
{
const IntSurf_PntOn2S& aPt = aWLine2->Point(aNPt);
aWLine1->Curve()->InsertBefore(1, aPt);
isLastConnected = Standard_True;
}
aWLine1->ComputeVertexParameters(theTol3D);
theSlin.Remove(aNumOfLine2);
aNumOfLine2--;
hasBeenRemoved = Standard_True;
continue;
}
}
if(aPntLWL1.IsSame(aPntFWL2, Precision::Confusion()))
if (isFirstConnected && isLastConnected)
{
const IntSurf_PntOn2S& aPt1 = aWLine1->Point(aNbPntsWL1-1);
const IntSurf_PntOn2S& aPt2 = aWLine2->Point(2);
Standard_Boolean aCond =
CheckArgumentsToJoin(gp_Vec(aPt1.Value(), aPntLWL1.Value()),
gp_Vec(aPntFWL2.Value(), aPt2.Value()));
aCond = aCond && !IsSeamOrBound(aPt1, aPt2, aPntLWL1,
theU1Period, theU2Period,
theV1Period, theV2Period,
theUfSurf1, theUlSurf1,
theVfSurf1, theVlSurf1,
theUfSurf2, theUlSurf2,
theVfSurf2, theVlSurf2);
if(aCond)
if (aSqMinFDist < aSqMinLDist)
{
aWLine1->ClearVertexes();
for(Standard_Integer aNPt = 1; aNPt <= aNbPntsWL2; aNPt++)
{
const IntSurf_PntOn2S& aPt = aWLine2->Point(aNPt);
aWLine1->Curve()->Add(aPt);
}
aWLine1->ComputeVertexParameters(theTol3D);
theSlin.Remove(aNumOfLine2);
aNumOfLine2--;
hasBeenRemoved = Standard_True;
continue;
aListFC.Append(aN2);
}
else
{
aListLC.Append(aN2);
}
}
if(aPntLWL1.IsSame(aPntLWL2, Precision::Confusion()))
else if (isFirstConnected)
{
const IntSurf_PntOn2S& aPt1 = aWLine1->Point(aNbPntsWL1-1);
const IntSurf_PntOn2S& aPt2 = aWLine2->Point(aNbPntsWL2-1);
aListFC.Append(aN2);
}
else if (isLastConnected)
{
aListLC.Append(aN2);
}
}
Standard_Boolean aCond =
CheckArgumentsToJoin(gp_Vec(aPt1.Value(), aPntLWL1.Value()),
gp_Vec(aPntLWL2.Value(), aPt2.Value()));
isFirstConnected = (aListFC.Extent() == 1);
isLastConnected = (aListLC.Extent() == 1);
aCond = aCond && !IsSeamOrBound(aPt1, aPt2, aPntLWL1,
theU1Period, theU2Period,
theV1Period, theV2Period,
theUfSurf1, theUlSurf1,
theVfSurf1, theVlSurf1,
theUfSurf2, theUlSurf2,
theVfSurf2, theVlSurf2);
if (!(isFirstConnected || isLastConnected))
{
continue;
}
if(aCond)
const Standard_Integer anIndexWL2 = isFirstConnected ? aListFC.First() : aListLC.First();
Handle(IntPatch_WLine) aWLine2(Handle(IntPatch_WLine)::DownCast(theSlin.Value(anIndexWL2)));
const Standard_Integer aNbPntsWL2 = aWLine2->NbPnts();
const IntSurf_PntOn2S& aPntFWL2 = aWLine2->Point(1);
aWLine1->ClearVertexes();
if (isFirstConnected)
{
if (aPntFWL1.IsSame(aPntFWL2, Precision::Confusion()))
{
//First-First-connection
for (Standard_Integer aNPt = 1; aNPt <= aNbPntsWL2; aNPt++)
{
aWLine1->ClearVertexes();
for(Standard_Integer aNPt = aNbPntsWL2; aNPt >= 1; aNPt--)
{
const IntSurf_PntOn2S& aPt = aWLine2->Point(aNPt);
aWLine1->Curve()->Add(aPt);
}
aWLine1->ComputeVertexParameters(theTol3D);
theSlin.Remove(aNumOfLine2);
aNumOfLine2--;
hasBeenRemoved = Standard_True;
continue;
const IntSurf_PntOn2S& aPt = aWLine2->Point(aNPt);
aWLine1->Curve()->InsertBefore(1, aPt);
}
}
else
{
//First-Last-connection
for (Standard_Integer aNPt = aNbPntsWL2; aNPt >= 1; aNPt--)
{
const IntSurf_PntOn2S& aPt = aWLine2->Point(aNPt);
aWLine1->Curve()->InsertBefore(1, aPt);
}
}
}
else //if (isLastConnected)
{
if (aPntLWL1.IsSame(aPntFWL2, Precision::Confusion()))
{
//Last-First connection
for(Standard_Integer aNPt = 1; aNPt <= aNbPntsWL2; aNPt++)
{
const IntSurf_PntOn2S& aPt = aWLine2->Point(aNPt);
aWLine1->Curve()->Add(aPt);
}
}
else
{
//Last-Last connection
for (Standard_Integer aNPt = aNbPntsWL2; aNPt >= 1; aNPt--)
{
const IntSurf_PntOn2S& aPt = aWLine2->Point(aNPt);
aWLine1->Curve()->Add(aPt);
}
}
}
if(hasBeenRemoved)
aNumOfLine1--;
aWLine1->ComputeVertexParameters(theTol3D);
theSlin.Remove(anIndexWL2);
aN1--;
}
}

23
src/IntPatch/IntPatch_WLineTool.hxx
View File

@ -14,9 +14,10 @@
#ifndef _IntPatch_WLineTool_HeaderFile
#define _IntPatch_WLineTool_HeaderFile
#include <Standard_DefineAlloc.hxx>
#include <IntPatch_SequenceOfLine.hxx>
#include <IntPatch_WLine.hxx>
#include <Standard_Macro.hxx>
class Adaptor3d_TopolTool;
@ -59,20 +60,9 @@ public:
//! this point will be deleted.
Standard_EXPORT static void JoinWLines(IntPatch_SequenceOfLine& theSlin,
IntPatch_SequenceOfPoint& theSPnt,
const Standard_Real theTol3D,
const Standard_Real theU1Period,
const Standard_Real theU2Period,
const Standard_Real theV1Period,
const Standard_Real theV2Period,
const Standard_Real theUfSurf1,
const Standard_Real theUlSurf1,
const Standard_Real theVfSurf1,
const Standard_Real theVlSurf1,
const Standard_Real theUfSurf2,
const Standard_Real theUlSurf2,
const Standard_Real theVfSurf2,
const Standard_Real theVlSurf2);
Handle(Adaptor3d_HSurface) theS1,
Handle(Adaptor3d_HSurface) theS2,
const Standard_Real theTol3D);
//! Extends every line from theSlin (if it is possible) to be started/finished
//! in strictly determined point (in the place of joint of two lines).
@ -80,7 +70,8 @@ public:
//! The Walking lines are supposed (algorithm will do nothing for not-Walking line)
//! to be computed as a result of intersection. Both theS1 and theS2
//! must be quadrics. Other cases are not supported.
//! theArrPeriods must be filled as follows:
//! theArrPeriods must be filled as follows (every value must not be negative;
//! if the surface is not periodic the period must be equal to 0.0 strictly):
//! {<U-period of 1st surface>, <V-period of 1st surface>,
//! <U-period of 2nd surface>, <V-period of 2nd surface>}.
Standard_EXPORT static void

15
tests/bugs/modalg_5/bug24915
View File

@ -25,17 +25,26 @@ checkshape r
# 2. geometry
set MaxTol 1.0e-7
set GoodNBCurv 3
set log [bopcurves b1 b2 -2d]
if { ! [regexp {Tolerance Reached=+([-0-9.+eE]+)\n+([-0-9.+eE]+)} ${log} full Toler NbCurv] } {
puts "Error: Cannot find tolerance value in output of bopcurve command"
}
if { $NbCurv != $GoodNBCurv } {
puts "Error: Number of curves is wrong!"
}
if {${Toler} > ${MaxTol}} {
puts "Error: Tolerance is too big!"
}
smallview
donly b2 c_2
fit
checkview -screenshot -2d -path ${imagedir}/${test_image}.png
for {set i 1} {$i <= $GoodNBCurv} {incr i} {
donly b2 c_$i
fit
checkview -screenshot -2d -path ${imagedir}/${test_image}_$i.png
}

29
tests/bugs/modalg_5/bug25292_11
View File

@ -44,38 +44,23 @@ if {${NbCurv} != ${GoodNbCurv}} {
#-------------
# 1
puts ""
mksurface s1 f1
mksurface s2 f2
for {set i 1} {$i <= ${NbCurv}} {incr i} {
set log [dump c_$i]
bounds c_$i U1 U2
puts "U2=[dval U1]"
puts "U2=[dval U2]"
regexp {Degree +([-0-9.+eE]+), +([-0-9.+eE]+) Poles, +([-0-9.+eE]+)} ${log} full Degree Poles KnotsPoles
puts "Degree=${Degree}"
puts "Poles=${Poles}"
puts "KnotsPoles=${KnotsPoles}"
puts ""
set Knot 1
set exp_string "Knots :\n\n +${Knot} : +(\[-0-9.+eE\]+) +(\[-0-9.+eE\]+)"
regexp ${exp_string} ${log} full U1 Mult1
set Knot ${KnotsPoles}
set exp_string " +${Knot} : +(\[-0-9.+eE\]+) +(\[-0-9.+eE\]+)"
regexp ${exp_string} ${log} full U2 Mult2
puts "U1=${U1}"
puts "U2=${U2}"
if {[expr {$U2 - $U1}] < 1.0e-20} {
if {[dval U2-U1] < 1.0e-20} {
puts "Error: Wrong curve's range!"
}
xdistcs c_$i s1 ${U1} ${U2} 10 1e-7
xdistcs c_$i s2 ${U1} ${U2} 10 1e-7
xdistcs c_$i s1 U1 U2 10 ${Toler}
xdistcs c_$i s2 U1 U2 10 ${Toler}
}
v2d

29
tests/bugs/modalg_5/bug25292_12
View File

@ -44,38 +44,23 @@ if {${NbCurv} != ${GoodNbCurv}} {
#-------------
# 1
puts ""
mksurface s1 f1
mksurface s2 f2
for {set i 1} {$i <= ${NbCurv}} {incr i} {
set log [dump c_$i]
bounds c_$i U1 U2
puts "U2=[dval U1]"
puts "U2=[dval U2]"
regexp {Degree +([-0-9.+eE]+), +([-0-9.+eE]+) Poles, +([-0-9.+eE]+)} ${log} full Degree Poles KnotsPoles
puts "Degree=${Degree}"
puts "Poles=${Poles}"
puts "KnotsPoles=${KnotsPoles}"
puts ""
set Knot 1
set exp_string "Knots :\n\n +${Knot} : +(\[-0-9.+eE\]+) +(\[-0-9.+eE\]+)"
regexp ${exp_string} ${log} full U1 Mult1
set Knot ${KnotsPoles}
set exp_string " +${Knot} : +(\[-0-9.+eE\]+) +(\[-0-9.+eE\]+)"
regexp ${exp_string} ${log} full U2 Mult2
puts "U1=${U1}"
puts "U2=${U2}"
if {[expr {$U2 - $U1}] < 1.0e-20} {
if {[dval U2-U1] < 1.0e-20} {
puts "Error: Wrong curve's range!"
}
xdistcs c_$i s1 ${U1} ${U2} 10 1e-7
xdistcs c_$i s2 ${U1} ${U2} 10 1e-7
xdistcs c_$i s1 U1 U2 10 ${Toler}
xdistcs c_$i s2 U1 U2 10 ${Toler}
}
v2d

103
tests/bugs/modalg_5/bug25292_15
View File

@ -6,27 +6,6 @@ puts ""
# Face/Face intersection algorithm gives different results for different order of the arguments
#######################################################################
proc GetRange { curve } {
global U1
global U2
set log [uplevel dump $curve]
regexp {Degree +([-0-9.+eE]+), +([-0-9.+eE]+) Poles, +([-0-9.+eE]+)} ${log} full Degree Poles KnotsPoles
puts "Degree=${Degree}"
puts "Poles=${Poles}"
puts "KnotsPoles=${KnotsPoles}"
puts ""
set Knot 1
set exp_string "Knots :\n\n +${Knot} : +(\[-0-9.+eE\]+) +(\[-0-9.+eE\]+)"
regexp ${exp_string} ${log} full U1 Mult1
set Knot ${KnotsPoles}
set exp_string " +${Knot} : +(\[-0-9.+eE\]+) +(\[-0-9.+eE\]+)"
regexp ${exp_string} ${log} full U2 Mult2
}
puts "##############################"
puts "#!!!Search \"Attention\" keyword on this web-page for additional checking!!!"
puts "##############################"
@ -51,62 +30,42 @@ mksurface s2 f2
#################
intersect res s1 s2
#################
set che [whatis res]
set ind [string first "3d curve" $che]
if {${ind} >= 0} {
#Only variable "res" exists
if { $GoodNbCurv == 1 } {
puts "OK: Curve Number is good!"
renamevar res res_1
}
set ic 1
set AllowRepeate 1
while { $AllowRepeate != 0 } {
set che [whatis res_$ic]
set ind [string first "3d curve" $che]
if {${ind} < 0} {
set AllowRepeate 0
} else {
puts "Error: Curve Number is bad!"
}
set U1 0.0
set U2 0.0
GetRange res
puts "U1 = ${U1}"
puts "U2 = ${U2}"
if {[expr {$U2 - $U1}] < 1.0e-20} {
puts "Error: Wrong curve's range!"
}
xdistcs res s1 ${U1} ${U2} 10 1e-7
xdistcs res s2 ${U1} ${U2} 10 1e-7
} else {
set ic 1
set AllowRepeate 1
while { $AllowRepeate != 0 } {
set che [whatis res_$ic]
set ind [string first "3d curve" $che]
if {${ind} < 0} {
set AllowRepeate 0
} else {
set U1 0.0
set U2 0.0
GetRange res_$ic
puts "U1 = ${U1}"
puts "U2 = ${U2}"
if {[expr {$U2 - $U1}] < 1.0e-20} {
puts "Error: Wrong curve's range!"
}
xdistcs res_$ic s1 ${U1} ${U2} 10 1e-7
xdistcs res_$ic s2 0 1 10 1e-7
incr ic
display res_$ic
bounds res_$ic U1 U2
dval U1
dval U2
if {[dval U2-U1] < 1.0e-20} {
puts "Error: Wrong curve's range!"
}
}
if {[expr {$ic - 1}] == $GoodNbCurv} {
puts "OK: Curve Number is good!"
} else {
puts "Error: Curve Number is bad!"
xdistcs res_$ic s1 U1 U2 10 1.0e-7
xdistcs res_$ic s2 U1 U2 10 1.0e-7
incr ic
}
}
if {[expr {$ic - 1}] == $GoodNbCurv} {
puts "OK: Curve Number is good!"
} else {
puts "Error: Curve Number is bad!"
}

102
tests/bugs/modalg_5/bug25292_16
View File

@ -6,27 +6,6 @@ puts ""
# Face/Face intersection algorithm gives different results for different order of the arguments
#######################################################################
proc GetRange { curve } {
global U1
global U2
set log [uplevel dump $curve]
regexp {Degree +([-0-9.+eE]+), +([-0-9.+eE]+) Poles, +([-0-9.+eE]+)} ${log} full Degree Poles KnotsPoles
puts "Degree=${Degree}"
puts "Poles=${Poles}"
puts "KnotsPoles=${KnotsPoles}"
puts ""
set Knot 1
set exp_string "Knots :\n\n +${Knot} : +(\[-0-9.+eE\]+) +(\[-0-9.+eE\]+)"
regexp ${exp_string} ${log} full U1 Mult1
set Knot ${KnotsPoles}
set exp_string " +${Knot} : +(\[-0-9.+eE\]+) +(\[-0-9.+eE\]+)"
regexp ${exp_string} ${log} full U2 Mult2
}
puts "##############################"
puts "#!!!Search \"Attention\" keyword on this web-page for additional checking!!!"
puts "##############################"
@ -56,58 +35,37 @@ set che [whatis res]
set ind [string first "3d curve" $che]
if {${ind} >= 0} {
#Only variable "res" exists
if { $GoodNbCurv == 1 } {
puts "OK: Curve Number is good!"
renamevar res res_1
}
set ic 1
set AllowRepeate 1
while { $AllowRepeate != 0 } {
set che [whatis res_$ic]
set ind [string first "3d curve" $che]
if {${ind} < 0} {
set AllowRepeate 0
} else {
puts "Error: Curve Number is bad!"
}
set U1 0.0
set U2 0.0
GetRange res
puts "U1 = ${U1}"
puts "U2 = ${U2}"
if {[expr {$U2 - $U1}] < 1.0e-20} {
puts "Error: Wrong curve's range!"
}
xdistcs res s1 ${U1} ${U2} 10 1e-7
xdistcs res s2 ${U1} ${U2} 10 1e-7
} else {
set ic 1
set AllowRepeate 1
while { $AllowRepeate != 0 } {
set che [whatis res_$ic]
set ind [string first "3d curve" $che]
if {${ind} < 0} {
set AllowRepeate 0
} else {
set U1 0.0
set U2 0.0
GetRange res_$ic
puts "U1 = ${U1}"
puts "U2 = ${U2}"
if {[expr {$U2 - $U1}] < 1.0e-20} {
puts "Error: Wrong curve's range!"
}
xdistcs res_$ic s1 ${U1} ${U2} 10 1e-7
xdistcs res_$ic s2 0 1 10 1e-7
incr ic
display res_$ic
bounds res_$ic U1 U2
dval U1
dval U2
if {[dval U2-U1] < 1.0e-20} {
puts "Error: Wrong curve's range!"
}
}
if {[expr {$ic - 1}] == $GoodNbCurv} {
puts "OK: Curve Number is good!"
} else {
puts "Error: Curve Number is bad!"
xdistcs res_$ic s1 U1 U2 10 1.0e-7
xdistcs res_$ic s2 U1 U2 10 1.0e-7
incr ic
}
}
if {[expr {$ic - 1}] == $GoodNbCurv} {
puts "OK: Curve Number is good!"
} else {
puts "Error: Curve Number is bad!"
}

30
tests/bugs/modalg_5/bug25292_21
View File

@ -44,35 +44,23 @@ if {${NbCurv} != ${GoodNbCurv}} {
#-------------
puts ""
mksurface s1 f1
mksurface s2 f2
for {set i 1} {$i <= ${NbCurv}} {incr i} {
set log [dump c_$i]
bounds c_$i U1 U2
puts "U2=[dval U1]"
puts "U2=[dval U2]"
regexp {Degree +([-0-9.+eE]+), +([-0-9.+eE]+) Poles, +([-0-9.+eE]+)} ${log} full Degree Poles KnotsPoles
puts "Degree=${Degree}"
puts "Poles=${Poles}"
puts "KnotsPoles=${KnotsPoles}"
puts ""
set Knot 1
set exp_string "Knots :\n\n +${Knot} : +(\[-0-9.+eE\]+) +(\[-0-9.+eE\]+)"
regexp ${exp_string} ${log} full U1 Mult1
set Knot ${KnotsPoles}
set exp_string " +${Knot} : +(\[-0-9.+eE\]+) +(\[-0-9.+eE\]+)"
regexp ${exp_string} ${log} full U2 Mult2
puts "U1=${U1}"
puts "U2=${U2}"
if {[expr {$U2 - $U1}] < 1.0e-20} {
if {[dval U2-U1] < 1.0e-20} {
puts "Error: Wrong curve's range!"
}
xdistcs c_$i s1 ${U1} ${U2} 10 1e-7
xdistcs c_$i s2 ${U1} ${U2} 10 1e-7
xdistcs c_$i s1 U1 U2 10 ${Toler}
xdistcs c_$i s2 U1 U2 10 ${Toler}
}
smallview

30
tests/bugs/modalg_5/bug25292_22
View File

@ -44,35 +44,23 @@ if {${NbCurv} != ${GoodNbCurv}} {
#-------------
puts ""
mksurface s1 f1
mksurface s2 f2
for {set i 1} {$i <= ${NbCurv}} {incr i} {
set log [dump c_$i]
bounds c_$i U1 U2
puts "U2=[dval U1]"
puts "U2=[dval U2]"
regexp {Degree +([-0-9.+eE]+), +([-0-9.+eE]+) Poles, +([-0-9.+eE]+)} ${log} full Degree Poles KnotsPoles
puts "Degree=${Degree}"
puts "Poles=${Poles}"
puts "KnotsPoles=${KnotsPoles}"
puts ""
set Knot 1
set exp_string "Knots :\n\n +${Knot} : +(\[-0-9.+eE\]+) +(\[-0-9.+eE\]+)"
regexp ${exp_string} ${log} full U1 Mult1
set Knot ${KnotsPoles}
set exp_string " +${Knot} : +(\[-0-9.+eE\]+) +(\[-0-9.+eE\]+)"
regexp ${exp_string} ${log} full U2 Mult2
puts "U1=${U1}"
puts "U2=${U2}"
if {[expr {$U2 - $U1}] < 1.0e-20} {
if {[dval U2-U1] < 1.0e-20} {
puts "Error: Wrong curve's range!"
}
xdistcs c_$i s1 ${U1} ${U2} 10 1e-7
xdistcs c_$i s2 ${U1} ${U2} 10 1e-7
xdistcs c_$i s1 U1 U2 10 ${Toler}
xdistcs c_$i s2 U1 U2 10 ${Toler}
}
smallview

101
tests/bugs/modalg_5/bug25292_25
View File

@ -6,27 +6,6 @@ puts ""
# Face/Face intersection algorithm gives different results for different order of the arguments
#######################################################################
proc GetRange { curve } {
global U1
global U2
set log [uplevel dump $curve]
regexp {Degree +([-0-9.+eE]+), +([-0-9.+eE]+) Poles, +([-0-9.+eE]+)} ${log} full Degree Poles KnotsPoles
puts "Degree=${Degree}"
puts "Poles=${Poles}"
puts "KnotsPoles=${KnotsPoles}"
puts ""
set Knot 1
set exp_string "Knots :\n\n +${Knot} : +(\[-0-9.+eE\]+) +(\[-0-9.+eE\]+)"
regexp ${exp_string} ${log} full U1 Mult1
set Knot ${KnotsPoles}
set exp_string " +${Knot} : +(\[-0-9.+eE\]+) +(\[-0-9.+eE\]+)"
regexp ${exp_string} ${log} full U2 Mult2
}
puts "##############################"
puts "#!!!Search \"Attention\" keyword on this web-page for additional checking!!!"
puts "##############################"
@ -56,59 +35,37 @@ set che [whatis res]
set ind [string first "3d curve" $che]
if {${ind} >= 0} {
#Only variable "res" exists
if { $GoodNbCurv == 1 } {
puts "OK: Curve Number is good!"
renamevar res res_1
}
set ic 1
set AllowRepeate 1
while { $AllowRepeate != 0 } {
set che [whatis res_$ic]
set ind [string first "3d curve" $che]
if {${ind} < 0} {
set AllowRepeate 0
} else {
puts "Error: Curve Number is bad!"
}
set U1 0.0
set U2 0.0
GetRange res
puts "U1 = ${U1}"
puts "U2 = ${U2}"
if {[expr {$U2 - $U1}] < 1.0e-20} {
puts "Error: Wrong curve's range!"
}
xdistcs res s1 ${U1} ${U2} 10 1e-7
xdistcs res s2 ${U1} ${U2} 10 1e-7
} else {
set ic 1
set AllowRepeate 1
while { $AllowRepeate != 0 } {
set che [whatis res_$ic]
set ind [string first "3d curve" $che]
if {${ind} < 0} {
set AllowRepeate 0
} else {
set U1 0.0
set U2 0.0
GetRange res_$ic
puts "U1 = ${U1}"
puts "U2 = ${U2}"
if {[expr {$U2 - $U1}] < 1.0e-20} {
puts "Error: Wrong curve's range!"
}
xdistcs res_$ic s1 ${U1} ${U2} 10 1e-7
xdistcs res_$ic s2 0 1 10 1e-7
incr ic
display res_$ic
bounds res_$ic U1 U2
dval U1
dval U2
if {[dval U2-U1] < 1.0e-20} {
puts "Error: Wrong curve's range!"
}
}
if {[expr {$ic - 1}] == $GoodNbCurv} {
puts "OK: Curve Number is good!"
} else {
puts "Error: Curve Number is bad!"
xdistcs res_$ic s1 U1 U2 10 1.0e-7
xdistcs res_$ic s2 U1 U2 10 1.0e-7
incr ic
}
}
if {[expr {$ic - 1}] == $GoodNbCurv} {
puts "OK: Curve Number is good!"
} else {
puts "Error: Curve Number is bad!"
}

102
tests/bugs/modalg_5/bug25292_26
View File

@ -6,27 +6,6 @@ puts ""
# Face/Face intersection algorithm gives different results for different order of the arguments
#######################################################################
proc GetRange { curve } {
global U1
global U2
set log [uplevel dump $curve]
regexp {Degree +([-0-9.+eE]+), +([-0-9.+eE]+) Poles, +([-0-9.+eE]+)} ${log} full Degree Poles KnotsPoles
puts "Degree=${Degree}"
puts "Poles=${Poles}"
puts "KnotsPoles=${KnotsPoles}"
puts ""
set Knot 1
set exp_string "Knots :\n\n +${Knot} : +(\[-0-9.+eE\]+) +(\[-0-9.+eE\]+)"
regexp ${exp_string} ${log} full U1 Mult1
set Knot ${KnotsPoles}
set exp_string " +${Knot} : +(\[-0-9.+eE\]+) +(\[-0-9.+eE\]+)"
regexp ${exp_string} ${log} full U2 Mult2
}
puts "##############################"
puts "#!!!Search \"Attention\" keyword on this web-page for additional checking!!!"
puts "##############################"
@ -56,58 +35,37 @@ set che [whatis res]
set ind [string first "3d curve" $che]
if {${ind} >= 0} {
#Only variable "res" exists
if { $GoodNbCurv == 1 } {
puts "OK: Curve Number is good!"
renamevar res res_1
}
set ic 1
set AllowRepeate 1
while { $AllowRepeate != 0 } {
set che [whatis res_$ic]
set ind [string first "3d curve" $che]
if {${ind} < 0} {
set AllowRepeate 0
} else {
puts "Error: Curve Number is bad!"
}
set U1 0.0
set U2 0.0
GetRange res
puts "U1 = ${U1}"
puts "U2 = ${U2}"
if {[expr {$U2 - $U1}] < 1.0e-20} {
puts "Error: Wrong curve's range!"
}
xdistcs res s1 ${U1} ${U2} 10 1e-7
xdistcs res s2 ${U1} ${U2} 10 1e-7
} else {
set ic 1
set AllowRepeate 1
while { $AllowRepeate != 0 } {
set che [whatis res_$ic]
set ind [string first "3d curve" $che]
if {${ind} < 0} {
set AllowRepeate 0
} else {
set U1 0.0
set U2 0.0
GetRange res_$ic
puts "U1 = ${U1}"
puts "U2 = ${U2}"
if {[expr {$U2 - $U1}] < 1.0e-20} {
puts "Error: Wrong curve's range!"
}
xdistcs res_$ic s1 ${U1} ${U2} 10 1e-7
xdistcs res_$ic s2 0 1 10 1e-7
incr ic
display res_$ic
bounds res_$ic U1 U2
dval U1
dval U2
if {[dval U2-U1] < 1.0e-20} {
puts "Error: Wrong curve's range!"
}
}
if {[expr {$ic - 1}] == $GoodNbCurv} {
puts "OK: Curve Number is good!"
} else {
puts "Error: Curve Number is bad!"
xdistcs res_$ic s1 U1 U2 10 1.0e-7
xdistcs res_$ic s2 U1 U2 10 1.0e-7
incr ic
}
}
if {[expr {$ic - 1}] == $GoodNbCurv} {
puts "OK: Curve Number is good!"
} else {
puts "Error: Curve Number is bad!"
}

30
tests/bugs/modalg_5/bug25292_31
View File

@ -38,35 +38,23 @@ if {${NbCurv} != ${GoodNbCurv}} {
#-------------
puts ""
mksurface s1 f1
mksurface s2 f2
for {set i 1} {$i <= ${NbCurv}} {incr i} {
set log [dump c_$i]
bounds c_$i U1 U2
puts "U2=[dval U1]"
puts "U2=[dval U2]"
regexp {Degree +([-0-9.+eE]+), +([-0-9.+eE]+) Poles, +([-0-9.+eE]+)} ${log} full Degree Poles KnotsPoles
puts "Degree=${Degree}"
puts "Poles=${Poles}"
puts "KnotsPoles=${KnotsPoles}"
puts ""
set Knot 1
set exp_string "Knots :\n\n +${Knot} : +(\[-0-9.+eE\]+) +(\[-0-9.+eE\]+)"
regexp ${exp_string} ${log} full U1 Mult1
set Knot ${KnotsPoles}
set exp_string " +${Knot} : +(\[-0-9.+eE\]+) +(\[-0-9.+eE\]+)"
regexp ${exp_string} ${log} full U2 Mult2
puts "U1=${U1}"
puts "U2=${U2}"
if {[expr {$U2 - $U1}] < 1.0e-20} {
if {[dval U2-U1] < 1.0e-20} {
puts "Error: Wrong curve's range!"
}
xdistcs c_$i s1 ${U1} ${U2} 10 1e-7 1e-8
xdistcs c_$i s2 ${U1} ${U2} 10 1e-7 1e-8
xdistcs c_$i s1 U1 U2 10 ${Toler}
xdistcs c_$i s2 U1 U2 10 ${Toler}
}
smallview

30
tests/bugs/modalg_5/bug25292_32
View File

@ -38,35 +38,23 @@ if {${NbCurv} != ${GoodNbCurv}} {
#-------------
puts ""
mksurface s1 f1
mksurface s2 f2
for {set i 1} {$i <= ${NbCurv}} {incr i} {
set log [dump c_$i]
bounds c_$i U1 U2
puts "U2=[dval U1]"
puts "U2=[dval U2]"
regexp {Degree +([-0-9.+eE]+), +([-0-9.+eE]+) Poles, +([-0-9.+eE]+)} ${log} full Degree Poles KnotsPoles
puts "Degree=${Degree}"
puts "Poles=${Poles}"
puts "KnotsPoles=${KnotsPoles}"
puts ""
set Knot 1
set exp_string "Knots :\n\n +${Knot} : +(\[-0-9.+eE\]+) +(\[-0-9.+eE\]+)"
regexp ${exp_string} ${log} full U1 Mult1
set Knot ${KnotsPoles}
set exp_string " +${Knot} : +(\[-0-9.+eE\]+) +(\[-0-9.+eE\]+)"
regexp ${exp_string} ${log} full U2 Mult2
puts "U1=${U1}"
puts "U2=${U2}"
if {[expr {$U2 - $U1}] < 1.0e-20} {
if {[dval U2-U1] < 1.0e-20} {
puts "Error: Wrong curve's range!"
}
xdistcs c_$i s1 ${U1} ${U2} 10 1e-7 1e-8
xdistcs c_$i s2 ${U1} ${U2} 10 1e-7 1e-8
xdistcs c_$i s1 U1 U2 10 ${Toler}
xdistcs c_$i s2 U1 U2 10 ${Toler}
}
smallview

42
tests/bugs/modalg_5/bug25292_33
View File

@ -28,37 +28,39 @@ intersect res s1 s2
set che [whatis res]
set ind [string first "3d curve" $che]
set AllowRepeate 1
set ic 1
if {${ind} >= 0} {
#Only variable "res" exists
renamevar res res_1
}
set ic 1
set AllowRepeate 1
while { $AllowRepeate != 0 } {
set che [whatis res_$ic]
set ind [string first "3d curve" $che]
if {${ind} < 0} {
set AllowRepeate 0
break
} else {
display res_$ic
bounds res_$ic U1 U2
dval U1
dval U2
if {[dval U2-U1] < 1.0e-20} {
puts "Error: Wrong curve's range!"
}
xdistcs res_$ic s1 U1 U2 10 1.0e-7
xdistcs res_$ic s2 U1 U2 10 1.0e-7
incr ic
}
bounds res_$ic U1 U2
if {[dval (U2-U1)] < 1.0e-20} {
puts "Error: Wrong curve's range!"
}
xdistcs res_$ic s1 U1 U2 10 1e-6 1e-7
xdistcs res_$ic s2 U1 U2 10 1e-6 1e-7
incr ic
}
if {[expr {$ic - 1}] == $GoodNbCurv} {
puts "OK: Good number of intersection curve(s) obtained by Surface/Surface Intersection Algorithm"
puts "OK: Curve Number is good!"
} else {
puts "Error: $GoodNbCurv intersection curve(s) expected but [expr {$ic - 1}] found"
}
puts "Error: Curve Number is bad!"
}

42
tests/bugs/modalg_5/bug25292_34
View File

@ -29,37 +29,39 @@ intersect res s2 s1
set che [whatis res]
set ind [string first "3d curve" $che]
set AllowRepeate 1
set ic 1
if {${ind} >= 0} {
#Only variable "res" exists
renamevar res res_1
}
set ic 1
set AllowRepeate 1
while { $AllowRepeate != 0 } {
set che [whatis res_$ic]
set ind [string first "3d curve" $che]
if {${ind} < 0} {
set AllowRepeate 0
break
} else {
display res_$ic
bounds res_$ic U1 U2
dval U1
dval U2
if {[dval U2-U1] < 1.0e-20} {
puts "Error: Wrong curve's range!"
}
xdistcs res_$ic s1 U1 U2 10 1.0e-7
xdistcs res_$ic s2 U1 U2 10 1.0e-7
incr ic
}
bounds res_$ic U1 U2
if {[dval (U2-U1)] < 1.0e-20} {
puts "Error: Wrong curve's range!"
}
xdistcs res_$ic s1 U1 U2 10 1e-6 1e-7
xdistcs res_$ic s2 U1 U2 10 1e-6 1e-7
incr ic
}
if {[expr {$ic - 1}] == $GoodNbCurv} {
puts "OK: Good number of intersection curve(s) obtained by Surface/Surface Intersection Algorithm"
puts "OK: Curve Number is good!"
} else {
puts "Error: $GoodNbCurv intersection curve(s) expected but [expr {$ic - 1}] found"
}
puts "Error: Curve Number is bad!"
}

21
tests/bugs/modalg_5/bug25292_35
View File

@ -37,8 +37,7 @@ set che [whatis res]
set ind [string first "3d curve" $che]
if {${ind} >= 0} {
#Only variable "res" exists
copy res res_1
renamevar res res_1
}
set ic 1
@ -49,26 +48,24 @@ while { $AllowRepeate != 0 } {
if {${ind} < 0} {
set AllowRepeate 0
} else {
set le [length res_$ic]
regexp "The length res_$ic is +(\[-0-9.+eE\]+)" ${le} full ll
if { $ll < 1.0e-7 } {
puts "Error: Curve is too small!"
}
display res_$ic
bounds res_$ic U1 U2
if {[dval U2-U1] < 1.0e-9} {
dval U1
dval U2
if {[dval U2-U1] < 1.0e-20} {
puts "Error: Wrong curve's range!"
}
xdistcs res_$ic s1 U1 U2 10 1e-7
xdistcs res_$ic s2 U1 U2 10 1e-7
xdistcs res_$ic s1 U1 U2 10 1.0e-7
xdistcs res_$ic s2 U1 U2 10 1.0e-7
incr ic
}
}
if {[expr {$ic - 1}] == $GoodNbCurv} {
puts "OK: Curve Number is good!"
} else {

16
tests/bugs/modalg_5/bug25292_36
View File

@ -37,8 +37,7 @@ set che [whatis res]
set ind [string first "3d curve" $che]
if {${ind} >= 0} {
#Only variable "res" exists
copy res res_1
renamevar res res_1
}
set ic 1
@ -49,19 +48,24 @@ while { $AllowRepeate != 0 } {
if {${ind} < 0} {
set AllowRepeate 0
} else {
display res_$ic
bounds res_$ic U1 U2
if {[dval U2-U1] < 1.0e-9} {
dval U1
dval U2
if {[dval U2-U1] < 1.0e-20} {
puts "Error: Wrong curve's range!"
}
xdistcs res_$ic s1 U1 U2 10 1e-7
xdistcs res_$ic s2 U1 U2 10 1e-7
xdistcs res_$ic s1 U1 U2 10 1.0e-7
xdistcs res_$ic s2 U1 U2 10 1.0e-7
incr ic
}
}
if {[expr {$ic - 1}] == $GoodNbCurv} {
puts "OK: Curve Number is good!"
} else {

23
tests/bugs/modalg_6/bug26310_3
View File

@ -9,10 +9,21 @@ puts ""
restore [locate_data_file OCC26310-b1.brep] b1
restore [locate_data_file OCC26310-b2.brep] b2
bop b1 b2
bclearobjects
bcleartools
baddobjects b1
baddtools b2
bfillds
bopcut res1
boptuc res2
# SECTION
bbop rr 4
# CUT 1-2
bbop res1 2
# CUT 2-1
bbop res2 3
checkshape res1
checkshape res2
@ -28,9 +39,13 @@ if { [string compare -nocase $log2 "Shape(s) seem(s) to be valid for BOP.\n"] }
puts "ERROR. res2 is not valid for BOP"
}
checknbshapes res1 -wire 6 -face 6 -shell 1 -solid 1 -t
checknbshapes res2 -wire 6 -face 6 -shell 1 -solid 1 -t
smallview
donly res1
donly rr
fit
donly res1
xwd ${imagedir}/${casename}_1.png
donly res2
fit

37
tests/bugs/modalg_6/bug26310_4
View File

@ -9,10 +9,21 @@ puts ""
restore [locate_data_file OCC26310-b1.brep] b1
restore [locate_data_file OCC26310-b2.brep] b2
bop b2 b1
bclearobjects
bcleartools
baddobjects b2
baddtools b1
bfillds
bopcut res1
boptuc res2
# SECTION
bbop rr 4
# CUT 1-2
bbop res1 2
# CUT 2-1
bbop res2 3
checkshape res1
checkshape res2
@ -20,26 +31,22 @@ checkshape res2
set log1 [bopargcheck res1 #F]
set log2 [bopargcheck res2 #F]
if { [string first "Faulties for FIRST shape found : 2" $log1] >= 0 } {
puts "ERROR in bopargcheck res1"
if { [string compare -nocase $log1 "Shape(s) seem(s) to be valid for BOP.\n"] } {
puts "ERROR. res1 is not valid for BOP"
}
if { [string first "Shapes with Continuity C0 : YES Cases(2) Total shapes(2)" $log1] >= 0 } {
puts "ERROR. res1 with continuity C0."
if { [string compare -nocase $log2 "Shape(s) seem(s) to be valid for BOP.\n"] } {
puts "ERROR. res2 is not valid for BOP"
}
if { [string first "Faulties for FIRST shape found : 2" $log2] >= 0 } {
puts "ERROR in bopargcheck res2"
}
if { [string first "Shapes with Continuity C0 : YES Cases(2) Total shapes(2)" $log2] >= 0 } {
puts "ERROR. res2 with continuity C0."
}
checknbshapes res1 -wire 6 -face 6 -shell 1 -solid 1 -t
checknbshapes res2 -wire 6 -face 6 -shell 1 -solid 1 -t
smallview
donly res1
fit
xwd ${imagedir}/${casename}_1.png
donly res2
donly rr
fit
donly res2
xwd ${imagedir}/${casename}_2.png

18
tests/bugs/modalg_6/bug27310_1
View File

@ -6,8 +6,11 @@ puts ""
# Huge tolerance obtained in the result of intersection of two cylindrical faces
#################################################
# Number of intersection curves cannot be subject to anything (indeed, output result can be empty).
# The main reason of the bug #27310 was a HUGE TOLERANCE VALUE (TolReached > 10).
# See test "bugs moddata_2 bug496" in case of doubt.
set ExpTol 1.0e-7
set GoodNbCurv 2
restore [locate_data_file OCC496a.brep] a
restore [locate_data_file OCC496b.brep] b
@ -19,15 +22,4 @@ set log [bopcurves a_8 b_2 -2d]
regexp {Tolerance Reached=+([-0-9.+eE]+)\n+([-0-9.+eE]+)} ${log} full Toler NbCurv
if {${NbCurv} != ${GoodNbCurv}} {
puts "Error: Number of curves is bad!"
}
checkreal TolReached $Toler $ExpTol 0.0 0.1
smallview
don c_*
fit
disp a_8 b_2
checkview -screenshot -2d -path ${imagedir}/${test_image}.png
checkreal TolReached $Toler $ExpTol 0.0 0.1

20
tests/bugs/modalg_6/bug27310_2
View File

@ -6,8 +6,11 @@ puts ""
# Huge tolerance obtained in the result of intersection of two cylindrical faces
#################################################
set ExpTol 6.9230965382090094e-006
set GoodNbCurv 2
# Number of intersection curves cannot be subject to anything (indeed, output result can be empty).
# The main reason of the bug #27310 was a HUGE TOLERANCE VALUE (TolReached > 10).
# See test "bugs moddata_2 bug496" in case of doubt.
set ExpTol 1.3609186093470008e-005
restore [locate_data_file OCC496a.brep] a
restore [locate_data_file OCC496b.brep] b
@ -19,15 +22,4 @@ set log [bopcurves a_10 b_4 -2d]
regexp {Tolerance Reached=+([-0-9.+eE]+)\n+([-0-9.+eE]+)} ${log} full Toler NbCurv
if {${NbCurv} != ${GoodNbCurv}} {
puts "Error: Number of curves is bad!"
}
checkreal TolReached $Toler $ExpTol 0.0 0.1
smallview
don c_*
fit
disp a_10 b_4
checkview -screenshot -2d -path ${imagedir}/${test_image}.png
checkreal TolReached $Toler $ExpTol 0.0 0.1

16
tests/bugs/modalg_6/bug27856_2
View File

@ -23,7 +23,7 @@ regexp {Tolerance Reached=+([-0-9.+eE]+)\n+([-0-9.+eE]+)} [bopcurves b_1_2 b_2_2
if {${NbCurv} != 1} {
puts "Error: Number of curves is bad!"
}
checkreal TolReached $Toler 0.00026943844817627679 0.0 1.0e-3
checkreal TolReached $Toler 0.00026207823091004516 0.0 1.0e-3
# ----
@ -33,7 +33,7 @@ regexp {Tolerance Reached=+([-0-9.+eE]+)\n+([-0-9.+eE]+)} [bopcurves b_1_4 b_2_4
if {${NbCurv} != 1} {
puts "Error: Number of curves is bad!"
}
checkreal TolReached $Toler 6.5039065434503992e-005 0.0 1.0e-2
checkreal TolReached $Toler 6.5053102894636701e-005 0.0 1.0e-2
# ----
@ -50,7 +50,7 @@ regexp {Tolerance Reached=+([-0-9.+eE]+)\n+([-0-9.+eE]+)} [bopcurves b_3_2 b_4_2
if {${NbCurv} != 1} {
puts "Error: Number of curves is bad!"
}
checkreal TolReached $Toler 0.00030603795647549098 0.0 1.0e-3
checkreal TolReached $Toler 0.00029706239430643614 0.0 1.0e-3
# ----
@ -60,7 +60,7 @@ regexp {Tolerance Reached=+([-0-9.+eE]+)\n+([-0-9.+eE]+)} [bopcurves b_3_4 b_4_4
if {${NbCurv} != 1} {
puts "Error: Number of curves is bad!"
}
checkreal TolReached $Toler 0.00029242900088525842 0.0 1.0e-3
checkreal TolReached $Toler 0.00029242389138280588 0.0 1.0e-3
# ----
@ -77,7 +77,7 @@ regexp {Tolerance Reached=+([-0-9.+eE]+)\n+([-0-9.+eE]+)} [bopcurves b_5_2 b_6_2
if {${NbCurv} != 1} {
puts "Error: Number of curves is bad!"
}
checkreal TolReached $Toler 2.0312181042800029e-005 0.0 1.0e-2
checkreal TolReached $Toler 1.4980089259007279e-005 0.0 1.0e-2
# ----
@ -87,7 +87,7 @@ regexp {Tolerance Reached=+([-0-9.+eE]+)\n+([-0-9.+eE]+)} [bopcurves b_5_4 b_6_4
if {${NbCurv} != 1} {
puts "Error: Number of curves is bad!"
}
checkreal TolReached $Toler 0.00023415774730871651 0.0 1.0e-3
checkreal TolReached $Toler 0.00023417493528435788 0.0 1.0e-3
# ----
@ -104,7 +104,7 @@ regexp {Tolerance Reached=+([-0-9.+eE]+)\n+([-0-9.+eE]+)} [bopcurves b_7_2 b_8_2
if {${NbCurv} != 1} {
puts "Error: Number of curves is bad!"
}
checkreal TolReached $Toler 0.00028209392756607551 0.0 1.0e-3
checkreal TolReached $Toler 0.00027445924390073518 0.0 1.0e-3
# ----
@ -114,5 +114,5 @@ regexp {Tolerance Reached=+([-0-9.+eE]+)\n+([-0-9.+eE]+)} [bopcurves b_7_4 b_8_4
if {${NbCurv} != 1} {
puts "Error: Number of curves is bad!"
}
checkreal TolReached $Toler 2.497244318171703e-005 0.0 1.0e-2
checkreal TolReached $Toler 1.867918118939262e-005 0.0 1.0e-2

2
tests/bugs/modalg_6/bug28009_2
View File

@ -7,7 +7,7 @@ puts ""
#######################################################################
set NbCurvGood 1
set ExpToler 9.0002189481237598e-008
set ExpToler 7.1928004468800293e-008
restore [locate_data_file bug28009_shape.brep] a

45
tests/bugs/modalg_6/bug28222_1 Normal file
View File

@ -0,0 +1,45 @@
puts "================"
puts "OCC28222"
puts "================"
puts ""
#######################################################################
# Intersection of two cylinders fails
#######################################################################
dsetsignal 1
set GoodNbCurv 4
foreach c [directory result*] {
unset $c
}
restore [locate_data_file bug28222_s1_cyl_read_d2.draw] s1
restore [locate_data_file bug28222_s2_cyl_read_d2.draw] s2
intersect result s1 s2
foreach c [directory result*] {
bounds $c U1 U2
if {[dval U2-U1] < 1.0e-9} {
puts "Error: Wrong curve's range!"
}
xdistcs $c s1 U1 U2 10 2.0e-7
xdistcs $c s2 U1 U2 10 2.0e-7
}
set NbCurv [llength [directory result*]]
if { $NbCurv == $GoodNbCurv } {
puts "OK: Number of curves is good!"
} else {
puts "Error: $GoodNbCurv is expected but $NbCurv is found!"
}
smallview
don result*
fit
disp s1 s2
checkview -screenshot -2d -path ${imagedir}/${test_image}.png

45
tests/bugs/modalg_6/bug28222_2 Normal file
View File

@ -0,0 +1,45 @@
puts "================"
puts "OCC28222"
puts "================"
puts ""
#######################################################################
# Intersection of two cylinders fails
#######################################################################
dsetsignal 1
set GoodNbCurv 4
foreach c [directory result*] {
unset $c
}
cylinder s1 -35 13.3706576198285 30.5814570420266 0 -0.258819045102521 -0.965925826289068 0 0.965925826289068 -0.258819045102521 11
cylinder s2 0 0 0 1 0 0 0 0 -1 16.5
intersect result s1 s2
foreach c [directory result*] {
bounds $c U1 U2
if {[dval U2-U1] < 1.0e-9} {
puts "Error: Wrong curve's range!"
}
xdistcs $c s1 U1 U2 10 2.0e-7
xdistcs $c s2 U1 U2 10 2.0e-7
}
set NbCurv [llength [directory result*]]
if { $NbCurv == $GoodNbCurv } {
puts "OK: Number of curves is good!"
} else {
puts "Error: $GoodNbCurv is expected but $NbCurv is found!"
}
smallview
don result*
fit
disp s1 s2
checkview -screenshot -2d -path ${imagedir}/${test_image}.png

46
tests/bugs/modalg_6/bug28222_3 Normal file
View File

@ -0,0 +1,46 @@
puts "================"
puts "OCC28222"
puts "================"
puts ""
#######################################################################
# Intersection of two cylinders fails
#######################################################################
dsetsignal 1
set GoodNbCurv 2
foreach c [directory result*] {
unset $c
}
cylinder s1 -9 -5 -2.2058 0 -1 0 0.001
cylinder s2 0 0 -2.2058 0 0 -1 9
intersect result s1 s2
foreach c [directory result*] {
bounds $c U1 U2
if {[dval U2-U1] < 1.0e-9} {
puts "Error: Wrong curve's range!"
}
xdistcs $c s1 U1 U2 10 2.0e-7
xdistcs $c s2 U1 U2 10 2.0e-7
}
set NbCurv [llength [directory result*]]
if { $NbCurv == $GoodNbCurv } {
puts "OK: Number of curves is good!"
} else {
puts "Error: $GoodNbCurv is expected but $NbCurv is found!"
}
smallview
don result*
fit
don s1 s2
disp result*
checkview -screenshot -2d -path ${imagedir}/${test_image}.png

32
tests/bugs/modalg_6/bug28706 Normal file
View File

@ -0,0 +1,32 @@
puts "================"
puts "OCC28706"
puts "================"
puts ""
#######################################################################
# Incomplete result of section operation between attached shapes
#######################################################################
dsetsignal 1
# Before the fix, section curve was incomplete
restore [locate_data_file bug28706_ar_shape.brep] s1
restore [locate_data_file bug28706_Prism.brep] s2
bsection result s1 s2
regexp {nb alone Vertices : ([-0-9.+eE]+)} [checksection result] full nbv
if { $nbv != 0 } {
puts "Error : Section is incorrect"
} else {
puts "Section is correct"
}
checkprops result -l 6.16832
smallview
don result
fit
checkview -screenshot -2d -path ${imagedir}/${test_image}.png

5
tests/bugs/moddata_2/bug235
View File

@ -36,6 +36,9 @@ if { $nb_result != 2 } {
}
}
checkview -display result -2d -path ${imagedir}/${test_image}.png
smallview
don result*
fit
checkview -screenshot -2d -path ${imagedir}/${test_image}.png

35
tests/perf/modalg/bug26310_1
View File

@ -6,27 +6,32 @@ puts ""
# Very slow boolean cut operations on cylinders
#################################################
if { [regexp {Debug mode} [dversion]] } {
set max_time 0.3
} else {
set max_time 0.15
}
set ExpTol1 3.2300230820477792e-007
set ExpTol2 3.2198007889220219e-007
set maxToler 1.5e-5
set GoodNbCurv 4
restore [locate_data_file OCC26310-b1.brep] b1
restore [locate_data_file OCC26310-b2.brep] b2
restore [locate_data_file OCC26310-b2.brep] b2
explode b1 f
explode b2 f
dchrono cr restart
set log1 [bopcurves b1_1 b2_1 -2d]
dchrono cr stop counter bopcurves
set log [bopcurves b1_1 b2_1 -2d]
regexp {Tolerance Reached=+([-0-9.+eE]+)\n+([-0-9.+eE]+)} ${log} full Toler NbCurv
regexp {Tolerance Reached=+([-0-9.+eE]+)} ${log1} full Toler
puts "TolReached = $Toler"
checkreal ToleranceReached ${Toler} ${ExpTol1} 0.0 0.01
if {${NbCurv} != ${GoodNbCurv}} {
puts "Error: Number of curves is bad!"
}
set log [bopcurves b2_1 b1_1 -2d]
regexp {Tolerance Reached=+([-0-9.+eE]+)\n+([-0-9.+eE]+)} ${log} full Toler NbCurv
checkreal ToleranceReached ${Toler} ${ExpTol2} 0.0 0.01
if {${NbCurv} != ${GoodNbCurv}} {
puts "Error: Number of curves is bad!"
}
if { $Toler > $maxToler } {
puts "Error: Tolerance is too big ($Toler > $maxToler)"
}