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

0026329: Restore floating point signals handling in DRAW

Browse Source 
Added DRAW command dsetsignal, resetting OSD signal handler with either armed or disabled FPE handler, according to an option.
If called without arguments, it sets FPE handler only if environment variable OSD_FPE is defined (with value different from 0).
On start, DRAW calls dsetsignal to set FPE signal if CSF_FPE is defined.
Test bugs fclasses bug6143 uses dsetsignal to set FPE handler unconditionally before the test command, and resets it to default at the end.

A number of changes in the code have been done in order to fix floating point exceptions that became generated after enabling signals:

- Global functions Sinh() and Cosh() defined in Standard_Real.hxx are improved to raise Standard_NumericError exception if argument is too big (greater than 710.47586), instead of relying on system treatment of floating point overflow. These functions are used instead of sinh and cosh in ElCLib.cxx.

- Maximal value of parameter on hyperbola is restricted by 23 (corresponding to ~1e10 in 3d) in order to avoid FP overflow in Extrema_GenExtCS.cxx, ShapeFix_EdgeProjAux.cxx.

- Interface of the root curve adaptor class Adaptor3d_Curve has been updated to add new virtual methods BasisCurve and OffsetValue. They complement the adaptor for the case of offset curves. These methods are used in Extrema_GenExtCS.cxx to restrict domain search in the case of offset of hyperbola, in order to get rid of floating point overflow. All classes inheriting Adaptor3d_Curve have been changed to implement the new virtual methods.

- Protection against division by zero has been implemented in ApproxInt_KnotTools.cxx, BRepClass3d_SClassifier.cxx, BRepGProp_Face.cxx, BRepMesh_FastDiscretFace.cxx, Geom2dGcc_Circ2d2TanOnIter.cxx, Geom2dInt_Geom2dCurveTool.cxx, IntPolyh_MaillageAffinage.cxx.

- Protection against calling of math functions of infinite arguments has been added in BRepCheck_Edge.cxx, BRepLib.cxx, CSLib_NormalPolyDef.cxx, Extrema_FuncExtPC.gxx, Extrema_GExtPC.gxx, Extrema_GLocateExtPC.gxx, Intf_InterferencePolygonPolyhedron.gxx, ShapeAnalysis_Surface.cxx, ShapeAnalysis_TransferParametersProj.cxx, ShapeAnalysis_Wire.cxx, math_FunctionSetRoot.cxx.

- Proper initialization of local variables is done in BOPAlgo_PaveFiller_6.cxx, XSDRAWSTLVRML.cxx.

- Inconsistent usage of Standard_Boolean* to access integer data in HLR (caused by #27772) is corrected

Some test cases have been updated to actual state.
This commit is contained in:
ifv 2016-08-09 20:12:59 +03:00 committed by kgv
parent 73594f7248
commit f4dee9bb20
48 changed files with 595 additions and 228 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
src/Adaptor3d/Adaptor3d_Curve.cxx
View File

@ -19,6 +19,7 @@
#include <Adaptor3d_HCurve.hxx>
#include <Geom_BezierCurve.hxx>
#include <Geom_BSplineCurve.hxx>
#include <Geom_OffsetCurve.hxx>
#include <gp_Circ.hxx>
#include <gp_Elips.hxx>
#include <gp_Hypr.hxx>
@ -376,3 +377,14 @@ Handle(Geom_BSplineCurve) Adaptor3d_Curve::BSpline() const
Standard_NotImplemented::Raise("Adaptor3d_Curve::BSpline");
return Handle(Geom_BSplineCurve)();
}
//=======================================================================
//function : BasisCurve
//purpose :
//=======================================================================
Handle(Geom_OffsetCurve) Adaptor3d_Curve::OffsetCurve() const
{
Standard_NotImplemented::Raise("Adaptor3d_Curve::OffsetCurve");
return Handle(Geom_OffsetCurve)();
}

4
src/Adaptor3d/Adaptor3d_Curve.hxx
View File

@ -40,6 +40,7 @@ class gp_Hypr;
class gp_Parab;
class Geom_BezierCurve;
class Geom_BSplineCurve;
class Geom_OffsetCurve;
//! Root class for 3D curves on which geometric
@ -155,6 +156,9 @@ public:
Standard_EXPORT virtual Handle(Geom_BezierCurve) Bezier() const;
Standard_EXPORT virtual Handle(Geom_BSplineCurve) BSpline() const;
Standard_EXPORT virtual Handle(Geom_OffsetCurve) OffsetCurve() const;
Standard_EXPORT virtual ~Adaptor3d_Curve();

3
src/Adaptor3d/Adaptor3d_HCurve.hxx
View File

@ -42,6 +42,7 @@ class gp_Pnt;
class gp_Vec;
class Geom_BezierCurve;
class Geom_BSplineCurve;
class Geom_OffsetCurve;
class Adaptor3d_HCurve;
@ -134,7 +135,7 @@ public:
Handle(Geom_BSplineCurve) BSpline() const;
Handle(Geom_OffsetCurve) OffsetCurve() const;
DEFINE_STANDARD_RTTIEXT(Adaptor3d_HCurve,MMgt_TShared)

9
src/Adaptor3d/Adaptor3d_HCurve.lxx
View File

@ -293,3 +293,12 @@ inline Standard_Integer Adaptor3d_HCurve::NbKnots() const
return Curve().BSpline();
}
//=======================================================================
//function : BasisCurve
//purpose :
//=======================================================================
inline Handle(Geom_OffsetCurve) Adaptor3d_HCurve::OffsetCurve() const
{
return Curve().OffsetCurve();
}

14
src/ApproxInt/ApproxInt_KnotTools.cxx
View File

