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

0032701: Modeling Algorithms - 2d curve has bending near the degenerated edge of the face

Browse Source 
ApproxInt_Approx, ApproxInt_KnotTools, BRepApprox_Approx,
GeomInt_IntSS, IntTools_FaceFace:
  Analysis of curvature is added for adjusting ParametrizationType

IntPatch_Intersection.cxx - adding methods for estimation of UV max step depending on used surfaces

GeomInt_IntSS.cxx, IntTools_FaceFace.cxx - using methods for max step estimation

Approx_SameParameter.cxx - adding control against big values.

BOPAlgo_PaveFiller_6.cxx - adjusting position of faces before intersection
This commit is contained in:
ifv 2021-12-02 17:02:17 +03:00 committed by smoskvin
parent 5614b1369a
commit 9eee5ab7e4
22 changed files with 776 additions and 135 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
src/Approx/Approx_SameParameter.cxx
View File

@ -166,8 +166,17 @@ static Standard_Real ComputeTolReached(const Handle(Adaptor3d_Curve)& c3d,
{
Standard_Real t = IntToReal(i) / IntToReal(nbp);
Standard_Real u = first * (1.0 - t) + last * t;
gp_Pnt Pc3d = c3d->Value(u);
gp_Pnt Pcons = cons.Value(u);
gp_Pnt Pc3d, Pcons;
try
{
Pc3d = c3d->Value(u);
Pcons = cons.Value(u);
}
catch (Standard_Failure const&)
{
d2 = Precision::Infinite();
break;
}
if (Precision::IsInfinite(Pcons.X()) ||
Precision::IsInfinite(Pcons.Y()) ||
Precision::IsInfinite(Pcons.Z()))

2
src/ApproxInt/ApproxInt_Approx.gxx
View File

@ -91,7 +91,7 @@ static void ComputeTrsf2d(const Handle(TheWLine)& theline,
//function : Parameters
//purpose :
//=======================================================================
static void Parameters(const ApproxInt_TheMultiLine& Line,
void ApproxInt_Approx::Parameters(const ApproxInt_TheMultiLine& Line,
const Standard_Integer firstP,
const Standard_Integer lastP,
const Approx_ParametrizationType Par,

330
src/ApproxInt/ApproxInt_KnotTools.cxx
View File

@ -22,6 +22,8 @@
#include <Precision.hxx>
#include <NCollection_Vector.hxx>
#include <TColgp_Array1OfPnt.hxx>
#include <GeomInt_WLApprox.hxx>
#include <GeomInt_TheMultiLineOfWLApprox.hxx>
// (Sqrt(5.0) - 1.0) / 4.0
//static const Standard_Real aSinCoeff = 0.30901699437494742410229341718282;
@ -84,6 +86,94 @@ static Standard_Real EvalCurv(const Standard_Real dim,
return curv;
}
//=======================================================================
//function : BuildCurvature
//purpose :
//=======================================================================
void ApproxInt_KnotTools::BuildCurvature(
const NCollection_LocalArray<Standard_Real>& theCoords,
const Standard_Integer theDim,
const math_Vector& thePars,
TColStd_Array1OfReal& theCurv,
Standard_Real& theMaxCurv)
{
// Arrays are allocated for max theDim = 7: 1 3d curve + 2 2d curves.
Standard_Real Val[21], Par[3], Res[21];
Standard_Integer i, j, m, ic;
Standard_Integer dim = theDim;
//
theMaxCurv = 0.;
if (theCurv.Length() < 3)
{
theCurv.Init(0.);
return;
}
i = theCurv.Lower();
for (j = 0; j < 3; ++j)
{
Standard_Integer k = i + j;
ic = (k - theCurv.Lower()) * dim;
Standard_Integer l = dim*j;
for (m = 0; m < dim; ++m)
{
Val[l + m] = theCoords[ic + m];
}
Par[j] = thePars(k);
}
PLib::EvalLagrange(Par[0], 2, 2, dim, *Val, *Par, *Res);
//
theCurv(i) = EvalCurv(dim, &Res[dim], &Res[2 * dim]);
//
if (theCurv(i) > theMaxCurv)
{
theMaxCurv = theCurv(i);
}
//
for (i = theCurv.Lower() + 1; i < theCurv.Upper(); ++i)
{
for (j = 0; j < 3; ++j)
{
Standard_Integer k = i + j - 1;
ic = (k - theCurv.Lower()) * dim;
Standard_Integer l = dim*j;
for (m = 0; m < dim; ++m)
{
Val[l + m] = theCoords[ic + m];
}
Par[j] = thePars(k);
}
PLib::EvalLagrange(Par[1], 2, 2, dim, *Val, *Par, *Res);
//
theCurv(i) = EvalCurv(dim, &Res[dim], &Res[2 * dim]);
if (theCurv(i) > theMaxCurv)
{
theMaxCurv = theCurv(i);
}
}
//
i = theCurv.Upper();
for (j = 0; j < 3; ++j)
{
Standard_Integer k = i + j - 2;
ic = (k - theCurv.Lower()) * dim;
Standard_Integer l = dim*j;
for (m = 0; m < dim; ++m)
{
Val[l + m] = theCoords[ic + m];
}
Par[j] = thePars(k);
}
PLib::EvalLagrange(Par[2], 2, 2, dim, *Val, *Par, *Res);
//
theCurv(i) = EvalCurv(dim, &Res[dim], &Res[2 * dim]);
if (theCurv(i) > theMaxCurv)
{
theMaxCurv = theCurv(i);
}
}
//=======================================================================
//function : ComputeKnotInds
//purpose :
@ -96,75 +186,10 @@ void ApproxInt_KnotTools::ComputeKnotInds(const NCollection_LocalArray<Standard_
//I: Create discrete curvature.
NCollection_Sequence<Standard_Integer> aFeatureInds;
TColStd_Array1OfReal aCurv(thePars.Lower(), thePars.Upper());
// Arrays are allocated for max theDim = 7: 1 3d curve + 2 2d curves.
Standard_Real Val[21], Par[3], Res[21];
Standard_Integer i, j, m, ic;
Standard_Real aMaxCurv = 0.;
Standard_Integer dim = theDim;
//
i = aCurv.Lower();
for(j = 0; j < 3; ++j)
{
Standard_Integer k = i+j;
ic = (k - aCurv.Lower()) * dim;
Standard_Integer l = dim*j;
for(m = 0; m < dim; ++m)
{
Val[l + m] = theCoords[ic + m];
}
Par[j] = thePars(k);
}
PLib::EvalLagrange(Par[0], 2, 2, dim, *Val, *Par, *Res);
//
aCurv(i) = EvalCurv(dim, &Res[dim], &Res[2*dim]);
//
if(aCurv(i) > aMaxCurv)
{
aMaxCurv = aCurv(i);
}
//
for(i = aCurv.Lower()+1; i < aCurv.Upper(); ++i)
{
for(j = 0; j < 3; ++j)
{
Standard_Integer k = i+j-1;
ic = (k - aCurv.Lower()) * dim;
Standard_Integer l = dim*j;
for(m = 0; m < dim; ++m)
{
Val[l + m] = theCoords[ic + m];
}
Par[j] = thePars(k);
}
PLib::EvalLagrange(Par[1], 2, 2, dim, *Val, *Par, *Res);
//
aCurv(i) = EvalCurv(dim, &Res[dim], &Res[2*dim]);
if(aCurv(i) > aMaxCurv)
{
aMaxCurv = aCurv(i);
}
}
//
i = aCurv.Upper();
for(j = 0; j < 3; ++j)
{
Standard_Integer k = i+j-2;
ic = (k - aCurv.Lower()) * dim;
Standard_Integer l = dim*j;
for(m = 0; m < dim; ++m)
{
Val[l + m] = theCoords[ic + m];
}
Par[j] = thePars(k);
}
PLib::EvalLagrange(Par[2], 2, 2, dim, *Val, *Par, *Res);
//
aCurv(i) = EvalCurv(dim, &Res[dim], &Res[2*dim]);
if(aCurv(i) > aMaxCurv)
{
aMaxCurv = aCurv(i);
}
BuildCurvature(theCoords, theDim, thePars, aCurv, aMaxCurv);
//
Standard_Integer i, j, dim = theDim;
#ifdef APPROXINT_KNOTTOOLS_DEBUG
std::cout << "Discrete curvature array is" << std::endl;
for(i = aCurv.Lower(); i <= aCurv.Upper(); ++i)
@ -623,3 +648,172 @@ void ApproxInt_KnotTools::BuildKnots(const TColgp_Array1OfPnt& thePntsXYZ,
#endif
}
//=======================================================================
//function : MaxParamRatio
//purpose :
//=======================================================================
static Standard_Real MaxParamRatio(const math_Vector& thePars)
{
Standard_Integer i;
Standard_Real aMaxRatio = 0.;
//
for (i = thePars.Lower() + 1; i < thePars.Upper(); ++i)
{
Standard_Real aRat = (thePars(i + 1) - thePars(i)) / (thePars(i) - thePars(i - 1));
if (aRat < 1.)
aRat = 1. / aRat;
aMaxRatio = Max(aMaxRatio, aRat);
}
return aMaxRatio;
}
//=======================================================================
//function : DefineParType
//purpose :
//=======================================================================
Approx_ParametrizationType ApproxInt_KnotTools::DefineParType(
const Handle(IntPatch_WLine)& theWL,
const Standard_Integer theFpar, const Standard_Integer theLpar,
const Standard_Boolean theApproxXYZ,
const Standard_Boolean theApproxU1V1,
const Standard_Boolean theApproxU2V2
)
{
if (theLpar - theFpar == 1)
return Approx_IsoParametric;
const Standard_Integer nbp3d = theApproxXYZ ? 1 : 0,
nbp2d = (theApproxU1V1 ? 1 : 0) + (theApproxU2V2 ? 1 : 0);
GeomInt_TheMultiLineOfWLApprox aTestLine(theWL, nbp3d, nbp2d, theApproxU1V1, theApproxU2V2,
0., 0., 0., 0., 0., 0., 0., theApproxU1V1, theFpar, theLpar);
TColgp_Array1OfPnt aTabPnt3d(1, Max(1, nbp3d));
TColgp_Array1OfPnt2d aTabPnt2d(1, Max(1, nbp2d));
TColgp_Array1OfPnt aPntXYZ(theFpar, theLpar);
TColgp_Array1OfPnt2d aPntU1V1(theFpar, theLpar);
TColgp_Array1OfPnt2d aPntU2V2(theFpar, theLpar);
Standard_Integer i, j;
for (i = theFpar; i <= theLpar; ++i)
{
if (nbp3d != 0 && nbp2d != 0) aTestLine.Value(i, aTabPnt3d, aTabPnt2d);
else if (nbp2d != 0) aTestLine.Value(i, aTabPnt2d);
else if (nbp3d != 0) aTestLine.Value(i, aTabPnt3d);
//
if (nbp3d > 0)
{
aPntXYZ(i) = aTabPnt3d(1);
}
if (nbp2d > 1)
{
aPntU1V1(i) = aTabPnt2d(1);
aPntU2V2(i) = aTabPnt2d(2);
}
else if (nbp2d > 0)
{
if (theApproxU1V1)
{
aPntU1V1(i) = aTabPnt2d(1);
}
else
{
aPntU2V2(i) = aTabPnt2d(1);
}
}
}
Standard_Integer aDim = 0;
if (theApproxXYZ)
aDim += 3;
if (theApproxU1V1)
aDim += 2;
if (theApproxU2V2)
aDim += 2;
Standard_Integer aLength = theLpar - theFpar + 1;
NCollection_LocalArray<Standard_Real> aCoords(aLength * aDim);
for (i = theFpar; i <= theLpar; ++i)
{
j = (i - theFpar) * aDim;
if (theApproxXYZ)
{
aCoords[j] = aPntXYZ.Value(i).X();
++j;
aCoords[j] = aPntXYZ.Value(i).Y();
++j;
aCoords[j] = aPntXYZ.Value(i).Z();
++j;
}
if (theApproxU1V1)
{
aCoords[j] = aPntU1V1.Value(i).X();
++j;
aCoords[j] = aPntU1V1.Value(i).Y();
++j;
}
if (theApproxU2V2)
{
aCoords[j] = aPntU2V2.Value(i).X();
++j;
aCoords[j] = aPntU2V2.Value(i).Y();
++j;
}
}
//Analysis of curvature
const Standard_Real aCritRat = 500.;
const Standard_Real aCritParRat = 100.;
math_Vector aPars(theFpar, theLpar);
Approx_ParametrizationType aParType = Approx_ChordLength;
GeomInt_WLApprox::Parameters(aTestLine, theFpar, theLpar, aParType, aPars);
TColStd_Array1OfReal aCurv(aPars.Lower(), aPars.Upper());
Standard_Real aMaxCurv = 0.;
BuildCurvature(aCoords, aDim, aPars, aCurv, aMaxCurv);
if (aMaxCurv < Precision::PConfusion()
|| Precision::IsPositiveInfinite(aMaxCurv))
{
//Linear case
return aParType;
}
Standard_Real aMidCurv = 0.;
Standard_Real eps = Epsilon(1.);
j = 0;
for (i = aCurv.Lower(); i <= aCurv.Upper(); ++i)
{
if (aMaxCurv - aCurv(i) < eps)
{
continue;
}
++j;
aMidCurv += aCurv(i);
}
if (j > 1)
{
aMidCurv /= j;
}
if (aMidCurv <= eps)
return aParType;
Standard_Real aRat = aMaxCurv / aMidCurv;
if (aRat > aCritRat)
{
if(aRat > 5.*aCritRat)
aParType = Approx_Centripetal;
else
{
Standard_Real aParRat = MaxParamRatio(aPars);
if (aParRat > aCritParRat)
aParType = Approx_Centripetal;
}
}
return aParType;
}

19
src/ApproxInt/ApproxInt_KnotTools.hxx
View File

@ -35,12 +35,15 @@
#include <TColgp_Array1OfPnt.hxx>
#include <TColStd_Array1OfReal.hxx>
#include <NCollection_LocalArray.hxx>
#include <Approx_ParametrizationType.hxx>
class math_Vector;
template <class A> class NCollection_Sequence;
template <class A> class NCollection_List;
template <class A> class NCollection_Vector;
class IntPatch_WLine;
// Corresponds for debug information output.
// Debug information is also printed when OCCT_DEBUG defined.
//#define APPROXINT_KNOTTOOLS_DEBUG
@ -81,6 +84,22 @@ public:
const Standard_Integer theMinNbPnts,
NCollection_Vector<Standard_Integer>& theKnots);
//! Builds discrete curvature
Standard_EXPORT static void BuildCurvature(
const NCollection_LocalArray<Standard_Real>& theCoords,
const Standard_Integer theDim,
const math_Vector& thePars,
TColStd_Array1OfReal& theCurv,
Standard_Real& theMaxCurv);
//! Defines preferable parametrization type for theWL
Standard_EXPORT static Approx_ParametrizationType DefineParType(const Handle(IntPatch_WLine)& theWL,
const Standard_Integer theFpar, const Standard_Integer theLpar,
const Standard_Boolean theApproxXYZ,
const Standard_Boolean theApproxU1V1,
const Standard_Boolean theApproxU2V2);
private:
//! Compute indices of knots:

107
src/BOPAlgo/BOPAlgo_PaveFiller_6.cxx
View File

@ -278,6 +278,35 @@ void BOPAlgo_PaveFiller::PerformFF(const Message_ProgressRange& theRange)
// Post-processing options
Standard_Boolean bSplitCurve = Standard_False;
//
// Collect all pairs of Edge/Edge interferences to check if
// some faces have to be moved to obtain more precise intersection
NCollection_DataMap<BOPDS_Pair, TColStd_ListOfInteger, BOPDS_PairMapHasher> aEEMap;
const BOPDS_VectorOfInterfEE& aVEEs = myDS->InterfEE();
for (Standard_Integer iEE = 0; iEE < aVEEs.Size(); ++iEE)
{
const BOPDS_Interf& aEE = aVEEs(iEE);
if (!aEE.HasIndexNew())
{
continue;
}
Standard_Integer nE1, nE2;
aEE.Indices(nE1, nE2);
const Standard_Integer nVN = aEE.IndexNew();
BOPDS_Pair aPair(nE1, nE2);
TColStd_ListOfInteger* pPoints = aEEMap.ChangeSeek(aPair);
if (pPoints)
{
pPoints->Append(nVN);
}
else
{
pPoints = aEEMap.Bound(BOPDS_Pair(nE1, nE2), TColStd_ListOfInteger());
pPoints->Append(nVN);
}
}
// Prepare the pairs of faces for intersection
BOPAlgo_VectorOfFaceFace aVFaceFace;
myIterator->Initialize(TopAbs_FACE, TopAbs_FACE);
@ -306,15 +335,87 @@ void BOPAlgo_PaveFiller::PerformFF(const Message_ProgressRange& theRange)
continue;
}
}
// Check if there is an intersection between edges of the faces.
// If there is an intersection, check if there is a shift between the edges
// (intersection point is on some distance from the edges), and move one of
// the faces to the point of exact edges intersection. This should allow
// obtaining more precise intersection curves between the faces
// (at least the curves should reach the boundary).
// Note, that currently this check considers only closed edges (seam edges).
TopoDS_Face aFShifted1 = aF1, aFShifted2 = aF2;
// Keep shift value to use it as the tolerance for intersection curves
Standard_Real aShiftValue = 0.;
if (aBAS1.GetType() != GeomAbs_Plane ||
aBAS2.GetType() != GeomAbs_Plane) {
Standard_Boolean isFound = Standard_False;
for (TopExp_Explorer aExp1(aF1, TopAbs_EDGE); !isFound && aExp1.More(); aExp1.Next())
{
const TopoDS_Edge& aE1 = TopoDS::Edge(aExp1.Current());
const Standard_Integer nE1 = myDS->Index(aE1);
for (TopExp_Explorer aExp2(aF2, TopAbs_EDGE); !isFound && aExp2.More(); aExp2.Next())
{
const TopoDS_Edge& aE2 = TopoDS::Edge(aExp2.Current());
const Standard_Integer nE2 = myDS->Index(aE2);
Standard_Boolean bIsClosed1 = BRep_Tool::IsClosed(aE1, aF1);
Standard_Boolean bIsClosed2 = BRep_Tool::IsClosed(aE2, aF2);
if (!bIsClosed1 && !bIsClosed2)
{
continue;
}
const TColStd_ListOfInteger* pPoints = aEEMap.Seek(BOPDS_Pair(nE1, nE2));
if (!pPoints)
{
continue;
}
for (TColStd_ListOfInteger::Iterator itEEP(*pPoints); itEEP.More(); itEEP.Next())
{
const Standard_Integer& nVN = itEEP.Value();
const TopoDS_Vertex& aVN = TopoDS::Vertex(myDS->Shape(nVN));
const gp_Pnt& aPnt = BRep_Tool::Pnt(aVN);
// Compute points exactly on the edges
GeomAPI_ProjectPointOnCurve& aProjPC1 = myContext->ProjPC(aE1);
GeomAPI_ProjectPointOnCurve& aProjPC2 = myContext->ProjPC(aE2);
aProjPC1.Perform(aPnt);
aProjPC2.Perform(aPnt);
if (!aProjPC1.NbPoints() && !aProjPC2.NbPoints())
{
continue;
}
gp_Pnt aP1 = aProjPC1.NbPoints() > 0 ? aProjPC1.NearestPoint() : aPnt;
gp_Pnt aP2 = aProjPC2.NbPoints() > 0 ? aProjPC2.NearestPoint() : aPnt;
Standard_Real aShiftDist = aP1.Distance(aP2);
if (aShiftDist > BRep_Tool::Tolerance(aVN))
{
// Move one of the faces to the point of exact intersection of edges
gp_Trsf aTrsf;
aTrsf.SetTranslation(bIsClosed1 ? gp_Vec(aP1, aP2) : gp_Vec(aP2, aP1));
TopLoc_Location aLoc(aTrsf);
(bIsClosed1 ? &aFShifted1 : &aFShifted2)->Move(aLoc);
aShiftValue = aShiftDist;
isFound = Standard_True;
}
}
}
}
}
//
BOPAlgo_FaceFace& aFaceFace=aVFaceFace.Appended();
//
aFaceFace.SetRunParallel (myRunParallel);
aFaceFace.SetIndices(nF1, nF2);
aFaceFace.SetFaces(aF1, aF2);
aFaceFace.SetFaces(aFShifted1, aFShifted2);
aFaceFace.SetBoxes (myDS->ShapeInfo (nF1).Box(), myDS->ShapeInfo (nF2).Box());
// compute minimal tolerance for the curves
Standard_Real aTolFF = ToleranceFF(aBAS1, aBAS2);
// Note: in case of faces with closed edges it should not be less than value of the shift
Standard_Real aTolFF = Max(aShiftValue, ToleranceFF(aBAS1, aBAS2));
aFaceFace.SetTolFF(aTolFF);
//
IntSurf_ListOfPntOn2S aListOfPnts;

5
src/BRepApprox/BRepApprox_Approx.hxx
View File

@ -105,6 +105,11 @@ public:
Standard_EXPORT const AppParCurves_MultiBSpCurve& Value (const Standard_Integer Index) const;
Standard_EXPORT static void Parameters(const BRepApprox_TheMultiLineOfApprox& Line,
const Standard_Integer firstP,
const Standard_Integer lastP,
const Approx_ParametrizationType Par,
math_Vector& TheParameters);

4
src/GeomInt/GeomInt_IntSS.cxx
View File

@ -18,6 +18,7 @@
#include <Adaptor3d_TopolTool.hxx>
#include <GeomAdaptor_Surface.hxx>
#include <Extrema_ExtPS.hxx>
//=======================================================================
//function : Perform
@ -82,7 +83,7 @@ void GeomInt_IntSS::Perform(const Handle(Geom_Surface)& S1,
Standard_Real TolArc = Tol;
Standard_Real TolTang = Tol;
Standard_Real UVMaxStep = 0.001;
Standard_Real UVMaxStep = IntPatch_Intersection::DefineUVMaxStep(myHS1, dom1, myHS2, dom2);
Standard_Real Deflection = 0.1;
myIntersector.SetTolerances(TolArc,TolTang,UVMaxStep,Deflection);
@ -184,3 +185,4 @@ void GeomInt_IntSS::Perform(const Handle(Geom_Surface)& S1,
StdFail_NotDone_Raise_if(!myIntersector.IsDone(),"GeomInt_IntSS::LineOnS2");
return slineS2(Index);
}

1
src/GeomInt/GeomInt_IntSS.hxx
View File

@ -106,7 +106,6 @@ public:
Standard_EXPORT static Handle(Geom2d_BSplineCurve) MakeBSpline2d(const Handle(IntPatch_WLine)& theWLine, const Standard_Integer ideb, const Standard_Integer ifin, const Standard_Boolean onFirst);
protected:

33
src/GeomInt/GeomInt_IntSS_1.cxx
View File

@ -48,6 +48,7 @@
#include <IntRes2d_IntersectionSegment.hxx>
#include <IntSurf_Quadric.hxx>
#include <Precision.hxx>
#include <ApproxInt_KnotTools.hxx>
//=======================================================================
//function : AdjustUPeriodic
@ -623,12 +624,31 @@ void GeomInt_IntSS::MakeCurve(const Standard_Integer Index,
ifprm = (Standard_Integer)fprm;
ilprm = (Standard_Integer)lprm;
}
//-- lbr :
//-- Si une des surfaces est un plan , on approxime en 2d
//-- sur cette surface et on remonte les points 2d en 3d.
Standard_Boolean anApprox = myApprox;
Standard_Boolean anApprox1 = myApprox1;
Standard_Boolean anApprox2 = myApprox2;
GeomAbs_SurfaceType typs1, typs2;
typs1 = myHS1->GetType();
typs2 = myHS2->GetType();
if (typs1 == GeomAbs_Plane) {
anApprox = Standard_False;
anApprox1 = Standard_True;
}
else if (typs2 == GeomAbs_Plane) {
anApprox = Standard_False;
anApprox2 = Standard_True;
}
Approx_ParametrizationType aParType = ApproxInt_KnotTools::DefineParType(WL, ifprm, ilprm,
anApprox, anApprox1, anApprox2);
theapp3d.SetParameters(myTolApprox, tol2d, 4, 8, 0, 30, myHS1 != myHS2, aParType);
//-- lbr :
//-- Si une des surfaces est un plan , on approxime en 2d
//-- sur cette surface et on remonte les points 2d en 3d.
//
if(typs1 == GeomAbs_Plane) {
theapp3d.Perform(myHS1, myHS2, WL, Standard_False,
@ -646,12 +666,7 @@ void GeomInt_IntSS::MakeCurve(const Standard_Integer Index,
if ((typs1==GeomAbs_BezierSurface || typs1==GeomAbs_BSplineSurface) &&
(typs2==GeomAbs_BezierSurface || typs2==GeomAbs_BSplineSurface)) {
theapp3d.SetParameters(myTolApprox, tol2d, 4, 8, 0, 30, Standard_True);
//Standard_Boolean bUseSurfaces;
//bUseSurfaces=NotUseSurfacesForApprox(myFace1, myFace2, WL, ifprm, ilprm);
//if (bUseSurfaces) {
//theapp3d.SetParameters(myTolApprox, tol2d, 4, 8, 0, Standard_False);
//}
theapp3d.SetParameters(myTolApprox, tol2d, 4, 8, 0, 30, Standard_True, aParType);
}
}
//

6
src/GeomInt/GeomInt_WLApprox.hxx
View File

@ -96,7 +96,11 @@ public:
Standard_EXPORT const AppParCurves_MultiBSpCurve& Value (const Standard_Integer Index) const;
Standard_EXPORT static void Parameters(const GeomInt_TheMultiLineOfWLApprox& Line,
const Standard_Integer firstP,
const Standard_Integer lastP,
const Approx_ParametrizationType Par,
math_Vector& TheParameters);
protected:

146
src/IntPatch/IntPatch_Intersection.cxx
View File

@ -35,6 +35,7 @@
#include <Geom2dAdaptor_Curve.hxx>
#include <ProjLib.hxx>
//======================================================================
// function: SequenceOfLine
//======================================================================
@ -125,7 +126,7 @@ void IntPatch_Intersection::SetTolerances(const Standard_Real TolArc,
if(myTolArc>0.5) myTolArc=0.5;
if(myTolTang>0.5) myTolTang=0.5;
if(myFleche<1.0e-3) myFleche=1e-3;
if(myUVMaxStep<1.0e-3) myUVMaxStep=1e-3;
//if(myUVMaxStep<1.0e-3) myUVMaxStep=1e-3;
if(myFleche>10) myFleche=10;
if(myUVMaxStep>0.5) myUVMaxStep=0.5;
}
@ -1023,7 +1024,6 @@ void IntPatch_Intersection::Perform(const Handle(Adaptor3d_Surface)& theS1,
myFleche = 0.01;
if(myUVMaxStep <= Precision::PConfusion())
myUVMaxStep = 0.01;
done = Standard_False;
spnt.Clear();
slin.Clear();
@ -1254,15 +1254,16 @@ void IntPatch_Intersection::ParamParamPerfom(const Handle(Adaptor3d_Surface)& t
const GeomAbs_SurfaceType typs2)
{
IntPatch_PrmPrmIntersection interpp;
//
if(!theD1->DomainIsInfinite() && !theD2->DomainIsInfinite())
{
Standard_Boolean ClearFlag = Standard_True;
if(!ListOfPnts.IsEmpty())
{
interpp.Perform(theS1,theD1,theS2,theD2,TolTang,TolArc,myFleche,myUVMaxStep, ListOfPnts);
interpp.Perform(theS1,theD1,theS2,theD2,TolTang,TolArc,myFleche, myUVMaxStep, ListOfPnts);
ClearFlag = Standard_False;
}
interpp.Perform(theS1,theD1,theS2,theD2,TolTang,TolArc,myFleche,myUVMaxStep,ClearFlag);
interpp.Perform(theS1,theD1,theS2,theD2,TolTang,TolArc,myFleche, myUVMaxStep,ClearFlag);
}
else if((theD1->DomainIsInfinite()) ^ (theD2->DomainIsInfinite()))
{
@ -1275,7 +1276,7 @@ void IntPatch_Intersection::ParamParamPerfom(const Handle(Adaptor3d_Surface)& t
const Standard_Real AP = Max(MU, MV);
Handle(Adaptor3d_Surface) SS;
FUN_TrimInfSurf(pMinXYZ, pMaxXYZ, theS1, AP, SS);
interpp.Perform(SS,theD1,theS2,theD2,TolTang,TolArc,myFleche,myUVMaxStep);
interpp.Perform(SS,theD1,theS2,theD2,TolTang,TolArc,myFleche, myUVMaxStep);
}
else
{
@ -1285,7 +1286,7 @@ void IntPatch_Intersection::ParamParamPerfom(const Handle(Adaptor3d_Surface)& t
const Standard_Real AP = Max(MU, MV);
Handle(Adaptor3d_Surface) SS;
FUN_TrimInfSurf(pMinXYZ, pMaxXYZ, theS2, AP, SS);
interpp.Perform(theS1, theD1, SS, theD2,TolTang, TolArc,myFleche,myUVMaxStep);
interpp.Perform(theS1, theD1, SS, theD2,TolTang, TolArc,myFleche, myUVMaxStep);
}
}//(theD1->DomainIsInfinite()) ^ (theD2->DomainIsInfinite())
else
@ -1324,7 +1325,7 @@ void IntPatch_Intersection::ParamParamPerfom(const Handle(Adaptor3d_Surface)& t
Handle(Adaptor3d_Surface) nS1 = theS1;
Handle(Adaptor3d_Surface) nS2 = theS2;
FUN_TrimBothSurf(theS1,typs1,theS2,typs2,1.e+8,nS1,nS2);
interpp.Perform(nS1,theD1,nS2,theD2,TolTang,TolArc,myFleche,myUVMaxStep);
interpp.Perform(nS1,theD1,nS2,theD2,TolTang,TolArc,myFleche, myUVMaxStep);
}// 'NON - COLLINEAR LINES'
}// both domains are infinite
@ -1791,3 +1792,134 @@ void IntPatch_Intersection::Dump(const Standard_Integer /*Mode*/,
#endif
}
//=======================================================================
//function : CheckSingularPoints
//purpose :
//=======================================================================
Standard_Boolean IntPatch_Intersection::CheckSingularPoints(
const Handle(Adaptor3d_Surface)& theS1,
const Handle(Adaptor3d_TopolTool)& theD1,
const Handle(Adaptor3d_Surface)& theS2,
Standard_Real& theDist)
{
theDist = Precision::Infinite();
Standard_Boolean isSingular = Standard_False;
if (theS1 == theS2)
{
return isSingular;
}
//
const Standard_Integer aNbBndPnts = 5;
const Standard_Real aTol = Precision::Confusion();
Standard_Integer i;
theD1->Init();
Standard_Boolean isU = Standard_True;
for (; theD1->More(); theD1->Next())
{
Handle(Adaptor2d_Curve2d) aBnd = theD1->Value();
Standard_Real pinf = aBnd->FirstParameter(), psup = aBnd->LastParameter();
if (Precision::IsNegativeInfinite(pinf) || Precision::IsPositiveInfinite(psup))
{
continue;
}
Standard_Real t, dt = (psup - pinf) / (aNbBndPnts - 1);
gp_Pnt2d aP1;
gp_Vec2d aDir;
aBnd->D1((pinf + psup) / 2., aP1, aDir);
if (Abs(aDir.X()) > Abs(aDir.Y()))
isU = Standard_True;
else
isU = Standard_False;
gp_Pnt aPP1;
gp_Vec aDU, aDV;
Standard_Real aD1NormMax = 0.;
gp_XYZ aPmid(0., 0., 0.);
Standard_Integer aNb = 0;
for (t = pinf; t <= psup; t += dt)
{
aP1 = aBnd->Value(t);
theS1->D1(aP1.X(), aP1.Y(), aPP1, aDU, aDV);
if (isU)
aD1NormMax = Max(aD1NormMax, aDU.Magnitude());
else
aD1NormMax = Max(aD1NormMax, aDV.Magnitude());
aPmid += aPP1.XYZ();
aNb++;
if (aD1NormMax > aTol)
break;
}
if (aD1NormMax <= aTol)
{
//Singular point aPP1;
aPmid /= aNb;
aPP1.SetXYZ(aPmid);
Standard_Real aTolU = Precision::PConfusion(), aTolV = Precision::PConfusion();
Extrema_ExtPS aProj(aPP1, *theS2.get(), aTolU, aTolV, Extrema_ExtFlag_MIN);
if (aProj.IsDone())
{
Standard_Integer aNbExt = aProj.NbExt();
for (i = 1; i <= aNbExt; ++i)
{
theDist = Min(theDist, aProj.SquareDistance(i));
}
}
}
}
if (!Precision::IsInfinite(theDist))
{
theDist = Sqrt(theDist);
isSingular = Standard_True;
}
return isSingular;
}
//=======================================================================
//function : DefineUVMaxStep
//purpose :
//=======================================================================
Standard_Real IntPatch_Intersection::DefineUVMaxStep(
const Handle(Adaptor3d_Surface)& theS1,
const Handle(Adaptor3d_TopolTool)& theD1,
const Handle(Adaptor3d_Surface)& theS2,
const Handle(Adaptor3d_TopolTool)& theD2)
{
Standard_Real anUVMaxStep = 0.001;
Standard_Real aDistToSing1 = Precision::Infinite();
Standard_Real aDistToSing2 = Precision::Infinite();
const Standard_Real aTolMin = Precision::Confusion(), aTolMax = 1.e-5;
if (theS1 != theS2)
{
Standard_Boolean isSing1 = CheckSingularPoints(theS1, theD1, theS2, aDistToSing1);
if (isSing1)
{
if (aDistToSing1 > aTolMin && aDistToSing1 < aTolMax)
{
anUVMaxStep = 0.0001;
}
else
{
isSing1 = Standard_False;
}
}
if (!isSing1)
{
Standard_Boolean isSing2 = CheckSingularPoints(theS2, theD2, theS1, aDistToSing2);
if (isSing2)
{
if (aDistToSing2 > aTolMin && aDistToSing2 < aTolMax)
{
anUVMaxStep = 0.0001;
}
}
}
}
return anUVMaxStep;
}

14
src/IntPatch/IntPatch_Intersection.hxx
View File

@ -133,7 +133,21 @@ public:
//! Mode for more accurate dumps.
Standard_EXPORT void Dump (const Standard_Integer Mode, const Handle(Adaptor3d_Surface)& S1, const Handle(Adaptor3d_TopolTool)& D1, const Handle(Adaptor3d_Surface)& S2, const Handle(Adaptor3d_TopolTool)& D2) const;
//! Checks if surface theS1 has degenerated boundary (dS/du or dS/dv = 0) and
//! calculates minimal distance between corresponding singular points and surface theS2
//! If singular point exists the method returns "true" and stores minimal distance in theDist.
Standard_EXPORT static Standard_Boolean CheckSingularPoints(
const Handle(Adaptor3d_Surface)& theS1,
const Handle(Adaptor3d_TopolTool)& theD1,
const Handle(Adaptor3d_Surface)& theS2,
Standard_Real& theDist);
//! Calculates recommended value for myUVMaxStep depending on surfaces and their domains
Standard_EXPORT static Standard_Real DefineUVMaxStep(
const Handle(Adaptor3d_Surface)& theS1,
const Handle(Adaptor3d_TopolTool)& theD1,
const Handle(Adaptor3d_Surface)& theS2,
const Handle(Adaptor3d_TopolTool)& theD2);
protected:

3
src/IntPatch/IntPatch_PrmPrmIntersection.cxx
View File

@ -2386,6 +2386,9 @@ void IntPatch_PrmPrmIntersection::Perform (const Handle(Adaptor3d_Surface)& Surf
//Try to extend the intersection line to the boundary,
//if it is possibly
PW.PutToBoundary(Surf1, Surf2);
//
if (PW.NbPoints() < 3)
continue;
const Standard_Integer aMinNbPoints = 40;
if(PW.NbPoints() < aMinNbPoints)

7
src/IntPatch/IntPatch_RstInt.cxx
View File

@ -649,8 +649,11 @@ void IntPatch_RstInt::PutVertexOnLine (const Handle(IntPatch_Line)& L,
IntCS.ParameterOnSurface(U2,V2);
gp_Pnt anOldPnt, aNewPnt;
OtherSurf->D0(U,V, anOldPnt);
OtherSurf->D0(U2,V2, aNewPnt);
if (anOldPnt.SquareDistance(aNewPnt) < Precision::SquareConfusion())
OtherSurf->D0(U2,V2, aNewPnt);
//if (anOldPnt.SquareDistance(aNewPnt) < Precision::SquareConfusion())
Standard_Real aTolConf = Max(Precision::Confusion(), edgeTol);
if (anOldPnt.SquareDistance(aNewPnt) < aTolConf * aTolConf)
{
U2 = U;
V2 = V;

51
src/IntTools/IntTools_FaceFace.cxx
View File

@ -55,6 +55,7 @@
#include <TopoDS.hxx>
#include <TopoDS_Edge.hxx>
#include <gp_Elips.hxx>
#include <ApproxInt_KnotTools.hxx>
static
void Parameters(const Handle(GeomAdaptor_Surface)&,
@ -502,7 +503,7 @@ void IntTools_FaceFace::Perform (const TopoDS_Face& aF1,
Tolerances(myHS1, myHS2, TolTang);
{
const Standard_Real UVMaxStep = 0.001;
const Standard_Real UVMaxStep = IntPatch_Intersection::DefineUVMaxStep(myHS1, dom1, myHS2, dom2);
const Standard_Real Deflection = 0.1;
myIntersector.SetTolerances(TolArc, TolTang, UVMaxStep, Deflection);
}
@ -1164,22 +1165,6 @@ void IntTools_FaceFace::MakeCurve(const Standard_Integer Index,
tol2d = myTolApprox;
}
if(myHS1 == myHS2) {
theapp3d.SetParameters(myTolApprox, tol2d, 4, 8, 0, 30, Standard_False, aParType);
rejectSurface = Standard_True;
}
else {
if(reApprox && !rejectSurface)
theapp3d.SetParameters(myTolApprox, tol2d, 4, 8, 0, 30, Standard_False, aParType);
else {
Standard_Integer iDegMax, iDegMin, iNbIter;
//
ApproxParameters(myHS1, myHS2, iDegMin, iDegMax, iNbIter);
theapp3d.SetParameters(myTolApprox, tol2d, iDegMin, iDegMax,
iNbIter, 30, Standard_True, aParType);
}
}
//
Standard_Real aReachedTol = Precision::Confusion();
bIsDecomposited = IntTools_WLineTool::
DecompositionOfWLine(WL,
@ -1227,6 +1212,35 @@ void IntTools_FaceFace::MakeCurve(const Standard_Integer Index,
ilprm = (Standard_Integer)lprm;
}
}
Standard_Boolean anApprox = myApprox;
if (typs1 == GeomAbs_Plane) {
anApprox = Standard_False;
anApprox1 = Standard_True;
}
else if (typs2 == GeomAbs_Plane) {
anApprox = Standard_False;
anApprox2 = Standard_True;
}
aParType = ApproxInt_KnotTools::DefineParType(WL, ifprm, ilprm,
anApprox, anApprox1, anApprox2);
if (myHS1 == myHS2) {
theapp3d.SetParameters(myTolApprox, tol2d, 4, 8, 0, 30, Standard_False, aParType);
rejectSurface = Standard_True;
}
else {
if (reApprox && !rejectSurface)
theapp3d.SetParameters(myTolApprox, tol2d, 4, 8, 0, 30, Standard_False, aParType);
else {
Standard_Integer iDegMax, iDegMin, iNbIter;
//
ApproxParameters(myHS1, myHS2, iDegMin, iDegMax, iNbIter);
theapp3d.SetParameters(myTolApprox, tol2d, iDegMin, iDegMax,
iNbIter, 30, Standard_True, aParType);
}
}
//-- lbr :
//-- Si une des surfaces est un plan , on approxime en 2d
//-- sur cette surface et on remonte les points 2d en 3d.
@ -1892,6 +1906,7 @@ Handle(Geom_Curve) MakeBSpline (const Handle(IntPatch_WLine)& WL,
enlarge=Standard_True;
}
//
if(!isuperiodic && enlarge) {
if(!Precision::IsInfinite(theumin) &&
@ -1907,6 +1922,7 @@ Handle(Geom_Curve) MakeBSpline (const Handle(IntPatch_WLine)& WL,
else
theumax = usup;
}
//
if(!isvperiodic && enlarge) {
if(!Precision::IsInfinite(thevmin) &&
@ -1924,6 +1940,7 @@ Handle(Geom_Curve) MakeBSpline (const Handle(IntPatch_WLine)& WL,
thevmax = vsup;
}
}
//
if(isuperiodic || isvperiodic) {
Standard_Boolean correct = Standard_False;

102
src/IntWalk/IntWalk_PWalking.cxx
View File

@ -2316,10 +2316,65 @@ Standard_Boolean IntWalk_PWalking::HandleSingleSingularPoint(const Handle(Adapto
if (anInt.IsEmpty())
continue;
anInt.Point().Parameters(thePnt(1), thePnt(2), thePnt(3), thePnt(4));
Standard_Real aPars[4];
anInt.Point().Parameters(aPars[0], aPars[1], aPars[2], aPars[3]);
Handle(Adaptor3d_Surface) aSurfs[2] = { theASurf1, theASurf2 };
//Local resolutions
Standard_Real aTol2 = the3DTol * the3DTol;
gp_Pnt aP;
gp_Vec aDU, aDV;
gp_Pnt aPInt;
Standard_Integer k;
for (k = 0; k < 2; ++k)
{
Standard_Integer iu, iv;
iu = 2*k;
iv = iu + 1;
aSurfs[k]->D1(aPars[iu], aPars[iv], aPInt, aDU, aDV);
Standard_Real aMod = aDU.Magnitude();
if (aMod > Precision::Confusion())
{
Standard_Real aTolU = the3DTol / aMod;
if (Abs(aLowBorder[iu] - aPars[iu]) < aTolU)
{
aP = aSurfs[k]->Value(aLowBorder[iu], aPars[iv]);
if (aPInt.SquareDistance(aP) < aTol2)
aPars[iu] = aLowBorder[iu];
}
else if (Abs(aUppBorder[iu] - aPars[iu]) < aTolU)
{
aP = aSurfs[k]->Value(aUppBorder[iu], aPars[iv]);
if (aPInt.SquareDistance(aP) < aTol2)
aPars[iu] = aUppBorder[iu];
}
}
aMod = aDV.Magnitude();
if (aMod > Precision::Confusion())
{
Standard_Real aTolV = the3DTol / aMod;
if (Abs(aLowBorder[iv] - aPars[iv]) < aTolV)
{
aP = aSurfs[k]->Value(aPars[iu], aLowBorder[iv]);
if (aPInt.SquareDistance(aP) < aTol2)
aPars[iv] = aLowBorder[iv];
}
else if (Abs(aUppBorder[iv] - aPars[iv]) < aTolV)
{
aP = aSurfs[k]->Value(aPars[iu], aUppBorder[iv]);
if (aPInt.SquareDistance(aP) < aTol2)
aPars[iv] = aUppBorder[iv];
}
}
}
//
//
Standard_Integer j;
for (j = 1; j <= 4; ++j)
{
thePnt(j) = aPars[j - 1];
}
Standard_Boolean isInDomain = Standard_True;
for (Standard_Integer j = 1; isInDomain && (j <= 4); ++j)
for (j = 1; isInDomain && (j <= 4); ++j)
{
if ((thePnt(j) - aLowBorder[j - 1] + Precision::PConfusion())*
(thePnt(j) - aUppBorder[j - 1] - Precision::PConfusion()) > 0.0)
@ -2461,13 +2516,13 @@ Standard_Boolean IntWalk_PWalking::
{
break;
}
else if (aPInd == 1)
{
// After insertion, we will obtain
// two coincident points in the line.
// Therefore, insertion is forbidden.
return isOK;
}
//else if (aPInd == 1)
//{
// // After insertion, we will obtain
// // two coincident points in the line.
// // Therefore, insertion is forbidden.
// return isOK;
//}
}
for (++aPInd; aPInd <= aNbPnts; aPInd++)
@ -2493,6 +2548,12 @@ Standard_Boolean IntWalk_PWalking::
RemoveAPoint(1);
}
aP1.SetXYZ(line->Value(1).Value().XYZ());
if (aP1.SquareDistance(aPInt) <= Precision::SquareConfusion())
{
RemoveAPoint(1);
}
line->InsertBefore(1, anIP);
isOK = Standard_True;
}
@ -2511,13 +2572,13 @@ Standard_Boolean IntWalk_PWalking::
{
break;
}
else if (aPInd == aNbPnts)
{
// After insertion, we will obtain
// two coincident points in the line.
// Therefore, insertion is forbidden.
return isOK;
}
//else if (aPInd == aNbPnts)
//{
// // After insertion, we will obtain
// // two coincident points in the line.
// // Therefore, insertion is forbidden.
// return isOK;
//}
}
for (--aPInd; aPInd > 0; aPInd--)
@ -2543,7 +2604,14 @@ Standard_Boolean IntWalk_PWalking::
RemoveAPoint(aNbPnts);
}
Standard_Integer aNbPnts = line->NbPoints();
aP1.SetXYZ(line->Value(aNbPnts).Value().XYZ());
if (aP1.SquareDistance(aPInt) <= Precision::SquareConfusion())
{
RemoveAPoint(aNbPnts);
}
line->Add(anIP);
isOK = Standard_True;
}

2
tests/lowalgos/intss/bug24472
View File

@ -7,7 +7,7 @@ puts ""
###############################
puts "TODO OCC29501 ALL: Error in ii12_22"
puts "TODO OCC29501 All: Error: The curve ii12_22 is possible"
set MaxToler 1.5e-4
restore [locate_data_file bug24472_Pipe_1.brep] b1

2
tests/lowalgos/intss/bug27190
View File

@ -7,7 +7,7 @@ puts ""
#######################################################################
set MaxTol 1.e-3
set GoodNbCurv 11
set GoodNbCurv 12
restore [locate_data_file bug27167_pipe.brep] a1
pcylinder a2 100 300

2
tests/lowalgos/intss/bug27664_1
View File

@ -6,7 +6,7 @@ puts ""
# Incomplete intersection curve from the attached shapes
#################################################
set ExpTol 1.1e-7
set ExpTol 1.e-5
set GoodNbCurv 3
set GoodLength 0.6288896355727489

2
tests/lowalgos/intss/bug28764
View File

@ -18,7 +18,7 @@ fit
# Before the fix: Exception in Debug-mode only
regexp {Tolerance Reached=+([-0-9.+eE]+)\n+([-0-9.+eE]+)} [bopcurves f_1 f_2 -2d] full Toler NbCurv
checkreal Tolerance $Toler 4.601149532364662e-008 1.0e-7 0.0
checkreal Tolerance $Toler 2.1053092622220167e-07 1.0e-7 0.0
if {$NbCurv != 1} {
puts "Error: Please check NbCurves for intersector"

4
tests/lowalgos/intss/bug29972_3
View File

@ -32,8 +32,8 @@ while { $AllowRepeat != 0 } {
puts "Error: Wrong curve's range!"
}
xdistcs res_$ic s1 U1 U2 100 2.0e-7
xdistcs res_$ic s2 U1 U2 100 2.0e-7
xdistcs res_$ic s1 U1 U2 100 6.0e-7
xdistcs res_$ic s2 U1 U2 100 6.0e-7
mkedge ee res_$ic
baddobjects ee

56
tests/lowalgos/intss/bug32701 Normal file
View File

@ -0,0 +1,56 @@
puts "========"
puts "0032701: Modeling Algorithms - 2d curve has bending near the degenerated edge of the face"
puts "========"
puts ""
restore [locate_data_file bug32701s.brep] s
restore [locate_data_file bug32701t.brep] t
explode t f
set log [bopcurves s t_3 -2d]
regexp {Tolerance Reached=+([-0-9.+eE]+)\n+([-0-9.+eE]+)} $log full Toler NbCurv
if {$NbCurv != 1} {
puts "Error: Number of curves is wrong"
}
if { $Toler > 3.0e-5} {
puts "Error: Big tolerance value"
}
set log [bopcurves s t_4 -2d]
regexp {Tolerance Reached=+([-0-9.+eE]+)\n+([-0-9.+eE]+)} $log full Toler NbCurv
if {$NbCurv != 1} {
puts "Error: Number of curves is wrong"
}
if { $Toler > 8.0e-5} {
puts "Error: Big tolerance value"
}
bcommon cc s t
checkshape cc
checkprops cc -s 19899.6
##checkview -display cc -2d -path ${imagedir}/${test_image}.png
bcut cct s t
checkshape cct
checkprops cct -s 32252.5
compound cc cct qq
checkview -display qq -2d -path ${imagedir}/${test_image}.png