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.
#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>
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)();
+}
class gp_Parab;
class Geom_BezierCurve;
class Geom_BSplineCurve;
+class Geom_OffsetCurve;
//! Root class for 3D curves on which geometric
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();
class gp_Vec;
class Geom_BezierCurve;
class Geom_BSplineCurve;
+class Geom_OffsetCurve;
class Adaptor3d_HCurve;
Handle(Geom_BSplineCurve) BSpline() const;
-
+ Handle(Geom_OffsetCurve) OffsetCurve() const;
DEFINE_STANDARD_RTTIEXT(Adaptor3d_HCurve,MMgt_TShared)
return Curve().BSpline();
}
+//=======================================================================
+//function : BasisCurve
+//purpose :
+//=======================================================================
+
+ inline Handle(Geom_OffsetCurve) Adaptor3d_HCurve::OffsetCurve() const
+{
+ return Curve().OffsetCurve();
+}
#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.
{
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;
}
//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));
{
if(ChkCurv)
{
- Standard_Real sina;
Standard_Integer ici = (anInd - theCurv.Lower()) * theDim,
ici1 = (anInd1 - theCurv.Lower()) * theDim,
icm = (mid - theCurv.Lower()) * theDim;
}
//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;
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;
//
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;
}
//
#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>
#include <Standard_OutOfRange.hxx>
#include <TopoDS_Edge.hxx>
#include <TopoDS_Face.hxx>
+#include <Geom_OffsetCurve.hxx>
+#include <GeomAdaptor_HCurve.hxx>
//=======================================================================
//function : BRepAdaptor_Curve
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));
+}
class gp_Parab;
class Geom_BezierCurve;
class Geom_BSplineCurve;
+class Geom_OffsetCurve;
//! The Curve from BRepAdaptor allows to use an Edge
//! using this method
Standard_EXPORT Handle(Geom_BSplineCurve) BSpline() const Standard_OVERRIDE;
+ Standard_EXPORT Handle(Geom_OffsetCurve) OffsetCurve() const Standard_OVERRIDE;
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;
}
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())
#include <TopoDS_Edge.hxx>
#include <TopoDS_Face.hxx>
+static const Standard_Real Epsilon1 = Epsilon(1.);
+
//=======================================================================
//function : UIntegrationOrder
//purpose :
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));
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;
}
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;
}
//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;
// 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()) {
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();
}
//Vertices are processed
+ const Standard_Real BigTol = 1.e10;
parents.Clear();
TopExp::MapShapesAndAncestors(aShape, TopAbs_VERTEX, TopAbs_EDGE, parents);
TColStd_MapOfTransient Initialized;
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());
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
(theSurf->Transformed(theLoc.Transformation()));
Handle(Geom2d_Curve) ProjPCurve =
GeomProjLib::Curve2d( C3d, f, l, theSurf );
- CurveRep->PCurve( ProjPCurve );
+ if(!ProjPCurve.IsNull())
+ {
+ CurveRep->PCurve( ProjPCurve );
+ }
}
}
}
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 : ";
__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",
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);
}
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);
}
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))*
#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>
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 :
__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!
_update_c_env env "" "unset"
}
+# arm signal handler with default FPE setting
+dsetsignal
+
# silent return from the script
return
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());
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());
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());
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());
}
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,
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);
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);
{
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());
{
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());
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;
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)
}
// Solve on the first and last intervals.
- if (mydist1 > Precision::SquareConfusion())
+ if (mydist1 > Precision::SquareConfusion() && !Precision::IsPositiveInfinite(mydist1))
{
ThePoint aP1, aP2;
TheVector aV1, aV2;
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;
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);
+ }
}
}
{
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:
{
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:
#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
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;
// 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);
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);
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);
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);
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();
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
#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)
{
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);
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(),
myCurveCache->BuildCache(theParameter, myBSplineCurve->Degree(),
myBSplineCurve->IsPeriodic(), myBSplineCurve->KnotSequence(),
myBSplineCurve->Poles(), myBSplineCurve->Weights());
- }
+}
}
//=======================================================================
return Standard_True;
}
return Standard_False;
-}
+ }
//=======================================================================
//function : Value
void GeomAdaptor_Curve::D0(const Standard_Real U, gp_Pnt& P) const
{
switch (myTypeCurve)
- {
+{
case GeomAbs_BezierCurve:
case GeomAbs_BSplineCurve:
{
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);
default:
myCurve->D0(U, P);
- }
+}
}
//=======================================================================
void GeomAdaptor_Curve::D1(const Standard_Real U, gp_Pnt& P, gp_Vec& V) const
{
switch (myTypeCurve)
- {
+{
case GeomAbs_BezierCurve:
case GeomAbs_BSplineCurve:
{
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);
default:
myCurve->D1(U, P, V);
- }
+}
}
//=======================================================================
gp_Pnt& P, gp_Vec& V1, gp_Vec& V2) const
{
switch (myTypeCurve)
- {
+{
case GeomAbs_BezierCurve:
case GeomAbs_BSplineCurve:
{
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);
default:
myCurve->D2(U, P, V1, V2);
- }
+}
}
//=======================================================================
gp_Vec& V2, gp_Vec& V3) const
{
switch (myTypeCurve)
- {
+{
case GeomAbs_BezierCurve:
case GeomAbs_BSplineCurve:
{
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);
default:
myCurve->D3(U, P, V1, V2, V3);
- }
+}
}
//=======================================================================
const Standard_Integer N) const
{
switch (myTypeCurve)
- {
+{
case GeomAbs_BezierCurve:
case GeomAbs_BSplineCurve:
{
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);
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);
+}
class gp_Parab;
class Geom_BezierCurve;
class Geom_BSplineCurve;
+class Geom_OffsetCurve;
//! This class provides an interface between the services provided by any
//! myFirst/Last.
Standard_EXPORT Handle(Geom_BSplineCurve) BSpline() const Standard_OVERRIDE;
+ Standard_EXPORT Handle(Geom_OffsetCurve) OffsetCurve() const Standard_OVERRIDE;
friend class GeomAdaptor_Surface;
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];
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];
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];
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];
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];
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];
#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]
#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]
#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]
#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]
#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]
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
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) {
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)
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";
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;
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;
(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;
//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) {
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;
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
catch(OSD_SIGSEGV)
#endif
{
- di << " Ok\n";
+ di << "Caught, OK\n";
} catch(Standard_Failure) {
//cout << " Caught (" << Standard_Failure::Caught() << ")... KO" << endl;
di << " Caught (";
//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;
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();
}
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;
}
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;
myStatus = ShapeExtend::EncodeStatus (ShapeExtend_FAIL2);
return Standard_False;
}
+ if (Precision::IsInfinite(aF) || Precision::IsInfinite(aL))
+ {
+ continue;
+ }
Standard_Integer aBegin = 0;
if (j == 1)
#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)
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();
//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
#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
//-------------------------------------------------------------------
__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 );
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
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
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());
}
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());
}
//----------------------------------------------------------------------
{
+ 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;
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);
puts "TODO OCC24156 MacOS: Faulty OCC6143"
+puts "TODO OCC27713 Linux: Faulty OCC6143"
+puts "TODO OCC27713 Linux: Error"
puts "================"
puts "OCC1723"
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}"
vsetdispmode 1
checkview -screenshot -3d -path ${imagedir}/${test_image}.png
-checkprops result -s 9951.34
+checkprops result -s 9994.76
#
# 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 ))
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 }
}
-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]
-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]
-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]
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
projects / occt-copy.git / commitdiff