@ -28,10 +28,10 @@
#include <TColgp_Array1OfPnt.hxx>
// (Sqrt(5.0) - 1.0) / 4.0
static const Standard_Real aSinCoeff = 0.30901699437494742410229341718282;
//static const Standard_Real aSinCoeff = 0.30901699437494742410229341718282;
static const Standard_Real aSinCoeff2 = 0.09549150281252627; // aSinCoeff^2 = (3. - Sqrt(5.)) / 8.
static const Standard_Integer aMaxPntCoeff = 15;
//=======================================================================
//function : EvalCurv
//purpose : Evaluate curvature in dim-dimension point.
@ -238,7 +238,6 @@ void ApproxInt_KnotTools::ComputeKnotInds(const NCollection_LocalArray<Standard_
{
Standard_Integer anIndPrev = theInds(j-1);
Standard_Integer anIndNext = theInds(j+1);
Standard_Real sina;
Standard_Integer ici = (anIndPrev - aCurv.Lower()) * theDim,
ici1 = (anIndNext - aCurv.Lower()) * theDim,
icm = (anInd - aCurv.Lower()) * theDim;
@ -262,10 +261,8 @@ void ApproxInt_KnotTools::ComputeKnotInds(const NCollection_LocalArray<Standard_
}
//mp *= 2.; //P(j,i) = -P(i,j);
//
sina = mp/(m1*m2);
sina = Sqrt(sina);
if(sina > aSinCoeff)
if(mp > aSinCoeff2 * m1 * m2) // Sqrt (mp/(m1*m2)) > aSinCoeff
{
//Insert new knots
Standard_Real d1 = Abs(aCurv(anInd) - aCurv(anIndPrev));
@ -494,7 +491,6 @@ Standard_Boolean ApproxInt_KnotTools::InsKnotBefI(const Standard_Integer theI,
{
if(ChkCurv)
{
Standard_Real sina;
Standard_Integer ici = (anInd - theCurv.Lower()) * theDim,
ici1 = (anInd1 - theCurv.Lower()) * theDim,
icm = (mid - theCurv.Lower()) * theDim;
@ -519,10 +515,8 @@ Standard_Boolean ApproxInt_KnotTools::InsKnotBefI(const Standard_Integer theI,
}
//mp *= 2.; //P(j,i) = -P(i,j);
//
sina = mp/(m1*m2);
sina = Sqrt(sina);
if(sina > aSinCoeff)
if (mp > aSinCoeff2 * m1 * m2) // Sqrt (mp / m1m2) > aSinCoeff
{
theInds.InsertBefore(theI, mid);
return Standard_True;

6
src/BOPAlgo/BOPAlgo_PaveFiller_6.cxx
View File

@ -1258,7 +1258,7 @@ Standard_Boolean BOPAlgo_PaveFiller::IsExistingPaveBlock
iFlag2 = (nV12 == nV21 || nV12 == nV22) ? 2 :
(!aBoxSp.IsOut(aBoxP2) ? 1 : 0);
if (iFlag1 && iFlag2) {
Standard_Real aDist;
Standard_Real aDist = 0.;
const Standard_Real aRealTol = myDS->IsCommonBlock(aPB) ?
Max(aTolV1, aTolV2) : theTolR3D;
@ -1275,13 +1275,13 @@ Standard_Boolean BOPAlgo_PaveFiller::IsExistingPaveBlock
//
if (iFlag1 == 1) {
iFlag1 = !myContext->ComputePE(aP1, aRealTol, aSp, aTx, aDist);
if (theTolNew < aDist)
if (iFlag1 && theTolNew < aDist)
theTolNew = aDist;
}
//
if (iFlag2 == 1) {
iFlag2 = !myContext->ComputePE(aP2, aRealTol, aSp, aTx, aDist);
if (theTolNew < aDist)
if (iFlag2 && theTolNew < aDist)
theTolNew = aDist;
}
//

18
src/BRepAdaptor/BRepAdaptor_Curve.cxx
View File

@ -25,6 +25,7 @@
#include <Geom2dAdaptor_HCurve.hxx>
#include <Geom_BezierCurve.hxx>
#include <Geom_BSplineCurve.hxx>
#include <Geom_OffsetCurve.hxx>
#include <Geom_Surface.hxx>
#include <GeomAdaptor_Curve.hxx>
#include <GeomAdaptor_HSurface.hxx>
@ -42,6 +43,8 @@
#include <Standard_OutOfRange.hxx>
#include <TopoDS_Edge.hxx>
#include <TopoDS_Face.hxx>
#include <Geom_OffsetCurve.hxx>
#include <GeomAdaptor_HCurve.hxx>
//=======================================================================
//function : BRepAdaptor_Curve
@ -649,3 +652,18 @@ Handle(Geom_BSplineCurve) BRepAdaptor_Curve::BSpline() const
return myTrsf.Form() == gp_Identity
? BS : Handle(Geom_BSplineCurve)::DownCast(BS->Transformed(myTrsf));
}
//=======================================================================
//function : BasisCurve
//purpose :
//=======================================================================
Handle(Geom_OffsetCurve) BRepAdaptor_Curve::OffsetCurve() const
{
if ( !Is3DCurve() || myCurve.GetType() != GeomAbs_OffsetCurve)
Standard_NoSuchObject::Raise("BRepAdaptor_Curve::OffsetCurve");
Handle(Geom_OffsetCurve) anOffC = myCurve.OffsetCurve();
return myTrsf.Form() == gp_Identity
? anOffC : Handle(Geom_OffsetCurve)::DownCast(anOffC->Transformed(myTrsf));
}

2
src/BRepAdaptor/BRepAdaptor_Curve.hxx
View File

@ -51,6 +51,7 @@ class gp_Hypr;
class gp_Parab;
class Geom_BezierCurve;
class Geom_BSplineCurve;
class Geom_OffsetCurve;
//! The Curve from BRepAdaptor allows to use an Edge
@ -220,6 +221,7 @@ public:
//! using this method
Standard_EXPORT Handle(Geom_BSplineCurve) BSpline() const Standard_OVERRIDE;
Standard_EXPORT Handle(Geom_OffsetCurve) OffsetCurve() const Standard_OVERRIDE;

10
src/BRepCheck/BRepCheck_Edge.cxx
View File

@ -555,8 +555,18 @@ Standard_Real BRepCheck_Edge::Tolerance()
prm = ((NCONTROL-1-i)*First + i*Last)/(NCONTROL-1);
tol2=dist2=0.;
center=(*(Handle(Adaptor3d_HCurve)*)&theRep(1))->Value(prm);
if(Precision::IsInfinite(center.X()) || Precision::IsInfinite(center.Y())
|| Precision::IsInfinite(center.Z()))
{
return Precision::Infinite();
}
for (iRep=2; iRep<=nbRep; iRep++) {
othP=(*(Handle(Adaptor3d_HCurve)*)&theRep(iRep))->Value(prm);
if(Precision::IsInfinite(othP.X()) || Precision::IsInfinite(othP.Y())
|| Precision::IsInfinite(othP.Z()))
{
return Precision::Infinite();
}
dist2=center.SquareDistance(othP);
if (dist2>tolCal) tolCal=dist2;
}

2
src/BRepClass3d/BRepClass3d_SClassifier.cxx
View File

@ -579,7 +579,7 @@ static Standard_Integer GetTransi(const TopoDS_Face& f1,
return -1;
}
if (nf1.IsEqual(nf2, Precision::Angular()))
if (nf1.IsParallel(nf2, Precision::Angular()))
{
Standard_Real angD = nf1.Dot(LDir);
if (Abs(angD) < Precision::Angular())

5
src/BRepGProp/BRepGProp_Face.cxx
View File

@ -34,6 +34,8 @@
#include <TopoDS_Edge.hxx>
#include <TopoDS_Face.hxx>
static const Standard_Real Epsilon1 = Epsilon(1.);
//=======================================================================
//function : UIntegrationOrder
//purpose :
@ -389,7 +391,8 @@ Standard_Integer BRepGProp_Face::LIntOrder(const Standard_Real Eps) const
Standard_Real aVmin = mySurface.FirstVParameter();
Standard_Real aVmax = mySurface.LastVParameter();
Standard_Real anR = Min((aYmax-aYmin)/(aVmax-aVmin), 1.);
Standard_Real dv = (aVmax-aVmin);
Standard_Real anR = (dv > Epsilon1 ? Min ((aYmax - aYmin) / dv, 1.) : 1.);
// Standard_Integer anRInt = Max(RealToInt(Ceiling(SVIntSubs()*anR)), 2);
Standard_Integer anRInt = RealToInt(Ceiling(SVIntSubs()*anR));

63
src/BRepLib/BRepLib.cxx
View File

@ -905,19 +905,53 @@ static Standard_Real ComputeTol(const Handle(Adaptor3d_HCurve)& c3d,
TColStd_Array1OfReal dist(1,nbp+10);
dist.Init(-1.);
Adaptor3d_CurveOnSurface cons(c2d,surf);
//Adaptor3d_CurveOnSurface cons(c2d,surf);
Standard_Real uf = surf->FirstUParameter(), ul = surf->LastUParameter(),
vf = surf->FirstVParameter(), vl = surf->LastVParameter();
Standard_Real du = 0.01 * (ul - uf), dv = 0.01 * (vl - vf);
Standard_Boolean isUPeriodic = surf->IsUPeriodic(), isVPeriodic = surf->IsVPeriodic();
Standard_Real DSdu = 1./surf->UResolution(1.), DSdv = 1./surf->VResolution(1.);
Standard_Real d2 = 0.;
Standard_Real first = c3d->FirstParameter();
Standard_Real last = c3d->LastParameter();
Standard_Real dapp = -1.;
Standard_Integer i = 0;
for(i = 0; i <= nbp; i++){
const Standard_Real t = IntToReal(i)/IntToReal(nbp);
const Standard_Real u = first*(1.-t) + last*t;
gp_Pnt Pc3d = c3d->Value(u);
gp_Pnt Pcons = cons.Value(u);
gp_Pnt2d Puv = c2d->Value(u);
if(!isUPeriodic)
{
if(Puv.X() < uf - du)
{
dapp = Max(dapp, DSdu * (uf - Puv.X()));
continue;
}
else if(Puv.X() > ul + du)
{
dapp = Max(dapp, DSdu * (Puv.X() - ul));
continue;
}
}
if(!isVPeriodic)
{
if(Puv.Y() < vf - dv)
{
dapp = Max(dapp, DSdv * (vf - Puv.Y()));
continue;
}
else if(Puv.Y() > vl + dv)
{
dapp = Max(dapp, DSdv * (Puv.Y() - vl));
continue;
}
}
gp_Pnt Pcons = surf->Value(Puv.X(), Puv.Y());
if (Precision::IsInfinite(Pcons.X()) ||
Precision::IsInfinite(Pcons.Y()) ||
Precision::IsInfinite(Pcons.Z())) {
Precision::IsInfinite(Pcons.Y()) ||
Precision::IsInfinite(Pcons.Z()))
{
d2=Precision::Infinite();
break;
}
@ -930,6 +964,16 @@ static Standard_Real ComputeTol(const Handle(Adaptor3d_HCurve)& c3d,
if(temp > d2) d2 = temp;
}
if(Precision::IsInfinite(d2))
{
return d2;
}
d2 = Sqrt(d2);
if(dapp > d2)
{
return dapp;
}
Standard_Boolean ana = Standard_False;
Standard_Real D2 = 0;
@ -952,7 +996,7 @@ static Standard_Real ComputeTol(const Handle(Adaptor3d_HCurve)& c3d,
}
//d2 = 1.5*sqrt(d2);
d2 = (!ana) ? 1.5*sqrt(d2) : 1.5*sqrt(D2);
d2 = (!ana) ? 1.5 * d2 : 1.5*sqrt(D2);
if(d2<1.e-7) d2 = 1.e-7;
return d2;
@ -1032,6 +1076,7 @@ void BRepLib::SameParameter(const TopoDS_Edge& AnEdge,
// Modified by skv - Thu Jun 3 12:39:20 2004 OCC5898 End
Standard_Boolean SameRange = BRep_Tool::SameRange(AnEdge);
Standard_Boolean YaPCu = Standard_False;
const Standard_Real BigError = 1.e10;
It.Initialize(CList);
while (It.More()) {
@ -1075,6 +1120,12 @@ void BRepLib::SameParameter(const TopoDS_Edge& AnEdge,
Standard_Real error = ComputeTol(HC, HC2d, HS, NCONTROL);
if(error > BigError)
{
maxdist = error;
break;
}
if(GAC2d.GetType() == GeomAbs_BSplineCurve &&
GAC2d.Continuity() == GeomAbs_C0) {
Handle(Geom2d_BSplineCurve) bs2d = GAC2d.BSpline();
@ -1416,6 +1467,7 @@ void BRepLib::UpdateTolerances(const TopoDS_Shape& aShape,
}
//Vertices are processed
const Standard_Real BigTol = 1.e10;
parents.Clear();
TopExp::MapShapesAndAncestors(aShape, TopAbs_VERTEX, TopAbs_EDGE, parents);
TColStd_MapOfTransient Initialized;
@ -1432,6 +1484,7 @@ void BRepLib::UpdateTolerances(const TopoDS_Shape& aShape,
const TopoDS_Edge& E = TopoDS::Edge(lConx.Value());
if(!Done.Add(E)) continue;
tol=Max(tol, BRep_Tool::Tolerance(E));
if(tol > BigTol) continue;
if(!BRep_Tool::SameRange(E)) continue;
Standard_Real par = BRep_Tool::Parameter(V,E);
Handle(BRep_TEdge)& TE = *((Handle(BRep_TEdge)*)&E.TShape());

4
src/BRepMesh/BRepMesh_FastDiscretFace.cxx
View File

@ -1011,7 +1011,9 @@ void BRepMesh_FastDiscretFace::insertInternalVerticesOther(
if (aDist < aDefFace)
{
// Lets check parameters for angular deflection.
if (aPrevVec2.Angle(aNextVec) < myAngle)
if (aPrevVec2.SquareMagnitude() > gp::Resolution() &&
aNextVec.SquareMagnitude() > gp::Resolution() &&
aPrevVec2.Angle(aNextVec) < myAngle)
{
// For current Iso line we can remove this parameter.
#ifdef DEBUG_InsertInternal

5
src/BRepOffset/BRepOffset_Tool.cxx
View File

@ -1039,7 +1039,10 @@ static void ReconstructPCurves(const TopoDS_Edge& anEdge)
(theSurf->Transformed(theLoc.Transformation()));
Handle(Geom2d_Curve) ProjPCurve =
GeomProjLib::Curve2d( C3d, f, l, theSurf );
CurveRep->PCurve( ProjPCurve );
if(!ProjPCurve.IsNull())
{
CurveRep->PCurve( ProjPCurve );
}
}
}
}

4
src/BRepTest/BRepTest_FeatureCommands.cxx
View File

@ -1009,7 +1009,7 @@ Standard_Integer offsetparameter(Draw_Interpretor& di,
Standard_Integer n, const char** a)
{
if ( n == 1 ) {
di << " OffsetParameter Tol Inter(c/p) JoinType(a/i/t) [RemoveInternalEdges(r/k) RemoveInvalidFaces(r/k)]\n";
di << " offsetparameter Tol Inter(c/p) JoinType(a/i/t) [RemoveInternalEdges(r/k) RemoveInvalidFaces(r/k)]\n";
di << " Current Values\n";
di << " --> Tolerance : " << TheTolerance << "\n";
di << " --> TheInter : ";
@ -2327,7 +2327,7 @@ void BRepTest::FeatureCommands (Draw_Interpretor& theCommands)
__FILE__,offsetshape,g);
theCommands.Add("offsetparameter",
"offsetparameter tol inter(a/i) join(a/i)",
"offsetparameter Tol Inter(c/p) JoinType(a/i/t) [RemoveInternalEdges(r/k) RemoveInvalidFaces(r/k)]",
__FILE__,offsetparameter);
theCommands.Add("offsetload",

16
src/CSLib/CSLib_NormalPolyDef.cxx
View File

@ -39,6 +39,11 @@ Standard_Boolean CSLib_NormalPolyDef::Value(const Standard_Real X,
co=cos(X);
si=sin(X);
if(Abs(co) <= RealSmall() || Abs(si) <= RealSmall())
{
F = 0.;
return Standard_True;
}
for(Standard_Integer i=0;i<=myK0;i++){
F=F+PLib::Bin(myK0,i)*pow(co,i)*pow(si,(myK0-i))*myTABli(i);
}
@ -54,6 +59,11 @@ Standard_Boolean CSLib_NormalPolyDef::Derivative(const Standard_Real X,
Standard_Real co,si;
co=cos(X);
si=sin(X);
if(Abs(co) <= RealSmall() || Abs(si) <= RealSmall())
{
D = 0.;
return Standard_True;
}
for(Standard_Integer i=0;i<=myK0;i++){
D=D+PLib::Bin(myK0,i)*pow(co,(i-1))*pow(si,(myK0-i-1))*(myK0*co*co-i);
}
@ -71,6 +81,12 @@ Standard_Boolean CSLib_NormalPolyDef::Values(const Standard_Real X,
Standard_Real co,si;
co=cos(X);
si=sin(X);
if(Abs(co) <= RealSmall() || Abs(si) <= RealSmall())
{
F = 0.;
D = 0.;
return Standard_True;
}
for(Standard_Integer i=0;i<=myK0;i++){
F=F+PLib::Bin(myK0,i)*pow(co,i)*pow(si,(myK0-i))*myTABli(i);
D=D+PLib::Bin(myK0,i)*pow(co,(i-1))*

28
src/Draw/Draw_BasicCommands.cxx
View File

@ -25,6 +25,7 @@
#include <Message_Messenger.hxx>
#include <OSD.hxx>
#include <OSD_Chronometer.hxx>
#include <OSD_Environment.hxx>
#include <OSD_Exception_CTRL_BREAK.hxx>
#include <OSD_MAllocHook.hxx>
#include <OSD_MemInfo.hxx>
@ -740,6 +741,31 @@ static int dperf (Draw_Interpretor& theDI, Standard_Integer theArgNb, const char
return 0;
}
//==============================================================================
//function : dsetsignal
//purpose :
//==============================================================================
static int dsetsignal (Draw_Interpretor& theDI, Standard_Integer theArgNb, const char** theArgVec)
{
// arm FPE handler if argument is provided and its first symbol is not '0'
// or if environment variable CSF_FPE is set and its first symbol is not '0'
bool setFPE = false;
if (theArgNb > 1)
{
setFPE = (theArgVec[1][0] == '1' || theArgVec[1][0] == 't');
}
else
{
OSD_Environment aEnv ("CSF_FPE");
TCollection_AsciiString aEnvStr = aEnv.Value();
setFPE = (! aEnvStr.IsEmpty() && aEnvStr.Value(1) != '0');
}
OSD::SetSignal (setFPE);
theDI << "Signal handlers are set, with FPE " << (setFPE ? "armed" : "disarmed");
return 0;
}
//==============================================================================
//function : dtracelevel
//purpose :
@ -864,6 +890,8 @@ void Draw::BasicCommands(Draw_Interpretor& theCommands)
__FILE__, dmeminfo, g);
theCommands.Add("dperf","dperf [reset] -- show performance counters, reset if argument is provided",
__FILE__,dperf,g);
theCommands.Add("dsetsignal","dsetsignal [fpe=0] -- set OSD signal handler, with FPE option if argument is given",
__FILE__,dsetsignal,g);
// Logging commands; note that their names are hard-coded in the code
// of Draw_Interpretor, thus should not be changed without update of that code!

3
src/DrawResources/DrawDefault
View File

@ -125,5 +125,8 @@ if { $tcl_platform(platform) == "windows" && ! [catch {dgetenv PATH}] } {
_update_c_env env "" "unset"
}
# arm signal handler with default FPE setting
dsetsignal
# silent return from the script
return

44
src/ElCLib/ElCLib.cxx
View File

@ -154,8 +154,8 @@ gp_Pnt ElCLib::HyperbolaValue (const Standard_Real U,
const gp_XYZ& XDir = Pos.XDirection().XYZ();
const gp_XYZ& YDir = Pos.YDirection().XYZ();
const gp_XYZ& PLoc = Pos.Location ().XYZ();
Standard_Real A1 = MajorRadius * cosh(U);
Standard_Real A2 = MinorRadius * sinh(U);
Standard_Real A1 = MajorRadius * Cosh(U);
Standard_Real A2 = MinorRadius * Sinh(U);
return gp_Pnt(A1 * XDir.X() + A2 * YDir.X() + PLoc.X(),
A1 * XDir.Y() + A2 * YDir.Y() + PLoc.Y(),
A1 * XDir.Z() + A2 * YDir.Z() + PLoc.Z());
@ -382,8 +382,8 @@ void ElCLib::HyperbolaD2 (const Standard_Real U,
gp_Vec& V1,
gp_Vec& V2)
{
Standard_Real Xc = cosh(U);
Standard_Real Yc = sinh(U);
Standard_Real Xc = Cosh(U);
Standard_Real Yc = Sinh(U);
gp_XYZ Coord0;
gp_XYZ Coord1 (Pos.XDirection().XYZ());
gp_XYZ Coord2 (Pos.YDirection().XYZ());
@ -514,8 +514,8 @@ void ElCLib::HyperbolaD3 (const Standard_Real U,
gp_Vec& V2,
gp_Vec& V3)
{
Standard_Real Xc = cosh(U);
Standard_Real Yc = sinh(U);
Standard_Real Xc = Cosh(U);
Standard_Real Yc = Sinh(U);
gp_XYZ Coord0;
gp_XYZ Coord1 (Pos.XDirection().XYZ());
gp_XYZ Coord2 (Pos.YDirection().XYZ());
@ -594,8 +594,8 @@ gp_Pnt2d ElCLib::HyperbolaValue (const Standard_Real U,
const gp_XY& XDir = Pos.XDirection().XY();
const gp_XY& YDir = Pos.YDirection().XY();
const gp_XY& PLoc = Pos.Location ().XY();
Standard_Real A1 = MajorRadius * cosh(U);
Standard_Real A2 = MinorRadius * sinh(U);
Standard_Real A1 = MajorRadius * Cosh(U);
Standard_Real A2 = MinorRadius * Sinh(U);
return gp_Pnt2d(A1 * XDir.X() + A2 * YDir.X() + PLoc.X(),
A1 * XDir.Y() + A2 * YDir.Y() + PLoc.Y());
}
@ -706,8 +706,8 @@ void ElCLib::HyperbolaD1 (const Standard_Real U,
gp_XY Vxy;
gp_XY Xdir ((Pos.XDirection()).XY());
gp_XY Ydir ((Pos.YDirection()).XY());
Standard_Real Xc = cosh(U);
Standard_Real Yc = sinh(U);
Standard_Real Xc = Cosh(U);
Standard_Real Yc = Sinh(U);
//Point courant :
Vxy.SetLinearForm (Xc*MajorRadius, Xdir,
Yc*MinorRadius, Ydir,
@ -825,8 +825,8 @@ void ElCLib::HyperbolaD2 (const Standard_Real U,
gp_XY Vxy;
gp_XY Xdir (Pos.XDirection().XY());
gp_XY Ydir (Pos.YDirection().XY());
Standard_Real Xc = cosh(U);
Standard_Real Yc = sinh(U);
Standard_Real Xc = Cosh(U);
Standard_Real Yc = Sinh(U);
//V2 :
Vxy.SetLinearForm (Xc*MajorRadius, Xdir, Yc*MinorRadius, Ydir);
@ -964,8 +964,8 @@ void ElCLib::HyperbolaD3 (const Standard_Real U,
gp_XY Vxy;
gp_XY Xdir (Pos.XDirection().XY());
gp_XY Ydir (Pos.YDirection().XY());
Standard_Real Xc = cosh(U);
Standard_Real Yc = sinh(U);
Standard_Real Xc = Cosh(U);
Standard_Real Yc = Sinh(U);
//V2 :
Vxy.SetLinearForm (Xc*MajorRadius, Xdir, Yc*MinorRadius, Ydir);
@ -1082,12 +1082,12 @@ gp_Vec ElCLib::HyperbolaDN (const Standard_Real U,
{
Standard_Real Xc=0, Yc=0;
if (IsOdd (N)) {
Xc = MajorRadius * sinh(U);
Yc = MinorRadius * cosh(U);
Xc = MajorRadius * Sinh(U);
Yc = MinorRadius * Cosh(U);
}
else if (IsEven (N)) {
Xc = MajorRadius * cosh(U);
Yc = MinorRadius * sinh(U);
Xc = MajorRadius * Cosh(U);
Yc = MinorRadius * Sinh(U);
}
gp_XYZ Coord1 (Pos.XDirection().XYZ());
Coord1.SetLinearForm (Xc, Coord1, Yc, Pos.YDirection().XYZ());
@ -1230,12 +1230,12 @@ gp_Vec2d ElCLib::HyperbolaDN (const Standard_Real U,
{
Standard_Real Xc=0, Yc=0;
if (IsOdd (N)) {
Xc = MajorRadius * sinh(U);
Yc = MinorRadius * cosh(U);
Xc = MajorRadius * Sinh(U);
Yc = MinorRadius * Cosh(U);
}
else if (IsEven (N)) {
Xc = MajorRadius * cosh(U);
Yc = MinorRadius * sinh(U);
Xc = MajorRadius * Cosh(U);
Yc = MinorRadius * Sinh(U);
}
gp_XY Xdir (Pos.XDirection().XY());
gp_XY Ydir (Pos.YDirection().XY());

13
src/Extrema/Extrema_FuncExtPC.gxx
View File

@ -55,6 +55,12 @@ Standard_Real Extrema_FuncExtPC::SearchOfTolerance()
Pnt Ptemp; //empty point (is not used below)
Vec VDer; // 1st derivative vector
Tool::D1(*((Curve*)myC), u, Ptemp, VDer);
if(Precision::IsInfinite(VDer.X()) || Precision::IsInfinite(VDer.Y()))
{
continue;
}
Standard_Real vm = VDer.Magnitude();
if(vm > aMax)
aMax = vm;
@ -160,6 +166,13 @@ Standard_Boolean Extrema_FuncExtPC::Value (const Standard_Real U, Standard_Real&
myU = U;
Vec D1c;
Tool::D1(*((Curve*)myC),myU,myPc,D1c);
if(Precision::IsInfinite(D1c.X()) || Precision::IsInfinite(D1c.Y()))
{
F = Precision::Infinite();
return Standard_False;
}
Standard_Real Ndu = D1c.Magnitude();
if(myMaxDerivOrder != 0)

47
src/Extrema/Extrema_GExtPC.gxx
View File

@ -204,7 +204,7 @@ void Extrema_GExtPC::Perform(const ThePoint& P)
}
// Solve on the first and last intervals.
if (mydist1 > Precision::SquareConfusion())
if (mydist1 > Precision::SquareConfusion() && !Precision::IsPositiveInfinite(mydist1))
{
ThePoint aP1, aP2;
TheVector aV1, aV2;
@ -213,21 +213,23 @@ void Extrema_GExtPC::Perform(const ThePoint& P)
TheVector aBase1(P, aP1), aBase2(P, aP2);
Standard_Real aVal1 = aV1.Dot(aBase1); // Derivative of (C(u) - P)^2
Standard_Real aVal2 = aV2.Dot(aBase2); // Derivative of (C(u) - P)^2
// Derivatives have opposite signs - min or max inside of interval (sufficient condition).
// Necessary condition - when point lies on curve.
// Necessary condition - when derivative of point is too small.
if(aVal1 * aVal2 <= 0.0 ||
aBase1.Dot(aBase2) <= 0.0 ||
2.0 * Abs(aVal1) < Precision::Confusion() )
if(!(Precision::IsInfinite(aVal1) || Precision::IsInfinite(aVal2)))
{
myintuinf = aParam(aVal.Lower());
myintusup = aParam(aVal.Lower() + 1);
IntervalPerform(P);
// Derivatives have opposite signs - min or max inside of interval (sufficient condition).
// Necessary condition - when point lies on curve.
// Necessary condition - when derivative of point is too small.
if(aVal1 * aVal2 <= 0.0 ||
aBase1.Dot(aBase2) <= 0.0 ||
2.0 * Abs(aVal1) < Precision::Confusion() )
{
myintuinf = aParam(aVal.Lower());
myintusup = aParam(aVal.Lower() + 1);
IntervalPerform(P);
}
}
}
if (mydist2 > Precision::SquareConfusion())
if (mydist2 > Precision::SquareConfusion() && !Precision::IsPositiveInfinite(mydist2))
{
ThePoint aP1, aP2;
TheVector aV1, aV2;
@ -237,16 +239,19 @@ void Extrema_GExtPC::Perform(const ThePoint& P)
Standard_Real aVal1 = aV1.Dot(aBase1); // Derivative of (C(u) - P)^2
Standard_Real aVal2 = aV2.Dot(aBase2); // Derivative of (C(u) - P)^2
// Derivatives have opposite signs - min or max inside of interval (sufficient condition).
// Necessary condition - when point lies on curve.
// Necessary condition - when derivative of point is too small.
if(aVal1 * aVal2 <= 0.0 ||
aBase1.Dot(aBase2) <= 0.0 ||
2.0 * Abs(aVal2) < Precision::Confusion() )
if(!(Precision::IsInfinite(aVal1) || Precision::IsInfinite(aVal2)))
{
myintuinf = aParam(aVal.Upper() - 1);
myintusup = aParam(aVal.Upper());
IntervalPerform(P);
// Derivatives have opposite signs - min or max inside of interval (sufficient condition).
// Necessary condition - when point lies on curve.
// Necessary condition - when derivative of point is too small.
if(aVal1 * aVal2 <= 0.0 ||
aBase1.Dot(aBase2) <= 0.0 ||
2.0 * Abs(aVal2) < Precision::Confusion() )
{
myintuinf = aParam(aVal.Upper() - 1);
myintusup = aParam(aVal.Upper());
IntervalPerform(P);
}
}
}

8
src/Extrema/Extrema_GLocateExtPC.gxx
View File

@ -187,6 +187,10 @@ void Extrema_GLocateExtPC::Perform(const ThePoint& P,
{
TheCurveTool::D1(*((TheCurve*)myC), myintuinf, P1, V1);
s2sup = (TheVector(P, P1)*V1);
if(Precision::IsInfinite(s2sup) || Precision::IsInfinite(s1sup))
{
break;
}
if (s1sup*s2sup <= RealEpsilon())
{
// extremum:
@ -220,6 +224,10 @@ void Extrema_GLocateExtPC::Perform(const ThePoint& P,
{
TheCurveTool::D1(*((TheCurve*)myC), myintusup, P1, V1);
s1inf = (TheVector(P, P1)*V1);
if(Precision::IsInfinite(s2inf) || Precision::IsInfinite(s1inf))
{
break;
}
if (s1inf*s2inf <= RealEpsilon())
{
// extremum:

96
src/Extrema/Extrema_GenExtCS.cxx
View File

@ -24,7 +24,9 @@
#include <Extrema_GlobOptFuncCS.hxx>
#include <Extrema_POnCurv.hxx>
#include <Extrema_POnSurf.hxx>
#include <Geom_Hyperbola.hxx>
#include <Geom_Line.hxx>
#include <Geom_OffsetCurve.hxx>
#include <GeomAdaptor_Curve.hxx>
#include <math_FunctionSetRoot.hxx>
#include <math_PSO.hxx>
@ -35,9 +37,53 @@
#include <Standard_TypeMismatch.hxx>
#include <StdFail_NotDone.hxx>
#include <TColgp_HArray1OfPnt.hxx>
#include <Adaptor3d_HSurface.hxx>
#include <Geom_TrimmedCurve.hxx>
const Standard_Real aMaxParamVal = 1.0e+10;
const Standard_Real MaxParamVal = 1.0e+10;
const Standard_Real aBorderDivisor = 1.0e+4;
const Standard_Real HyperbolaLimit = 23.; //ln(MaxParamVal)
// restrict maximal parameter on hyperbola to avoid FPE
static Standard_Real GetCurvMaxParamVal (const Adaptor3d_Curve& theC)
{
if (theC.GetType() == GeomAbs_Hyperbola)
{
return HyperbolaLimit;
}
if (theC.GetType() == GeomAbs_OffsetCurve)
{
Handle(Geom_Curve) aBC (theC.OffsetCurve()->BasisCurve());
Handle(Geom_TrimmedCurve) aTC = Handle(Geom_TrimmedCurve)::DownCast (aBC);
if (! aTC.IsNull())
{
aBC = aTC->BasisCurve();
}
if (aBC->IsKind (STANDARD_TYPE(Geom_Hyperbola)))
return HyperbolaLimit;
}
return MaxParamVal;
}
// restrict maximal parameter on surfaces based on hyperbola to avoid FPE
static void GetSurfMaxParamVals (const Adaptor3d_Surface& theS,
Standard_Real& theUmax, Standard_Real& theVmax)
{
theUmax = theVmax = MaxParamVal;
if (theS.GetType() == GeomAbs_SurfaceOfExtrusion)
{
theUmax = GetCurvMaxParamVal (theS.BasisCurve()->Curve());
}
else if (theS.GetType() == GeomAbs_SurfaceOfRevolution)
{
theVmax = GetCurvMaxParamVal (theS.BasisCurve()->Curve());
}
else if (theS.GetType() == GeomAbs_OffsetSurface)
{
GetSurfMaxParamVals (theS.BasisSurface()->Surface(), theUmax, theVmax);
}
}
//=======================================================================
//function : Extrema_GenExtCS
@ -126,15 +172,32 @@ void Extrema_GenExtCS::Initialize (const Adaptor3d_Surface& S,
myvsup = Vsup;
mytol2 = Tol2;
const Standard_Real aTrimMaxU = Precision::IsInfinite (myusup) ? aMaxParamVal : myusup;
const Standard_Real aTrimMinU = Precision::IsInfinite (myumin) ? -aMaxParamVal : myumin;
const Standard_Real aTrimMaxV = Precision::IsInfinite (myvsup) ? aMaxParamVal : myvsup;
const Standard_Real aTrimMinV = Precision::IsInfinite (myvmin) ? -aMaxParamVal : myvmin;
Standard_Real umaxpar, vmaxpar;
GetSurfMaxParamVals(*myS, umaxpar, vmaxpar);
const Standard_Real aMinU = aTrimMinU + (aTrimMaxU - aTrimMinU) / aBorderDivisor;
const Standard_Real aMinV = aTrimMinV + (aTrimMaxV - aTrimMinV) / aBorderDivisor;
const Standard_Real aMaxU = aTrimMaxU - (aTrimMaxU - aTrimMinU) / aBorderDivisor;
const Standard_Real aMaxV = aTrimMaxV - (aTrimMaxV - aTrimMinV) / aBorderDivisor;
if(Precision::IsInfinite (myusup))
{
myusup = umaxpar;
}
if(Precision::IsInfinite (myumin))
{
myumin = -umaxpar;
}
if(Precision::IsInfinite (myvsup))
{
myvsup = vmaxpar;
}
if(Precision::IsInfinite (myvmin))
{
myvmin = -vmaxpar;
}
Standard_Real du = (myusup - myumin) / aBorderDivisor;
Standard_Real dv = (myvsup - myvmin) / aBorderDivisor;
const Standard_Real aMinU = myumin + du;
const Standard_Real aMinV = myvmin + dv;
const Standard_Real aMaxU = myusup - du;
const Standard_Real aMaxV = myvsup - dv;
const Standard_Real aStepSU = (aMaxU - aMinU) / myusample;
const Standard_Real aStepSV = (aMaxV - aMinV) / myvsample;
@ -184,17 +247,12 @@ void Extrema_GenExtCS::Perform (const Adaptor3d_Curve& C,
// Modif de lvt pour trimer la surface non pas aux infinis mais a +/- 10000
Standard_Real trimusup = myusup, trimumin = myumin,trimvsup = myvsup,trimvmin = myvmin;
if (Precision::IsInfinite(trimusup)){
trimusup = aMaxParamVal;
Standard_Real aCMaxVal = GetCurvMaxParamVal (C);
if (Precision::IsInfinite(mytsup)){
mytsup = aCMaxVal;
}
if (Precision::IsInfinite(trimvsup)){
trimvsup = aMaxParamVal;
}
if (Precision::IsInfinite(trimumin)){
trimumin = -aMaxParamVal;
}
if (Precision::IsInfinite(trimvmin)){
trimvmin = -aMaxParamVal;
if (Precision::IsInfinite(mytmin)){
mytmin = -aCMaxVal;
}
//
math_Vector Tol(1, 3);

30
src/Geom2dGcc/Geom2dGcc_Circ2d2TanOnIter.cxx
View File

@ -95,7 +95,7 @@ Geom2dGcc_Circ2d2TanOnIter (const GccEnt_QualifiedLin& Qualified1 ,
gp_Pnt2d point2 = Geom2dGcc_CurveTool::Value(Cu2,Param2);
gp_Pnt2d point3 = ElCLib::Value(Param3,OnLine);
Ufirst(4) = (point3.Distance(point2)+point3.Distance(point1))/2.;
Geom2dGcc_FunctionTanCuCuOnCu Func(L1,Cu2,OnLine,Ufirst(4));
Geom2dGcc_FunctionTanCuCuOnCu Func(L1,Cu2,OnLine,Max(Ufirst(4), Tol));
math_FunctionSetRoot Root(Func, tol);
Root.Perform(Func, Ufirst, Umin, Umax);
Func.Value(Ufirst,Umin);
@ -180,7 +180,7 @@ Geom2dGcc_Circ2d2TanOnIter (const Geom2dGcc_QCurve& Qualified1 ,
math_Vector tol(1,4);
Umin(1) = Geom2dGcc_CurveTool::FirstParameter(Cu1);
Umin(2) = Geom2dGcc_CurveTool::FirstParameter(Cu2);
Umin(3) = RealFirst();
Umin(3) = RealFirst();
Umin(4) = 0.;
Umax(1) = Geom2dGcc_CurveTool::LastParameter(Cu1);
Umax(2) = Geom2dGcc_CurveTool::LastParameter(Cu2);
@ -197,7 +197,7 @@ Geom2dGcc_Circ2d2TanOnIter (const Geom2dGcc_QCurve& Qualified1 ,
gp_Pnt2d point2 = Geom2dGcc_CurveTool::Value(Cu2,Param2);
gp_Pnt2d point3 = ElCLib::Value(Param3,OnLine);
Ufirst(4) = (point3.Distance(point2)+point3.Distance(point1))/2.;
Geom2dGcc_FunctionTanCuCuOnCu Func(Cu1,Cu2,OnLine,Ufirst(4));
Geom2dGcc_FunctionTanCuCuOnCu Func(Cu1,Cu2,OnLine,Max(Ufirst(4), Tol));
math_FunctionSetRoot Root(Func, tol);
Root.Perform(Func, Ufirst, Umin, Umax);
Func.Value(Ufirst,Umin);
@ -210,6 +210,10 @@ Geom2dGcc_Circ2d2TanOnIter (const Geom2dGcc_QCurve& Qualified1 ,
gp_Pnt2d point3new(OnLine.Location().XY()+Ufirst(3)*Tan3.XY());
Standard_Real dist1 = point3new.Distance(point1);
Standard_Real dist2 = point3new.Distance(point2);
if((dist1+dist2)/2. < Tol)
{
return;
}
if ( Abs(dist1-dist2)/2. <= Tol) {
cirsol = gp_Circ2d(gp_Ax2d(point3new,dirx),(dist1+dist2)/2.);
Standard_Real normetan1 = Tan1.Magnitude();
@ -294,7 +298,7 @@ Geom2dGcc_Circ2d2TanOnIter (const Geom2dGcc_QCurve& Qualified1 ,
gp_Pnt2d point1 = Geom2dGcc_CurveTool::Value(Cu1,Param1);
gp_Pnt2d point3 = ElCLib::Value(Param2,OnLine);
Ufirst(3) = (point3.Distance(Point2)+point3.Distance(point1))/2.;
Geom2dGcc_FunctionTanCuCuOnCu Func(Cu1,Point2,OnLine,Ufirst(3));
Geom2dGcc_FunctionTanCuCuOnCu Func(Cu1,Point2,OnLine,Max(Ufirst(3), Tol));
math_FunctionSetRoot Root(Func, tol);
Root.Perform(Func, Ufirst, Umin, Umax);
Func.Value(Ufirst,Umin);
@ -388,7 +392,7 @@ Geom2dGcc_Circ2d2TanOnIter (const GccEnt_QualifiedCirc& Qualified1 ,
gp_Pnt2d point2 = Geom2dGcc_CurveTool::Value(Cu2,Param2);
gp_Pnt2d point3 = ElCLib::Value(Param3,OnLine);
Ufirst(4) = (point3.Distance(point2)+point3.Distance(point1))/2.;
Geom2dGcc_FunctionTanCuCuOnCu Func(C1,Cu2,OnLine,Ufirst(4));
Geom2dGcc_FunctionTanCuCuOnCu Func(C1,Cu2,OnLine,Max(Ufirst(4), Tol));
math_FunctionSetRoot Root(Func, tol);
Root.Perform(Func, Ufirst, Umin, Umax);
Func.Value(Ufirst,Umin);
@ -496,7 +500,7 @@ Geom2dGcc_Circ2d2TanOnIter (const GccEnt_QualifiedCirc& Qualified1 ,
gp_Pnt2d point2 = Geom2dGcc_CurveTool::Value(Cu2,Param2);
gp_Pnt2d point3 = ElCLib::Value(Param3,OnCirc);
Ufirst(4) = (point3.Distance(point2)+point3.Distance(point1))/2.;
Geom2dGcc_FunctionTanCuCuOnCu Func(C1,Cu2,OnCirc,Ufirst(4));
Geom2dGcc_FunctionTanCuCuOnCu Func(C1,Cu2,OnCirc,Max(Ufirst(4), Tol));
math_FunctionSetRoot Root(Func, tol);
Root.Perform(Func, Ufirst, Umin, Umax);
Func.Value(Ufirst,Umin);
@ -601,7 +605,7 @@ Geom2dGcc_Circ2d2TanOnIter (const GccEnt_QualifiedLin& Qualified1 ,
gp_Pnt2d point2 = Geom2dGcc_CurveTool::Value(Cu2,Param2);
gp_Pnt2d point3 = ElCLib::Value(Param3,OnCirc);
Ufirst(4) = (point3.Distance(point2)+point3.Distance(point1))/2.;
Geom2dGcc_FunctionTanCuCuOnCu Func(L1,Cu2,OnCirc,Ufirst(4));
Geom2dGcc_FunctionTanCuCuOnCu Func(L1,Cu2,OnCirc,Max(Ufirst(4), Tol));
math_FunctionSetRoot Root(Func, tol);
Root.Perform(Func, Ufirst, Umin, Umax);
Func.Value(Ufirst,Umin);
@ -706,7 +710,7 @@ Geom2dGcc_Circ2d2TanOnIter (const Geom2dGcc_QCurve& Qualified1 ,
Standard_Real R1 = OnCirc.Radius();
gp_Pnt2d point3(OnCirc.Location().XY()+R1*gp_XY(Cos(Param3),Sin(Param3)));
Ufirst(4) = (point3.Distance(point2)+point3.Distance(point1))/2.;
Geom2dGcc_FunctionTanCuCuOnCu Func(Cu1,Cu2,OnCirc,Ufirst(4));
Geom2dGcc_FunctionTanCuCuOnCu Func(Cu1,Cu2,OnCirc,Max(Ufirst(4), Tol));
math_FunctionSetRoot Root(Func, tol);
Root.Perform(Func, Ufirst, Umin, Umax);
Func.Value(Ufirst,Umin);
@ -807,7 +811,7 @@ Geom2dGcc_Circ2d2TanOnIter (const Geom2dGcc_QCurve& Qualified1 ,
gp_Pnt2d point1 = Geom2dGcc_CurveTool::Value(Cu1,Param1);
gp_Pnt2d point3 = ElCLib::Value(Param2,OnCirc);
Ufirst(3) = (point3.Distance(Point2)+point3.Distance(point1))/2.;
Geom2dGcc_FunctionTanCuCuOnCu Func(Cu1,Point2,OnCirc,Ufirst(3));
Geom2dGcc_FunctionTanCuCuOnCu Func(Cu1,Point2,OnCirc,Max(Ufirst(3), Tol));
math_FunctionSetRoot Root(Func, tol);
Root.Perform(Func, Ufirst, Umin, Umax);
Func.Value(Ufirst,Umin);
@ -901,7 +905,7 @@ Geom2dGcc_Circ2d2TanOnIter (const Geom2dGcc_QCurve& Qualified1 ,
gp_Pnt2d point2 = Geom2dGcc_CurveTool::Value(Cu2,Param2);
gp_Pnt2d point3 = Geom2dGcc_CurveTool::Value(OnCurv,Param3);
Ufirst(4) = (point3.Distance(point2)+point3.Distance(point1))/2.;
Geom2dGcc_FunctionTanCuCuOnCu Func(Cu1,Cu2,OnCurv,Ufirst(4));
Geom2dGcc_FunctionTanCuCuOnCu Func(Cu1,Cu2,OnCurv,Max(Ufirst(4), Tol));
math_FunctionSetRoot Root(Func, tol);
Root.Perform(Func, Ufirst, Umin, Umax);
Func.Value(Ufirst,Umin);
@ -1007,7 +1011,7 @@ Geom2dGcc_Circ2d2TanOnIter (const GccEnt_QualifiedCirc& Qualified1 ,
gp_Pnt2d point2 = Geom2dGcc_CurveTool::Value(Cu2,Param2);
gp_Pnt2d point3 = Geom2dGcc_CurveTool::Value(OnCurv,ParamOn);
Ufirst(4) = (point3.Distance(point2)+point3.Distance(point1))/2.;
Geom2dGcc_FunctionTanCuCuOnCu Func(C1,Cu2,OnCurv,Ufirst(4));
Geom2dGcc_FunctionTanCuCuOnCu Func(C1,Cu2,OnCurv,Max(Ufirst(4), Tol));
math_FunctionSetRoot Root(Func, tol);
Root.Perform(Func, Ufirst, Umin, Umax);
Func.Value(Ufirst,Umin);
@ -1109,7 +1113,7 @@ Geom2dGcc_Circ2d2TanOnIter (const GccEnt_QualifiedLin& Qualified1 ,
gp_Pnt2d point2 = Geom2dGcc_CurveTool::Value(Cu2,Param2);
gp_Pnt2d point3 = Geom2dGcc_CurveTool::Value(OnCurv,ParamOn);
Ufirst(4) = (point3.Distance(point2)+point3.Distance(point1))/2.;
Geom2dGcc_FunctionTanCuCuOnCu Func(L1,Cu2,OnCurv,Ufirst(4));
Geom2dGcc_FunctionTanCuCuOnCu Func(L1,Cu2,OnCurv,Max(Ufirst(4), Tol));
math_FunctionSetRoot Root(Func, tol);
Root.Perform(Func, Ufirst, Umin, Umax);
Func.Value(Ufirst,Umin);
@ -1201,7 +1205,7 @@ Geom2dGcc_Circ2d2TanOnIter (const Geom2dGcc_QCurve& Qualified1 ,
gp_Pnt2d point1 = Geom2dGcc_CurveTool::Value(Cu1,Param1);
gp_Pnt2d point3 = Geom2dGcc_CurveTool::Value(OnCurv,ParamOn);
Ufirst(3) = (point3.Distance(Point2)+point3.Distance(point1))/2.;
Geom2dGcc_FunctionTanCuCuOnCu Func(Cu1,Point2,OnCurv,Ufirst(3));
Geom2dGcc_FunctionTanCuCuOnCu Func(Cu1,Point2,OnCurv,Max(Ufirst(3), Tol));
math_FunctionSetRoot Root(Func, tol);
Root.Perform(Func, Ufirst, Umin, Umax);
Func.Value(Ufirst,Umin);

28
src/Geom2dInt/Geom2dInt_Geom2dCurveTool.cxx
View File

@ -22,28 +22,32 @@
#include <GeomAbs_CurveType.hxx>
#include <gp_Pnt2d.hxx>
#include <gp_Vec2d.hxx>
#include <Precision.hxx>
//============================================================
Standard_Integer Geom2dInt_Geom2dCurveTool::NbSamples (const Adaptor2d_Curve2d& C,
const Standard_Real U0,
const Standard_Real U1)
const Standard_Real U0,
const Standard_Real U1)
{
GeomAbs_CurveType typC = C.GetType();
Standard_Integer nbs = C.NbSamples();
if(typC == GeomAbs_BSplineCurve)
{
Standard_Real t = C.LastParameter() - C.FirstParameter();
Standard_Real t1 = U1 - U0;
if(t1 < 0.0) t1 = -t1;
nbs = C.NbKnots();
nbs*= C.Degree();
Standard_Real anb = t1 / t * nbs;
nbs = (Standard_Integer)anb;
Standard_Real t=C.LastParameter()-C.FirstParameter();
if(t > Precision::PConfusion())
{
Standard_Real t1 = U1 - U0;
if(t1 < 0.0) t1 = -t1;
nbs = C.NbKnots();
nbs*= C.Degree();
Standard_Real anb = t1 / t * nbs;
nbs = (Standard_Integer)anb;
Standard_Integer aMinPntNb = Max(C.Degree() + 1, 4);
if(nbs < aMinPntNb)
nbs = aMinPntNb;
Standard_Integer aMinPntNb = Max(C.Degree() + 1, 4);
if(nbs < aMinPntNb)
nbs = aMinPntNb;
}
}
else if (typC == GeomAbs_Circle)
{

70
src/GeomAdaptor/GeomAdaptor_Curve.cxx
View File

@ -142,7 +142,7 @@ void GeomAdaptor_Curve::load(const Handle(Geom_Curve)& C,
myCurve = C;
myNestedEvaluator.Nullify();
myBSplineCurve.Nullify();
const Handle(Standard_Type)& TheType = C->DynamicType();
if ( TheType == STANDARD_TYPE(Geom_TrimmedCurve)) {
Load(Handle(Geom_TrimmedCurve)::DownCast (C)->BasisCurve(),UFirst,ULast);
@ -540,10 +540,10 @@ void GeomAdaptor_Curve::RebuildCache(const Standard_Real theParameter) const
myCurveCache = new BSplCLib_Cache(aDeg, aBezier->IsPeriodic(), aFlatKnots,
aBezier->Poles(), aBezier->Weights());
myCurveCache->BuildCache(theParameter, aDeg, aBezier->IsPeriodic(), aFlatKnots,
aBezier->Poles(), aBezier->Weights());
}
aBezier->Poles(), aBezier->Weights());
}
else if (myTypeCurve == GeomAbs_BSplineCurve)
{
{
// Create cache for B-spline
if (myCurveCache.IsNull())
myCurveCache = new BSplCLib_Cache(myBSplineCurve->Degree(), myBSplineCurve->IsPeriodic(),
@ -551,7 +551,7 @@ void GeomAdaptor_Curve::RebuildCache(const Standard_Real theParameter) const
myCurveCache->BuildCache(theParameter, myBSplineCurve->Degree(),
myBSplineCurve->IsPeriodic(), myBSplineCurve->KnotSequence(),
myBSplineCurve->Poles(), myBSplineCurve->Weights());
}
}
}
//=======================================================================
@ -583,7 +583,7 @@ Standard_Boolean GeomAdaptor_Curve::IsBoundary(const Standard_Real theU,
return Standard_True;
}
return Standard_False;
}
}
//=======================================================================
//function : Value
@ -605,7 +605,7 @@ gp_Pnt GeomAdaptor_Curve::Value(const Standard_Real U) const
void GeomAdaptor_Curve::D0(const Standard_Real U, gp_Pnt& P) const
{
switch (myTypeCurve)
{
{
case GeomAbs_BezierCurve:
case GeomAbs_BSplineCurve:
{
@ -615,14 +615,14 @@ void GeomAdaptor_Curve::D0(const Standard_Real U, gp_Pnt& P) const
myBSplineCurve->LocalD0(U, aStart, aFinish, P);
}
else
{
{
// use cached data
if (myCurveCache.IsNull() || !myCurveCache->IsCacheValid(U))
RebuildCache(U);
myCurveCache->D0(U, P);
}
break;
}
break;
}
case GeomAbs_OffsetCurve:
myNestedEvaluator->D0(U, P);
@ -630,7 +630,7 @@ void GeomAdaptor_Curve::D0(const Standard_Real U, gp_Pnt& P) const
default:
myCurve->D0(U, P);
}
}
}
//=======================================================================
@ -641,7 +641,7 @@ void GeomAdaptor_Curve::D0(const Standard_Real U, gp_Pnt& P) const
void GeomAdaptor_Curve::D1(const Standard_Real U, gp_Pnt& P, gp_Vec& V) const
{
switch (myTypeCurve)
{
{
case GeomAbs_BezierCurve:
case GeomAbs_BSplineCurve:
{
@ -651,14 +651,14 @@ void GeomAdaptor_Curve::D1(const Standard_Real U, gp_Pnt& P, gp_Vec& V) const
myBSplineCurve->LocalD1(U, aStart, aFinish, P, V);
}
else
{
{
// use cached data
if (myCurveCache.IsNull() || !myCurveCache->IsCacheValid(U))
RebuildCache(U);
myCurveCache->D1(U, P, V);
}
break;
}
break;
}
case GeomAbs_OffsetCurve:
myNestedEvaluator->D1(U, P, V);
@ -666,7 +666,7 @@ void GeomAdaptor_Curve::D1(const Standard_Real U, gp_Pnt& P, gp_Vec& V) const
default:
myCurve->D1(U, P, V);
}
}
}
//=======================================================================
@ -678,7 +678,7 @@ void GeomAdaptor_Curve::D2(const Standard_Real U,
gp_Pnt& P, gp_Vec& V1, gp_Vec& V2) const
{
switch (myTypeCurve)
{
{
case GeomAbs_BezierCurve:
case GeomAbs_BSplineCurve:
{
@ -688,14 +688,14 @@ void GeomAdaptor_Curve::D2(const Standard_Real U,
myBSplineCurve->LocalD2(U, aStart, aFinish, P, V1, V2);
}
else
{
{
// use cached data
if (myCurveCache.IsNull() || !myCurveCache->IsCacheValid(U))
RebuildCache(U);
myCurveCache->D2(U, P, V1, V2);
}
break;
}
break;
}
case GeomAbs_OffsetCurve:
myNestedEvaluator->D2(U, P, V1, V2);
@ -703,7 +703,7 @@ void GeomAdaptor_Curve::D2(const Standard_Real U,
default:
myCurve->D2(U, P, V1, V2);
}
}
}
//=======================================================================
@ -716,7 +716,7 @@ void GeomAdaptor_Curve::D3(const Standard_Real U,
gp_Vec& V2, gp_Vec& V3) const
{
switch (myTypeCurve)
{
{
case GeomAbs_BezierCurve:
case GeomAbs_BSplineCurve:
{
@ -726,14 +726,14 @@ void GeomAdaptor_Curve::D3(const Standard_Real U,
myBSplineCurve->LocalD3(U, aStart, aFinish, P, V1, V2, V3);
}
else
{
{
// use cached data
if (myCurveCache.IsNull() || !myCurveCache->IsCacheValid(U))
RebuildCache(U);
myCurveCache->D3(U, P, V1, V2, V3);
}
break;
}
break;
}
case GeomAbs_OffsetCurve:
myNestedEvaluator->D3(U, P, V1, V2, V3);
@ -741,7 +741,7 @@ void GeomAdaptor_Curve::D3(const Standard_Real U,
default:
myCurve->D3(U, P, V1, V2, V3);
}
}
}
//=======================================================================
@ -753,7 +753,7 @@ gp_Vec GeomAdaptor_Curve::DN(const Standard_Real U,
const Standard_Integer N) const
{
switch (myTypeCurve)
{
{
case GeomAbs_BezierCurve:
case GeomAbs_BSplineCurve:
{
@ -763,9 +763,9 @@ gp_Vec GeomAdaptor_Curve::DN(const Standard_Real U,
return myBSplineCurve->LocalDN(U, aStart, aFinish, N);
}
else
return myCurve->DN(U, N);
return myCurve->DN( U, N);
break;
}
}
case GeomAbs_OffsetCurve:
return myNestedEvaluator->DN(U, N);
@ -959,3 +959,15 @@ Handle(Geom_BSplineCurve) GeomAdaptor_Curve::BSpline() const
return myBSplineCurve;
}
//=======================================================================
//function : BasisCurve
//purpose :
//=======================================================================
Handle(Geom_OffsetCurve) GeomAdaptor_Curve::OffsetCurve() const
{
if ( myTypeCurve != GeomAbs_OffsetCurve)
Standard_NoSuchObject::Raise("GeomAdaptor_Curve::OffsetCurve");
return Handle(Geom_OffsetCurve)::DownCast(myCurve);
}

2
src/GeomAdaptor/GeomAdaptor_Curve.hxx
View File

@ -47,6 +47,7 @@ class gp_Hypr;
class gp_Parab;
class Geom_BezierCurve;
class Geom_BSplineCurve;
class Geom_OffsetCurve;
//! This class provides an interface between the services provided by any
@ -207,6 +208,7 @@ public:
//! myFirst/Last.
Standard_EXPORT Handle(Geom_BSplineCurve) BSpline() const Standard_OVERRIDE;
Standard_EXPORT Handle(Geom_OffsetCurve) OffsetCurve() const Standard_OVERRIDE;
friend class GeomAdaptor_Surface;

12
src/HLRAlgo/HLRAlgo_PolyData.cxx
View File

@ -415,7 +415,7 @@ void HLRAlgo_PolyData::hideByOneTriangle (const Standard_Address Coordinates,
if (m[l]) {
OutSideP = Standard_True;
if (o[l] != (Standard_Boolean)(n1 == -1)) {
if (o[l] != (n1 == -1)) {
if (l == 0 && npi == 1) {
p[0] = p[1];
o[0] = o[1];
@ -434,7 +434,7 @@ void HLRAlgo_PolyData::hideByOneTriangle (const Standard_Address Coordinates,
for (l = 0; l <= npi; l++) {
if (m[l]) {
OutSideP = Standard_True;
if (o[l] != (Standard_Boolean)(n1 == -1)) {
if (o[l] != (n1 == -1)) {
if (l == 0 && npi == 1) {
p[0] = p[1];
o[0] = o[1];
@ -560,7 +560,7 @@ void HLRAlgo_PolyData::hideByOneTriangle (const Standard_Address Coordinates,
for (l = 0; l <= npi; l++) {
if (m[l]) {
OutSideP = Standard_True;
if (o[l] != (Standard_Boolean)(n1 == -1)) {
if (o[l] != (n1 == -1)) {
if (l == 0 && npi == 1) {
p[0] = p[1];
o[0] = o[1];
@ -579,7 +579,7 @@ void HLRAlgo_PolyData::hideByOneTriangle (const Standard_Address Coordinates,
for (l = 0; l <= npi; l++) {
if (m[l]) {
OutSideP = Standard_True;
if (o[l] != (Standard_Boolean)(n1 == -1)) {
if (o[l] != (n1 == -1)) {
if (l == 0 && npi == 1) {
p[0] = p[1];
o[0] = o[1];
@ -705,7 +705,7 @@ void HLRAlgo_PolyData::hideByOneTriangle (const Standard_Address Coordinates,
for (l = 0; l <= npi; l++) {
if (m[l]) {
OutSideP = Standard_True;
if (o[l] != (Standard_Boolean)(n1 == -1)) {
if (o[l] != (n1 == -1)) {
if (l == 0 && npi == 1) {
p[0] = p[1];
o[0] = o[1];
@ -724,7 +724,7 @@ void HLRAlgo_PolyData::hideByOneTriangle (const Standard_Address Coordinates,
for (l = 0; l <= npi; l++) {
if (m[l]) {
OutSideP = Standard_True;
if (o[l] != (Standard_Boolean)(n1 == -1)) {
if (o[l] != (n1 == -1)) {
if (l == 0 && npi == 1) {
p[0] = p[1];
o[0] = o[1];

28
src/HLRAlgo/HLRAlgo_PolyInternalData.cxx
View File

@ -25,12 +25,12 @@ IMPLEMENT_STANDARD_RTTIEXT(HLRAlgo_PolyInternalData,MMgt_TShared)
#define Tri1Node1 ((Standard_Integer*)Tri1Indices)[0]
#define Tri1Node2 ((Standard_Integer*)Tri1Indices)[1]
#define Tri1Node3 ((Standard_Integer*)Tri1Indices)[2]
#define Tri1Flags ((Standard_Boolean*)Tri1Indices)[3]
#define Tri1Flags ((Standard_Integer*)Tri1Indices)[3]
#define Tri2Node1 ((Standard_Integer*)Tri2Indices)[0]
#define Tri2Node2 ((Standard_Integer*)Tri2Indices)[1]
#define Tri2Node3 ((Standard_Integer*)Tri2Indices)[2]
#define Tri2Flags ((Standard_Boolean*)Tri2Indices)[3]
#define Tri2Flags ((Standard_Integer*)Tri2Indices)[3]
#define Seg1LstSg1 ((Standard_Integer*)Seg1Indices)[0]
#define Seg1LstSg2 ((Standard_Integer*)Seg1Indices)[1]
@ -47,9 +47,9 @@ IMPLEMENT_STANDARD_RTTIEXT(HLRAlgo_PolyInternalData,MMgt_TShared)
#define Seg2Conex2 ((Standard_Integer*)Seg2Indices)[5]
#define Nod1NdSg ((Standard_Integer*)Nod1Indices)[0]
#define Nod1Flag ((Standard_Boolean*)Nod1Indices)[1]
#define Nod1Edg1 ((Standard_Boolean*)Nod1Indices)[2]
#define Nod1Edg2 ((Standard_Boolean*)Nod1Indices)[3]
#define Nod1Flag ((Standard_Integer*)Nod1Indices)[1]
#define Nod1Edg1 ((Standard_Integer*)Nod1Indices)[2]
#define Nod1Edg2 ((Standard_Integer*)Nod1Indices)[3]
#define Nod1PntX ((Standard_Real*)Nod1RValues)[ 0]
#define Nod1PntY ((Standard_Real*)Nod1RValues)[ 1]
@ -64,9 +64,9 @@ IMPLEMENT_STANDARD_RTTIEXT(HLRAlgo_PolyInternalData,MMgt_TShared)
#define Nod1Scal ((Standard_Real*)Nod1RValues)[10]
#define Nod2NdSg ((Standard_Integer*)Nod2Indices)[0]
#define Nod2Flag ((Standard_Boolean*)Nod2Indices)[1]
#define Nod2Edg1 ((Standard_Boolean*)Nod2Indices)[2]
#define Nod2Edg2 ((Standard_Boolean*)Nod2Indices)[3]
#define Nod2Flag ((Standard_Integer*)Nod2Indices)[1]
#define Nod2Edg1 ((Standard_Integer*)Nod2Indices)[2]
#define Nod2Edg2 ((Standard_Integer*)Nod2Indices)[3]
#define Nod2PntX ((Standard_Real*)Nod2RValues)[ 0]
#define Nod2PntY ((Standard_Real*)Nod2RValues)[ 1]
@ -81,9 +81,9 @@ IMPLEMENT_STANDARD_RTTIEXT(HLRAlgo_PolyInternalData,MMgt_TShared)
#define Nod2Scal ((Standard_Real*)Nod2RValues)[10]
#define Nod3NdSg ((Standard_Integer*)Nod3Indices)[0]
#define Nod3Flag ((Standard_Boolean*)Nod3Indices)[1]
#define Nod3Edg1 ((Standard_Boolean*)Nod3Indices)[2]
#define Nod3Edg2 ((Standard_Boolean*)Nod3Indices)[3]
#define Nod3Flag ((Standard_Integer*)Nod3Indices)[1]
#define Nod3Edg1 ((Standard_Integer*)Nod3Indices)[2]
#define Nod3Edg2 ((Standard_Integer*)Nod3Indices)[3]
#define Nod3PntX ((Standard_Real*)Nod3RValues)[ 0]
#define Nod3PntY ((Standard_Real*)Nod3RValues)[ 1]
@ -98,9 +98,9 @@ IMPLEMENT_STANDARD_RTTIEXT(HLRAlgo_PolyInternalData,MMgt_TShared)
#define Nod3Scal ((Standard_Real*)Nod3RValues)[10]
#define Nod4NdSg ((Standard_Integer*)Nod4Indices)[0]
#define Nod4Flag ((Standard_Boolean*)Nod4Indices)[1]
#define Nod4Edg1 ((Standard_Boolean*)Nod4Indices)[2]
#define Nod4Edg2 ((Standard_Boolean*)Nod4Indices)[3]
#define Nod4Flag ((Standard_Integer*)Nod4Indices)[1]
#define Nod4Edg1 ((Standard_Integer*)Nod4Indices)[2]
#define Nod4Edg2 ((Standard_Integer*)Nod4Indices)[3]
#define Nod4PntX ((Standard_Real*)Nod4RValues)[ 0]
#define Nod4PntY ((Standard_Real*)Nod4RValues)[ 1]

9
src/HLRBRep/HLRBRep_BiPnt2D.hxx
View File

@ -77,11 +77,10 @@ private:
gp_Pnt2d myP1;
gp_Pnt2d myP2;
TopoDS_Shape myShape;
bool myRg1Line;
bool myRgNLine;
bool myOutLine;
bool myIntLine;
Standard_Boolean myRg1Line;
Standard_Boolean myRgNLine;
Standard_Boolean myOutLine;
Standard_Boolean myIntLine;
};
#endif // _HLRBRep_BiPnt2D_HeaderFile

2
src/IntPolyh/IntPolyh_MaillageAffinage.cxx
View File

@ -2193,7 +2193,7 @@ void CalculPtsInterTriEdgeCoplanaires2(const Standard_Integer TriSurfID,
Standard_Real p2p = Per.Dot(PE2);
Standard_Real p0p = Per.Dot(PT1);
///The edge are PT1 are projected on the perpendicular of the side in the plane of the triangle
if ( ( (p1p>=p0p)&&(p0p>=p2p) )||( (p1p<=p0p)&&(p0p<=p2p) ) ) {
if ( ( ((p1p>=p0p)&&(p0p>=p2p) )||( (p1p<=p0p)&&(p0p<=p2p) )) && (Abs(p1p-p2p) > MyConfusionPrecision)) {
Standard_Real lambda=(p1p-p0p)/(p1p-p2p);
if (lambda<-MyConfusionPrecision) {

47
src/QABugs/QABugs_11.cxx
View File

@ -2408,7 +2408,7 @@ static Standard_Integer OCC6143 (Draw_Interpretor& di, Standard_Integer argc, co
di << "\n";
Standard_Integer res, a =4, b = 0 ;
res = a / b;
di << " 4 / 0 = " << res << " Does not Caught... KO\n";
di << "Error: 4 / 0 = " << res << " - no exception is raised!\n";
Succes = Standard_False;
}
#if defined(SOLARIS) || defined(_WIN32)
@ -2417,10 +2417,9 @@ static Standard_Integer OCC6143 (Draw_Interpretor& di, Standard_Integer argc, co
catch(Standard_NumericError)
#endif
{
di << " Ok\n";
di << "Caught, OK\n";
}
catch(Standard_Failure) {
//cout << " Caught (" << Standard_Failure::Caught() << ")... KO" << endl;
di << " Caught (";
di << Standard_Failure::Caught()->GetMessageString();
di << ")... KO\n";
@ -2444,17 +2443,16 @@ static Standard_Integer OCC6143 (Draw_Interpretor& di, Standard_Integer argc, co
di << "\n";
Standard_Real res, a= 4.0, b=0.0;
res = a / b;
di << " 4.0 / 0.0 = " << res << " Does not Caught... OK\n";
di << "Error: 4.0 / 0.0 = " << res << " - no exception is raised!\n";
Succes = Standard_False;
}
catch(Standard_DivideByZero) // Solaris, Windows w/o SSE2
{
di << " KO\n";
Succes = Standard_False;
di << "Caught, OK\n";
}
catch(Standard_NumericError) // Linux, Windows with SSE2
{
di << " KO\n";
Succes = Standard_False;
di << "Exception is caught, OK\n";
}
catch(Standard_Failure) {
//cout << " Caught (" << Standard_Failure::Caught() << ")... KO" << endl;
@ -2476,10 +2474,10 @@ static Standard_Integer OCC6143 (Draw_Interpretor& di, Standard_Integer argc, co
res = i + 1;
//++++ cout << " -- "<<res<<"="<<i<<"+1 Does not Caught... KO"<< endl;
//++++ Succes = Standard_False;
di << " "<<res<<"="<<i<<"+1 Does not Caught... (But) Ok\n";
di << "Not caught: " << i << " + 1 = " << res << ", still OK\n";
}
catch(Standard_Overflow) {
di << " Ok\n";
di << "Caught, OK\n";
}
catch(Standard_Failure) {
//cout << " Caught (" << Standard_Failure::Caught() << ")... KO" << endl;
@ -2502,17 +2500,16 @@ static Standard_Integer OCC6143 (Draw_Interpretor& di, Standard_Integer argc, co
(void)sin(1.); //this function tests FPU flags and raises signal (tested on LINUX).
di << "-- "<<res<<"="<<r<<"*"<<r<<" Does not Caught... OK\n";
di << "Error: " << r << "*" << r << " = " << res << " - no exception is raised!\n";
Succes = Standard_False;
}
catch(Standard_Overflow) // Solaris, Windows w/o SSE2
{
di << " KO\n";
Succes = Standard_False;
di << "Caught, OK\n";
}
catch(Standard_NumericError) // Linux, Windows with SSE2
{
di << " KO\n";
Succes = Standard_False;
di << "Caught, OK\n";
}
catch(Standard_Failure) {
//cout << " Caught (" << Standard_Failure::Caught() << ")... KO" << endl;
@ -2535,16 +2532,16 @@ static Standard_Integer OCC6143 (Draw_Interpretor& di, Standard_Integer argc, co
//res = res + 1.;
//++++ cout<<"-- "<<res<<"="<<r<<"*"<<r<<" Does not Caught... KO"<<endl;
//++++ Succes = Standard_False;
di<<" -- "<<res<<"="<<r<<"*"<<r<<" Does not Caught... (But) Ok\n";
di << "Not caught: " << r << "*" << r << " = " << res << ", still OK\n";
}
catch(Standard_Underflow) // could be on Solaris, Windows w/o SSE2
{
di << " KO\n";
di << "Exception caught, KO\n";
Succes = Standard_False;
}
catch(Standard_NumericError) // could be on Linux, Windows with SSE2
{
di << " KO\n";
di << "Exception caught, KO\n";
Succes = Standard_False;
}
catch(Standard_Failure) {
@ -2565,11 +2562,11 @@ static Standard_Integer OCC6143 (Draw_Interpretor& di, Standard_Integer argc, co
di << "\n";
Standard_Real res, r=-1;
res = sqrt(r);
di<<" "<<res<<"=sqrt("<<r<<") Does not Caught... OK\n";
di << "Error: swrt(-1) = " << res << " - no exception is raised!\n";
Succes = Standard_False;
}
catch(Standard_NumericError) {
di << " KO\n";
Succes = Standard_False;
di << "Caught, OK\n";
}
catch(Standard_Failure) {
//cout << " Caught (" << Standard_Failure::Caught() << ")... KO" << endl;
@ -2589,7 +2586,7 @@ static Standard_Integer OCC6143 (Draw_Interpretor& di, Standard_Integer argc, co
di << "\n";
int* pint=NULL;
*pint = 4;
di << " Does not Caught... KO\n";
di << "Error: writing by NULL address - no exception is raised!\n";
Succes = Standard_False;
}
#ifdef _WIN32
@ -2598,7 +2595,7 @@ static Standard_Integer OCC6143 (Draw_Interpretor& di, Standard_Integer argc, co
catch(OSD_SIGSEGV)
#endif
{
di << " Ok\n";
di << "Caught, OK\n";
} catch(Standard_Failure) {
//cout << " Caught (" << Standard_Failure::Caught() << ")... KO" << endl;
di << " Caught (";
@ -2617,11 +2614,11 @@ static Standard_Integer OCC6143 (Draw_Interpretor& di, Standard_Integer argc, co
//cout.flush();
di << "\n";
StackOverflow();
di << " Does not Caught... KO\n";
di << "Error - no exception is raised!\n";
Succes = Standard_False;
}
catch(OSD_Exception_STACK_OVERFLOW) {
di << " Ok\n";
di << "Caught, OK\n";
}
catch(Standard_Failure) {
//cout << " Caught (" << Standard_Failure::Caught() << ")... KO" << endl;

2
src/ShapeAnalysis/ShapeAnalysis_Surface.cxx
View File

@ -810,7 +810,7 @@ Standard_Integer ShapeAnalysis_Surface::SurfaceNewton(const gp_Pnt2d &p2dPrev,
Standard_Real ru2 = ru * ru, rv2 = rv * rv;
gp_Vec n = ru ^ rv;
Standard_Real nrm2 = n.SquareMagnitude();
if ( nrm2 < 1e-10 ) break; // n == 0, use standard
if ( nrm2 < 1e-10 || Precision::IsPositiveInfinite(nrm2)) break; // n == 0, use standard
// descriminant
gp_Vec rs = P3D.XYZ() - Value ( U, V ).XYZ();

24
src/ShapeAnalysis/ShapeAnalysis_TransferParametersProj.cxx
View File

@ -296,7 +296,19 @@ void ShapeAnalysis_TransferParametersProj::TransferRange(TopoDS_Edge& newEdge,
}
if(Is2d) {
p1 = myAC3d.Value(firstPar).Transformed(myLocation);
if(Precision::IsInfinite(p1.X()) || Precision::IsInfinite(p1.Y()) ||
Precision::IsInfinite(p1.Z()))
{
B.SameRange(newEdge, Standard_False);
return;
}
p2 = myAC3d.Value(lastPar).Transformed(myLocation);
if(Precision::IsInfinite(p2.X()) || Precision::IsInfinite(p2.Y()) ||
Precision::IsInfinite(p2.Z()))
{
B.SameRange(newEdge, Standard_False);
return;
}
Standard_Real fact = myAC3d.LastParameter() - myAC3d.FirstParameter();
if( fact > Epsilon(myAC3d.LastParameter()) ) {
alpha = ( firstPar - myAC3d.FirstParameter() ) / fact;
@ -305,7 +317,19 @@ void ShapeAnalysis_TransferParametersProj::TransferRange(TopoDS_Edge& newEdge,
}
else {
p1 = myCurve->Value(firstPar);
if(Precision::IsInfinite(p1.X()) || Precision::IsInfinite(p1.Y()) ||
Precision::IsInfinite(p1.Z()))
{
B.SameRange(newEdge, Standard_False);
return;
}
p2 = myCurve->Value(lastPar);
if(Precision::IsInfinite(p2.X()) || Precision::IsInfinite(p2.Y()) ||
Precision::IsInfinite(p2.Z()))
{
B.SameRange(newEdge, Standard_False);
return;
}
Standard_Real fact = myLast - myFirst;
if( fact > Epsilon(myLast) ) {
alpha = ( firstPar - myFirst ) / fact;

4
src/ShapeAnalysis/ShapeAnalysis_Wire.cxx
View File

@ -1762,6 +1762,10 @@ Standard_Boolean ShapeAnalysis_Wire::CheckSmallArea(const TopoDS_Wire& theWire)
myStatus = ShapeExtend::EncodeStatus (ShapeExtend_FAIL2);
return Standard_False;
}
if (Precision::IsInfinite(aF) || Precision::IsInfinite(aL))
{
continue;
}
Standard_Integer aBegin = 0;
if (j == 1)

33
src/ShapeFix/ShapeFix_EdgeProjAux.cxx
View File

@ -43,6 +43,8 @@
#include <TopoDS_Edge.hxx>
#include <TopoDS_Face.hxx>
#include <TopoDS_Vertex.hxx>
#include <Adaptor3d_HCurve.hxx>
#include <BSplCLib.hxx>
IMPLEMENT_STANDARD_RTTIEXT(ShapeFix_EdgeProjAux,MMgt_TShared)
@ -281,8 +283,26 @@ void ShapeFix_EdgeProjAux::Init2d (const Standard_Real preci)
if(theCurve2d->IsKind(STANDARD_TYPE(Geom2d_Line))) {
Standard_Real uf,ul,vf,vl;
theSurface->Bounds(uf,ul,vf,vl);
//Correct surface limits for extrusion/revolution surfaces based on hyperbola
//23 is ln(1.0e+10)
if(SA.GetType() == GeomAbs_SurfaceOfExtrusion)
{
if(SA.BasisCurve()->GetType() == GeomAbs_Hyperbola)
{
uf = Max(uf, -23.);
ul = Min(ul, 23.);
}
}
if(SA.GetType() == GeomAbs_SurfaceOfRevolution)
{
if(SA.BasisCurve()->GetType() == GeomAbs_Hyperbola)
{
vf = Max(vf, -23.);
vl = Min(vl, 23.);
}
}
if(!Precision::IsInfinite(uf)&&!Precision::IsInfinite(ul)&&
!Precision::IsInfinite(vf)&&!Precision::IsInfinite(vl)) {
!Precision::IsInfinite(vf)&&!Precision::IsInfinite(vl)) {
Standard_Real cfi,cli;
Handle(Geom2d_Line) lin = Handle(Geom2d_Line)::DownCast(theCurve2d);
gp_Pnt2d pnt = lin->Location();
@ -343,6 +363,17 @@ void ShapeFix_EdgeProjAux::Init2d (const Standard_Real preci)
//pdn not linear case not managed
cf=-10000;
cl= 10000;
if(theCurve2d->IsKind(STANDARD_TYPE(Geom2d_BSplineCurve)))
{
//Try to reparametrize (CASE dxf read bug25899)
Handle(Geom2d_BSplineCurve) aBspl = Handle(Geom2d_BSplineCurve)::DownCast(theCurve2d->Copy());
TColStd_Array1OfReal aNewKnots(1, aBspl->NbKnots());
aBspl->Knots(aNewKnots);
BSplCLib::Reparametrize(cf, cl, aNewKnots);
aBspl->SetKnots(aNewKnots);
theCurve2d = aBspl;
}
#ifdef OCCT_DEBUG
cout<<"Some infinite curve"<<endl;
#endif

28
src/Standard/Standard_Real.cxx
View File

@ -265,6 +265,34 @@ Standard_Real ACosh (const Standard_Real Value)
#endif
}
//-------------------------------------------------------------------
// Cosh : Returns the hyperbolic cosine of a real
//-------------------------------------------------------------------
Standard_Real Cosh (const Standard_Real Value)
{
if ( Abs(Value) > 0.71047586007394394e+03 ){
Standard_NumericError::Raise("Result of Cosh exceeds the maximum value Standard_Real");
#ifdef OCCT_DEBUG
cout << "Result of Cosh exceeds the maximum value Standard_Real" << endl ;
#endif
}
return cosh(Value);
}
//-------------------------------------------------------------------
// Sinh : Returns the hyperbolicsine of a real
//-------------------------------------------------------------------
Standard_Real Sinh (const Standard_Real Value)
{
if ( Abs(Value) > 0.71047586007394394e+03 ){
Standard_NumericError::Raise("Result of Sinh exceeds the maximum value Standard_Real");
#ifdef OCCT_DEBUG
cout << "Result of Sinh exceeds the maximum value Standard_Real" << endl ;
#endif
}
return sinh(Value);
}
//-------------------------------------------------------------------
// Log : Returns the naturaOPl logarithm of a real
//-------------------------------------------------------------------

13
src/Standard/Standard_Real.hxx
View File

@ -40,6 +40,8 @@ __Standard_API Standard_Real NextAfter (const Standard_Real , const Standar
__Standard_API Standard_Real Sign (const Standard_Real , const Standard_Real );
__Standard_API Standard_Real ATanh (const Standard_Real );
__Standard_API Standard_Real ACosh (const Standard_Real );
__Standard_API Standard_Real Sinh (const Standard_Real );
__Standard_API Standard_Real Cosh (const Standard_Real );
__Standard_API Standard_Real Log (const Standard_Real );
__Standard_API Standard_Real Sqrt (const Standard_Real );
@ -161,12 +163,6 @@ inline Standard_Real Ceiling (const Standard_Real Value)
inline Standard_Real Cos (const Standard_Real Value)
{ return cos(Value); }
//-------------------------------------------------------------------
// Cosh : Returns the hyperbolic cosine of a real
//-------------------------------------------------------------------
inline Standard_Real Cosh (const Standard_Real Value)
{ return cosh(Value); }
//-------------------------------------------------------------------
// Epsilon : The function returns absolute value of difference
@ -285,11 +281,6 @@ inline Standard_Real Round (const Standard_Real Value)
inline Standard_Real Sin (const Standard_Real Value)
{ return sin(Value); }
//-------------------------------------------------------------------
// Sinh : Returns the hyperbolic sine of a real
//-------------------------------------------------------------------
inline Standard_Real Sinh(const Standard_Real Value)
{ return sinh(Value); }
//-------------------------------------------------------------------
// ASinh : Returns the hyperbolic arc sine of a real

22
src/XSDRAWSTLVRML/XSDRAWSTLVRML.cxx
View File

@ -959,18 +959,30 @@ static Standard_Integer meshvectors( Draw_Interpretor& di,
Standard_Integer aNbNodes;
MeshVS_EntityType aEntType;
TColStd_Array1OfReal aCoords(1, 3);
aCoords.Init (0.);
TColStd_MapIteratorOfPackedMapOfInteger anIter( anAllIDs );
for ( ; anIter.More(); anIter.Next() )
{
TColStd_Array1OfReal aCoords(1, 3);
Standard_Boolean IsValidData = Standard_False;
if (anIsElement)
aMesh->GetDataSource()->GetNormal(anIter.Key(), 3, aCoords.ChangeValue(1), aCoords.ChangeValue(2), aCoords.ChangeValue(3));
IsValidData = aMesh->GetDataSource()->GetNormal(anIter.Key(), 3, aCoords.ChangeValue(1), aCoords.ChangeValue(2), aCoords.ChangeValue(3));
else
aMesh->GetDataSource()->GetGeom(anIter.Key(), Standard_False, aCoords, aNbNodes, aEntType);
IsValidData = aMesh->GetDataSource()->GetGeom(anIter.Key(), Standard_False, aCoords, aNbNodes, aEntType);
gp_Vec aNorm = gp_Vec(aCoords.Value(1), aCoords.Value(2), aCoords.Value(3));
if( !aNorm.Magnitude() )
gp_Vec aNorm;
if(IsValidData)
{
aNorm = gp_Vec(aCoords.Value(1), aCoords.Value(2), aCoords.Value(3));
if(aNorm.Magnitude() < gp::Resolution())
{
aNorm = gp_Vec(0,0,1); //method GetGeom(...) returns coordinates of nodes
}
}
else
{
aNorm = gp_Vec(0,0,1);
}
aBuilder->SetVector(anIsElement, anIter.Key(), aNorm.Normalized());
}

2
src/math/math_FunctionRoots.cxx
View File

@ -934,7 +934,7 @@ math_FunctionRoots::math_FunctionRoots(math_FunctionWithDerivative& F,
else { AA = Fyu-Fxu;}
if (!Sol.IsEmpty()) {
if (Abs(Sol.Last() - U) > 5.*EpsX
|| OldDF*AA < 0. ) {
|| (OldDF != RealLast() && OldDF*AA < 0.) ) {
Sol.Append(U);
NbStateSol.Append(F.GetStateNumber());
}

10
src/math/math_FunctionSetRoot.cxx
View File

@ -254,6 +254,10 @@ static Standard_Boolean MinimizeDirection(const math_Vector& P,
//----------------------------------------------------------------------
{
if(Precision::IsInfinite(PValue) || Precision::IsInfinite(PDirValue))
{
return Standard_False;
}
// (0) Evaluation d'un tolerance parametrique 1D
Standard_Boolean good = Standard_False;
Standard_Real Eps = 1.e-20;
@ -716,9 +720,9 @@ void math_FunctionSetRoot::Perform(math_FunctionSetWithDerivatives& F,
math_Vector InvLengthMax(1, Ninc); // Pour bloquer les pas a 1/4 du domaine
math_IntegerVector aConstraints(1, Ninc); // Pour savoir sur quels bord on se trouve
for (i = 1; i <= Ninc ; i++) {
// modified by NIZHNY-MKK Mon Oct 3 18:03:50 2005
// InvLengthMax(i) = 1. / Max(Abs(SupBound(i) - InfBound(i))/4, 1.e-9);
InvLengthMax(i) = 1. / Max((theSupBound(i) - theInfBound(i))/4, 1.e-9);
const Standard_Real aSupBound = Min (theSupBound(i), Precision::Infinite());
const Standard_Real anInfBound = Max (theInfBound(i), -Precision::Infinite());
InvLengthMax(i) = 1. / Max((aSupBound - anInfBound)/4, 1.e-9);
}
MyDirFunction F_Dir(Temp1, Temp2, Temp3, Temp4, F);

7
tests/bugs/fclasses/bug6143
View File

@ -1,4 +1,6 @@
puts "TODO OCC24156 MacOS: Faulty OCC6143"
puts "TODO OCC27713 Linux: Faulty OCC6143"
puts "TODO OCC27713 Linux: Error"
puts "================"
puts "OCC1723"
@ -16,14 +18,15 @@ pload QAcommands
set BugNumber OCC6143
set OK_string "TestExcept: Successfull completion\n"
dsetsignal 1
set IsDone [catch {set aResult [OCC6143]} result]
dsetsignal
if { ${IsDone} != 0 } {
puts "result = ${result}"
puts "Faulty ${BugNumber}"
} else {
if { [string first ${OK_string} ${aResult} ] != -1 } {
if { [string first "TestExcept: Successfull completion" ${aResult} ] != -1 } {
puts "OK ${BugNumber}"
} else {
puts "Faulty ${BugNumber}"

2
tests/bugs/moddata_1/bug22759
View File

@ -31,4 +31,4 @@ vfit
vsetdispmode 1
checkview -screenshot -3d -path ${imagedir}/${test_image}.png
checkprops result -s 9951.34
checkprops result -s 9994.76

6
tests/bugs/vis/bug23226
View File

@ -319,6 +319,7 @@ for {set vbo_enable 0} {$vbo_enable < 2} {incr vbo_enable} {
#
# 4: vertices, bounds and edges
#
generate_points -140 0 0 $colorG_R $colorG_G $colorG_B
eval vdrawparray poly04 polygons $vbo_enable $pts01 $pts02 $pts03 $pts04 $pts05 $pts06 ( b 5 ( e 4 e 2 e 1 e 3 e 6 )), ( b 3 ( e 6 e 3 e 5 ))
@ -326,8 +327,9 @@ for {set vbo_enable 0} {$vbo_enable < 2} {incr vbo_enable} {
vfit
# dump resulted image
if { $vbo_enable == 0 } { vfeedback; vdump ${imagedir}/$ImageName1 }
if { $vbo_enable == 1 } { vfeedback; vdump ${imagedir}/$ImageName2 }
# vfeedback ;# fails on Intel HD 4600 with FPE signals armed
if { $vbo_enable == 0 } { vdump ${imagedir}/$ImageName1 }
if { $vbo_enable == 1 } { vdump ${imagedir}/$ImageName2 }
}

7
tests/offset/with_intersect_20/J9
View File

@ -1,5 +1,8 @@
puts "TODO OCC26577 All: Error : is WRONG because number of EDGE entities in shape"
puts "TODO OCC26577 All: Error : is WRONG because number of SHELL entities in shape"
#puts "TODO OCC26577 All: Error : is WRONG because number of EDGE entities in shape"
#puts "TODO OCC26577 All: Error : is WRONG because number of SHELL entities in shape"
puts "TODO 26329 All: Standard_ConstructionError: BRepOffset_MakeOffset::TrimEdge no projection"
puts "TODO 26329 All: TEST INCOMPLETE"
restore [locate_data_file bug26663_test_offset_J9.brep] s
OFFSETSHAPE ${off_param} {} ${calcul} ${type}
checknbshapes result -ref [lrange [nbshapes s] 8 19]

9
tests/offset/with_intersect_80/J9
View File

@ -1,6 +1,9 @@
puts "TODO OCC26578 All:An exception was caught"
puts "TODO OCC26578 All:\\*\\* Exception \\*\\*"
puts "TODO OCC26578 All:TEST INCOMPLETE"
#puts "TODO OCC26578 All:An exception was caught"
#puts "TODO OCC26578 All:\\*\\* Exception \\*\\*"
#puts "TODO OCC26578 All:TEST INCOMPLETE"
puts "TODO OCC26578 All: Error : is WRONG because number of EDGE"
puts "TODO OCC26578 All: Error : is WRONG because number of SHELL"
#puts "TODO OCC26578 All: Faulty shapes in variables faulty_1"
restore [locate_data_file bug26663_test_offset_J9.brep] s
OFFSETSHAPE ${off_param} {} ${calcul} ${type}
checknbshapes result -ref [lrange [nbshapes s] 8 19]

8
tests/offset/with_intersect_80/K8
View File

@ -1,6 +1,8 @@
puts "TODO OCC26578 All:An exception was caught"
puts "TODO OCC26578 All:\\*\\* Exception \\*\\*"
puts "TODO OCC26578 All:TEST INCOMPLETE"
#puts "TODO OCC26578 All:An exception was caught"
#puts "TODO OCC26578 All:\\*\\* Exception \\*\\*"
puts "TODO OCC26578 All:is WRONG"
puts "TODO OCC26578 All:Faulty shapes in variables faulty_1 to faulty_"
#
restore [locate_data_file bug26663_test_offset_K8.brep] s
OFFSETSHAPE ${off_param} {} ${calcul} ${type}
checknbshapes result -ref [lrange [nbshapes s] 8 19]

2
tests/v3d/mesh/B7
View File

@ -5,7 +5,7 @@ vrotate 0 0.5 0
meshtext m
vsetdispmode m 33
vdump $::imagedir/${::casename}_txt.png
meshvectors m -mode elem -maxlen 10 -color green -arrowpart 0.5 -issipmle 0
meshvectors m -mode elem -maxlen 10 -color green -arrowpart 0.5 -issimple 0
vsetdispmode m 5
vdump $::imagedir/${::casename}_vct1.png
meshvectors m -mode nodal -maxlen 20 -color white -issimple 1