0026329: Restore floating point signals handling in DRAW
authorifv <ifv@opencascade.com>
Tue, 9 Aug 2016 17:12:59 +0000 (20:12 +0300)
committerkgv <kgv@opencascade.com>
Fri, 30 Sep 2016 08:17:17 +0000 (11:17 +0300)
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.

48 files changed:
src/Adaptor3d/Adaptor3d_Curve.cxx
src/Adaptor3d/Adaptor3d_Curve.hxx
src/Adaptor3d/Adaptor3d_HCurve.hxx
src/Adaptor3d/Adaptor3d_HCurve.lxx
src/ApproxInt/ApproxInt_KnotTools.cxx
src/BOPAlgo/BOPAlgo_PaveFiller_6.cxx
src/BRepAdaptor/BRepAdaptor_Curve.cxx
src/BRepAdaptor/BRepAdaptor_Curve.hxx
src/BRepCheck/BRepCheck_Edge.cxx
src/BRepClass3d/BRepClass3d_SClassifier.cxx
src/BRepGProp/BRepGProp_Face.cxx
src/BRepLib/BRepLib.cxx
src/BRepMesh/BRepMesh_FastDiscretFace.cxx
src/BRepOffset/BRepOffset_Tool.cxx
src/BRepTest/BRepTest_FeatureCommands.cxx
src/CSLib/CSLib_NormalPolyDef.cxx
src/Draw/Draw_BasicCommands.cxx
src/DrawResources/DrawDefault
src/ElCLib/ElCLib.cxx
src/Extrema/Extrema_FuncExtPC.gxx
src/Extrema/Extrema_GExtPC.gxx
src/Extrema/Extrema_GLocateExtPC.gxx
src/Extrema/Extrema_GenExtCS.cxx
src/Geom2dGcc/Geom2dGcc_Circ2d2TanOnIter.cxx
src/Geom2dInt/Geom2dInt_Geom2dCurveTool.cxx
src/GeomAdaptor/GeomAdaptor_Curve.cxx
src/GeomAdaptor/GeomAdaptor_Curve.hxx
src/HLRAlgo/HLRAlgo_PolyData.cxx
src/HLRAlgo/HLRAlgo_PolyInternalData.cxx
src/HLRBRep/HLRBRep_BiPnt2D.hxx
src/IntPolyh/IntPolyh_MaillageAffinage.cxx
src/QABugs/QABugs_11.cxx
src/ShapeAnalysis/ShapeAnalysis_Surface.cxx
src/ShapeAnalysis/ShapeAnalysis_TransferParametersProj.cxx
src/ShapeAnalysis/ShapeAnalysis_Wire.cxx
src/ShapeFix/ShapeFix_EdgeProjAux.cxx
src/Standard/Standard_Real.cxx
src/Standard/Standard_Real.hxx
src/XSDRAWSTLVRML/XSDRAWSTLVRML.cxx
src/math/math_FunctionRoots.cxx
src/math/math_FunctionSetRoot.cxx
tests/bugs/fclasses/bug6143
tests/bugs/moddata_1/bug22759
tests/bugs/vis/bug23226
tests/offset/with_intersect_20/J9
tests/offset/with_intersect_80/J9
tests/offset/with_intersect_80/K8
tests/v3d/mesh/B7

index 487dd59..4825344 100644 (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)();
+}
index 647cf03..de882dc 100644 (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();
 
 
index 2ca8d25..be29b50 100644 (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)
index 8a81896..48b2d8d 100644 (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();
+}
index 0fa2043..7d7a77d 100644 (file)
 #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;
index c3b5b1a..b6730c0 100644 (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;
       }
       //
index ca986ab..c1b0751 100644 (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));
+}
index 7440175..96a87a7 100644 (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;
 
 
 
index 0c19274..e0261a0 100644 (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;
     }
index 6a68919..16e0bf8 100644 (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())
index 0ce1303..4484d21 100644 (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));
index aced41c..3d42110 100644 (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());
index 80df07b..89cbc89 100644 (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
index 356ae06..0874a23 100644 (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 );
+          }
        }
     }
 }
index 28e8094..79bf466 100644 (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",
index 909c5ee..5104fbc 100644 (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))*
index 0fda933..7c9487d 100644 (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>
@@ -741,6 +742,31 @@ static int dperf (Draw_Interpretor& theDI, Standard_Integer theArgNb, const char
 }
 
 //==============================================================================
+//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!
index bb37408..d5973b8 100755 (executable)
@@ -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
index 170dd2d..6bfb2de 100644 (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());
index a79915d..8d83e39 100644 (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)
index a61234c..2ed746d 100644 (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);
+          }
         }
       }
 
index 5f9a911..3f5eb2e 100644 (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:
index dca7a2a..edf0247 100644 (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>
 #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;
-  }
-  if (Precision::IsInfinite(trimvsup)){
-    trimvsup = aMaxParamVal;
-  }
-  if (Precision::IsInfinite(trimumin)){
-    trimumin = -aMaxParamVal;
+  Standard_Real aCMaxVal = GetCurvMaxParamVal (C);
+  if (Precision::IsInfinite(mytsup)){
+    mytsup = aCMaxVal;
   }
-  if (Precision::IsInfinite(trimvmin)){
-    trimvmin = -aMaxParamVal;
+  if (Precision::IsInfinite(mytmin)){
+    mytmin = -aCMaxVal;
   }
   //
   math_Vector Tol(1, 3);
index 3c0a921..f544121 100644 (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);
index cdeca87..d9c7ade 100644 (file)
 #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)
   {
index 5be1665..90f9214 100644 (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);
+}
index 1cc735c..6904809 100644 (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;
 
index 108c109..759d60f 100644 (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];
index f174de7..69c26a2 100644 (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]
index b85d128..6b1fc43 100644 (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
index 78ee8bd..5f85179 100644 (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) {
 
index 6029068..2c1d49d 100644 (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;
index f5350f5..22dc6a3 100644 (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();
index dca87dd..3cf48a8 100644 (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;
index 9de7601..a49c025 100644 (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)
index 08b0065..e19cd9b 100644 (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 
index 8345a81..0c97334 100644 (file)
@@ -266,6 +266,34 @@ Standard_Real     ACosh (const Standard_Real Value)
 }
 
 //-------------------------------------------------------------------
+// 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
 //-------------------------------------------------------------------
 Standard_Real     Log (const Standard_Real Value) 
index 6ce243e..84e84e0 100644 (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
index bcc5c64..43e5d31 100644 (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());
     }
 
index 43903ba..7e19758 100644 (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());
              }
index aa41d3d..7e2f7a1 100644 (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);
index 3e1ffff..a3bbb06 100644 (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}"
index ee0042c..c9d306e 100755 (executable)
@@ -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
index 5cdf5d4..fdf76f4 100755 (executable)
@@ -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 }
 
 }
 
index 55246c9..3be5c69 100644 (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]
index 5c5f4e7..4db409e 100644 (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]
index c7b86dc..d3cbc90 100644 (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]
index afd1f7a..17c86a4 100644 (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