Handling of FPE signals has been restored for MSVC and GCC compilers.
The test bug6143 (that checks signals handling) has been corrected accordingly.
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 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. They allow setting the correct limitation of domain search in the case of offset of hyperbola, in order to get rid of floating point overflow (see Extrema_GenExtCS.cxx). 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, Graphic3d_Camera.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.
Some test cases have been updated to actual state.
Standard_NotImplemented::Raise("Adaptor3d_Curve::BSpline");
return Handle(Geom_BSplineCurve)();
}
+
+//=======================================================================
+//function : BasisCurve
+//purpose :
+//=======================================================================
+
+Handle(Adaptor3d_HCurve) Adaptor3d_Curve::BasisCurve() const
+{
+ Standard_NotImplemented::Raise("Adaptor3d_Curve::BasisCurve");
+ return Handle(Adaptor3d_HCurve)();
+}
+
+
+//=======================================================================
+//function : OffsetValue
+//purpose :
+//=======================================================================
+
+Standard_Real Adaptor3d_Curve::OffsetValue() const
+{
+ Standard_NotImplemented::Raise("Adaptor3d_Curve::OffsetValue");
+ return 0.;
+}
Standard_EXPORT virtual Handle(Geom_BezierCurve) Bezier() const;
Standard_EXPORT virtual Handle(Geom_BSplineCurve) BSpline() const;
+
+ Standard_EXPORT virtual Handle(Adaptor3d_HCurve) BasisCurve() const;
+
+ Standard_EXPORT virtual Standard_Real OffsetValue() const;
+
Standard_EXPORT virtual ~Adaptor3d_Curve();
Handle(Geom_BSplineCurve) BSpline() const;
+ Handle(Adaptor3d_HCurve) BasisCurve() const;
+
+ Standard_Real OffsetValue() const;
return Curve().BSpline();
}
+//=======================================================================
+//function : BasisCurve
+//purpose :
+//=======================================================================
+
+ inline Handle(Adaptor3d_HCurve) Adaptor3d_HCurve::BasisCurve() const
+{
+ return Curve().BasisCurve();
+}
+
+
+//=======================================================================
+//function : OffsetValue
+//purpose :
+//=======================================================================
+
+ inline Standard_Real Adaptor3d_HCurve::OffsetValue() const
+{
+ return Curve().OffsetValue();
+}
NCollection_Sequence<Standard_Integer>& theInds,
const Standard_Boolean ChkCurv)
{
+ const Standard_Real eps = Epsilon(1.);
Standard_Integer anInd1 = theInds(theI);
Standard_Integer anInd = theInds(theI - 1);
//
}
//mp *= 2.; //P(j,i) = -P(i,j);
//
- sina = mp/(m1*m2);
+ Standard_Real m1m2 = m1*m2;
+ if(m1m2 > eps)
+ {
+ sina = mp/m1m2;
+ }
+ else
+ {
+ sina = 0.;
+ }
sina = Sqrt(sina);
if(sina > aSinCoeff)
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)
- theTolNew = aDist;
+ if(iFlag1)
+ {
+ if (theTolNew < aDist)
+ theTolNew = aDist;
+ }
}
//
if (iFlag2 == 1) {
iFlag2 = !myContext->ComputePE(aP2, aRealTol, aSp, aTx, aDist);
- if (theTolNew < aDist)
- theTolNew = aDist;
+ if(iFlag2)
+ {
+ if (theTolNew < aDist)
+ theTolNew = aDist;
+ }
}
//
if (iFlag1 && iFlag2) {
#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(Adaptor3d_HCurve) BRepAdaptor_Curve::BasisCurve() const
+{
+ if ( !Is3DCurve() || myCurve.GetType() != GeomAbs_OffsetCurve)
+ Standard_NoSuchObject::Raise("BRepAdaptor_Curve::BasisCurve");
+
+ const Handle(Geom_Curve)& aGC = myCurve.Curve();
+ Handle(Geom_OffsetCurve) anOffC = Handle(Geom_OffsetCurve)::DownCast(aGC);
+ Handle(Geom_Curve) aBC = anOffC->BasisCurve();
+ aBC = Handle(Geom_Curve)::DownCast(aBC->Transformed(myTrsf));
+
+ Handle(GeomAdaptor_HCurve) aGABC = new GeomAdaptor_HCurve(aBC);
+
+ return aGABC;
+}
+
+//=======================================================================
+//function : OffsetValue
+//purpose :
+//=======================================================================
+
+Standard_Real BRepAdaptor_Curve::OffsetValue() const
+{
+ if ( !Is3DCurve() || myCurve.GetType() != GeomAbs_OffsetCurve)
+ Standard_NoSuchObject::Raise("BRepAdaptor_Curve::OffsetValue");
+
+ return myCurve.OffsetValue();
+}
//! using this method
Standard_EXPORT Handle(Geom_BSplineCurve) BSpline() const Standard_OVERRIDE;
+ Standard_EXPORT Handle(Adaptor3d_HCurve) BasisCurve() const Standard_OVERRIDE;
+
+ Standard_EXPORT Standard_Real OffsetValue() 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())
Standard_Integer BRepGProp_Face::LIntOrder(const Standard_Real Eps) const
{
Bnd_Box2d aBox;
+ const Standard_Real eps = Epsilon(1.);
BndLib_Add2dCurve::Add(myCurve, 1.e-7, aBox);
Standard_Real aXmin, aXmax, aYmin, aYmax;
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 = 1.;
+ if(dv > eps)
+ {
+ anR = (aYmax-aYmin) / dv;
+ anR = Min(anR, 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());
gp_Pnt aPrevPnt2;
gp_Vec aPrevVec2;
aIso.D1 (aPrevParam2, aPrevPnt2, aPrevVec2);
+ Standard_Real aMod2PrevVec2 = aPrevVec2.SquareMagnitude();
for (Standard_Integer j = 2; j <= aParams2.Length();)
{
Standard_Real aParam2 = aParams2(j);
if (aDist < aDefFace)
{
// Lets check parameters for angular deflection.
- if (aPrevVec2.Angle(aNextVec) < myAngle)
+ if (aMod2PrevVec2 > gp::Resolution() && (aPrevVec2.Angle(aNextVec) < myAngle))
{
// For current Iso line we can remove this parameter.
#ifdef DEBUG_InsertInternal
aPrevParam2 = aNextParam;
aPrevPnt2 = aNextPnt;
aPrevVec2 = aNextVec;
+ aMod2PrevVec2 = aPrevVec2.SquareMagnitude();
j += 2;
continue;
}
aPrevParam2 = aParam2;
aPrevPnt2 = aPnt2;
aPrevVec2 = aVec2;
+ aMod2PrevVec2 = aPrevVec2.SquareMagnitude();
++j;
}
}
Handle(Geom_Curve) theCurve = BRep_Tool::Curve(NE, f, l);
gp_Pnt thePoint = BRep_Tool::Pnt(V);
GeomAPI_ProjectPointOnCurve Projector(thePoint, theCurve);
- if (Projector.NbPoints() == 0)
- Standard_ConstructionError::Raise("BRepOffset_MakeOffset::TrimEdge no projection");
- U = Projector.LowerDistanceParameter();
+ if (Projector.NbPoints() > 0)
+ {
+ U = Projector.LowerDistanceParameter();
+ }
+ else
+ {
+ U = .5*(f + l);
+ }
}
if (U < UMin) {
UMin = U; V1 = V;
(theSurf->Transformed(theLoc.Transformation()));
Handle(Geom2d_Curve) ProjPCurve =
GeomProjLib::Curve2d( C3d, f, l, theSurf );
- CurveRep->PCurve( ProjPCurve );
+ if(!ProjPCurve.IsNull())
+ {
+ CurveRep->PCurve( ProjPCurve );
+ }
}
}
}
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))*
// *****************************************************************
// set signals
// *****************************************************************
+#if defined(__INTEL_COMPILER) || defined(__clang__)
+ // FPE signals are disabled for Intel compiler (see #24589) and CLang (see #23802)
OSD::SetSignal(Standard_False);
+#else
+ OSD::SetSignal();
+#endif
#ifdef _WIN32
// in interactive mode, force Windows to report dll loading problems interactively
#endif //#ifdef _TK
// set signal handler in the new thread
+#if defined(__INTEL_COMPILER) || defined(__clang__)
+ // FPE signals are disabled for Intel compiler (see #24589) and CLang (see #23802)
OSD::SetSignal(Standard_False);
+#else
+ OSD::SetSignal();
+#endif
// inform the others that we have started
isTkLoopStarted = true;
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 <Standard_TypeMismatch.hxx>
#include <StdFail_NotDone.hxx>
#include <TColgp_HArray1OfPnt.hxx>
+#include <Adaptor3d_HSurface.hxx>
-const Standard_Real aMaxParamVal = 1.0e+10;
+const Standard_Real UMaxParamVal = 1.0e+10;
+const Standard_Real VMaxParamVal = 1.0e+10;
+const Standard_Real CMaxParamVal = 1.0e+10;
const Standard_Real aBorderDivisor = 1.0e+4;
+const Standard_Real HyperbolaLimit = 23.; //ln(UMaxParamVal)
+static void GetSurfMaxParamVals(const Adaptor3d_SurfacePtr theS,
+ Standard_Real& theUmax, Standard_Real& theVmax)
+{
+ theUmax = UMaxParamVal;
+ theVmax = VMaxParamVal;
+ Handle(Adaptor3d_HCurve) aBC;
+ GeomAbs_SurfaceType aST = GeomAbs_OtherSurface;
+ if(theS->GetType() == GeomAbs_OffsetSurface)
+ {
+ Handle(Adaptor3d_HSurface) aBS = theS->BasisSurface();
+ if(aBS->GetType() == GeomAbs_SurfaceOfExtrusion ||
+ aBS->GetType() == GeomAbs_SurfaceOfRevolution)
+ {
+ aST = aBS->GetType();
+ aBC = aBS->BasisCurve();
+ }
+ else
+ {
+ return;
+ }
+ }
+ else if(theS->GetType() == GeomAbs_SurfaceOfExtrusion ||
+ theS->GetType() == GeomAbs_SurfaceOfRevolution)
+ {
+ aST = theS->GetType();
+ aBC = theS->BasisCurve();
+ }
+ else
+ {
+ return;
+ }
+ //
+ if(aBC->GetType() == GeomAbs_OffsetCurve)
+ {
+ aBC = aBC->BasisCurve();
+ }
+
+ if(aBC->GetType() == GeomAbs_Hyperbola)
+ {
+ if(aST == GeomAbs_SurfaceOfExtrusion)
+ {
+ theUmax = HyperbolaLimit;
+ }
+ else
+ {
+ theVmax = HyperbolaLimit;
+ }
+ }
+ return;
+}
+//
+static Standard_Real GetCurvMaxParamVal(const Adaptor3d_Curve& theC)
+{
+ if(theC.GetType() == GeomAbs_OffsetCurve)
+ {
+ Handle(Adaptor3d_HCurve) aBC = theC.BasisCurve();
+ if(aBC->GetType() == GeomAbs_Hyperbola)
+ {
+ return HyperbolaLimit;
+ }
+ else
+ {
+ return CMaxParamVal;
+ }
+ }
+ else if(theC.GetType() == GeomAbs_Hyperbola)
+ {
+ return HyperbolaLimit;
+ }
+ else
+ {
+ return CMaxParamVal;
+ }
+ //
+}
//=======================================================================
//function : Extrema_GenExtCS
//purpose :
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(Adaptor3d_HCurve) GeomAdaptor_Curve::BasisCurve() const
+{
+ if ( myTypeCurve != GeomAbs_OffsetCurve)
+ Standard_NoSuchObject::Raise("GeomAdaptor_Curve::BasisCurve");
+
+ Handle(Geom_OffsetCurve) anOffC = Handle(Geom_OffsetCurve)::DownCast(myCurve);
+ Handle(Geom_Curve) aBC = anOffC->BasisCurve();
+
+ Handle(GeomAdaptor_HCurve) aGABC = new GeomAdaptor_HCurve(aBC);
+ return aGABC;
+}
+
+//=======================================================================
+//function : OffsetValue
+//purpose :
+//=======================================================================
+
+Standard_Real GeomAdaptor_Curve::OffsetValue() const
+{
+ if ( myTypeCurve != GeomAbs_OffsetCurve)
+ Standard_NoSuchObject::Raise("GeomAdaptor_Curve::OffsetValue");
+
+ return Handle(Geom_OffsetCurve)::DownCast(myCurve)->Offset();
+}
+
//! myFirst/Last.
Standard_EXPORT Handle(Geom_BSplineCurve) BSpline() const Standard_OVERRIDE;
+ Standard_EXPORT Handle(Adaptor3d_HCurve) BasisCurve() const Standard_OVERRIDE;
+
+ Standard_EXPORT Standard_Real OffsetValue() const Standard_OVERRIDE;
friend class GeomAdaptor_Surface;
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) {
#include <Extrema_ExtElC.hxx>
#include <Extrema_POnCurv.hxx>
+#include <Precision.hxx>
static const int Pourcent3[4] = {0, 1, 2, 0};
static Standard_Boolean IsInSegment(const gp_Vec& P1P2,
- const gp_Vec& P1P,
- const Standard_Real NP1P2,
- Standard_Real &Param,
- const Standard_Real Tolerance) {
- Param = P1P2.Dot(P1P);
- Param/= NP1P2;
- if(Param > (NP1P2+Tolerance))
- return(Standard_False);
- if(Param < (-Tolerance))
- return(Standard_False);
- Param/=NP1P2;
- if(Param<0.0) Param=0.0;
- if(Param>1.0) Param=1.0;
- return(Standard_True);
+ const gp_Vec& P1P,
+ const Standard_Real NP1P2,
+ Standard_Real &Param,
+ const Standard_Real Tolerance) {
+ Param = P1P2.Dot(P1P);
+ Param/= NP1P2;
+ if(Param > (NP1P2+Tolerance))
+ return(Standard_False);
+ if(Param < (-Tolerance))
+ return(Standard_False);
+ Param/=NP1P2;
+ if(Param<0.0) Param=0.0;
+ if(Param>1.0) Param=1.0;
+ return(Standard_True);
}
-
+
//=======================================================================
//function : Intf_InterferencePolygonPolyhedron
//=======================================================================
Intf_InterferencePolygonPolyhedron::Intf_InterferencePolygonPolyhedron()
-: Intf_Interference (Standard_False),
+ : Intf_Interference (Standard_False),
BeginOfClosedPolygon (Standard_False),
iLin (0)
{}
Intf_InterferencePolygonPolyhedron::Intf_InterferencePolygonPolyhedron
(const Polygon3d& thePolyg, const Polyhedron& thePolyh)
-: Intf_Interference (Standard_False),
+ : Intf_Interference (Standard_False),
BeginOfClosedPolygon (Standard_False),
iLin (0)
{
Tolerance=ToolPolygon3d::DeflectionOverEstimation(thePolyg)+
- ToolPolyh::DeflectionOverEstimation(thePolyh);
+ ToolPolyh::DeflectionOverEstimation(thePolyh);
if (Tolerance==0.)
Tolerance=Epsilon(1000.);
Intf_InterferencePolygonPolyhedron::Intf_InterferencePolygonPolyhedron
(const Polygon3d& thePolyg, const Polyhedron& thePolyh,
- Bnd_BoundSortBox &PolyhGrid)
-: Intf_Interference (Standard_False),
+ Bnd_BoundSortBox &PolyhGrid)
+ : Intf_Interference (Standard_False),
BeginOfClosedPolygon (Standard_False),
iLin (0)
{
Tolerance=ToolPolygon3d::DeflectionOverEstimation(thePolyg)+
- ToolPolyh::DeflectionOverEstimation(thePolyh);
+ ToolPolyh::DeflectionOverEstimation(thePolyh);
if (Tolerance==0.)
Tolerance=Epsilon(1000.);
Intf_InterferencePolygonPolyhedron::Intf_InterferencePolygonPolyhedron
(const gp_Lin& theLin, const Polyhedron& thePolyh)
-: Intf_Interference (Standard_False),
+ : Intf_Interference (Standard_False),
BeginOfClosedPolygon (Standard_False),
iLin (0)
{
Bnd_BoundSortBox PolyhGrid;
PolyhGrid.Initialize(ToolPolyh::Bounding(thePolyh),
- ToolPolyh::ComponentsBounding(thePolyh));
+ ToolPolyh::ComponentsBounding(thePolyh));
Standard_Integer indTri;
iLin=0;
while (iCl.More()) {
indTri=iCl.Value();
Intersect
- (theLin.Location(),
- theLin.Location().Translated(gp_Vec(theLin.Direction())),
- Standard_True, indTri, thePolyh);
+ (theLin.Location(),
+ theLin.Location().Translated(gp_Vec(theLin.Direction())),
+ Standard_True, indTri, thePolyh);
iCl.Next();
}
}
Intf_InterferencePolygonPolyhedron::Intf_InterferencePolygonPolyhedron
(const Intf_Array1OfLin& theLins, const Polyhedron& thePolyh)
-: Intf_Interference (Standard_False),
+ : Intf_Interference (Standard_False),
BeginOfClosedPolygon (Standard_False),
iLin (0)
{
Bnd_BoundSortBox PolyhGrid;
PolyhGrid.Initialize(ToolPolyh::Bounding(thePolyh),
- ToolPolyh::ComponentsBounding(thePolyh));
+ ToolPolyh::ComponentsBounding(thePolyh));
Standard_Integer indTri;
while (ilC.More()) {
indTri=ilC.Value();
Intersect
- (theLins(iLin).Location(),
- theLins(iLin).Location().Translated(gp_Vec(theLins(iLin).Direction())),
- Standard_True, indTri, thePolyh);
+ (theLins(iLin).Location(),
+ theLins(iLin).Location().Translated(gp_Vec(theLins(iLin).Direction())),
+ Standard_True, indTri, thePolyh);
ilC.Next();
}
}
{
SelfInterference(Standard_False);
Tolerance=ToolPolygon3d::DeflectionOverEstimation(thePolyg)+
- ToolPolyh::DeflectionOverEstimation(thePolyh);
+ ToolPolyh::DeflectionOverEstimation(thePolyh);
if (Tolerance==0.)
Tolerance=Epsilon(1000.);
if (!ToolPolygon3d::Bounding(thePolyg).IsOut
- (ToolPolyh::Bounding(thePolyh))) {
- Interference(thePolyg, thePolyh);
+ (ToolPolyh::Bounding(thePolyh))) {
+ Interference(thePolyg, thePolyh);
}
}
Bnd_BoundSortBox PolyhGrid;
PolyhGrid.Initialize(ToolPolyh::Bounding(thePolyh),
- ToolPolyh::ComponentsBounding(thePolyh));
+ ToolPolyh::ComponentsBounding(thePolyh));
Standard_Integer indTri;
while (lCi.More()) {
indTri=lCi.Value();
Intersect
- (theLin.Location(),
- theLin.Location().Translated(gp_Vec(theLin.Direction())),
- Standard_True, indTri, thePolyh);
+ (theLin.Location(),
+ theLin.Location().Translated(gp_Vec(theLin.Direction())),
+ Standard_True, indTri, thePolyh);
lCi.Next();
}
}
Bnd_BoundSortBox PolyhGrid;
PolyhGrid.Initialize(ToolPolyh::Bounding(thePolyh),
- ToolPolyh::ComponentsBounding(thePolyh));
+ ToolPolyh::ComponentsBounding(thePolyh));
Standard_Integer indTri;
while (tlC.More()) {
indTri=tlC.Value();
Intersect
- (theLins(iLin).Location(),
- theLins(iLin).Location().Translated(gp_Vec(theLins(iLin).Direction())),
- Standard_True, indTri, thePolyh);
+ (theLins(iLin).Location(),
+ theLins(iLin).Location().Translated(gp_Vec(theLins(iLin).Direction())),
+ Standard_True, indTri, thePolyh);
tlC.Next();
}
}
Bnd_BoundSortBox PolyhGrid;
PolyhGrid.Initialize(ToolPolyh::Bounding(thePolyh),
- ToolPolyh::ComponentsBounding(thePolyh));
+ ToolPolyh::ComponentsBounding(thePolyh));
Standard_Integer indTri;
BeginOfClosedPolygon=ToolPolygon3d::Closed(thePolyg);
gp_Vec Normale = PaPb.Crossed(PaPc);
Standard_Real Norm_Normale=Normale.Magnitude();
if(Norm_Normale<1e-14)
- continue;
+ continue;
Normale.Multiply(defPh/Norm_Normale);
gp_Pnt p1m = p1.Translated(-Normale);
gp_Pnt p1p = p1.Translated( Normale);
gp_Pnt p2m = p2.Translated(-Normale);
gp_Pnt p2p = p2.Translated( Normale);
Intersect(p1m,
- p2p,
- Standard_False, indTri, thePolyh);
+ p2p,
+ Standard_False, indTri, thePolyh);
Intersect(p1p,
- p2m,
- Standard_False, indTri, thePolyh);
-// Intersect(ToolPolygon3d::BeginOfSeg(thePolyg, iLin),
-// ToolPolygon3d::EndOfSeg(thePolyg, iLin),
-// Standard_False, indTri, thePolyh);
+ p2m,
+ Standard_False, indTri, thePolyh);
+ // Intersect(ToolPolygon3d::BeginOfSeg(thePolyg, iLin),
+ // ToolPolygon3d::EndOfSeg(thePolyg, iLin),
+ // Standard_False, indTri, thePolyh);
}
BeginOfClosedPolygon=Standard_False;
}
Intf_InterferencePolygonPolyhedron::Intf_InterferencePolygonPolyhedron
(const gp_Lin& theLin, const Polyhedron& thePolyh,
- Bnd_BoundSortBox &PolyhGrid)
-: Intf_Interference(Standard_False)
+ Bnd_BoundSortBox &PolyhGrid)
+ : Intf_Interference(Standard_False)
{
Tolerance=ToolPolyh::DeflectionOverEstimation(thePolyh);
if (Tolerance==0.)
while (iCl.More()) {
indTri=iCl.Value();
Intersect
- (theLin.Location(),
- theLin.Location().Translated(gp_Vec(theLin.Direction())),
- Standard_True, indTri, thePolyh);
+ (theLin.Location(),
+ theLin.Location().Translated(gp_Vec(theLin.Direction())),
+ Standard_True, indTri, thePolyh);
iCl.Next();
}
}
Intf_InterferencePolygonPolyhedron::Intf_InterferencePolygonPolyhedron
(const Intf_Array1OfLin& theLins, const Polyhedron& thePolyh,
- Bnd_BoundSortBox &PolyhGrid)
-: Intf_Interference(Standard_False)
+ Bnd_BoundSortBox &PolyhGrid)
+ : Intf_Interference(Standard_False)
{
Tolerance=ToolPolyh::DeflectionOverEstimation(thePolyh);
if (Tolerance==0.)
while (ilC.More()) {
indTri=ilC.Value();
Intersect
- (theLins(iLin).Location(),
- theLins(iLin).Location().Translated(gp_Vec(theLins(iLin).Direction())),
- Standard_True, indTri, thePolyh);
+ (theLins(iLin).Location(),
+ theLins(iLin).Location().Translated(gp_Vec(theLins(iLin).Direction())),
+ Standard_True, indTri, thePolyh);
ilC.Next();
}
}
void Intf_InterferencePolygonPolyhedron::Perform
(const Polygon3d& thePolyg, const Polyhedron& thePolyh,
- Bnd_BoundSortBox &PolyhGrid)
+ Bnd_BoundSortBox &PolyhGrid)
{
SelfInterference(Standard_False);
Tolerance=ToolPolygon3d::DeflectionOverEstimation(thePolyg)+
- ToolPolyh::DeflectionOverEstimation(thePolyh);
+ ToolPolyh::DeflectionOverEstimation(thePolyh);
if (Tolerance==0.)
Tolerance=Epsilon(1000.);
if (!ToolPolygon3d::Bounding(thePolyg).IsOut
- (ToolPolyh::Bounding(thePolyh))) {
- Interference(thePolyg, thePolyh,PolyhGrid);
+ (ToolPolyh::Bounding(thePolyh))) {
+ Interference(thePolyg, thePolyh,PolyhGrid);
}
}
void Intf_InterferencePolygonPolyhedron::Perform
(const gp_Lin& theLin, const Polyhedron& thePolyh,
- Bnd_BoundSortBox &PolyhGrid)
+ Bnd_BoundSortBox &PolyhGrid)
{
SelfInterference(Standard_False);
Tolerance=ToolPolyh::DeflectionOverEstimation(thePolyh);
while (lCi.More()) {
indTri=lCi.Value();
Intersect
- (theLin.Location(),
- theLin.Location().Translated(gp_Vec(theLin.Direction())),
- Standard_True, indTri, thePolyh);
+ (theLin.Location(),
+ theLin.Location().Translated(gp_Vec(theLin.Direction())),
+ Standard_True, indTri, thePolyh);
lCi.Next();
}
}
void Intf_InterferencePolygonPolyhedron::Perform
(const Intf_Array1OfLin& theLins, const Polyhedron& thePolyh,
- Bnd_BoundSortBox &PolyhGrid)
+ Bnd_BoundSortBox &PolyhGrid)
{
SelfInterference(Standard_False);
Tolerance=ToolPolyh::DeflectionOverEstimation(thePolyh);
while (tlC.More()) {
indTri=tlC.Value();
Intersect
- (theLins(iLin).Location(),
- theLins(iLin).Location().Translated(gp_Vec(theLins(iLin).Direction())),
- Standard_True, indTri, thePolyh);
+ (theLins(iLin).Location(),
+ theLins(iLin).Location().Translated(gp_Vec(theLins(iLin).Direction())),
+ Standard_True, indTri, thePolyh);
tlC.Next();
}
}
void Intf_InterferencePolygonPolyhedron::Interference
(const Polygon3d& thePolyg, const Polyhedron& thePolyh,
- Bnd_BoundSortBox &PolyhGrid)
+ Bnd_BoundSortBox &PolyhGrid)
{
Bnd_Box bofSeg;
ToolPolyh::Triangle(thePolyh, indTri, pTri[0], pTri[1], pTri[2]);
gp_XYZ triNor; // Vecteur normal.
Standard_Real triDp = 0.; // Distance polaire.
-
+
Intf::PlaneEquation(ToolPolyh::Point(thePolyh, pTri[0]),
- ToolPolyh::Point(thePolyh, pTri[1]),
- ToolPolyh::Point(thePolyh, pTri[2]),
- triNor, triDp);
+ ToolPolyh::Point(thePolyh, pTri[1]),
+ ToolPolyh::Point(thePolyh, pTri[2]),
+ triNor, triDp);
// enlarge boundary segment
if ( iLin == 1 ) {
- gp_XYZ dif = p1.XYZ() - p2.XYZ();
- Standard_Real dist = dif.Modulus();
- if ( dist > gp::Resolution() ) {
- dif /= dist;
- Standard_Real aCos = dif * triNor;
- aCos = fabs(aCos);
- if ( aCos > gp::Resolution() ) {
- Standard_Real shift = defPh / aCos;
- Beg0.SetXYZ( p1.XYZ() + dif * shift );
- }
- }
+ gp_XYZ dif = p1.XYZ() - p2.XYZ();
+ Standard_Real dist = dif.Modulus();
+ if ( dist > gp::Resolution() ) {
+ dif /= dist;
+ Standard_Real aCos = dif * triNor;
+ aCos = fabs(aCos);
+ if ( aCos > gp::Resolution() ) {
+ Standard_Real shift = defPh / aCos;
+ Beg0.SetXYZ( p1.XYZ() + dif * shift );
+ }
+ }
}
else if ( iLin == ToolPolygon3d::NbSegments(thePolyg) ) {
- gp_XYZ dif = p2.XYZ() - p1.XYZ();
- Standard_Real dist = dif.Modulus();
- if ( dist > gp::Resolution() ) {
- dif /= dist;
- Standard_Real aCos = dif * triNor;
- aCos = fabs(aCos);
- if ( aCos > gp::Resolution() ) {
- Standard_Real shift = defPh / aCos;
- End0.SetXYZ( p2.XYZ() + dif * shift );
- }
- }
+ gp_XYZ dif = p2.XYZ() - p1.XYZ();
+ Standard_Real dist = dif.Modulus();
+ if ( dist > gp::Resolution() ) {
+ dif /= dist;
+ Standard_Real aCos = dif * triNor;
+ aCos = fabs(aCos);
+ if ( aCos > gp::Resolution() ) {
+ Standard_Real shift = defPh / aCos;
+ End0.SetXYZ( p2.XYZ() + dif * shift );
+ }
+ }
}
Standard_Real dBegTri=(triNor*Beg0.XYZ())-triDp; // Distance <p1> plane
Standard_Real dEndTri=(triNor*End0.XYZ())-triDp; // Distance <p2> plane
//=======================================================================
#if 0
void Intf_InterferencePolygonPolyhedron::Intersect
-(const gp_Pnt& BegO, const gp_Pnt& EndO, const Standard_Boolean Infinite,
- const Standard_Integer TTri, const Polyhedron& thePolyh)
+ (const gp_Pnt& BegO, const gp_Pnt& EndO, const Standard_Boolean Infinite,
+ const Standard_Integer TTri, const Polyhedron& thePolyh)
{
Standard_Integer pTri0,pTri1,pTri2;
ToolPolyh::Triangle(thePolyh, TTri, pTri0, pTri1, pTri2);
Standard_Real Norm_Normale=Normale.Magnitude();
if(Norm_Normale<1e-14)
return;
-
+
//-- Equation du Plan
Standard_Real A=Normale.X()/Norm_Normale;
Standard_Real B=Normale.Y()/Norm_Normale;
Standard_Real C=Normale.Z()/Norm_Normale;
Standard_Real D=-(A*Pa.X()+B*Pa.Y()+C*Pa.Z());
-
+
gp_Vec BegOEndO(BegO,EndO);
Standard_Real Norm_BegOEndO=BegOEndO.Magnitude();
if(Norm_BegOEndO<1e-14)
Standard_Real Lx=BegOEndO.X()/Norm_BegOEndO;
Standard_Real Ly=BegOEndO.Y()/Norm_BegOEndO;
Standard_Real Lz=BegOEndO.Z()/Norm_BegOEndO;
-
+
Standard_Real Vd=A*Lx+B*Ly+C*Lz; //-- DirLigne . NormalePlan
-
+
if(Vd==0) { //-- Droite parallele au plan
return;
}
-
-
+
+
//-- Calcul du parametre sur la ligne
Standard_Real t=-(A*BegO.X()+B*BegO.Y()+C*BegO.Z()+D) / Vd;
-
+
Standard_Real tol=1e-8; //-- Deflection sur le triangle
if(t<-tol || t>(Norm_BegOEndO+tol)) {
if(Infinite==Standard_False) {
//-- On a une intersection droite plan
//-- On teste si c est dans le triangle
gp_Pnt PRes(BegO.X()+t*Lx,BegO.Y()+t*Ly,BegO.Z()+t*Lz);
-
+
Standard_Real AbsA=A; if(AbsA<0) AbsA=-AbsA;
Standard_Real AbsB=B; if(AbsB<0) AbsB=-AbsB;
Standard_Real AbsC=C; if(AbsC<0) AbsC=-AbsC;
-
+
Standard_Real Au,Av,Bu,Bv,Cu,Cv,Pu,Pv;
if(AbsA>AbsB) {
if(AbsA>AbsC) {
Standard_Real ABu=Bu-Au; Standard_Real ABv=Bv-Av;
Standard_Real ACu=Cu-Au; Standard_Real ACv=Cv-Av;
Standard_Real BCu=Cu-Bu; Standard_Real BCv=Cv-Bv;
-
+
Standard_Real t1,t2;
//-- Test sur AB et C
t1=-ABv*Cu + ABu*Cv;
Intf_SectionPoint SP(PRes,
- Intf_EDGE,
- 0,
- iLin, //-- !!!!! VARIABLE STATIQUE
- t / Norm_BegOEndO,
- Intf_FACE,
- TTri, 0, 0.,1.);
+ Intf_EDGE,
+ 0,
+ iLin, //-- !!!!! VARIABLE STATIQUE
+ t / Norm_BegOEndO,
+ Intf_FACE,
+ TTri, 0, 0.,1.);
mySPoins.Append(SP);
}
#else
void Intf_InterferencePolygonPolyhedron::Intersect
(const gp_Pnt& BegO, const gp_Pnt& EndO, const Standard_Boolean Infinite,
- const Standard_Integer TTri, const Polyhedron& thePolyh)
+ const Standard_Integer TTri, const Polyhedron& thePolyh)
{
Intf_PIType typOnG=Intf_EDGE;
Standard_Real t;
Standard_Real triDp; // Distance polaire.
Intf::PlaneEquation(ToolPolyh::Point(thePolyh, pTri[0]),
- ToolPolyh::Point(thePolyh, pTri[1]),
- ToolPolyh::Point(thePolyh, pTri[2]),
- triNor, triDp);
+ ToolPolyh::Point(thePolyh, pTri[1]),
+ ToolPolyh::Point(thePolyh, pTri[2]),
+ triNor, triDp);
Standard_Real dBegTri=(triNor*BegO.XYZ())-triDp; // Distance <BegO> plan
param = dBegTri/t;
else param = dBegTri;
Standard_Real floatgap=Epsilon(1000.);
-
+
if (!Infinite) {
if (dBegTri<=floatgap && dBegTri>=-floatgap ) {
param=0.;typOnG=Intf_VERTEX;
if (BeginOfClosedPolygon)
- NoIntersectionWithTriangle = Standard_False;
+ NoIntersectionWithTriangle = Standard_False;
}
else if (dEndTri<=floatgap && dEndTri>=-floatgap) {
param=1.;typOnG=Intf_VERTEX;
Standard_Integer tbreak=0;
{ //-- is = 0
gp_XYZ segT(ToolPolyh::Point(thePolyh, pTri[1]).XYZ()-
- ToolPolyh::Point(thePolyh, pTri[0]).XYZ());
+ ToolPolyh::Point(thePolyh, pTri[0]).XYZ());
gp_XYZ vecP(spLieu-ToolPolyh::Point(thePolyh, pTri[0]).XYZ());
dPtPi[0]=vecP.Modulus();
if (dPtPi[0]<=floatgap) {
- sVertex=0;
- is=0;
- tbreak=1;
+ sVertex=0;
+ is=0;
+ tbreak=1;
}
else {
- gp_XYZ segT_x_vecP(segT^vecP);
- Standard_Real Modulus_segT_x_vecP = segT_x_vecP.Modulus();
- sigd = segT_x_vecP*triNor;
- if(sigd>floatgap)
- sigd = 1.0;
- else if(sigd<-floatgap)
- sigd = -1.0;
- else {
- sigd = 0.0;
- }
- dPiE[0]=sigd*(Modulus_segT_x_vecP/segT.Modulus());
- if (dPiE[0]<=floatgap && dPiE[0]>=-floatgap) {
- sEdge=0;
- is=0;
- tbreak=1;
- }
+ gp_XYZ segT_x_vecP(segT^vecP);
+ Standard_Real Modulus_segT_x_vecP;
+ if(Precision::IsInfinite(segT_x_vecP.X()) || Precision::IsInfinite(segT_x_vecP.Y()) ||
+ Precision::IsInfinite(segT_x_vecP.Z()))
+ {
+ Modulus_segT_x_vecP = Precision::Infinite();
+ }
+ else
+ {
+ Modulus_segT_x_vecP = segT_x_vecP.Modulus();
+ }
+ sigd = segT_x_vecP*triNor;
+ if(sigd>floatgap)
+ sigd = 1.0;
+ else if(sigd<-floatgap)
+ sigd = -1.0;
+ else {
+ sigd = 0.0;
+ }
+ dPiE[0]=sigd*(Modulus_segT_x_vecP/segT.Modulus());
+ if (dPiE[0]<=floatgap && dPiE[0]>=-floatgap) {
+ sEdge=0;
+ is=0;
+ tbreak=1;
+ }
}
}
if(tbreak==0) { //-- is = 1
gp_XYZ segT(ToolPolyh::Point(thePolyh, pTri[2]).XYZ()-
- ToolPolyh::Point(thePolyh, pTri[1]).XYZ());
+ ToolPolyh::Point(thePolyh, pTri[1]).XYZ());
gp_XYZ vecP(spLieu-ToolPolyh::Point(thePolyh, pTri[1]).XYZ());
dPtPi[1]=vecP.Modulus();
if (dPtPi[1]<=floatgap) {
- sVertex=1;
- is=1;
- tbreak=1;
+ sVertex=1;
+ is=1;
+ tbreak=1;
}
else {
- gp_XYZ segT_x_vecP(segT^vecP);
- Standard_Real Modulus_segT_x_vecP = segT_x_vecP.Modulus();
- sigd = segT_x_vecP*triNor;
- if(sigd>floatgap)
- sigd = 1.0;
- else if(sigd<-floatgap)
- sigd = -1.0;
- else {
- sigd = 0.0;
- }
- dPiE[1]=sigd*(Modulus_segT_x_vecP/segT.Modulus());
- if (dPiE[1]<=floatgap && dPiE[1]>=-floatgap) {
- sEdge=1;
- is=1;
- tbreak=1;
- }
+ gp_XYZ segT_x_vecP(segT^vecP);
+ Standard_Real Modulus_segT_x_vecP;
+ if(Precision::IsInfinite(segT_x_vecP.X()) || Precision::IsInfinite(segT_x_vecP.Y()) ||
+ Precision::IsInfinite(segT_x_vecP.Z()))
+ {
+ Modulus_segT_x_vecP = Precision::Infinite();
+ }
+ else
+ {
+ Modulus_segT_x_vecP = segT_x_vecP.Modulus();
+ }
+ sigd = segT_x_vecP*triNor;
+ if(sigd>floatgap)
+ sigd = 1.0;
+ else if(sigd<-floatgap)
+ sigd = -1.0;
+ else {
+ sigd = 0.0;
+ }
+ dPiE[1]=sigd*(Modulus_segT_x_vecP/segT.Modulus());
+ if (dPiE[1]<=floatgap && dPiE[1]>=-floatgap) {
+ sEdge=1;
+ is=1;
+ tbreak=1;
+ }
}
}
if(tbreak==0) { //-- is = 2
gp_XYZ segT(ToolPolyh::Point(thePolyh, pTri[0]).XYZ()-
- ToolPolyh::Point(thePolyh, pTri[2]).XYZ());
+ ToolPolyh::Point(thePolyh, pTri[2]).XYZ());
gp_XYZ vecP(spLieu-ToolPolyh::Point(thePolyh, pTri[2]).XYZ());
dPtPi[2]=vecP.Modulus();
if (dPtPi[2]<=floatgap) {
- sVertex=2;
- is=2;
+ sVertex=2;
+ is=2;
}
gp_XYZ segT_x_vecP(segT^vecP);
- Standard_Real Modulus_segT_x_vecP = segT_x_vecP.Modulus();
+ Standard_Real Modulus_segT_x_vecP;
+ if(Precision::IsInfinite(segT_x_vecP.X()) || Precision::IsInfinite(segT_x_vecP.Y()) ||
+ Precision::IsInfinite(segT_x_vecP.Z()))
+ {
+ Modulus_segT_x_vecP = Precision::Infinite();
+ }
+ else
+ {
+ Modulus_segT_x_vecP = segT_x_vecP.Modulus();
+ }
sigd = segT_x_vecP*triNor;
if(sigd>floatgap)
- sigd = 1.0;
+ sigd = 1.0;
else if(sigd<-floatgap)
- sigd = -1.0;
+ sigd = -1.0;
else {
- sigd = 0.0;
+ sigd = 0.0;
}
dPiE[2]=sigd*(Modulus_segT_x_vecP/segT.Modulus());
if (dPiE[2]<=floatgap && dPiE[2]>=-floatgap) {
- sEdge=2;
- is=2;
+ sEdge=2;
+ is=2;
}
}
//-- fin for i=0 to 2
// !!cout<<endl;
-
+
Standard_Integer triCon, pedg;
if (sVertex>-1) {
triCon=TTri;
pedg=pTri[Pourcent3[sVertex+1]];
-//-- while (triCon!=0) {
-//-- ToolPolyh::TriConnex(thePolyh, triCon,pTri[sVertex],pedg,triCon,pedg);
-//-- //-- if (triCon<TTri) return;
-//-- if (triCon==TTri) break;
-//-- }
+ //-- while (triCon!=0) {
+ //-- ToolPolyh::TriConnex(thePolyh, triCon,pTri[sVertex],pedg,triCon,pedg);
+ //-- //-- if (triCon<TTri) return;
+ //-- if (triCon==TTri) break;
+ //-- }
Intf_SectionPoint SP(spLieu,
- typOnG, 0, iLin, param,
- Intf_VERTEX, pTri[is], 0, 0.,
- 1.);
+ typOnG, 0, iLin, param,
+ Intf_VERTEX, pTri[is], 0, 0.,
+ 1.);
mySPoins.Append(SP);
}
else if (sEdge>-1) {
ToolPolyh::TriConnex(thePolyh, TTri, pTri[sEdge], pTri[Pourcent3[sEdge+1]],
- triCon, pedg);
+ triCon, pedg);
//-- if (triCon<=TTri) return; ???????????????????? LBR
// !!cout<<" sEdge "<<endl;
Intf_SectionPoint SP(spLieu,
- typOnG, 0, iLin, param,
- Intf_EDGE, Min(pTri[sEdge], pTri[Pourcent3[sEdge+1]]),
- Max(pTri[sEdge], pTri[Pourcent3[sEdge+1]]), 0.,
- 1.);
+ typOnG, 0, iLin, param,
+ Intf_EDGE, Min(pTri[sEdge], pTri[Pourcent3[sEdge+1]]),
+ Max(pTri[sEdge], pTri[Pourcent3[sEdge+1]]), 0.,
+ 1.);
mySPoins.Append(SP);
}
else if (dPiE[0]>0. && dPiE[1]>0. && dPiE[2]>0.) {
// !!cout<<" 3 Positifs "<<endl;
Intf_SectionPoint SP(spLieu,
- typOnG, 0, iLin, param,
- Intf_FACE, TTri, 0, 0.,
- 1.);
+ typOnG, 0, iLin, param,
+ Intf_FACE, TTri, 0, 0.,
+ 1.);
mySPoins.Append(SP);
}
-// Modified by Sergey KHROMOV - Fri Dec 7 14:40:11 2001 Begin
+ // Modified by Sergey KHROMOV - Fri Dec 7 14:40:11 2001 Begin
// Sometimes triangulation doesn't cover whole the face. In this
// case it is necessary to take into account the deflection between boundary
// isolines of the surface and boundary trianles. Computed value of this
Standard_Integer i;
for (i = 1; i <= 3; i++) {
- Standard_Integer indP1 = (i == 3) ? pTri[0] : pTri[i];
- Standard_Integer indP2 = pTri[i - 1];
-
- if (ToolPolyh::IsOnBound(thePolyh, indP1, indP2)) {
- // For boundary line it is necessary to check the border deflection.
- Standard_Real Deflection = ToolPolyh::GetBorderDeflection(thePolyh);
- const gp_Pnt &BegP = ToolPolyh::Point(thePolyh, indP1);
- const gp_Pnt &EndP = ToolPolyh::Point(thePolyh, indP2);
- gp_Vec VecTri(BegP,EndP);
- gp_Dir DirTri(VecTri);
- gp_Lin LinTri(BegP,DirTri);
- gp_Pnt aPOnE(spLieu);
- Standard_Real aDist = LinTri.Distance(aPOnE);
-
- if (aDist <= Deflection) {
- gp_Vec aVLocPOnE(BegP, aPOnE);
- gp_Vec aVecDirTri(DirTri);
- Standard_Real aPar = aVLocPOnE*aVecDirTri;
- Standard_Real aMaxPar = VecTri.Magnitude();
-
- if (aPar >= 0 && aPar <= aMaxPar) {
- Intf_SectionPoint SP(spLieu,
- typOnG, 0, iLin, param,
- Intf_FACE, TTri, 0, 0.,
- 1.);
- mySPoins.Append(SP);
- }
- }
- }
+ Standard_Integer indP1 = (i == 3) ? pTri[0] : pTri[i];
+ Standard_Integer indP2 = pTri[i - 1];
+
+ if (ToolPolyh::IsOnBound(thePolyh, indP1, indP2)) {
+ // For boundary line it is necessary to check the border deflection.
+ Standard_Real Deflection = ToolPolyh::GetBorderDeflection(thePolyh);
+ const gp_Pnt &BegP = ToolPolyh::Point(thePolyh, indP1);
+ const gp_Pnt &EndP = ToolPolyh::Point(thePolyh, indP2);
+ gp_Vec VecTri(BegP,EndP);
+ gp_Dir DirTri(VecTri);
+ gp_Lin LinTri(BegP,DirTri);
+ gp_Pnt aPOnE(spLieu);
+ Standard_Real aDist = LinTri.Distance(aPOnE);
+
+ if (aDist <= Deflection) {
+ gp_Vec aVLocPOnE(BegP, aPOnE);
+ gp_Vec aVecDirTri(DirTri);
+ Standard_Real aPar = aVLocPOnE*aVecDirTri;
+ Standard_Real aMaxPar = VecTri.Magnitude();
+
+ if (aPar >= 0 && aPar <= aMaxPar) {
+ Intf_SectionPoint SP(spLieu,
+ typOnG, 0, iLin, param,
+ Intf_FACE, TTri, 0, 0.,
+ 1.);
+ mySPoins.Append(SP);
+ }
+ }
+ }
}
}
-// Modified by Sergey KHROMOV - Fri Dec 7 14:40:29 2001 End
+ // Modified by Sergey KHROMOV - Fri Dec 7 14:40:29 2001 End
} //---- if(NoIntersectionWithTriangle == Standard_False)
-
+
//---------------------------------------------------------------------------
//-- On teste la distance entre les cotes du triangle et le polygone
//--
//-- Si cette distance est inferieure a Tolerance, on cree un SP.
//--
//-- printf("\nIntf_InterferencePolygPolyh : dBegTri=%g dEndTri=%g Tolerance=%g\n",dBegTri,dEndTri,Tolerance);
-// if(Abs(dBegTri) <= Tolerance || Abs(dEndTri) <= Tolerance)
+ // if(Abs(dBegTri) <= Tolerance || Abs(dEndTri) <= Tolerance)
{
gp_Vec VecPol(BegO,EndO);
Standard_Real NVecPol = VecPol.Magnitude();
gp_Dir DirPol(VecPol);
gp_Lin LinPol(BegO,DirPol);
Standard_Real dist2,ParamOnO,ParamOnT;
-
+
for (Standard_Integer i=0; i<3; i++) {
Standard_Integer pTri_ip1pc3 = pTri[Pourcent3[i+1]];
Standard_Integer pTri_i = pTri[i];
gp_Lin LinTri(BegT,DirTri);
Extrema_ExtElC Extrema(LinPol,LinTri,0.00000001);
if(Extrema.IsDone()) {
- if(Extrema.IsParallel() == Standard_False) {
- if(Extrema.NbExt()) {
- dist2 = Extrema.SquareDistance();
- if(dist2<=Tolerance * Tolerance) {
- Extrema_POnCurv POnC1,POnC2;
- Extrema.Points(1,POnC1,POnC2);
- const gp_Pnt& PO = POnC1.Value();
- const gp_Pnt& PT = POnC2.Value();
- //--cout<<" ** Nouveau "<<dist2<<endl;
- if(IsInSegment(VecPol,gp_Vec(BegO,PO),NVecPol,ParamOnO,Tolerance)) {
- if(IsInSegment(VecTri,gp_Vec(BegT,PT),NVecTri,ParamOnT,Tolerance)) {
- //-- cout<<" * "<<endl;
- gp_XYZ spLieu=BegT.XYZ()+((EndT.XYZ()-BegT.XYZ())*param);
- Standard_Integer tmin,tmax;
- if(pTri_i>pTri_ip1pc3) {
- tmin=pTri_ip1pc3; tmax=pTri_i;
- }
- else {
- tmax=pTri_ip1pc3; tmin=pTri_i;
- }
- Intf_SectionPoint SP(spLieu,
- typOnG, 0, iLin, ParamOnO,
- Intf_EDGE,
- tmin,
- tmax, 0.,
- 1.);
- mySPoins.Append(SP);
- }
- }
- }
- }
- }
+ if(Extrema.IsParallel() == Standard_False) {
+ if(Extrema.NbExt()) {
+ dist2 = Extrema.SquareDistance();
+ if(dist2<=Tolerance * Tolerance) {
+ Extrema_POnCurv POnC1,POnC2;
+ Extrema.Points(1,POnC1,POnC2);
+ const gp_Pnt& PO = POnC1.Value();
+ const gp_Pnt& PT = POnC2.Value();
+ //--cout<<" ** Nouveau "<<dist2<<endl;
+ if(IsInSegment(VecPol,gp_Vec(BegO,PO),NVecPol,ParamOnO,Tolerance)) {
+ if(IsInSegment(VecTri,gp_Vec(BegT,PT),NVecTri,ParamOnT,Tolerance)) {
+ //-- cout<<" * "<<endl;
+ gp_XYZ spLieu=BegT.XYZ()+((EndT.XYZ()-BegT.XYZ())*param);
+ Standard_Integer tmin,tmax;
+ if(pTri_i>pTri_ip1pc3) {
+ tmin=pTri_ip1pc3; tmax=pTri_i;
+ }
+ else {
+ tmax=pTri_ip1pc3; tmin=pTri_i;
+ }
+ Intf_SectionPoint SP(spLieu,
+ typOnG, 0, iLin, ParamOnO,
+ Intf_EDGE,
+ tmin,
+ tmax, 0.,
+ 1.);
+ mySPoins.Append(SP);
+ }
+ }
+ }
+ }
+ }
}
}
}
#endif
void Intf_InterferencePolygonPolyhedron::Intersect (const gp_Pnt& BegO,
- const gp_Pnt& EndO,
- const Standard_Boolean Infinite,
- const Standard_Integer TTri,
- const Polyhedron& thePolyh,
- const gp_XYZ& TriNormal,
- const Standard_Real /*TriDp*/,
- const Standard_Real dBegTri,
- const Standard_Real dEndTri)
+ const gp_Pnt& EndO,
+ const Standard_Boolean Infinite,
+ const Standard_Integer TTri,
+ const Polyhedron& thePolyh,
+ const gp_XYZ& TriNormal,
+ const Standard_Real /*TriDp*/,
+ const Standard_Real dBegTri,
+ const Standard_Real dEndTri)
{
Intf_PIType typOnG=Intf_EDGE;
Standard_Real t;
//Standard_Real triDp = TriDp; // Distance polaire.
-// Standard_Real dBegTri=(triNor*BegO.XYZ())-triDp; // Distance <BegO> plan
-// Standard_Real dEndTri=(triNor*EndO.XYZ())-triDp; // Distance <EndO> plan
+ // Standard_Real dBegTri=(triNor*BegO.XYZ())-triDp; // Distance <BegO> plan
+ // Standard_Real dEndTri=(triNor*EndO.XYZ())-triDp; // Distance <EndO> plan
Standard_Boolean NoIntersectionWithTriangle = Standard_False;
param = dBegTri/t;
else param = dBegTri;
Standard_Real floatgap=Epsilon(1000.);
-
+
if (!Infinite) {
if (dBegTri<=floatgap && dBegTri>=-floatgap ) {
param=0.;typOnG=Intf_VERTEX;
if (BeginOfClosedPolygon)
- NoIntersectionWithTriangle = Standard_False;
+ NoIntersectionWithTriangle = Standard_False;
}
else if (dEndTri<=floatgap && dEndTri>=-floatgap) {
param=1.;typOnG=Intf_VERTEX;
Standard_Integer tbreak=0;
{ //-- is = 0
gp_XYZ segT(ToolPolyh::Point(thePolyh, pTri[1]).XYZ()-
- ToolPolyh::Point(thePolyh, pTri[0]).XYZ());
+ ToolPolyh::Point(thePolyh, pTri[0]).XYZ());
gp_XYZ vecP(spLieu-ToolPolyh::Point(thePolyh, pTri[0]).XYZ());
dPtPi[0]=vecP.Modulus();
if (dPtPi[0]<=floatgap) {
- sVertex=0;
- is=0;
- tbreak=1;
+ sVertex=0;
+ is=0;
+ tbreak=1;
}
else {
- gp_XYZ segT_x_vecP(segT^vecP);
- Standard_Real Modulus_segT_x_vecP = segT_x_vecP.Modulus();
- sigd = segT_x_vecP*triNor;
- if(sigd>floatgap)
- sigd = 1.0;
- else if(sigd<-floatgap)
- sigd = -1.0;
- else {
- sigd = 0.0;
- }
- dPiE[0]=sigd*(Modulus_segT_x_vecP/segT.Modulus());
- if (dPiE[0]<=floatgap && dPiE[0]>=-floatgap) {
- sEdge=0;
- is=0;
- tbreak=1;
- }
+ gp_XYZ segT_x_vecP(segT^vecP);
+ Standard_Real Modulus_segT_x_vecP;
+ if(Precision::IsInfinite(segT_x_vecP.X()) || Precision::IsInfinite(segT_x_vecP.Y()) ||
+ Precision::IsInfinite(segT_x_vecP.Z()))
+ {
+ Modulus_segT_x_vecP = Precision::Infinite();
+ }
+ else
+ {
+ Modulus_segT_x_vecP = segT_x_vecP.Modulus();
+ }
+ sigd = segT_x_vecP*triNor;
+ if(sigd>floatgap)
+ sigd = 1.0;
+ else if(sigd<-floatgap)
+ sigd = -1.0;
+ else {
+ sigd = 0.0;
+ }
+ dPiE[0]=sigd*(Modulus_segT_x_vecP/segT.Modulus());
+ if (dPiE[0]<=floatgap && dPiE[0]>=-floatgap) {
+ sEdge=0;
+ is=0;
+ tbreak=1;
+ }
}
}
-
+
if(tbreak==0) { //-- is = 1
gp_XYZ segT(ToolPolyh::Point(thePolyh, pTri[2]).XYZ()-
- ToolPolyh::Point(thePolyh, pTri[1]).XYZ());
+ ToolPolyh::Point(thePolyh, pTri[1]).XYZ());
gp_XYZ vecP(spLieu-ToolPolyh::Point(thePolyh, pTri[1]).XYZ());
dPtPi[1]=vecP.Modulus();
if (dPtPi[1]<=floatgap) {
- sVertex=1;
- is=1;
- tbreak=1;
+ sVertex=1;
+ is=1;
+ tbreak=1;
}
else {
- gp_XYZ segT_x_vecP(segT^vecP);
- Standard_Real Modulus_segT_x_vecP = segT_x_vecP.Modulus();
- sigd = segT_x_vecP*triNor;
- if(sigd>floatgap)
- sigd = 1.0;
- else if(sigd<-floatgap)
- sigd = -1.0;
- else {
- sigd = 0.0;
- }
- dPiE[1]=sigd*(Modulus_segT_x_vecP/segT.Modulus());
- if (dPiE[1]<=floatgap && dPiE[1]>=-floatgap) {
- sEdge=1;
- is=1;
- tbreak=1;
- }
+ gp_XYZ segT_x_vecP(segT^vecP);
+ Standard_Real Modulus_segT_x_vecP;
+ if(Precision::IsInfinite(segT_x_vecP.X()) || Precision::IsInfinite(segT_x_vecP.Y()) ||
+ Precision::IsInfinite(segT_x_vecP.Z()))
+ {
+ Modulus_segT_x_vecP = Precision::Infinite();
+ }
+ else
+ {
+ Modulus_segT_x_vecP = segT_x_vecP.Modulus();
+ }
+ sigd = segT_x_vecP*triNor;
+ if(sigd>floatgap)
+ sigd = 1.0;
+ else if(sigd<-floatgap)
+ sigd = -1.0;
+ else {
+ sigd = 0.0;
+ }
+ dPiE[1]=sigd*(Modulus_segT_x_vecP/segT.Modulus());
+ if (dPiE[1]<=floatgap && dPiE[1]>=-floatgap) {
+ sEdge=1;
+ is=1;
+ tbreak=1;
+ }
}
}
if(tbreak==0) { //-- is = 2
gp_XYZ segT(ToolPolyh::Point(thePolyh, pTri[0]).XYZ()-
- ToolPolyh::Point(thePolyh, pTri[2]).XYZ());
+ ToolPolyh::Point(thePolyh, pTri[2]).XYZ());
gp_XYZ vecP(spLieu-ToolPolyh::Point(thePolyh, pTri[2]).XYZ());
dPtPi[2]=vecP.Modulus();
if (dPtPi[2]<=floatgap) {
- sVertex=2;
- is=2;
+ sVertex=2;
+ is=2;
}
gp_XYZ segT_x_vecP(segT^vecP);
- Standard_Real Modulus_segT_x_vecP = segT_x_vecP.Modulus();
+ Standard_Real Modulus_segT_x_vecP;
+ if(Precision::IsInfinite(segT_x_vecP.X()) || Precision::IsInfinite(segT_x_vecP.Y()) ||
+ Precision::IsInfinite(segT_x_vecP.Z()))
+ {
+ Modulus_segT_x_vecP = Precision::Infinite();
+ }
+ else
+ {
+ Modulus_segT_x_vecP = segT_x_vecP.Modulus();
+ }
sigd = segT_x_vecP*triNor;
if(sigd>floatgap)
- sigd = 1.0;
+ sigd = 1.0;
else if(sigd<-floatgap)
- sigd = -1.0;
+ sigd = -1.0;
else {
- sigd = 0.0;
+ sigd = 0.0;
}
dPiE[2]=sigd*(Modulus_segT_x_vecP/segT.Modulus());
if (dPiE[2]<=floatgap && dPiE[2]>=-floatgap) {
- sEdge=2;
- is=2;
+ sEdge=2;
+ is=2;
}
}
//-- fin for i=0 to 2
// !!cout<<endl;
-
+
Standard_Integer triCon, pedg;
if (sVertex>-1) {
triCon=TTri;
pedg=pTri[Pourcent3[sVertex+1]];
-//-- while (triCon!=0) {
-//-- ToolPolyh::TriConnex(thePolyh, triCon,pTri[sVertex],pedg,triCon,pedg);
-//-- //-- if (triCon<TTri) return;
-//-- if (triCon==TTri) break;
-//-- }
+ //-- while (triCon!=0) {
+ //-- ToolPolyh::TriConnex(thePolyh, triCon,pTri[sVertex],pedg,triCon,pedg);
+ //-- //-- if (triCon<TTri) return;
+ //-- if (triCon==TTri) break;
+ //-- }
Intf_SectionPoint SP(spLieu,
- typOnG, 0, iLin, param,
- Intf_VERTEX, pTri[is], 0, 0.,
- 1.);
+ typOnG, 0, iLin, param,
+ Intf_VERTEX, pTri[is], 0, 0.,
+ 1.);
mySPoins.Append(SP);
}
else if (sEdge>-1) {
ToolPolyh::TriConnex(thePolyh, TTri, pTri[sEdge], pTri[Pourcent3[sEdge+1]],
- triCon, pedg);
+ triCon, pedg);
//-- if (triCon<=TTri) return; ???????????????????? LBR
// !!cout<<" sEdge "<<endl;
Intf_SectionPoint SP(spLieu,
- typOnG, 0, iLin, param,
- Intf_EDGE, Min(pTri[sEdge], pTri[Pourcent3[sEdge+1]]),
- Max(pTri[sEdge], pTri[Pourcent3[sEdge+1]]), 0.,
- 1.);
+ typOnG, 0, iLin, param,
+ Intf_EDGE, Min(pTri[sEdge], pTri[Pourcent3[sEdge+1]]),
+ Max(pTri[sEdge], pTri[Pourcent3[sEdge+1]]), 0.,
+ 1.);
mySPoins.Append(SP);
}
else if (dPiE[0]>0. && dPiE[1]>0. && dPiE[2]>0.) {
// !!cout<<" 3 Positifs "<<endl;
Intf_SectionPoint SP(spLieu,
- typOnG, 0, iLin, param,
- Intf_FACE, TTri, 0, 0.,
- 1.);
+ typOnG, 0, iLin, param,
+ Intf_FACE, TTri, 0, 0.,
+ 1.);
mySPoins.Append(SP);
}
-// Modified by Sergey KHROMOV - Fri Dec 7 14:40:11 2001 Begin
+ // Modified by Sergey KHROMOV - Fri Dec 7 14:40:11 2001 Begin
// Sometimes triangulation doesn't cover whole the face. In this
// case it is necessary to take into account the deflection between boundary
// isolines of the surface and boundary trianles. Computed value of this
Standard_Integer i;
for (i = 1; i <= 3; i++) {
- Standard_Integer indP1 = (i == 3) ? pTri[0] : pTri[i];
- Standard_Integer indP2 = pTri[i - 1];
-
- if (ToolPolyh::IsOnBound(thePolyh, indP1, indP2)) {
- // For boundary line it is necessary to check the border deflection.
- Standard_Real Deflection = ToolPolyh::GetBorderDeflection(thePolyh);
- const gp_Pnt &BegP = ToolPolyh::Point(thePolyh, indP1);
- const gp_Pnt &EndP = ToolPolyh::Point(thePolyh, indP2);
- gp_Vec VecTri(BegP,EndP);
- gp_Dir DirTri(VecTri);
- gp_Lin LinTri(BegP,DirTri);
- gp_Pnt aPOnE(spLieu);
- Standard_Real aDist = LinTri.Distance(aPOnE);
-
- if (aDist <= Deflection) {
- gp_Vec aVLocPOnE(BegP, aPOnE);
- gp_Vec aVecDirTri(DirTri);
- Standard_Real aPar = aVLocPOnE*aVecDirTri;
- Standard_Real aMaxPar = VecTri.Magnitude();
-
- if (aPar >= 0 && aPar <= aMaxPar) {
- Intf_SectionPoint SP(spLieu,
- typOnG, 0, iLin, param,
- Intf_FACE, TTri, 0, 0.,
- 1.);
- mySPoins.Append(SP);
- }
- }
- }
+ Standard_Integer indP1 = (i == 3) ? pTri[0] : pTri[i];
+ Standard_Integer indP2 = pTri[i - 1];
+
+ if (ToolPolyh::IsOnBound(thePolyh, indP1, indP2)) {
+ // For boundary line it is necessary to check the border deflection.
+ Standard_Real Deflection = ToolPolyh::GetBorderDeflection(thePolyh);
+ const gp_Pnt &BegP = ToolPolyh::Point(thePolyh, indP1);
+ const gp_Pnt &EndP = ToolPolyh::Point(thePolyh, indP2);
+ gp_Vec VecTri(BegP,EndP);
+ gp_Dir DirTri(VecTri);
+ gp_Lin LinTri(BegP,DirTri);
+ gp_Pnt aPOnE(spLieu);
+ Standard_Real aDist = LinTri.Distance(aPOnE);
+
+ if (aDist <= Deflection) {
+ gp_Vec aVLocPOnE(BegP, aPOnE);
+ gp_Vec aVecDirTri(DirTri);
+ Standard_Real aPar = aVLocPOnE*aVecDirTri;
+ Standard_Real aMaxPar = VecTri.Magnitude();
+
+ if (aPar >= 0 && aPar <= aMaxPar) {
+ Intf_SectionPoint SP(spLieu,
+ typOnG, 0, iLin, param,
+ Intf_FACE, TTri, 0, 0.,
+ 1.);
+ mySPoins.Append(SP);
+ }
+ }
+ }
}
}
-// Modified by Sergey KHROMOV - Fri Dec 7 14:40:29 2001 End
+ // Modified by Sergey KHROMOV - Fri Dec 7 14:40:29 2001 End
} //---- if(NoIntersectionWithTriangle == Standard_False)
-
+
//---------------------------------------------------------------------------
//-- On teste la distance entre les cotes du triangle et le polygone
//--
//-- Si cette distance est inferieure a Tolerance, on cree un SP.
//--
//-- printf("\nIntf_InterferencePolygPolyh : dBegTri=%g dEndTri=%g Tolerance=%g\n",dBegTri,dEndTri,Tolerance);
-// if (Abs(dBegTri) <= Tolerance || Abs(dEndTri) <= Tolerance)
+ // if (Abs(dBegTri) <= Tolerance || Abs(dEndTri) <= Tolerance)
{
gp_Vec VecPol(BegO,EndO);
Standard_Real NVecPol = VecPol.Magnitude();
gp_Dir DirPol(VecPol);
gp_Lin LinPol(BegO,DirPol);
Standard_Real dist2,ParamOnO,ParamOnT;
-
+
for (Standard_Integer i=0; i<3; i++) {
Standard_Integer pTri_ip1pc3 = pTri[Pourcent3[i+1]];
Standard_Integer pTri_i = pTri[i];
gp_Lin LinTri(BegT,DirTri);
Extrema_ExtElC Extrema(LinPol,LinTri,0.00000001);
if(Extrema.IsDone()) {
- if(Extrema.IsParallel() == Standard_False) {
- if(Extrema.NbExt()) {
- dist2 = Extrema.SquareDistance();
- if(dist2<=Tolerance * Tolerance) {
- Extrema_POnCurv POnC1,POnC2;
- Extrema.Points(1,POnC1,POnC2);
- const gp_Pnt& PO = POnC1.Value();
- const gp_Pnt& PT = POnC2.Value();
- //--cout<<" ** Nouveau "<<dist2<<endl;
- if(IsInSegment(VecPol,gp_Vec(BegO,PO),NVecPol,ParamOnO,Tolerance)) {
- if(IsInSegment(VecTri,gp_Vec(BegT,PT),NVecTri,ParamOnT,Tolerance)) {
- //-- cout<<" * "<<endl;
- gp_XYZ spLieu=BegT.XYZ()+((EndT.XYZ()-BegT.XYZ())*param);
- Standard_Integer tmin,tmax;
- if(pTri_i>pTri_ip1pc3) {
- tmin=pTri_ip1pc3; tmax=pTri_i;
- }
- else {
- tmax=pTri_ip1pc3; tmin=pTri_i;
- }
- Intf_SectionPoint SP(spLieu,
- typOnG, 0, iLin, ParamOnO,
- Intf_EDGE,
- tmin,
- tmax, 0.,
- 1.);
- mySPoins.Append(SP);
- }
- }
- }
- }
- }
+ if(Extrema.IsParallel() == Standard_False) {
+ if(Extrema.NbExt()) {
+ dist2 = Extrema.SquareDistance();
+ if(dist2<=Tolerance * Tolerance) {
+ Extrema_POnCurv POnC1,POnC2;
+ Extrema.Points(1,POnC1,POnC2);
+ const gp_Pnt& PO = POnC1.Value();
+ const gp_Pnt& PT = POnC2.Value();
+ //--cout<<" ** Nouveau "<<dist2<<endl;
+ if(IsInSegment(VecPol,gp_Vec(BegO,PO),NVecPol,ParamOnO,Tolerance)) {
+ if(IsInSegment(VecTri,gp_Vec(BegT,PT),NVecTri,ParamOnT,Tolerance)) {
+ //-- cout<<" * "<<endl;
+ gp_XYZ spLieu=BegT.XYZ()+((EndT.XYZ()-BegT.XYZ())*param);
+ Standard_Integer tmin,tmax;
+ if(pTri_i>pTri_ip1pc3) {
+ tmin=pTri_ip1pc3; tmax=pTri_i;
+ }
+ else {
+ tmax=pTri_ip1pc3; tmin=pTri_i;
+ }
+ Intf_SectionPoint SP(spLieu,
+ typOnG, 0, iLin, ParamOnO,
+ Intf_EDGE,
+ tmin,
+ tmax, 0.,
+ 1.);
+ mySPoins.Append(SP);
+ }
+ }
+ }
+ }
+ }
}
}
}
Standard_Real DistTol3d = 1.0*Tol3d;
Standard_Real TolU = Surf->UResolution(Tol3d), TolV = Surf->VResolution(Tol3d);
Standard_Real Tol2d = Max(Sqrt(TolU*TolU + TolV*TolV), Precision::PConfusion());
+ //
+ Standard_Real BigTol3d = 10.;
+ if(Tol3d > BigTol3d)
+ {
+ Tol2d = Max(Tol2d, 0.01 * Tol3d);//0.01 = PConfusion/Confusion
+ }
+ //
Standard_Integer i;
GeomAbs_SurfaceType TheTypeS = Surf->GetType();
GeomAbs_CurveType TheTypeC = Curve->GetType();
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()))
+ {
+ samerange = Standard_False;
+ B.SameRange(newEdge, samerange);
+ return;
+ }
p2 = myAC3d.Value(lastPar).Transformed(myLocation);
+ if(Precision::IsInfinite(p2.X()) || Precision::IsInfinite(p2.Y()) ||
+ Precision::IsInfinite(p2.Z()))
+ {
+ samerange = Standard_False;
+ B.SameRange(newEdge, samerange);
+ 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()))
+ {
+ samerange = Standard_False;
+ B.SameRange(newEdge, samerange);
+ return;
+ }
p2 = myCurve->Value(lastPar);
+ if(Precision::IsInfinite(p2.X()) || Precision::IsInfinite(p2.Y()) ||
+ Precision::IsInfinite(p2.Z()))
+ {
+ samerange = Standard_False;
+ B.SameRange(newEdge, samerange);
+ 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)
aMinParSpeed = Min(aMinParSpeed, aDist / aStep);
}
const Standard_Real aCoeff = aLength3d / (aLastParam - aFirstParam);
- if (Abs(aCoeff) > gp::Resolution())
+ if (aCoeff > gp::Resolution())
aKnotCoeffs.Append(aCoeff);
aFirstParam = aLastParam;
}
#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
for ( ; anIter.More(); anIter.Next() )
{
TColStd_Array1OfReal aCoords(1, 3);
+ aCoords(1) = 0.;
+ aCoords(2) = 0.;
+ aCoords(3) = 0.;
+ 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());
}
//----------------------------------------------------------------------
{
+ 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;
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);
+ Standard_Real SupBound = theSupBound(i), InfBound = theInfBound(i);
+ if(Precision::IsNegativeInfinite(SupBound))
+ {
+ SupBound = -Precision::Infinite();
+ }
+ else if(Precision::IsPositiveInfinite(SupBound))
+ {
+ SupBound = Precision::Infinite();
+ }
+ if(Precision::IsNegativeInfinite(InfBound))
+ {
+ InfBound = -Precision::Infinite();
+ }
+ else if(Precision::IsPositiveInfinite(InfBound))
+ {
+ InfBound = Precision::Infinite();
+ }
+
+ InvLengthMax(i) = 1. / Max((SupBound - InfBound)/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"
vsetdispmode 1
checkview -screenshot -3d -path ${imagedir}/${test_image}.png
-checkprops result -s 9951.34
+checkprops result -s 9994.76
-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