return;
}
- Geom2dAdaptor_Curve anAdaptor(myGeom2dCurve);
+ Handle(Geom2dAdaptor_Curve) anAdaptor = new Geom2dAdaptor_Curve(myGeom2dCurve);
GCPnts_QuasiUniformDeflection anEdgeDistrib(anAdaptor, 1.e-2);
if (anEdgeDistrib.IsDone())
{
if (myDisplayPole)
{
- if (anAdaptor.GetType() == GeomAbs_BezierCurve)
+ if (anAdaptor->GetType() == GeomAbs_BezierCurve)
{
- Handle(Geom2d_BezierCurve) aBezier = anAdaptor.Bezier();
+ Handle(Geom2d_BezierCurve) aBezier = anAdaptor->Bezier();
Handle(Graphic3d_ArrayOfPolylines) anArrayOfVertex = new Graphic3d_ArrayOfPolylines(aBezier->NbPoles());
for (int i = 1; i <= aBezier->NbPoles(); i++)
{
aPrsGroup->AddPrimitiveArray(anArrayOfVertex);
}
- if (anAdaptor.GetType() == GeomAbs_BSplineCurve)
+ if (anAdaptor->GetType() == GeomAbs_BSplineCurve)
{
- Handle(Geom2d_BSplineCurve) aBSpline = anAdaptor.BSpline();
+ Handle(Geom2d_BSplineCurve) aBSpline = anAdaptor->BSpline();
Handle(Graphic3d_ArrayOfPolylines) anArrayOfVertex = new Graphic3d_ArrayOfPolylines(aBSpline->NbPoles());
for (int i = 1; i <= aBSpline->NbPoles(); i++)
{
}
}
- if (myDisplayCurbure && (anAdaptor.GetType() != GeomAbs_Line))
+ if (myDisplayCurbure && (anAdaptor->GetType() != GeomAbs_Line))
{
- const Standard_Integer nbintv = anAdaptor.NbIntervals(GeomAbs_CN);
+ const Standard_Integer nbintv = anAdaptor->NbIntervals(GeomAbs_CN);
TColStd_Array1OfReal TI(1, nbintv + 1);
- anAdaptor.Intervals(TI, GeomAbs_CN);
+ anAdaptor->Intervals(TI, GeomAbs_CN);
Standard_Real Resolution = 1.0e-9, Curvature;
Geom2dLProp_CLProps2d LProp(myGeom2dCurve, 2, Resolution);
gp_Pnt2d P1, P2;
const Handle(Prs3d_Presentation)& thePrs,
const Standard_Integer theMode)
{
- GeomAdaptor_Curve anAdaptorCurve(myCurve);
+ Handle(GeomAdaptor_Curve) anAdaptorCurve = new GeomAdaptor_Curve(myCurve);
switch (theMode)
{
case 1:
// Compute BSpline surface bounding box.
Bnd_Box aBndBox;
- BndLib_AddSurface::AddOptimal(GeomAdaptor_Surface(aBSplineSurf), Precision::Confusion(), aBndBox);
+ BndLib_AddSurface::AddOptimal(new GeomAdaptor_Surface(aBSplineSurf), Precision::Confusion(), aBndBox);
myResult << "Bounding box:" << std::endl;
myResult << " Min corner = [ "
<< aBndBox.CornerMin().X() << ", "
// Compute BSpline curve bounding box.
Bnd_Box aBndBox;
- BndLib_Add3dCurve::AddOptimal(GeomAdaptor_Curve(aBSplineCurve), Precision::Confusion(), aBndBox);
+ BndLib_Add3dCurve::AddOptimal(new GeomAdaptor_Curve(aBSplineCurve), Precision::Confusion(), aBndBox);
myResult << "Bounding box:" << std::endl;
myResult << " Min corner = [ "
<< aBndBox.CornerMin().X() << ", "
for (TopExp_Explorer anEdgeIter (myshape, TopAbs_EDGE); anEdgeIter.More(); anEdgeIter.Next())
{
const TopoDS_Edge& anEdge = TopoDS::Edge (anEdgeIter.Current());
- BRepAdaptor_Curve2d aCurveOnEdge (anEdge, aFace);
+ Handle(BRepAdaptor_Curve2d) aCurveOnEdge = new BRepAdaptor_Curve2d(anEdge, aFace);
GCPnts_QuasiUniformDeflection anEdgeDistrib(aCurveOnEdge, 1.e-2);
if (!anEdgeDistrib.IsDone())
{
if (!aTrimmedCurve.IsNull())
{
Handle(Geom_Curve) aCurve3d = GeomLib::To3d(gp_Ax2(gp_Pnt(0, 0, 0), gp_Dir(0, 0, 1)), aTrimmedCurve);
- BRepAdaptor_Curve2d aCurveOnEdge (anEdge, aFace);
+ Handle(BRepAdaptor_Curve2d) aCurveOnEdge = new BRepAdaptor_Curve2d(anEdge, aFace);
GCPnts_QuasiUniformDeflection anEdgeDistrib (aCurveOnEdge, 1.e-2);
if (!anEdgeDistrib.IsDone())
{
// make a 3D curve from 2D trimmed curve to display it
Handle(Geom_Curve) aCurve3d = GeomLib::To3d(gp_Ax2(gp_Pnt(0, 0, 0), gp_Dir(0, 0, 1)), aTrimmedCurve);
// make distribution of points
- BRepAdaptor_Curve2d aCurveOnEdge (anEdge, aFace);
+ Handle(BRepAdaptor_Curve2d) aCurveOnEdge = new BRepAdaptor_Curve2d(anEdge, aFace);
GCPnts_QuasiUniformDeflection anEdgeDistrib(aCurveOnEdge, 1.e-2);
if (anEdgeDistrib.IsDone())
{
Standard_Real radius = 5;
Handle(Geom2d_Circle) C =
new Geom2d_Circle(gp::OX2d(),radius);
- Geom2dAdaptor_Curve GAC (C);
+ Handle(Geom2dAdaptor_Curve) GAC = new Geom2dAdaptor_Curve(C);
Standard_Real startparam = 10*M_PI/180;
Standard_Real abscissa = 45*M_PI/180;
gp_Pnt2d P1;
//==============================================================
TCollection_AsciiString Message (" \n\
- \n\
- \n\
-Standard_Real radius = 5; \n\
-Handle(Geom2d_Circle) C = \n\
- new Geom2d_Circle(gp::OX2d(),radius); \n\
-Geom2dAdaptor_Curve GAC (C); \n\
-Standard_Real startparam = 10*PI180; \n\
-Standard_Real abscissa = 45*PI180; \n\
-gp_Pnt2d P1; \n\
-C->D0(startparam,P1); \n\
-// abscissa is the distance along the curve from startparam \n\
-GCPnts_AbscissaPoint AP (GAC, abscissa, startparam); \n\
-gp_Pnt2d P2; \n\
-if (AP.IsDone()){C->D0(AP.Parameter(),P2);} \n\
-// P is now correctly set \n\
- \n\
- \n");
+ \n\
+ \n\
+Standard_Real radius = 5; \n\
+Handle(Geom2d_Circle) C = \n\
+ new Geom2d_Circle(gp::OX2d(),radius); \n\
+Handle(Geom2dAdaptor_Curve) GAC = new Geom2dAdaptor_Curve(C); \n\
+Standard_Real startparam = 10*PI180; \n\
+Standard_Real abscissa = 45*PI180; \n\
+gp_Pnt2d P1; \n\
+C->D0(startparam,P1); \n\
+// abscissa is the distance along the curve from startparam \n\
+GCPnts_AbscissaPoint AP (GAC, abscissa, startparam); \n\
+gp_Pnt2d P2; \n\
+if (AP.IsDone()){C->D0(AP.Parameter(),P2);} \n\
+// P is now correctly set \n\
+ \n\
+ \n");
AddSeparator(aDoc,Message);
//--------------------------------------------------------------
Handle(ISession2D_Curve) aCurve = new ISession2D_Curve(C);
Standard_Real radius = 5;
Handle(Geom2d_Circle) C =
new Geom2d_Circle(gp::OX2d(),radius);
- Geom2dAdaptor_Curve GAC (C);
+ Handle(Geom2dAdaptor_Curve) GAC = new Geom2dAdaptor_Curve(C);
Standard_Real abscissa = 3;
GCPnts_UniformAbscissa UA (GAC,abscissa);
TColgp_SequenceOfPnt2d aSequence;
//==============================================================
TCollection_AsciiString Message (" \
- \n\
-gp_Pnt2d P; \n\
-Standard_Real radius = 5; \n\
-Handle(Geom2d_Circle) C = \n\
- new Geom2d_Circle(gp::OX2d(),radius); \n\
-Geom2dAdaptor_Curve GAC (C); \n\
-Standard_Real abscissa = 3; \n\
-GCPnts_UniformAbscissa UA (GAC,abscissa); \n\
-TColgp_SequenceOfPnt2d aSequence; \n\
-if (UA.IsDone()) \n\
- { \n\
- Standard_Real N = UA.NbPoints(); \n\
- Standard_Integer count = 1; \n\
- for(;count<=N;count++) \n\
- { \n\
- C->D0(UA.Parameter(count),P); \n\
- Standard_Real Parameter = UA.Parameter(count); \n\
- // append P in a Sequence \n\
- aSequence.Append(P); \n\
- } \n\
-} \n\
-Standard_Real Abscissa = UA.Abscissa(); \n\
- \n");
+ \n\
+gp_Pnt2d P; \n\
+Standard_Real radius = 5; \n\
+Handle(Geom2d_Circle) C = \n\
+ new Geom2d_Circle(gp::OX2d(),radius); \n\
+Handle(Geom2dAdaptor_Curve) GAC = new Geom2dAdaptor_Curve(C); \n\
+Standard_Real abscissa = 3; \n\
+GCPnts_UniformAbscissa UA (GAC,abscissa); \n\
+TColgp_SequenceOfPnt2d aSequence; \n\
+if (UA.IsDone()) \n\
+ { \n\
+ Standard_Real N = UA.NbPoints(); \n\
+ Standard_Integer count = 1; \n\
+ for(;count<=N;count++) \n\
+ { \n\
+ C->D0(UA.Parameter(count),P); \n\
+ Standard_Real Parameter = UA.Parameter(count); \n\
+ // append P in a Sequence \n\
+ aSequence.Append(P); \n\
+ } \n\
+} \n\
+Standard_Real Abscissa = UA.Abscissa(); \n\
+ \n");
AddSeparator(aDoc,Message);
//--------------------------------------------------------------
Handle(ISession2D_Curve) aCurve = new ISession2D_Curve(C);
Handle(Geom2d_BSplineCurve) SPL2 = anInterpolation.Curve();
Bnd_Box2d aCBox;
- Geom2dAdaptor_Curve GACC (C);
+ Handle(Geom2dAdaptor_Curve) GACC = new Geom2dAdaptor_Curve(C);
BndLib_Add2dCurve::Add (GACC,Precision::Approximation(),aCBox);
Standard_Real aCXmin, aCYmin, aCXmax, aCYmax;
aCBox.Get( aCXmin, aCYmin, aCXmax,aCYmax);
Bnd_Box2d aSPL1Box;
- Geom2dAdaptor_Curve GAC1 (SPL1);
+ Handle(Geom2dAdaptor_Curve) GAC1 = new Geom2dAdaptor_Curve(SPL1);
BndLib_Add2dCurve::Add (GAC1,Precision::Approximation(),aSPL1Box);
Standard_Real aSPL1Xmin,aSPL1Ymin,aSPL1Xmax,aSPL1Ymax;
aSPL1Box.Get( aSPL1Xmin, aSPL1Ymin, aSPL1Xmax,aSPL1Ymax);
Bnd_Box2d aSPL2Box;
- Geom2dAdaptor_Curve GAC2 (SPL2);
+ Handle(Geom2dAdaptor_Curve) GAC2 = new Geom2dAdaptor_Curve(SPL2);
BndLib_Add2dCurve::Add (GAC2,Precision::Approximation(),aSPL2Box);
Standard_Real aSPL2Xmin,aSPL2Ymin,aSPL2Xmax,aSPL2Ymax;
Handle(Geom2d_BSplineCurve) SPL2 ; // SPL2 = ... \n\
\n\
Bnd_Box2d aCBox; \n\
-Geom2dAdaptor_Curve GACC (C); \n\
+Handle(Geom2dAdaptor_Curve) GACC = new Geom2dAdaptor_Curve(C); \n\
BndLib_Add2dCurve::Add (GACC,Precision::Approximation(),aCBox); \n\
\n\
Standard_Real aCXmin, aCYmin, aCXmax, aCYmax; \n\
aCBox.Get( aCXmin, aCYmin, aCXmax,aCYmax); \n\
\n\
Bnd_Box2d aSPL1Box; \n\
-Geom2dAdaptor_Curve GAC1 (SPL1); \n\
+Handle(Geom2dAdaptor_Curve) GAC1 = new Geom2dAdaptor_Curve(SPL1); \n\
BndLib_Add2dCurve::Add (GAC1,Precision::Approximation(),aSPL1Box); \n\
\n\
Standard_Real aSPL1Xmin,aSPL1Ymin,aSPL1Xmax,aSPL1Ymax; \n\
Message += "\
\n\
Bnd_Box2d aSPL2Box; \n\
-Geom2dAdaptor_Curve GAC2 (SPL2); \n\
+Handle(Geom2dAdaptor_Curve) GAC2 = new Geom2dAdaptor_Curve(SPL2); \n\
BndLib_Add2dCurve::Add (GAC2,Precision::Approximation(),aSPL2Box); \n\
\n\
Standard_Real aSPL2Xmin,aSPL2Ymin,aSPL2Xmax,aSPL2Ymax; \n\
Handle(Geom_Circle) C =
new Geom_Circle(anAxis,radius);
- GeomAdaptor_Curve GAC (C);
+ Handle(GeomAdaptor_Curve) GAC = new GeomAdaptor_Curve(C);
BndLib_Add3dCurve::Add (GAC,Precision::Approximation(),aBox);
Standard_Real aXmin, aYmin, aZmin, aXmax, aYmax, aZmax ;
\n\
Handle(Geom_Circle) C = \n\
new Geom_Circle(anAxis,radius); \n\
-GeomAdaptor_Curve GAC (C); \n\
+Handle(GeomAdaptor_Curve) GAC = new GeomAdaptor_Curve(C); \n\
BndLib_Add3dCurve::Add (GAC,Precision::Approximation(),aBox); \n\
\n\
Standard_Real aXmin, aYmin, aZmin, aXmax, aYmax, aZmax ; \n\
GeomFill_FillingStyle Type = GeomFill_StretchStyle;
GeomFill_BSplineCurves aGeomFill1(SPL1,SPL2,Type);
Handle(Geom_BSplineSurface) aSurf = aGeomFill1.Surface();
- GeomAdaptor_Surface GAS (aSurf);
+ Handle(GeomAdaptor_Surface) GAS = new GeomAdaptor_Surface(aSurf);
Bnd_Box aBox;
BndLib_AddSurface::Add (GAS,Precision::Approximation(),aBox);
array2.SetValue(3,gp_Pnt ( 20, 30,-10)); \n\
array2.SetValue(4,gp_Pnt ( 30, 70,-20)); \n\
array2.SetValue(5,gp_Pnt ( 40, 90,-10)); \n\
-Handle(Geom_BSplineCurve) SPL2 = \n\
+Handle(Geom_BSplineCurve) SPL2 = \n\
GeomAPI_PointsToBSpline(array2).Curve(); \n\
- \n\
-GeomFill_FillingStyle Type = GeomFill_StretchStyle; \n\
-GeomFill_BSplineCurves aGeomFill1(SPL1,SPL2,Type); \n\
-Handle(Geom_BSplineSurface) aSurf = aGeomFill1.Surface(); \n\
-GeomAdaptor_Surface GAS (aSurf); \n\
-Bnd_Box aBox; \n\
-BndLib_AddSurface::Add (GAS,Precision::Approximation(),aBox); \n\
- \n\
-Standard_Real aXmin, aYmin, aZmin, aXmax, aYmax, aZmax ; \n\
-aBox.Get( aXmin, aYmin,aZmin, aXmax,aYmax,aZmax); \n\
- \n");
+ \n\
+GeomFill_FillingStyle Type = GeomFill_StretchStyle; \n\
+GeomFill_BSplineCurves aGeomFill1(SPL1,SPL2,Type); \n\
+Handle(Geom_BSplineSurface) aSurf = aGeomFill1.Surface(); \n\
+Handle(GeomAdaptor_Surface) GAS = new GeomAdaptor_Surface(aSurf); \n\
+Bnd_Box aBox; \n\
+BndLib_AddSurface::Add (GAS,Precision::Approximation(),aBox); \n\
+ \n\
+Standard_Real aXmin, aYmin, aZmin, aXmax, aYmax, aZmax ; \n\
+aBox.Get( aXmin, aYmin,aZmin, aXmax,aYmax,aZmax); \n\
+ \n");
AddSeparator(aDoc,Message);
//--------------------------------------------------------------
aPrsGroup->SetGroupPrimitivesAspect (myDrawer->LineAspect()->Aspect());
aPrsGroup->SetGroupPrimitivesAspect (myDrawer->PointAspect()->Aspect());
- Geom2dAdaptor_Curve anAdaptor(myGeom2dCurve);
+ Handle(Geom2dAdaptor_Curve) anAdaptor = new Geom2dAdaptor_Curve(myGeom2dCurve);
GCPnts_QuasiUniformDeflection anEdgeDistrib(anAdaptor,1.e-2);
if(anEdgeDistrib.IsDone())
{
if (myDisplayPole)
{
- if (anAdaptor.GetType() == GeomAbs_BezierCurve )
+ if (anAdaptor->GetType() == GeomAbs_BezierCurve )
{
- Handle(Geom2d_BezierCurve) aBezier = anAdaptor.Bezier();
+ Handle(Geom2d_BezierCurve) aBezier = anAdaptor->Bezier();
Handle(Graphic3d_ArrayOfPolylines) anArrayOfVertex = new Graphic3d_ArrayOfPolylines(aBezier->NbPoles());
for(int i=1;i<=aBezier->NbPoles();i++)
{
aPrsGroup->AddPrimitiveArray (anArrayOfVertex);
}
- if (anAdaptor.GetType() == GeomAbs_BSplineCurve )
+ if (anAdaptor->GetType() == GeomAbs_BSplineCurve )
{
- Handle(Geom2d_BSplineCurve) aBSpline = anAdaptor.BSpline();
+ Handle(Geom2d_BSplineCurve) aBSpline = anAdaptor->BSpline();
Handle(Graphic3d_ArrayOfPolylines) anArrayOfVertex =
new Graphic3d_ArrayOfPolylines(aBSpline->NbPoles());
}
}
- if (myDisplayCurbure && (anAdaptor.GetType() != GeomAbs_Line))
+ if (myDisplayCurbure && (anAdaptor->GetType() != GeomAbs_Line))
{
Standard_Integer ii;
- Standard_Integer intrv, nbintv = anAdaptor.NbIntervals(GeomAbs_CN);
+ Standard_Integer intrv, nbintv = anAdaptor->NbIntervals(GeomAbs_CN);
TColStd_Array1OfReal TI(1,nbintv+1);
- anAdaptor.Intervals(TI,GeomAbs_CN);
+ anAdaptor->Intervals(TI,GeomAbs_CN);
Standard_Real Resolution = 1.0e-9, Curvature;
Geom2dLProp_CLProps2d LProp(myGeom2dCurve, 2, Resolution);
gp_Pnt2d P1, P2;
const Handle(Prs3d_Presentation)& thePrs,
const Standard_Integer theMode)
{
- GeomAdaptor_Curve anAdaptorCurve (myCurve);
+ Handle(GeomAdaptor_Curve) anAdaptorCurve = new GeomAdaptor_Curve(myCurve);
switch (theMode)
{
case 1:
const Handle(Prs3d_Presentation)& thePrs,
const Standard_Integer theMode)
{
- GeomAdaptor_Surface anAdaptorSurface (mySurface);
- Handle(GeomAdaptor_Surface) anAdaptorHSurface = new GeomAdaptor_Surface (mySurface);
+ Handle(GeomAdaptor_Surface) anAdaptorSurface = new GeomAdaptor_Surface (mySurface);
Handle(Prs3d_Drawer) aPoleDrawer = new Prs3d_Drawer();
aPoleDrawer->SetOwnLineAspects();
}
case 0:
{
- StdPrs_WFSurface::Add (thePrs, anAdaptorHSurface, myDrawer);
+ StdPrs_WFSurface::Add (thePrs, anAdaptorSurface, myDrawer);
break;
}
}
thePrs->SetInfiniteState (myInfiniteState);
if (!myIsXYZAxis)
{
- GeomAdaptor_Curve curv (myComponent);
+ Handle(GeomAdaptor_Curve) curv = new GeomAdaptor_Curve(myComponent);
StdPrs_Curve::Add (thePrs, curv, myDrawer);
}
else
void AIS_Circle::ComputeCircle (const Handle(Prs3d_Presentation)& thePresentation)
{
- GeomAdaptor_Curve curv(myComponent);
+ Handle(GeomAdaptor_Curve) curv = new GeomAdaptor_Curve(myComponent);
Standard_Real prevdev = myDrawer->DeviationCoefficient();
myDrawer->SetDeviationCoefficient (1.e-5);
StdPrs_DeflectionCurve::Add (thePresentation, curv, myDrawer);
//=======================================================================
void AIS_Circle::ComputeArc (const Handle(Prs3d_Presentation)& thePresentation)
{
- GeomAdaptor_Curve curv(myComponent, myUStart, myUEnd);
+ Handle(GeomAdaptor_Curve) curv = new GeomAdaptor_Curve(myComponent, myUStart, myUEnd);
Standard_Real prevdev = myDrawer->DeviationCoefficient();
myDrawer->SetDeviationCoefficient (1.e-5);
StdPrs_DeflectionCurve::Add (thePresentation, curv, myDrawer);
//=======================================================================
void AIS_Line::ComputeInfiniteLine( const Handle(Prs3d_Presentation)& aPresentation)
{
- GeomAdaptor_Curve curv(myComponent);
+ Handle(GeomAdaptor_Curve) curv = new GeomAdaptor_Curve(myComponent);
StdPrs_Curve::Add(aPresentation,curv,myDrawer);
//pas de prise en compte lors du FITALL
myComponent = new Geom_Line(P1,gp_Dir(P2.XYZ()-P1.XYZ()));
Standard_Real dist = P1.Distance(P2);
- GeomAdaptor_Curve curv(myComponent,0.,dist);
+ Handle(GeomAdaptor_Curve) curv = new GeomAdaptor_Curve(myComponent,0.,dist);
StdPrs_Curve::Add(aPresentation,curv,myDrawer);
}
ComputeFrame();
const Handle(Geom_Plane)& pl = myComponent;
Handle(Geom_Plane) thegoodpl (Handle(Geom_Plane)::DownCast(pl->Translated(pl->Location(),myCenter)));
- GeomAdaptor_Surface surf(thegoodpl);
+ Handle(GeomAdaptor_Surface) surf = new GeomAdaptor_Surface(thegoodpl);
StdPrs_Plane::Add (thePrs, surf, myDrawer);
}
else
}
}
-/*static Standard_Real curvature(const Standard_Real U, const Adaptor3d_Curve& C)
+/*static Standard_Real curvature(const Standard_Real U, const Handle(Adaptor3d_Curve)& C)
{
Standard_Real k, tau, mod1, mod2, OMEGA;
gp_Pnt P;
void Approx_CurvlinFunc::Init()
{
- Adaptor3d_CurveOnSurface CurOnSur;
-
+ Handle(Adaptor3d_CurveOnSurface) CurOnSur;
+
switch(myCase) {
case 1:
- Init (*myC3D, mySi_1, myUi_1);
- myFirstU1 = myC3D->FirstParameter();
- myLastU1 = myC3D->LastParameter();
- myFirstU2 = myLastU2 = 0;
- break;
+ {
+ Init(myC3D, mySi_1, myUi_1);
+ myFirstU1 = myC3D->FirstParameter();
+ myLastU1 = myC3D->LastParameter();
+ myFirstU2 = myLastU2 = 0;
+ break;
+ }
case 2:
- CurOnSur.Load(myC2D1);
- CurOnSur.Load(mySurf1);
- Init(CurOnSur, mySi_1, myUi_1);
- myFirstU1 = CurOnSur.FirstParameter();
- myLastU1 = CurOnSur.LastParameter();
- myFirstU2 = myLastU2 = 0;
- break;
+ {
+ CurOnSur = new Adaptor3d_CurveOnSurface(myC2D1, mySurf1);
+ CurOnSur->Load(myC2D1);
+ CurOnSur->Load(mySurf1);
+ Init(CurOnSur, mySi_1, myUi_1);
+ myFirstU1 = CurOnSur->FirstParameter();
+ myLastU1 = CurOnSur->LastParameter();
+ myFirstU2 = myLastU2 = 0;
+ break;
+ }
case 3:
- CurOnSur.Load(myC2D1);
- CurOnSur.Load(mySurf1);
- Init(CurOnSur, mySi_1, myUi_1);
- myFirstU1 = CurOnSur.FirstParameter();
- myLastU1 = CurOnSur.LastParameter();
- CurOnSur.Load(myC2D2);
- CurOnSur.Load(mySurf2);
- Init(CurOnSur, mySi_2, myUi_2);
- myFirstU2 = CurOnSur.FirstParameter();
- myLastU2 = CurOnSur.LastParameter();
+ {
+ CurOnSur = new Adaptor3d_CurveOnSurface(myC2D1, mySurf1);
+ Init(CurOnSur, mySi_1, myUi_1);
+ myFirstU1 = CurOnSur->FirstParameter();
+ myLastU1 = CurOnSur->LastParameter();
+ CurOnSur->Load(myC2D2);
+ CurOnSur->Load(mySurf2);
+ Init(CurOnSur, mySi_2, myUi_2);
+ myFirstU2 = CurOnSur->FirstParameter();
+ myLastU2 = CurOnSur->LastParameter();
+ }
}
Length();
//purpose : Init the values
//history : 23/10/1998 PMN : Cut at curve's discontinuities
//=======================================================================
-void Approx_CurvlinFunc::Init(Adaptor3d_Curve& C, Handle(TColStd_HArray1OfReal)& Si,
- Handle(TColStd_HArray1OfReal)& Ui) const
+void Approx_CurvlinFunc::Init (const Handle(Adaptor3d_Curve)& C, Handle(TColStd_HArray1OfReal)& Si,
+ Handle(TColStd_HArray1OfReal)& Ui) const
{
Standard_Real Step, FirstU, LastU;
Standard_Integer i, j, k, NbInt, NbIntC3;
- FirstU = C.FirstParameter();
- LastU = C.LastParameter();
+ FirstU = C->FirstParameter();
+ LastU = C->LastParameter();
NbInt = 10;
- NbIntC3 = C.NbIntervals(GeomAbs_C3);
+ NbIntC3 = C->NbIntervals(GeomAbs_C3);
TColStd_Array1OfReal Disc(1, NbIntC3+1);
if (NbIntC3 >1) {
- C.Intervals(Disc, GeomAbs_C3);
+ C->Intervals(Disc, GeomAbs_C3);
}
else {
Disc(1) = FirstU;
if ((Last - First) < Tol) return;
Standard_Real FirstU, LastU;
- Adaptor3d_CurveOnSurface CurOnSur;
- Handle(Adaptor3d_CurveOnSurface) HCurOnSur;
+ Handle(Adaptor3d_CurveOnSurface) CurOnSur;
+ Handle(Adaptor3d_CurveOnSurface) TCurOnSur;
switch(myCase) {
case 1:
myC3D = myC3D->Trim(myFirstU1, myLastU1, Tol);
- FirstU = GetUParameter(*myC3D, First, 1);
- LastU = GetUParameter (*myC3D, Last, 1);
+ FirstU = GetUParameter(myC3D, First, 1);
+ LastU = GetUParameter (myC3D, Last, 1);
myC3D = myC3D->Trim(FirstU, LastU, Tol);
break;
case 3:
- CurOnSur.Load(myC2D2);
- CurOnSur.Load(mySurf2);
- HCurOnSur = Handle(Adaptor3d_CurveOnSurface)::DownCast (CurOnSur.Trim(myFirstU2, myLastU2, Tol));
- myC2D2 = HCurOnSur->GetCurve();
- mySurf2 = HCurOnSur->GetSurface();
- CurOnSur.Load(myC2D2);
- CurOnSur.Load(mySurf2);
+ CurOnSur = new Adaptor3d_CurveOnSurface(myC2D2, mySurf2);
+ TCurOnSur = Handle(Adaptor3d_CurveOnSurface)::DownCast (CurOnSur->Trim(myFirstU2, myLastU2, Tol));
+ myC2D2 = TCurOnSur->GetCurve();
+ mySurf2 = TCurOnSur->GetSurface();
+ CurOnSur->Load(myC2D2);
+ CurOnSur->Load(mySurf2);
FirstU = GetUParameter(CurOnSur, First, 1);
LastU = GetUParameter(CurOnSur, Last, 1);
- HCurOnSur = Handle(Adaptor3d_CurveOnSurface)::DownCast (CurOnSur.Trim(FirstU, LastU, Tol));
- myC2D2 = HCurOnSur->GetCurve();
- mySurf2 = HCurOnSur->GetSurface();
+ TCurOnSur = Handle(Adaptor3d_CurveOnSurface)::DownCast (CurOnSur->Trim(FirstU, LastU, Tol));
+ myC2D2 = TCurOnSur->GetCurve();
+ mySurf2 = TCurOnSur->GetSurface();
Standard_FALLTHROUGH
case 2:
- CurOnSur.Load(myC2D1);
- CurOnSur.Load(mySurf1);
- HCurOnSur = Handle(Adaptor3d_CurveOnSurface)::DownCast (CurOnSur.Trim(myFirstU1, myLastU1, Tol));
- myC2D1 = HCurOnSur->GetCurve();
- mySurf1 = HCurOnSur->GetSurface();
- CurOnSur.Load(myC2D1);
- CurOnSur.Load(mySurf1);
+ CurOnSur = new Adaptor3d_CurveOnSurface(myC2D1, mySurf1);
+ TCurOnSur = Handle(Adaptor3d_CurveOnSurface)::DownCast (CurOnSur->Trim(myFirstU1, myLastU1, Tol));
+ myC2D1 = TCurOnSur->GetCurve();
+ mySurf1 = TCurOnSur->GetSurface();
+ CurOnSur->Load(myC2D1);
+ CurOnSur->Load(mySurf1);
FirstU = GetUParameter(CurOnSur, First, 1);
LastU = GetUParameter(CurOnSur, Last, 1);
- HCurOnSur = Handle(Adaptor3d_CurveOnSurface)::DownCast (CurOnSur.Trim(FirstU, LastU, Tol));
- myC2D1 = HCurOnSur->GetCurve();
- mySurf1 = HCurOnSur->GetSurface();
+ TCurOnSur = Handle(Adaptor3d_CurveOnSurface)::DownCast (CurOnSur->Trim(FirstU, LastU, Tol));
+ myC2D1 = TCurOnSur->GetCurve();
+ mySurf1 = TCurOnSur->GetSurface();
}
myFirstS = First;
myLastS = Last;
void Approx_CurvlinFunc::Length()
{
- Adaptor3d_CurveOnSurface CurOnSur;
+ Handle(Adaptor3d_CurveOnSurface) CurOnSur;
Standard_Real FirstU, LastU;
switch(myCase){
case 1:
FirstU = myC3D->FirstParameter();
LastU = myC3D->LastParameter();
- myLength = Length (*myC3D, FirstU, LastU);
+ myLength = Length (myC3D, FirstU, LastU);
myLength1 = myLength2 = 0;
break;
case 2:
- CurOnSur.Load(myC2D1);
- CurOnSur.Load(mySurf1);
- FirstU = CurOnSur.FirstParameter();
- LastU = CurOnSur.LastParameter();
+ CurOnSur = new Adaptor3d_CurveOnSurface(myC2D1, mySurf1);
+ FirstU = CurOnSur->FirstParameter();
+ LastU = CurOnSur->LastParameter();
myLength = Length(CurOnSur, FirstU, LastU);
myLength1 = myLength2 = 0;
break;
case 3:
- CurOnSur.Load(myC2D1);
- CurOnSur.Load(mySurf1);
- FirstU = CurOnSur.FirstParameter();
- LastU = CurOnSur.LastParameter();
+ CurOnSur = new Adaptor3d_CurveOnSurface(myC2D1, mySurf1);
+ FirstU = CurOnSur->FirstParameter();
+ LastU = CurOnSur->LastParameter();
myLength1 = Length(CurOnSur, FirstU, LastU);
- CurOnSur.Load(myC2D2);
- CurOnSur.Load(mySurf2);
- FirstU = CurOnSur.FirstParameter();
- LastU = CurOnSur.LastParameter();
+ CurOnSur->Load(myC2D2);
+ CurOnSur->Load(mySurf2);
+ FirstU = CurOnSur->FirstParameter();
+ LastU = CurOnSur->LastParameter();
myLength2 = Length(CurOnSur, FirstU, LastU);
myLength = (myLength1 + myLength2)/2;
}
}
-Standard_Real Approx_CurvlinFunc::Length(Adaptor3d_Curve& C, const Standard_Real FirstU, const Standard_Real LastU) const
+Standard_Real Approx_CurvlinFunc::Length(const Handle(Adaptor3d_Curve)& C, const Standard_Real FirstU, const Standard_Real LastU) const
{
Standard_Real Length;
Standard_Real Approx_CurvlinFunc::GetSParameter(const Standard_Real U) const
{
Standard_Real S=0, S1, S2;
- Adaptor3d_CurveOnSurface CurOnSur;
+ Handle(Adaptor3d_CurveOnSurface) CurOnSur;
switch (myCase) {
case 1:
- S = GetSParameter (*myC3D, U, myLength);
+ S = GetSParameter (myC3D, U, myLength);
break;
case 2:
- CurOnSur.Load(myC2D1);
- CurOnSur.Load(mySurf1);
+ CurOnSur = new Adaptor3d_CurveOnSurface(myC2D1, mySurf1);
S = GetSParameter(CurOnSur, U, myLength);
break;
case 3:
- CurOnSur.Load(myC2D1);
- CurOnSur.Load(mySurf1);
- S1 = GetSParameter(CurOnSur, U, myLength1);
- CurOnSur.Load(myC2D2);
- CurOnSur.Load(mySurf2);
- S2 = GetSParameter(CurOnSur, U, myLength2);
+ CurOnSur = new Adaptor3d_CurveOnSurface(myC2D1, mySurf1);
+ S1 = GetSParameter(CurOnSur, U, myLength1);
+ CurOnSur->Load(myC2D2);
+ CurOnSur->Load(mySurf2);
+ S2 = GetSParameter(CurOnSur, U, myLength2);
S = (S1 + S2)/2;
}
return S;
-Standard_Real Approx_CurvlinFunc::GetUParameter(Adaptor3d_Curve& C,
- const Standard_Real S,
- const Standard_Integer NumberOfCurve) const
+Standard_Real Approx_CurvlinFunc::GetUParameter (const Handle(Adaptor3d_Curve)& C,
+ const Standard_Real S,
+ const Standard_Integer NumberOfCurve) const
{
Standard_Real deltaS, base, U, Length;
Standard_Integer NbInt, NInterval, i;
return U;
}
-Standard_Real Approx_CurvlinFunc::GetSParameter(Adaptor3d_Curve& C, const Standard_Real U, const Standard_Real Len) const
+Standard_Real Approx_CurvlinFunc::GetSParameter(const Handle(Adaptor3d_Curve)& C, const Standard_Real U, const Standard_Real Len) const
{
Standard_Real S, Origin;
- Origin = C.FirstParameter();
- S = myFirstS + Length(C, Origin, U)/Len;
+ Origin = C->FirstParameter();
+ S = myFirstS + Length(C, Origin, U)/Len;
return S;
}
gp_Vec dC_dU, dC_dS, d2C_dU2, d2C_dS2;
Standard_Real U, Mag, dU_dS, d2U_dS2;
- U = GetUParameter (*myC3D, S, 1);
+ U = GetUParameter (myC3D, S, 1);
switch(Order) {
if (NumberOfCurve == 1) {
Cur2D = myC2D1;
- Surf = mySurf1;
- Adaptor3d_CurveOnSurface CurOnSur(myC2D1, mySurf1);
+ Surf = mySurf1;
+ Handle(Adaptor3d_CurveOnSurface) CurOnSur = new Adaptor3d_CurveOnSurface(myC2D1, mySurf1);
U = GetUParameter(CurOnSur, S, 1);
if(myCase == 3) Length = myLength1;
else Length = myLength;
}
else if (NumberOfCurve == 2) {
Cur2D = myC2D2;
- Surf = mySurf2;
- Adaptor3d_CurveOnSurface CurOnSur(myC2D2, mySurf2);
+ Surf = mySurf2;
+ Handle(Adaptor3d_CurveOnSurface) CurOnSur = new Adaptor3d_CurveOnSurface(myC2D2, mySurf2);
U = GetUParameter(CurOnSur, S, 2);
Length = myLength2;
}
Standard_EXPORT void Length();
//! Computes length of the curve segment.
- Standard_EXPORT Standard_Real Length (Adaptor3d_Curve& C, const Standard_Real FirstU, const Standard_Real LasrU) const;
+ Standard_EXPORT Standard_Real Length (const Handle(Adaptor3d_Curve)& C, const Standard_Real FirstU, const Standard_Real LasrU) const;
Standard_EXPORT Standard_Real GetLength() const;
//! returns original parameter corresponding S. if
//! Case == 1 computation is performed on myC2D1 and mySurf1,
//! otherwise it is done on myC2D2 and mySurf2.
- Standard_EXPORT Standard_Real GetUParameter (Adaptor3d_Curve& C, const Standard_Real S, const Standard_Integer NumberOfCurve) const;
+ Standard_EXPORT Standard_Real GetUParameter (const Handle(Adaptor3d_Curve)& C, const Standard_Real S, const Standard_Integer NumberOfCurve) const;
//! returns original parameter corresponding S.
Standard_EXPORT Standard_Real GetSParameter (const Standard_Real U) const;
Standard_EXPORT void Init();
- Standard_EXPORT void Init (Adaptor3d_Curve& C, Handle(TColStd_HArray1OfReal)& Si, Handle(TColStd_HArray1OfReal)& Ui) const;
+ Standard_EXPORT void Init (const Handle(Adaptor3d_Curve)& C, Handle(TColStd_HArray1OfReal)& Si, Handle(TColStd_HArray1OfReal)& Ui) const;
//! returns curvilinear parameter corresponding U.
- Standard_EXPORT Standard_Real GetSParameter (Adaptor3d_Curve& C, const Standard_Real U, const Standard_Real Length) const;
+ Standard_EXPORT Standard_Real GetSParameter (const Handle(Adaptor3d_Curve)& C, const Standard_Real U, const Standard_Real Length) const;
Standard_EXPORT Standard_Boolean EvalCurOnSur (const Standard_Real S, const Standard_Integer Order, TColStd_Array1OfReal& Result, const Standard_Integer NumberOfCurve) const;
const gp_Pnt& APoint,
const Standard_Real Tolerance,
const Standard_Integer NumIteration,
- const Adaptor3d_Curve& Curve,
+ const Handle(Adaptor3d_Curve)& Curve,
Standard_Boolean& Status,
Standard_Real& Result)
{
do
{
num_iter++;
- Curve.D2(param, a_point, d1, d2);
+ Curve->D2(param, a_point, d1, d2);
vector = gp_Vec(a_point,APoint);
func = vector.Dot(d1);
if( Abs(func_derivative) > Toler )
param -= func / func_derivative;
- param = Max(param,Curve.FirstParameter());
- param = Min(param,Curve.LastParameter());
+ param = Max(param,Curve->FirstParameter());
+ param = Min(param,Curve->LastParameter());
}
} while (not_done && num_iter <= NumIteration);
//purpose :
//=======================================================================
static Standard_Real ComputeTolReached(const Handle(Adaptor3d_Curve)& c3d,
- const Adaptor3d_CurveOnSurface& cons,
+ const Handle(Adaptor3d_CurveOnSurface)& cons,
const Standard_Integer nbp)
{
Standard_Real d2 = 0.0; // Square max discrete deviation.
try
{
Pc3d = c3d->Value(u);
- Pcons = cons.Value(u);
+ Pcons = cons->Value(u);
}
catch (Standard_Failure const&)
{
const Standard_Integer nbp,
const Standard_Real *pc3d,
const Handle(Adaptor3d_Curve)& c3d,
- const Adaptor3d_CurveOnSurface& cons,
+ const Handle(Adaptor3d_CurveOnSurface)& cons,
Standard_Real& tol,
const Standard_Real oldtol)
{
Standard_Real aParamFirst = 3.0 * pc3d[0] - 2.0 * pc3d[nbp - 1];
Standard_Real aParamLast = 3.0 * pc3d[nbp - 1] - 2.0 * pc3d[0];
- Standard_Real FirstPar = cons.FirstParameter();
- Standard_Real LastPar = cons.LastParameter();
+ Standard_Real FirstPar = cons->FirstParameter();
+ Standard_Real LastPar = cons->LastParameter();
if (aParamFirst < FirstPar)
aParamFirst = FirstPar;
if (aParamLast > LastPar)
return Standard_False;
}
tprev = tcons;
- gp_Pnt Pcons = cons.Value(tcons);
+ gp_Pnt Pcons = cons->Value(tcons);
Standard_Real temp = Pc3d.SquareDistance(Pcons);
if(temp > d2) d2 = temp;
}
// Create and fill data structure.
Approx_SameParameter_Data aData;
- aData.myCOnS = Adaptor3d_CurveOnSurface(myHCurve2d,mySurf);
- aData.myC2dPF = aData.myCOnS.FirstParameter();
- aData.myC2dPL = aData.myCOnS.LastParameter();
+ aData.myCOnS = new Adaptor3d_CurveOnSurface(myHCurve2d,mySurf);
+ aData.myC2dPF = aData.myCOnS->FirstParameter();
+ aData.myC2dPL = aData.myCOnS->LastParameter();
aData.myC3dPF = myC3d->FirstParameter();
aData.myC3dPL = myC3d->LastParameter();
aData.myNbPnt = 0; // No points initially.
if(aData.myNbPnt < aNbPnt )
{
myTolReached = ComputeTolReached(myC3d,aData.myCOnS, 2 * myNbSamples);
- myCurve2d = Geom2dAdaptor::MakeCurve (*myHCurve2d);
+ myCurve2d = Geom2dAdaptor::MakeCurve (myHCurve2d);
myDone = Standard_False;
return;
}
if (anApproximator.IsDone() || anApproximator.HasResult())
{
- Adaptor3d_CurveOnSurface ACS = aData.myCOnS;
+ Handle(Adaptor3d_CurveOnSurface) ACS = Handle(Adaptor3d_CurveOnSurface)::DownCast(aData.myCOnS->ShallowCopy());
GeomLib_MakeCurvefromApprox aCurveBuilder(anApproximator);
Handle(Geom2d_BSplineCurve) aC2d = aCurveBuilder.Curve2dFromTwo1d(1,2);
Handle(Adaptor2d_Curve2d) aHCurve2d = new Geom2dAdaptor_Curve(aC2d);
- aData.myCOnS.Load(aHCurve2d);
+ aData.myCOnS->Load(aHCurve2d);
myTolReached = ComputeTolReached(myC3d,aData.myCOnS, 2 * myNbSamples);
const Standard_Real aMult = 250.0; // To be tolerant with discrete tolerance.
// using data from the last loop iteration or initial data. Use data set with minimal deflection.
// Original 2d curve.
- aData.myCOnS.Load(myHCurve2d);
+ aData.myCOnS->Load(myHCurve2d);
myTolReached = ComputeTolReached(myC3d,aData.myCOnS, 2 * myNbSamples);
- myCurve2d = Geom2dAdaptor::MakeCurve (*myHCurve2d);
+ myCurve2d = Geom2dAdaptor::MakeCurve (myHCurve2d);
// Approximation curve.
Standard_Integer num_knots = aData.myNbPnt + 7;
GeomLib_MakeCurvefromApprox aCurveBuilder(anApproximator);
Handle(Geom2d_BSplineCurve) aC2d = aCurveBuilder.Curve2dFromTwo1d(1,2);
Handle(Adaptor2d_Curve2d) aHCurve2d = new Geom2dAdaptor_Curve(aC2d);
- aData.myCOnS.Load(aHCurve2d);
+ aData.myCOnS->Load(aHCurve2d);
Standard_Real anApproxTol = ComputeTolReached(myC3d,aData.myCOnS,2 * myNbSamples);
if (anApproxTol < myTolReached)
myDone = Standard_True;
}
- myCurveOnSurface = Handle(Adaptor3d_CurveOnSurface)::DownCast(aData.myCOnS.ShallowCopy());
+ myCurveOnSurface = Handle(Adaptor3d_CurveOnSurface)::DownCast(aData.myCOnS->ShallowCopy());
}
//=======================================================================
// Compute initial distance on boundary points.
gp_Pnt Pcons, Pc3d;
- theData.myCOnS.D0(theData.myC2dPF, Pcons);
+ theData.myCOnS->D0(theData.myC2dPF, Pcons);
myC3d->D0(theData.myC3dPF, Pc3d);
Standard_Real dist2 = Pcons.SquareDistance(Pc3d);
Standard_Real dmax2 = dist2;
- theData.myCOnS.D0(theData.myC2dPL, Pcons);
+ theData.myCOnS->D0(theData.myC2dPL, Pcons);
myC3d->D0(theData.myC3dPL, Pc3d);
dist2 = Pcons.SquareDistance(Pc3d);
dmax2 = Max(dmax2, dist2);
Extrema_LocateExtPC Projector;
- Projector.Initialize (*myC3d, theData.myC3dPF, theData.myC3dPL, theData.myTol);
+ Projector.Initialize (myC3d, theData.myC3dPF, theData.myC3dPL, theData.myTol);
Standard_Integer count = 1;
Standard_Real previousp = theData.myC3dPF, initp=0, curp;
Standard_Boolean isProjOk = Standard_False;
for (Standard_Integer ii = 1; ii < theData.myNbPnt; ii++)
{
- theData.myCOnS.D0(theData.myPC2d[ii],Pcons);
+ theData.myCOnS->D0(theData.myPC2d[ii],Pcons);
myC3d->D0(theData.myPC3d[ii],Pc3d);
dist2 = Pcons.SquareDistance(Pc3d);
}
else
{
- ProjectPointOnCurve(initp,Pcons,theData.myTol,30, *myC3d,isProjOk,curp);
+ ProjectPointOnCurve(initp,Pcons,theData.myTol,30, myC3d,isProjOk,curp);
}
isProjOk = isProjOk && // Good projection.
curp > previousp + myDeltaMin && // Point is separated from previous.
}
// Whole parameter space search using general extrema.
- Extrema_ExtPC PR(Pcons, *myC3d, theData.myC3dPF, theData.myC3dPL, theData.myTol);
+ Extrema_ExtPC PR(Pcons, myC3d, theData.myC3dPF, theData.myC3dPL, theData.myTol);
if (!PR.IsDone() || PR.NbExt() == 0) // Lazy evaluation is used.
continue;
//function : ComputeTangents
//purpose : Sub-method in Build.
//=======================================================================
-Standard_Boolean Approx_SameParameter::ComputeTangents(const Adaptor3d_CurveOnSurface & theCOnS,
+Standard_Boolean Approx_SameParameter::ComputeTangents(const Handle(Adaptor3d_CurveOnSurface) & theCOnS,
Standard_Real &theFirstTangent,
Standard_Real &theLastTangent) const
{
// First point.
const Standard_Real aParamFirst = myC3d->FirstParameter();
- theCOnS.D1(aParamFirst, aPntCOnS, aVecConS);
+ theCOnS->D1(aParamFirst, aPntCOnS, aVecConS);
myC3d->D1(aParamFirst, aPnt, aVec);
Standard_Real aMagnitude = aVecConS.Magnitude();
if (aMagnitude > aSmallMagnitude)
// Last point.
const Standard_Real aParamLast = myC3d->LastParameter();
- theCOnS.D1(aParamLast,aPntCOnS,aVecConS);
+ theCOnS->D1(aParamLast,aPntCOnS,aVecConS);
myC3d->D1(aParamLast, aPnt, aVec);
aMagnitude = aVecConS.Magnitude();
Standard_Real &theBestSqTol) const
{
Extrema_LocateExtPC Projector;
- Projector.Initialize (*myC3d, myC3d->FirstParameter(), myC3d->LastParameter(), theData.myTol);
+ Projector.Initialize (myC3d, myC3d->FirstParameter(), myC3d->LastParameter(), theData.myTol);
Standard_Real curp = 0.0;
Standard_Boolean projok = Standard_False;
Standard_Real uc3d = 0.5*(theData.myPC3d[ii]+theData.myPC3d[ii+1]);
gp_Pnt Pcons;
- theData.myCOnS.D0(ucons,Pcons);
+ theData.myCOnS->D0(ucons,Pcons);
Projector.Perform(Pcons, uc3d);
if (Projector.IsDone())
{
}
else
{
- ProjectPointOnCurve(uc3d,Pcons,theData.myTol,30, *myC3d,projok,curp);
+ ProjectPointOnCurve(uc3d,Pcons,theData.myTol,30, myC3d,projok,curp);
}
if(projok)
{
Standard_Real uc3d = 0.5*(theData.myPC3d[n]+theData.myPC3d[n+1]);
gp_Pnt Pcons;
- theData.myCOnS.D0(ucons,Pcons);
+ theData.myCOnS->D0(ucons,Pcons);
Projector.Perform(Pcons, uc3d);
if (Projector.IsDone())
{
}
else
{
- ProjectPointOnCurve(uc3d,Pcons,theData.myTol,30, *myC3d,projok,curp);
+ ProjectPointOnCurve(uc3d,Pcons,theData.myTol,30, myC3d,projok,curp);
}
if(projok)
{
//! a lot of memory is used in intermediate computations.
struct Approx_SameParameter_Data
{
- Adaptor3d_CurveOnSurface myCOnS; // Curve on surface.
+ Handle(Adaptor3d_CurveOnSurface) myCOnS; // Curve on surface.
Standard_Integer myNbPnt; // Number of points.
Standard_Real *myPC3d; // Parameters on 3d curve.
Standard_Real *myPC2d; // Parameters on 2d curve.
//! Computes tangents on boundary points.
//@return true if tangents are not null and false otherwise.
- Standard_Boolean ComputeTangents(const Adaptor3d_CurveOnSurface & theCOnS,
+ Standard_Boolean ComputeTangents(const Handle(Adaptor3d_CurveOnSurface) & theCOnS,
Standard_Real &theFirstTangent,
Standard_Real &theLastTangent) const;
{
// At this stage, context should contain adaptor for all intersected faces,
// so getting a type of the underlying surface should be done at no cost.
- if (myContext->SurfaceAdaptor(TopoDS::Face(aF)).GetType() == GeomAbs_Plane)
+ if (myContext->SurfaceAdaptor(TopoDS::Face(aF))->GetType() == GeomAbs_Plane)
{
// Check bounding box of the face - it should not be open in any side
const Bnd_Box& aBox = aSI.Box();
}
else {
// build bounding box
- BRepAdaptor_Curve aBAC(theE);
+ Handle(BRepAdaptor_Curve) aBAC = new BRepAdaptor_Curve(theE);
Standard_Real aTol = BRep_Tool::Tolerance(theE) + Precision::Confusion();
BndLib_Add3dCurve::Add(aBAC, theSFirst, theSLast, aTol, theBox);
thePBBox.Bind(thePB, theBox);
//
Standard_Boolean bLinePlane = Standard_False;
if (aNbCPrts) {
- BRepAdaptor_Curve aBAC(aE);
- bLinePlane = (aBAC.GetType() == GeomAbs_Line &&
- myContext->SurfaceAdaptor(aF).GetType() == GeomAbs_Plane);
+ Handle(BRepAdaptor_Curve) aBAC = new BRepAdaptor_Curve(aE);
+ bLinePlane = (aBAC->GetType() == GeomAbs_Line &&
+ myContext->SurfaceAdaptor(aF)->GetType() == GeomAbs_Plane);
}
//
for (i=1; i<=aNbCPrts; ++i) {
// Projection tool
GeomAPI_ProjectPointOnSurf& aProjPS = myContext->ProjPS(aF);
- BRepAdaptor_Surface& aSurfAdaptor = myContext->SurfaceAdaptor (aF);
+ const Handle(BRepAdaptor_Surface)& aSurfAdaptor = myContext->SurfaceAdaptor (aF);
// Iterate on pave blocks and combine pairs containing
// the same vertices
if (!myContext->IsPointInFace(aF, gp_Pnt2d(U, V)))
continue;
- if (aSurfAdaptor.GetType() != GeomAbs_Plane ||
+ if (aSurfAdaptor->GetType() != GeomAbs_Plane ||
aBAC.GetType() != GeomAbs_Line)
{
gp_Pnt aPOnS = aProjPS.NearestPoint();
#include <TopTools_ListOfShape.hxx>
//
-static Standard_Real ToleranceFF(const BRepAdaptor_Surface& aBAS1,
- const BRepAdaptor_Surface& aBAS2);
+static Standard_Real ToleranceFF(const Handle(BRepAdaptor_Surface)& aBAS1,
+ const Handle(BRepAdaptor_Surface)& aBAS2);
/////////////////////////////////////////////////////////////////////////
//=======================================================================
const TopoDS_Face& aF1 = (*(TopoDS_Face *)(&myDS->Shape(nF1)));
const TopoDS_Face& aF2 = (*(TopoDS_Face *)(&myDS->Shape(nF2)));
//
- const BRepAdaptor_Surface& aBAS1 = myContext->SurfaceAdaptor(aF1);
- const BRepAdaptor_Surface& aBAS2 = myContext->SurfaceAdaptor(aF2);
- if (aBAS1.GetType() == GeomAbs_Plane &&
- aBAS2.GetType() == GeomAbs_Plane) {
+ const Handle(BRepAdaptor_Surface)& aBAS1 = myContext->SurfaceAdaptor(aF1);
+ const Handle(BRepAdaptor_Surface)& aBAS2 = myContext->SurfaceAdaptor(aF2);
+ if (aBAS1->GetType() == GeomAbs_Plane &&
+ aBAS2->GetType() == GeomAbs_Plane) {
// Check if the planes are really interfering
Standard_Boolean bToIntersect = CheckPlanes(nF1, nF2);
if (!bToIntersect) {
// Keep shift value to use it as the tolerance for intersection curves
Standard_Real aShiftValue = 0.;
- if (aBAS1.GetType() != GeomAbs_Plane ||
- aBAS2.GetType() != GeomAbs_Plane) {
+ if (aBAS1->GetType() != GeomAbs_Plane ||
+ aBAS2->GetType() != GeomAbs_Plane) {
Standard_Boolean isFound = Standard_False;
for (TopExp_Explorer aExp1(aF1, TopAbs_EDGE); !isFound && aExp1.More(); aExp1.Next())
//
// check if the pave block has a valid range
Standard_Real aFirst, aLast;
- if (!BRepLib::FindValidRange(GeomAdaptor_Curve(aIC.Curve()), aTolR3D,
+ if (!BRepLib::FindValidRange(new GeomAdaptor_Curve(aIC.Curve()), aTolR3D,
aT1, BRep_Tool::Pnt(aV1), Max (aTolR3D, BRep_Tool::Tolerance(aV1)),
aT2, BRep_Tool::Pnt(aV2), Max (aTolR3D, BRep_Tool::Tolerance(aV2)),
aFirst, aLast))
// Check if there will be valid range on the curve
Standard_Real aFirst, aLast;
Standard_Real aNewTolV = Max(aTolV, aDistVP + BOPTools_AlgoTools::DTolerance());
- if (!BRepLib::FindValidRange(GeomAdaptor_Curve(aIC.Curve()), aIC.Tolerance(),
+ if (!BRepLib::FindValidRange(new GeomAdaptor_Curve(aIC.Curve()), aIC.Tolerance(),
aT[0], aP[0], aNewTolV,
aT[1], aP[1], aNewTolV,
aFirst, aLast))
//purpose : Computes the TolFF according to the tolerance value and
// types of the faces.
//=======================================================================
-Standard_Real ToleranceFF(const BRepAdaptor_Surface& aBAS1,
- const BRepAdaptor_Surface& aBAS2)
+Standard_Real ToleranceFF(const Handle(BRepAdaptor_Surface)& aBAS1,
+ const Handle(BRepAdaptor_Surface)& aBAS2)
{
- Standard_Real aTol1 = aBAS1.Tolerance();
- Standard_Real aTol2 = aBAS2.Tolerance();
+ Standard_Real aTol1 = aBAS1->Tolerance();
+ Standard_Real aTol2 = aBAS2->Tolerance();
Standard_Real aTolFF = Max(aTol1, aTol2);
//
Standard_Boolean isAna1, isAna2;
- isAna1 = (aBAS1.GetType() == GeomAbs_Plane ||
- aBAS1.GetType() == GeomAbs_Cylinder ||
- aBAS1.GetType() == GeomAbs_Cone ||
- aBAS1.GetType() == GeomAbs_Sphere ||
- aBAS1.GetType() == GeomAbs_Torus);
- //
- isAna2 = (aBAS2.GetType() == GeomAbs_Plane ||
- aBAS2.GetType() == GeomAbs_Cylinder ||
- aBAS2.GetType() == GeomAbs_Cone ||
- aBAS2.GetType() == GeomAbs_Sphere ||
- aBAS2.GetType() == GeomAbs_Torus);
+ isAna1 = (aBAS1->GetType() == GeomAbs_Plane ||
+ aBAS1->GetType() == GeomAbs_Cylinder ||
+ aBAS1->GetType() == GeomAbs_Cone ||
+ aBAS1->GetType() == GeomAbs_Sphere ||
+ aBAS1->GetType() == GeomAbs_Torus);
+ //
+ isAna2 = (aBAS2->GetType() == GeomAbs_Plane ||
+ aBAS2->GetType() == GeomAbs_Cylinder ||
+ aBAS2->GetType() == GeomAbs_Cone ||
+ aBAS2->GetType() == GeomAbs_Sphere ||
+ aBAS2->GetType() == GeomAbs_Torus);
//
if (!isAna1 || !isAna2) {
aTolFF = Max(aTolFF, 5.e-6);
}
else
{
- const BRepAdaptor_Surface& aBAS = myContext->SurfaceAdaptor(myF);
- if (aBAS.IsUPeriodic() || aBAS.IsVPeriodic())
+ const Handle(BRepAdaptor_Surface)& aBAS = myContext->SurfaceAdaptor(myF);
+ if (aBAS->IsUPeriodic() || aBAS->IsVPeriodic())
{
// The curve already exists. Adjust it for periodic cases.
BOPTools_AlgoTools2D::AdjustPCurveOnSurf
const TopoDS_Face& aDF = (*(TopoDS_Face *)(&myDS->Shape(nFD)));
//
Standard_Real aTolV = BRep_Tool::Tolerance(aDV);
- const BRepAdaptor_Surface& aBAS = myContext->SurfaceAdaptor(aDF);
+ const Handle(BRepAdaptor_Surface)& aBAS = myContext->SurfaceAdaptor(aDF);
//
// 2D intersection tolerance should be computed as a resolution
// from the tolerance of vertex to resolve the touching cases
Standard_Real aTolInt = Precision::PConfusion();
// UResolution from the tolerance of the vertex
- Standard_Real aURes = aBAS.UResolution(aTolV);
+ Standard_Real aURes = aBAS->UResolution(aTolV);
// VResolution from the tolerance of the vertex
- Standard_Real aVRes = aBAS.VResolution(aTolV);
+ Standard_Real aVRes = aBAS->VResolution(aTolV);
//
aTolInt = Max(aTolInt, Max(aURes, aVRes));
//
aTolCmp = Max(aTolCmp, (bUDir ? aURes : aVRes));
//
// Prepare adaptor for the degenerated edge for intersection
- Geom2dAdaptor_Curve aGAC1;
- aGAC1.Load(aC2DDE, aTD1, aTD2);
+ Handle(Geom2dAdaptor_Curve) aGAC1 = new Geom2dAdaptor_Curve(aC2DDE, aTD1, aTD2);
//
BOPDS_ListIteratorOfListOfPaveBlock aItLPB(aLPBOut);
for (; aItLPB.More(); aItLPB.Next()) {
}
//
// Prepare adaptor for the passing edge for intersection
- Geom2dAdaptor_Curve aGAC2;
+ Handle(Geom2dAdaptor_Curve) aGAC2 = new Geom2dAdaptor_Curve();
//
Handle(Geom2d_Line) aL2D = Handle(Geom2d_Line)::DownCast(aC2D);
if (!aL2D.IsNull()) {
- aGAC2.Load(aC2D);
+ aGAC2->Load(aC2D);
}
else {
- aGAC2.Load(aC2D, aT1, aT2);
+ aGAC2->Load(aC2D, aT1, aT2);
}
// Intersection
Geom2dInt_GInter aGInter(aGAC1, aGAC2, aTolInt, aTolInt);
TopTools_MapOfShape& theMEdgesNoUniquePlane);
static
- Standard_Boolean FindPlane(const BRepAdaptor_Curve& theCurve,
+ Standard_Boolean FindPlane(const Handle(BRepAdaptor_Curve)& theCurve,
gp_Pln& thePlane);
static
gp_Dir& theTgt);
static
- Standard_Boolean FindEdgeTangent(const BRepAdaptor_Curve& theCurve,
+ Standard_Boolean FindEdgeTangent(const Handle(BRepAdaptor_Curve)& theCurve,
gp_Vec& theTangent);
//=======================================================================
aExp.Init(aSEdges, TopAbs_EDGE);
for (; aExp.More(); aExp.Next()) {
const TopoDS_Edge& aE = TopoDS::Edge(aExp.Current());
- BRepAdaptor_Curve aBAC(aE);
+ Handle(BRepAdaptor_Curve) aBAC = new BRepAdaptor_Curve(aE);
//
gp_Pln aPln;
if (FindPlane(aBAC, aPln)) {
gp_Dir *pDTE = theDMEdgeTgt.ChangeSeek(theEdge);
if (!pDTE) {
gp_Vec aVTE;
- BRepAdaptor_Curve aBAC(theEdge);
+ Handle(BRepAdaptor_Curve) aBAC = new BRepAdaptor_Curve(theEdge);
if (!FindEdgeTangent(aBAC, aVTE)) {
return Standard_False;
}
//function : FindEdgeTangent
//purpose : Finds the tangent for the edge
//=======================================================================
-Standard_Boolean FindEdgeTangent(const BRepAdaptor_Curve& theCurve,
+Standard_Boolean FindEdgeTangent(const Handle(BRepAdaptor_Curve)& theCurve,
gp_Vec& theTangent)
{
- if (!theCurve.Is3DCurve()) {
+ if (!theCurve->Is3DCurve()) {
return Standard_False;
}
// for the line the tangent is defined by the direction
- if (theCurve.GetType() == GeomAbs_Line) {
- theTangent = theCurve.Line().Position().Direction();
+ if (theCurve->GetType() == GeomAbs_Line) {
+ theTangent = theCurve->Line().Position().Direction();
return Standard_True;
}
//
// for other curves take D1 and check for its length
- Standard_Real aT, aT1(theCurve.FirstParameter()), aT2(theCurve.LastParameter());
+ Standard_Real aT, aT1(theCurve->FirstParameter()), aT2(theCurve->LastParameter());
const Standard_Integer aNbP = 11;
const Standard_Real aDt = (aT2 - aT1) / aNbP;
//
for (aT = aT1 + aDt; aT <= aT2; aT += aDt) {
gp_Pnt aP;
- theCurve.D1(aT, aP, theTangent);
+ theCurve->D1(aT, aP, theTangent);
if (theTangent.Magnitude() > Precision::Confusion()) {
return Standard_True;
}
//function : FindPlane
//purpose : Finds the plane in which the edge is located
//=======================================================================
-Standard_Boolean FindPlane(const BRepAdaptor_Curve& theCurve,
+Standard_Boolean FindPlane(const Handle(BRepAdaptor_Curve)& theCurve,
gp_Pln& thePlane)
{
- if (!theCurve.Is3DCurve()) {
+ if (!theCurve->Is3DCurve()) {
return Standard_False;
}
//
Standard_Boolean bFound = Standard_True;
gp_Vec aVN;
- switch (theCurve.GetType()) {
+ switch (theCurve->GetType()) {
case GeomAbs_Line:
return Standard_False;
case GeomAbs_Circle:
- aVN = theCurve.Circle().Position().Direction();
+ aVN = theCurve->Circle().Position().Direction();
break;
case GeomAbs_Ellipse:
- aVN = theCurve.Ellipse().Position().Direction();
+ aVN = theCurve->Ellipse().Position().Direction();
break;
case GeomAbs_Hyperbola:
- aVN = theCurve.Hyperbola().Position().Direction();
+ aVN = theCurve->Hyperbola().Position().Direction();
break;
case GeomAbs_Parabola:
- aVN = theCurve.Parabola().Position().Direction();
+ aVN = theCurve->Parabola().Position().Direction();
break;
default: {
// for all other types of curve compute two tangent vectors
// on the curve and cross them
bFound = Standard_False;
- Standard_Real aT, aT1(theCurve.FirstParameter()), aT2(theCurve.LastParameter());
+ Standard_Real aT, aT1(theCurve->FirstParameter()), aT2(theCurve->LastParameter());
const Standard_Integer aNbP = 11;
const Standard_Real aDt = (aT2 - aT1) / aNbP;
//
aT = aT1;
gp_Pnt aP1;
gp_Vec aV1;
- theCurve.D1(aT, aP1, aV1);
+ theCurve->D1(aT, aP1, aV1);
//
for (aT = aT1 + aDt; aT <= aT2; aT += aDt) {
gp_Pnt aP2;
gp_Vec aV2;
- theCurve.D1(aT, aP2, aV2);
+ theCurve->D1(aT, aP2, aV2);
//
aVN = aV1^aV2;
if (aVN.Magnitude() > Precision::Confusion()) {
}
//
if (bFound) {
- thePlane = gp_Pln(theCurve.Value(theCurve.FirstParameter()), gp_Dir(aVN));
+ thePlane = gp_Pln(theCurve->Value(theCurve->FirstParameter()), gp_Dir(aVN));
}
return bFound;
}
if (theMEdgesNoUniquePlane.Contains(aE)) {
continue;
}
- BRepAdaptor_Curve aBAC(aE);
+ Handle(BRepAdaptor_Curve) aBAC = new BRepAdaptor_Curve(aE);
if (FindPlane(aBAC, thePlane)) {
return Standard_True;
}
Standard_Real Angle2D (const TopoDS_Vertex& aV,
const TopoDS_Edge& anEdge,
const TopoDS_Face& myFace,
- const GeomAdaptor_Surface& aGAS,
+ const Handle(GeomAdaptor_Surface)& aGAS,
const Standard_Boolean aFlag,
const Handle(IntTools_Context)& theContext);
const Standard_Real aAngleOut);
static
- void Path (const GeomAdaptor_Surface& aGAS,
+ void Path (const Handle(GeomAdaptor_Surface)& aGAS,
const TopoDS_Face& myFace,
const MyDataMapOfShapeBoolean& aVertMap,
const TopoDS_Vertex& aVa,
static
Standard_Real Tolerance2D (const TopoDS_Vertex& aV,
- const GeomAdaptor_Surface& aGAS);
+ const Handle(GeomAdaptor_Surface)& aGAS);
static
Standard_Real UTolerance2D (const TopoDS_Vertex& aV,
- const GeomAdaptor_Surface& aGAS);
+ const Handle(GeomAdaptor_Surface)& aGAS);
static
Standard_Real VTolerance2D (const TopoDS_Vertex& aV,
- const GeomAdaptor_Surface& aGAS);
+ const Handle(GeomAdaptor_Surface)& aGAS);
static
void RefineAngles(const TopoDS_Face& myFace,
}
//
// 3. Angles in mySmartMap
- const BRepAdaptor_Surface& aBAS = theContext->SurfaceAdaptor(myFace);
- const GeomAdaptor_Surface& aGAS=aBAS.Surface();
+ const Handle(BRepAdaptor_Surface)& aBAS = theContext->SurfaceAdaptor(myFace);
+ const Handle(GeomAdaptor_Surface)& aGAS = aBAS->Surface();
//
for (i=1; i<=aNb; i++) {
const TopoDS_Vertex& aV = (*(TopoDS_Vertex *)(&mySmartMap.FindKey(i)));
// function: Path
// purpose:
//=======================================================================
-void Path (const GeomAdaptor_Surface& aGAS,
+void Path (const Handle(GeomAdaptor_Surface)& aGAS,
const TopoDS_Face& myFace,
const MyDataMapOfShapeBoolean& aVertMap,
const TopoDS_Vertex& aVFirst,
Standard_Real Angle2D (const TopoDS_Vertex& aV,
const TopoDS_Edge& anEdge,
const TopoDS_Face& myFace,
- const GeomAdaptor_Surface& aGAS,
+ const Handle(GeomAdaptor_Surface)& aGAS,
const Standard_Boolean bIsIN,
const Handle(IntTools_Context)& theContext)
{
// purpose:
//=======================================================================
Standard_Real Tolerance2D (const TopoDS_Vertex& aV,
- const GeomAdaptor_Surface& aGAS)
+ const Handle(GeomAdaptor_Surface)& aGAS)
{
Standard_Real aTol2D, anUr, aVr, aTolV3D;
GeomAbs_SurfaceType aType;
//
- aType=aGAS.GetType();
+ aType=aGAS->GetType();
aTolV3D=BRep_Tool::Tolerance(aV);
- anUr=aGAS.UResolution(aTolV3D);
- aVr =aGAS.VResolution(aTolV3D);
+ anUr=aGAS->UResolution(aTolV3D);
+ aVr =aGAS->VResolution(aTolV3D);
aTol2D=(aVr>anUr) ? aVr : anUr;
//
if (aTol2D < aTolV3D) {
//purpose :
//=======================================================================
Standard_Real UTolerance2D (const TopoDS_Vertex& aV,
- const GeomAdaptor_Surface& aGAS)
+ const Handle(GeomAdaptor_Surface)& aGAS)
{
const Standard_Real aTolV3D = BRep_Tool::Tolerance(aV);
- const Standard_Real anUr = aGAS.UResolution(aTolV3D);
+ const Standard_Real anUr = aGAS->UResolution(aTolV3D);
//
return anUr;
}
//purpose :
//=======================================================================
Standard_Real VTolerance2D (const TopoDS_Vertex& aV,
- const GeomAdaptor_Surface& aGAS)
+ const Handle(GeomAdaptor_Surface)& aGAS)
{
const Standard_Real aTolV3D = BRep_Tool::Tolerance(aV);
- const Standard_Real anVr = aGAS.VResolution(aTolV3D);
+ const Standard_Real anVr = aGAS->VResolution(aTolV3D);
//
return anVr;
}
gp_Pnt2d aPV, aP, aP1, aP2;
Handle(Geom2d_Curve) aC2D;
Handle(Geom2d_Line) aLi;
- Geom2dAdaptor_Curve aGAC1, aGAC2;
+ Handle(Geom2dAdaptor_Curve) aGAC1 = new Geom2dAdaptor_Curve();
+ Handle(Geom2dAdaptor_Curve) aGAC2 = new Geom2dAdaptor_Curve();
Geom2dInt_GInter aGInter;
IntRes2d_Domain aDomain1, aDomain2;
//
aTolInt=1.e-10;
//
BOPTools_AlgoTools2D::CurveOnSurface(aE, myFace, aC2D, aT1, aT2, aTol, theContext);
- aGAC1.Load(aC2D, aT1, aT2);
+ aGAC1->Load(aC2D, aT1, aT2);
//
aTV=BRep_Tool::Parameter (aV, aE, myFace);
- aGAC1.D0(aTV, aPV);
+ aGAC1->D0(aTV, aPV);
//
aTOp = (fabs(aTV-aT1) < fabs(aTV-aT2)) ? aT2 : aT1;
//
const Standard_Real MaxDT = 0.3 * (aT2 - aT1);
- aGAC1.D0(aT1, aP1);
- aGAC1.D0(aT2, aP2);
+ aGAC1->D0(aT1, aP1);
+ aGAC1->D0(aT2, aP2);
aDomain1.SetValues(aP1, aT1, aTolInt, aP2, aT2, aTolInt);
//
for (i=0; i<2; ++i) {
gp_Dir2d aDiri(aXi, aYi);
aLi=new Geom2d_Line(aPV, aDiri);
//
- aGAC2.Load(aLi);
+ aGAC2->Load(aLi);
//
aGInter.Perform(aGAC1, aDomain1, aGAC2, aDomain2, aTolInt, aTolInt);
if (!aGInter.IsDone()) {
}
//
aT = aT1max + aCf*dT;
- aGAC1.D0(aT, aP);
+ aGAC1->D0(aT, aP);
gp_Vec2d aV2D(aPV, aP);
gp_Dir2d aDir2D(aV2D);
//
break; //xx
}
//
- BRepAdaptor_Curve2d aBAC2D(aE, aFF);
+ Handle(BRepAdaptor_Curve2d) aBAC2D = new BRepAdaptor_Curve2d(aE, aFF);
aNbS=Geom2dInt_Geom2dCurveTool::NbSamples(aBAC2D);
if (aNbS>2) {
aNbS*=4;
dU=-dU;
}
//
- aBAC2D.D0(aU, aP2D0);
+ aBAC2D->D0(aU, aP2D0);
for(i=2; i<=aNbS; i++) {
aU=aU1+(i-1)*dU;
- aBAC2D.D0(aU, aP2D1);
+ aBAC2D->D0(aU, aP2D1);
aP2D0.Coord(aX0, aY0);
aP2D1.Coord(aX1, aY1);
//
}
//
// try to compute the minimal 3D step
- const BRepAdaptor_Surface& aBAS = theContext->SurfaceAdaptor(aF);
+ const Handle(BRepAdaptor_Surface)& aBAS = theContext->SurfaceAdaptor(aF);
Standard_Real aR = 0.;
- GeomAbs_SurfaceType aSType = aBAS.GetType();
+ GeomAbs_SurfaceType aSType = aBAS->GetType();
switch (aSType) {
case GeomAbs_Cylinder: {
- aR = aBAS.Cylinder().Radius();
+ aR = aBAS->Cylinder().Radius();
break;
}
case GeomAbs_Cone: {
- gp_Lin aL(aBAS.Cone().Axis());
+ gp_Lin aL(aBAS->Cone().Axis());
aR = aL.Distance(aP);
break;
}
case GeomAbs_Sphere: {
aDtMin = Max(aDtMin, 5.e-4);
- aR = aBAS.Sphere().Radius();
+ aR = aBAS->Sphere().Radius();
break;
}
case GeomAbs_Torus: {
- aR = aBAS.Torus().MajorRadius();
+ aR = aBAS->Torus().MajorRadius();
break;
}
default:
const BOPTools_CoupleOfShape& aCS = aIt.Value();
const TopoDS_Face& aF = (*(TopoDS_Face*)(&aCS.Shape2()));
//
- const BRepAdaptor_Surface& aBAS = theContext->SurfaceAdaptor(aF);
+ const Handle(BRepAdaptor_Surface)& aBAS = theContext->SurfaceAdaptor(aF);
//
Standard_Real aUMin, aUMax, aVMin, aVMax;
theContext->UVBounds(aF, aUMin, aUMax, aVMin, aVMax);
//
Standard_Real aDU = aUMax - aUMin;
if (aDU > 0.) {
- Standard_Real aURes = aBAS.UResolution(aDtMax);
+ Standard_Real aURes = aBAS->UResolution(aDtMax);
if (2*aURes > aDU) {
break;
}
//
Standard_Real aDV = aVMax - aVMin;
if (aDV > 0.) {
- Standard_Real aVRes = aBAS.VResolution(aDtMax);
+ Standard_Real aVRes = aBAS->VResolution(aDtMax);
if (2*aVRes > aDV) {
break;
}
Handle(Geom2d_Curve)& theC2DA,
const Handle(IntTools_Context)& theContext)
{
- BRepAdaptor_Surface aBASTmp;
- const BRepAdaptor_Surface* pBAS;
+ Handle(BRepAdaptor_Surface) aBASTmp = new BRepAdaptor_Surface();
+ Handle(BRepAdaptor_Surface) pBAS;
if (!theContext.IsNull()) {
- pBAS = &theContext->SurfaceAdaptor(theF);
+ pBAS = theContext->SurfaceAdaptor(theF);
}
else {
- aBASTmp.Initialize(theF, Standard_True);
- pBAS = &aBASTmp;
+ aBASTmp->Initialize(theF, Standard_True);
+ pBAS = aBASTmp;
}
//
- BOPTools_AlgoTools2D::AdjustPCurveOnSurf(*pBAS, theFirst, theLast, theC2D, theC2DA);
+ BOPTools_AlgoTools2D::AdjustPCurveOnSurf(pBAS, theFirst, theLast, theC2D, theC2DA);
}
//=======================================================================
//function : AdjustPCurveOnFace
//purpose :
//=======================================================================
void BOPTools_AlgoTools2D::AdjustPCurveOnSurf
- (const BRepAdaptor_Surface& aBAS,
+ (const Handle(BRepAdaptor_Surface)& aBAS,
const Standard_Real aFirst,
const Standard_Real aLast,
const Handle(Geom2d_Curve)& aC2D,
Standard_Real UMin, UMax, VMin, VMax, aT, u2, v2, du, dv, aDelta;
Standard_Real aUPeriod;
//
- const TopoDS_Face& aF=aBAS.Face();
- UMin=aBAS.FirstUParameter();
- UMax=aBAS.LastUParameter();
- VMin=aBAS.FirstVParameter();
- VMax=aBAS.LastVParameter();
+ const TopoDS_Face& aF=aBAS->Face();
+ UMin=aBAS->FirstUParameter();
+ UMax=aBAS->LastUParameter();
+ VMin=aBAS->FirstVParameter();
+ VMax=aBAS->LastVParameter();
//
aDelta=Precision::PConfusion();
//
// du
du = 0.;
- if (aBAS.IsUPeriodic()) {
- aUPeriod = aBAS.UPeriod();
+ if (aBAS->IsUPeriodic()) {
+ aUPeriod = aBAS->UPeriod();
//
// a. try to clarify u2 using the precision (aDelta)
GeomInt::AdjustPeriodic(u2, UMin, UMax, aUPeriod, u2, du, 0.);
//
if (du==0.) {
- if (aBAS.GetType()==GeomAbs_Cylinder) {
+ if (aBAS->GetType()==GeomAbs_Cylinder) {
Standard_Real aR, dFi, aTol;
//
- gp_Cylinder aCylinder=aBAS.Cylinder();
+ gp_Cylinder aCylinder=aBAS->Cylinder();
aR=aCylinder.Radius();
aTol=MaxToleranceEdge(aF);
dFi=aTol/aR;
// dv
dv = 0.;
- if (aBAS.IsVPeriodic()) {
+ if (aBAS->IsVPeriodic()) {
Standard_Real aVPeriod, aVm, aVr, aVmid, dVm, dVr;
//
- aVPeriod = aBAS.VPeriod();
+ aVPeriod = aBAS->VPeriod();
mincond = (VMin - v2 > aDelta);
maxcond = (v2 - VMax > aDelta);
//
Standard_Real u,v;
u = u2 + du;
v = v2 + dv;
- if (aBAS.IsUPeriodic()) {
- aUPeriod = aBAS.UPeriod();
+ if (aBAS->IsUPeriodic()) {
+ aUPeriod = aBAS->UPeriod();
if ((UMax - UMin - 2*aDelta) > aUPeriod) {
if ((u > (UMin + aDelta + aUPeriod)) ||
(u < (UMax - aDelta - aUPeriod))) {
}
//
u = u2 + du;
- if (aBAS.IsVPeriodic()) {
- Standard_Real aVPeriod = aBAS.VPeriod();
+ if (aBAS->IsVPeriodic()) {
+ Standard_Real aVPeriod = aBAS->VPeriod();
if ((VMax - VMin - 2*aDelta) > aVPeriod) {
if ((v > (VMin + aDelta + aVPeriod)) ||
(v < (VMax - aDelta - aVPeriod))) {
Standard_Real& TolReached2d,
const Handle(IntTools_Context)& theContext)
{
- BRepAdaptor_Surface aBASTmp;
- const BRepAdaptor_Surface* pBAS;
+ Handle(BRepAdaptor_Surface) aBASTmp = new BRepAdaptor_Surface();
+ Handle(BRepAdaptor_Surface) pBAS;
if (!theContext.IsNull()) {
- pBAS = &theContext->SurfaceAdaptor(aF);
+ pBAS = theContext->SurfaceAdaptor(aF);
}
else {
- aBASTmp.Initialize(aF, Standard_True);
- pBAS = &aBASTmp;
+ aBASTmp->Initialize(aF, Standard_True);
+ pBAS = aBASTmp;
}
//
Handle(BRepAdaptor_Surface) aBAHS = new BRepAdaptor_Surface(*pBAS);
// Adjust curve for periodic surface
Handle(Geom2d_Curve) aC2DA;
- BOPTools_AlgoTools2D::AdjustPCurveOnSurf (*pBAS, aT1, aT2, aC2D, aC2DA);
+ BOPTools_AlgoTools2D::AdjustPCurveOnSurf (pBAS, aT1, aT2, aC2D, aC2DA);
aC2D = aC2DA;
// Make sure that the range of the 2D curve is sufficient for representation of the 3D curve.
}
// compute the appropriate tolerance for the edge
- Handle(Geom_Surface) aS = pBAS->Surface().Surface();
+ Handle(Geom_Surface) aS = pBAS->Surface()->Surface();
aS = Handle(Geom_Surface)::DownCast(aS->Transformed(pBAS->Trsf()));
//
Standard_Real aT;
//! Adjust P-Curve <aC2D> (3D-curve <C3D>) on surface <aF> .
//! [aT1, aT2] - range to adjust
- Standard_EXPORT static void AdjustPCurveOnSurf(const BRepAdaptor_Surface& aF,
+ Standard_EXPORT static void AdjustPCurveOnSurf(const Handle(BRepAdaptor_Surface)& aF,
const Standard_Real aT1,
const Standard_Real aT2,
const Handle(Geom2d_Curve)& aC2D,
//
Geom2dHatch_Hatcher& aHatcher = theContext->Hatcher(theF);
//
- Geom2dAdaptor_Curve aHCur(theL2D);
+ Handle(Geom2dAdaptor_Curve) aHCur = new Geom2dAdaptor_Curve(theL2D);
//
aHatcher.ClrHatchings();
aIH = aHatcher.AddHatching(aHCur);
Standard_Real aLen = 0.;
if (!BRep_Tool::Degenerated(theEdge))
{
- BRepAdaptor_Curve aCurve(theEdge);
+ Handle(BRepAdaptor_Curve) aCurve = new BRepAdaptor_Curve(theEdge);
aLen = GCPnts_AbscissaPoint::Length(aCurve);
}
pLen = theMapEdgeLen.Bound(theEdge, aLen);
const TopoDS_Edge* Edge; // Edge
Standard_Real VParameter; // Parameter of the vertex on the edge
Standard_Boolean IsClosed; // Closed flag of the edge
- Geom2dAdaptor_Curve GAdaptor; // 2D adaptor for PCurve of the edge on the face
+ Handle(Geom2dAdaptor_Curve) GAdaptor; // 2D adaptor for PCurve of the edge on the face
Standard_Real First; // First parameter in the range
Standard_Real Last; // Last parameter in the rage
};
Standard_Real aMaxDist = 0.;
Standard_Real aTol2d = 1.e-10;
//
- IntRes2d_Domain aDom1(theEData1.GAdaptor.Value(aT11), aT11, aTol2d,
- theEData1.GAdaptor.Value(aT12), aT12, aTol2d);
- IntRes2d_Domain aDom2(theEData2.GAdaptor.Value(aT21), aT21, aTol2d,
- theEData2.GAdaptor.Value(aT22), aT22, aTol2d);
+ IntRes2d_Domain aDom1(theEData1.GAdaptor->Value(aT11), aT11, aTol2d,
+ theEData1.GAdaptor->Value(aT12), aT12, aTol2d);
+ IntRes2d_Domain aDom2(theEData2.GAdaptor->Value(aT21), aT21, aTol2d,
+ theEData2.GAdaptor->Value(aT22), aT22, aTol2d);
//
anInter.Perform(theEData1.GAdaptor, aDom1, theEData2.GAdaptor, aDom2, aTol2d, aTol2d);
if (!anInter.IsDone() || (!anInter.NbSegments() && !anInter.NbPoints())) {
if (aD2>aD2max) {
aD2max=aD2;
}
- EdgeData anEData = {&aE, aT, isClosed, Geom2dAdaptor_Curve(aC2D), aT1, aT2};
+ EdgeData anEData = {&aE, aT, isClosed, new Geom2dAdaptor_Curve(aC2D), aT1, aT2};
aLEPars.Append(anEData);
}
//
Handle(GeomAdaptor_Curve) aHCurve =
new GeomAdaptor_Curve(ProjOnPlane);
- ProjLib_ProjectedCurve proj(GAHS,aHCurve);
+ Handle(ProjLib_ProjectedCurve) proj = new ProjLib_ProjectedCurve(GAHS,aHCurve);
Handle(Geom2d_Curve) PC = Geom2dAdaptor::MakeCurve(proj);
Handle(Geom2dAdaptor_Curve) GHPC =
new Geom2dAdaptor_Curve(PC,
Handle(GeomAdaptor_Surface) HS = new GeomAdaptor_Surface(GP);
Handle(GeomAdaptor_Curve) HC = new GeomAdaptor_Curve(ProjOnPlane);
- ProjLib_ProjectedCurve Proj(HS, HC);
+ Handle(ProjLib_ProjectedCurve) Proj = new ProjLib_ProjectedCurve(HS, HC);
Handle(Geom2d_Curve) pc = Geom2dAdaptor::MakeCurve(Proj);
if (pc->DynamicType() == STANDARD_TYPE(Geom2d_TrimmedCurve)) {
#include <BRepAdaptor_Curve.hxx>
#include <NCollection_Array1.hxx>
-typedef NCollection_Array1<BRepAdaptor_Curve> BRepAdaptor_Array1OfCurve;
+typedef NCollection_Array1<Handle(BRepAdaptor_Curve)> BRepAdaptor_Array1OfCurve;
#endif
aCopy->myCurves = new (BRepAdaptor_HArray1OfCurve) (1, myCurves->Size());
for (Standard_Integer anI = 1; anI <= myCurves->Size(); ++anI)
{
- const Handle(Adaptor3d_Curve) aCurve = myCurves->Value(anI).ShallowCopy();
- const BRepAdaptor_Curve& aBrepCurve = *(Handle(BRepAdaptor_Curve)::DownCast(aCurve));
+ const Handle(Adaptor3d_Curve) aCurve = myCurves->Value(anI)->ShallowCopy();
+ const Handle(BRepAdaptor_Curve) aBrepCurve = Handle(BRepAdaptor_Curve)::DownCast(aCurve);
aCopy->myCurves->SetValue(anI, aBrepCurve);
}
aCopy->myKnots = myKnots;
E = wexp.Current();
if (! BRep_Tool::Degenerated(E)) {
ii++;
- myCurves->ChangeValue(ii).Initialize(E);
+ myCurves->ChangeValue(ii) = new BRepAdaptor_Curve(E);
if (AC) {
myKnots->SetValue(ii+1, myKnots->Value(ii));
myKnots->ChangeValue(ii+1) +=
Forward = Standard_True; // Default ; The Reverse Edges are parsed.
if((NbEdge > 2) || ((NbEdge==2) && (!myWire.Closed())) ) {
- TopAbs_Orientation Or = myCurves->Value(1).Edge().Orientation();
+ TopAbs_Orientation Or = myCurves->Value(1)->Edge().Orientation();
TopoDS_Vertex VI, VL;
- TopExp::CommonVertex(myCurves->Value(1).Edge(),
- myCurves->Value(2).Edge(),
+ TopExp::CommonVertex(myCurves->Value(1)->Edge(),
+ myCurves->Value(2)->Edge(),
VI);
- VL = TopExp::LastVertex(myCurves->Value(1).Edge());
+ VL = TopExp::LastVertex(myCurves->Value(1)->Edge());
if (VI.IsSame(VL)) { // The direction of parsing is always preserved
if (Or == TopAbs_REVERSED)
Forward = Standard_False;
CurIndex = (i1+i2)/2; // Small optimization
if (i1==i2) {
if (l > f)
- HC = Handle(BRepAdaptor_Curve)::DownCast(myCurves->Value(i1).Trim(f, l, PTol));
+ HC = Handle(BRepAdaptor_Curve)::DownCast(myCurves->Value(i1)->Trim(f, l, PTol));
else
- HC = Handle(BRepAdaptor_Curve)::DownCast(myCurves->Value(i1).Trim(l, f, PTol));
- myCurves->SetValue(i1, *HC);
+ HC = Handle(BRepAdaptor_Curve)::DownCast(myCurves->Value(i1)->Trim(l, f, PTol));
+ myCurves->SetValue(i1, HC);
}
else {
- const BRepAdaptor_Curve& c1 = myCurves->Value(i1);
- const BRepAdaptor_Curve& c2 = myCurves->Value(i2);
+ const Handle(BRepAdaptor_Curve)& c1 = myCurves->Value(i1);
+ const Handle(BRepAdaptor_Curve)& c2 = myCurves->Value(i2);
Standard_Real k;
- k = c1.LastParameter();
+ k = c1->LastParameter();
if (k>f)
- HC = Handle(BRepAdaptor_Curve)::DownCast(c1.Trim(f, k, PTol));
+ HC = Handle(BRepAdaptor_Curve)::DownCast(c1->Trim(f, k, PTol));
else
- HC = Handle(BRepAdaptor_Curve)::DownCast(c1.Trim(k, f, PTol));
- myCurves->SetValue(i1, *HC);
+ HC = Handle(BRepAdaptor_Curve)::DownCast(c1->Trim(k, f, PTol));
+ myCurves->SetValue(i1, HC);
- k = c2.FirstParameter();
+ k = c2->FirstParameter();
if (k<=l)
- HC = Handle(BRepAdaptor_Curve)::DownCast(c2.Trim(k, l, PTol));
+ HC = Handle(BRepAdaptor_Curve)::DownCast(c2->Trim(k, l, PTol));
else
- HC = Handle(BRepAdaptor_Curve)::DownCast(c2.Trim(l, k, PTol));
- myCurves->SetValue(i2, *HC);
+ HC = Handle(BRepAdaptor_Curve)::DownCast(c2->Trim(l, k, PTol));
+ myCurves->SetValue(i2, HC);
}
}
Standard_Integer index = CurIndex;
UonE = U;
Prepare(UonE, d, index);
- E = myCurves->Value(index).Edge();
+ E = myCurves->Value(index)->Edge();
}
Standard_Real BRepAdaptor_CompCurve::FirstParameter() const
GeomAbs_Shape BRepAdaptor_CompCurve::Continuity() const
{
if ( myCurves->Length() > 1) return GeomAbs_C0;
- return myCurves->Value(1).Continuity();
+ return myCurves->Value(1)->Continuity();
}
Standard_Integer BRepAdaptor_CompCurve::NbIntervals(const GeomAbs_Shape S) const
{
Standard_Integer NbInt, ii;
for (ii=1, NbInt=0; ii<=myCurves->Length(); ii++)
- NbInt += myCurves->ChangeValue(ii).NbIntervals(S);
+ NbInt += myCurves->ChangeValue(ii)->NbIntervals(S);
return NbInt;
}
Standard_Real f, F, delta;
// First curve (direction of parsing of the edge)
- n = myCurves->ChangeValue(1).NbIntervals(S);
+ n = myCurves->ChangeValue(1)->NbIntervals(S);
Handle(TColStd_HArray1OfReal) Ti = new (TColStd_HArray1OfReal) (1, n+1);
- myCurves->ChangeValue(1).Intervals(Ti->ChangeArray1(), S);
+ myCurves->ChangeValue(1)->Intervals(Ti->ChangeArray1(), S);
InvPrepare(1, f, delta);
F = myKnots->Value(1);
if (delta < 0) {
// and the next
for (ii=2; ii<=myCurves->Length(); ii++) {
- n = myCurves->ChangeValue(ii).NbIntervals(S);
+ n = myCurves->ChangeValue(ii)->NbIntervals(S);
if (n != Ti->Length()-1) Ti = new (TColStd_HArray1OfReal) (1, n+1);
- myCurves->ChangeValue(ii).Intervals(Ti->ChangeArray1(), S);
+ myCurves->ChangeValue(ii)->Intervals(Ti->ChangeArray1(), S);
InvPrepare(ii, f, delta);
F = myKnots->Value(ii);
if (delta < 0) {
Standard_Real u = U, d;
Standard_Integer index = CurIndex;
Prepare(u, d, index);
- return myCurves->Value(index).Value(u);
+ return myCurves->Value(index)->Value(u);
}
void BRepAdaptor_CompCurve::D0(const Standard_Real U,
Standard_Real u = U, d;
Standard_Integer index = CurIndex;
Prepare(u, d, index);
- myCurves->Value(index).D0(u, P);
+ myCurves->Value(index)->D0(u, P);
}
void BRepAdaptor_CompCurve::D1(const Standard_Real U,
Standard_Real u = U, d;
Standard_Integer index = CurIndex;
Prepare(u, d, index);
- myCurves->Value(index).D1(u, P, V);
+ myCurves->Value(index)->D1(u, P, V);
V*=d;
}
Standard_Real u = U, d;
Standard_Integer index = CurIndex;
Prepare(u, d, index);
- myCurves->Value(index).D2(u, P, V1, V2);
+ myCurves->Value(index)->D2(u, P, V1, V2);
V1*=d;
V2 *= d*d;
}
Standard_Real u = U, d;
Standard_Integer index = CurIndex;
Prepare(u, d, index);
- myCurves->Value(index).D3(u, P, V1, V2, V3);
+ myCurves->Value(index)->D3(u, P, V1, V2, V3);
V1*=d;
V2 *= d*d;
V3 *= d*d*d;
Standard_Integer index = CurIndex;
Prepare(u, d, index);
- return (myCurves->Value(index).DN(u, N) * Pow(d, N));
+ return (myCurves->Value(index)->DN(u, N) * Pow(d, N));
}
Standard_Real BRepAdaptor_CompCurve::Resolution(const Standard_Real R3d) const
Standard_Real Res = 1.e200, r;
Standard_Integer ii, L = myCurves->Length();
for (ii=1; ii<=L; ii++) {
- r = myCurves->Value(ii).Resolution(R3d);
+ r = myCurves->Value(ii)->Resolution(R3d);
if (r < Res) Res = r;
}
return Res;
gp_Lin BRepAdaptor_CompCurve::Line() const
{
- return myCurves->Value(1).Line();
+ return myCurves->Value(1)->Line();
}
gp_Circ BRepAdaptor_CompCurve::Circle() const
{
- return myCurves->Value(1).Circle();
+ return myCurves->Value(1)->Circle();
}
gp_Elips BRepAdaptor_CompCurve::Ellipse() const
{
- return myCurves->Value(1).Ellipse();
+ return myCurves->Value(1)->Ellipse();
}
gp_Hypr BRepAdaptor_CompCurve::Hyperbola() const
{
- return myCurves->Value(1).Hyperbola();
+ return myCurves->Value(1)->Hyperbola();
}
gp_Parab BRepAdaptor_CompCurve::Parabola() const
{
- return myCurves->Value(1).Parabola();
+ return myCurves->Value(1)->Parabola();
}
Standard_Integer BRepAdaptor_CompCurve::Degree() const
{
- return myCurves->Value(1).Degree();
+ return myCurves->Value(1)->Degree();
}
Standard_Boolean BRepAdaptor_CompCurve::IsRational() const
{
- return myCurves->Value(1).IsRational();
+ return myCurves->Value(1)->IsRational();
}
Standard_Integer BRepAdaptor_CompCurve::NbPoles() const
{
- return myCurves->Value(1).NbPoles();
+ return myCurves->Value(1)->NbPoles();
}
Standard_Integer BRepAdaptor_CompCurve::NbKnots() const
{
- return myCurves->Value(1).NbKnots();
+ return myCurves->Value(1)->NbKnots();
}
Handle(Geom_BezierCurve) BRepAdaptor_CompCurve::Bezier() const
{
- return myCurves->Value(1).Bezier();
+ return myCurves->Value(1)->Bezier();
}
Handle(Geom_BSplineCurve) BRepAdaptor_CompCurve::BSpline() const
{
- return myCurves->Value(1).BSpline();
+ return myCurves->Value(1)->BSpline();
}
//=======================================================================
}
// Invert ?
- const TopoDS_Edge& E = myCurves->Value(theCurIndex).Edge();
+ const TopoDS_Edge& E = myCurves->Value(theCurIndex)->Edge();
TopAbs_Orientation Or = E.Orientation();
Standard_Boolean Reverse;
Reverse = (Forward && (Or == TopAbs_REVERSED)) ||
Standard_Real& Delta) const
{
// Invert?
- const TopoDS_Edge& E = myCurves->Value(index).Edge();
+ const TopoDS_Edge& E = myCurves->Value(index)->Edge();
TopAbs_Orientation Or = E.Orientation();
Standard_Boolean Reverse;
Reverse = (Forward && (Or == TopAbs_REVERSED)) ||
aCopy->myTrsf = myTrsf;
- const Handle(Adaptor3d_Curve) aCurve = myCurve.ShallowCopy();
- const GeomAdaptor_Curve& aGeomCurve = *(Handle(GeomAdaptor_Curve)::DownCast(aCurve));
+ const Handle(Adaptor3d_Curve) aCurve = myCurve->ShallowCopy();
+ const Handle(GeomAdaptor_Curve) aGeomCurve = Handle(GeomAdaptor_Curve)::DownCast(aCurve);
aCopy->myCurve = aGeomCurve;
if (!myConSurf.IsNull())
//=======================================================================
void BRepAdaptor_Curve::Reset()
{
- myCurve.Reset();
+ myCurve->Reset();
myConSurf.Nullify();
myEdge.Nullify();
myTrsf = gp_Trsf();
Handle(Geom_Curve) C = BRep_Tool::Curve(E,L,pf,pl);
if (!C.IsNull()) {
- myCurve.Load(C,pf,pl);
+ myCurve = new GeomAdaptor_Curve();
+ myCurve->Load(C,pf,pl);
}
else {
Handle(Geom2d_Curve) PC;
//=======================================================================
void BRepAdaptor_Curve::Initialize(const TopoDS_Edge& E,
- const TopoDS_Face& F)
+ const TopoDS_Face& F)
{
myConSurf.Nullify();
//purpose :
//=======================================================================
-const GeomAdaptor_Curve& BRepAdaptor_Curve::Curve() const
+const Handle(GeomAdaptor_Curve)& BRepAdaptor_Curve::Curve() const
{
return myCurve;
}
//purpose :
//=======================================================================
-const Adaptor3d_CurveOnSurface& BRepAdaptor_Curve::CurveOnSurface() const
+const Handle(Adaptor3d_CurveOnSurface)& BRepAdaptor_Curve::CurveOnSurface() const
{
- return *myConSurf;
+ return myConSurf;
}
//=======================================================================
Standard_Real BRepAdaptor_Curve::FirstParameter() const
{
if (myConSurf.IsNull()) {
- return myCurve.FirstParameter();
+ return myCurve->FirstParameter();
}
else {
return myConSurf->FirstParameter();
//purpose :
//=======================================================================
-Standard_Real BRepAdaptor_Curve::LastParameter() const
+Standard_Real BRepAdaptor_Curve::LastParameter() const
{
if (myConSurf.IsNull()) {
- return myCurve.LastParameter();
+ return myCurve->LastParameter();
}
else {
return myConSurf->LastParameter();
GeomAbs_Shape BRepAdaptor_Curve::Continuity() const
{
if (myConSurf.IsNull()) {
- return myCurve.Continuity();
+ return myCurve->Continuity();
}
else {
return myConSurf->Continuity();
Standard_Integer BRepAdaptor_Curve::NbIntervals(const GeomAbs_Shape S) const
{
if (myConSurf.IsNull()) {
- return myCurve.NbIntervals(S);
+ return myCurve->NbIntervals(S);
}
else {
return myConSurf->NbIntervals(S);
const GeomAbs_Shape S) const
{
if (myConSurf.IsNull()) {
- myCurve.Intervals(T, S);
+ myCurve->Intervals(T, S);
}
else {
myConSurf->Intervals(T, S);
//=======================================================================
Handle(Adaptor3d_Curve) BRepAdaptor_Curve::Trim(const Standard_Real First,
- const Standard_Real Last,
- const Standard_Real Tol) const
+ const Standard_Real Last,
+ const Standard_Real Tol) const
{
// On fait une copie de this pour garder la trsf.
Handle(BRepAdaptor_Curve) res;
if (myConSurf.IsNull()){
- Standard_Real pf = FirstParameter(), pl = LastParameter();
- Handle(Geom_Curve) C = myCurve.Curve();
- const_cast<GeomAdaptor_Curve*>(&myCurve)->Load(C,First,Last);
- res = new BRepAdaptor_Curve (*this);
- const_cast<GeomAdaptor_Curve*>(&myCurve)->Load(C,pf,pl);
+ Handle(GeomAdaptor_Curve) aGAC = myCurve;
+ const_cast<Handle(GeomAdaptor_Curve)&>(myCurve) = Handle(GeomAdaptor_Curve)::DownCast(myCurve->Trim(First, Last, Tol));
+ res = new BRepAdaptor_Curve(*this);
+ const_cast<Handle(GeomAdaptor_Curve)&>(myCurve) = aGAC;
}
else {
Handle(Adaptor3d_CurveOnSurface) sav = myConSurf;
Standard_Boolean BRepAdaptor_Curve::IsClosed() const
{
if (myConSurf.IsNull()) {
- return myCurve.IsClosed();
+ return myCurve->IsClosed();
}
else {
return myConSurf->IsClosed();
Standard_Boolean BRepAdaptor_Curve::IsPeriodic() const
{
if (myConSurf.IsNull()) {
- return myCurve.IsPeriodic();
+ return myCurve->IsPeriodic();
}
else {
return myConSurf->IsPeriodic();
Standard_Real BRepAdaptor_Curve::Period() const
{
if (myConSurf.IsNull()) {
- return myCurve.Period();
+ return myCurve->Period();
}
else {
return myConSurf->Period();
{
gp_Pnt P;
if (myConSurf.IsNull())
- P = myCurve.Value(U);
+ P = myCurve->Value(U);
else
P = myConSurf->Value(U);
P.Transform(myTrsf);
void BRepAdaptor_Curve::D0(const Standard_Real U, gp_Pnt& P) const
{
if (myConSurf.IsNull())
- myCurve.D0(U,P);
+ myCurve->D0(U,P);
else
myConSurf->D0(U,P);
P.Transform(myTrsf);
//=======================================================================
void BRepAdaptor_Curve::D1(const Standard_Real U,
- gp_Pnt& P, gp_Vec& V) const
+ gp_Pnt& P, gp_Vec& V) const
{
if (myConSurf.IsNull())
- myCurve.D1(U,P,V);
+ myCurve->D1(U,P,V);
else
myConSurf->D1(U,P,V);
P.Transform(myTrsf);
//=======================================================================
void BRepAdaptor_Curve::D2(const Standard_Real U,
- gp_Pnt& P, gp_Vec& V1, gp_Vec& V2) const
+ gp_Pnt& P, gp_Vec& V1, gp_Vec& V2) const
{
if (myConSurf.IsNull())
- myCurve.D2(U,P,V1,V2);
+ myCurve->D2(U,P,V1,V2);
else
myConSurf->D2(U,P,V1,V2);
P.Transform(myTrsf);
//=======================================================================
void BRepAdaptor_Curve::D3(const Standard_Real U,
- gp_Pnt& P,
- gp_Vec& V1, gp_Vec& V2, gp_Vec& V3) const
+ gp_Pnt& P,
+ gp_Vec& V1, gp_Vec& V2, gp_Vec& V3) const
{
if (myConSurf.IsNull())
- myCurve.D3(U,P,V1,V2,V3);
+ myCurve->D3(U,P,V1,V2,V3);
else
myConSurf->D3(U,P,V1,V2,V3);
P.Transform(myTrsf);
//purpose :
//=======================================================================
-gp_Vec BRepAdaptor_Curve::DN(const Standard_Real U,
- const Standard_Integer N) const
+gp_Vec BRepAdaptor_Curve::DN (const Standard_Real U,
+ const Standard_Integer N) const
{
gp_Vec V;
if (myConSurf.IsNull())
- V = myCurve.DN(U,N);
+ V = myCurve->DN(U,N);
else
V = myConSurf->DN(U,N);
V.Transform(myTrsf);
Standard_Real BRepAdaptor_Curve::Resolution(const Standard_Real R) const
{
if (myConSurf.IsNull()) {
- return myCurve.Resolution(R);
+ return myCurve->Resolution(R);
}
else {
return myConSurf->Resolution(R);
GeomAbs_CurveType BRepAdaptor_Curve::GetType() const
{
if (myConSurf.IsNull()) {
- return myCurve.GetType();
+ return myCurve->GetType();
}
else {
return myConSurf->GetType();
{
gp_Lin L;
if (myConSurf.IsNull())
- L = myCurve.Line();
+ L = myCurve->Line();
else
L = myConSurf->Line();
L.Transform(myTrsf);
{
gp_Circ C;
if (myConSurf.IsNull())
- C = myCurve.Circle();
+ C = myCurve->Circle();
else
C = myConSurf->Circle();
C.Transform(myTrsf);
{
gp_Elips E;
if (myConSurf.IsNull())
- E = myCurve.Ellipse();
+ E = myCurve->Ellipse();
else
E = myConSurf->Ellipse();
E.Transform(myTrsf);
{
gp_Hypr H;
if (myConSurf.IsNull())
- H = myCurve.Hyperbola();
+ H = myCurve->Hyperbola();
else
H = myConSurf->Hyperbola();
H.Transform(myTrsf);
{
gp_Parab P;
if (myConSurf.IsNull())
- P = myCurve.Parabola();
+ P = myCurve->Parabola();
else
P = myConSurf->Parabola();
P.Transform(myTrsf);
Standard_Integer BRepAdaptor_Curve::Degree() const
{
if (myConSurf.IsNull())
- return myCurve.Degree();
+ return myCurve->Degree();
else
return myConSurf->Degree();
}
Standard_Boolean BRepAdaptor_Curve::IsRational() const
{
if (myConSurf.IsNull())
- return myCurve.IsRational();
+ return myCurve->IsRational();
else
return myConSurf->IsRational();
}
Standard_Integer BRepAdaptor_Curve::NbPoles() const
{
if (myConSurf.IsNull())
- return myCurve.NbPoles();
+ return myCurve->NbPoles();
else
return myConSurf->NbPoles();
}
Standard_Integer BRepAdaptor_Curve::NbKnots() const
{
if (myConSurf.IsNull())
- return myCurve.NbKnots();
+ return myCurve->NbKnots();
else
return myConSurf->NbKnots();
}
{
Handle(Geom_BezierCurve) BC;
if (myConSurf.IsNull()) {
- BC = myCurve.Bezier();
+ BC = myCurve->Bezier();
}
else {
BC = myConSurf->Bezier();
{
Handle(Geom_BSplineCurve) BS;
if (myConSurf.IsNull()) {
- BS = myCurve.BSpline();
+ BS = myCurve->BSpline();
}
else {
BS = myConSurf->BSpline();
Handle(Geom_OffsetCurve) BRepAdaptor_Curve::OffsetCurve() const
{
- if ( !Is3DCurve() || myCurve.GetType() != GeomAbs_OffsetCurve)
+ if ( !Is3DCurve() || myCurve->GetType() != GeomAbs_OffsetCurve)
throw Standard_NoSuchObject("BRepAdaptor_Curve::OffsetCurve");
- Handle(Geom_OffsetCurve) anOffC = myCurve.OffsetCurve();
+ Handle(Geom_OffsetCurve) anOffC = myCurve->OffsetCurve();
return myTrsf.Form() == gp_Identity
? anOffC : Handle(Geom_OffsetCurve)::DownCast(anOffC->Transformed(myTrsf));
}
Standard_EXPORT Standard_Boolean IsCurveOnSurface() const;
//! Returns the Curve of the edge.
- Standard_EXPORT const GeomAdaptor_Curve& Curve() const;
+ Standard_EXPORT const Handle(GeomAdaptor_Curve)& Curve() const;
//! Returns the CurveOnSurface of the edge.
- Standard_EXPORT const Adaptor3d_CurveOnSurface& CurveOnSurface() const;
+ Standard_EXPORT const Handle(Adaptor3d_CurveOnSurface)& CurveOnSurface() const;
//! Returns the edge.
Standard_EXPORT const TopoDS_Edge& Edge() const;
private:
gp_Trsf myTrsf;
- GeomAdaptor_Curve myCurve;
+ Handle(GeomAdaptor_Curve) myCurve;
Handle(Adaptor3d_CurveOnSurface) myConSurf;
TopoDS_Edge myEdge;
//=======================================================================
BRepAdaptor_Surface::BRepAdaptor_Surface()
{
+ mySurf = new GeomAdaptor_Surface();
}
BRepAdaptor_Surface::BRepAdaptor_Surface(const TopoDS_Face& F,
const Standard_Boolean R)
{
+ mySurf = new GeomAdaptor_Surface();
Initialize(F,R);
}
{
Handle(BRepAdaptor_Surface) aCopy = new BRepAdaptor_Surface();
- const Handle(Adaptor3d_Surface) aSurface = mySurf.ShallowCopy();
- const GeomAdaptor_Surface& aGeomSurface = *(Handle(GeomAdaptor_Surface)::DownCast(aSurface));
- aCopy->mySurf = aGeomSurface;
+ const Handle(Adaptor3d_Surface) aSurface = mySurf->ShallowCopy();
+ aCopy->mySurf = Handle(GeomAdaptor_Surface)::DownCast(aSurface);
aCopy->myTrsf = myTrsf;
aCopy->myFace = myFace;
if (Restriction) {
Standard_Real umin,umax,vmin,vmax;
BRepTools::UVBounds(F,umin,umax,vmin,vmax);
- mySurf.Load(aSurface,umin,umax,vmin,vmax);
+ mySurf->Load(aSurface,umin,umax,vmin,vmax);
}
else
- mySurf.Load(aSurface);
+ mySurf->Load(aSurface);
myTrsf = L.Transformation();
}
//purpose :
//=======================================================================
-const GeomAdaptor_Surface& BRepAdaptor_Surface::Surface() const
+const Handle(GeomAdaptor_Surface)& BRepAdaptor_Surface::Surface() const
{
return mySurf;
}
-
-//=======================================================================
-//function : ChangeSurface
-//purpose :
-//=======================================================================
-
-GeomAdaptor_Surface& BRepAdaptor_Surface::ChangeSurface()
-{
- return mySurf;
-}
-
-
//=======================================================================
//function : Trsf
//purpose :
void BRepAdaptor_Surface::UIntervals(TColStd_Array1OfReal& T,
const GeomAbs_Shape S) const
{
- mySurf.UIntervals(T,S);
+ mySurf->UIntervals(T,S);
}
void BRepAdaptor_Surface::VIntervals(TColStd_Array1OfReal& T,
const GeomAbs_Shape S) const
{
- mySurf.VIntervals(T,S);
+ mySurf->VIntervals(T,S);
}
const Standard_Real Tol ) const
{
Handle(GeomAdaptor_Surface) HS = new GeomAdaptor_Surface();
- HS->Load (Handle(Geom_Surface)::DownCast(mySurf.Surface()->Transformed(myTrsf)));
+ HS->Load (Handle(Geom_Surface)::DownCast(mySurf->Surface()->Transformed(myTrsf)));
return HS->UTrim(First,Last,Tol);
}
const Standard_Real Tol) const
{
Handle(GeomAdaptor_Surface) HS = new GeomAdaptor_Surface();
- HS->Load (Handle(Geom_Surface)::DownCast(mySurf.Surface()->Transformed(myTrsf)));
+ HS->Load (Handle(Geom_Surface)::DownCast(mySurf->Surface()->Transformed(myTrsf)));
return HS->VTrim(First,Last,Tol);
}
gp_Pnt BRepAdaptor_Surface::Value(const Standard_Real U,
const Standard_Real V) const
{
- return mySurf.Value(U,V).Transformed(myTrsf);
+ return mySurf->Value(U,V).Transformed(myTrsf);
}
//=======================================================================
const Standard_Real V,
gp_Pnt& P) const
{
- mySurf.D0(U,V,P);
+ mySurf->D0(U,V,P);
P.Transform(myTrsf);
}
gp_Vec& D1U,
gp_Vec& D1V)const
{
- mySurf.D1(U,V,P,D1U,D1V);
+ mySurf->D1(U,V,P,D1U,D1V);
P.Transform(myTrsf);
D1U.Transform(myTrsf);
D1V.Transform(myTrsf);
gp_Vec& D2V,
gp_Vec& D2UV)const
{
- mySurf.D2(U,V,P,D1U,D1V,D2U,D2V,D2UV);
+ mySurf->D2(U,V,P,D1U,D1V,D2U,D2V,D2UV);
P.Transform(myTrsf);
D1U.Transform(myTrsf);
D1V.Transform(myTrsf);
gp_Vec& D3U, gp_Vec& D3V,
gp_Vec& D3UUV, gp_Vec& D3UVV)const
{
- mySurf.D3(U,V,P,D1U,D1V,D2U,D2V,D2UV,D3U,D3V,D3UUV,D3UVV);
+ mySurf->D3(U,V,P,D1U,D1V,D2U,D2V,D2UV,D3U,D3V,D3UUV,D3UVV);
P.Transform(myTrsf);
D1U.Transform(myTrsf);
D1V.Transform(myTrsf);
const Standard_Integer Nu,
const Standard_Integer Nv) const
{
- return mySurf.DN(U,V,Nu,Nv).Transformed(myTrsf);
+ return mySurf->DN(U,V,Nu,Nv).Transformed(myTrsf);
}
//=======================================================================
gp_Pln BRepAdaptor_Surface::Plane()const
{
- return mySurf.Plane().Transformed(myTrsf);
+ return mySurf->Plane().Transformed(myTrsf);
}
gp_Cylinder BRepAdaptor_Surface::Cylinder()const
{
- return mySurf.Cylinder().Transformed(myTrsf);
+ return mySurf->Cylinder().Transformed(myTrsf);
}
gp_Sphere BRepAdaptor_Surface::Sphere()const
{
- return mySurf.Sphere().Transformed(myTrsf);
+ return mySurf->Sphere().Transformed(myTrsf);
}
gp_Cone BRepAdaptor_Surface::Cone()const
{
- return mySurf.Cone().Transformed(myTrsf);
+ return mySurf->Cone().Transformed(myTrsf);
}
//=======================================================================
gp_Torus BRepAdaptor_Surface::Torus()const
{
- return mySurf.Torus().Transformed(myTrsf);
+ return mySurf->Torus().Transformed(myTrsf);
}
//=======================================================================
Handle(Geom_BezierSurface) BRepAdaptor_Surface::Bezier() const
{
return Handle(Geom_BezierSurface)::DownCast
- (mySurf.Bezier()->Transformed(myTrsf));
+ (mySurf->Bezier()->Transformed(myTrsf));
}
Handle(Geom_BSplineSurface) BRepAdaptor_Surface::BSpline() const
{
return Handle(Geom_BSplineSurface)::DownCast
- (mySurf.BSpline()->Transformed(myTrsf));
+ (mySurf->BSpline()->Transformed(myTrsf));
}
gp_Ax1 BRepAdaptor_Surface::AxeOfRevolution() const
{
- return mySurf.AxeOfRevolution().Transformed(myTrsf);
+ return mySurf->AxeOfRevolution().Transformed(myTrsf);
}
gp_Dir BRepAdaptor_Surface::Direction() const
{
- return mySurf.Direction().Transformed(myTrsf);
+ return mySurf->Direction().Transformed(myTrsf);
}
Handle(Adaptor3d_Curve) BRepAdaptor_Surface::BasisCurve() const
{
Handle(GeomAdaptor_Surface) HS = new GeomAdaptor_Surface();
- HS->Load (Handle(Geom_Surface)::DownCast(mySurf.Surface()->Transformed(myTrsf)));
+ HS->Load (Handle(Geom_Surface)::DownCast(mySurf->Surface()->Transformed(myTrsf)));
return HS->BasisCurve();
}
Handle(Adaptor3d_Surface) BRepAdaptor_Surface::BasisSurface() const
{
Handle(GeomAdaptor_Surface) HS = new GeomAdaptor_Surface();
- HS->Load (Handle(Geom_Surface)::DownCast(mySurf.Surface()->Transformed(myTrsf)));
+ HS->Load (Handle(Geom_Surface)::DownCast(mySurf->Surface()->Transformed(myTrsf)));
return HS->BasisSurface();
}
Standard_Real BRepAdaptor_Surface::OffsetValue() const
{
- return mySurf.OffsetValue();
+ return mySurf->OffsetValue();
}
Standard_EXPORT void Initialize (const TopoDS_Face& F, const Standard_Boolean Restriction = Standard_True);
//! Returns the surface.
- Standard_EXPORT const GeomAdaptor_Surface& Surface() const;
-
- //! Returns the surface.
- Standard_EXPORT GeomAdaptor_Surface& ChangeSurface();
+ Standard_EXPORT const Handle(GeomAdaptor_Surface)& Surface() const;
//! Returns the surface coordinate system.
Standard_EXPORT const gp_Trsf& Trsf() const;
//! Returns the face tolerance.
Standard_EXPORT Standard_Real Tolerance() const;
- virtual Standard_Real FirstUParameter() const Standard_OVERRIDE { return mySurf.FirstUParameter(); }
+ virtual Standard_Real FirstUParameter() const Standard_OVERRIDE { return mySurf->FirstUParameter(); }
- virtual Standard_Real LastUParameter() const Standard_OVERRIDE { return mySurf.LastUParameter(); }
+ virtual Standard_Real LastUParameter() const Standard_OVERRIDE { return mySurf->LastUParameter(); }
- virtual Standard_Real FirstVParameter() const Standard_OVERRIDE { return mySurf.FirstVParameter(); }
+ virtual Standard_Real FirstVParameter() const Standard_OVERRIDE { return mySurf->FirstVParameter(); }
- virtual Standard_Real LastVParameter() const Standard_OVERRIDE { return mySurf.LastVParameter(); }
+ virtual Standard_Real LastVParameter() const Standard_OVERRIDE { return mySurf->LastVParameter(); }
- virtual GeomAbs_Shape UContinuity() const Standard_OVERRIDE { return mySurf.UContinuity(); }
+ virtual GeomAbs_Shape UContinuity() const Standard_OVERRIDE { return mySurf->UContinuity(); }
- virtual GeomAbs_Shape VContinuity() const Standard_OVERRIDE { return mySurf.VContinuity(); }
+ virtual GeomAbs_Shape VContinuity() const Standard_OVERRIDE { return mySurf->VContinuity(); }
//! If necessary, breaks the surface in U intervals of
//! continuity <S>. And returns the number of
//! intervals.
- virtual Standard_Integer NbUIntervals (const GeomAbs_Shape theSh) const Standard_OVERRIDE { return mySurf.NbUIntervals (theSh); }
+ virtual Standard_Integer NbUIntervals (const GeomAbs_Shape theSh) const Standard_OVERRIDE { return mySurf->NbUIntervals (theSh); }
//! If necessary, breaks the surface in V intervals of
//! continuity <S>. And returns the number of
//! intervals.
- virtual Standard_Integer NbVIntervals (const GeomAbs_Shape theSh) const Standard_OVERRIDE { return mySurf.NbVIntervals (theSh); }
+ virtual Standard_Integer NbVIntervals (const GeomAbs_Shape theSh) const Standard_OVERRIDE { return mySurf->NbVIntervals (theSh); }
//! Returns the intervals with the requested continuity
//! in the U direction.
//! If <First> >= <Last>
Standard_EXPORT Handle(Adaptor3d_Surface) VTrim (const Standard_Real First, const Standard_Real Last, const Standard_Real Tol) const Standard_OVERRIDE;
- virtual Standard_Boolean IsUClosed() const Standard_OVERRIDE { return mySurf.IsUClosed(); }
+ virtual Standard_Boolean IsUClosed() const Standard_OVERRIDE { return mySurf->IsUClosed(); }
- virtual Standard_Boolean IsVClosed() const Standard_OVERRIDE { return mySurf.IsVClosed(); }
+ virtual Standard_Boolean IsVClosed() const Standard_OVERRIDE { return mySurf->IsVClosed(); }
- virtual Standard_Boolean IsUPeriodic() const Standard_OVERRIDE { return mySurf.IsUPeriodic(); }
+ virtual Standard_Boolean IsUPeriodic() const Standard_OVERRIDE { return mySurf->IsUPeriodic(); }
- virtual Standard_Real UPeriod() const Standard_OVERRIDE { return mySurf.UPeriod(); }
+ virtual Standard_Real UPeriod() const Standard_OVERRIDE { return mySurf->UPeriod(); }
- virtual Standard_Boolean IsVPeriodic() const Standard_OVERRIDE { return mySurf.IsVPeriodic(); }
+ virtual Standard_Boolean IsVPeriodic() const Standard_OVERRIDE { return mySurf->IsVPeriodic(); }
- virtual Standard_Real VPeriod() const Standard_OVERRIDE { return mySurf.VPeriod(); }
+ virtual Standard_Real VPeriod() const Standard_OVERRIDE { return mySurf->VPeriod(); }
//! Computes the point of parameters U,V on the surface.
//! Tip: use GeomLib::NormEstim() to calculate surface normal at specified (U, V) point.
//! Returns the parametric U resolution corresponding
//! to the real space resolution <R3d>.
- virtual Standard_Real UResolution (const Standard_Real theR3d) const Standard_OVERRIDE { return mySurf.UResolution (theR3d); }
+ virtual Standard_Real UResolution (const Standard_Real theR3d) const Standard_OVERRIDE { return mySurf->UResolution (theR3d); }
//! Returns the parametric V resolution corresponding
//! to the real space resolution <R3d>.
- virtual Standard_Real VResolution (const Standard_Real theR3d) const Standard_OVERRIDE { return mySurf.VResolution (theR3d); }
+ virtual Standard_Real VResolution (const Standard_Real theR3d) const Standard_OVERRIDE { return mySurf->VResolution (theR3d); }
//! Returns the type of the surface : Plane, Cylinder,
//! Cone, Sphere, Torus, BezierSurface,
//! BSplineSurface, SurfaceOfRevolution,
//! SurfaceOfExtrusion, OtherSurface
- virtual GeomAbs_SurfaceType GetType() const Standard_OVERRIDE { return mySurf.GetType(); }
+ virtual GeomAbs_SurfaceType GetType() const Standard_OVERRIDE { return mySurf->GetType(); }
Standard_EXPORT gp_Pln Plane() const Standard_OVERRIDE;
Standard_EXPORT gp_Torus Torus() const Standard_OVERRIDE;
- virtual Standard_Integer UDegree() const Standard_OVERRIDE { return mySurf.UDegree(); }
+ virtual Standard_Integer UDegree() const Standard_OVERRIDE { return mySurf->UDegree(); }
- virtual Standard_Integer NbUPoles() const Standard_OVERRIDE { return mySurf.NbUPoles(); }
+ virtual Standard_Integer NbUPoles() const Standard_OVERRIDE { return mySurf->NbUPoles(); }
- virtual Standard_Integer VDegree() const Standard_OVERRIDE { return mySurf.VDegree(); }
+ virtual Standard_Integer VDegree() const Standard_OVERRIDE { return mySurf->VDegree(); }
- virtual Standard_Integer NbVPoles() const Standard_OVERRIDE { return mySurf.NbVPoles(); }
+ virtual Standard_Integer NbVPoles() const Standard_OVERRIDE { return mySurf->NbVPoles(); }
- virtual Standard_Integer NbUKnots() const Standard_OVERRIDE { return mySurf.NbUKnots(); }
+ virtual Standard_Integer NbUKnots() const Standard_OVERRIDE { return mySurf->NbUKnots(); }
- virtual Standard_Integer NbVKnots() const Standard_OVERRIDE { return mySurf.NbVKnots(); }
+ virtual Standard_Integer NbVKnots() const Standard_OVERRIDE { return mySurf->NbVKnots(); }
- virtual Standard_Boolean IsURational() const Standard_OVERRIDE { return mySurf.IsURational(); }
+ virtual Standard_Boolean IsURational() const Standard_OVERRIDE { return mySurf->IsURational(); }
- virtual Standard_Boolean IsVRational() const Standard_OVERRIDE { return mySurf.IsVRational(); }
+ virtual Standard_Boolean IsVRational() const Standard_OVERRIDE { return mySurf->IsVRational(); }
Standard_EXPORT Handle(Geom_BezierSurface) Bezier() const Standard_OVERRIDE;
private:
- GeomAdaptor_Surface mySurf;
+ Handle(GeomAdaptor_Surface) mySurf;
gp_Trsf myTrsf;
TopoDS_Face myFace;
for(i = 1; i <= NbEdges; i++){
DescenList.Clear();
Handle(BRepAdaptor_Curve) hcur = new BRepAdaptor_Curve (TopoDS::Edge(Edges->Value(i)));
- Elementary = IsElementary(*hcur);
+ Elementary = IsElementary(hcur);
for(j = 1; j <= NbFaces; j++){
Handle(BRepAdaptor_Surface) hsur = new BRepAdaptor_Surface (TopoDS::Face(Faces->Value(j)));
//purpose :
//=======================================================================
- Standard_Boolean BRepAlgo_NormalProjection::IsElementary(const Adaptor3d_Curve& C) const
+ Standard_Boolean BRepAlgo_NormalProjection::IsElementary(const Handle(Adaptor3d_Curve)& C) const
{
GeomAbs_CurveType type;
- type = C.GetType();
+ type = C->GetType();
switch(type) {
case GeomAbs_Line:
case GeomAbs_Circle:
//! shape <S>.
Standard_EXPORT const TopTools_ListOfShape& Generated (const TopoDS_Shape& S);
- Standard_EXPORT Standard_Boolean IsElementary (const Adaptor3d_Curve& C) const;
+ Standard_EXPORT Standard_Boolean IsElementary (const Handle(Adaptor3d_Curve)& C) const;
//! build the result as a list of wire if possible in --
//! a first returns a wire only if there is only a wire.
Standard_EXPORT BRepApprox_Approx();
- Standard_EXPORT void Perform (const BRepAdaptor_Surface& Surf1, const BRepAdaptor_Surface& Surf2, const Handle(BRepApprox_ApproxLine)& aLine, const Standard_Boolean ApproxXYZ = Standard_True, const Standard_Boolean ApproxU1V1 = Standard_True, const Standard_Boolean ApproxU2V2 = Standard_True, const Standard_Integer indicemin = 0, const Standard_Integer indicemax = 0);
+ Standard_EXPORT void Perform (const Handle(BRepAdaptor_Surface)& Surf1, const Handle(BRepAdaptor_Surface)& Surf2, const Handle(BRepApprox_ApproxLine)& aLine, const Standard_Boolean ApproxXYZ = Standard_True, const Standard_Boolean ApproxU1V1 = Standard_True, const Standard_Boolean ApproxU2V2 = Standard_True, const Standard_Integer indicemin = 0, const Standard_Integer indicemax = 0);
Standard_EXPORT void Perform (const Handle(BRepApprox_ApproxLine)& aLine, const Standard_Boolean ApproxXYZ = Standard_True, const Standard_Boolean ApproxU1V1 = Standard_True, const Standard_Boolean ApproxU2V2 = Standard_True, const Standard_Integer indicemin = 0, const Standard_Integer indicemax = 0);
private:
- Standard_EXPORT void Perform (const IntSurf_Quadric& Surf1, const BRepAdaptor_Surface& Surf2, const Handle(BRepApprox_ApproxLine)& aLine, const Standard_Boolean ApproxXYZ, const Standard_Boolean ApproxU1V1, const Standard_Boolean ApproxU2V2, const Standard_Integer indicemin, const Standard_Integer indicemax, const Standard_Boolean isTheQuadFirst);
+ Standard_EXPORT void Perform (const IntSurf_Quadric& Surf1, const Handle(BRepAdaptor_Surface)& Surf2, const Handle(BRepApprox_ApproxLine)& aLine, const Standard_Boolean ApproxXYZ, const Standard_Boolean ApproxU1V1, const Standard_Boolean ApproxU2V2, const Standard_Integer indicemin, const Standard_Integer indicemax, const Standard_Boolean isTheQuadFirst);
Standard_EXPORT void UpdateTolReached();
#include <AppParCurves_MultiBSpCurve.hxx>
-#define ThePSurface BRepAdaptor_Surface
+#define ThePSurface Handle(BRepAdaptor_Surface)
#define ThePSurface_hxx <BRepAdaptor_Surface.hxx>
#define ThePSurfaceTool BRepApprox_SurfaceTool
#define ThePSurfaceTool_hxx <BRepApprox_SurfaceTool.hxx>
#include <BRepAdaptor_Surface.hxx>
#include <Geom_BezierSurface.hxx>
-Standard_Integer BRepApprox_SurfaceTool::NbSamplesU (const BRepAdaptor_Surface&)
+Standard_Integer BRepApprox_SurfaceTool::NbSamplesU (const Handle(BRepAdaptor_Surface)&)
{
return(10);
}
-Standard_Integer BRepApprox_SurfaceTool::NbSamplesV (const BRepAdaptor_Surface&)
+Standard_Integer BRepApprox_SurfaceTool::NbSamplesV (const Handle(BRepAdaptor_Surface)&)
{
return(10);
}
-Standard_Integer BRepApprox_SurfaceTool::NbSamplesU (const BRepAdaptor_Surface&,
+Standard_Integer BRepApprox_SurfaceTool::NbSamplesU (const Handle(BRepAdaptor_Surface)&,
const Standard_Real,
const Standard_Real)
{
return(10);
}
-Standard_Integer BRepApprox_SurfaceTool::NbSamplesV (const BRepAdaptor_Surface&,
+Standard_Integer BRepApprox_SurfaceTool::NbSamplesV (const Handle(BRepAdaptor_Surface)&,
const Standard_Real,
const Standard_Real)
{
DEFINE_STANDARD_ALLOC
- static Standard_Real FirstUParameter (const BRepAdaptor_Surface& S);
+ static Standard_Real FirstUParameter (const Handle(BRepAdaptor_Surface)& S);
- static Standard_Real FirstVParameter (const BRepAdaptor_Surface& S);
+ static Standard_Real FirstVParameter (const Handle(BRepAdaptor_Surface)& S);
- static Standard_Real LastUParameter (const BRepAdaptor_Surface& S);
+ static Standard_Real LastUParameter (const Handle(BRepAdaptor_Surface)& S);
- static Standard_Real LastVParameter (const BRepAdaptor_Surface& S);
+ static Standard_Real LastVParameter (const Handle(BRepAdaptor_Surface)& S);
- static Standard_Integer NbUIntervals (const BRepAdaptor_Surface& S, const GeomAbs_Shape Sh);
+ static Standard_Integer NbUIntervals (const Handle(BRepAdaptor_Surface)& S, const GeomAbs_Shape Sh);
- static Standard_Integer NbVIntervals (const BRepAdaptor_Surface& S, const GeomAbs_Shape Sh);
+ static Standard_Integer NbVIntervals (const Handle(BRepAdaptor_Surface)& S, const GeomAbs_Shape Sh);
- static void UIntervals (const BRepAdaptor_Surface& S, TColStd_Array1OfReal& T, const GeomAbs_Shape Sh);
+ static void UIntervals (const Handle(BRepAdaptor_Surface)& S, TColStd_Array1OfReal& T, const GeomAbs_Shape Sh);
- static void VIntervals (const BRepAdaptor_Surface& S, TColStd_Array1OfReal& T, const GeomAbs_Shape Sh);
+ static void VIntervals (const Handle(BRepAdaptor_Surface)& S, TColStd_Array1OfReal& T, const GeomAbs_Shape Sh);
//! If <First> >= <Last>
- static Handle(Adaptor3d_Surface) UTrim (const BRepAdaptor_Surface& S, const Standard_Real First, const Standard_Real Last, const Standard_Real Tol);
+ static Handle(Adaptor3d_Surface) UTrim (const Handle(BRepAdaptor_Surface)& S, const Standard_Real First, const Standard_Real Last, const Standard_Real Tol);
//! If <First> >= <Last>
- static Handle(Adaptor3d_Surface) VTrim (const BRepAdaptor_Surface& S, const Standard_Real First, const Standard_Real Last, const Standard_Real Tol);
+ static Handle(Adaptor3d_Surface) VTrim (const Handle(BRepAdaptor_Surface)& S, const Standard_Real First, const Standard_Real Last, const Standard_Real Tol);
- static Standard_Boolean IsUClosed (const BRepAdaptor_Surface& S);
+ static Standard_Boolean IsUClosed (const Handle(BRepAdaptor_Surface)& S);
- static Standard_Boolean IsVClosed (const BRepAdaptor_Surface& S);
+ static Standard_Boolean IsVClosed (const Handle(BRepAdaptor_Surface)& S);
- static Standard_Boolean IsUPeriodic (const BRepAdaptor_Surface& S);
+ static Standard_Boolean IsUPeriodic (const Handle(BRepAdaptor_Surface)& S);
- static Standard_Real UPeriod (const BRepAdaptor_Surface& S);
+ static Standard_Real UPeriod (const Handle(BRepAdaptor_Surface)& S);
- static Standard_Boolean IsVPeriodic (const BRepAdaptor_Surface& S);
+ static Standard_Boolean IsVPeriodic (const Handle(BRepAdaptor_Surface)& S);
- static Standard_Real VPeriod (const BRepAdaptor_Surface& S);
+ static Standard_Real VPeriod (const Handle(BRepAdaptor_Surface)& S);
- static gp_Pnt Value (const BRepAdaptor_Surface& S, const Standard_Real u, const Standard_Real v);
+ static gp_Pnt Value (const Handle(BRepAdaptor_Surface)& S, const Standard_Real u, const Standard_Real v);
- static void D0 (const BRepAdaptor_Surface& S, const Standard_Real u, const Standard_Real v, gp_Pnt& P);
+ static void D0 (const Handle(BRepAdaptor_Surface)& S, const Standard_Real u, const Standard_Real v, gp_Pnt& P);
- static void D1 (const BRepAdaptor_Surface& S, const Standard_Real u, const Standard_Real v, gp_Pnt& P, gp_Vec& D1u, gp_Vec& D1v);
+ static void D1 (const Handle(BRepAdaptor_Surface)& S, const Standard_Real u, const Standard_Real v, gp_Pnt& P, gp_Vec& D1u, gp_Vec& D1v);
- static void D2 (const BRepAdaptor_Surface& S, const Standard_Real u, const Standard_Real v, gp_Pnt& P, gp_Vec& D1U, gp_Vec& D1V, gp_Vec& D2U, gp_Vec& D2V, gp_Vec& D2UV);
+ static void D2 (const Handle(BRepAdaptor_Surface)& S, const Standard_Real u, const Standard_Real v, gp_Pnt& P, gp_Vec& D1U, gp_Vec& D1V, gp_Vec& D2U, gp_Vec& D2V, gp_Vec& D2UV);
- static void D3 (const BRepAdaptor_Surface& S, const Standard_Real u, const Standard_Real v, gp_Pnt& P, gp_Vec& D1U, gp_Vec& D1V, gp_Vec& D2U, gp_Vec& D2V, gp_Vec& D2UV, gp_Vec& D3U, gp_Vec& D3V, gp_Vec& D3UUV, gp_Vec& D3UVV);
+ static void D3 (const Handle(BRepAdaptor_Surface)& S, const Standard_Real u, const Standard_Real v, gp_Pnt& P, gp_Vec& D1U, gp_Vec& D1V, gp_Vec& D2U, gp_Vec& D2V, gp_Vec& D2UV, gp_Vec& D3U, gp_Vec& D3V, gp_Vec& D3UUV, gp_Vec& D3UVV);
- static gp_Vec DN (const BRepAdaptor_Surface& S, const Standard_Real u, const Standard_Real v, const Standard_Integer Nu, const Standard_Integer Nv);
+ static gp_Vec DN (const Handle(BRepAdaptor_Surface)& S, const Standard_Real u, const Standard_Real v, const Standard_Integer Nu, const Standard_Integer Nv);
- static Standard_Real UResolution (const BRepAdaptor_Surface& S, const Standard_Real R3d);
+ static Standard_Real UResolution (const Handle(BRepAdaptor_Surface)& S, const Standard_Real R3d);
- static Standard_Real VResolution (const BRepAdaptor_Surface& S, const Standard_Real R3d);
+ static Standard_Real VResolution (const Handle(BRepAdaptor_Surface)& S, const Standard_Real R3d);
- static GeomAbs_SurfaceType GetType (const BRepAdaptor_Surface& S);
+ static GeomAbs_SurfaceType GetType (const Handle(BRepAdaptor_Surface)& S);
- static gp_Pln Plane (const BRepAdaptor_Surface& S);
+ static gp_Pln Plane (const Handle(BRepAdaptor_Surface)& S);
- static gp_Cylinder Cylinder (const BRepAdaptor_Surface& S);
+ static gp_Cylinder Cylinder (const Handle(BRepAdaptor_Surface)& S);
- static gp_Cone Cone (const BRepAdaptor_Surface& S);
+ static gp_Cone Cone (const Handle(BRepAdaptor_Surface)& S);
- static gp_Torus Torus (const BRepAdaptor_Surface& S);
+ static gp_Torus Torus (const Handle(BRepAdaptor_Surface)& S);
- static gp_Sphere Sphere (const BRepAdaptor_Surface& S);
+ static gp_Sphere Sphere (const Handle(BRepAdaptor_Surface)& S);
- static Handle(Geom_BezierSurface) Bezier (const BRepAdaptor_Surface& S);
+ static Handle(Geom_BezierSurface) Bezier (const Handle(BRepAdaptor_Surface)& S);
- static Handle(Geom_BSplineSurface) BSpline (const BRepAdaptor_Surface& S);
+ static Handle(Geom_BSplineSurface) BSpline (const Handle(BRepAdaptor_Surface)& S);
- static gp_Ax1 AxeOfRevolution (const BRepAdaptor_Surface& S);
+ static gp_Ax1 AxeOfRevolution (const Handle(BRepAdaptor_Surface)& S);
- static gp_Dir Direction (const BRepAdaptor_Surface& S);
+ static gp_Dir Direction (const Handle(BRepAdaptor_Surface)& S);
- static Handle(Adaptor3d_Curve) BasisCurve (const BRepAdaptor_Surface& S);
+ static Handle(Adaptor3d_Curve) BasisCurve (const Handle(BRepAdaptor_Surface)& S);
- Standard_EXPORT static Standard_Integer NbSamplesU (const BRepAdaptor_Surface& S);
+ Standard_EXPORT static Standard_Integer NbSamplesU (const Handle(BRepAdaptor_Surface)& S);
- Standard_EXPORT static Standard_Integer NbSamplesV (const BRepAdaptor_Surface& S);
+ Standard_EXPORT static Standard_Integer NbSamplesV (const Handle(BRepAdaptor_Surface)& S);
- Standard_EXPORT static Standard_Integer NbSamplesU (const BRepAdaptor_Surface& S, const Standard_Real u1, const Standard_Real u2);
+ Standard_EXPORT static Standard_Integer NbSamplesU (const Handle(BRepAdaptor_Surface)& S, const Standard_Real u1, const Standard_Real u2);
- Standard_EXPORT static Standard_Integer NbSamplesV (const BRepAdaptor_Surface& S, const Standard_Real v1, const Standard_Real v2);
+ Standard_EXPORT static Standard_Integer NbSamplesV (const Handle(BRepAdaptor_Surface)& S, const Standard_Real v1, const Standard_Real v2);
#include <Adaptor3d_Surface.hxx>
#include <Adaptor3d_Curve.hxx>
-inline Standard_Real BRepApprox_SurfaceTool::FirstUParameter(const BRepAdaptor_Surface& Surf){ return Surf.FirstUParameter(); }
-inline Standard_Real BRepApprox_SurfaceTool::FirstVParameter(const BRepAdaptor_Surface& Surf){ return Surf.FirstVParameter();}
-inline Standard_Real BRepApprox_SurfaceTool::LastUParameter(const BRepAdaptor_Surface& Surf){ return Surf.LastUParameter();}
-inline Standard_Real BRepApprox_SurfaceTool::LastVParameter(const BRepAdaptor_Surface& Surf){ return Surf.LastVParameter();}
+inline Standard_Real BRepApprox_SurfaceTool::FirstUParameter(const Handle(BRepAdaptor_Surface)& Surf){ return Surf->FirstUParameter(); }
+inline Standard_Real BRepApprox_SurfaceTool::FirstVParameter(const Handle(BRepAdaptor_Surface)& Surf){ return Surf->FirstVParameter();}
+inline Standard_Real BRepApprox_SurfaceTool::LastUParameter(const Handle(BRepAdaptor_Surface)& Surf){ return Surf->LastUParameter();}
+inline Standard_Real BRepApprox_SurfaceTool::LastVParameter(const Handle(BRepAdaptor_Surface)& Surf){ return Surf->LastVParameter();}
-inline Standard_Integer BRepApprox_SurfaceTool::NbUIntervals(const BRepAdaptor_Surface& Surf,
+inline Standard_Integer BRepApprox_SurfaceTool::NbUIntervals(const Handle(BRepAdaptor_Surface)& Surf,
const GeomAbs_Shape S){
- return Surf.NbUIntervals(S);
+ return Surf->NbUIntervals(S);
}
-inline Standard_Integer BRepApprox_SurfaceTool::NbVIntervals(const BRepAdaptor_Surface& Surf,
+inline Standard_Integer BRepApprox_SurfaceTool::NbVIntervals(const Handle(BRepAdaptor_Surface)& Surf,
const GeomAbs_Shape S){
- return Surf.NbVIntervals(S);
+ return Surf->NbVIntervals(S);
}
-inline void BRepApprox_SurfaceTool::UIntervals(const BRepAdaptor_Surface& Surf,
+inline void BRepApprox_SurfaceTool::UIntervals(const Handle(BRepAdaptor_Surface)& Surf,
TColStd_Array1OfReal& Tab,
const GeomAbs_Shape S){
- Surf.UIntervals(Tab,S);
+ Surf->UIntervals(Tab,S);
}
-inline void BRepApprox_SurfaceTool::VIntervals(const BRepAdaptor_Surface& Surf,
+inline void BRepApprox_SurfaceTool::VIntervals(const Handle(BRepAdaptor_Surface)& Surf,
TColStd_Array1OfReal& Tab,
const GeomAbs_Shape S){
- Surf.VIntervals(Tab,S);
+ Surf->VIntervals(Tab,S);
}
-inline Handle(Adaptor3d_Surface) BRepApprox_SurfaceTool::UTrim(const BRepAdaptor_Surface& Surf,
+inline Handle(Adaptor3d_Surface) BRepApprox_SurfaceTool::UTrim(const Handle(BRepAdaptor_Surface)& Surf,
const Standard_Real F,
const Standard_Real L,
const Standard_Real Tol) {
- return Surf.UTrim(F,L,Tol);
+ return Surf->UTrim(F,L,Tol);
}
-inline Handle(Adaptor3d_Surface) BRepApprox_SurfaceTool::VTrim(const BRepAdaptor_Surface& Surf,
+inline Handle(Adaptor3d_Surface) BRepApprox_SurfaceTool::VTrim(const Handle(BRepAdaptor_Surface)& Surf,
const Standard_Real F,
const Standard_Real L,
const Standard_Real Tol) {
- return Surf.VTrim(F,L,Tol);
+ return Surf->VTrim(F,L,Tol);
}
-inline Standard_Boolean BRepApprox_SurfaceTool::IsUClosed(const BRepAdaptor_Surface& S)
+inline Standard_Boolean BRepApprox_SurfaceTool::IsUClosed(const Handle(BRepAdaptor_Surface)& S)
{
- return S.IsUClosed();
+ return S->IsUClosed();
}
-inline Standard_Boolean BRepApprox_SurfaceTool::IsVClosed(const BRepAdaptor_Surface& S)
+inline Standard_Boolean BRepApprox_SurfaceTool::IsVClosed(const Handle(BRepAdaptor_Surface)& S)
{
- return S.IsVClosed();
+ return S->IsVClosed();
}
-inline Standard_Boolean BRepApprox_SurfaceTool::IsUPeriodic(const BRepAdaptor_Surface& S)
+inline Standard_Boolean BRepApprox_SurfaceTool::IsUPeriodic(const Handle(BRepAdaptor_Surface)& S)
{
- return S.IsUPeriodic();
+ return S->IsUPeriodic();
}
-inline Standard_Real BRepApprox_SurfaceTool::UPeriod(const BRepAdaptor_Surface& S)
+inline Standard_Real BRepApprox_SurfaceTool::UPeriod(const Handle(BRepAdaptor_Surface)& S)
{
- return S.UPeriod();
+ return S->UPeriod();
}
-inline Standard_Boolean BRepApprox_SurfaceTool::IsVPeriodic(const BRepAdaptor_Surface& S)
+inline Standard_Boolean BRepApprox_SurfaceTool::IsVPeriodic(const Handle(BRepAdaptor_Surface)& S)
{
- return S.IsVPeriodic();
+ return S->IsVPeriodic();
}
-inline Standard_Real BRepApprox_SurfaceTool::VPeriod(const BRepAdaptor_Surface& S)
+inline Standard_Real BRepApprox_SurfaceTool::VPeriod(const Handle(BRepAdaptor_Surface)& S)
{
- return S.VPeriod();
+ return S->VPeriod();
}
-inline gp_Pnt BRepApprox_SurfaceTool::Value(const BRepAdaptor_Surface& S,
+inline gp_Pnt BRepApprox_SurfaceTool::Value(const Handle(BRepAdaptor_Surface)& S,
const Standard_Real U,
const Standard_Real V )
{
- return S.Value(U,V);
+ return S->Value(U,V);
}
-inline void BRepApprox_SurfaceTool::D0(const BRepAdaptor_Surface& S,
+inline void BRepApprox_SurfaceTool::D0(const Handle(BRepAdaptor_Surface)& S,
const Standard_Real U,
const Standard_Real V,
gp_Pnt& P)
{
- S.D0(U,V,P);
+ S->D0(U,V,P);
}
-inline void BRepApprox_SurfaceTool::D1(const BRepAdaptor_Surface& S,
+inline void BRepApprox_SurfaceTool::D1(const Handle(BRepAdaptor_Surface)& S,
const Standard_Real U,
const Standard_Real V,
gp_Pnt& P,
gp_Vec& D1U,
gp_Vec& D1V)
{
- S.D1(U,V,P,D1U,D1V);
+ S->D1(U,V,P,D1U,D1V);
}
-inline void BRepApprox_SurfaceTool::D2(const BRepAdaptor_Surface& S,
+inline void BRepApprox_SurfaceTool::D2(const Handle(BRepAdaptor_Surface)& S,
const Standard_Real U,
const Standard_Real V,
gp_Pnt& P,
gp_Vec& D2V,
gp_Vec& D2UV)
{
- S.D2(U,V,P,D1U,D1V,D2U,D2V,D2UV);
+ S->D2(U,V,P,D1U,D1V,D2U,D2V,D2UV);
}
-inline void BRepApprox_SurfaceTool::D3(const BRepAdaptor_Surface& S,
+inline void BRepApprox_SurfaceTool::D3(const Handle(BRepAdaptor_Surface)& S,
const Standard_Real U,
const Standard_Real V,
gp_Pnt& P,
gp_Vec& D3UUV,
gp_Vec& D3UVV)
{
- S.D3(U,V,P,D1U,D1V,D2U,D2V,D2UV,D3U,D3V,D3UUV,D3UVV);
+ S->D3(U,V,P,D1U,D1V,D2U,D2V,D2UV,D3U,D3V,D3UUV,D3UVV);
}
-inline gp_Vec BRepApprox_SurfaceTool::DN(const BRepAdaptor_Surface& S,
+inline gp_Vec BRepApprox_SurfaceTool::DN(const Handle(BRepAdaptor_Surface)& S,
const Standard_Real U,
const Standard_Real V,
const Standard_Integer Nu,
const Standard_Integer Nv)
{
- return S.DN(U,V,Nu,Nv);
+ return S->DN(U,V,Nu,Nv);
}
-inline Standard_Real BRepApprox_SurfaceTool::UResolution(const BRepAdaptor_Surface& S,
+inline Standard_Real BRepApprox_SurfaceTool::UResolution(const Handle(BRepAdaptor_Surface)& S,
const Standard_Real R3d)
{
- return S.UResolution(R3d);
+ return S->UResolution(R3d);
}
-inline Standard_Real BRepApprox_SurfaceTool::VResolution(const BRepAdaptor_Surface& S,
+inline Standard_Real BRepApprox_SurfaceTool::VResolution(const Handle(BRepAdaptor_Surface)& S,
const Standard_Real R3d)
{
- return S.VResolution(R3d);
+ return S->VResolution(R3d);
}
-inline GeomAbs_SurfaceType BRepApprox_SurfaceTool::GetType(const BRepAdaptor_Surface& S )
+inline GeomAbs_SurfaceType BRepApprox_SurfaceTool::GetType(const Handle(BRepAdaptor_Surface)& S )
{
- return S.GetType();
+ return S->GetType();
}
-inline gp_Pln BRepApprox_SurfaceTool::Plane(const BRepAdaptor_Surface& S)
+inline gp_Pln BRepApprox_SurfaceTool::Plane(const Handle(BRepAdaptor_Surface)& S)
{
- return S.Plane();
+ return S->Plane();
}
-inline gp_Cylinder BRepApprox_SurfaceTool::Cylinder(const BRepAdaptor_Surface& S)
+inline gp_Cylinder BRepApprox_SurfaceTool::Cylinder(const Handle(BRepAdaptor_Surface)& S)
{
- return S.Cylinder();
+ return S->Cylinder();
}
-inline gp_Cone BRepApprox_SurfaceTool::Cone(const BRepAdaptor_Surface& S)
+inline gp_Cone BRepApprox_SurfaceTool::Cone(const Handle(BRepAdaptor_Surface)& S)
{
- return S.Cone();
+ return S->Cone();
}
-inline gp_Sphere BRepApprox_SurfaceTool::Sphere(const BRepAdaptor_Surface& S)
+inline gp_Sphere BRepApprox_SurfaceTool::Sphere(const Handle(BRepAdaptor_Surface)& S)
{
- return S.Sphere();
+ return S->Sphere();
}
-inline gp_Torus BRepApprox_SurfaceTool::Torus(const BRepAdaptor_Surface& S)
+inline gp_Torus BRepApprox_SurfaceTool::Torus(const Handle(BRepAdaptor_Surface)& S)
{
- return S.Torus();
+ return S->Torus();
}
-inline Handle(Geom_BezierSurface) BRepApprox_SurfaceTool::Bezier(const BRepAdaptor_Surface& S) {
- return(S.Bezier());
+inline Handle(Geom_BezierSurface) BRepApprox_SurfaceTool::Bezier(const Handle(BRepAdaptor_Surface)& S) {
+ return(S->Bezier());
}
-inline Handle(Geom_BSplineSurface) BRepApprox_SurfaceTool::BSpline(const BRepAdaptor_Surface& S) {
- return(S.BSpline());
+inline Handle(Geom_BSplineSurface) BRepApprox_SurfaceTool::BSpline(const Handle(BRepAdaptor_Surface)& S) {
+ return(S->BSpline());
}
-inline gp_Ax1 BRepApprox_SurfaceTool::AxeOfRevolution(const BRepAdaptor_Surface& S) {
- return(S.AxeOfRevolution());
+inline gp_Ax1 BRepApprox_SurfaceTool::AxeOfRevolution(const Handle(BRepAdaptor_Surface)& S) {
+ return(S->AxeOfRevolution());
}
-inline gp_Dir BRepApprox_SurfaceTool::Direction(const BRepAdaptor_Surface& S) {
- return(S.Direction());
+inline gp_Dir BRepApprox_SurfaceTool::Direction(const Handle(BRepAdaptor_Surface)& S) {
+ return(S->Direction());
}
-inline Handle(Adaptor3d_Curve) BRepApprox_SurfaceTool::BasisCurve(const BRepAdaptor_Surface& S) {
- return(S.BasisCurve());
+inline Handle(Adaptor3d_Curve) BRepApprox_SurfaceTool::BasisCurve(const Handle(BRepAdaptor_Surface)& S) {
+ return(S->BasisCurve());
}
DEFINE_STANDARD_ALLOC
- Standard_EXPORT BRepApprox_TheFunctionOfTheInt2SOfThePrmPrmSvSurfacesOfApprox(const BRepAdaptor_Surface& S1, const BRepAdaptor_Surface& S2);
+ Standard_EXPORT BRepApprox_TheFunctionOfTheInt2SOfThePrmPrmSvSurfacesOfApprox(const Handle(BRepAdaptor_Surface)& S1, const Handle(BRepAdaptor_Surface)& S2);
Standard_EXPORT Standard_Integer NbVariables() const;
gp_Dir2d DirectionOnS2() const;
- const BRepAdaptor_Surface& AuxillarSurface1() const;
+ const Handle(BRepAdaptor_Surface) AuxillarSurface1() const;
- const BRepAdaptor_Surface& AuxillarSurface2() const;
+ const Handle(BRepAdaptor_Surface) AuxillarSurface2() const;
};
-#define ThePSurface BRepAdaptor_Surface
+#define ThePSurface Handle(BRepAdaptor_Surface)
#define ThePSurface_hxx <BRepAdaptor_Surface.hxx>
#define ThePSurfaceTool BRepApprox_SurfaceTool
#define ThePSurfaceTool_hxx <BRepApprox_SurfaceTool.hxx>
#include <math_Matrix.hxx>
-#define ThePSurface BRepAdaptor_Surface
+#define ThePSurface Handle(BRepAdaptor_Surface)
#define ThePSurface_hxx <BRepAdaptor_Surface.hxx>
#define ThePSurfaceTool BRepApprox_SurfaceTool
#define ThePSurfaceTool_hxx <BRepApprox_SurfaceTool.hxx>
DEFINE_STANDARD_ALLOC
- Standard_EXPORT BRepApprox_TheImpPrmSvSurfacesOfApprox(const BRepAdaptor_Surface& Surf1, const IntSurf_Quadric& Surf2);
+ Standard_EXPORT BRepApprox_TheImpPrmSvSurfacesOfApprox(const Handle(BRepAdaptor_Surface)& Surf1, const IntSurf_Quadric& Surf2);
- Standard_EXPORT BRepApprox_TheImpPrmSvSurfacesOfApprox(const IntSurf_Quadric& Surf1, const BRepAdaptor_Surface& Surf2);
+ Standard_EXPORT BRepApprox_TheImpPrmSvSurfacesOfApprox(const IntSurf_Quadric& Surf1, const Handle(BRepAdaptor_Surface)& Surf2);
//! returns True if Tg,Tguv1 Tguv2 can be computed.
Standard_EXPORT Standard_Boolean Compute (Standard_Real& u1, Standard_Real& v1, Standard_Real& u2, Standard_Real& v2,
#include <gp_Vec2d.hxx>
-#define ThePSurface BRepAdaptor_Surface
+#define ThePSurface Handle(BRepAdaptor_Surface)
#define ThePSurface_hxx <BRepAdaptor_Surface.hxx>
#define ThePSurfaceTool BRepApprox_SurfaceTool
#define ThePSurfaceTool_hxx <BRepApprox_SurfaceTool.hxx>
DEFINE_STANDARD_ALLOC
//! compute the solution point with the close point
- Standard_EXPORT BRepApprox_TheInt2SOfThePrmPrmSvSurfacesOfApprox(const TColStd_Array1OfReal& Param, const BRepAdaptor_Surface& S1, const BRepAdaptor_Surface& S2, const Standard_Real TolTangency);
+ Standard_EXPORT BRepApprox_TheInt2SOfThePrmPrmSvSurfacesOfApprox(const TColStd_Array1OfReal& Param, const Handle(BRepAdaptor_Surface)& S1, const Handle(BRepAdaptor_Surface)& S2, const Standard_Real TolTangency);
//! initialize the parameters to compute the solution point
//! it 's possible to write to optimize:
//! param(3)=...
//! inter.Perform(Param,rsnld);
//! }
- Standard_EXPORT BRepApprox_TheInt2SOfThePrmPrmSvSurfacesOfApprox(const BRepAdaptor_Surface& S1, const BRepAdaptor_Surface& S2, const Standard_Real TolTangency);
+ Standard_EXPORT BRepApprox_TheInt2SOfThePrmPrmSvSurfacesOfApprox(const Handle(BRepAdaptor_Surface)& S1, const Handle(BRepAdaptor_Surface)& S2, const Standard_Real TolTangency);
//! returns the best constant isoparametric to find
//! the next intersection's point +stores the solution
#include <gp_Dir2d.hxx>
-#define ThePSurface BRepAdaptor_Surface
+#define ThePSurface Handle(BRepAdaptor_Surface)
#define ThePSurface_hxx <BRepAdaptor_Surface.hxx>
#define ThePSurfaceTool BRepApprox_SurfaceTool
#define ThePSurfaceTool_hxx <BRepApprox_SurfaceTool.hxx>
DEFINE_STANDARD_ALLOC
- Standard_EXPORT BRepApprox_ThePrmPrmSvSurfacesOfApprox(const BRepAdaptor_Surface& Surf1, const BRepAdaptor_Surface& Surf2);
+ Standard_EXPORT BRepApprox_ThePrmPrmSvSurfacesOfApprox(const Handle(BRepAdaptor_Surface)& Surf1, const Handle(BRepAdaptor_Surface)& Surf2);
//! returns True if Tg,Tguv1 Tguv2 can be computed.
Standard_EXPORT Standard_Boolean Compute (Standard_Real& u1, Standard_Real& v1, Standard_Real& u2, Standard_Real& v2,
#include <gp_Vec2d.hxx>
-#define ThePSurface BRepAdaptor_Surface
+#define ThePSurface Handle(BRepAdaptor_Surface)
#define ThePSurface_hxx <BRepAdaptor_Surface.hxx>
#define ThePSurfaceTool BRepApprox_SurfaceTool
#define ThePSurfaceTool_hxx <BRepApprox_SurfaceTool.hxx>
Standard_EXPORT BRepApprox_TheZerImpFuncOfTheImpPrmSvSurfacesOfApprox();
- Standard_EXPORT BRepApprox_TheZerImpFuncOfTheImpPrmSvSurfacesOfApprox(const BRepAdaptor_Surface& PS, const IntSurf_Quadric& IS);
+ Standard_EXPORT BRepApprox_TheZerImpFuncOfTheImpPrmSvSurfacesOfApprox(const Handle(BRepAdaptor_Surface)& PS, const IntSurf_Quadric& IS);
Standard_EXPORT BRepApprox_TheZerImpFuncOfTheImpPrmSvSurfacesOfApprox(const IntSurf_Quadric& IS);
- void Set (const BRepAdaptor_Surface& PS);
+ void Set (const Handle(BRepAdaptor_Surface)& PS);
void SetImplicitSurface (const IntSurf_Quadric& IS);
const gp_Dir2d& Direction2d();
- const BRepAdaptor_Surface& PSurface() const;
+ const Handle(BRepAdaptor_Surface) PSurface() const;
const IntSurf_Quadric& ISurface() const;
};
-#define ThePSurface BRepAdaptor_Surface
+#define ThePSurface Handle(BRepAdaptor_Surface)
#define ThePSurface_hxx <BRepAdaptor_Surface.hxx>
#define ThePSurfaceTool BRepApprox_SurfaceTool
#define ThePSurfaceTool_hxx <BRepApprox_SurfaceTool.hxx>
#include <gp_Dir2d.hxx>
-#define ThePSurface BRepAdaptor_Surface
+#define ThePSurface Handle(BRepAdaptor_Surface)
#define ThePSurface_hxx <BRepAdaptor_Surface.hxx>
#define ThePSurfaceTool BRepApprox_SurfaceTool
#define ThePSurfaceTool_hxx <BRepApprox_SurfaceTool.hxx>
const Standard_Real epsX = 1.e-8;
const Standard_Integer Nbu = 20;
const Standard_Real Tol = 1.e-5;
- Extrema_EPCOfExtPC2d extrema(P, *C, Nbu, epsX, Tol);
+ Extrema_EPCOfExtPC2d extrema(P, C, Nbu, epsX, Tol);
if (!extrema.IsDone())
return Standard_True;
gp_Dir2d d(v);
Handle(Geom2d_Line) bid = new Geom2d_Line(P1,d);
- Geom2dAdaptor_Curve seg(bid,-0.01*mag,1.01*mag);
+ Handle(Geom2dAdaptor_Curve) seg = new Geom2dAdaptor_Curve(bid,-0.01*mag,1.01*mag);
- Geom2dInt_GInter inter (seg, *C, Tol, Tol);
+ Geom2dInt_GInter inter (seg, C, Tol, Tol);
if (!inter.IsDone())
return Standard_False;
#include <Extrema_ExtSS.hxx>
#include <GeomAdaptor_Surface.hxx>
//
-static Standard_Boolean CanUseEdges(const Adaptor3d_Surface& BS);
+static Standard_Boolean CanUseEdges(const Handle(Adaptor3d_Surface)& BS);
//
static void FindExactUVBounds(const TopoDS_Face F,
Standard_Real& umin, Standard_Real& umax,
const Standard_Real Tol,
Standard_Boolean& isNaturalRestriction);
//
-static void AdjustFaceBox(const BRepAdaptor_Surface& BS,
+static void AdjustFaceBox(const Handle(BRepAdaptor_Surface)& BS,
const Standard_Real umin, const Standard_Real umax,
const Standard_Real vmin, const Standard_Real vmax,
Bnd_Box& FaceBox,
const Bnd_Box& EdgeBox, const Standard_Real Tol);
//
-static Standard_Boolean IsModifySize(const BRepAdaptor_Surface& theBS,
+static Standard_Boolean IsModifySize(const Handle(BRepAdaptor_Surface)& theBS,
const gp_Pln& thePln, const gp_Pnt& theP,
const Standard_Real umin, const Standard_Real umax,
const Standard_Real vmin, const Standard_Real vmax,
TopExp_Explorer ex;
// Add the faces
- BRepAdaptor_Surface BS;
+ Handle(BRepAdaptor_Surface) BS = new BRepAdaptor_Surface();
TopLoc_Location l, aDummyLoc;
Standard_Integer i, nbNodes;
- BRepAdaptor_Curve BC;
+ Handle(BRepAdaptor_Curve) BC = new BRepAdaptor_Curve();
for (ex.Init(S,TopAbs_FACE); ex.More(); ex.Next()) {
const TopoDS_Face& F = TopoDS::Face(ex.Current());
} else
{
if (!GS.IsNull()) {
- BS.Initialize(F, Standard_False);
- if (BS.GetType() != GeomAbs_Plane) {
- BS.Initialize(F);
+ BS->Initialize(F, Standard_False);
+ if (BS->GetType() != GeomAbs_Plane) {
+ BS->Initialize(F);
BndLib_AddSurface::Add(BS, BRep_Tool::Tolerance(F), B);
}
else {
// on travaille directement sur les courbes 3d.
TopExp_Explorer ex2(F, TopAbs_EDGE);
if (!ex2.More()) {
- BS.Initialize(F);
+ BS->Initialize(F);
BndLib_AddSurface::Add(BS, BRep_Tool::Tolerance(F), B);
}
else {
const TopoDS_Edge& anEdge = TopoDS::Edge(ex2.Current());
if (BRep_Tool::IsGeometric (anEdge))
{
- BC.Initialize (anEdge);
+ BC->Initialize (anEdge);
BndLib_Add3dCurve::Add (BC, BRep_Tool::Tolerance (anEdge), B);
}
}
else {
if (BRep_Tool::IsGeometric(E))
{
- BC.Initialize(E);
+ BC->Initialize(E);
BndLib_Add3dCurve::Add(BC, BRep_Tool::Tolerance(E), B);
}
}
// Add the edges
- BRepAdaptor_Curve BC;
+ Handle(BRepAdaptor_Curve) BC = new BRepAdaptor_Curve();
for (ex.Init(S,TopAbs_EDGE); ex.More(); ex.Next()) {
const TopoDS_Edge& anEdge = TopoDS::Edge (ex.Current());
if (BRep_Tool::IsGeometric (anEdge))
{
- BC.Initialize (anEdge);
+ BC->Initialize (anEdge);
BndLib_Add3dCurve::Add(BC,0.,B);
}
}
TopExp_Explorer ex;
// Add the faces
- BRepAdaptor_Surface BS;
+ Handle(BRepAdaptor_Surface) BS = new BRepAdaptor_Surface();
Handle(Poly_Triangulation) T;
TopLoc_Location l;
Standard_Integer i, nbNodes;
- BRepAdaptor_Curve BC;
+ Handle(BRepAdaptor_Curve) BC = new BRepAdaptor_Curve();
for (ex.Init(S,TopAbs_FACE); ex.More(); ex.Next()) {
const TopoDS_Face& F = TopoDS::Face(ex.Current());
{
const Handle(Geom_Surface)& GS = BRep_Tool::Surface(F, l);
if (!GS.IsNull()) {
- BS.Initialize(F, Standard_False);
+ BS->Initialize(F, Standard_False);
if (CanUseEdges(BS)) {
TopExp_Explorer ex2(F, TopAbs_EDGE);
if (!ex2.More()) {
- BS.Initialize(F);
+ BS->Initialize(F);
Standard_Real Tol = useShapeTolerance? BRep_Tool::Tolerance(F) : 0.;
BndLib_AddSurface::AddOptimal(BS, Tol, aLocBox);
}
{
continue;
}
- BC.Initialize(anE);
+ BC->Initialize(anE);
Tol = useShapeTolerance? BRep_Tool::Tolerance(anE) : 0.;
BndLib_Add3dCurve::AddOptimal(BC, Tol, anEBox);
aLocBox.Add(anEBox);
{
continue;
}
- BC.Initialize(anE);
+ BC->Initialize(anE);
Tol = useShapeTolerance? BRep_Tool::Tolerance(anE) : 0.;
BndLib_Add3dCurve::AddOptimal(BC, Tol, anEBox);
EBox.Add(anEBox);
else {
if (BRep_Tool::IsGeometric(E))
{
- BC.Initialize(E);
+ BC->Initialize(E);
Standard_Real Tol = useShapeTolerance? BRep_Tool::Tolerance(E) : 0.;
BndLib_Add3dCurve::AddOptimal(BC, Tol, aLocBox);
}
//purpose : Define is it possible using only edges bnd boxes
// to get face bnd box
//=======================================================================
-Standard_Boolean CanUseEdges(const Adaptor3d_Surface& BS)
+Standard_Boolean CanUseEdges(const Handle(Adaptor3d_Surface)& BS)
{
- GeomAbs_SurfaceType aST = BS.GetType();
+ GeomAbs_SurfaceType aST = BS->GetType();
if(aST == GeomAbs_Plane ||
aST == GeomAbs_Cylinder ||
aST == GeomAbs_Cone ||
}
else if(aST == GeomAbs_SurfaceOfRevolution)
{
- const Handle(Adaptor3d_Curve)& aBC = BS.BasisCurve();
+ const Handle(Adaptor3d_Curve)& aBC = BS->BasisCurve();
if(aBC->GetType() == GeomAbs_Line)
{
return Standard_True;
}
else if(aST == GeomAbs_OffsetSurface)
{
- const Handle(Adaptor3d_Surface)& aS = BS.BasisSurface();
- return CanUseEdges (*aS);
+ const Handle(Adaptor3d_Surface)& aS = BS->BasisSurface();
+ return CanUseEdges (aS);
}
else if(aST == GeomAbs_BSplineSurface)
{
- Handle(Geom_BSplineSurface) aBSpl = BS.BSpline();
+ Handle(Geom_BSplineSurface) aBSpl = BS->BSpline();
if((aBSpl->UDegree() == 1 && aBSpl->NbUKnots() == 2) ||
(aBSpl->VDegree() == 1 && aBSpl->NbVKnots() == 2))
{
}
else if(aST == GeomAbs_BezierSurface)
{
- Handle(Geom_BezierSurface) aBz = BS.Bezier();
+ Handle(Geom_BezierSurface) aBz = BS->Bezier();
if((aBz->UDegree() == 1 ) ||
(aBz->VDegree() == 1 ))
{
//function : IsModifySize
//purpose :
//=======================================================================
-Standard_Boolean IsModifySize(const BRepAdaptor_Surface& theBS,
+Standard_Boolean IsModifySize(const Handle(BRepAdaptor_Surface)& theBS,
const gp_Pln& thePln, const gp_Pnt& theP,
const Standard_Real umin, const Standard_Real umax,
const Standard_Real vmin, const Standard_Real vmax,
Reorder(pu1, pu2);
Reorder(pv1, pv2);
Handle(Geom_Plane) aPlane = new Geom_Plane(thePln);
- GeomAdaptor_Surface aGAPln(aPlane, pu1, pu2, pv1, pv2);
+ Handle(GeomAdaptor_Surface) aGAPln = new GeomAdaptor_Surface(aPlane, pu1, pu2, pv1, pv2);
Extrema_ExtSS anExtr(aGAPln, theBS, pu1, pu2, pv1, pv2, umin, umax, vmin, vmax, theTolU, theTolV);
if(anExtr.IsDone())
{
//function : AdjustFaceBox
//purpose :
//=======================================================================
-void AdjustFaceBox(const BRepAdaptor_Surface& BS,
+void AdjustFaceBox(const Handle(BRepAdaptor_Surface)& BS,
const Standard_Real umin, const Standard_Real umax,
const Standard_Real vmin, const Standard_Real vmax,
Bnd_Box& FaceBox,
FaceBox.Get(fxmin, fymin, fzmin, fxmax, fymax, fzmax);
EdgeBox.Get(exmin, eymin, ezmin, exmax, eymax, ezmax);
//
- Standard_Real TolU = Max(BS.UResolution(Tol), Precision::PConfusion());
- Standard_Real TolV = Max(BS.VResolution(Tol), Precision::PConfusion());
- BRepTopAdaptor_FClass2d FClass(BS.Face(), Max(TolU, TolV));
+ Standard_Real TolU = Max(BS->UResolution(Tol), Precision::PConfusion());
+ Standard_Real TolV = Max(BS->VResolution(Tol), Precision::PConfusion());
+ BRepTopAdaptor_FClass2d FClass(BS->Face(), Max(TolU, TolV));
//
Standard_Boolean isModified = Standard_False;
if(exmin > fxmin)
// Function : IsLinear
// purpose : Returns TRUE if theC is line-like.
//=======================================================================
-static Standard_Boolean IsLinear(const Adaptor3d_Curve& theC)
+static Standard_Boolean IsLinear(const Handle(Adaptor3d_Curve)& theC)
{
- const GeomAbs_CurveType aCT = theC.GetType();
+ const GeomAbs_CurveType aCT = theC->GetType();
if(aCT == GeomAbs_OffsetCurve)
{
- return IsLinear(GeomAdaptor_Curve(theC.OffsetCurve()->BasisCurve()));
+ return IsLinear(new GeomAdaptor_Curve(theC->OffsetCurve()->BasisCurve()));
}
if((aCT == GeomAbs_BSplineCurve) || (aCT == GeomAbs_BezierCurve))
// represented with set of points. It will be possible made
// in the future.
- return ((theC.Degree() == 1) &&
- (theC.Continuity() != GeomAbs_C0));
+ return ((theC->Degree() == 1) &&
+ (theC->Continuity() != GeomAbs_C0));
}
if(aCT == GeomAbs_Line)
// Function : IsPlanar
// purpose : Returns TRUE if theS is plane-like.
//=======================================================================
-static Standard_Boolean IsPlanar(const Adaptor3d_Surface& theS)
+static Standard_Boolean IsPlanar(const Handle(Adaptor3d_Surface)& theS)
{
- const GeomAbs_SurfaceType aST = theS.GetType();
+ const GeomAbs_SurfaceType aST = theS->GetType();
if(aST == GeomAbs_OffsetSurface)
{
- return IsPlanar (*theS.BasisSurface());
+ return IsPlanar (theS->BasisSurface());
}
if(aST == GeomAbs_SurfaceOfExtrusion)
{
- return IsLinear (*theS.BasisCurve());
+ return IsLinear (theS->BasisCurve());
}
if((aST == GeomAbs_BSplineSurface) || (aST == GeomAbs_BezierSurface))
{
- if((theS.UDegree() != 1) || (theS.VDegree() != 1))
+ if((theS->UDegree() != 1) || (theS->VDegree() != 1))
return Standard_False;
// Indeed, surfaces with C0-continuity and degree==1, may be
// represented with set of points. It will be possible made
// in the future.
- return ((theS.UContinuity() != GeomAbs_C0) && (theS.VContinuity() != GeomAbs_C0));
+ return ((theS->UContinuity() != GeomAbs_C0) && (theS->VContinuity() != GeomAbs_C0));
}
if(aST == GeomAbs_Plane)
const TopoDS_Edge &anE = TopoDS::Edge(anExpE.Current());
if (BRep_Tool::IsGeometric (anE))
{
- const BRepAdaptor_Curve anAC(anE);
+ Handle(BRepAdaptor_Curve) anAC = new BRepAdaptor_Curve(anE);
if (!IsLinear(anAC))
{
if (!theIsTriangulationUsed)
const TopoDS_Edge &anE = TopoDS::Edge(anExpE.Current());
if (BRep_Tool::IsGeometric (anE))
{
- const BRepAdaptor_Curve anAC(anE);
+ Handle(BRepAdaptor_Curve) anAC = new BRepAdaptor_Curve(anE);
if (IsLinear(anAC))
{
// skip linear edge as its vertices have already been added
Standard_Real first,last;
Handle(Geom_Curve) c3d = BRep_Tool::Curve(TopoDS::Edge(aedge), first, last);
if (!c3d.IsNull()) {
- GeomAdaptor_Curve cAdapt(c3d);
+ Handle(GeomAdaptor_Curve) cAdapt = new GeomAdaptor_Curve(c3d);
Standard_Real length = GCPnts_AbscissaPoint::Length(cAdapt, first, last);
TotLength += length;
if (ve2.IsSame(v1) || ve2.IsSame(v2)) break;
return Standard_False;
Standard_Real first, last;
Handle(Geom_Curve) c3d = BRep_Tool::Curve(theEdge,first, last);
- GeomAdaptor_Curve GAC(c3d);
+ Handle(GeomAdaptor_Curve) GAC = new GeomAdaptor_Curve(c3d);
Extrema_ExtPC locProj;
locProj.Initialize(GAC, first, last);
- gp_Pnt pfirst = GAC.Value(first), plast = GAC.Value(last);
+ gp_Pnt pfirst = GAC->Value(first), plast = GAC->Value(last);
for (Standard_Integer i = 1; i <= nbV; i++) {
// Take the longest edge as first
Standard_Real f, l;
Handle(Geom_Curve) c3d1 = BRep_Tool::Curve(TopoDS::Edge(edgeFirst), f, l);
- GeomAdaptor_Curve cAdapt1(c3d1);
+ Handle(GeomAdaptor_Curve) cAdapt1 = new GeomAdaptor_Curve(c3d1);
Standard_Real len1 = GCPnts_AbscissaPoint::Length(cAdapt1, f, l);
Handle(Geom_Curve) c3d2 = BRep_Tool::Curve(TopoDS::Edge(edgeLast), f, l);
- GeomAdaptor_Curve cAdapt2(c3d2);
+ Handle(GeomAdaptor_Curve) cAdapt2 = new GeomAdaptor_Curve(c3d2);
Standard_Real len2 = GCPnts_AbscissaPoint::Length(cAdapt2, f, l);
if (len1 < len2) {
edge1 = edgeLast;
c3d->Transform(loc.Transformation());
}
- GeomAdaptor_Curve adapt(c3d);
+ Handle(GeomAdaptor_Curve) adapt = new GeomAdaptor_Curve(c3d);
GCPnts_UniformAbscissa uniAbs(adapt, npt, first, last);
Standard_Real cumulateAngular = 0.0;
Standard_Real C2Umin, C2Vmin, C2Umax, C2Vmax;
{ //szv: Use brackets to destroy local variables
Bnd_Box2d B1, B2;
- Geom2dAdaptor_Curve aC2d1(C2d1), aC2d2(C2d2);
+ Handle(Geom2dAdaptor_Curve) aC2d1 = new Geom2dAdaptor_Curve(C2d1);
+ Handle(Geom2dAdaptor_Curve) aC2d2 = new Geom2dAdaptor_Curve(C2d2);
BndLib_Add2dCurve::Add(aC2d1,first2d1,last2d1,Precision::PConfusion(),B1);
BndLib_Add2dCurve::Add(aC2d2,first2d2,last2d2,Precision::PConfusion(),B2);
B1.Get(C1Umin,C1Vmin,C1Umax,C1Vmax);
for (i = 1; i <= nbSection; i++) {
Standard_Real f, l;
Handle(Geom_Curve) c3d = BRep_Tool::Curve(TopoDS::Edge(seqEdges(i)), f, l);
- GeomAdaptor_Curve cAdapt(c3d);
+ Handle(GeomAdaptor_Curve) cAdapt = new GeomAdaptor_Curve(c3d);
Standard_Real len = GCPnts_AbscissaPoint::Length(cAdapt, f, l);
if (len > lenRef) { indRef = i; lenRef = len; }
}
{ //szv: Use brackets to destroy local variables
// Create bounding box around curve
Bnd_Box aGlobalBox;
- GeomAdaptor_Curve adptC(c3d,first,last);
+ Handle(GeomAdaptor_Curve) adptC = new GeomAdaptor_Curve(c3d,first,last);
BndLib_Add3dCurve::Add(adptC,myTolerance,aGlobalBox);
// Sort vertices to find candidates
aSelector.SetCurrent (aGlobalBox);
length = pfirst.Distance(plast);
}
else {
- GeomAdaptor_Curve cAdapt(c3d);
+ Handle(GeomAdaptor_Curve) cAdapt = new GeomAdaptor_Curve(c3d);
length = GCPnts_AbscissaPoint::Length(cAdapt, first, last);
}
Standard_Real tole = BRep_Tool::Tolerance(Ve1)+BRep_Tool::Tolerance(Ve2);
{
arrDist.Init(-1.0);
- GeomAdaptor_Curve GAC(c3d);
+ Handle(GeomAdaptor_Curve) GAC = new GeomAdaptor_Curve(c3d);
Extrema_ExtPC locProj;
locProj.Initialize(GAC, first, last);
- gp_Pnt pfirst = GAC.Value(first), plast = GAC.Value(last);
+ gp_Pnt pfirst = GAC->Value(first), plast = GAC->Value(last);
Standard_Integer find = 1;//(isConsiderEnds ? 1 : 2);
Standard_Integer lind = arrPnt.Length();//(isConsiderEnds ? arrPnt.Length() : arrPnt.Length() -1);
isProjected = Standard_True;
Extrema_POnCurv pOnC = locProj.Point(indMin);
Standard_Real paramProj = pOnC.Parameter();
- gp_Pnt ptProj = GAC.Value(paramProj);
+ gp_Pnt ptProj = GAC->Value(paramProj);
Standard_Real distProj2 = ptProj.SquareDistance(pt);
if (!locProj.IsMin(indMin)) {
if (Min(distF2,distL2) < dist2Min) {
//function : PrecCurve
//purpose :
//=======================================================================
-Standard_Real BRepCheck::PrecCurve(const Adaptor3d_Curve& aAC3D)
+Standard_Real BRepCheck::PrecCurve(const Handle(Adaptor3d_Curve)& aAC3D)
{
Standard_Real aXEmax = RealEpsilon();
//
- GeomAbs_CurveType aCT = aAC3D.GetType();
+ GeomAbs_CurveType aCT = aAC3D->GetType();
if (aCT==GeomAbs_Ellipse) {
Standard_Real aX[5];
//
- gp_Elips aEL3D=aAC3D.Ellipse();
+ gp_Elips aEL3D=aAC3D->Ellipse();
aEL3D.Location().Coord(aX[0], aX[1], aX[2]);
aX[3]=aEL3D.MajorRadius();
aX[4]=aEL3D.MinorRadius();
Standard_EXPORT static Standard_Boolean SelfIntersection (const TopoDS_Wire& W, const TopoDS_Face& F, TopoDS_Edge& E1, TopoDS_Edge& E2);
//! Returns the resolution on the 3d curve
- Standard_EXPORT static Standard_Real PrecCurve(const Adaptor3d_Curve& aAC3D);
+ Standard_EXPORT static Standard_Real PrecCurve(const Handle(Adaptor3d_Curve)& aAC3D);
//! Returns the resolution on the surface
Standard_EXPORT static Standard_Real PrecSurface(const Handle(Adaptor3d_Surface)& aAHSurf);
Handle(GeomAdaptor_Curve) aHCurve =
new GeomAdaptor_Curve(ProjOnPlane);
- ProjLib_ProjectedCurve proj(GAHS,aHCurve);
+ Handle(ProjLib_ProjectedCurve) proj = new ProjLib_ProjectedCurve(GAHS,aHCurve);
Handle(Geom2d_Curve) PC = Geom2dAdaptor::MakeCurve(proj);
Handle(Geom2dAdaptor_Curve) GHPC =
new Geom2dAdaptor_Curve(PC,
exp1.Next();
}
- Geom2dAdaptor_Curve aC;
+ Handle(Geom2dAdaptor_Curve) aC = new Geom2dAdaptor_Curve();
Standard_Real aFirst, aLast;
DataMapOfShapeBox2d aMapShapeBox2d;
for (exp1.Init (myShape, TopAbs_WIRE); exp1.More(); exp1.Next())
for (exp2.Init (aWire, TopAbs_EDGE); exp2.More(); exp2.Next())
{
const TopoDS_Edge& anEdge = TopoDS::Edge (exp2.Current());
- aC.Load (BRep_Tool::CurveOnSurface (anEdge, TopoDS::Face (myShape), aFirst, aLast));
+ aC->Load (BRep_Tool::CurveOnSurface (anEdge, TopoDS::Face (myShape), aFirst, aLast));
// To avoid exception in Segment if C1 is BSpline
- if (aC.FirstParameter() > aFirst)
+ if (aC->FirstParameter() > aFirst)
{
- aFirst = aC.FirstParameter();
+ aFirst = aC->FirstParameter();
}
- if (aC.LastParameter() < aLast)
+ if (aC->LastParameter() < aLast)
{
- aLast = aC.LastParameter();
+ aLast = aC->LastParameter();
}
Bnd_Box2d aBoxE;
BndLib_Add2dCurve::Add (aC, aFirst, aLast, 0., aBoxE);
PntSeq.Append( P );
}
- Geom2dAdaptor_Curve C1,C2;
+ Handle(Geom2dAdaptor_Curve) C1 = new Geom2dAdaptor_Curve();
+ Handle(Geom2dAdaptor_Curve) C2 = new Geom2dAdaptor_Curve();
gp_Pnt2d pfirst1,plast1,pfirst2,plast2;
Standard_Real first1,last1,first2,last2;
Geom2dInt_GInter Inter;
{
const TopoDS_Edge& edg1 = TopoDS::Edge(exp1.Current());
// cur1.Initialize(edg1,F);
- C1.Load( BRep_Tool::CurveOnSurface(edg1,F,first1,last1) );
+ C1->Load( BRep_Tool::CurveOnSurface(edg1,F,first1,last1) );
// To avoid exception in Segment if C1 is BSpline - IFV
- if(C1.FirstParameter() > first1) first1 = C1.FirstParameter();
- if(C1.LastParameter() < last1 ) last1 = C1.LastParameter();
+ if(C1->FirstParameter() > first1) first1 = C1->FirstParameter();
+ if(C1->LastParameter() < last1 ) last1 = C1->LastParameter();
Box1.SetVoid();
if (theMapEdgeBox.IsBound (edg1))
if (!edg1.IsSame(edg2))
{
//cur2.Initialize(edg2,F);
- C2.Load( BRep_Tool::CurveOnSurface(edg2,F,first2,last2) );
+ C2->Load( BRep_Tool::CurveOnSurface(edg2,F,first2,last2) );
// To avoid exception in Segment if C2 is BSpline - IFV
- if(C2.FirstParameter() > first2) first2 = C2.FirstParameter();
- if(C2.LastParameter() < last2 ) last2 = C2.LastParameter();
+ if(C2->FirstParameter() > first2) first2 = C2->FirstParameter();
+ if(C2->LastParameter() < last2 ) last2 = C2->LastParameter();
Box2.SetVoid();
if (theMapEdgeBox.IsBound (edg2))
}
static
- void CurveDirForParameter(const Geom2dAdaptor_Curve& aC2d,
+ void CurveDirForParameter(const Handle(Geom2dAdaptor_Curve)& aC2d,
const Standard_Real aPrm,
gp_Pnt2d& Pnt,
gp_Vec2d& aVec2d);
//purpose :
//=======================================================================
static
-Standard_Boolean IsDistanceIn2DTolerance (const BRepAdaptor_Surface& aFaceSurface,
+Standard_Boolean IsDistanceIn2DTolerance (const Handle(BRepAdaptor_Surface)& aFaceSurface,
const gp_Pnt2d& thePnt,
const gp_Pnt2d& thePntRef,
const Standard_Real aTol3d,
const Standard_Boolean = Standard_True)
#endif
{
- Standard_Real dumax = 0.01 * (aFaceSurface.LastUParameter() - aFaceSurface.FirstUParameter());
- Standard_Real dvmax = 0.01 * (aFaceSurface.LastVParameter() - aFaceSurface.FirstVParameter());
+ Standard_Real dumax = 0.01 * (aFaceSurface->LastUParameter() - aFaceSurface->FirstUParameter());
+ Standard_Real dvmax = 0.01 * (aFaceSurface->LastVParameter() - aFaceSurface->FirstVParameter());
Standard_Real dumin = Abs(thePnt.X() - thePntRef.X());
Standard_Real dvmin = Abs(thePnt.Y() - thePntRef.Y());
std::cout << "; VLast = " << aFaceSurface.LastVParameter() << std::endl;
}
#endif
- dumax = aFaceSurface.UResolution(aTol3d);
- dvmax = aFaceSurface.VResolution(aTol3d);
+ dumax = aFaceSurface->UResolution(aTol3d);
+ dvmax = aFaceSurface->VResolution(aTol3d);
gp_Pnt aP;
gp_Vec aDU, aDV;
Standard_Real um = (thePnt.X() + thePntRef.X()) / 2.;
Standard_Real vm = (thePnt.Y() + thePntRef.Y()) / 2.;
- aFaceSurface.D1(um, vm, aP, aDU, aDV);
+ aFaceSurface->D1(um, vm, aP, aDU, aDV);
Standard_Real aMDU = aDU.Magnitude();
if (aMDU > Precision::Confusion())
{
// 20/03/02 akm vvv : (OCC234) Hence this method will be used to check
// both periodic and non-periodic faces
// // this check is for periodic faces
- BRepAdaptor_Surface aFaceSurface (theFace, Standard_False);
+ Handle(BRepAdaptor_Surface) aFaceSurface = new BRepAdaptor_Surface(theFace, Standard_False);
// if (!aFaceSurface.IsUPeriodic() && !aFaceSurface.IsVPeriodic())
// {
// if (Update)
gp_Pnt2d pfirst1,plast1,pfirst2,plast2;
gp_Pnt P3d, P3d2;
Handle(BRepAdaptor_Surface) HS;
- Geom2dAdaptor_Curve C1, C2;
+ Handle(Geom2dAdaptor_Curve) C1 = new Geom2dAdaptor_Curve();
+ Handle(Geom2dAdaptor_Curve) C2 = new Geom2dAdaptor_Curve();
Geom2dInt_GInter Inter;
IntRes2d_Domain myDomain1;
TopTools_IndexedMapOfOrientedShape EMap;
return(BRepCheck_SelfIntersectingWire);
}
//
- C1.Load(pcu);
+ C1->Load(pcu);
// To avoid exception in Segment if C1 is BSpline - IFV
- if(!C1.IsPeriodic()) {
- if(C1.FirstParameter() > first1) {
- first1 = C1.FirstParameter();
+ if(!C1->IsPeriodic()) {
+ if(C1->FirstParameter() > first1) {
+ first1 = C1->FirstParameter();
}
- if(C1.LastParameter() < last1 ){
- last1 = C1.LastParameter();
+ if(C1->LastParameter() < last1 ){
+ last1 = C1->LastParameter();
}
}
//
BndLib_Add2dCurve::Add(C1, first1, last1, Precision::PConfusion(), boxes(i));
}//if (i == 1) {
else {
- C1.Load(tabCur(i));
+ C1->Load(tabCur(i));
myDomain1 = tabDom[i-1];
}
//
// Modified by Sergey KHROMOV - Mon Apr 15 12:34:22 2002 Begin
}
else {
- gp_Pnt2d aP2d = C1.Value(IP.ParamOnFirst());
+ gp_Pnt2d aP2d = C1->Value(IP.ParamOnFirst());
P3d = HS->Value(aP2d.X(), aP2d.Y());
}
// Modified by Sergey KHROMOV - Mon Apr 15 12:34:22 2002 End
if (i == 1) {
tabCur(j) = BRep_Tool::CurveOnSurface(E2,F,first2,last2);
if (!tabCur(j).IsNull() && last2 > first2) {
- C2.Load(tabCur(j));
+ C2->Load(tabCur(j));
// To avoid exception in Segment if C2 is BSpline - IFV
- if(!C2.IsPeriodic()) {
- if(C2.FirstParameter() > first2) {
- first2 = C2.FirstParameter();
+ if(!C2->IsPeriodic()) {
+ if(C2->FirstParameter() > first2) {
+ first2 = C2->FirstParameter();
}
- if(C2.LastParameter() < last2 ) {
- last2 = C2.LastParameter();
+ if(C2->LastParameter() < last2 ) {
+ last2 = C2->LastParameter();
}
}
//
}
}// if (i == 1) {
else {
- C2.Load(tabCur(j));
+ C2->Load(tabCur(j));
}
//
if (boxes(i).IsOut( boxes(j))) {
P3d.Transform(L.Transformation());
}
else {
- gp_Pnt2d aP2d = C1.Value(IP_ParamOnFirst);
+ gp_Pnt2d aP2d = C1->Value(IP_ParamOnFirst);
P3d = HS->Value(aP2d.X(), aP2d.Y());
}
//
P3d2.Transform(L2.Transformation());
}
else {
- gp_Pnt2d aP2d = C2.Value(IP_ParamOnSecond);
+ gp_Pnt2d aP2d = C2->Value(IP_ParamOnSecond);
P3d2 = HS->Value(aP2d.X(), aP2d.Y());
}
// Modified by Sergey KHROMOV - Mon Apr 15 12:34:22 2002 End
P1.Transform(L.Transformation());
}
else {
- gp_Pnt2d aP2d = C1.Value(u);
+ gp_Pnt2d aP2d = C1->Value(u);
P1 = HS->Value(aP2d.X(), aP2d.Y());
}
// Modified by Sergey KHROMOV - Mon Apr 15 12:34:22 2002 End
P2.Transform(L2.Transformation());
}
else {
- gp_Pnt2d aP2d = C2.Value(u);
+ gp_Pnt2d aP2d = C2->Value(u);
P2 = HS->Value(aP2d.X(), aP2d.Y());
}
// Modified by Sergey KHROMOV - Mon Apr 15 12:34:22 2002 End
if(aPCR1!=IntRes2d_Middle && aPCR2!=IntRes2d_Middle) {
GeomAbs_CurveType aCT1, aCT2;
//ZZ
- aCT1=C1.GetType();
- aCT2=C2.GetType();
+ aCT1=C1->GetType();
+ aCT2=C2->GetType();
if (aCT1==GeomAbs_Line && aCT2==GeomAbs_Line) {
// check for the two lines coincidence
Standard_Real aPAR_T, aT11, aT12, aT21, aT22, aT1m, aT2m;
aTol2=aTolE1+aTolE2;
aTol2=aTol2*aTol2;
//
- aL1=C1.Line();
- aL2=C2.Line();
+ aL1=C1->Line();
+ aL2=C2->Line();
//
aT11=PSeg[0].ParamOnFirst();
aT12=PSeg[1].ParamOnFirst();
aT22=PSeg[1].ParamOnSecond();
//
aT1m=(1.-aPAR_T)*aT11 + aPAR_T*aT12;
- aP1m=C1.Value(aT1m);
+ aP1m=C1->Value(aT1m);
//
aD2=aL2.SquareDistance(aP1m);
if (aD2<aTol2) {
P3d = ConS->Value(IP_ParamOnFirst);
P3d.Transform(L.Transformation());
} else {
- gp_Pnt2d aP2d = C1.Value(IP_ParamOnFirst);
+ gp_Pnt2d aP2d = C1->Value(IP_ParamOnFirst);
P3d = HS->Value(aP2d.X(), aP2d.Y());
}
if (!ConS2.IsNull()) {
P3d2 = ConS2->Value(IP_ParamOnSecond);
P3d2.Transform(L2.Transformation());
} else {
- gp_Pnt2d aP2d = C2.Value(IP_ParamOnSecond);
+ gp_Pnt2d aP2d = C2->Value(IP_ParamOnSecond);
P3d2 = HS->Value(aP2d.X(), aP2d.Y());
}
// Modified by Sergey KHROMOV - Mon Apr 15 12:34:22 2002 End
Standard_Real a_gpResolution=gp::Resolution();
TopAbs_Orientation aVOrientation, anEdgOrientation;
Standard_Real aParam = 0.0, aFirstParam = 0.0, aLastParam = 0.0, aParPiv = 0.0;
- BRepAdaptor_Surface aFaceSurface(theFace,Standard_False); // no restriction
+ Handle(BRepAdaptor_Surface) aFaceSurface = new BRepAdaptor_Surface(theFace, Standard_False); // no restriction
Handle(Geom2d_Curve) C2d = BRep_Tool::CurveOnSurface(theEdge, theFace, aFirstParam, aLastParam);
if (C2d.IsNull())// JAG 10.12.96
aMinAngle = RealLast();
aMaxAngle = RealFirst();
- CurveDirForParameter(C2d, aParPiv, aPntRef, aDerRef);
+ CurveDirForParameter(new Geom2dAdaptor_Curve(C2d), aParPiv, aPntRef, aDerRef);
if (aVOrientation != anEdgOrientation)
aDerRef.Reverse();
if(!IsDistanceIn2DTolerance(aFaceSurface, aPnt, aPntRef, aTol3d, Standard_False))
continue;
- CurveDirForParameter(aCA, aParam, aPnt, aDer);
+ CurveDirForParameter(new Geom2dAdaptor_Curve(aCA), aParam, aPnt, aDer);
if (aVOrientation == anE.Orientation())
aDer.Reverse();
//function : CurveDirForParameter
//purpose :
//=======================================================================
-void CurveDirForParameter(const Geom2dAdaptor_Curve& aC2d,
+void CurveDirForParameter(const Handle(Geom2dAdaptor_Curve)& aC2d,
const Standard_Real aPrm,
gp_Pnt2d& Pnt,
gp_Vec2d& aVec2d)
Standard_Real aTol=gp::Resolution();
Standard_Integer i;
- aC2d.D1(aPrm, Pnt, aVec2d);
+ aC2d->D1(aPrm, Pnt, aVec2d);
//
if (aVec2d.Magnitude() <= aTol) {
for (i = 2; i <= 100; i++){
- aVec2d = aC2d.DN(aPrm, i);
+ aVec2d = aC2d->DN(aPrm, i);
if (aVec2d.Magnitude() > aTol) {
break;
}
aMaxDist=RealLast();
aIndice=0;
//
- BRepAdaptor_Surface aSurf(theF, Standard_False);
+ Handle(BRepAdaptor_Surface) aSurf = new BRepAdaptor_Surface(theF, Standard_False);
BRepTools::UVBounds(theF, aU1, aU2, aV1, aV2);
aExtrema.Initialize(aSurf, aU1, aU2, aV1, aV2, theTol, theTol);
//
static
void RefineTolerance(const TopoDS_Face& aF,
- const Geom2dAdaptor_Curve& aC,
+ const Handle(Geom2dAdaptor_Curve)& aC,
const Standard_Real aT,
Standard_Real& aTolZ);
Standard_Boolean CheckOn(IntRes2d_IntersectionPoint& thePntInter,
const TopoDS_Face& theF,
const gp_Lin2d& theL,
- const Geom2dAdaptor_Curve& theCur,
+ const Handle(Geom2dAdaptor_Curve)& theCur,
Standard_Real& theTolZ,
const Standard_Real theFin,
const Standard_Real theDeb);
const BRepClass_Edge& theE,
const Handle(Geom2d_Curve)& theC2D,
const IntRes2d_Domain& theDL,
- Geom2dAdaptor_Curve& theCur,
- const Geom2dAdaptor_Curve& theCGA,
+ Handle(Geom2dAdaptor_Curve)& theCur,
+ const Handle(Geom2dAdaptor_Curve)& theCGA,
Standard_Real& theFin,
Standard_Real& theDeb,
const Standard_Real theMaxTol,
Standard_Boolean CheckOn(IntRes2d_IntersectionPoint& thePntInter,
const TopoDS_Face& theF,
const gp_Lin2d& theL,
- const Geom2dAdaptor_Curve& theCur,
+ const Handle(Geom2dAdaptor_Curve)& theCur,
Standard_Real& theTolZ,
const Standard_Real theFin,
const Standard_Real theDeb)
const BRepClass_Edge& theE,
const Handle(Geom2d_Curve)& theC2D,
const IntRes2d_Domain& theDL,
- Geom2dAdaptor_Curve& theCur,
- const Geom2dAdaptor_Curve& theCGA,
+ Handle(Geom2dAdaptor_Curve)& theCur,
+ const Handle(Geom2dAdaptor_Curve)& theCGA,
Standard_Real& theFin,
Standard_Real& theDeb,
const Standard_Real theMaxTol,
return;
}
// if we got
- theCur.Load(aSkipC2D);
- if (theCur.Curve().IsNull())
+ theCur->Load(aSkipC2D);
+ if (theCur->Curve().IsNull())
{
return;
}
Standard_Real atoldeb = 1.e-5, atolfin = 1.e-5;
- theDeb = theCur.FirstParameter();
- theFin = theCur.LastParameter();
- theCur.D0(theDeb, thePdeb);
- theCur.D0(theFin, thePfin);
+ theDeb = theCur->FirstParameter();
+ theFin = theCur->LastParameter();
+ theCur->D0(theDeb, thePdeb);
+ theCur->D0(theFin, thePfin);
IntRes2d_Domain aDE(thePdeb, theDeb, atoldeb, thePfin, theFin, atolfin);
// temporary periodic domain
- if (theCur.Curve()->IsPeriodic())
+ if (theCur->Curve()->IsPeriodic())
{
- aDE.SetEquivalentParameters(theCur.FirstParameter(),
- theCur.FirstParameter() +
- theCur.Curve()->LastParameter() -
- theCur.Curve()->FirstParameter());
+ aDE.SetEquivalentParameters(theCur->FirstParameter(),
+ theCur->FirstParameter() +
+ theCur->Curve()->LastParameter() -
+ theCur->Curve()->FirstParameter());
}
theInter = Geom2dInt_GInter(theCGA, theDL, theCur, aDE,
aPntF = L.Location();
}
//
- Geom2dAdaptor_Curve C(aC2D, deb, fin);
+ Handle(Geom2dAdaptor_Curve) C = new Geom2dAdaptor_Curve(aC2D, deb, fin);
//
// Case of "ON": direct check of belonging to edge
// taking into account the tolerance
}
}
gp_Pnt2d pdeb, pfin;
- C.D0(deb, pdeb);
- C.D0(fin, pfin);
+ C->D0(deb, pdeb);
+ C->D0(fin, pfin);
Standard_Real toldeb = 1.e-5, tolfin = 1.e-5;
IntRes2d_Domain DL;
IntRes2d_Domain DE(pdeb, deb, toldeb, pfin, fin, tolfin);
// temporary periodic domain
- if (C.Curve()->IsPeriodic()) {
- DE.SetEquivalentParameters(C.FirstParameter(),
- C.FirstParameter() +
- C.Curve()->LastParameter() -
- C.Curve()->FirstParameter());
+ if (C->Curve()->IsPeriodic()) {
+ DE.SetEquivalentParameters(C->FirstParameter(),
+ C->FirstParameter() +
+ C->Curve()->LastParameter() -
+ C->Curve()->FirstParameter());
}
Handle(Geom2d_Line) GL = new Geom2d_Line(L);
- Geom2dAdaptor_Curve CGA(GL);
+ Handle(Geom2dAdaptor_Curve) CGA = new Geom2dAdaptor_Curve(GL);
Geom2dInt_GInter Inter(CGA, DL, C, DE,
Precision::PConfusion(),
Precision::PIntersection());
//purpose :
//=======================================================================
void RefineTolerance(const TopoDS_Face& aF,
- const Geom2dAdaptor_Curve& aC,
+ const Handle(Geom2dAdaptor_Curve)& aC,
const Standard_Real aT,
Standard_Real& aTolZ)
{
aURes=aBAS.UResolution(aTolZ);
aVRes=aBAS.VResolution(aTolZ);
//
- aC.D1(aT, aP2D, aV2D);
+ aC->D1(aT, aP2D, aV2D);
gp_Dir2d aD2D(aV2D);
//
aTolX=aURes*aD2D.Y()+aVRes*aD2D.X();
Standard_Real EdgeTSq = BRep_Tool::Tolerance(E);
EdgeTSq *= EdgeTSq;
Standard_Real f, l;
- BRepAdaptor_Curve C(E);
+ Handle(BRepAdaptor_Curve) C = new BRepAdaptor_Curve(E);
BRep_Tool::Range(E,f,l);
// Edge-Point interference.
Standard_Real EdgeTSq = BRep_Tool::Tolerance(E);
EdgeTSq *= EdgeTSq;
Standard_Real f, l;
- BRepAdaptor_Curve C(E);
+ Handle(BRepAdaptor_Curve) C = new BRepAdaptor_Curve(E);
BRep_Tool::Range(E, f, l);
// Edge-Line interference.
- Extrema_ExtCC ExtCC(C, myLC, f, l, myLC.FirstParameter(), myLC.LastParameter());
+ Extrema_ExtCC ExtCC(C, myLC, f, l, myLC->FirstParameter(), myLC->LastParameter());
if (ExtCC.IsDone())
{
if (ExtCC.IsParallel())
BRepClass3d_BndBoxTreeSelectorLine(const TopTools_IndexedMapOfShape& theMapOfShape)
: BRepClass3d_BndBoxTreeSelectorLine::Selector(),
myMapOfShape(theMapOfShape),
+ myLC(new GeomAdaptor_Curve()),
myIsValid(Standard_True)
{}
const Standard_Real theMaxParam)
{
myL = theL;
- myLC.Load(new Geom_Line(theL), -Precision::PConfusion(), theMaxParam);
+ myLC->Load(new Geom_Line(theL), -Precision::PConfusion(), theMaxParam);
}
void GetEdgeParam(const Standard_Integer i,
gp_Lin myL;
NCollection_Sequence<EdgeParam> myEP; //output result (edge vs line)
NCollection_Sequence<VertParam> myVP; //output result (vertex vs line)
- GeomAdaptor_Curve myLC;
+ Handle(GeomAdaptor_Curve) myLC;
Standard_Boolean myIsValid;
};
if (Intersector3d.IsParallel())
{
//Check distance between surface and point
- BRepAdaptor_Surface aBAS(f, Standard_False);
+ Handle(BRepAdaptor_Surface) aBAS = new BRepAdaptor_Surface(f, Standard_False);
Extrema_ExtPS aProj(P, aBAS, Precision::PConfusion(), Precision::PConfusion());
if (aProj.IsDone() && aProj.NbExt() > 0)
{
_u = (U1 + U2) * 0.5;
_v = (V1 + V2) * 0.5;
- GeomAdaptor_Surface GA(BRep_Tool::Surface(face));
+ Handle(GeomAdaptor_Surface) GA = new GeomAdaptor_Surface(BRep_Tool::Surface(face));
Extrema_ExtPS Ext(P, GA, TolU, TolV);
//
if (Ext.IsDone() && Ext.NbExt() > 0) {
Standard_Real Tol = Min(BRep_Tool::Tolerance(E2), Precision::Confusion());
Tol = Max(Curv.Resolution(Tol), Precision::PConfusion());
BRep_Tool::Range(E2,V1,V2);
- myExtCC.SetCurve (2, *myHC, V1, V2);
+ myExtCC.SetCurve (2, myHC, V1, V2);
myExtCC.SetTolerance(2, Tol);
}
Standard_Real Tol = Min(BRep_Tool::Tolerance(E1), Precision::Confusion());
Tol = Max(Curv.Resolution(Tol), Precision::PConfusion());
BRep_Tool::Range(E1,U1,U2);
- myExtCC.SetCurve (1, *HC, U1, U2);
+ myExtCC.SetCurve (1, HC, U1, U2);
myExtCC.SetTolerance(1, Tol);
// If we enable SetSingleSolutionFlag Extrema will run much quicker on almost parallel curves
// (e.g. bug 27665), however some solutions will be lost, e.g. see bug 28183.
//
Standard_Real U1, U2, V1, V2;
BRepTools::UVBounds(F, U1, U2, V1, V2);
- myExtCS.Initialize (*myHS, U1, U2, V1, V2, aTolC, aTolS);
+ myExtCS.Initialize (myHS, U1, U2, V1, V2, aTolC, aTolS);
}
//=======================================================================
BRepAdaptor_Curve Curv(E);
Handle(BRepAdaptor_Curve) HC = new BRepAdaptor_Curve(Curv);
- myExtCS.Perform(*HC, U1, U2);
+ myExtCS.Perform(HC, U1, U2);
if(!myExtCS.IsDone())
return;
Tol = Max(Tol, Precision::PConfusion());
Standard_Real U1, U2, V1, V2;
BRepTools::UVBounds(F2, U1, U2, V1, V2);
- myExtSS.Initialize (*myHS, U1, U2, V1, V2, Tol);
+ myExtSS.Initialize (myHS, U1, U2, V1, V2, Tol);
}
//=======================================================================
Tol1 = Max(Tol1, Precision::PConfusion());
Standard_Real U1, U2, V1, V2;
BRepTools::UVBounds(F1, U1, U2, V1, V2);
- myExtSS.Perform (*HS1, U1, U2, V1, V2, Tol1);
+ myExtSS.Perform (HS1, U1, U2, V1, V2, Tol1);
if (!myExtSS.IsDone())
return;
Standard_Real Tol = Min(BRep_Tool::Tolerance(E), Precision::Confusion());
Tol = Max(myHC->Resolution(Tol), Precision::PConfusion());
BRep_Tool::Range(E,U1,U2);
- myExtPC.Initialize (*myHC, U1, U2, Tol);
+ myExtPC.Initialize (myHC, U1, U2, Tol);
}
//=======================================================================
{
// cette surface doit etre en champ. Extrema ne fait
// pas de copie et prend seulement un pointeur dessus.
- mySurf.Initialize(TheFace, Standard_False);
+ mySurf = new BRepAdaptor_Surface(TheFace, Standard_False);
- if (mySurf.GetType() == GeomAbs_OtherSurface)
+ if (mySurf->GetType() == GeomAbs_OtherSurface)
return; // protect against non-geometric type (e.g. triangulation)
Standard_Real Tol = Min(BRep_Tool::Tolerance(TheFace), Precision::Confusion());
Standard_Real aTolU, aTolV;
- aTolU = Max(mySurf.UResolution(Tol), Precision::PConfusion());
- aTolV = Max(mySurf.VResolution(Tol), Precision::PConfusion());
+ aTolU = Max(mySurf->UResolution(Tol), Precision::PConfusion());
+ aTolV = Max(mySurf->VResolution(Tol), Precision::PConfusion());
Standard_Real U1, U2, V1, V2;
BRepTools::UVBounds(TheFace, U1, U2, V1, V2);
myExtPS.SetFlag(TheFlag);
myPoints.Clear();
const gp_Pnt P = BRep_Tool::Pnt(TheVertex);
- if (mySurf.GetType() == GeomAbs_OtherSurface)
+ if (mySurf->GetType() == GeomAbs_OtherSurface)
return; // protect against non-geometric type (e.g. triangulation)
myExtPS.Perform(P);
Extrema_ExtPS myExtPS;
TColStd_SequenceOfReal mySqDist;
Extrema_SequenceOfPOnSurf myPoints;
- BRepAdaptor_Surface mySurf;
+ Handle(BRepAdaptor_Surface) mySurf;
};
#endif
Handle(Geom_Curve) C;
Standard_Real f,l,prm;
Standard_Integer i, nbp= 0;
- GeomAdaptor_Curve TheCurve(CC);
+ Handle(GeomAdaptor_Curve) TheCurve = new GeomAdaptor_Curve(CC);
Extrema_ExtPC extpc;
extpc.Initialize(TheCurve,CC->FirstParameter(),CC->LastParameter());
Standard_Real parbar = 0;
Standard_Real f,l,prm;
// Standard_Integer i, nbp= 0;
Standard_Integer i;
- GeomAdaptor_Curve TheCurve(CC);
+ Handle(GeomAdaptor_Curve) TheCurve = new GeomAdaptor_Curve(CC);
Extrema_ExtPC extpc;
- extpc.Initialize(TheCurve,CC->FirstParameter(),CC->LastParameter());
+ extpc.Initialize(TheCurve, CC->FirstParameter(),CC->LastParameter());
prbmin = RealLast();
prbmax = RealFirst();
for (; exp.More(); exp.Next()) {
//=======================================================================
static Standard_Boolean IsIn (BRepTopAdaptor_FClass2d& FC,
- Geom2dAdaptor_Curve AC)
+ const Handle(Geom2dAdaptor_Curve)& AC)
{
Standard_Real Def = 100*Precision::Confusion();
GCPnts_QuasiUniformDeflection QU(AC,Def);
for (Standard_Integer i = 1; i <= QU.NbPoints(); i++) {
- gp_Pnt2d P = AC.Value(QU.Parameter(i));
+ gp_Pnt2d P = AC->Value(QU.Parameter(i));
if (FC.Perform(P, Standard_False) == TopAbs_OUT) {
return Standard_False;
}
if(flagu == 1) PutInBoundsU(umin, umax, eps, uperiod, f1, l1, C);
if(flagv == 1) PutInBoundsV(vmin, vmax, eps, vperiod, f1, l1, C);
}
- Geom2dAdaptor_Curve AC(C,f1,l1);
- if (!IsIn(FC,AC)) {
+ Handle(Geom2dAdaptor_Curve) AC = new Geom2dAdaptor_Curve(C,f1,l1);
+ if (!IsIn(FC, AC)) {
return Standard_False;
}
}
Standard_EXPORT static Standard_Boolean IsInside (const TopoDS_Face& F1, const TopoDS_Face& F2);
- Standard_EXPORT static Standard_Boolean IsInOut (const BRepTopAdaptor_FClass2d& FC, const Geom2dAdaptor_Curve& AC);
+ Standard_EXPORT static Standard_Boolean IsInOut (const BRepTopAdaptor_FClass2d& FC, const Handle(Geom2dAdaptor_Curve)& AC);
Standard_EXPORT static void FaceUntil (const TopoDS_Shape& S, TopoDS_Face& F);
TopoDS_Edge Ecur = TopoDS::Edge(anExp.Current());
ACR(nbEdges) = ACR(nbEdges-1);
if (!BRep_Tool::Degenerated(Ecur)) {
- BRepAdaptor_Curve anEcur(Ecur);
+ Handle(BRepAdaptor_Curve) anEcur = new BRepAdaptor_Curve(Ecur);
ACR(nbEdges) += GCPnts_AbscissaPoint::Length(anEcur);
}
}
class NormalFunc : public math_MultipleVarFunctionWithGradient
{
public:
- NormalFunc(const Adaptor3d_CurveOnSurface& theCOS) :myCOnS(theCOS)
+ NormalFunc(const Handle(Adaptor3d_CurveOnSurface)& theCOS) :myCOnS(theCOS)
{
}
NormalFunc& operator=(NormalFunc&);
private:
- const Adaptor3d_CurveOnSurface& myCOnS;
+ const Handle(Adaptor3d_CurveOnSurface)& myCOnS;
};
//=======================================================================
TopExp::Vertices(Edge2,V2,Vbid,Standard_True);
Standard_Real U1 = BRep_Tool::Parameter(V1,Edge1);
Standard_Real U2 = BRep_Tool::Parameter(V2,Edge2);
- BRepAdaptor_Curve Curve1(Edge1);
- BRepAdaptor_Curve Curve2(Edge2);
+ Handle(BRepAdaptor_Curve) Curve1 = new BRepAdaptor_Curve(Edge1);
+ Handle(BRepAdaptor_Curve) Curve2 = new BRepAdaptor_Curve(Edge2);
Standard_Real Eps = BRep_Tool::Tolerance(V2) + BRep_Tool::Tolerance(V1);
if(j == nbEdges)
- testconti = Curve1.Value(U1).IsEqual(Curve2.Value(U2), Eps);
+ testconti = Curve1->Value(U1).IsEqual(Curve2->Value(U2), Eps);
if(testconti) {
cont = BRepLProp::Continuity(Curve1,Curve2,U1,U2,
// Calculate the Transformation
gp_Ax3 N(Bary, D);
Tf.SetTransformation(N);
- BRepAdaptor_Curve AC;
+ Handle(BRepAdaptor_Curve) AC = new BRepAdaptor_Curve();
// BndLib_Add3dCurve BC;
// transformation to the wire
// Calculate the box
Box.SetVoid();
for (Exp.Init(TheW); Exp.More(); Exp.Next()) {
- AC.Initialize(Exp.Current());
+ AC->Initialize(Exp.Current());
// BC.Add(AC, 0.1, Box);
BndLib_Add3dCurve::Add(AC, 0.1, Box);
}
// box with bounds of the stop surface
Handle(Geom_Surface) Surf;
Surf = Handle(Geom_Surface)::DownCast(Surface->Transformed(Trsf));
- GeomAdaptor_Surface S1 (Surf);
+ Handle(GeomAdaptor_Surface) S1 = new GeomAdaptor_Surface(Surf);
// BndLib_AddSurface AS;
// AS.Add(S1, 0.1, SBox);
BndLib_AddSurface::Add(S1, 0.1, SBox);
Surf = Handle(Geom_Surface)::DownCast(
// BT.Surface(TopoDS::Face(Ex.Current()))->Transformed(Trsf) );
BRep_Tool::Surface(TopoDS::Face(Ex.Current()))->Transformed(Trsf) );
- GeomAdaptor_Surface S1 (Surf);
+ Handle(GeomAdaptor_Surface) S1 = new GeomAdaptor_Surface(Surf);
// bounding box of the current face
// AS.Add(S1, Umin, Umax, Vmin, Vmax, 0.1, BSurf);
BndLib_AddSurface::Add(S1, Umin, Umax, Vmin, Vmax, 0.1, BSurf);
// the regularities are already coded on the edges of elementary volevos
Standard_Real U1 = BRep_Tool::Parameter(V,CurE);
Standard_Real U2 = BRep_Tool::Parameter(V,PrecE);
- BRepAdaptor_Curve Curve1(CurE);
- BRepAdaptor_Curve Curve2(PrecE);
+ Handle(BRepAdaptor_Curve) Curve1 = new BRepAdaptor_Curve(CurE);
+ Handle(BRepAdaptor_Curve) Curve2 = new BRepAdaptor_Curve(PrecE);
GeomAbs_Shape Continuity = BRepLProp::Continuity(Curve1,Curve2,U1,U2);
if (Continuity >=1) {
//Closed profile.
Standard_Real U1 = BRep_Tool::Parameter(VF,CurE);
Standard_Real U2 = BRep_Tool::Parameter(VF,FirstE);
- BRepAdaptor_Curve Curve1(CurE);
- BRepAdaptor_Curve Curve2(FirstE);
+ Handle(BRepAdaptor_Curve) Curve1 = new BRepAdaptor_Curve(CurE);
+ Handle(BRepAdaptor_Curve) Curve2 = new BRepAdaptor_Curve(FirstE);
GeomAbs_Shape Continuity = BRepLProp::Continuity(Curve1,Curve2,U1,U2);
if (Continuity >=1) {
l= C2d->LastParameter();
Bnd_Box2d B;
- Geom2dAdaptor_Curve AC2d(C2d);
+ Handle(Geom2dAdaptor_Curve) AC2d = new Geom2dAdaptor_Curve(C2d);
BndLib_Add2dCurve::Add(AC2d,BRepFill_Confusion(),B);
Standard_Real xmin,xmax;
B.Get(xmin,U1,xmax,U2);
// modified by NIZHNY-EAP Wed Feb 2 16:33:05 2000 ___END___
// On calcule les intersection avec Oy.
- Geom2dAdaptor_Curve ALine(Line);
+ Handle(Geom2dAdaptor_Curve) ALine = new Geom2dAdaptor_Curve(Line);
Standard_Real Tol = Precision::Intersection();
Standard_Real TolC = 0.;
for (ii=1, Length=0.; ii<=NbE; ii++) {
myLaws->Value(ii)->GetDomain(f, l);
- Length += AbsC.Length(*myLaws->Value(ii)->GetCurve(), myTol);
+ Length += AbsC.Length(myLaws->Value(ii)->GetCurve(), myTol);
myLength->SetValue(ii+1, Length);
}
else {
GCPnts_AbscissaPoint
AbsC(myTol,
- *myLaws->Value(iedge)->GetCurve(),
+ myLaws->Value(iedge)->GetCurve(),
Abcissa-myLength->Value(iedge), f);
U = AbsC.Parameter();
}
CurvilinearBounds(Index, bid, Length);
}
- Length += AbsC.Length(*myLaws->Value(Index)->GetCurve(),
+ Length += AbsC.Length(myLaws->Value(Index)->GetCurve(),
myLaws->Value(Index)->GetCurve()->FirstParameter(),
Param, myTol);
return Length;
{
myNbPnt2d = 2;
myNbPnt = 1;
+ myU1 = new Geom2dAdaptor_Curve();
+ myV1 = new Geom2dAdaptor_Curve();
+ myU2 = new Geom2dAdaptor_Curve();
+ myV2 = new Geom2dAdaptor_Curve();
+ myBis = new Geom2dAdaptor_Curve();
}
const Handle(Geom2d_Curve)& Bissec)
: myFace1(Face1 ),
myFace2(Face2 ),
- myBis (Bissec),
+ myBis(new Geom2dAdaptor_Curve(Bissec)),
myKPart(0)
{
//
}
// end try duplication
- myU1 = Geom2dAdaptor_Curve(GeomProjLib::Curve2d(UU1, BasisPlane),
+ myU1 = new Geom2dAdaptor_Curve(GeomProjLib::Curve2d(UU1, BasisPlane),
Umin, Umax);
UU1->D1(Umin, P, DZ);
RefPlane = new Geom_Plane(gp_Ax3(P,DZ,gp::DZ()));
- myV1 = Geom2dAdaptor_Curve(GeomProjLib::Curve2d(VV1, RefPlane),
+ myV1 = new Geom2dAdaptor_Curve(GeomProjLib::Curve2d(VV1, RefPlane),
Vmin, Vmax);
}
// end try duplication
- myU2 = Geom2dAdaptor_Curve(GeomProjLib::Curve2d(UU2, BasisPlane),
+ myU2 = new Geom2dAdaptor_Curve(GeomProjLib::Curve2d(UU2, BasisPlane),
Umin, Umax);
UU2->D1(Umin, P, DZ);
RefPlane = new Geom_Plane(gp_Ax3(P,DZ,gp::DZ()));
- myV2 = Geom2dAdaptor_Curve(GeomProjLib::Curve2d(VV2, RefPlane),
+ myV2 = new Geom2dAdaptor_Curve(GeomProjLib::Curve2d(VV2, RefPlane),
Vmin, Vmax);
// eval if in a particular case.
// - 2 surfaces are planes.
myCont = GeomAbs_C0;
- if ( myBis.GetType() == GeomAbs_Line) {
- Standard_Real DeltaU = myBis.LastParameter() - myBis.FirstParameter();
- gp_Pnt2d aPnt1 = ValueOnF1(myBis.FirstParameter() + 0.1*DeltaU);
- gp_Pnt2d aPnt2 = ValueOnF1(myBis.FirstParameter() + 0.9*DeltaU);
+ if ( myBis->GetType() == GeomAbs_Line) {
+ Standard_Real DeltaU = myBis->LastParameter() - myBis->FirstParameter();
+ gp_Pnt2d aPnt1 = ValueOnF1(myBis->FirstParameter() + 0.1*DeltaU);
+ gp_Pnt2d aPnt2 = ValueOnF1(myBis->FirstParameter() + 0.9*DeltaU);
if ( myIsoU1) {
if ( Abs(aPnt1.Y() - aPnt2.Y()) < eps)
myKPart = 1;
gp_Pnt2d P1,P2,PMil;
Standard_Real f,l;
- P1 = ValueOnF1(myBis.FirstParameter());
- P2 = ValueOnF1(myBis.LastParameter());
+ P1 = ValueOnF1(myBis->FirstParameter());
+ P2 = ValueOnF1(myBis->LastParameter());
// find value of the with medium point
// the ends can be degenerated points.
- PMil = ValueOnF1(0.5*(myBis.FirstParameter() + myBis.LastParameter()));
+ PMil = ValueOnF1(0.5*(myBis->FirstParameter() + myBis->LastParameter()));
TopLoc_Location L;
Handle(Geom_Surface) S = BRep_Tool::Surface(myFace1,L);
PCurve1 = new Geom2d_TrimmedCurve( PCurve1 ,f ,l);
}
- P1 = ValueOnF2(myBis.FirstParameter());
- P2 = ValueOnF2(myBis.LastParameter());
- PMil = ValueOnF2(0.5*(myBis.FirstParameter() + myBis.LastParameter()));
+ P1 = ValueOnF2(myBis->FirstParameter());
+ P2 = ValueOnF2(myBis->LastParameter());
+ PMil = ValueOnF2(0.5*(myBis->FirstParameter() + myBis->LastParameter()));
if (!myIsoU2) {
Sens = P1.Y() < P2.Y();
Handle(Geom_Plane) Plane = Handle(Geom_Plane)::DownCast(S);
// eval the 3d curve corresponding to the bissectrice.
- gp_Pnt2d P = myBis.Line().Location();
- gp_Dir2d D = myBis.Line().Direction();
+ gp_Pnt2d P = myBis->Line().Location();
+ gp_Dir2d D = myBis->Line().Direction();
Handle(Geom_Line) Line = new Geom_Line(gp_Pnt(P.X(),P.Y(),0.),
gp_Dir(D.X(),D.Y(),0.) );
Handle(Geom_TrimmedCurve) TLine =
- new Geom_TrimmedCurve(Line, myBis.FirstParameter(),
- myBis.LastParameter());
+ new Geom_TrimmedCurve(Line, myBis->FirstParameter(),
+ myBis->LastParameter());
Curve = GeomProjLib::ProjectOnPlane(TLine, Plane,
gp::DZ(), Standard_False);
Standard_Real BRepFill_MultiLine::FirstParameter() const
{
- return myBis.FirstParameter();
+ return myBis->FirstParameter();
}
Standard_Real BRepFill_MultiLine::LastParameter() const
{
- return myBis.LastParameter();
+ return myBis->LastParameter();
}
//=======================================================================
static gp_Pnt2d ValueOnFace(const Standard_Real U,
- const Geom2dAdaptor_Curve& TheBis,
- const Geom2dAdaptor_Curve& TheU,
- const Geom2dAdaptor_Curve& TheV,
+ const Handle(Geom2dAdaptor_Curve)& TheBis,
+ const Handle(Geom2dAdaptor_Curve)& TheU,
+ const Handle(Geom2dAdaptor_Curve)& TheV,
const Standard_Boolean IsIsoU)
{
- gp_Pnt2d P = TheBis.Value(U);
+ gp_Pnt2d P = TheBis->Value(U);
- Geom2dAPI_ProjectPointOnCurve Ext(P,TheU.Curve(),
- TheU.FirstParameter(),
- TheU.LastParameter());
+ Geom2dAPI_ProjectPointOnCurve Ext(P,TheU->Curve(),
+ TheU->FirstParameter(),
+ TheU->LastParameter());
#ifdef DRAW
if (AffichCurve) {
char* TheUname = "TheU";
char* PP1name = "PP1";
- DrawTrSurf::Set(TheUname,TheU.Curve());
+ DrawTrSurf::Set(TheUname,TheU->Curve());
DrawTrSurf::Set(PP1name,P);
- // DrawTrSurf::Set("TheU",TheU.Curve());
+ // DrawTrSurf::Set("TheU",TheU->Curve());
// DrawTrSurf::Set("PP1",P);
}
#endif
Dist = Ext.LowerDistance();
}
// Control with `ends`
- D1 = P.Distance(TheU.Value(TheU.FirstParameter()));
- D2 = P.Distance(TheU.Value(TheU.LastParameter()));
+ D1 = P.Distance(TheU->Value(TheU->FirstParameter()));
+ D2 = P.Distance(TheU->Value(TheU->LastParameter()));
if (D1 < Dist || D2 < Dist || Abs(D1 - Dist) < eps || Abs(D2 - Dist) < eps) {
if ( Abs( D1 - D2) < eps) {
- if ( TheU.GetType() == GeomAbs_Circle) {
- gp_Vec2d Axis = TheU.Circle().XAxis().Direction();
- gp_Vec2d D12d = TheBis.DN(TheBis.FirstParameter(),1);
+ if ( TheU->GetType() == GeomAbs_Circle) {
+ gp_Vec2d Axis = TheU->Circle().XAxis().Direction();
+ gp_Vec2d D12d = TheBis->DN(TheBis->FirstParameter(),1);
Standard_Real Ang = Axis.Angle(D12d);
- if ( !TheU.Circle().IsDirect()) Ang = -Ang;
- UU = ElCLib::InPeriod( Ang, TheU.FirstParameter(),
- TheU.FirstParameter() + 2*M_PI);
- Dist = TheU.Circle().Radius();
+ if ( !TheU->Circle().IsDirect()) Ang = -Ang;
+ UU = ElCLib::InPeriod( Ang, TheU->FirstParameter(),
+ TheU->FirstParameter() + 2*M_PI);
+ Dist = TheU->Circle().Radius();
}
else {
#ifdef OCCT_DEBUG
}
else if ( D1 < D2) {
Dist = D1;
- UU = TheU.FirstParameter();
+ UU = TheU->FirstParameter();
}
else {
Dist = D2;
- UU = TheU.LastParameter();
+ UU = TheU->LastParameter();
}
}
const Standard_Real Tol = Precision::Confusion();
Standard_Real VV;
- gp_Pnt2d PF = TheV.Value(TheV.FirstParameter());
- gp_Pnt2d PL = TheV.Value(TheV.LastParameter());
+ gp_Pnt2d PF = TheV->Value(TheV->FirstParameter());
+ gp_Pnt2d PL = TheV->Value(TheV->LastParameter());
if (Abs(Dist - Abs(PF.Y())) < Tol) {
- VV = TheV.FirstParameter();
+ VV = TheV->FirstParameter();
}
else if (Abs(Dist - Abs(PL.Y())) < Tol) {
- VV = TheV.LastParameter();
+ VV = TheV->LastParameter();
}
else {
// test if the curve is at the side `negative Y`.
#ifdef DRAW
if (AffichCurve) {
static Standard_CString aTheV = "TheV" ;
- DrawTrSurf::Set(aTheV,TheV.Curve());
+ DrawTrSurf::Set(aTheV,TheV->Curve());
static Standard_CString aLINF1 = "LINF1" ;
DrawTrSurf::Set(aLINF1,Line);
}
#endif
- Geom2dAdaptor_Curve Cu1 = TheV;
- Geom2dAdaptor_Curve Cu2( Line);
+ Handle(Geom2dAdaptor_Curve) Cu1 = Handle(Geom2dAdaptor_Curve)::DownCast(TheV->ShallowCopy());
+ Handle(Geom2dAdaptor_Curve) Cu2 = new Geom2dAdaptor_Curve(Line);
Standard_Real TolConf = 0.;
IntRes2d_IntersectionSegment Seg = Intersector.Segment(1);
Standard_Real VS1 = Seg.FirstPoint().ParamOnFirst();
Standard_Real VS2 = Seg.LastPoint().ParamOnFirst();
- gp_Pnt2d PS1 = TheV.Value(VS1);
- gp_Pnt2d PS2 = TheV.Value(VS2);
+ gp_Pnt2d PS1 = TheV->Value(VS1);
+ gp_Pnt2d PS2 = TheV->Value(VS2);
Standard_Real Alp = (Dist - PS1.Y())/(PS2.Y() - PS1.Y());
VV = Alp*(VS2 - VS1) + VS1;
}
std::cout << " ---> ValueonFace failed at parameter U = " << U << std::endl;
#endif
if (Abs(Dist - PL.Y()) < Abs(Dist - PF.Y()))
- VV = TheV.LastParameter();
+ VV = TheV->LastParameter();
else
- VV = TheV.FirstParameter();
+ VV = TheV->FirstParameter();
}
}
}
private:
TopoDS_Face myFace1;
TopoDS_Face myFace2;
- Geom2dAdaptor_Curve myU1;
- Geom2dAdaptor_Curve myV1;
- Geom2dAdaptor_Curve myU2;
- Geom2dAdaptor_Curve myV2;
+ Handle(Geom2dAdaptor_Curve) myU1;
+ Handle(Geom2dAdaptor_Curve) myV1;
+ Handle(Geom2dAdaptor_Curve) myU2;
+ Handle(Geom2dAdaptor_Curve) myV2;
Standard_Boolean myIsoU1;
Standard_Boolean myIsoU2;
- Geom2dAdaptor_Curve myBis;
+ Handle(Geom2dAdaptor_Curve) myBis;
Standard_Integer myKPart;
GeomAbs_Shape myCont;
};
{
Standard_Real U1 = BRep_Tool::Parameter(V1,Edge1);
Standard_Real U2 = BRep_Tool::Parameter(V2,Edge2);
- BRepAdaptor_Curve Curve1(Edge1);
- BRepAdaptor_Curve Curve2(Edge2);
+ Handle(BRepAdaptor_Curve) Curve1 = new BRepAdaptor_Curve(Edge1);
+ Handle(BRepAdaptor_Curve) Curve2 = new BRepAdaptor_Curve(Edge2);
Standard_Real Eps = BRep_Tool::Tolerance(V2) +
BRep_Tool::Tolerance(V1);
cont_jj = BRepLProp::Continuity(Curve1,Curve2,U1,U2, Eps, TolAngular);
// Modified by Sergey KHROMOV - Thu Nov 16 17:24:39 2000 Begin
-static void QuasiFleche(const Adaptor3d_Curve& C,
+static void QuasiFleche(const Handle(Adaptor3d_Curve)& C,
const Standard_Real Deflection2,
const Standard_Real Udeb,
const gp_Pnt& Pdeb,
static Standard_Boolean PerformCurve (TColStd_SequenceOfReal& Parameters,
TColgp_SequenceOfPnt& Points,
- const Adaptor3d_Curve& C,
+ const Handle(Adaptor3d_Curve)& C,
const Standard_Real Deflection,
const Standard_Real U1,
const Standard_Real U2,
Standard_Real f, l;
Handle(Geom_Curve) G3d = BRep_Tool::Curve(TopoDS::Edge(anE),f,l);
- GeomAdaptor_Curve AC(G3d,f,l);
+ Handle(GeomAdaptor_Curve) AC = new GeomAdaptor_Curve(G3d,f,l);
PerformCurve(Parameters, Points, AC, aDefl, f,
l, Precision::Confusion(), 2);
static Standard_Boolean PerformCurve (TColStd_SequenceOfReal& Parameters,
TColgp_SequenceOfPnt& Points,
- const Adaptor3d_Curve& C,
+ const Handle(Adaptor3d_Curve)& C,
const Standard_Real Deflection,
const Standard_Real U1,
const Standard_Real U2,
gp_Pnt Pdeb, Pfin;
gp_Vec Ddeb,Dfin;
- C.D1(UU1,Pdeb,Ddeb);
+ C->D1(UU1,Pdeb,Ddeb);
Parameters.Append(UU1);
Points.Append(Pdeb);
- C.D1(UU2,Pfin,Dfin);
+ C->D1(UU2,Pfin,Dfin);
const Standard_Real aDelta = UU2 - UU1;
const Standard_Real aDist = Pdeb.Distance(Pfin);
//purpose :
//=======================================================================
-static void QuasiFleche(const Adaptor3d_Curve& C,
+static void QuasiFleche(const Handle(Adaptor3d_Curve)& C,
const Standard_Real Deflection2,
const Standard_Real Udeb,
gp_Vec Vdelta;
if (Nbmin > 2) {
Udelta /=(Nbmin-1);
- C.D1(Udeb+Udelta,Pdelta,Vdelta);
+ C->D1(Udeb+Udelta,Pdelta,Vdelta);
}
else {
Pdelta = Pfin;
}
if (!flecheok) {
gp_Pnt Pmid((Pdeb.XYZ()+Pdelta.XYZ())/2.);
- gp_Pnt Pverif(C.Value(Udeb+Udelta/2.));
+ gp_Pnt Pverif(C->Value(Udeb+Udelta/2.));
theFleche = Pmid.SquareDistance(Pverif);
}
Standard_Real U1 = BRep_Tool::Parameter(V1,Edge1);
Standard_Real U2 = BRep_Tool::Parameter(V2,Edge2);
- BRepAdaptor_Curve Curve1(Edge1);
- BRepAdaptor_Curve Curve2(Edge2);
+ Handle(BRepAdaptor_Curve) Curve1 = new BRepAdaptor_Curve(Edge1);
+ Handle(BRepAdaptor_Curve) Curve2 = new BRepAdaptor_Curve(Edge2);
Standard_Real Eps = BRep_Tool::Tolerance(V2) +
BRep_Tool::Tolerance(V1);
GeomAbs_Shape cont;
Iso->D0((Iso->FirstParameter()+Iso->LastParameter())/2, P);
// if (P.Distance(BT.Pnt(V)) < tol) {
if (P.Distance(BRep_Tool::Pnt(V)) < tol) {
- GeomAdaptor_Curve AC(Iso);
+ Handle(GeomAdaptor_Curve) AC = new GeomAdaptor_Curve(Iso);
sing = GCPnts_AbscissaPoint::Length(AC, tol/4) < tol;
}
}
Standard_Real tol = BRep_Tool::Tolerance(Vf);
Iso->D0((Iso->FirstParameter()+Iso->LastParameter())/2, Pmid);
if (Pmid.Distance(BRep_Tool::Pnt(Vf)) < tol) {
- GeomAdaptor_Curve AC(Iso);
+ Handle(GeomAdaptor_Curve) AC = new GeomAdaptor_Curve(Iso);
sing = GCPnts_AbscissaPoint::Length(AC, tol/4) < tol;
}
}
for (ii=1, dt = (Umax-Umin)/(Nb+1); B && (ii<=Nb); ii++) {
t = Umin + ii*dt;
Iso = S->UIso(t);
- GeomAdaptor_Curve AC(Iso);
+ Handle(GeomAdaptor_Curve) AC = new GeomAdaptor_Curve(Iso);
l = GC.Length(AC, Tol/4);
B = (l <= Tol);
}
for (ii=1, dt = (Vmax-Vmin)/(Nb+1); B && (ii<=Nb); ii++) {
t = Vmin + ii*dt;
Iso = S->VIso(t);
- GeomAdaptor_Curve AC(Iso);
+ Handle(GeomAdaptor_Curve) AC = new GeomAdaptor_Curve(Iso);
l = GC.Length(AC, Tol/4);
B = (l <= Tol);
}
BRepFill_TrimEdgeTool::BRepFill_TrimEdgeTool()
{
+ myBis = new Geom2dAdaptor_Curve();
}
// return the simple expression of the bissectrice
Handle(Geom2d_Curve) Bis;
SimpleExpression(myBisec, Bis);
- myBis = Geom2dAdaptor_Curve(Bis);
+ myBis = new Geom2dAdaptor_Curve(Bis);
#ifdef DRAW
if ( Affich) {
char* myBisname = "myBis";
//purpose :
//=======================================================================
-static void EvalParameters(const Geom2dAdaptor_Curve& Bis,
- const Geom2dAdaptor_Curve& AC,
+static void EvalParameters(const Handle(Geom2dAdaptor_Curve)& Bis,
+ const Handle(Geom2dAdaptor_Curve)& AC,
TColgp_SequenceOfPnt& Params)
{
Geom2dInt_GInter Intersector;
Standard_Real Tol = Precision::Confusion();
// Standard_Real TolC = 1.e-9;
- Geom2dAdaptor_Curve CBis(Bis);
- Geom2dAdaptor_Curve CAC (AC);
+ Handle(Geom2dAdaptor_Curve) CBis = Handle(Geom2dAdaptor_Curve)::DownCast(Bis->ShallowCopy());
+ Handle(Geom2dAdaptor_Curve) CAC = Handle(Geom2dAdaptor_Curve)::DownCast(AC->ShallowCopy());
//Intersector = Geom2dInt_GInter(CBis, CAC, TolC, Tol);
Intersector = Geom2dInt_GInter(CAC, CBis, Tol, Tol);
Seg = Intersector.Segment(i);
U1 = Seg.FirstPoint().ParamOnSecond();
Standard_Real Ulast = Seg.LastPoint().ParamOnSecond();
- if ( Abs(U1 - CBis.FirstParameter()) <= Tol &&
- Abs(Ulast - CBis.LastParameter()) <= Tol ) {
+ if ( Abs(U1 - CBis->FirstParameter()) <= Tol &&
+ Abs(Ulast - CBis->LastParameter()) <= Tol ) {
P = gp_Pnt(U1,Seg.FirstPoint().ParamOnFirst(),0.);
Params.Append(P);
P = gp_Pnt(Ulast,Seg.LastPoint().ParamOnFirst(),0.);
Bubble( Params);
}
-static void EvalParametersBis(const Geom2dAdaptor_Curve& Bis,
- const Geom2dAdaptor_Curve& AC,
+static void EvalParametersBis(const Handle(Geom2dAdaptor_Curve)& Bis,
+ const Handle(Geom2dAdaptor_Curve)& AC,
TColgp_SequenceOfPnt& Params,
const Standard_Real Tol)
{
Geom2dInt_GInter Intersector;
Standard_Real TolC = Tol;
- Geom2dAdaptor_Curve CBis(Bis);
- Geom2dAdaptor_Curve CAC (AC);
+ Handle(Geom2dAdaptor_Curve) CBis = Handle(Geom2dAdaptor_Curve)::DownCast(Bis->ShallowCopy());
+ Handle(Geom2dAdaptor_Curve) CAC = Handle(Geom2dAdaptor_Curve)::DownCast(AC->ShallowCopy());
Intersector = Geom2dInt_GInter(CAC, CBis, TolC, Tol);
Seg = Intersector.Segment(i);
U1 = Seg.FirstPoint().ParamOnSecond();
Standard_Real Ulast = Seg.LastPoint().ParamOnSecond();
- if ( Abs(U1 - CBis.FirstParameter()) <= Tol &&
- Abs(Ulast - CBis.LastParameter()) <= Tol ) {
+ if ( Abs(U1 - CBis->FirstParameter()) <= Tol &&
+ Abs(Ulast - CBis->LastParameter()) <= Tol ) {
P = gp_Pnt(U1,Seg.FirstPoint().ParamOnFirst(),0.);
Params.Append(P);
P = gp_Pnt(Ulast,Seg.LastPoint().ParamOnFirst(),0.);
Handle(Geom2d_Curve) C1;
BRep_Tool::CurveOnSurface(Edge1,C1,Surf,L,f,l);
- Geom2dAdaptor_Curve AC1(C1,f,l);
+ Handle(Geom2dAdaptor_Curve) AC1 = new Geom2dAdaptor_Curve(C1,f,l);
Handle(Geom2d_Curve) C2;
BRep_Tool::CurveOnSurface(Edge2,C2,Surf,L,f,l);
- Geom2dAdaptor_Curve AC2(C2,f,l);
+ Handle(Geom2dAdaptor_Curve) AC2 = new Geom2dAdaptor_Curve(C2,f,l);
#ifdef DRAW
if ( AffichInt) {
- f = AC1.FirstParameter();
- l = AC1.LastParameter();
+ f = AC1->FirstParameter();
+ l = AC1->LastParameter();
char name[32];
sprintf(name,"C1_%d", ++intind);
DrawTrSurf::Set(name, new Geom2d_TrimmedCurve(C1,f,l));
- f = AC2.FirstParameter();
- l = AC2.LastParameter();
+ f = AC2->FirstParameter();
+ l = AC2->LastParameter();
sprintf(name,"C2_%d", intind);
DrawTrSurf::Set(name, new Geom2d_TrimmedCurve(C2,f,l));
- f = myBis.FirstParameter();
- l = myBis.LastParameter();
+ f = myBis->FirstParameter();
+ l = myBis->LastParameter();
sprintf(name,"BIS%d", intind);
- DrawTrSurf::Set(name, new Geom2d_TrimmedCurve(myBis.Curve(),f,l));
+ DrawTrSurf::Set(name, new Geom2d_TrimmedCurve(myBis->Curve(),f,l));
sprintf(name,"E1_%d", intind);
DBRep::Set(name, Edge1);
sprintf(name,"E2_%d", intind);
Standard_Real TolInit= 1.e-9;
Standard_Integer nn = 7;
- if((AC1.GetType() != GeomAbs_Circle && AC1.GetType() != GeomAbs_Line) ||
- (AC2.GetType() != GeomAbs_Circle && AC2.GetType() != GeomAbs_Line)) {
+ if((AC1->GetType() != GeomAbs_Circle && AC1->GetType() != GeomAbs_Line) ||
+ (AC2->GetType() != GeomAbs_Circle && AC2->GetType() != GeomAbs_Line)) {
TolInit = 1.e-8;
nn = 6;
{
//Check, may be there are no intersections at all
// for case myBis == Line
- if(myBis.GetType() == GeomAbs_Line)
+ if(myBis->GetType() == GeomAbs_Line)
{
Standard_Real dmax = TolInit;
Standard_Integer n = 0;
}
dmax *= dmax;
//
- gp_Lin2d anL = myBis.Line();
+ gp_Lin2d anL = myBis->Line();
Standard_Boolean isFar1 = Standard_True;
Standard_Boolean isFar2 = Standard_True;
gp_Pnt2d aP;
//
Standard_Real d = RealLast();
- AC1.D0(AC1.FirstParameter(), aP);
+ AC1->D0(AC1->FirstParameter(), aP);
Standard_Real par = ElCLib::Parameter(anL, aP);
- if(par >= myBis.FirstParameter() && par <= myBis.LastParameter())
+ if(par >= myBis->FirstParameter() && par <= myBis->LastParameter())
{
d = anL.SquareDistance(aP);
}
- AC1.D0(AC1.LastParameter(), aP);
+ AC1->D0(AC1->LastParameter(), aP);
par = ElCLib::Parameter(anL, aP);
- if(par >= myBis.FirstParameter() && par <= myBis.LastParameter())
+ if(par >= myBis->FirstParameter() && par <= myBis->LastParameter())
{
d = Min(anL.SquareDistance(aP), d);
}
isFar1 = d > dmax;
//
d = RealLast();
- AC2.D0(AC2.FirstParameter(), aP);
+ AC2->D0(AC2->FirstParameter(), aP);
par = ElCLib::Parameter(anL, aP);
- if(par >= myBis.FirstParameter() && par <= myBis.LastParameter())
+ if(par >= myBis->FirstParameter() && par <= myBis->LastParameter())
{
d = anL.SquareDistance(aP);
}
- AC2.D0(AC2.LastParameter(), aP);
+ AC2->D0(AC2->LastParameter(), aP);
par = ElCLib::Parameter(anL, aP);
- if(par >= myBis.FirstParameter() && par <= myBis.LastParameter())
+ if(par >= myBis->FirstParameter() && par <= myBis->LastParameter())
{
d = Min(anL.SquareDistance(aP), d);
}
//std::cout << "Params.Length() == 0 && Points2.Length() == 1" << std::endl;
Standard_Real dmin, dmax = 0.25*myOffset*myOffset;
Standard_Real tBis = Points2(1).X();
- gp_Pnt2d PBis = myBis.Value(tBis);
+ gp_Pnt2d PBis = myBis->Value(tBis);
- Standard_Real t = AC1.FirstParameter();
- gp_Pnt2d PC = AC1.Value(t);
+ Standard_Real t = AC1->FirstParameter();
+ gp_Pnt2d PC = AC1->Value(t);
dmin = PC.SquareDistance(PBis);
gp_Pnt P(tBis, t, 0.);
if(dmin < dmax)
Params.Append(P);
}
- t = AC1.LastParameter();
- PC = AC1.Value(t);
+ t = AC1->LastParameter();
+ PC = AC1->Value(t);
Standard_Real dmin1 = PC.SquareDistance(PBis);
if(dmin > dmin1 && dmin1 < dmax ) {
P.SetY(t);
//std::cout << "Params.Length() == 1 && Points2.Length() == 0" << std::endl;
Standard_Real dmin, dmax = 0.25*myOffset*myOffset;
Standard_Real tBis = Params(1).X();
- gp_Pnt2d PBis = myBis.Value(tBis);
+ gp_Pnt2d PBis = myBis->Value(tBis);
- Standard_Real t = AC2.FirstParameter();
- gp_Pnt2d PC = AC2.Value(t);
+ Standard_Real t = AC2->FirstParameter();
+ gp_Pnt2d PC = AC2->Value(t);
dmin = PC.SquareDistance(PBis);
gp_Pnt P(tBis, t, 0.);
if(dmin < dmax)
Points2.Append(P);
}
- t = AC2.LastParameter();
- PC = AC2.Value(t);
+ t = AC2->LastParameter();
+ PC = AC2->Value(t);
Standard_Real dmin1 = PC.SquareDistance(PBis);
if(dmin > dmin1 && dmin1 < dmax ) {
P.SetY(t);
{
Standard_Real Delta = 2*M_PI - IC1.LastParameter() + IC1.FirstParameter();
if (ToExtendFirstPar && ToExtendLastPar)
- init_fpar = AC1.FirstParameter() + Delta/2;
+ init_fpar = AC1->FirstParameter() + Delta/2;
else if (ToExtendFirstPar)
- init_fpar = AC1.FirstParameter() + Delta;
+ init_fpar = AC1->FirstParameter() + Delta;
else if (ToExtendLastPar)
- init_fpar = AC1.FirstParameter();
+ init_fpar = AC1->FirstParameter();
init_lpar = init_fpar + IC1.LastParameter() - IC1.FirstParameter();
}
}
Geom2dAdaptor_Curve AC1(C1,f,l);
- if (Start) PBis = myBis.Value(myBis.FirstParameter());
- else PBis = myBis.Value(myBis.LastParameter ());
+ if (Start) PBis = myBis->Value(myBis->FirstParameter());
+ else PBis = myBis->Value(myBis->LastParameter ());
// Test if the end of the bissectrice is in the set of intersection points.
if (!Params.IsEmpty()) {
Projector1.LowerDistanceParameter(),
Projector2.LowerDistanceParameter());
if (Start) {
- PInt.SetX (myBis.FirstParameter());
+ PInt.SetX (myBis->FirstParameter());
Params.Prepend(PInt);
}
else {
- PInt.SetX (myBis.LastParameter());
+ PInt.SetX (myBis->LastParameter());
Params.Append(PInt);
}
}
Handle(Geom2d_Curve) myC2;
Standard_Real myOffset;
Bisector_Bisec myBisec;
- Geom2dAdaptor_Curve myBis;
+ Handle(Geom2dAdaptor_Curve) myBis;
};
for (TopoDS_Iterator iter (aWire); iter.More(); iter.Next())
{
const TopoDS_Edge& anEdge = TopoDS::Edge( iter.Value() );
- BRepAdaptor_Curve aCurve(anEdge);
+ Handle(BRepAdaptor_Curve) aCurve = new BRepAdaptor_Curve(anEdge);
GCPnts_UniformAbscissa Distribution( aCurve, N+1 );
for (i = 1; i <= N; i++)
{
Standard_Real par = Distribution.Parameter(i);
- Pnts( ind++ ) = aCurve.Value(par);
+ Pnts( ind++ ) = aCurve->Value(par);
}
}
// projection of 3d curves in the plane xOy
Handle(Geom2d_Curve) C2d = GeomProjLib::Curve2d(CT,Plane);
- Geom2dAdaptor_Curve AC(C2d);
- Geom2dAdaptor_Curve ABis(Bis);
+ Handle(Geom2dAdaptor_Curve) AC = new Geom2dAdaptor_Curve(C2d);
+ Handle(Geom2dAdaptor_Curve) ABis = new Geom2dAdaptor_Curve(Bis);
Intersector = Geom2dInt_GInter(ABis, AC, TolC, Tol);
// don't do it rightaway from the beginning in order not to get
// extra solutions those would cause *Exception*: incoherent intersection
- GeomAbs_CurveType CType = AC.GetType(), BisType = ABis.GetType();
+ GeomAbs_CurveType CType = AC->GetType(), BisType = ABis->GetType();
Standard_Boolean canElongateC = !(CType == GeomAbs_BezierCurve ||
CType == GeomAbs_BSplineCurve ||
CType == GeomAbs_OffsetCurve ||
if (canElongateC) {
TC2d->SetTrim(TC2d->FirstParameter() - Tol, TC2d->LastParameter() + Tol);
- AC.Load(TC2d);
+ AC->Load(TC2d);
}
if (canElongateBis) {
TBis->SetTrim(TBis->FirstParameter() - Tol, TBis->LastParameter() + Tol);
- ABis.Load(TBis);
+ ABis->Load(TBis);
}
Intersector = Geom2dInt_GInter(ABis, AC, TolC, Tol*10);
P.Transform(S.Location());
SProps = GProp_GProps(P);
- BRepAdaptor_Curve BAC;
+ Handle(BRepAdaptor_Curve) BAC = new BRepAdaptor_Curve();
TopTools_MapOfShape anEMap;
TopExp_Explorer ex;
for (ex.Init(S,TopAbs_EDGE); ex.More(); ex.Next()) {
{
if (IsGeom)
{
- BAC.Initialize(aE);
+ BAC->Initialize(aE);
BRepGProp_Cinert CG(BAC, P);
SProps.Add(CG);
}
loc = CLocation;
}
-void BRepGProp_Cinert::Perform (const BRepAdaptor_Curve& C)
+void BRepGProp_Cinert::Perform (const Handle(BRepAdaptor_Curve)& C)
{
Standard_Real Ix, Iy, Iz, Ixx, Iyy, Izz, Ixy, Ixz, Iyz;
}
-BRepGProp_Cinert::BRepGProp_Cinert (const BRepAdaptor_Curve& C,
+BRepGProp_Cinert::BRepGProp_Cinert (const Handle(BRepAdaptor_Curve)& C,
const gp_Pnt& CLocation)
{
SetLocation(CLocation);
Standard_EXPORT BRepGProp_Cinert();
- Standard_EXPORT BRepGProp_Cinert(const BRepAdaptor_Curve& C, const gp_Pnt& CLocation);
+ Standard_EXPORT BRepGProp_Cinert(const Handle(BRepAdaptor_Curve)& C, const gp_Pnt& CLocation);
Standard_EXPORT void SetLocation (const gp_Pnt& CLocation);
- Standard_EXPORT void Perform (const BRepAdaptor_Curve& C);
+ Standard_EXPORT void Perform (const Handle(BRepAdaptor_Curve)& C);
#include <gp_Pnt.hxx>
#include <gp_Vec.hxx>
-Standard_Real BRepGProp_EdgeTool::FirstParameter(const BRepAdaptor_Curve& C)
+Standard_Real BRepGProp_EdgeTool::FirstParameter(const Handle(BRepAdaptor_Curve)& C)
{
- return C.FirstParameter();
+ return C->FirstParameter();
}
-Standard_Real BRepGProp_EdgeTool::LastParameter(const BRepAdaptor_Curve& C)
+Standard_Real BRepGProp_EdgeTool::LastParameter(const Handle(BRepAdaptor_Curve)& C)
{
- return C.LastParameter();
+ return C->LastParameter();
}
-Standard_Integer BRepGProp_EdgeTool::IntegrationOrder(const BRepAdaptor_Curve& BAC)
+Standard_Integer BRepGProp_EdgeTool::IntegrationOrder(const Handle(BRepAdaptor_Curve)& BAC)
{
- switch (BAC.GetType()) {
+ switch (BAC->GetType()) {
case GeomAbs_Line :
return 2;
case GeomAbs_BezierCurve :
{
- const GeomAdaptor_Curve& GAC = BAC.Curve();
- const Handle(Geom_Curve)& GC = GAC.Curve();
+ const Handle(GeomAdaptor_Curve)& GAC = BAC->Curve();
+ const Handle(Geom_Curve)& GC = GAC->Curve();
Handle(Geom_BezierCurve) GBZC (Handle(Geom_BezierCurve)::DownCast (GC));
Standard_Integer n = 2*(GBZC->NbPoles()) - 1;
return n;
break;
case GeomAbs_BSplineCurve :
{
- const GeomAdaptor_Curve& GAC = BAC.Curve();
- const Handle(Geom_Curve)& GC = GAC.Curve();
+ const Handle(GeomAdaptor_Curve)& GAC = BAC->Curve();
+ const Handle(Geom_Curve)& GC = GAC->Curve();
Handle(Geom_BSplineCurve) GBSC (Handle(Geom_BSplineCurve)::DownCast (GC));
Standard_Integer n = 2*(GBSC->NbPoles()) - 1;
return n;
}
}
-gp_Pnt BRepGProp_EdgeTool::Value(const BRepAdaptor_Curve& C, const Standard_Real U)
+gp_Pnt BRepGProp_EdgeTool::Value(const Handle(BRepAdaptor_Curve)& C, const Standard_Real U)
{
- return C.Value(U);
+ return C->Value(U);
}
-void BRepGProp_EdgeTool::D1(const BRepAdaptor_Curve& C,
+void BRepGProp_EdgeTool::D1(const Handle(BRepAdaptor_Curve)& C,
const Standard_Real U, gp_Pnt& P, gp_Vec& V1)
{
- C.D1(U,P,V1);
+ C->D1(U,P,V1);
}
// modified by NIZHNY-MKK Thu Jun 9 12:15:15 2005.BEGIN
-Standard_Integer BRepGProp_EdgeTool::NbIntervals(const BRepAdaptor_Curve& C,const GeomAbs_Shape S)
+Standard_Integer BRepGProp_EdgeTool::NbIntervals(const Handle(BRepAdaptor_Curve)& C,const GeomAbs_Shape S)
{
- BRepAdaptor_Curve* pC = (BRepAdaptor_Curve*) &C; // at the moment actually NbIntervals() does not modify the
- // object "C". So it is safe to do such a cast.
- return pC->NbIntervals(S);
+ return C->NbIntervals(S);
}
-void BRepGProp_EdgeTool::Intervals(const BRepAdaptor_Curve& C,TColStd_Array1OfReal& T,const GeomAbs_Shape S)
+void BRepGProp_EdgeTool::Intervals(const Handle(BRepAdaptor_Curve)& C,TColStd_Array1OfReal& T,const GeomAbs_Shape S)
{
- BRepAdaptor_Curve* pC = (BRepAdaptor_Curve*) &C; // at the moment actually Intervals() does not modify the
- // object "C". So it is safe to do such a cast.
- pC->Intervals(T, S);
+ C->Intervals(T, S);
}
// modified by NIZHNY-MKK Thu Jun 9 12:15:18 2005.END
//! Returns the parametric value of the start point of
//! the curve. The curve is oriented from the start point
//! to the end point.
- Standard_EXPORT static Standard_Real FirstParameter (const BRepAdaptor_Curve& C);
+ Standard_EXPORT static Standard_Real FirstParameter (const Handle(BRepAdaptor_Curve)& C);
//! Returns the parametric value of the end point of
//! the curve. The curve is oriented from the start point
//! to the end point.
- Standard_EXPORT static Standard_Real LastParameter (const BRepAdaptor_Curve& C);
+ Standard_EXPORT static Standard_Real LastParameter (const Handle(BRepAdaptor_Curve)& C);
//! Returns the number of Gauss points required to do
//! Gauss method. For a polynomial curve of degree n
//! the maxima of accuracy is obtained with an order
//! of integration equal to 2*n-1.
- Standard_EXPORT static Standard_Integer IntegrationOrder (const BRepAdaptor_Curve& C);
+ Standard_EXPORT static Standard_Integer IntegrationOrder (const Handle(BRepAdaptor_Curve)& C);
//! Returns the point of parameter U on the loaded curve.
- Standard_EXPORT static gp_Pnt Value (const BRepAdaptor_Curve& C, const Standard_Real U);
+ Standard_EXPORT static gp_Pnt Value (const Handle(BRepAdaptor_Curve)& C, const Standard_Real U);
//! Returns the point of parameter U and the first derivative
//! at this point.
- Standard_EXPORT static void D1 (const BRepAdaptor_Curve& C, const Standard_Real U, gp_Pnt& P, gp_Vec& V1);
+ Standard_EXPORT static void D1 (const Handle(BRepAdaptor_Curve)& C, const Standard_Real U, gp_Pnt& P, gp_Vec& V1);
//! Returns the number of intervals for continuity
//! <S>. May be one if Continuity(me) >= <S>
- Standard_EXPORT static Standard_Integer NbIntervals (const BRepAdaptor_Curve& C, const GeomAbs_Shape S);
+ Standard_EXPORT static Standard_Integer NbIntervals (const Handle(BRepAdaptor_Curve)& C, const GeomAbs_Shape S);
//! Stores in <T> the parameters bounding the intervals
//! of continuity <S>.
//!
//! The array must provide enough room to accommodate
//! for the parameters. i.e. T.Length() > NbIntervals()
- Standard_EXPORT static void Intervals (const BRepAdaptor_Curve& C, TColStd_Array1OfReal& T, const GeomAbs_Shape S);
+ Standard_EXPORT static void Intervals (const Handle(BRepAdaptor_Curve)& C, TColStd_Array1OfReal& T, const GeomAbs_Shape S);
Standard_Integer BRepGProp_Face::UIntegrationOrder() const {
Standard_Integer Nu;
- switch (mySurface.GetType())
+ switch (mySurface->GetType())
{
case GeomAbs_Plane :
case GeomAbs_BezierSurface :
{
- Nu = (*((Handle(Geom_BezierSurface)*)&((mySurface.Surface()).Surface())))->UDegree()+1;
+ Nu = (*((Handle(Geom_BezierSurface)*)&((mySurface->Surface())->Surface())))->UDegree()+1;
Nu = Max(4,Nu);
}
break;
case GeomAbs_BSplineSurface :
{
- Standard_Integer a = (*((Handle(Geom_BSplineSurface)*)&((mySurface.Surface()).Surface())))->UDegree()+1;
- Standard_Integer b = (*((Handle(Geom_BSplineSurface)*)&((mySurface.Surface()).Surface())))->NbUKnots()-1;
+ Standard_Integer a = (*((Handle(Geom_BSplineSurface)*)&((mySurface->Surface())->Surface())))->UDegree()+1;
+ Standard_Integer b = (*((Handle(Geom_BSplineSurface)*)&((mySurface->Surface())->Surface())))->NbUKnots()-1;
Nu = Max(4,a*b);
}
break;
Standard_Integer BRepGProp_Face::VIntegrationOrder() const
{
Standard_Integer Nv;
- switch (mySurface.GetType()) {
+ switch (mySurface->GetType()) {
case GeomAbs_Plane :
Nv = 4;
case GeomAbs_BezierSurface :
{
- Nv = (*((Handle(Geom_BezierSurface)*)&((mySurface.Surface()).Surface())))->VDegree()+1;
+ Nv = (*((Handle(Geom_BezierSurface)*)&((mySurface->Surface())->Surface())))->VDegree()+1;
Nv = Max(4,Nv);
}
break;
case GeomAbs_BSplineSurface :
{
- Standard_Integer a = (*((Handle(Geom_BSplineSurface)*)&((mySurface.Surface()).Surface())))->VDegree()+1;
- Standard_Integer b = (*((Handle(Geom_BSplineSurface)*)&((mySurface.Surface()).Surface())))->NbVKnots()-1;
+ Standard_Integer a = (*((Handle(Geom_BSplineSurface)*)&((mySurface->Surface())->Surface())))->VDegree()+1;
+ Standard_Integer b = (*((Handle(Geom_BSplineSurface)*)&((mySurface->Surface())->Surface())))->NbVKnots()-1;
Nv = Max(4,a*b);
}
break;
{
Standard_Integer N;
- switch (myCurve.GetType()) {
+ switch (myCurve->GetType()) {
case GeomAbs_Line :
N = 2;
case GeomAbs_BezierCurve :
{
- N = (*((Handle(Geom2d_BezierCurve)*)&(myCurve.Curve())))->Degree() + 1;
+ N = (*((Handle(Geom2d_BezierCurve)*)&(myCurve->Curve())))->Degree() + 1;
}
break;
case GeomAbs_BSplineCurve :
{
- Standard_Integer a = (*((Handle(Geom2d_BSplineCurve)*)&(myCurve.Curve())))->Degree() + 1;
- Standard_Integer b = (*((Handle(Geom2d_BSplineCurve)*)&(myCurve.Curve())))->NbKnots() - 1;
+ Standard_Integer a = (*((Handle(Geom2d_BSplineCurve)*)&(myCurve->Curve())))->Degree() + 1;
+ Standard_Integer b = (*((Handle(Geom2d_BSplineCurve)*)&(myCurve->Curve())))->NbKnots() - 1;
N = a * b;
}
break;
Standard_Real& V1,
Standard_Real& V2)const
{
- U1 = mySurface.FirstUParameter();
- U2 = mySurface.LastUParameter();
- V1 = mySurface.FirstVParameter();
- V2 = mySurface.LastVParameter();
+ U1 = mySurface->FirstUParameter();
+ U2 = mySurface->LastUParameter();
+ V1 = mySurface->FirstVParameter();
+ V2 = mySurface->LastVParameter();
}
//=======================================================================
bool BRepGProp_Face::Load(const TopoDS_Edge& E)
{
Standard_Real a,b;
- Handle(Geom2d_Curve) C = BRep_Tool::CurveOnSurface(E, mySurface.Face(), a,b);
+ Handle(Geom2d_Curve) C = BRep_Tool::CurveOnSurface(E, mySurface->Face(), a,b);
if (C.IsNull())
{
return false;
b = C->ReversedParameter(x);
C = C->Reversed();
}
- myCurve.Load(C,a,b);
+ myCurve->Load(C,a,b);
return true;
}
void BRepGProp_Face::Load(const TopoDS_Face& F)
{
TopoDS_Shape aLocalShape = F.Oriented(TopAbs_FORWARD);
- mySurface.Initialize(TopoDS::Face(aLocalShape));
-// mySurface.Initialize(TopoDS::Face(F.Oriented(TopAbs_FORWARD)));
+ mySurface->Initialize(TopoDS::Face(aLocalShape));
+// mySurface->Initialize(TopoDS::Face(F.Oriented(TopAbs_FORWARD)));
mySReverse = (F.Orientation() == TopAbs_REVERSED);
}
gp_Vec &VNor) const
{
gp_Vec D1U,D1V;
- mySurface.D1(U,V,P,D1U,D1V);
+ mySurface->D1(U,V,P,D1U,D1V);
VNor = D1U.Crossed(D1V);
if (mySReverse) VNor.Reverse();
Standard_Integer BRepGProp_Face::SIntOrder(const Standard_Real Eps) const
{
Standard_Integer Nv, Nu;
- switch (mySurface.GetType()) {
+ switch (mySurface->GetType()) {
case GeomAbs_Plane:
Nu = 1; Nv = 1; break;
case GeomAbs_Cylinder:
case GeomAbs_Torus:
Nu = 2; Nv = 2; break;
case GeomAbs_BezierSurface:
- Nv = (*((Handle(Geom_BezierSurface)*)&((mySurface.Surface()).Surface())))->VDegree();
- Nu = (*((Handle(Geom_BezierSurface)*)&((mySurface.Surface()).Surface())))->UDegree();
+ Nv = (*((Handle(Geom_BezierSurface)*)&((mySurface->Surface())->Surface())))->VDegree();
+ Nu = (*((Handle(Geom_BezierSurface)*)&((mySurface->Surface())->Surface())))->UDegree();
break;
case GeomAbs_BSplineSurface:
- Nv = (*((Handle(Geom_BSplineSurface)*)&((mySurface.Surface()).Surface())))->VDegree();
- Nu = (*((Handle(Geom_BSplineSurface)*)&((mySurface.Surface()).Surface())))->UDegree();
+ Nv = (*((Handle(Geom_BSplineSurface)*)&((mySurface->Surface())->Surface())))->VDegree();
+ Nu = (*((Handle(Geom_BSplineSurface)*)&((mySurface->Surface())->Surface())))->UDegree();
break;
default:
Nu = 2; Nv = 2; break;
Standard_Integer BRepGProp_Face::SUIntSubs() const
{
Standard_Integer N;
- switch (mySurface.GetType()) {
+ switch (mySurface->GetType()) {
case GeomAbs_Plane:
N = 2; break;
case GeomAbs_Cylinder:
case GeomAbs_BezierSurface:
N = 2; break;
case GeomAbs_BSplineSurface:
- N = (*((Handle(Geom_BSplineSurface)*)&((mySurface.Surface()).Surface())))->NbUKnots(); break;
+ N = (*((Handle(Geom_BSplineSurface)*)&((mySurface->Surface())->Surface())))->NbUKnots(); break;
default:
N = 2; break;
}
Standard_Integer BRepGProp_Face::SVIntSubs() const
{
Standard_Integer N;
- switch (mySurface.GetType()) {
+ switch (mySurface->GetType()) {
case GeomAbs_Plane:
N = 2; break;
case GeomAbs_Cylinder:
case GeomAbs_BezierSurface:
N = 2; break;
case GeomAbs_BSplineSurface:
- N = (*((Handle(Geom_BSplineSurface)*)&((mySurface.Surface()).Surface())))->NbVKnots();
+ N = (*((Handle(Geom_BSplineSurface)*)&((mySurface->Surface())->Surface())))->NbVKnots();
break;
default:
N = 2; break;
void BRepGProp_Face::UKnots(TColStd_Array1OfReal& Knots) const
{
- switch (mySurface.GetType()) {
+ switch (mySurface->GetType()) {
case GeomAbs_Plane:
- Knots(1) = mySurface.FirstUParameter(); Knots(2) = mySurface.LastUParameter();
+ Knots(1) = mySurface->FirstUParameter(); Knots(2) = mySurface->LastUParameter();
break;
case GeomAbs_Cylinder:
case GeomAbs_Cone:
Knots(1) = 0.0; Knots(2) = M_PI*2.0/3.0; Knots(3) = M_PI*4.0/3.0; Knots(4) = M_PI*6.0/3.0;
break;
case GeomAbs_BSplineSurface:
- (*((Handle(Geom_BSplineSurface)*)&((mySurface.Surface()).Surface())))->UKnots(Knots);
+ (*((Handle(Geom_BSplineSurface)*)&((mySurface->Surface())->Surface())))->UKnots(Knots);
break;
default:
- Knots(1) = mySurface.FirstUParameter(); Knots(2) = mySurface.LastUParameter();
+ Knots(1) = mySurface->FirstUParameter(); Knots(2) = mySurface->LastUParameter();
break;
}
}
void BRepGProp_Face::VKnots(TColStd_Array1OfReal& Knots) const
{
- switch (mySurface.GetType()) {
+ switch (mySurface->GetType()) {
case GeomAbs_Plane:
case GeomAbs_Cylinder:
case GeomAbs_Cone:
- Knots(1) = mySurface.FirstUParameter(); Knots(2) = mySurface.LastUParameter();
+ Knots(1) = mySurface->FirstUParameter(); Knots(2) = mySurface->LastUParameter();
break;
case GeomAbs_Sphere:
Knots(1) = -M_PI/2.0; Knots(2) = 0.0; Knots(3) = +M_PI/2.0;
Knots(1) = 0.0; Knots(2) = M_PI*2.0/3.0; Knots(3) = M_PI*4.0/3.0; Knots(4) = M_PI*6.0/3.0;
break;
case GeomAbs_BSplineSurface:
- (*((Handle(Geom_BSplineSurface)*)&((mySurface.Surface()).Surface())))->VKnots(Knots);
+ (*((Handle(Geom_BSplineSurface)*)&((mySurface->Surface())->Surface())))->VKnots(Knots);
break;
default:
- Knots(1) = mySurface.FirstUParameter(); Knots(2) = mySurface.LastUParameter();
+ Knots(1) = mySurface->FirstUParameter(); Knots(2) = mySurface->LastUParameter();
break;
}
}
BndLib_Add2dCurve::Add(myCurve, 1.e-7, aBox);
Standard_Real aXmin, aXmax, aYmin, aYmax;
aBox.Get(aXmin, aYmin, aXmax, aYmax);
- Standard_Real aVmin = mySurface.FirstVParameter();
- Standard_Real aVmax = mySurface.LastVParameter();
+ Standard_Real aVmin = mySurface->FirstVParameter();
+ Standard_Real aVmax = mySurface->LastVParameter();
Standard_Real dv = (aVmax-aVmin);
Standard_Real anR = (dv > Epsilon1 ? Min ((aYmax - aYmin) / dv, 1.) : 1.);
// Standard_Real NL, NS = Max(SIntOrder(1.0)*anRInt/LIntSubs(), 1);
Standard_Real NL, NS = Max(SIntOrder(1.)*anRInt/aLSubs, 1);
- switch (myCurve.GetType()) {
+ switch (myCurve->GetType()) {
case GeomAbs_Line:
NL = 1; break;
case GeomAbs_Circle:
case GeomAbs_Hyperbola:
NL = 3 * 3; break;
case GeomAbs_BezierCurve:
- NL = (*((Handle(Geom2d_BezierCurve)*)&(myCurve.Curve())))->Degree();
+ NL = (*((Handle(Geom2d_BezierCurve)*)&(myCurve->Curve())))->Degree();
break;
case GeomAbs_BSplineCurve:
- NL = (*((Handle(Geom2d_BSplineCurve)*)&(myCurve.Curve())))->Degree();
+ NL = (*((Handle(Geom2d_BSplineCurve)*)&(myCurve->Curve())))->Degree();
break;
default:
NL = 3 * 3; break;
Standard_Integer BRepGProp_Face::LIntSubs() const
{
Standard_Integer N;
- switch (myCurve.GetType()) {
+ switch (myCurve->GetType()) {
case GeomAbs_Line:
N = 2; break;
case GeomAbs_Circle:
case GeomAbs_Hyperbola:
N = 2; break;
case GeomAbs_BSplineCurve:
- N = (*((Handle(Geom2d_BSplineCurve)*)&(myCurve.Curve())))->NbKnots();
+ N = (*((Handle(Geom2d_BSplineCurve)*)&(myCurve->Curve())))->NbKnots();
break;
default:
N = 2; break;
void BRepGProp_Face::LKnots(TColStd_Array1OfReal& Knots) const
{
- switch (myCurve.GetType()) {
+ switch (myCurve->GetType()) {
case GeomAbs_Line:
- Knots(1) = myCurve.FirstParameter(); Knots(2) = myCurve.LastParameter();
+ Knots(1) = myCurve->FirstParameter(); Knots(2) = myCurve->LastParameter();
break;
case GeomAbs_Circle:
case GeomAbs_Ellipse:
break;
case GeomAbs_Parabola:
case GeomAbs_Hyperbola:
- Knots(1) = myCurve.FirstParameter(); Knots(2) = myCurve.LastParameter();
+ Knots(1) = myCurve->FirstParameter(); Knots(2) = myCurve->LastParameter();
break;
case GeomAbs_BSplineCurve:
- (*((Handle(Geom2d_BSplineCurve)*)&(myCurve.Curve())))->Knots(Knots);
+ (*((Handle(Geom2d_BSplineCurve)*)&(myCurve->Curve())))->Knots(Knots);
break;
default:
- Knots(1) = myCurve.FirstParameter(); Knots(2) = myCurve.LastParameter();
+ Knots(1) = myCurve->FirstParameter(); Knots(2) = myCurve->LastParameter();
break;
}
}
Handle(Geom2d_Curve) aLin = new Geom2d_Line(aLoc, aDir);
- myCurve.Load(aLin, 0., aLen);
+ myCurve->Load(aLin, 0., aLen);
}
//=======================================================================
static void GetCurveKnots(const Standard_Real theMin,
const Standard_Real theMax,
- const Geom2dAdaptor_Curve &theCurve,
+ const Handle(Geom2dAdaptor_Curve) &theCurve,
Handle(TColStd_HArray1OfReal) &theKnots)
{
- Standard_Boolean isSBSpline = theCurve.GetType() == GeomAbs_BSplineCurve;
+ Standard_Boolean isSBSpline = theCurve->GetType() == GeomAbs_BSplineCurve;
if (isSBSpline) {
Handle(Geom2d_BSplineCurve) aCrv;
Standard_Integer aNbKnots;
Handle(TColStd_HArray1OfReal) aCrvKnots;
- aCrv = Handle(Geom2d_BSplineCurve)::DownCast(theCurve.Curve());
+ aCrv = Handle(Geom2d_BSplineCurve)::DownCast(theCurve->Curve());
aNbKnots = aCrv->NbKnots();
aCrvKnots = new TColStd_HArray1OfReal(1, aNbKnots);
aCrv->Knots(aCrvKnots->ChangeArray1());
const Standard_Real theUMax,
Handle(TColStd_HArray1OfReal) &theUKnots) const
{
- Standard_Boolean isSBSpline = mySurface.GetType() == GeomAbs_BSplineSurface;
+ Standard_Boolean isSBSpline = mySurface->GetType() == GeomAbs_BSplineSurface;
Standard_Boolean isCBSpline = Standard_False;
if (!isSBSpline) {
// Check the basis curve of the surface of linear extrusion.
- if (mySurface.GetType() == GeomAbs_SurfaceOfExtrusion) {
+ if (mySurface->GetType() == GeomAbs_SurfaceOfExtrusion) {
GeomAdaptor_Curve aCurve;
- Handle(Geom_Surface) aSurf = mySurface.Surface().Surface();
+ Handle(Geom_Surface) aSurf = mySurface->Surface()->Surface();
aCurve.Load(Handle(Geom_SurfaceOfLinearExtrusion)::DownCast (aSurf)->BasisCurve());
isCBSpline = aCurve.GetType() == GeomAbs_BSplineCurve;
if (isSBSpline) {
// Get U knots of BSpline surface.
- Handle(Geom_Surface) aSurf = mySurface.Surface().Surface();
+ Handle(Geom_Surface) aSurf = mySurface->Surface()->Surface();
Handle(Geom_BSplineSurface) aBSplSurf;
aBSplSurf = Handle(Geom_BSplineSurface)::DownCast(aSurf);
// Get U knots of BSpline curve - basis curve of
// the surface of linear extrusion.
GeomAdaptor_Curve aCurve;
- Handle(Geom_Surface) aSurf = mySurface.Surface().Surface();
+ Handle(Geom_Surface) aSurf = mySurface->Surface()->Surface();
Handle(Geom_BSplineCurve) aBSplCurve;
aCurve.Load(Handle(Geom_SurfaceOfLinearExtrusion)::DownCast (aSurf)->BasisCurve());
const Standard_Real theTMax,
Handle(TColStd_HArray1OfReal) &theTKnots) const
{
- Standard_Boolean isBSpline = mySurface.GetType() == GeomAbs_BSplineSurface;
+ Standard_Boolean isBSpline = mySurface->GetType() == GeomAbs_BSplineSurface;
if (myIsUseSpan && isBSpline) {
// Using span decomposition for BSpline.
Standard_Integer aNbKnots;
// Get V knots of BSpline surface.
- Handle(Geom_Surface) aSurf = mySurface.Surface().Surface();
+ Handle(Geom_Surface) aSurf = mySurface->Surface()->Surface();
Handle(Geom_BSplineSurface) aBSplSurf;
aBSplSurf = Handle(Geom_BSplineSurface)::DownCast(aSurf);
- BRepAdaptor_Surface mySurface;
- Geom2dAdaptor_Curve myCurve;
+ Handle(BRepAdaptor_Surface) mySurface;
+ Handle(Geom2dAdaptor_Curve) myCurve;
Standard_Boolean mySReverse;
Standard_Boolean myIsUseSpan;
: mySReverse (Standard_False),
myIsUseSpan(IsUseSpan)
{
+ mySurface = new BRepAdaptor_Surface();
+ myCurve = new Geom2dAdaptor_Curve();
}
//=======================================================================
const Standard_Boolean IsUseSpan)
: myIsUseSpan(IsUseSpan)
{
+ mySurface = new BRepAdaptor_Surface();
+ myCurve = new Geom2dAdaptor_Curve();
Load(F);
}
inline Standard_Boolean BRepGProp_Face::NaturalRestriction() const
{
- return BRep_Tool::NaturalRestriction(mySurface.Face());
+ return BRep_Tool::NaturalRestriction(mySurface->Face());
}
//
//=======================================================================
inline const TopoDS_Face& BRepGProp_Face::GetFace() const
{
- return mySurface.Face();
+ return mySurface->Face();
}
//=======================================================================
inline gp_Pnt2d BRepGProp_Face::Value2d(const Standard_Real U) const
{
- return myCurve.Value(U);
+ return myCurve->Value(U);
}
//=======================================================================
gp_Pnt2d &P,
gp_Vec2d &V1) const
{
- myCurve.D1(U,P,V1);
+ myCurve->D1(U,P,V1);
}
//=======================================================================
inline Standard_Real BRepGProp_Face::FirstParameter() const
{
- return myCurve.FirstParameter();
+ return myCurve->FirstParameter();
}
//=======================================================================
inline Standard_Real BRepGProp_Face::LastParameter() const
{
- return myCurve.LastParameter();
+ return myCurve->LastParameter();
}
myCurve = new GeomAdaptor_Curve(theCurve );
if( !Precision::IsInfinite(aFirst) && !Precision::IsInfinite(aLast) )
{
- BndLib_Add3dCurve::Add (*myCurve, 0., myCurveBox);
+ BndLib_Add3dCurve::Add (myCurve, 0., myCurveBox);
}
Find();
}
//function : Continuity
//purpose :
//=======================================================================
-GeomAbs_Shape BRepLProp::Continuity(const BRepAdaptor_Curve& C1,
- const BRepAdaptor_Curve& C2,
+GeomAbs_Shape BRepLProp::Continuity(const Handle(BRepAdaptor_Curve)& C1,
+ const Handle(BRepAdaptor_Curve)& C2,
const Standard_Real u1,
const Standard_Real u2,
const Standard_Real tl,
Standard_Boolean fini = Standard_False;
gp_Vec d1,d2;
gp_Dir dir1,dir2;
- GeomAbs_Shape cont1 = C1.Continuity(), cont2 = C2.Continuity();
+ GeomAbs_Shape cont1 = C1->Continuity(), cont2 = C2->Continuity();
Standard_Integer n1 = 0, n2 = 0;
if (cont1 >= 5) n1 = 3;
else if(cont1 == 4) n1 = 2;
if ( min >= 1 ) {
d1 = clp1.D1();
d2 = clp2.D1();
- if(C1.Edge().Orientation() == TopAbs_REVERSED) d1.Reverse();
- if(C2.Edge().Orientation() == TopAbs_REVERSED) d2.Reverse();
+ if(C1->Edge().Orientation() == TopAbs_REVERSED) d1.Reverse();
+ if(C2->Edge().Orientation() == TopAbs_REVERSED) d2.Reverse();
if(d1.IsEqual(d2,tl,ta)) {
cont = GeomAbs_C1;
}
else if(clp1.IsTangentDefined() && clp2.IsTangentDefined()){
clp1.Tangent(dir1);
clp2.Tangent(dir2);
- if(C1.Edge().Orientation() == TopAbs_REVERSED) dir1.Reverse();
- if(C2.Edge().Orientation() == TopAbs_REVERSED) dir2.Reverse();
+ if(C1->Edge().Orientation() == TopAbs_REVERSED) dir1.Reverse();
+ if(C2->Edge().Orientation() == TopAbs_REVERSED) dir2.Reverse();
if(dir1.IsEqual(dir2,ta)){
cont = GeomAbs_G1;
}
cont = GeomAbs_C2;
}
}
- const TopoDS_Edge& E1 = C1.Edge();
- const TopoDS_Edge& E2 = C2.Edge();
- if (E1.IsSame(E2) && C1.IsPeriodic() && cont >= GeomAbs_G1)
+ const TopoDS_Edge& E1 = C1->Edge();
+ const TopoDS_Edge& E2 = C2->Edge();
+ if (E1.IsSame(E2) && C1->IsPeriodic() && cont >= GeomAbs_G1)
cont = GeomAbs_CN;
return cont;
}
//purpose :
//=======================================================================
-GeomAbs_Shape BRepLProp::Continuity(const BRepAdaptor_Curve& C1,
- const BRepAdaptor_Curve& C2,
+GeomAbs_Shape BRepLProp::Continuity(const Handle(BRepAdaptor_Curve)& C1,
+ const Handle(BRepAdaptor_Curve)& C2,
const Standard_Real u1,
const Standard_Real u2)
{
//! C2. The point u1 on C1 and the point u2 on C2 must be
//! confused. tl and ta are the linear and angular
//! tolerance used two compare the derivative.
- Standard_EXPORT static GeomAbs_Shape Continuity (const BRepAdaptor_Curve& C1, const BRepAdaptor_Curve& C2, const Standard_Real u1, const Standard_Real u2, const Standard_Real tl, const Standard_Real ta);
+ Standard_EXPORT static GeomAbs_Shape Continuity (const Handle(BRepAdaptor_Curve)& C1, const Handle(BRepAdaptor_Curve)& C2, const Standard_Real u1, const Standard_Real u2, const Standard_Real tl, const Standard_Real ta);
//! The same as preceding but using the standard tolerances from package Precision.
- Standard_EXPORT static GeomAbs_Shape Continuity (const BRepAdaptor_Curve& C1, const BRepAdaptor_Curve& C2, const Standard_Real u1, const Standard_Real u2);
+ Standard_EXPORT static GeomAbs_Shape Continuity (const Handle(BRepAdaptor_Curve)& C1, const Handle(BRepAdaptor_Curve)& C2, const Standard_Real u1, const Standard_Real u2);
};
//! only the tangent, N should be equal to 1.
//! <Resolution> is the linear tolerance (it is used to test
//! if a vector is null).
- Standard_EXPORT BRepLProp_CLProps(const BRepAdaptor_Curve& C, const Standard_Integer N, const Standard_Real Resolution);
+ Standard_EXPORT BRepLProp_CLProps(const Handle(BRepAdaptor_Curve)& C, const Standard_Integer N, const Standard_Real Resolution);
//! Same as previous constructor but here the parameter is
//! set to the value <U>.
//! All the computations done will be related to <C> and <U>.
- Standard_EXPORT BRepLProp_CLProps(const BRepAdaptor_Curve& C, const Standard_Real U, const Standard_Integer N, const Standard_Real Resolution);
+ Standard_EXPORT BRepLProp_CLProps(const Handle(BRepAdaptor_Curve)& C, const Standard_Real U, const Standard_Integer N, const Standard_Real Resolution);
//! Same as previous constructor but here the parameter is
//! set to the value <U> and the curve is set
//! Initializes the local properties of the curve
//! for the new curve.
- Standard_EXPORT void SetCurve (const BRepAdaptor_Curve& C);
+ Standard_EXPORT void SetCurve (const Handle(BRepAdaptor_Curve)& C);
//! Returns the Point.
Standard_EXPORT const gp_Pnt& Value() const;
- BRepAdaptor_Curve myCurve;
+ Handle(BRepAdaptor_Curve) myCurve;
Standard_Real myU;
Standard_Integer myDerOrder;
Standard_Real myCN;
#include <BRepLProp_CurveTool.hxx>
-#define Curve BRepAdaptor_Curve
+#define Curve Handle(BRepAdaptor_Curve)
#define Curve_hxx <BRepAdaptor_Curve.hxx>
#define Vec gp_Vec
#define Vec_hxx <gp_Vec.hxx>
//function : Value
//purpose :
//=======================================================================
-void BRepLProp_CurveTool::Value(const BRepAdaptor_Curve& C,
+void BRepLProp_CurveTool::Value(const Handle(BRepAdaptor_Curve)& C,
const Standard_Real U,
gp_Pnt& P)
{
- P = C.Value(U);
+ P = C->Value(U);
}
//purpose :
//=======================================================================
-void BRepLProp_CurveTool::D1(const BRepAdaptor_Curve& C,
+void BRepLProp_CurveTool::D1(const Handle(BRepAdaptor_Curve)& C,
const Standard_Real U,
gp_Pnt& P,
gp_Vec& V1)
{
- C.D1(U,P,V1);
+ C->D1(U,P,V1);
}
//purpose :
//=======================================================================
-void BRepLProp_CurveTool::D2(const BRepAdaptor_Curve& C,
+void BRepLProp_CurveTool::D2(const Handle(BRepAdaptor_Curve)& C,
const Standard_Real U,
gp_Pnt& P,
gp_Vec& V1,
gp_Vec& V2)
{
- C.D2(U,P,V1,V2);
+ C->D2(U,P,V1,V2);
}
//purpose :
//=======================================================================
-void BRepLProp_CurveTool::D3(const BRepAdaptor_Curve& C,
+void BRepLProp_CurveTool::D3(const Handle(BRepAdaptor_Curve)& C,
const Standard_Real U,
gp_Pnt& P,
gp_Vec& V1,
gp_Vec& V2,
gp_Vec& V3)
{
- C.D3(U,P,V1,V2,V3);
+ C->D3(U,P,V1,V2,V3);
}
//purpose :
//=======================================================================
-Standard_Integer BRepLProp_CurveTool::Continuity(const BRepAdaptor_Curve& C)
+Standard_Integer BRepLProp_CurveTool::Continuity(const Handle(BRepAdaptor_Curve)& C)
{
- GeomAbs_Shape s = C.Continuity();
+ GeomAbs_Shape s = C->Continuity();
switch (s) {
case GeomAbs_C0:
return 0;
//purpose :
//=======================================================================
-Standard_Real BRepLProp_CurveTool::FirstParameter(const BRepAdaptor_Curve& C)
+Standard_Real BRepLProp_CurveTool::FirstParameter(const Handle(BRepAdaptor_Curve)& C)
{
- return C.FirstParameter();
+ return C->FirstParameter();
}
//purpose :
//=======================================================================
-Standard_Real BRepLProp_CurveTool::LastParameter(const BRepAdaptor_Curve& C)
+Standard_Real BRepLProp_CurveTool::LastParameter(const Handle(BRepAdaptor_Curve)& C)
{
- return C.LastParameter();
+ return C->LastParameter();
}
//! Computes the point <P> of parameter <U> on the curve <C>.
- Standard_EXPORT static void Value (const BRepAdaptor_Curve& C, const Standard_Real U, gp_Pnt& P);
+ Standard_EXPORT static void Value (const Handle(BRepAdaptor_Curve)& C, const Standard_Real U, gp_Pnt& P);
//! Computes the point <P> and first derivative <V1> of
//! parameter <U> on the curve <C>.
- Standard_EXPORT static void D1 (const BRepAdaptor_Curve& C, const Standard_Real U, gp_Pnt& P, gp_Vec& V1);
+ Standard_EXPORT static void D1 (const Handle(BRepAdaptor_Curve)& C, const Standard_Real U, gp_Pnt& P, gp_Vec& V1);
//! Computes the point <P>, the first derivative <V1> and second
//! derivative <V2> of parameter <U> on the curve <C>.
- Standard_EXPORT static void D2 (const BRepAdaptor_Curve& C, const Standard_Real U, gp_Pnt& P, gp_Vec& V1, gp_Vec& V2);
+ Standard_EXPORT static void D2 (const Handle(BRepAdaptor_Curve)& C, const Standard_Real U, gp_Pnt& P, gp_Vec& V1, gp_Vec& V2);
//! Computes the point <P>, the first derivative <V1>, the
//! second derivative <V2> and third derivative <V3> of
//! parameter <U> on the curve <C>.
- Standard_EXPORT static void D3 (const BRepAdaptor_Curve& C, const Standard_Real U, gp_Pnt& P, gp_Vec& V1, gp_Vec& V2, gp_Vec& V3);
+ Standard_EXPORT static void D3 (const Handle(BRepAdaptor_Curve)& C, const Standard_Real U, gp_Pnt& P, gp_Vec& V1, gp_Vec& V2, gp_Vec& V3);
//! returns the order of continuity of the curve <C>.
//! returns 1 : first derivative only is computable
//! returns 2 : first and second derivative only are computable.
//! returns 3 : first, second and third are computable.
- Standard_EXPORT static Standard_Integer Continuity (const BRepAdaptor_Curve& C);
+ Standard_EXPORT static Standard_Integer Continuity (const Handle(BRepAdaptor_Curve)& C);
//! returns the first parameter bound of the curve.
- Standard_EXPORT static Standard_Real FirstParameter (const BRepAdaptor_Curve& C);
+ Standard_EXPORT static Standard_Real FirstParameter (const Handle(BRepAdaptor_Curve)& C);
//! returns the last parameter bound of the curve.
//! FirstParameter must be less than LastParamenter.
- Standard_EXPORT static Standard_Real LastParameter (const BRepAdaptor_Curve& C);
+ Standard_EXPORT static Standard_Real LastParameter (const Handle(BRepAdaptor_Curve)& C);
//! only the tangent, N should be equal to 1.
//! <Resolution> is the linear tolerance (it is used to test
//! if a vector is null).
- Standard_EXPORT BRepLProp_SLProps(const BRepAdaptor_Surface& S, const Standard_Real U, const Standard_Real V, const Standard_Integer N, const Standard_Real Resolution);
+ Standard_EXPORT BRepLProp_SLProps(const Handle(BRepAdaptor_Surface)& S, const Standard_Real U, const Standard_Real V, const Standard_Integer N, const Standard_Real Resolution);
//! idem as previous constructor but without setting the value
//! of parameters <U> and <V>.
- Standard_EXPORT BRepLProp_SLProps(const BRepAdaptor_Surface& S, const Standard_Integer N, const Standard_Real Resolution);
+ Standard_EXPORT BRepLProp_SLProps(const Handle(BRepAdaptor_Surface)& S, const Standard_Integer N, const Standard_Real Resolution);
//! idem as previous constructor but without setting the value
//! of parameters <U> and <V> and the surface.
//! Initializes the local properties of the surface S
//! for the new surface.
- Standard_EXPORT void SetSurface (const BRepAdaptor_Surface& S);
+ Standard_EXPORT void SetSurface (const Handle(BRepAdaptor_Surface)& S);
//! Initializes the local properties of the surface S
//! for the new parameter values (<U>, <V>).
- BRepAdaptor_Surface mySurf;
+ Handle(BRepAdaptor_Surface) mySurf;
Standard_Real myU;
Standard_Real myV;
Standard_Integer myDerOrder;
#include <gp_Dir.hxx>
-#define Surface BRepAdaptor_Surface
+#define Surface Handle(BRepAdaptor_Surface)
#define Surface_hxx <BRepAdaptor_Surface.hxx>
#define Tool BRepLProp_SurfaceTool
#define Tool_hxx <BRepLProp_SurfaceTool.hxx>
//function : Value
//purpose :
//=======================================================================
-void BRepLProp_SurfaceTool::Value(const BRepAdaptor_Surface& S,
+void BRepLProp_SurfaceTool::Value(const Handle(BRepAdaptor_Surface)& S,
const Standard_Real U,
const Standard_Real V,
gp_Pnt& P)
{
- P = S.Value(U, V);
+ Standard_ASSERT_RAISE(!S.IsNull(), "Surface Adaptor is not initialized");
+ P = S->Value(U, V);
}
//purpose :
//=======================================================================
-void BRepLProp_SurfaceTool::D1(const BRepAdaptor_Surface& S,
+void BRepLProp_SurfaceTool::D1(const Handle(BRepAdaptor_Surface)& S,
const Standard_Real U,
const Standard_Real V,
gp_Pnt& P,
gp_Vec& D1U,
gp_Vec& D1V)
{
- S.D1(U, V, P, D1U, D1V);
+ Standard_ASSERT_RAISE(!S.IsNull(), "Surface Adaptor is not initialized");
+ S->D1(U, V, P, D1U, D1V);
}
//purpose :
//=======================================================================
-void BRepLProp_SurfaceTool::D2(const BRepAdaptor_Surface& S,
+void BRepLProp_SurfaceTool::D2(const Handle(BRepAdaptor_Surface)& S,
const Standard_Real U,
const Standard_Real V,
gp_Pnt& P,
gp_Vec& D2V,
gp_Vec& DUV)
{
- S.D2(U, V, P, D1U, D1V, D2U, D2V, DUV);
+ Standard_ASSERT_RAISE(!S.IsNull(), "Surface Adaptor is not initialized");
+ S->D2(U, V, P, D1U, D1V, D2U, D2V, DUV);
}
//=======================================================================
//function : DN
//purpose :
//=======================================================================
-gp_Vec BRepLProp_SurfaceTool::DN(const BRepAdaptor_Surface& S,
+gp_Vec BRepLProp_SurfaceTool::DN(const Handle(BRepAdaptor_Surface)& S,
const Standard_Real U,
const Standard_Real V,
const Standard_Integer IU,
const Standard_Integer IV)
{
- return S.DN(U, V, IU, IV);
+ Standard_ASSERT_RAISE(!S.IsNull(), "Surface Adaptor is not initialized");
+ return S->DN(U, V, IU, IV);
}
//=======================================================================
Standard_Integer BRepLProp_SurfaceTool::Continuity
- (const BRepAdaptor_Surface& S)
+ (const Handle(BRepAdaptor_Surface)& S)
{
- GeomAbs_Shape s = (GeomAbs_Shape) Min(S.UContinuity(),S.VContinuity());
+ Standard_ASSERT_RAISE(!S.IsNull(), "Surface Adaptor is not initialized");
+ GeomAbs_Shape s = (GeomAbs_Shape) Min(S->UContinuity(),S->VContinuity());
switch (s) {
case GeomAbs_C0:
return 0;
//purpose :
//=======================================================================
-void BRepLProp_SurfaceTool::Bounds(const BRepAdaptor_Surface& S,
+void BRepLProp_SurfaceTool::Bounds(const Handle(BRepAdaptor_Surface)& S,
Standard_Real& U1,
Standard_Real& V1,
Standard_Real& U2,
Standard_Real& V2)
{
- U1 = S.FirstUParameter();
- V1 = S.FirstVParameter();
- U2 = S.LastUParameter();
- V2 = S.LastVParameter();
+ Standard_ASSERT_RAISE(!S.IsNull(), "Surface Adaptor is not initialized");
+ U1 = S->FirstUParameter();
+ V1 = S->FirstVParameter();
+ U2 = S->LastUParameter();
+ V2 = S->LastVParameter();
}
//! Computes the point <P> of parameter <U> and <V> on the
//! Surface <S>.
- Standard_EXPORT static void Value (const BRepAdaptor_Surface& S, const Standard_Real U, const Standard_Real V, gp_Pnt& P);
+ Standard_EXPORT static void Value (const Handle(BRepAdaptor_Surface)& S, const Standard_Real U, const Standard_Real V, gp_Pnt& P);
//! Computes the point <P> and first derivative <D1*> of
//! parameter <U> and <V> on the Surface <S>.
- Standard_EXPORT static void D1 (const BRepAdaptor_Surface& S, const Standard_Real U, const Standard_Real V, gp_Pnt& P, gp_Vec& D1U, gp_Vec& D1V);
+ Standard_EXPORT static void D1 (const Handle(BRepAdaptor_Surface)& S, const Standard_Real U, const Standard_Real V, gp_Pnt& P, gp_Vec& D1U, gp_Vec& D1V);
//! Computes the point <P>, the first derivative <D1*> and second
//! derivative <D2*> of parameter <U> and <V> on the Surface <S>.
- Standard_EXPORT static void D2 (const BRepAdaptor_Surface& S, const Standard_Real U, const Standard_Real V, gp_Pnt& P, gp_Vec& D1U, gp_Vec& D1V, gp_Vec& D2U, gp_Vec& D2V, gp_Vec& DUV);
+ Standard_EXPORT static void D2 (const Handle(BRepAdaptor_Surface)& S, const Standard_Real U, const Standard_Real V, gp_Pnt& P, gp_Vec& D1U, gp_Vec& D1V, gp_Vec& D2U, gp_Vec& D2V, gp_Vec& DUV);
- Standard_EXPORT static gp_Vec DN (const BRepAdaptor_Surface& S, const Standard_Real U, const Standard_Real V, const Standard_Integer IU, const Standard_Integer IV);
+ Standard_EXPORT static gp_Vec DN (const Handle(BRepAdaptor_Surface)& S, const Standard_Real U, const Standard_Real V, const Standard_Integer IU, const Standard_Integer IV);
//! returns the order of continuity of the Surface <S>.
//! returns 1 : first derivative only is computable
//! returns 2 : first and second derivative only are computable.
- Standard_EXPORT static Standard_Integer Continuity (const BRepAdaptor_Surface& S);
+ Standard_EXPORT static Standard_Integer Continuity (const Handle(BRepAdaptor_Surface)& S);
//! returns the bounds of the Surface.
- Standard_EXPORT static void Bounds (const BRepAdaptor_Surface& S, Standard_Real& U1, Standard_Real& V1, Standard_Real& U2, Standard_Real& V2);
+ Standard_EXPORT static void Bounds (const Handle(BRepAdaptor_Surface)& S, Standard_Real& U1, Standard_Real& V1, Standard_Real& U2, Standard_Real& V2);
//=======================================================================
static Standard_Integer evaluateMaxSegment(const Standard_Integer aMaxSegment,
- const Adaptor3d_CurveOnSurface& aCurveOnSurface)
+ const Handle(Adaptor3d_CurveOnSurface)& aCurveOnSurface)
{
if (aMaxSegment != 0) return aMaxSegment;
- Handle(Adaptor3d_Surface) aSurf = aCurveOnSurface.GetSurface();
- Handle(Adaptor2d_Curve2d) aCurv2d = aCurveOnSurface.GetCurve();
+ Handle(Adaptor3d_Surface) aSurf = aCurveOnSurface->GetSurface();
+ Handle(Adaptor2d_Curve2d) aCurv2d = aCurveOnSurface->GetCurve();
Standard_Real aNbSKnots = 0, aNbC2dKnots = 0;
new Geom2dAdaptor_Curve(AnAdaptor3dCurve2d) ;
Handle(GeomAdaptor_Surface) AnAdaptor3dSurfacePtr =
new GeomAdaptor_Surface (AnAdaptor3dSurface) ;
- Adaptor3d_CurveOnSurface CurveOnSurface( AnAdaptor3dCurve2dPtr,
- AnAdaptor3dSurfacePtr) ;
+ Handle(Adaptor3d_CurveOnSurface) CurveOnSurface =
+ new Adaptor3d_CurveOnSurface (AnAdaptor3dCurve2dPtr, AnAdaptor3dSurfacePtr);
Handle(Geom_Curve) NewCurvePtr ;
Handle(Geom_Surface) surface_ptr ;
TopLoc_Location local_location ;
GCPnts_QuasiUniformDeflection a_sampler ;
- GeomAdaptor_Curve geom_reference_curve ;
- Adaptor3d_CurveOnSurface curve_on_surface_reference ;
+ Handle(GeomAdaptor_Curve) geom_reference_curve = new GeomAdaptor_Curve();
+ Handle(Adaptor3d_CurveOnSurface) curve_on_surface_reference = new Adaptor3d_CurveOnSurface();
Handle(Geom_Curve) C = BRep_Tool::Curve(AnEdge,
local_location,
current_first,
C = Handle(Geom_Curve)::
DownCast(C-> Transformed(local_location.Transformation()) ) ;
}
- geom_reference_curve.Load(C) ;
+ geom_reference_curve->Load(C) ;
geom_reference_curve_flag = 1 ;
a_sampler.Initialize(geom_reference_curve,
MinToleranceRequested * factor,
new Geom2dAdaptor_Curve(AnAdaptor3dCurve2d) ;
Handle(GeomAdaptor_Surface) AnAdaptor3dSurfacePtr =
new GeomAdaptor_Surface (AnAdaptor3dSurface) ;
- curve_on_surface_reference.Load (AnAdaptor3dCurve2dPtr, AnAdaptor3dSurfacePtr);
+ curve_on_surface_reference->Load (AnAdaptor3dCurve2dPtr, AnAdaptor3dSurfacePtr);
a_sampler.Initialize(curve_on_surface_reference,
MinToleranceRequested * factor,
current_first,
new Geom2dAdaptor_Curve(an_adaptor_curve2d) ;
Handle(GeomAdaptor_Surface) an_adaptor_surface_ptr =
new GeomAdaptor_Surface (an_adaptor_surface) ;
- Adaptor3d_CurveOnSurface a_curve_on_surface(an_adaptor_curve2d_ptr,
- an_adaptor_surface_ptr) ;
+ Handle(Adaptor3d_CurveOnSurface) a_curve_on_surface =
+ new Adaptor3d_CurveOnSurface (an_adaptor_curve2d_ptr, an_adaptor_surface_ptr);
if (BRep_Tool::SameParameter(AnEdge)) {
GeomAdaptor_Surface& GAS = *HS;
GAS.Load(GP);
- ProjLib_ProjectedCurve Proj(HS,HC);
+ Handle(ProjLib_ProjectedCurve) Proj = new ProjLib_ProjectedCurve(HS,HC);
Handle(Geom2d_Curve) pc = Geom2dAdaptor::MakeCurve(Proj);
gp_Pln pln = GAS.Plane();
//=======================================================================
static Standard_Boolean EvalTol(const Handle(Geom2d_Curve)& pc,
const Handle(Geom_Surface)& s,
- const GeomAdaptor_Curve& gac,
+ const Handle(GeomAdaptor_Curve)& gac,
const Standard_Real tol,
Standard_Real& tolbail)
{
Standard_Integer ok = 0;
- Standard_Real f = gac.FirstParameter();
- Standard_Real l = gac.LastParameter();
+ Standard_Real f = gac->FirstParameter();
+ Standard_Real l = gac->LastParameter();
Extrema_LocateExtPC Projector;
Projector.Initialize(gac,f,l,tol);
Standard_Real u,v;
Handle(GeomAdaptor_Curve) HC = new GeomAdaptor_Curve();
Handle(Geom2dAdaptor_Curve) HC2d = new Geom2dAdaptor_Curve();
Handle(GeomAdaptor_Surface) HS = new GeomAdaptor_Surface();
- GeomAdaptor_Curve& GAC = *HC;
Geom2dAdaptor_Curve& GAC2d = *HC2d;
GeomAdaptor_Surface& GAS = *HS;
if(!L3d.IsIdentity()){
C3d = Handle(Geom_Curve)::DownCast(C3d->Transformed(L3d.Transformation()));
}
- GAC.Load(C3d,f3d,l3d);
+ HC->Load(C3d,f3d,l3d);
- Standard_Real Prec_C3d = BRepCheck::PrecCurve(GAC);
+ Standard_Real Prec_C3d = BRepCheck::PrecCurve(HC);
Standard_Boolean IsSameP = 1;
Standard_Real maxdist = 0.;
}
// Eval tol2d to compute SameRange
- Standard_Real TolSameRange = Max(GAC.Resolution(theTolerance), Precision::PConfusion());
+ Standard_Real TolSameRange = Max(HC->Resolution(theTolerance), Precision::PConfusion());
for(Standard_Integer i = 0; i < 2; i++){
Handle(Geom2d_Curve) curPC = PC[i];
Standard_Boolean updatepc = 0;
if(bs2d->Continuity() == GeomAbs_C0) {
Standard_Real tolbail;
- if(EvalTol(curPC,S,GAC,theTolerance,tolbail)){
+ if(EvalTol(curPC,S,HC,theTolerance,tolbail)){
bs2d = bs2dsov;
Standard_Real UResbail = GAS.UResolution(tolbail);
Standard_Real VResbail = GAS.VResolution(tolbail);
{
// adaptor for pcurve on the second surface
aHC2 = new BRepAdaptor_Curve (anEdgeInFace2, theFace2);
- ext.Initialize(*aHC2, f, l, Precision::PConfusion());
+ ext.Initialize(aHC2, f, l, Precision::PConfusion());
}
ext.Perform(aSP1.Value(), u);
if (ext.IsDone() && ext.IsMin())
{
// Get basis transformed basis surface
Handle(Geom_Surface) aSurf = Handle(Geom_Surface)::
- DownCast(aBAS.Surface().Surface()->Transformed(aBAS.Trsf()));
+ DownCast(aBAS.Surface()->Surface()->Transformed(aBAS.Trsf()));
// Get bounds of the basis surface
Standard_Real aSUMin, aSUMax, aSVMin, aSVMax;
//! Returns false if there is no such range. Otherwise, sets theFirst and
//! theLast as its bounds.
Standard_EXPORT static Standard_Boolean FindValidRange
- (const Adaptor3d_Curve& theCurve, const Standard_Real theTolE,
+ (const Handle(Adaptor3d_Curve)& theCurve, const Standard_Real theTolE,
const Standard_Real theParV1, const gp_Pnt& thePntV1, const Standard_Real theTolV1,
const Standard_Real theParV2, const gp_Pnt& thePntV2, const Standard_Real theTolV2,
Standard_Real& theFirst, Standard_Real& theLast);
// center theVertPnt and radius theTol.
//=======================================================================
static Standard_Boolean findNearestValidPoint(
- const Adaptor3d_Curve& theCurve,
+ const Handle(Adaptor3d_Curve)& theCurve,
const Standard_Real theFirst, const Standard_Real theLast,
const Standard_Boolean isFirst,
const gp_Pnt& theVertPnt,
Standard_Real anEndU = theLast;
if (!isFirst)
std::swap(aStartU, anEndU);
- gp_Pnt aP = theCurve.Value(aStartU);
+ gp_Pnt aP = theCurve->Value(aStartU);
const Standard_Real aSqTol = theTol * theTol;
if (aP.SquareDistance(theVertPnt) > aSqTol)
// the vertex does not cover the corresponding to this vertex end of the curve
// stepping along the curve by theTol till go out
//
// the general step is computed using general curve resolution
- Standard_Real aStep = theCurve.Resolution(theTol) * 1.01;
+ Standard_Real aStep = theCurve->Resolution(theTol) * 1.01;
if (aStep < theEps)
aStep = theEps;
// aD1Mag is a threshold to consider local derivative magnitude too small
// (inverse of resolution is the maximal derivative);
// this is actual for bezier and b-spline types only
Standard_Real aD1Mag = 0.;
- GeomAbs_CurveType aType = theCurve.GetType();
+ GeomAbs_CurveType aType = theCurve->GetType();
if (aType == GeomAbs_OffsetCurve)
{
- Handle(Geom_OffsetCurve) anOffsetCurve = theCurve.OffsetCurve();
+ Handle(Geom_OffsetCurve) anOffsetCurve = theCurve->OffsetCurve();
Handle(Geom_Curve) aBaseCurve = anOffsetCurve->BasisCurve();
aType = GeomAdaptor_Curve(aBaseCurve).GetType();
}
if (aType == GeomAbs_BezierCurve || aType == GeomAbs_BSplineCurve)
{
- aD1Mag = 1. / theCurve.Resolution(1.) * 0.01;
+ aD1Mag = 1. / theCurve->Resolution(1.) * 0.01;
aD1Mag *= aD1Mag;
}
if (!isFirst)
{
// step is too big and we go out of bounds,
// check if the opposite bound is outside
- aP = theCurve.Value(anEndU);
+ aP = theCurve->Value(anEndU);
isOut = (aP.SquareDistance(theVertPnt) > aSqTol);
if (!isOut)
// all range is inside sphere
{
// cycle to go out of local singularity
gp_Vec aD1;
- theCurve.D1(anUOut, aP, aD1);
+ theCurve->D1(anUOut, aP, aD1);
isOut = (aP.SquareDistance(theVertPnt) > aSqTol);
if (!isOut && aD1.SquareMagnitude() < aD1Mag)
{
continue;
// went out of range, so check if the end point has out state
anUOut = anEndU;
- aP = theCurve.Value(anUOut);
+ aP = theCurve->Value(anUOut);
isOut = (aP.SquareDistance(theVertPnt) > aSqTol);
if (!isOut)
// all range is inside sphere
}
else
{
- aP = theCurve.Value(anUOut);
+ aP = theCurve->Value(anUOut);
}
if (!isOut)
isOut = (aP.SquareDistance(theVertPnt) > aSqTol);
while (aDelta > theEps)
{
Standard_Real aMidU = (anUIn + anUOut) * 0.5;
- aP = theCurve.Value(aMidU);
+ aP = theCurve->Value(aMidU);
isOut = (aP.SquareDistance(theVertPnt) > aSqTol);
if (isOut)
anUOut = aMidU;
// purpose :
//=======================================================================
Standard_Boolean BRepLib::FindValidRange
- (const Adaptor3d_Curve& theCurve, const Standard_Real theTolE,
+ (const Handle(Adaptor3d_Curve)& theCurve, const Standard_Real theTolE,
const Standard_Real theParV1, const gp_Pnt& thePntV1, const Standard_Real theTolV1,
const Standard_Real theParV2, const gp_Pnt& thePntV2, const Standard_Real theTolV2,
Standard_Real& theFirst, Standard_Real& theLast)
if (!isInfParV2)
aMaxPar = Max (aMaxPar, Abs (theParV2));
- Standard_Real anEps = Max (Max (theCurve.Resolution (theTolE) * 0.1, Epsilon (aMaxPar)),
+ Standard_Real anEps = Max (Max (theCurve->Resolution (theTolE) * 0.1, Epsilon (aMaxPar)),
Precision::PConfusion());
if (isInfParV1)
Standard_Real f, l;
if (BRep_Tool::Curve(theEdge, aLoc, f, l).IsNull())
return Standard_False;
- BRepAdaptor_Curve anAC(theEdge);
- Standard_Real aParV[2] = { anAC.FirstParameter(), anAC.LastParameter() };
+ Handle(BRepAdaptor_Curve) anAC = new BRepAdaptor_Curve(theEdge);
+ Standard_Real aParV[2] = { anAC->FirstParameter(), anAC->LastParameter() };
if (aParV[1] - aParV[0] < Precision::PConfusion())
return Standard_False;
else if (!Precision::IsInfinite(aParV[i]))
{
aTolV[i] += aTolE;
- aPntV[i] = anAC.Value(aParV[i]);
+ aPntV[i] = anAC->Value(aParV[i]);
}
}
return FindValidRange(anAC, aTolE,
theParams.Append (theParMax);
}
-static void fillPoints (const BRepAdaptor_Curve& theCurve,
+static void fillPoints (BRepAdaptor_Curve& theCurve,
const NCollection_Vector<Standard_Real>& theParams,
TColgp_SequenceOfPnt& thePoints,
TColStd_SequenceOfReal& theWeights)
}
if(porig > l) {
//try to project
- GeomAdaptor_Curve aGAC(aBC);
+ Handle(GeomAdaptor_Curve) aGAC = new GeomAdaptor_Curve(aBC);
Extrema_LocateExtPC aPrj(PF, aGAC, pmin, Precision::PConfusion());
if(aPrj.IsDone()) {
porig = aPrj.Point().Parameter();
Eps2 *= Eps2;
gp_Pnt P = BRep_Tool::Pnt(V);
- GeomAdaptor_Curve GAC(C);
+ Handle(GeomAdaptor_Curve) GAC = new GeomAdaptor_Curve(C);
// Afin de faire les extremas, on verifie les distances en bout
Standard_Real D1,D2;
gp_Pnt P1,P2;
- P1 = GAC.Value(GAC.FirstParameter());
- P2 = GAC.Value(GAC.LastParameter());
+ P1 = GAC->Value(GAC->FirstParameter());
+ P2 = GAC->Value(GAC->LastParameter());
D1 = P1.SquareDistance(P);
D2 = P2.SquareDistance(P);
if ( (D1 < D2) && (D1 <= Eps2) ) {
- p = GAC.FirstParameter();
+ p = GAC->FirstParameter();
return Standard_True;
}
else if ( (D2 < D1) && (D2 <= Eps2) ) {
- p = GAC.LastParameter();
+ p = GAC->LastParameter();
return Standard_True;
}
Handle(Geom2dAdaptor_Curve) HG2AHC = new Geom2dAdaptor_Curve (C);
Handle(GeomAdaptor_Surface) HGAHS = new GeomAdaptor_Surface (S);
- Adaptor3d_CurveOnSurface ACOS(HG2AHC,HGAHS);
+ Handle(Adaptor3d_CurveOnSurface) ACOS = new Adaptor3d_CurveOnSurface(HG2AHC,HGAHS);
Standard_Real D1,D2;
gp_Pnt P1,P2;
- P1 = ACOS.Value(ACOS.FirstParameter());
- P2 = ACOS.Value(ACOS.LastParameter());
+ P1 = ACOS->Value(ACOS->FirstParameter());
+ P2 = ACOS->Value(ACOS->LastParameter());
D1 = P1.SquareDistance(P);
D2 = P2.SquareDistance(P);
if ( (D1 < D2) && (D1 <= Eps2) ) {
- p = ACOS.FirstParameter();
+ p = ACOS->FirstParameter();
return Standard_True;
}
else if ( (D2 < D1) && (D2 <= Eps2) ) {
- p = ACOS.LastParameter();
+ p = ACOS->LastParameter();
return Standard_True;
}
Standard_Real& p)
{
gp_Pnt2d P = Project(V);
- Geom2dAdaptor_Curve AC(C);
- if (AC.GetType() == GeomAbs_Line) {
- p = ElCLib::LineParameter(AC.Line().Position(),P);
+ Handle(Geom2dAdaptor_Curve) AC = new Geom2dAdaptor_Curve(C);
+ if (AC->GetType() == GeomAbs_Line) {
+ p = ElCLib::LineParameter(AC->Line().Position(),P);
}
- else if (AC.GetType() == GeomAbs_Circle) {
- p = ElCLib::CircleParameter(AC.Circle().Position(),P);
+ else if (AC->GetType() == GeomAbs_Circle) {
+ p = ElCLib::CircleParameter(AC->Circle().Position(),P);
}
else {
Extrema_ExtPC2d extrema(P,AC);
Standard_Real BRepLib_ValidateEdge::correctTolerance(Standard_Real theTolerance)
{
const Handle(Adaptor3d_Surface)& aSurface = myOtherCurve->GetSurface();
- Standard_Real aCurvePrecision = BRepCheck::PrecCurve(*myReferenceCurve);
+ Standard_Real aCurvePrecision = BRepCheck::PrecCurve(myReferenceCurve);
Standard_Real aSurfacePrecision = BRepCheck::PrecSurface(aSurface);
Standard_Real aToleranceDelta = (aCurvePrecision > aSurfacePrecision) ? aCurvePrecision : aSurfacePrecision;
Standard_Real aCorrectedTolerance = theTolerance + aToleranceDelta;
}
Extrema_LocateExtPC aReferenceExtrema, anOtherExtrema;
- aReferenceExtrema.Initialize(*myReferenceCurve, aReferenceFirstParam, aReferenceLastParam, myReferenceCurve->Resolution(Precision::Confusion()));
- anOtherExtrema.Initialize(*myOtherCurve, anOtherFirstParam, anOtherLastParam, myOtherCurve->Resolution(Precision::Confusion()));
+ aReferenceExtrema.Initialize(myReferenceCurve, aReferenceFirstParam, aReferenceLastParam, myReferenceCurve->Resolution(Precision::Confusion()));
+ anOtherExtrema.Initialize(myOtherCurve, anOtherFirstParam, anOtherLastParam, myOtherCurve->Resolution(Precision::Confusion()));
for (Standard_Integer i = 1; i < aControlPointsNumber; i++)
{
Standard_Real aReferenceParam = ((aControlPointsNumber - i) * aReferenceFirstParam + i * aReferenceLastParam) / aControlPointsNumber;
: myDEdge(theEdge),
myParameters(theParameters),
myEdge(theEdge->GetEdge()),
- myCurve(myEdge)
+ myCurve(new BRepAdaptor_Curve(myEdge))
{
init();
}
: myDEdge(theEdge),
myParameters(theParameters),
myEdge(TopoDS::Edge(theEdge->GetEdge().Oriented(theOrientation))),
- myCurve(myEdge, theFace->GetFace())
+ myCurve(new BRepAdaptor_Curve(myEdge, theFace->GetFace()))
{
init();
}
if (myParameters.AdjustMinSize)
{
aMinSize = Min (aMinSize, myParameters.RelMinSize() * GCPnts_AbscissaPoint::Length (
- myCurve, myCurve.FirstParameter(), myCurve.LastParameter(), aPreciseLinDef));
+ myCurve, myCurve->FirstParameter(), myCurve->LastParameter(), aPreciseLinDef));
}
mySquareEdgeDef = aPreciseLinDef * aPreciseLinDef;
myEdgeSqTol = BRep_Tool::Tolerance (myEdge);
myEdgeSqTol *= myEdgeSqTol;
- const Standard_Integer aMinPntNb = (myCurve.GetType() == GeomAbs_Circle) ? 4 : 2; //OCC287
+ const Standard_Integer aMinPntNb = (myCurve->GetType() == GeomAbs_Circle) ? 4 : 2; //OCC287
myDiscretTool.Initialize (myCurve,
- myCurve.FirstParameter(), myCurve.LastParameter(),
+ myCurve->FirstParameter(), myCurve->LastParameter(),
aPreciseAngDef, aPreciseLinDef, aMinPntNb,
Precision::PConfusion(), aMinSize);
- if (myCurve.IsCurveOnSurface())
+ if (myCurve->IsCurveOnSurface())
{
- const Adaptor3d_CurveOnSurface& aCurve = myCurve.CurveOnSurface();
- const Handle(Adaptor3d_Surface)& aSurface = aCurve.GetSurface();
+ const Handle(Adaptor3d_CurveOnSurface)& aCurve = myCurve->CurveOnSurface();
+ const Handle(Adaptor3d_Surface)& aSurface = aCurve->GetSurface();
const Standard_Real aTol = Precision::Confusion();
const Standard_Real aDu = aSurface->UResolution(aTol);
/*if (!isInToleranceOfVertex(thePoint, myFirstVertex) &&
!isInToleranceOfVertex(thePoint, myLastVertex))
{*/
- if (!myCurve.IsCurveOnSurface())
+ if (!myCurve->IsCurveOnSurface())
{
return Standard_True;
}
// If point coordinates are out of surface range,
// it is necessary to re-project point.
- const Adaptor3d_CurveOnSurface& aCurve = myCurve.CurveOnSurface();
- const Handle(Adaptor3d_Surface)& aSurface = aCurve.GetSurface();
+ const Handle(Adaptor3d_CurveOnSurface)& aCurve = myCurve->CurveOnSurface();
+ const Handle(Adaptor3d_Surface)& aSurface = aCurve->GetSurface();
if (aSurface->GetType() != GeomAbs_BSplineSurface &&
aSurface->GetType() != GeomAbs_BezierSurface &&
aSurface->GetType() != GeomAbs_OtherSurface)
}
gp_Pnt2d aUV;
- aCurve.GetCurve()->D0(theParameter, aUV);
+ aCurve->GetCurve()->D0(theParameter, aUV);
// Point lies within the surface range - nothing to do.
if (aUV.X() > myFaceRangeU[0] && aUV.X() < myFaceRangeU[1] &&
aUV.Y() > myFaceRangeV[0] && aUV.Y() < myFaceRangeV[1])
}
midpar = (theFirst + theLast) * 0.5;
- myCurve.D0 (midpar, midP3d);
+ myCurve->D0 (midpar, midP3d);
myDiscretTool.AddPoint (midP3d, midpar, Standard_False);
splitSegment (theSurf, theCurve2d, theFirst, midpar, theNbIter + 1);
const IMeshData::IEdgeHandle& myDEdge;
const IMeshTools_Parameters& myParameters;
TopoDS_Edge myEdge;
- BRepAdaptor_Curve myCurve;
+ Handle(BRepAdaptor_Curve) myCurve;
GCPnts_TangentialDeflection myDiscretTool;
TopoDS_Vertex myFirstVertex;
TopoDS_Vertex myLastVertex;
// Slightly increase exact resolution so to cover links with approximate
// length equal to resolution itself on sub-resolution differences.
const Standard_Real aTolerance = BRep_Tool::Tolerance (myDFace->GetFace());
- const Adaptor3d_Surface& aSurface = GetSurface()->Surface();
- const Standard_Real aResU = aSurface.UResolution (aTolerance) * 1.1;
- const Standard_Real aResV = aSurface.VResolution (aTolerance) * 1.1;
+ const Handle(Adaptor3d_Surface)& aSurface = GetSurface()->Surface();
+ const Standard_Real aResU = aSurface->UResolution (aTolerance) * 1.1;
+ const Standard_Real aResV = aSurface->VResolution (aTolerance) * 1.1;
const Standard_Real aDeflectionUV = 1.e-05;
myTolerance.first = Max(Min(aDeflectionUV, aResU), 1e-7 * aDiffU);
const gp_XY& /*theMidPoint*/)
{
gp_Dir aNorm1, aNorm2;
- const Handle(Geom_Surface)& aSurf = this->getDFace()->GetSurface()->Surface().Surface();
+ const Handle(Geom_Surface)& aSurf = this->getDFace()->GetSurface()->Surface()->Surface();
if ((GeomLib::NormEstim(aSurf, theNodeInfo1.Point2d, Precision::Confusion(), aNorm1) == 0) &&
(GeomLib::NormEstim(aSurf, theNodeInfo2.Point2d, Precision::Confusion(), aNorm2) == 0))
myCurParam(0.0),
myFoundParam(0.0)
{
+ myCurveAdaptor = new BRepAdaptor_Curve();
}
//! Constructor.
const IMeshData::IFaceHandle& theFace,
const ParametersCollection& theParameters)
{
+ myCurveAdaptor = new BRepAdaptor_Curve();
Init(theEdge, theOrientation, theFace, theParameters);
}
// Extract actual parametric values
const TopoDS_Edge aEdge = TopoDS::Edge(theEdge->GetEdge().Oriented(theOrientation));
- myCurveAdaptor.Initialize(aEdge, theFace->GetFace());
+ myCurveAdaptor->Initialize(aEdge, theFace->GetFace());
if (myIsSameParam)
{
return;
}
- myFirstParam = myCurveAdaptor.FirstParameter();
- const Standard_Real aLastParam = myCurveAdaptor.LastParameter();
+ myFirstParam = myCurveAdaptor->FirstParameter();
+ const Standard_Real aLastParam = myCurveAdaptor->LastParameter();
myFoundParam = myCurParam = myFirstParam;
myScale = (aLastParam - myFirstParam) / (aOldLastParam - myOldFirstParam);
}
- myProjector.Initialize(myCurveAdaptor, myCurveAdaptor.FirstParameter(),
- myCurveAdaptor.LastParameter(),Precision::PConfusion());
+ myProjector.Initialize(myCurveAdaptor, myCurveAdaptor->FirstParameter(),
+ myCurveAdaptor->LastParameter(),Precision::PConfusion());
}
//! Returns parameter according to SameParameter flag of the edge.
//! Returns pcurve used to compute parameters.
const Handle(Adaptor2d_Curve2d)& GetPCurve() const
{
- return myCurveAdaptor.CurveOnSurface().GetCurve();
+ return myCurveAdaptor->CurveOnSurface()->GetCurve();
}
private:
mutable Standard_Real myCurParam;
mutable Standard_Real myFoundParam;
- BRepAdaptor_Curve myCurveAdaptor;
+ Handle(BRepAdaptor_Curve) myCurveAdaptor;
mutable Extrema_LocateExtPC myProjector;
};
//purpose :
//=======================================================================
BRepMesh_GeomTool::BRepMesh_GeomTool(
- const BRepAdaptor_Curve& theCurve,
+ const Handle(BRepAdaptor_Curve)& theCurve,
const Standard_Real theFirstParam,
const Standard_Real theLastParam,
const Standard_Real theLinDeflection,
const Standard_Real theAngDeflection,
const Standard_Integer theMinPointsNb,
const Standard_Real theMinSize)
- : myEdge(&theCurve.Edge()),
+ : myEdge(&theCurve->Edge()),
myIsoType(GeomAbs_NoneIso)
{
myDiscretTool.Initialize(theCurve, theFirstParam, theLastParam,
: myEdge(NULL),
myIsoType(theIsoType)
{
- Adaptor3d_IsoCurve aIso(theSurface, theIsoType, theParamIso,
+ Handle(Adaptor3d_IsoCurve) aIso = new Adaptor3d_IsoCurve(theSurface, theIsoType, theParamIso,
theFirstParam, theLastParam);
myDiscretTool.Initialize(aIso, theFirstParam, theLastParam,
//! @param theAngDeflection angular deflection.
//! @param theMinPointsNb minimum number of points to be produced.
Standard_EXPORT BRepMesh_GeomTool(
- const BRepAdaptor_Curve& theCurve,
+ const Handle(BRepAdaptor_Curve)& theCurve,
const Standard_Real theFirstParam,
const Standard_Real theLastParam,
const Standard_Real theLinDeflection,
const Handle(IMeshData::MapOfReal)& theParamsForbiddenToRemove,
const Handle(IMeshData::MapOfReal)& theControlParamsForbiddenToRemove)
: myDFace(theDFace),
- mySurface(myDFace->GetSurface()->Surface().Surface()),
+ mySurface(myDFace->GetSurface()->Surface()->Surface()),
myIsoU(theIsoType == GeomAbs_IsoU),
myParams(theParams),
myControlParams(theControlParams),
const Standard_Real aDefFace = GetDFace()->GetDeflection();
const Handle(BRepAdaptor_Surface)& gFace = GetSurface();
- Handle(Geom_Surface) aSurface = gFace->Surface().Surface();
+ Handle(Geom_Surface) aSurface = gFace->Surface()->Surface();
const Handle(NCollection_IncAllocator) aTmpAlloc =
new NCollection_IncAllocator(IMeshData::MEMORY_BLOCK_SIZE_HUGE);
aSurface->UIntervals(aIntervals[0], aContinuity);
aSurface->VIntervals(aIntervals[1], aContinuity);
- const Standard_Boolean isSplitIntervals = toSplitIntervals (aSurface->Surface().Surface(), aIntervals);
+ const Standard_Boolean isSplitIntervals = toSplitIntervals (aSurface->Surface()->Surface(), aIntervals);
if (!initParamsFromIntervals(aIntervals[0], GetRangeU(), isSplitIntervals,
const_cast<IMeshData::IMapOfReal&>(GetParametersU())))
//=======================================================================
static void EdgeInter(const TopoDS_Face& F,
- const BRepAdaptor_Surface& BAsurf,
+ const Handle(BRepAdaptor_Surface)& BAsurf,
const TopoDS_Edge& E1,
const TopoDS_Edge& E2,
const Handle(BRepAlgo_AsDes)& AsDes,
//
Handle(Geom2d_Curve) pcurve1 = BRep_Tool::CurveOnSurface(E1, F, f[1], l[1]);
Handle(Geom2d_Curve) pcurve2 = BRep_Tool::CurveOnSurface(E2, F, f[2], l[2]);
- Geom2dAdaptor_Curve GAC1(pcurve1, f[1], l[1]);
- Geom2dAdaptor_Curve GAC2(pcurve2, f[2], l[2]);
+ Handle(Geom2dAdaptor_Curve) GAC1 = new Geom2dAdaptor_Curve(pcurve1, f[1], l[1]);
+ Handle(Geom2dAdaptor_Curve) GAC2 = new Geom2dAdaptor_Curve(pcurve2, f[2], l[2]);
Geom2dInt_GInter Inter2d( GAC1, GAC2, TolDub, TolDub );
for (i = 1; i <= Inter2d.NbPoints(); i++)
{
else
{
gp_Pnt2d P2d = Inter2d.Point(i).Value();
- P3d = BAsurf.Value( P2d.X(), P2d.Y() );
+ P3d = BAsurf->Value( P2d.X(), P2d.Y() );
}
ResPoints.Append( P3d );
ResParamsOnE1.Append( Inter2d.Point(i).ParamOnFirst() );
//=======================================================================
static void RefEdgeInter(const TopoDS_Face& F,
- const BRepAdaptor_Surface& BAsurf,
+ const Handle(BRepAdaptor_Surface)& BAsurf,
const TopoDS_Edge& E1,
const TopoDS_Edge& E2,
const TopAbs_Orientation theOr1,
//
Handle(Geom2d_Curve) pcurve1 = BRep_Tool::CurveOnSurface(E1, F, f[1], l[1]);
Handle(Geom2d_Curve) pcurve2 = BRep_Tool::CurveOnSurface(E2, F, f[2], l[2]);
- Geom2dAdaptor_Curve GAC1(pcurve1, f[1], l[1]);
- Geom2dAdaptor_Curve GAC2(pcurve2, f[2], l[2]);
- if ((GAC1.GetType() == GeomAbs_Line) &&
- (GAC2.GetType() == GeomAbs_Line))
+ Handle(Geom2dAdaptor_Curve) GAC1 = new Geom2dAdaptor_Curve(pcurve1, f[1], l[1]);
+ Handle(Geom2dAdaptor_Curve) GAC2 = new Geom2dAdaptor_Curve(pcurve2, f[2], l[2]);
+ if ((GAC1->GetType() == GeomAbs_Line) &&
+ (GAC2->GetType() == GeomAbs_Line))
{
// Just quickly check if lines coincide
- Standard_Real anAngle = Abs(GAC1.Line().Direction().Angle(GAC2.Line().Direction()));
+ Standard_Real anAngle = Abs(GAC1->Line().Direction().Angle(GAC2->Line().Direction()));
if (anAngle <= 1.e-8 || M_PI - anAngle <= 1.e-8)
{
theCoincide = Standard_True;
//
if (!Inter2d.IsDone() || !Inter2d.NbPoints()) {
theCoincide = (Inter2d.NbSegments() &&
- (GAC1.GetType() == GeomAbs_Line) &&
- (GAC2.GetType() == GeomAbs_Line));
+ (GAC1->GetType() == GeomAbs_Line) &&
+ (GAC2->GetType() == GeomAbs_Line));
return;
}
//
else
{
gp_Pnt2d P2d = Inter2d.Point(i).Value();
- P3d = BAsurf.Value( P2d.X(), P2d.Y() );
+ P3d = BAsurf->Value( P2d.X(), P2d.Y() );
}
ResPoints.Append( P3d );
ResParamsOnE1.Append( Inter2d.Point(i).ParamOnFirst() );
//purpose : return MaxSegment to pass in approximation
//======================================================================
-static Standard_Integer evaluateMaxSegment(const Adaptor3d_CurveOnSurface& aCurveOnSurface)
+static Standard_Integer evaluateMaxSegment(const Handle(Adaptor3d_CurveOnSurface)& aCurveOnSurface)
{
- Handle(Adaptor3d_Surface) aSurf = aCurveOnSurface.GetSurface();
- Handle(Adaptor2d_Curve2d) aCurv2d = aCurveOnSurface.GetCurve();
+ Handle(Adaptor3d_Surface) aSurf = aCurveOnSurface->GetSurface();
+ Handle(Adaptor2d_Curve2d) aCurv2d = aCurveOnSurface->GetCurve();
Standard_Real aNbSKnots = 0, aNbC2dKnots = 0;
TColStd_SequenceOfReal params;
Geom2dInt_GInter IntCC;
- Geom2dAdaptor_Curve GAcurve(theCurve);
+ Handle(Geom2dAdaptor_Curve) GAcurve = new Geom2dAdaptor_Curve(theCurve);
for (i = 1; i <= BoundLines.Length(); i++)
{
- Geom2dAdaptor_Curve GAline( BoundLines(i) );
+ Handle(Geom2dAdaptor_Curve) GAline = new Geom2dAdaptor_Curve( BoundLines(i) );
IntCC.Perform( GAcurve, GAline, Precision::PConfusion(), Precision::PConfusion());
if (IntCC.IsDone())
{
GeomAdaptor_Surface GAsurf( MinSurf );
Handle(Geom2dAdaptor_Curve) HC2d = new Geom2dAdaptor_Curve( AC2d );
Handle(GeomAdaptor_Surface) HSurf = new GeomAdaptor_Surface( GAsurf );
- Adaptor3d_CurveOnSurface ConS( HC2d, HSurf );
+ Handle(Adaptor3d_CurveOnSurface) ConS = new Adaptor3d_CurveOnSurface( HC2d, HSurf );
Standard_Real /*max_deviation,*/ average_deviation;
GeomAbs_Shape Continuity = GeomAbs_C1;
Standard_Integer MaxDegree = 14;
const TopTools_ListOfShape& LE = AsDes->Descendant(F);
TopoDS_Vertex V1,V2;
Standard_Integer j, i = 1;
- BRepAdaptor_Surface BAsurf(F);
+ Handle(BRepAdaptor_Surface) BAsurf = new BRepAdaptor_Surface(F);
//
Message_ProgressScope aPS(theRange, "Intersecting edges on faces", LE.Size());
for ( it1LE.Initialize(LE) ; it1LE.More(); it1LE.Next(), aPS.Next()) {
TopoDS_Face FIO = TopoDS::Face(OFI.Face());
if (MES.IsBound(FIO)) FIO = TopoDS::Face(MES(FIO));
//
- BRepAdaptor_Surface BAsurf(FIO);
+ Handle(BRepAdaptor_Surface) BAsurf = new BRepAdaptor_Surface(FIO);
TopExp_Explorer exp(FI.Oriented(TopAbs_FORWARD),TopAbs_WIRE);
for (; exp.More(); exp.Next(), aPS.Next()) {
aME.Add(aE);
}
//
- BRepAdaptor_Surface BAsurf(FIO);
+ Handle(BRepAdaptor_Surface) BAsurf = new BRepAdaptor_Surface(FIO);
//
Message_ProgressScope aPS(theRange, "Intersecting edges created from vertices", 1, Standard_True);
TopExp_Explorer exp(FI.Oriented(TopAbs_FORWARD),TopAbs_WIRE);
GeomAdaptor_Surface GAsurf( theSurf );
Handle(Geom2dAdaptor_Curve) HC2d = new Geom2dAdaptor_Curve( AC2d );
Handle(GeomAdaptor_Surface) HSurf = new GeomAdaptor_Surface( GAsurf );
- Adaptor3d_CurveOnSurface ConS( HC2d, HSurf );
+ Handle(Adaptor3d_CurveOnSurface) ConS = new Adaptor3d_CurveOnSurface( HC2d, HSurf );
Standard_Real max_deviation = 0., average_deviation;
GeomLib::BuildCurve3d(Precision::Confusion(),
ConS, FirstPar, LastPar,
GeomAdaptor_Surface GAsurf( theSurf );
Handle(Geom2dAdaptor_Curve) HC2d = new Geom2dAdaptor_Curve( AC2d );
Handle(GeomAdaptor_Surface) HSurf = new GeomAdaptor_Surface( GAsurf );
- Adaptor3d_CurveOnSurface ConS( HC2d, HSurf );
+ Handle(Adaptor3d_CurveOnSurface) ConS = new Adaptor3d_CurveOnSurface( HC2d, HSurf );
Standard_Real max_deviation = 0., average_deviation;
GeomLib::BuildCurve3d(Precision::Confusion(),
ConS, FirstPar, LastPar,
Standard_Real BRepOffset_Tool::Gabarit(const Handle(Geom_Curve)& aCurve)
{
- GeomAdaptor_Curve GC( aCurve );
+ Handle(GeomAdaptor_Curve) GC = new GeomAdaptor_Curve( aCurve );
Bnd_Box aBox;
BndLib_Add3dCurve::Add( GC, Precision::Confusion(), aBox );
Standard_Real aXmin, aYmin, aZmin, aXmax, aYmax, aZmax, dist;
for (; Explo.More(); Explo.Next())
{
TopoDS_Edge anEdge = TopoDS::Edge( Explo.Current() );
- BRepAdaptor_Curve aCurve( anEdge );
+ Handle(BRepAdaptor_Curve) aCurve = new BRepAdaptor_Curve( anEdge );
Extrema_ExtPC fextr( fpoint, aCurve );
if (!fextr.IsDone() || fextr.NbExt() < 1)
continue;
Handle (Geom2d_Curve) C2 = BRep_Tool::CurveOnSurface(E,F2,f,l);
Handle (Geom_Curve) C = BRep_Tool::Curve(E,L,f,l);
- BRepAdaptor_Curve BAcurve( E );
+ Handle(BRepAdaptor_Curve) BAcurve = new BRepAdaptor_Curve( E );
GCPnts_AbscissaPoint AP(BAcurve,GCPnts_AbscissaPoint::Length(BAcurve)/2.0,f);
Standard_Real ParOnC;
{
const TopoDS_Edge& anEdge = TopoDS::Edge (itl.Value());
- BRepAdaptor_Curve aBAcurve (anEdge);
- gp_Pnt aMidPntOnEdge = aBAcurve.Value ((aBAcurve.FirstParameter() + aBAcurve.LastParameter())/2);
+ Handle(BRepAdaptor_Curve) aBAcurve = new BRepAdaptor_Curve(anEdge);
+ gp_Pnt aMidPntOnEdge = aBAcurve->Value ((aBAcurve->FirstParameter() + aBAcurve->LastParameter())/2);
gp_Vec RefToMid (aRefPnt, aMidPntOnEdge);
Extrema_ExtPC aProjector (aRefPnt, aBAcurve);
Standard_Boolean found = Standard_False;
gp_Pnt P = BRep_Tool::Pnt (V);
- BRepAdaptor_Curve C = BRepAdaptor_Curve(E);
- f = C.FirstParameter(); l = C.LastParameter();
+ Handle(BRepAdaptor_Curve) C = new BRepAdaptor_Curve(E);
+ f = C->FirstParameter(); l = C->LastParameter();
if (V.Orientation() == TopAbs_FORWARD) {
if (Abs(f) < Precision::Infinite()) {
- gp_Pnt PF = C.Value (f);
+ gp_Pnt PF = C->Value (f);
if (PF.IsEqual(P,TolConf)) {
U = f;
found = Standard_True;
}
if (V.Orientation() == TopAbs_REVERSED) {
if (!found && Abs(l) < Precision::Infinite()) {
- gp_Pnt PL = C.Value (l);
+ gp_Pnt PL = C->Value (l);
if (PL.IsEqual(P,TolConf)) {
U = l;
found = Standard_True;
fl1[0] = C1->FirstParameter(); fl1[1] = C1->LastParameter();
fl2[0] = C2->FirstParameter(); fl2[1] = C2->LastParameter();
}
- Geom2dAdaptor_Curve AC1(C1,fl1[0],fl1[1]);
- Geom2dAdaptor_Curve AC2(C2,fl2[0],fl2[1]);
+ Handle(Geom2dAdaptor_Curve) AC1 = new Geom2dAdaptor_Curve(C1,fl1[0],fl1[1]);
+ Handle(Geom2dAdaptor_Curve) AC2 = new Geom2dAdaptor_Curve(C2,fl2[0],fl2[1]);
if (itry == 0) {
gp_Pnt2d P1[2],P2[2];
else
{
viso = S->VIso( vf1 );
- GeomAdaptor_Curve gac( viso );
+ Handle(GeomAdaptor_Curve) gac = new GeomAdaptor_Curve( viso );
Standard_Real du_default = GCPnts_AbscissaPoint::Length( gac ) * coeff;
du_first = (theLenBeforeUfirst == -1)? du_default : theLenBeforeUfirst;
du_last = (theLenAfterUlast == -1)? du_default : theLenAfterUlast;
else
{
uiso = S->UIso( uf1 );
- GeomAdaptor_Curve gac( uiso );
+ Handle(GeomAdaptor_Curve) gac = new GeomAdaptor_Curve( uiso );
Standard_Real dv_default = GCPnts_AbscissaPoint::Length( gac ) * coeff;
dv_first = (theLenBeforeVfirst == -1)? dv_default : theLenBeforeVfirst;
dv_last = (theLenAfterVlast == -1)? dv_default : theLenAfterVlast;
gabarit_uiso2 <= TolApex)
enlargeV = Standard_False;
- GeomAdaptor_Curve gac;
+ Handle(GeomAdaptor_Curve) gac = new GeomAdaptor_Curve();
if (enlargeU)
{
- gac.Load( viso1 );
+ gac->Load( viso1 );
Standard_Real du_default = GCPnts_AbscissaPoint::Length( gac ) * coeff;
du_first = (theLenBeforeUfirst == -1)? du_default : theLenBeforeUfirst;
du_last = (theLenAfterUlast == -1)? du_default : theLenAfterUlast;
}
if (enlargeV)
{
- gac.Load( uiso1 );
+ gac->Load( uiso1 );
Standard_Real dv_default = GCPnts_AbscissaPoint::Length( gac ) * coeff;
dv_first = (theLenBeforeVfirst == -1)? dv_default : theLenBeforeVfirst;
dv_last = (theLenAfterVlast == -1)? dv_default : theLenAfterVlast;
//=======================================================================
static Standard_Boolean IsInOut (BRepTopAdaptor_FClass2d& FC,
- Geom2dAdaptor_Curve AC,
+ const Handle(Geom2dAdaptor_Curve)& AC,
const TopAbs_State& S )
{
Standard_Real Def = 100*Precision::Confusion();
GCPnts_QuasiUniformDeflection QU(AC,Def);
for (Standard_Integer i = 1; i <= QU.NbPoints(); i++) {
- gp_Pnt2d P = AC.Value(QU.Parameter(i));
+ gp_Pnt2d P = AC->Value(QU.Parameter(i));
if (FC.Perform(P) != S) {
return Standard_False;
}
if (NewEdges.Contains(OE)) {
Handle(Geom2d_Curve) CO2d =
BRep_Tool::CurveOnSurface(TopoDS::Edge(OE),OF,f,l);
- Geom2dAdaptor_Curve AC(CO2d,f,l);
+ Handle(Geom2dAdaptor_Curve) AC = new Geom2dAdaptor_Curve(CO2d,f,l);
if (Offset > 0) {
if (IsInOut(FC,AC,TopAbs_OUT)) OE.Reverse();
//
// Prepare 2D adaptors for intersection.
// The seam edge has two 2D curve, thus we have to create 2 adaptors
- BRepAdaptor_Curve2d aBAC2D1(TopoDS::Edge(CurEdge), aFace);
- BRepAdaptor_Curve2d aBAC2D1R(TopoDS::Edge(CurEdge.Reversed()), aFace);
+ Handle(BRepAdaptor_Curve2d) aBAC2D1 = new BRepAdaptor_Curve2d(TopoDS::Edge(CurEdge), aFace);
+ Handle(BRepAdaptor_Curve2d) aBAC2D1R = new BRepAdaptor_Curve2d(TopoDS::Edge(CurEdge.Reversed()), aFace);
// Get surface of the face to get 3D intersection point
TopLoc_Location aLoc;
const Handle(Geom_Surface)& aSurf = BRep_Tool::Surface(aFace, aLoc);
const TopoDS_Edge& anEdge = TopoDS::Edge(eit.Value());
//
// Prepare 2D adaptor for intersection
- BRepAdaptor_Curve2d aBAC2D2(anEdge, aFace);
+ Handle(BRepAdaptor_Curve2d) aBAC2D2 = new BRepAdaptor_Curve2d(anEdge, aFace);
// Perform intersection
Geom2dInt_GInter aGInter;
aGInter.Perform(aBAC2D1, aBAC2D2, TolInter, TolInter);
TopTools_ListIteratorOfListOfShape itF;
for (itF.Initialize(Faces) ; itF.More(); itF.Next()) {
TopoDS_Face& F = TopoDS::Face(itF.Value());
- BRepAdaptor_Surface S(F,0);
+ Handle(BRepAdaptor_Surface) S = new BRepAdaptor_Surface(F,0);
Standard_Real Tol = BRep_Tool::Tolerance(F);
BRepTopAdaptor_FClass2d CL(F,Precision::Confusion());
const Standard_Real theV)
{
Standard_Real aPrec = gp::Resolution();
- BRepLProp_SLProps aProps(BRepAdaptor_Surface(theFace), theU, theV, 2, aPrec);
+ BRepLProp_SLProps aProps(new BRepAdaptor_Surface(theFace), theU, theV, 2, aPrec);
gp_Dir aNormal = aProps.Normal();
if (theFace.Orientation() == TopAbs_REVERSED)
aNormal.Reverse();
}
}
const Handle(Geom_Line) aL = new Geom_Line(anAxis);
- const GeomAdaptor_Curve aLin(aL);
+ const Handle(GeomAdaptor_Curve) aLin = new GeomAdaptor_Curve(aL);
const Standard_Real aParTol = theC->Resolution(Precision::Confusion());
const Standard_Real aParF = theC->FirstParameter() + aParTol,
aParL = theC->LastParameter() - aParTol;
- Extrema_ExtCC anExtr (*theC, aLin);
+ Extrema_ExtCC anExtr (theC, aLin);
anExtr.Perform();
if (anExtr.IsDone() && anExtr.NbExt() > 0)
{
if(aGenS.ShapeType() == TopAbs_EDGE){
if (HasShape(aGenS,aDirS)){
TopoDS_Edge E = TopoDS::Edge(aGenS);
- BRepAdaptor_Curve e;
+ Handle(BRepAdaptor_Curve) e = new BRepAdaptor_Curve();
Standard_Real ud,uf;
TopoDS_Vertex d,f;
TopExp::Vertices(E,d,f);
if(d.IsSame(f)){
// tol3d = Max(tl,BRep_Tool::Tolerance(d));
tol3d = Max(tl,2.*BRep_Tool::Tolerance(d));//IFV 24.05.00 buc60684
- e.Initialize(E);
+ e->Initialize(E);
ud = BRep_Tool::Parameter(d,TopoDS::Edge(aGenS));
uf = BRep_Tool::Parameter(f,TopoDS::Edge(aGenS));
cont = BRepLProp::Continuity(e,e,ud,uf,tol3d,ta);
}
else if(aGenS.ShapeType() == TopAbs_WIRE){
TopoDS_Edge E1,E2;
- BRepAdaptor_Curve e1,e2;
+ Handle(BRepAdaptor_Curve) e1 = new BRepAdaptor_Curve();
+ Handle(BRepAdaptor_Curve) e2 = new BRepAdaptor_Curve();
Standard_Real u1,u2;
TopTools_IndexedDataMapOfShapeListOfShape M;
TopExp::MapShapesAndAncestors(aGenS,TopAbs_VERTEX,TopAbs_EDGE,M);
u2 = BRep_Tool::Parameter(V,E2);
// tol3d = Max(tl,BRep_Tool::Tolerance(V));
tol3d = Max(tl,2.*BRep_Tool::Tolerance(V)); //IFV 24.05.00 buc60684
- e1.Initialize(E1);
- e2.Initialize(E2);
+ e1->Initialize(E1);
+ e2->Initialize(E2);
cont = BRepLProp::Continuity(e1,e2,u1,u2,tol3d,ta);
if(cont >= 1){
TopoDS_Shape s_wnt = Shape(V,aDirS);
if (!S.IsNull())
{
//add surf
- GeomAdaptor_Surface aGAS(S);
+ Handle(GeomAdaptor_Surface) aGAS = new GeomAdaptor_Surface(S);
if (IsOptimal)
BndLib_AddSurface::AddOptimal(aGAS, Precision::Confusion(), B);
else
if (!C.IsNull())
{
// add cur
- GeomAdaptor_Curve aGAC(C);
+ Handle(GeomAdaptor_Curve) aGAC = new GeomAdaptor_Curve(C);
if (IsOptimal)
BndLib_Add3dCurve::AddOptimal(aGAC, Precision::Confusion(), B);
else
const Standard_Real theTol,
Standard_Real& theParam)
{
- GeomAdaptor_Curve anAdaptor(theCurve);
+ Handle(GeomAdaptor_Curve) anAdaptor = new GeomAdaptor_Curve(theCurve);
Extrema_LocateExtPC proj(thePoint, anAdaptor, theParam, theFirst, theLast, Precision::PConfusion());
if (proj.IsDone())
{
const Standard_Real theTol,
Standard_Real& theParam)
{
- Geom2dAdaptor_Curve anAdaptor(theCurve2d);
+ Handle(Geom2dAdaptor_Curve) anAdaptor = new Geom2dAdaptor_Curve(theCurve2d);
Extrema_LocateExtPC2d aProj(theUV, anAdaptor, theParam, Precision::PConfusion());
if (aProj.IsDone())
{
const Standard_Real theTol,
gp_Pnt2d& theUV)
{
- GeomAdaptor_Surface anAdaptor(theSurf);
+ Handle(GeomAdaptor_Surface) anAdaptor = new GeomAdaptor_Surface(theSurf);
Extrema_GenLocateExtPS aProj(anAdaptor);
aProj.Perform(thePoint, theUV.X(), theUV.Y());
if (aProj.IsDone())
{
Standard_Real pfbid,plbid;
if(BRep_Tool::CurveOnSurface(edge,Face,pfbid,plbid).IsNull()) return;
- BRepAdaptor_Curve2d C(edge,Face);
+ Handle(BRepAdaptor_Curve2d) C = new BRepAdaptor_Curve2d(edge,Face);
//-- ----------------------------------------
Standard_Boolean degenerated=Standard_False;
Standard_Integer Avant = nbpnts;
for(Standard_Integer e = firstpoint; e<=nbs; e++)
{
- gp_Pnt2d P2d = C.Value(u);
+ gp_Pnt2d P2d = C->Value(u);
if(P2d.X()<Umin) Umin = P2d.X();
if(P2d.X()>Umax) Umax = P2d.X();
if(P2d.Y()<Vmin) Vmin = P2d.Y();
Standard_Real pfbid, plbid;
BRep_Tool::Range(edge, Face, pfbid, plbid);
if (Abs(plbid - pfbid) < 1.e-9) continue;
- BRepAdaptor_Curve2d C(edge, Face);
+ Handle(BRepAdaptor_Curve2d) C = new BRepAdaptor_Curve2d(edge, Face);
GCPnts_QuasiUniformDeflection aDiscr(C, aDiscrDefl);
if (!aDiscr.IsDone())
break;
i += iStep;
for (; i != iEnd; i += iStep)
{
- gp_Pnt2d aP2d = C.Value(aDiscr.Parameter(i));
+ gp_Pnt2d aP2d = C->Value(aDiscr.Parameter(i));
SeqPnt2d.Append(aP2d);
}
if (nbp > 2)
= new Bisector_BisecPC(curve2, P1, sign2, VMin, VMax);
Handle(Geom2d_Line) NorLi = new Geom2d_Line (P1,N1);
- Geom2dAdaptor_Curve ABisPC(BisPC);
- Geom2dAdaptor_Curve ANorLi(NorLi);
+ Handle(Geom2dAdaptor_Curve) ABisPC = new Geom2dAdaptor_Curve(BisPC);
+ Handle(Geom2dAdaptor_Curve) ANorLi = new Geom2dAdaptor_Curve(NorLi);
//-------------------------------------------------------------------------
Geom2dInt_GInter Intersect(ABisPC,ANorLi,
Precision::Confusion(),Precision::Confusion());
Handle(Geom2d_Line) NorLi = new Geom2d_Line (P1,N1);
- Geom2dAdaptor_Curve ABisPC(BisPC);
- Geom2dAdaptor_Curve ANorLi(NorLi);
+ Handle(Geom2dAdaptor_Curve) ABisPC = new Geom2dAdaptor_Curve(BisPC);
+ Handle(Geom2dAdaptor_Curve) ANorLi = new Geom2dAdaptor_Curve(NorLi);
//-------------------------------------------------------------------------
Geom2dInt_GInter Intersect(ABisPC,ANorLi,
Precision::Confusion(),Precision::Confusion());
D2,C2Bis1,D1,TolConf,Standard_True);
}
Geom2dInt_GInter Intersect;
- Geom2dAdaptor_Curve AC2Bis1(C2Bis1);
- Geom2dAdaptor_Curve AC2Bis2(C2Bis2);
+ Handle(Geom2dAdaptor_Curve) AC2Bis1 = new Geom2dAdaptor_Curve(C2Bis1);
+ Handle(Geom2dAdaptor_Curve) AC2Bis2 = new Geom2dAdaptor_Curve(C2Bis2);
Intersect.Perform(AC2Bis1,D1,AC2Bis2,D2,TolConf,Tol);
Append (Intersect,D1.FirstParameter(),D1.LastParameter(),
D2.FirstParameter(),D2.LastParameter());
}
else if (Type1 == STANDARD_TYPE(Bisector_BisecPC) || Type2 == STANDARD_TYPE(Bisector_BisecPC)) {
Geom2dInt_GInter Intersect;
- Geom2dAdaptor_Curve ABis1(Bis1);
- Geom2dAdaptor_Curve ABis2(Bis2);
+ Handle(Geom2dAdaptor_Curve) ABis1 = new Geom2dAdaptor_Curve(Bis1);
+ Handle(Geom2dAdaptor_Curve) ABis2 = new Geom2dAdaptor_Curve(Bis2);
Intersect.Perform(ABis1,D1,ABis2,D2,TolConf,Tol);
Append (Intersect,D1.FirstParameter(),D1.LastParameter(),
D2.FirstParameter(),D2.LastParameter());
D2,Bis1,D1,TolConf,Standard_True);
}
Geom2dInt_GInter Intersect;
- Geom2dAdaptor_Curve ABis1(Bis1);
- Geom2dAdaptor_Curve ABis2(Bis2);
+ Handle(Geom2dAdaptor_Curve) ABis1 = new Geom2dAdaptor_Curve(Bis1);
+ Handle(Geom2dAdaptor_Curve) ABis2 = new Geom2dAdaptor_Curve(Bis2);
Intersect.Perform(ABis1,D1,ABis2,D2,TolConf,Tol);
Append (Intersect,D1.FirstParameter(),D1.LastParameter(),
D2.FirstParameter(),D2.LastParameter());
{
const Standard_Real TolAng = 0.001; //bug OCC25701
- ChFiDS_ElSpine& theElSpine = *hguide;
- if (theElSpine.NbVertices() == 0)
+ if (hguide->NbVertices() == 0)
return Standard_False;
Handle(TheTopolTool) DomainOfRst = (IndexOfRst == 1)? recdomain1 : recdomain2;
{
gp_Pnt2d P2dOnEnd = TheArcTool::Value(DomainOfRst->Value(), Ends[k]);
gp_Pnt PntOnEnd = TheSurfaceTool::Value(SurfOfRst, P2dOnEnd.X(), P2dOnEnd.Y());
- Extrema_ExtPC projoncurv(PntOnEnd, theElSpine);
+ Extrema_ExtPC projoncurv(PntOnEnd, hguide);
if (!projoncurv.IsDone())
continue;
Standard_Real MinSqDist = Precision::Infinite();
//Second we find right point and tangent on guide
GlobalMinSqDist = Precision::Infinite();
gp_Ax1 theAx1;
- for (Standard_Integer ind = 1; ind <= theElSpine.NbVertices(); ind++)
+ for (Standard_Integer ind = 1; ind <= hguide->NbVertices(); ind++)
{
- const gp_Ax1& anAx1 = theElSpine.VertexWithTangent(ind);
+ const gp_Ax1& anAx1 = hguide->VertexWithTangent(ind);
gp_Pnt aPnt = anAx1.Location();
Standard_Real aSqDist = PointOnGuide.SquareDistance(aPnt);
if (aSqDist < GlobalMinSqDist)
////////////////////////////////////////////////////////////////////////
//Project the point <PntOnPlane> on the surface 2
- Extrema_ExtPS projonsurf(PntOnPlane, *AnotherSurf,
+ Extrema_ExtPS projonsurf(PntOnPlane, AnotherSurf,
Precision::PConfusion(), Precision::PConfusion(),
Extrema_ExtFlag_MIN);
if (projonsurf.IsDone())
//function : Add
//purpose :
//=======================================================================
-void BndLib_Add2dCurve::Add(const Adaptor2d_Curve2d& aC,
+void BndLib_Add2dCurve::Add(const Handle(Adaptor2d_Curve2d)& aC,
const Standard_Real aTol,
Bnd_Box2d& aBox2D)
{
BndLib_Add2dCurve::Add(aC,
- aC.FirstParameter(),
- aC.LastParameter (),
+ aC->FirstParameter(),
+ aC->LastParameter (),
aTol,
aBox2D);
}
//function : Add
//purpose :
//=======================================================================
-void BndLib_Add2dCurve::Add(const Adaptor2d_Curve2d& aC,
+void BndLib_Add2dCurve::Add(const Handle(Adaptor2d_Curve2d)& aC,
const Standard_Real aU1,
const Standard_Real aU2,
const Standard_Real aTol,
Bnd_Box2d& aBox2D)
{
- Adaptor2d_Curve2d *pC=(Adaptor2d_Curve2d *)&aC;
- Geom2dAdaptor_Curve *pA=dynamic_cast<Geom2dAdaptor_Curve*>(pC);
- if (!pA) {
+ Handle(Geom2dAdaptor_Curve) pA = Handle(Geom2dAdaptor_Curve)::DownCast(aC);
+ if (pA.IsNull()) {
Standard_Real U, DU;
Standard_Integer N, j;
gp_Pnt2d P;
U = aU1;
DU = (aU2-aU1)/(N-1);
for (j=1; j<N; j++) {
- aC.D0(U,P);
+ aC->D0(U,P);
U+=DU;
aBox2D.Add(P);
}
- aC.D0(aU2,P);
+ aC->D0(aU2,P);
aBox2D.Add(P);
aBox2D.Enlarge(aTol);
return;
//! - a Geom_Hyperbola,
//! and P1 and P2 are either two negative infinite real
//! numbers, or two positive infinite real numbers.
- Standard_EXPORT static void Add (const Adaptor2d_Curve2d& C, const Standard_Real Tol, Bnd_Box2d& B);
+ Standard_EXPORT static void Add (const Handle(Adaptor2d_Curve2d)& C, const Standard_Real Tol, Bnd_Box2d& B);
//! Adds to the bounding box Bthe arc of the curve C limited by the two parameter
//! values P1 and P2.
//! - a Geom_Hyperbola,
//! and P1 and P2 are either two negative infinite real
//! numbers, or two positive infinite real numbers.
- Standard_EXPORT static void Add (const Adaptor2d_Curve2d& C, const Standard_Real U1, const Standard_Real U2, const Standard_Real Tol, Bnd_Box2d& B);
+ Standard_EXPORT static void Add (const Handle(Adaptor2d_Curve2d)& C, const Standard_Real U1, const Standard_Real U2, const Standard_Real Tol, Bnd_Box2d& B);
//! Adds to the bounding box B the curve C
//! B is then enlarged by the tolerance value Tol.
#include <math_PSO.hxx>
#include <math_BrentMinimum.hxx>
//
-static Standard_Integer NbSamples(const Adaptor3d_Curve& C,
+static Standard_Integer NbSamples(const Handle(Adaptor3d_Curve)& C,
const Standard_Real Umin,
const Standard_Real Umax);
-static Standard_Real AdjustExtr(const Adaptor3d_Curve& C,
+static Standard_Real AdjustExtr(const Handle(Adaptor3d_Curve)& C,
const Standard_Real UMin,
const Standard_Real UMax,
const Standard_Real Extr0,
//purpose : This method intended to reduce box in case of
// bezier and bspline curve.
//=======================================================================
-static void reduceSplineBox(const Adaptor3d_Curve& theCurve,
+static void reduceSplineBox(const Handle(Adaptor3d_Curve)& theCurve,
const Bnd_Box& theOrigBox,
Bnd_Box & theReducedBox)
{
Standard_Real aPolesXMin, aPolesYMin, aPolesZMin,
aPolesXMax, aPolesYMax, aPolesZMax;
- if (theCurve.GetType() == GeomAbs_BSplineCurve)
+ if (theCurve->GetType() == GeomAbs_BSplineCurve)
{
- Handle(Geom_BSplineCurve) aC = theCurve.BSpline();
+ Handle(Geom_BSplineCurve) aC = theCurve->BSpline();
const TColgp_Array1OfPnt& aPoles = aC->Poles();
for(Standard_Integer anIdx = aPoles.Lower();
aPolesBox.Add(aPoles.Value(anIdx));
}
}
- if (theCurve.GetType() == GeomAbs_BezierCurve)
+ if (theCurve->GetType() == GeomAbs_BezierCurve)
{
- Handle(Geom_BezierCurve) aC = theCurve.Bezier();
+ Handle(Geom_BezierCurve) aC = theCurve->Bezier();
const TColgp_Array1OfPnt& aPoles = aC->Poles();
for(Standard_Integer anIdx = aPoles.Lower();
//function : Add
//purpose :
//=======================================================================
-void BndLib_Add3dCurve::Add( const Adaptor3d_Curve& C,
+void BndLib_Add3dCurve::Add( const Handle(Adaptor3d_Curve)& C,
const Standard_Real Tol,
Bnd_Box& B )
{
BndLib_Add3dCurve::Add(C,
- C.FirstParameter(),
- C.LastParameter (),
+ C->FirstParameter(),
+ C->LastParameter (),
Tol,B);
}
//OCC566(apo)->
-static Standard_Real FillBox(Bnd_Box& B, const Adaptor3d_Curve& C,
+static Standard_Real FillBox(Bnd_Box& B, const Handle(Adaptor3d_Curve)& C,
const Standard_Real first, const Standard_Real last,
const Standard_Integer N)
{
gp_Pnt P1, P2, P3;
- C.D0(first,P1); B.Add(P1);
+ C->D0(first,P1); B.Add(P1);
Standard_Real p = first, dp = last-first, tol= 0.;
if(Abs(dp) > Precision::PConfusion()){
Standard_Integer i;
dp /= 2*N;
for(i = 1; i <= N; i++){
- p += dp; C.D0(p,P2); B.Add(P2);
- p += dp; C.D0(p,P3); B.Add(P3);
+ p += dp; C->D0(p,P2); B.Add(P2);
+ p += dp; C->D0(p,P3); B.Add(P3);
gp_Pnt Pc((P1.XYZ()+P3.XYZ())/2.0);
tol = Max(tol,Pc.Distance(P2));
P1 = P3;
}
}else{
- C.D0(first,P1); B.Add(P1);
- C.D0(last,P3); B.Add(P3);
+ C->D0(first,P1); B.Add(P1);
+ C->D0(last,P3); B.Add(P3);
tol = 0.;
}
return tol;
//purpose :
//=======================================================================
-void BndLib_Add3dCurve::Add( const Adaptor3d_Curve& C,
+void BndLib_Add3dCurve::Add( const Handle(Adaptor3d_Curve)& C,
const Standard_Real U1,
const Standard_Real U2,
const Standard_Real Tol,
{
static Standard_Real weakness = 1.5; //OCC566(apo)
Standard_Real tol = 0.0;
- switch (C.GetType()) {
+ switch (C->GetType()) {
case GeomAbs_Line:
{
- BndLib::Add(C.Line(),U1,U2,Tol,B);
+ BndLib::Add(C->Line(),U1,U2,Tol,B);
break;
}
case GeomAbs_Circle:
{
- BndLib::Add(C.Circle(),U1,U2,Tol,B);
+ BndLib::Add(C->Circle(),U1,U2,Tol,B);
break;
}
case GeomAbs_Ellipse:
{
- BndLib::Add(C.Ellipse(),U1,U2,Tol,B);
+ BndLib::Add(C->Ellipse(),U1,U2,Tol,B);
break;
}
case GeomAbs_Hyperbola:
{
- BndLib::Add(C.Hyperbola(),U1,U2,Tol,B);
+ BndLib::Add(C->Hyperbola(),U1,U2,Tol,B);
break;
}
case GeomAbs_Parabola:
{
- BndLib::Add(C.Parabola(),U1,U2,Tol,B);
+ BndLib::Add(C->Parabola(),U1,U2,Tol,B);
break;
}
case GeomAbs_BezierCurve:
{
- Handle(Geom_BezierCurve) Bz = C.Bezier();
+ Handle(Geom_BezierCurve) Bz = C->Bezier();
Standard_Integer N = Bz->Degree();
- GeomAdaptor_Curve GACurve(Bz);
+ Handle(GeomAdaptor_Curve) GACurve = new GeomAdaptor_Curve(Bz);
Bnd_Box B1;
tol = FillBox(B1,GACurve,U1,U2,N);
B1.Enlarge(weakness*tol);
}
case GeomAbs_BSplineCurve:
{
- Handle(Geom_BSplineCurve) Bs = C.BSpline();
+ Handle(Geom_BSplineCurve) Bs = C->BSpline();
if(Abs(Bs->FirstParameter() - U1) > Precision::Parametric(Tol)||
Abs(Bs->LastParameter() - U2) > Precision::Parametric(Tol)) {
N = Bs->Degree(), NbKnots = Bs->NbKnots();
TColStd_Array1OfReal Knots(1,NbKnots);
Bs->Knots(Knots);
- GeomAdaptor_Curve GACurve(Bs);
+ Handle(GeomAdaptor_Curve) GACurve = new GeomAdaptor_Curve(Bs);
Standard_Real first = Knots(k1), last;
for(k = k1 + 1; k <= k2; k++){
last = Knots(k);
//purpose :
//=======================================================================
-void BndLib_Add3dCurve::AddOptimal( const Adaptor3d_Curve& C,
+void BndLib_Add3dCurve::AddOptimal( const Handle(Adaptor3d_Curve)& C,
const Standard_Real Tol,
Bnd_Box& B )
{
BndLib_Add3dCurve::AddOptimal(C,
- C.FirstParameter(),
- C.LastParameter (),
+ C->FirstParameter(),
+ C->LastParameter (),
Tol,B);
}
//purpose :
//=======================================================================
-void BndLib_Add3dCurve::AddOptimal( const Adaptor3d_Curve& C,
+void BndLib_Add3dCurve::AddOptimal( const Handle(Adaptor3d_Curve)& C,
const Standard_Real U1,
const Standard_Real U2,
const Standard_Real Tol,
Bnd_Box& B)
{
- switch (C.GetType()) {
+ switch (C->GetType()) {
case GeomAbs_Line:
{
- BndLib::Add(C.Line(),U1,U2,Tol,B);
+ BndLib::Add(C->Line(),U1,U2,Tol,B);
break;
}
case GeomAbs_Circle:
{
- BndLib::Add(C.Circle(),U1,U2,Tol,B);
+ BndLib::Add(C->Circle(),U1,U2,Tol,B);
break;
}
case GeomAbs_Ellipse:
{
- BndLib::Add(C.Ellipse(),U1,U2,Tol,B);
+ BndLib::Add(C->Ellipse(),U1,U2,Tol,B);
break;
}
case GeomAbs_Hyperbola:
{
- BndLib::Add(C.Hyperbola(),U1,U2,Tol,B);
+ BndLib::Add(C->Hyperbola(),U1,U2,Tol,B);
break;
}
case GeomAbs_Parabola:
{
- BndLib::Add(C.Parabola(),U1,U2,Tol,B);
+ BndLib::Add(C->Parabola(),U1,U2,Tol,B);
break;
}
default:
//function : AddGenCurv
//purpose :
//=======================================================================
-void BndLib_Add3dCurve::AddGenCurv(const Adaptor3d_Curve& C,
+void BndLib_Add3dCurve::AddGenCurv(const Handle(Adaptor3d_Curve)& C,
const Standard_Real UMin,
const Standard_Real UMax,
const Standard_Real Tol,
Standard_Real u;
for (i = 1, u = UMin; i <= Nu; i++, u += du)
{
- C.D0(u,P);
+ C->D0(u,P);
aPnts(i) = P.XYZ();
//
for(k = 0; k < 3; ++k)
if(i > 1)
{
gp_XYZ aPm = 0.5 * (aPnts(i-1) + aPnts(i));
- C.D0(u - du2, P);
+ C->D0(u - du2, P);
gp_XYZ aD = (P.XYZ() - aPm);
for(k = 0; k < 3; ++k)
{
class CurvMaxMinCoordMVar : public math_MultipleVarFunction
{
public:
- CurvMaxMinCoordMVar(const Adaptor3d_Curve& theCurve,
+ CurvMaxMinCoordMVar(const Handle(Adaptor3d_Curve)& theCurve,
const Standard_Real UMin,
const Standard_Real UMax,
const Standard_Integer CoordIndx,
{
return Standard_False;
}
- gp_Pnt aP = myCurve.Value(X(1));
+ gp_Pnt aP = myCurve->Value(X(1));
F = mySign * aP.Coord(myCoordIndx);
return Standard_True;
}
- const Adaptor3d_Curve& myCurve;
+ const Handle(Adaptor3d_Curve)& myCurve;
Standard_Real myUMin;
Standard_Real myUMax;
Standard_Integer myCoordIndx;
class CurvMaxMinCoord : public math_Function
{
public:
- CurvMaxMinCoord(const Adaptor3d_Curve& theCurve,
+ CurvMaxMinCoord(const Handle(Adaptor3d_Curve)& theCurve,
const Standard_Real UMin,
const Standard_Real UMax,
const Standard_Integer CoordIndx,
{
return Standard_False;
}
- gp_Pnt aP = myCurve.Value(X);
+ gp_Pnt aP = myCurve->Value(X);
F = mySign * aP.Coord(myCoordIndx);
return Standard_True;
}
- const Adaptor3d_Curve& myCurve;
+ const Handle(Adaptor3d_Curve)& myCurve;
Standard_Real myUMin;
Standard_Real myUMax;
Standard_Integer myCoordIndx;
//purpose :
//=======================================================================
-Standard_Real AdjustExtr(const Adaptor3d_Curve& C,
+Standard_Real AdjustExtr(const Handle(Adaptor3d_Curve)& C,
const Standard_Real UMin,
const Standard_Real UMax,
const Standard_Real Extr0,
Standard_Real aSign = IsMin ? 1.:-1.;
Standard_Real extr = aSign * Extr0;
//
- Standard_Real uTol = Max(C.Resolution(Tol), Precision::PConfusion());
- Standard_Real Du = (C.LastParameter() - C.FirstParameter());
+ Standard_Real uTol = Max(C->Resolution(Tol), Precision::PConfusion());
+ Standard_Real Du = (C->LastParameter() - C->FirstParameter());
//
Standard_Real reltol = uTol / Max(Abs(UMin), Abs(UMax));
if(UMax - UMin < 0.01 * Du)
//purpose :
//=======================================================================
-Standard_Integer NbSamples(const Adaptor3d_Curve& C,
+Standard_Integer NbSamples(const Handle(Adaptor3d_Curve)& C,
const Standard_Real Umin,
const Standard_Real Umax)
{
Standard_Integer N;
- GeomAbs_CurveType Type = C.GetType();
+ GeomAbs_CurveType Type = C->GetType();
switch (Type) {
case GeomAbs_BezierCurve:
{
- N = 2 * C.NbPoles();
+ N = 2 * C->NbPoles();
//By default parametric range of Bezier curv is [0, 1]
Standard_Real du = Umax - Umin;
if(du < .9)
}
case GeomAbs_BSplineCurve:
{
- const Handle(Geom_BSplineCurve)& BC = C.BSpline();
+ const Handle(Geom_BSplineCurve)& BC = C->BSpline();
N = 2 * (BC->Degree() + 1)*(BC->NbKnots() -1);
Standard_Real umin = BC->FirstParameter(),
umax = BC->LastParameter();
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
//
class Adaptor3d_Curve;
//! - a Geom_Hyperbola,
//! and P1 and P2 are either two negative infinite real
//! numbers, or two positive infinite real numbers.
- Standard_EXPORT static void Add (const Adaptor3d_Curve& C, const Standard_Real Tol, Bnd_Box& B);
+ Standard_EXPORT static void Add (const Handle(Adaptor3d_Curve)& C, const Standard_Real Tol, Bnd_Box& B);
//! Adds to the bounding box B the curve C
//! the arc of the curve C limited by the two parameter values P1 and P2.
//! - a Geom_Hyperbola,
//! and P1 and P2 are either two negative infinite real
//! numbers, or two positive infinite real numbers.
- Standard_EXPORT static void Add (const Adaptor3d_Curve& C, const Standard_Real U1, const Standard_Real U2, const Standard_Real Tol, Bnd_Box& B);
+ Standard_EXPORT static void Add (const Handle(Adaptor3d_Curve)& C, const Standard_Real U1, const Standard_Real U2, const Standard_Real Tol, Bnd_Box& B);
//! Adds to the bounding box B the curve C
//! These methods use more precise algorithms for building bnd box
//! then methods Add(...)
- Standard_EXPORT static void AddOptimal (const Adaptor3d_Curve& C, const Standard_Real Tol, Bnd_Box& B);
- Standard_EXPORT static void AddOptimal (const Adaptor3d_Curve& C,
+ Standard_EXPORT static void AddOptimal (const Handle(Adaptor3d_Curve)& C, const Standard_Real Tol, Bnd_Box& B);
+ Standard_EXPORT static void AddOptimal (const Handle(Adaptor3d_Curve)& C,
const Standard_Real U1, const Standard_Real U2,
const Standard_Real Tol, Bnd_Box& B);
//! Adds to the bounding box B the curve C
//! using numerical minimization algorithms
//! This method is used in AddOptimal for not analytical curves.
//! if Tol < Precision::Confusion(), Precision:;Confusion is used as computation tolerance
- Standard_EXPORT static void AddGenCurv(const Adaptor3d_Curve& C,
+ Standard_EXPORT static void AddGenCurv(const Handle(Adaptor3d_Curve)& C,
const Standard_Real UMin,
const Standard_Real UMax,
const Standard_Real Tol,
#include <math_PSO.hxx>
#include <math_Powell.hxx>
//
-static Standard_Integer NbUSamples(const Adaptor3d_Surface& S,
+static Standard_Integer NbUSamples(const Handle(Adaptor3d_Surface)& S,
const Standard_Real Umin,
const Standard_Real Umax);
//
-static Standard_Integer NbVSamples(const Adaptor3d_Surface& S,
+static Standard_Integer NbVSamples(const Handle(Adaptor3d_Surface)& S,
const Standard_Real Vmin,
const Standard_Real Vmax);
//
-static Standard_Real AdjustExtr(const Adaptor3d_Surface& S,
+static Standard_Real AdjustExtr(const Handle(Adaptor3d_Surface)& S,
const Standard_Real UMin,
const Standard_Real UMax,
const Standard_Real VMin,
//function : Add
//purpose :
//=======================================================================
-void BndLib_AddSurface::Add(const Adaptor3d_Surface& S,
+void BndLib_AddSurface::Add(const Handle(Adaptor3d_Surface)& S,
const Standard_Real Tol,
Bnd_Box& B )
{
BndLib_AddSurface::Add(S,
- S.FirstUParameter(),
- S.LastUParameter (),
- S.FirstVParameter(),
- S.LastVParameter (),Tol,B);
+ S->FirstUParameter(),
+ S->LastUParameter (),
+ S->FirstVParameter(),
+ S->LastVParameter (),Tol,B);
}
//=======================================================================
//function : NbUSamples
//purpose :
//=======================================================================
-static Standard_Integer NbUSamples(const Adaptor3d_Surface& S)
+static Standard_Integer NbUSamples(const Handle(Adaptor3d_Surface)& S)
{
Standard_Integer N;
- GeomAbs_SurfaceType Type = S.GetType();
+ GeomAbs_SurfaceType Type = S->GetType();
switch (Type) {
case GeomAbs_BezierSurface:
{
- N = 2*S.NbUPoles();
+ N = 2*S->NbUPoles();
break;
}
case GeomAbs_BSplineSurface:
{
- const Handle(Geom_BSplineSurface)& BS = S.BSpline();
+ const Handle(Geom_BSplineSurface)& BS = S->BSpline();
N = 2*(BS->UDegree() + 1)*(BS->NbUKnots() -1);
break;
}
//purpose :
//=======================================================================
-static Standard_Integer NbVSamples(const Adaptor3d_Surface& S)
+static Standard_Integer NbVSamples(const Handle(Adaptor3d_Surface)& S)
{
Standard_Integer N;
- GeomAbs_SurfaceType Type = S.GetType();
+ GeomAbs_SurfaceType Type = S->GetType();
switch (Type) {
case GeomAbs_BezierSurface:
{
- N = 2*S.NbVPoles();
+ N = 2*S->NbVPoles();
break;
}
case GeomAbs_BSplineSurface:
{
- const Handle(Geom_BSplineSurface)& BS = S.BSpline();
+ const Handle(Geom_BSplineSurface)& BS = S->BSpline();
N = 2*(BS->VDegree() + 1)*(BS->NbVKnots() - 1) ;
break;
}
//function : Add
//purpose :
//=======================================================================
-void BndLib_AddSurface::Add(const Adaptor3d_Surface& S,
+void BndLib_AddSurface::Add(const Handle(Adaptor3d_Surface)& S,
const Standard_Real UMin,
const Standard_Real UMax,
const Standard_Real VMin,
const Standard_Real Tol,
Bnd_Box& B )
{
- GeomAbs_SurfaceType Type = S.GetType(); // skv OCC6503
+ GeomAbs_SurfaceType Type = S->GetType(); // skv OCC6503
if (Precision::IsInfinite(VMin) ||
Precision::IsInfinite(VMax) ||
switch (Type) {
case GeomAbs_Plane:
{
- TreatInfinitePlane(S.Plane(), UMin, UMax, VMin, VMax, Tol, B);
+ TreatInfinitePlane(S->Plane(), UMin, UMax, VMin, VMax, Tol, B);
return;
}
default:
// Modified by skv - Fri Aug 27 12:29:04 2004 OCC6503 End
}
-// GeomAbs_SurfaceType Type = S.GetType(); // skv OCC6503
+// GeomAbs_SurfaceType Type = S->GetType(); // skv OCC6503
switch (Type) {
case GeomAbs_Plane:
{
- gp_Pln Plan = S.Plane();
+ gp_Pln Plan = S->Plane();
B.Add(ElSLib::Value(UMin,VMin,Plan));
B.Add(ElSLib::Value(UMin,VMax,Plan));
B.Add(ElSLib::Value(UMax,VMin,Plan));
}
case GeomAbs_Cylinder:
{
- BndLib::Add(S.Cylinder(),UMin,UMax,VMin,VMax,Tol,B);
+ BndLib::Add(S->Cylinder(),UMin,UMax,VMin,VMax,Tol,B);
break;
}
case GeomAbs_Cone:
{
- BndLib::Add(S.Cone(),UMin,UMax,VMin,VMax,Tol,B);
+ BndLib::Add(S->Cone(),UMin,UMax,VMin,VMax,Tol,B);
break;
}
case GeomAbs_Torus:
{
- BndLib::Add(S.Torus(),UMin,UMax,VMin,VMax,Tol,B);
+ BndLib::Add(S->Torus(),UMin,UMax,VMin,VMax,Tol,B);
break;
}
case GeomAbs_Sphere:
Abs(UMax - 2.*M_PI) < Precision::Angular() &&
Abs(VMin + M_PI/2.) < Precision::Angular() &&
Abs(VMax - M_PI/2.) < Precision::Angular()) // a whole sphere
- BndLib::Add(S.Sphere(),Tol,B);
+ BndLib::Add(S->Sphere(),Tol,B);
else
- BndLib::Add(S.Sphere(),UMin,UMax,VMin,VMax,Tol,B);
+ BndLib::Add(S->Sphere(),UMin,UMax,VMin,VMax,Tol,B);
break;
}
case GeomAbs_OffsetSurface:
{
- Handle(Adaptor3d_Surface) HS = S.BasisSurface();
- Add (*HS,UMin,UMax,VMin,VMax,Tol,B);
- B.Enlarge(S.OffsetValue());
+ Handle(Adaptor3d_Surface) HS = S->BasisSurface();
+ Add (HS,UMin,UMax,VMin,VMax,Tol,B);
+ B.Enlarge(S->OffsetValue());
B.Enlarge(Tol);
break;
}
// All of poles used for any parameter,
// that's why in case of trimmed parameters handled by grid algorithm.
- if (Abs(UMin-S.FirstUParameter()) > PTol ||
- Abs(VMin-S.FirstVParameter()) > PTol ||
- Abs(UMax-S.LastUParameter ()) > PTol ||
- Abs(VMax-S.LastVParameter ()) > PTol )
+ if (Abs(UMin-S->FirstUParameter()) > PTol ||
+ Abs(VMin-S->FirstVParameter()) > PTol ||
+ Abs(UMax-S->LastUParameter ()) > PTol ||
+ Abs(VMax-S->LastVParameter ()) > PTol )
{
// Borders not equal to topology borders.
isUseConvexHullAlgorithm = Standard_False;
// use convex hull algorithm,
// if Umin, VMin, Umax, Vmax lies outside then:
// use grid algorithm on analytic continuation (default case).
- aBS = S.BSpline();
+ aBS = S->BSpline();
aBS->Bounds(anUMinParam, anUMaxParam, aVMinParam, aVMaxParam);
if ( (UMin - anUMinParam) < -PTol ||
(VMin - aVMinParam) < -PTol ||
if (isUseConvexHullAlgorithm)
{
- Standard_Integer aNbUPoles = S.NbUPoles(), aNbVPoles = S.NbVPoles();
+ Standard_Integer aNbUPoles = S->NbUPoles(), aNbVPoles = S->NbVPoles();
TColgp_Array2OfPnt Tp(1, aNbUPoles, 1, aNbVPoles);
Standard_Integer UMinIdx = 0, UMaxIdx = 0;
Standard_Integer VMinIdx = 0, VMaxIdx = 0;
- Standard_Boolean isUPeriodic = S.IsUPeriodic(), isVPeriodic = S.IsVPeriodic();
+ Standard_Boolean isUPeriodic = S->IsUPeriodic(), isVPeriodic = S->IsVPeriodic();
if (Type == GeomAbs_BezierSurface)
{
- S.Bezier()->Poles(Tp);
+ S->Bezier()->Poles(Tp);
UMinIdx = 1; UMaxIdx = aNbUPoles;
VMinIdx = 1; VMaxIdx = aNbVPoles;
}
Standard_Real U = UMin + ((UMax-UMin)*(i-1)/(Nu-1));
for (Standard_Integer j=1 ;j<=Nv;j++){
Standard_Real V = VMin + ((VMax-VMin)*(j-1)/(Nv-1));
- S.D0(U,V,P);
+ S->D0(U,V,P);
B.Add(P);
}
}
//function : AddOptimal
//purpose :
//=======================================================================
-void BndLib_AddSurface::AddOptimal(const Adaptor3d_Surface& S,
+void BndLib_AddSurface::AddOptimal(const Handle(Adaptor3d_Surface)& S,
const Standard_Real Tol,
Bnd_Box& B )
{
BndLib_AddSurface::AddOptimal(S,
- S.FirstUParameter(),
- S.LastUParameter (),
- S.FirstVParameter(),
- S.LastVParameter (),Tol,B);
+ S->FirstUParameter(),
+ S->LastUParameter (),
+ S->FirstVParameter(),
+ S->LastVParameter (),Tol,B);
}
//=======================================================================
//function : AddOptimal
//purpose :
//=======================================================================
-void BndLib_AddSurface::AddOptimal(const Adaptor3d_Surface& S,
+void BndLib_AddSurface::AddOptimal(const Handle(Adaptor3d_Surface)& S,
const Standard_Real UMin,
const Standard_Real UMax,
const Standard_Real VMin,
const Standard_Real Tol,
Bnd_Box& B )
{
- GeomAbs_SurfaceType Type = S.GetType();
+ GeomAbs_SurfaceType Type = S->GetType();
if (Precision::IsInfinite(VMin) ||
Precision::IsInfinite(VMax) ||
switch (Type) {
case GeomAbs_Plane:
{
- TreatInfinitePlane(S.Plane(), UMin, UMax, VMin, VMax, Tol, B);
+ TreatInfinitePlane(S->Plane(), UMin, UMax, VMin, VMax, Tol, B);
return;
}
default:
case GeomAbs_Plane:
{
- gp_Pln Plan = S.Plane();
+ gp_Pln Plan = S->Plane();
B.Add(ElSLib::Value(UMin,VMin,Plan));
B.Add(ElSLib::Value(UMin,VMax,Plan));
B.Add(ElSLib::Value(UMax,VMin,Plan));
}
case GeomAbs_Cylinder:
{
- BndLib::Add(S.Cylinder(), UMin, UMax, VMin, VMax, Tol, B);
+ BndLib::Add(S->Cylinder(), UMin, UMax, VMin, VMax, Tol, B);
break;
}
case GeomAbs_Cone:
{
- BndLib::Add(S.Cone(), UMin, UMax, VMin, VMax, Tol, B);
+ BndLib::Add(S->Cone(), UMin, UMax, VMin, VMax, Tol, B);
break;
}
case GeomAbs_Sphere:
{
- BndLib::Add(S.Sphere(), UMin, UMax, VMin, VMax, Tol, B);
+ BndLib::Add(S->Sphere(), UMin, UMax, VMin, VMax, Tol, B);
break;
}
default:
//function : AddGenSurf
//purpose :
//=======================================================================
-void BndLib_AddSurface::AddGenSurf(const Adaptor3d_Surface& S,
+void BndLib_AddSurface::AddGenSurf(const Handle(Adaptor3d_Surface)& S,
const Standard_Real UMin,
const Standard_Real UMax,
const Standard_Real VMin,
gp_Pnt P;
for (i = 1, u = UMin; i <= Nu; i++, u += du){
for (j = 1, v = VMin;j <= Nv; j++, v += dv){
- S.D0(u,v,P);
+ S->D0(u,v,P);
aPnts(i, j) = P.XYZ();
//
for(k = 0; k < 3; ++k)
if(i > 1)
{
gp_XYZ aPm = 0.5 * (aPnts(i-1,j) + aPnts(i, j));
- S.D0(u - du2, v, P);
+ S->D0(u - du2, v, P);
gp_XYZ aD = (P.XYZ() - aPm);
for(k = 0; k < 3; ++k)
{
if(j > 1)
{
gp_XYZ aPm = 0.5 * (aPnts(i,j-1) + aPnts(i, j));
- S.D0(u , v - dv2, P);
+ S->D0(u , v - dv2, P);
gp_XYZ aD = (P.XYZ() - aPm);
for(k = 0; k < 3; ++k)
{
class SurfMaxMinCoord : public math_MultipleVarFunction
{
public:
- SurfMaxMinCoord(const Adaptor3d_Surface& theSurf,
+ SurfMaxMinCoord(const Handle(Adaptor3d_Surface)& theSurf,
const Standard_Real UMin,
const Standard_Real UMax,
const Standard_Real VMin,
{
if (CheckInputData(X))
{
- gp_Pnt aP = mySurf.Value(X(1), X(2));
+ gp_Pnt aP = mySurf->Value(X(1), X(2));
F = mySign * aP.Coord(myCoordIndx);
}
else
v0 = X(2);
}
//
- gp_Pnt aP = mySurf.Value(u0, v0);
+ gp_Pnt aP = mySurf->Value(u0, v0);
F = mySign * aP.Coord(myCoordIndx) + UPen + VPen;
}
return Standard_True;
}
- const Adaptor3d_Surface& mySurf;
+ const Handle(Adaptor3d_Surface)& mySurf;
Standard_Real myUMin;
Standard_Real myUMax;
Standard_Real myVMin;
//purpose :
//=======================================================================
-Standard_Real AdjustExtr(const Adaptor3d_Surface& S,
+Standard_Real AdjustExtr(const Handle(Adaptor3d_Surface)& S,
const Standard_Real UMin,
const Standard_Real UMax,
const Standard_Real VMin,
{
relTol /= Abs(extr);
}
- Standard_Real Du = (S.LastUParameter() - S.FirstUParameter());
- Standard_Real Dv = (S.LastVParameter() - S.FirstVParameter());
+ Standard_Real Du = (S->LastUParameter() - S->FirstUParameter());
+ Standard_Real Dv = (S->LastVParameter() - S->FirstVParameter());
//
math_Vector aT(1,2);
math_Vector aLowBorder(1,2);
//purpose :
//=======================================================================
-Standard_Integer NbUSamples(const Adaptor3d_Surface& S,
+Standard_Integer NbUSamples(const Handle(Adaptor3d_Surface)& S,
const Standard_Real Umin,
const Standard_Real Umax)
{
Standard_Integer N;
- GeomAbs_SurfaceType Type = S.GetType();
+ GeomAbs_SurfaceType Type = S->GetType();
switch (Type) {
case GeomAbs_BezierSurface:
{
- N = 2*S.NbUPoles();
+ N = 2*S->NbUPoles();
//By default parametric range of Bezier surf is [0, 1] [0, 1]
Standard_Real du = Umax - Umin;
if(du < .9)
}
case GeomAbs_BSplineSurface:
{
- const Handle(Geom_BSplineSurface)& BS = S.BSpline();
+ const Handle(Geom_BSplineSurface)& BS = S->BSpline();
N = 2*(BS->UDegree() + 1)*(BS->NbUKnots() -1);
Standard_Real umin, umax, vmin, vmax;
BS->Bounds(umin, umax, vmin, vmax);
//purpose :
//=======================================================================
-Standard_Integer NbVSamples(const Adaptor3d_Surface& S,
+Standard_Integer NbVSamples(const Handle(Adaptor3d_Surface)& S,
const Standard_Real Vmin,
const Standard_Real Vmax)
{
Standard_Integer N;
- GeomAbs_SurfaceType Type = S.GetType();
+ GeomAbs_SurfaceType Type = S->GetType();
switch (Type) {
case GeomAbs_BezierSurface:
{
- N = 2*S.NbVPoles();
+ N = 2*S->NbVPoles();
//By default parametric range of Bezier surf is [0, 1] [0, 1]
Standard_Real dv = Vmax - Vmin;
if(dv < .9)
}
case GeomAbs_BSplineSurface:
{
- const Handle(Geom_BSplineSurface)& BS = S.BSpline();
+ const Handle(Geom_BSplineSurface)& BS = S->BSpline();
N = 2*(BS->VDegree() + 1)*(BS->NbVKnots() - 1) ;
Standard_Real umin, umax, vmin, vmax;
BS->Bounds(umin, umax, vmin, vmax);
//! // ...
//! Standard_Real Tol = ... ;
//! AddSurface::Add ( S, Tol, B );
- Standard_EXPORT static void Add (const Adaptor3d_Surface& S, const Standard_Real Tol, Bnd_Box& B);
+ Standard_EXPORT static void Add (const Handle(Adaptor3d_Surface)& S, const Standard_Real Tol, Bnd_Box& B);
//! Adds to the bounding box B the surface S
//! the patch of the surface S limited in the u parametric
//! // ...
//! Standard_Real Tol = ... ;
//! AddSurface::Add ( S, Tol, B );
- Standard_EXPORT static void Add (const Adaptor3d_Surface& S, const Standard_Real UMin, const Standard_Real UMax, const Standard_Real VMin, const Standard_Real VMax, const Standard_Real Tol, Bnd_Box& B);
+ Standard_EXPORT static void Add (const Handle(Adaptor3d_Surface)& S, const Standard_Real UMin, const Standard_Real UMax, const Standard_Real VMin, const Standard_Real VMax, const Standard_Real Tol, Bnd_Box& B);
//! Adds the surface S to the bounding box B.
//! This algorithm builds precise bounding box
- Standard_EXPORT static void AddOptimal (const Adaptor3d_Surface& S, const Standard_Real Tol, Bnd_Box& B);
+ Standard_EXPORT static void AddOptimal (const Handle(Adaptor3d_Surface)& S, const Standard_Real Tol, Bnd_Box& B);
- Standard_EXPORT static void AddOptimal (const Adaptor3d_Surface& S,
+ Standard_EXPORT static void AddOptimal (const Handle(Adaptor3d_Surface)& S,
const Standard_Real UMin, const Standard_Real UMax,
const Standard_Real VMin, const Standard_Real VMax,
const Standard_Real Tol, Bnd_Box& B);
//! using numerical minimization algorithms
//! This method is used in AddOptimal for not analytical surfaces and torus.
//! if Tol < Precision::Confusion(), Precision::Confusion is used as computation tolerance
- Standard_EXPORT static void AddGenSurf(const Adaptor3d_Surface& S,
+ Standard_EXPORT static void AddGenSurf(const Handle(Adaptor3d_Surface)& S,
const Standard_Real UMin,
const Standard_Real UMax,
const Standard_Real VMin,
return V.Magnitude();
}
-static Standard_Integer order(const Adaptor3d_Curve& C)
+static Standard_Integer order(const Handle(Adaptor3d_Curve)& C)
{
- switch (C.GetType()) {
+ switch (C->GetType()) {
case GeomAbs_Line :
return 2;
return 5;
case GeomAbs_BezierCurve :
- return Min(24, 2*C.Degree());
+ return Min(24, 2*C->Degree());
case GeomAbs_BSplineCurve :
- return Min(24, 2*C.NbPoles()-1);
+ return Min(24, 2*C->NbPoles()-1);
default :
return 10;
}
}
-static Standard_Integer order(const Adaptor2d_Curve2d& C)
+static Standard_Integer order(const Handle(Adaptor2d_Curve2d)& C)
{
- switch (C.GetType()) {
+ switch (C->GetType()) {
case GeomAbs_Line :
return 2;
return 5;
case GeomAbs_BezierCurve :
- return Min(24, 2*C.Bezier()->Degree());
+ return Min(24, 2*C->Bezier()->Degree());
case GeomAbs_BSplineCurve :
- return Min(24, 2*C.BSpline()->NbPoles()-1);
+ return Min(24, 2*C->BSpline()->NbPoles()-1);
default :
return 10;
//purpose : 3d
//=======================================================================
-Standard_Real CPnts_AbscissaPoint::Length(const Adaptor3d_Curve& C)
+Standard_Real CPnts_AbscissaPoint::Length(const Handle(Adaptor3d_Curve)& C)
{
- return CPnts_AbscissaPoint::Length(C, C.FirstParameter(),
- C.LastParameter());
+ return CPnts_AbscissaPoint::Length(C, C->FirstParameter(),
+ C->LastParameter());
}
//=======================================================================
//purpose : 2d
//=======================================================================
-Standard_Real CPnts_AbscissaPoint::Length(const Adaptor2d_Curve2d& C)
+Standard_Real CPnts_AbscissaPoint::Length(const Handle(Adaptor2d_Curve2d)& C)
{
- return CPnts_AbscissaPoint::Length(C, C.FirstParameter(),
- C.LastParameter());
+ return CPnts_AbscissaPoint::Length(C, C->FirstParameter(),
+ C->LastParameter());
}
//=======================================================================
//purpose : 3d with tolerance
//=======================================================================
-Standard_Real CPnts_AbscissaPoint::Length(const Adaptor3d_Curve& C, const Standard_Real Tol)
+Standard_Real CPnts_AbscissaPoint::Length(const Handle(Adaptor3d_Curve)& C, const Standard_Real Tol)
{
- return CPnts_AbscissaPoint::Length(C, C.FirstParameter(),
- C.LastParameter(), Tol);
+ return CPnts_AbscissaPoint::Length(C, C->FirstParameter(),
+ C->LastParameter(), Tol);
}
//=======================================================================
//purpose : 2d with tolerance
//=======================================================================
-Standard_Real CPnts_AbscissaPoint::Length(const Adaptor2d_Curve2d& C, const Standard_Real Tol)
+Standard_Real CPnts_AbscissaPoint::Length(const Handle(Adaptor2d_Curve2d)& C, const Standard_Real Tol)
{
- return CPnts_AbscissaPoint::Length(C, C.FirstParameter(),
- C.LastParameter(), Tol);
+ return CPnts_AbscissaPoint::Length(C, C->FirstParameter(),
+ C->LastParameter(), Tol);
}
//purpose : 3d with parameters
//=======================================================================
-Standard_Real CPnts_AbscissaPoint::Length(const Adaptor3d_Curve& C,
+Standard_Real CPnts_AbscissaPoint::Length(const Handle(Adaptor3d_Curve)& C,
const Standard_Real U1,
const Standard_Real U2)
{
CPnts_MyGaussFunction FG;
//POP pout WNT
CPnts_RealFunction rf = f3d;
- FG.Init(rf,(Standard_Address)&C);
+ FG.Init(rf, C.operator->());
// FG.Init(f3d,(Standard_Address)&C);
math_GaussSingleIntegration TheLength(FG, U1, U2, order(C));
if (!TheLength.IsDone()) {
//purpose : 2d with parameters
//=======================================================================
-Standard_Real CPnts_AbscissaPoint::Length(const Adaptor2d_Curve2d& C,
+Standard_Real CPnts_AbscissaPoint::Length(const Handle(Adaptor2d_Curve2d)& C,
const Standard_Real U1,
const Standard_Real U2)
{
CPnts_MyGaussFunction FG;
//POP pout WNT
CPnts_RealFunction rf = f2d;
- FG.Init(rf,(Standard_Address)&C);
+ FG.Init(rf, C.operator->());
// FG.Init(f2d,(Standard_Address)&C);
math_GaussSingleIntegration TheLength(FG, U1, U2, order(C));
if (!TheLength.IsDone()) {
//purpose : 3d with parameters and tolerance
//=======================================================================
-Standard_Real CPnts_AbscissaPoint::Length(const Adaptor3d_Curve& C,
+Standard_Real CPnts_AbscissaPoint::Length(const Handle(Adaptor3d_Curve)& C,
const Standard_Real U1,
const Standard_Real U2,
const Standard_Real Tol)
CPnts_MyGaussFunction FG;
//POP pout WNT
CPnts_RealFunction rf = f3d;
- FG.Init(rf,(Standard_Address)&C);
+ FG.Init(rf, C.operator->());
// FG.Init(f3d,(Standard_Address)&C);
math_GaussSingleIntegration TheLength(FG, U1, U2, order(C), Tol);
if (!TheLength.IsDone()) {
//purpose : 2d with parameters and tolerance
//=======================================================================
-Standard_Real CPnts_AbscissaPoint::Length(const Adaptor2d_Curve2d& C,
+Standard_Real CPnts_AbscissaPoint::Length(const Handle(Adaptor2d_Curve2d)& C,
const Standard_Real U1,
const Standard_Real U2,
const Standard_Real Tol)
CPnts_MyGaussFunction FG;
//POP pout WNT
CPnts_RealFunction rf = f2d;
- FG.Init(rf,(Standard_Address)&C);
+ FG.Init(rf, C.operator->());
// FG.Init(f2d,(Standard_Address)&C);
math_GaussSingleIntegration TheLength(FG, U1, U2, order(C), Tol);
if (!TheLength.IsDone()) {
//purpose :
//=======================================================================
-CPnts_AbscissaPoint::CPnts_AbscissaPoint(const Adaptor3d_Curve& C,
+CPnts_AbscissaPoint::CPnts_AbscissaPoint(const Handle(Adaptor3d_Curve)& C,
const Standard_Real Abscissa,
const Standard_Real U0,
const Standard_Real Resolution)
//purpose :
//=======================================================================
-CPnts_AbscissaPoint::CPnts_AbscissaPoint(const Adaptor2d_Curve2d& C,
+CPnts_AbscissaPoint::CPnts_AbscissaPoint(const Handle(Adaptor2d_Curve2d)& C,
const Standard_Real Abscissa,
const Standard_Real U0,
const Standard_Real Resolution)
//purpose :
//=======================================================================
-CPnts_AbscissaPoint::CPnts_AbscissaPoint(const Adaptor3d_Curve& C,
+CPnts_AbscissaPoint::CPnts_AbscissaPoint(const Handle(Adaptor3d_Curve)& C,
const Standard_Real Abscissa,
const Standard_Real U0,
const Standard_Real Ui,
//purpose :
//=======================================================================
-CPnts_AbscissaPoint::CPnts_AbscissaPoint(const Adaptor2d_Curve2d& C,
+CPnts_AbscissaPoint::CPnts_AbscissaPoint(const Handle(Adaptor2d_Curve2d)& C,
const Standard_Real Abscissa,
const Standard_Real U0,
const Standard_Real Ui,
//purpose :
//=======================================================================
-void CPnts_AbscissaPoint::Init(const Adaptor3d_Curve& C)
+void CPnts_AbscissaPoint::Init(const Handle(Adaptor3d_Curve)& C)
{
- Init(C,C.FirstParameter(),C.LastParameter());
+ Init(C, C->FirstParameter(), C->LastParameter());
}
//=======================================================================
//purpose :
//=======================================================================
-void CPnts_AbscissaPoint::Init(const Adaptor2d_Curve2d& C)
+void CPnts_AbscissaPoint::Init(const Handle(Adaptor2d_Curve2d)& C)
{
- Init(C,C.FirstParameter(),C.LastParameter());
+ Init(C, C->FirstParameter(), C->LastParameter());
}
//=======================================================================
//purpose : introduced by rbv for curvilinear parametrization
//=======================================================================
-void CPnts_AbscissaPoint::Init(const Adaptor3d_Curve& C, const Standard_Real Tol)
+void CPnts_AbscissaPoint::Init(const Handle(Adaptor3d_Curve)& C, const Standard_Real Tol)
{
- Init(C,C.FirstParameter(),C.LastParameter(), Tol);
+ Init(C, C->FirstParameter(), C->LastParameter(), Tol);
}
//=======================================================================
//purpose :
//=======================================================================
-void CPnts_AbscissaPoint::Init(const Adaptor2d_Curve2d& C, const Standard_Real Tol)
+void CPnts_AbscissaPoint::Init(const Handle(Adaptor2d_Curve2d)& C, const Standard_Real Tol)
{
- Init(C,C.FirstParameter(),C.LastParameter(), Tol);
+ Init(C, C->FirstParameter(), C->LastParameter(), Tol);
}
//=======================================================================
//purpose :
//=======================================================================
-void CPnts_AbscissaPoint::Init(const Adaptor3d_Curve& C,
+void CPnts_AbscissaPoint::Init(const Handle(Adaptor3d_Curve)& C,
const Standard_Real U1,
const Standard_Real U2)
{
//POP pout WNT
CPnts_RealFunction rf = f3d;
- myF.Init(rf,(Standard_Address)&C,order(C));
+ myF.Init(rf, C.operator->(), order(C));
// myF.Init(f3d,(Standard_Address)&C,order(C));
myL = CPnts_AbscissaPoint::Length(C, U1, U2);
myUMin = Min(U1, U2);
//purpose :
//=======================================================================
-void CPnts_AbscissaPoint::Init(const Adaptor2d_Curve2d& C,
+void CPnts_AbscissaPoint::Init(const Handle(Adaptor2d_Curve2d)& C,
const Standard_Real U1,
const Standard_Real U2)
{
//POP pout WNT
CPnts_RealFunction rf = f2d;
- myF.Init(rf,(Standard_Address)&C,order(C));
+ myF.Init(rf, C.operator->(), order(C));
// myF.Init(f2d,(Standard_Address)&C,order(C));
myL = CPnts_AbscissaPoint::Length(C, U1, U2);
myUMin = Min(U1, U2);
//purpose : introduced by rbv for curvilinear parametrization
//=======================================================================
-void CPnts_AbscissaPoint::Init(const Adaptor3d_Curve& C,
+void CPnts_AbscissaPoint::Init(const Handle(Adaptor3d_Curve)& C,
const Standard_Real U1,
const Standard_Real U2,
const Standard_Real Tol)
{
//POP pout WNT
CPnts_RealFunction rf = f3d;
- myF.Init(rf,(Standard_Address)&C,order(C));
+ myF.Init(rf, C.operator->(), order(C));
// myF.Init(f3d,(Standard_Address)&C,order(C));
myL = CPnts_AbscissaPoint::Length(C, U1, U2, Tol);
myUMin = Min(U1, U2);
//purpose :
//=======================================================================
-void CPnts_AbscissaPoint::Init(const Adaptor2d_Curve2d& C,
+void CPnts_AbscissaPoint::Init(const Handle(Adaptor2d_Curve2d)& C,
const Standard_Real U1,
const Standard_Real U2,
const Standard_Real Tol)
{
//POP pout WNT
CPnts_RealFunction rf = f2d;
- myF.Init(rf,(Standard_Address)&C,order(C));
+ myF.Init(rf, C.operator->(), order(C));
// myF.Init(f2d,(Standard_Address)&C,order(C));
myL = CPnts_AbscissaPoint::Length(C, U1, U2, Tol);
myUMin = Min(U1, U2);
//! Computes the length of the Curve <C>.
- Standard_EXPORT static Standard_Real Length (const Adaptor3d_Curve& C);
+ Standard_EXPORT static Standard_Real Length (const Handle(Adaptor3d_Curve)& C);
//! Computes the length of the Curve <C>.
- Standard_EXPORT static Standard_Real Length (const Adaptor2d_Curve2d& C);
+ Standard_EXPORT static Standard_Real Length (const Handle(Adaptor2d_Curve2d)& C);
//! Computes the length of the Curve <C> with the given tolerance.
- Standard_EXPORT static Standard_Real Length (const Adaptor3d_Curve& C, const Standard_Real Tol);
+ Standard_EXPORT static Standard_Real Length (const Handle(Adaptor3d_Curve)& C, const Standard_Real Tol);
//! Computes the length of the Curve <C> with the given tolerance.
- Standard_EXPORT static Standard_Real Length (const Adaptor2d_Curve2d& C, const Standard_Real Tol);
+ Standard_EXPORT static Standard_Real Length (const Handle(Adaptor2d_Curve2d)& C, const Standard_Real Tol);
//! Computes the length of the Curve <C> between <U1> and <U2>.
- Standard_EXPORT static Standard_Real Length (const Adaptor3d_Curve& C, const Standard_Real U1, const Standard_Real U2);
+ Standard_EXPORT static Standard_Real Length (const Handle(Adaptor3d_Curve)& C, const Standard_Real U1, const Standard_Real U2);
//! Computes the length of the Curve <C> between <U1> and <U2>.
- Standard_EXPORT static Standard_Real Length (const Adaptor2d_Curve2d& C, const Standard_Real U1, const Standard_Real U2);
+ Standard_EXPORT static Standard_Real Length (const Handle(Adaptor2d_Curve2d)& C, const Standard_Real U1, const Standard_Real U2);
//! Computes the length of the Curve <C> between <U1> and <U2> with the given tolerance.
- Standard_EXPORT static Standard_Real Length (const Adaptor3d_Curve& C, const Standard_Real U1, const Standard_Real U2, const Standard_Real Tol);
+ Standard_EXPORT static Standard_Real Length (const Handle(Adaptor3d_Curve)& C, const Standard_Real U1, const Standard_Real U2, const Standard_Real Tol);
//! Computes the length of the Curve <C> between <U1> and <U2> with the given tolerance.
//! creation of a indefinite AbscissaPoint.
- Standard_EXPORT static Standard_Real Length (const Adaptor2d_Curve2d& C, const Standard_Real U1, const Standard_Real U2, const Standard_Real Tol);
+ Standard_EXPORT static Standard_Real Length (const Handle(Adaptor2d_Curve2d)& C, const Standard_Real U1, const Standard_Real U2, const Standard_Real Tol);
Standard_EXPORT CPnts_AbscissaPoint();
//! distance <Abscissa> from the point of parameter <U0>.
//! <Resolution> is the error allowed in the computation.
//! The computed point can be outside of the curve 's bounds.
- Standard_EXPORT CPnts_AbscissaPoint(const Adaptor3d_Curve& C, const Standard_Real Abscissa, const Standard_Real U0, const Standard_Real Resolution);
+ Standard_EXPORT CPnts_AbscissaPoint(const Handle(Adaptor3d_Curve)& C, const Standard_Real Abscissa, const Standard_Real U0, const Standard_Real Resolution);
//! the algorithm computes a point on a curve <Curve> at the
//! distance <Abscissa> from the point of parameter <U0>.
//! <Resolution> is the error allowed in the computation.
//! The computed point can be outside of the curve 's bounds.
- Standard_EXPORT CPnts_AbscissaPoint(const Adaptor2d_Curve2d& C, const Standard_Real Abscissa, const Standard_Real U0, const Standard_Real Resolution);
+ Standard_EXPORT CPnts_AbscissaPoint(const Handle(Adaptor2d_Curve2d)& C, const Standard_Real Abscissa, const Standard_Real U0, const Standard_Real Resolution);
//! the algorithm computes a point on a curve <Curve> at the
//! distance <Abscissa> from the point of parameter <U0>.
//! solution
//! <Resolution> is the error allowed in the computation.
//! The computed point can be outside of the curve 's bounds.
- Standard_EXPORT CPnts_AbscissaPoint(const Adaptor3d_Curve& C, const Standard_Real Abscissa, const Standard_Real U0, const Standard_Real Ui, const Standard_Real Resolution);
+ Standard_EXPORT CPnts_AbscissaPoint(const Handle(Adaptor3d_Curve)& C, const Standard_Real Abscissa, const Standard_Real U0, const Standard_Real Ui, const Standard_Real Resolution);
//! the algorithm computes a point on a curve <Curve> at the
//! distance <Abscissa> from the point of parameter <U0>.
//! solution
//! <Resolution> is the error allowed in the computation.
//! The computed point can be outside of the curve 's bounds.
- Standard_EXPORT CPnts_AbscissaPoint(const Adaptor2d_Curve2d& C, const Standard_Real Abscissa, const Standard_Real U0, const Standard_Real Ui, const Standard_Real Resolution);
+ Standard_EXPORT CPnts_AbscissaPoint(const Handle(Adaptor2d_Curve2d)& C, const Standard_Real Abscissa, const Standard_Real U0, const Standard_Real Ui, const Standard_Real Resolution);
//! Initializes the resolution function with <C>.
- Standard_EXPORT void Init (const Adaptor3d_Curve& C);
+ Standard_EXPORT void Init (const Handle(Adaptor3d_Curve)& C);
//! Initializes the resolution function with <C>.
- Standard_EXPORT void Init (const Adaptor2d_Curve2d& C);
+ Standard_EXPORT void Init (const Handle(Adaptor2d_Curve2d)& C);
//! Initializes the resolution function with <C>.
- Standard_EXPORT void Init (const Adaptor3d_Curve& C, const Standard_Real Tol);
+ Standard_EXPORT void Init (const Handle(Adaptor3d_Curve)& C, const Standard_Real Tol);
//! Initializes the resolution function with <C>.
- Standard_EXPORT void Init (const Adaptor2d_Curve2d& C, const Standard_Real Tol);
+ Standard_EXPORT void Init (const Handle(Adaptor2d_Curve2d)& C, const Standard_Real Tol);
//! Initializes the resolution function with <C>
//! between U1 and U2.
- Standard_EXPORT void Init (const Adaptor3d_Curve& C, const Standard_Real U1, const Standard_Real U2);
+ Standard_EXPORT void Init (const Handle(Adaptor3d_Curve)& C, const Standard_Real U1, const Standard_Real U2);
//! Initializes the resolution function with <C>
//! between U1 and U2.
- Standard_EXPORT void Init (const Adaptor2d_Curve2d& C, const Standard_Real U1, const Standard_Real U2);
+ Standard_EXPORT void Init (const Handle(Adaptor2d_Curve2d)& C, const Standard_Real U1, const Standard_Real U2);
//! Initializes the resolution function with <C>
//! between U1 and U2.
- Standard_EXPORT void Init (const Adaptor3d_Curve& C, const Standard_Real U1, const Standard_Real U2, const Standard_Real Tol);
+ Standard_EXPORT void Init (const Handle(Adaptor3d_Curve)& C, const Standard_Real U1, const Standard_Real U2, const Standard_Real Tol);
//! Initializes the resolution function with <C>
//! between U1 and U2.
- Standard_EXPORT void Init (const Adaptor2d_Curve2d& C, const Standard_Real U1, const Standard_Real U2, const Standard_Real Tol);
+ Standard_EXPORT void Init (const Handle(Adaptor2d_Curve2d)& C, const Standard_Real U1, const Standard_Real U2, const Standard_Real Tol);
//! Computes the point at the distance <Abscissa> of
//! the curve.
//=======================================================================
CPnts_UniformDeflection::CPnts_UniformDeflection
- (const Adaptor3d_Curve& C,
+ (const Handle(Adaptor3d_Curve)& C,
const Standard_Real Deflection,
const Standard_Real Resolution,
const Standard_Boolean WithControl)
//=======================================================================
CPnts_UniformDeflection::CPnts_UniformDeflection
- (const Adaptor2d_Curve2d& C,
+ (const Handle(Adaptor2d_Curve2d)& C,
const Standard_Real Deflection,
const Standard_Real Resolution,
const Standard_Boolean WithControl)
//purpose :
//=======================================================================
-void CPnts_UniformDeflection::Initialize(const Adaptor3d_Curve& C,
+void CPnts_UniformDeflection::Initialize(const Handle(Adaptor3d_Curve)& C,
const Standard_Real Deflection,
const Standard_Real Resolution,
const Standard_Boolean WithControl)
{
- Initialize(C,Deflection,C.FirstParameter(),C.LastParameter(),
+ Initialize(C,Deflection,C->FirstParameter(),C->LastParameter(),
Resolution,WithControl);
}
//purpose :
//=======================================================================
-void CPnts_UniformDeflection::Initialize(const Adaptor2d_Curve2d& C,
+void CPnts_UniformDeflection::Initialize(const Handle(Adaptor2d_Curve2d)& C,
const Standard_Real Deflection,
const Standard_Real Resolution,
const Standard_Boolean WithControl)
{
- Initialize(C,Deflection,C.FirstParameter(),C.LastParameter(),
+ Initialize(C,Deflection,C->FirstParameter(),C->LastParameter(),
Resolution,WithControl);
}
//=======================================================================
CPnts_UniformDeflection ::CPnts_UniformDeflection
- (const Adaptor3d_Curve& C,
+ (const Handle(Adaptor3d_Curve)& C,
const Standard_Real Deflection,
const Standard_Real U1,
const Standard_Real U2,
//=======================================================================
CPnts_UniformDeflection ::CPnts_UniformDeflection
- (const Adaptor2d_Curve2d& C,
+ (const Handle(Adaptor2d_Curve2d)& C,
const Standard_Real Deflection,
const Standard_Real U1,
const Standard_Real U2,
//purpose :
//=======================================================================
-void CPnts_UniformDeflection::Initialize (const Adaptor3d_Curve& C,
+void CPnts_UniformDeflection::Initialize (const Handle(Adaptor3d_Curve)& C,
const Standard_Real Deflection,
const Standard_Real U1,
const Standard_Real U2,
myDwmax = myLastParam-myFirstParam;
myDu = myDwmax/2. ;
myDone = Standard_True;
- myCurve = (Standard_Address) &C;
+ myCurve = (Standard_Address) (C.get());
myFinish = Standard_False;
myTolCur = Resolution;
myDeflection = Deflection;
//purpose :
//=======================================================================
-void CPnts_UniformDeflection::Initialize (const Adaptor2d_Curve2d& C,
+void CPnts_UniformDeflection::Initialize (const Handle(Adaptor2d_Curve2d)& C,
const Standard_Real Deflection,
const Standard_Real U1,
const Standard_Real U2,
myDwmax = myLastParam-myFirstParam;
myDu = myDwmax/2. ;
myDone = Standard_True;
- myCurve = (Standard_Address) &C;
+ myCurve = (Standard_Address) (C.get());
myFinish = Standard_False;
myTolCur = Resolution;
myDeflection = Deflection;
//! P(u + Max(CurrentStep,Abs(LastParameter-FirstParameter)))
//! if the singularity is at the first point ,the next point
//! calculated is the P(LastParameter)
- Standard_EXPORT CPnts_UniformDeflection(const Adaptor3d_Curve& C, const Standard_Real Deflection, const Standard_Real Resolution, const Standard_Boolean WithControl);
+ Standard_EXPORT CPnts_UniformDeflection(const Handle(Adaptor3d_Curve)& C, const Standard_Real Deflection, const Standard_Real Resolution, const Standard_Boolean WithControl);
//! As above with 2d curve
- Standard_EXPORT CPnts_UniformDeflection(const Adaptor2d_Curve2d& C, const Standard_Real Deflection, const Standard_Real Resolution, const Standard_Boolean WithControl);
+ Standard_EXPORT CPnts_UniformDeflection(const Handle(Adaptor2d_Curve2d)& C, const Standard_Real Deflection, const Standard_Real Resolution, const Standard_Boolean WithControl);
//! Computes an uniform deflection distribution of points on a part of
//! the curve <C>. Deflection defines the step between the points.
//! <U1> and <U2> define the distribution span.
//! <U1> and <U2> must be in the parametric range of the curve.
- Standard_EXPORT CPnts_UniformDeflection(const Adaptor3d_Curve& C, const Standard_Real Deflection, const Standard_Real U1, const Standard_Real U2, const Standard_Real Resolution, const Standard_Boolean WithControl);
+ Standard_EXPORT CPnts_UniformDeflection(const Handle(Adaptor3d_Curve)& C, const Standard_Real Deflection, const Standard_Real U1, const Standard_Real U2, const Standard_Real Resolution, const Standard_Boolean WithControl);
//! As above with 2d curve
- Standard_EXPORT CPnts_UniformDeflection(const Adaptor2d_Curve2d& C, const Standard_Real Deflection, const Standard_Real U1, const Standard_Real U2, const Standard_Real Resolution, const Standard_Boolean WithControl);
+ Standard_EXPORT CPnts_UniformDeflection(const Handle(Adaptor2d_Curve2d)& C, const Standard_Real Deflection, const Standard_Real U1, const Standard_Real U2, const Standard_Real Resolution, const Standard_Boolean WithControl);
//! Initialize the algorithms with <C>, <Deflection>, <UStep>,
//! <Resolution> and <WithControl>
- Standard_EXPORT void Initialize (const Adaptor3d_Curve& C, const Standard_Real Deflection, const Standard_Real Resolution, const Standard_Boolean WithControl);
+ Standard_EXPORT void Initialize (const Handle(Adaptor3d_Curve)& C, const Standard_Real Deflection, const Standard_Real Resolution, const Standard_Boolean WithControl);
//! Initialize the algorithms with <C>, <Deflection>, <UStep>,
//! <Resolution> and <WithControl>
- Standard_EXPORT void Initialize (const Adaptor2d_Curve2d& C, const Standard_Real Deflection, const Standard_Real Resolution, const Standard_Boolean WithControl);
+ Standard_EXPORT void Initialize (const Handle(Adaptor2d_Curve2d)& C, const Standard_Real Deflection, const Standard_Real Resolution, const Standard_Boolean WithControl);
//! Initialize the algorithms with <C>, <Deflection>, <UStep>,
//! <U1>, <U2> and <WithControl>
- Standard_EXPORT void Initialize (const Adaptor3d_Curve& C, const Standard_Real Deflection, const Standard_Real U1, const Standard_Real U2, const Standard_Real Resolution, const Standard_Boolean WithControl);
+ Standard_EXPORT void Initialize (const Handle(Adaptor3d_Curve)& C, const Standard_Real Deflection, const Standard_Real U1, const Standard_Real U2, const Standard_Real Resolution, const Standard_Boolean WithControl);
//! Initialize the algorithms with <C>, <Deflection>, <UStep>,
//! <U1>, <U2> and <WithControl>
- Standard_EXPORT void Initialize (const Adaptor2d_Curve2d& C, const Standard_Real Deflection, const Standard_Real U1, const Standard_Real U2, const Standard_Real Resolution, const Standard_Boolean WithControl);
+ Standard_EXPORT void Initialize (const Handle(Adaptor2d_Curve2d)& C, const Standard_Real Deflection, const Standard_Real U1, const Standard_Real U2, const Standard_Real Resolution, const Standard_Boolean WithControl);
//! To know if all the calculus were done successfully
//! (ie all the points have been computed). The calculus can fail if
#include <ElSLib.hxx>
// Compute the flag: CW || CCW
-static Standard_Boolean isCW(const BRepAdaptor_Curve& AC)
+static Standard_Boolean isCW(const Handle(BRepAdaptor_Curve)& AC)
{
- const Standard_Real f = AC.FirstParameter();
- const Standard_Real l = AC.LastParameter();
- Handle(Geom_Circle) circle = Handle(Geom_Circle)::DownCast(AC.Curve().Curve());
- gp_Pnt start = AC.Value(f);
- gp_Pnt end = AC.Value(l);
- gp_Pnt center = AC.Circle().Location();
- gp_Ax3 plane = AC.Circle().Position();
+ const Standard_Real f = AC->FirstParameter();
+ const Standard_Real l = AC->LastParameter();
+ Handle(Geom_Circle) circle = Handle(Geom_Circle)::DownCast(AC->Curve()->Curve());
+ gp_Pnt start = AC->Value(f);
+ gp_Pnt end = AC->Value(l);
+ gp_Pnt center = AC->Circle().Location();
+ gp_Ax3 plane = AC->Circle().Position();
// Get point on circle at half angle
gp_Pnt m;
throw Standard_TypeMismatch("The algorithm expects a wire consisting of two linear or circular edges.");
// Left neighbour.
- BRepAdaptor_Curve AC1(e1);
- if (AC1.GetType() != GeomAbs_Line && AC1.GetType() != GeomAbs_Circle)
+ Handle(BRepAdaptor_Curve) AC1 = new BRepAdaptor_Curve(e1);
+ if (AC1->GetType() != GeomAbs_Line && AC1->GetType() != GeomAbs_Circle)
throw Standard_TypeMismatch("A segment or an arc of circle is expected.");
TopoDS_Vertex v1, v2;
p2.Coord(x12, y12);
segment1 = true;
- if (AC1.GetType() == GeomAbs_Circle)
+ if (AC1->GetType() == GeomAbs_Circle)
{
segment1 = false;
- gp_Circ c = AC1.Circle();
+ gp_Circ c = AC1->Circle();
gp_Pnt2d loc = ProjLib::Project(thePlane, c.Location());
loc.Coord(xc1, yc1);
}
// Right neighbour.
- BRepAdaptor_Curve AC2(e2);
- if (AC2.GetType() != GeomAbs_Line && AC2.GetType() != GeomAbs_Circle)
+ Handle(BRepAdaptor_Curve) AC2 = new BRepAdaptor_Curve(e2);
+ if (AC2->GetType() != GeomAbs_Line && AC2->GetType() != GeomAbs_Circle)
throw Standard_TypeMismatch("A segment or an arc of circle is expected.");
TopExp::Vertices(e2, v1, v2, Standard_True);
p2.Coord(x22, y22);
segment2 = true;
- if (AC2.GetType() == GeomAbs_Circle)
+ if (AC2->GetType() == GeomAbs_Circle)
{
segment2 = false;
- gp_Circ c = AC2.Circle();
+ gp_Circ c = AC2->Circle();
gp_Pnt2d loc = ProjLib::Project(thePlane, c.Location());
loc.Coord(xc2, yc2);
if (segment1)
{
BRepBuilderAPI_MakeEdge mkSegment1;
- mkSegment1.Init(AC1.Curve().Curve(), p1, p2);
+ mkSegment1.Init(AC1.Curve()->Curve(), p1, p2);
if (mkSegment1.IsDone())
shrinke1 = mkSegment1.Edge();
}
else
{
BRepBuilderAPI_MakeEdge mkCirc1;
- mkCirc1.Init(AC1.Curve().Curve(), p1, p2);
+ mkCirc1.Init(AC1.Curve()->Curve(), p1, p2);
if (mkCirc1.IsDone())
shrinke1 = mkCirc1.Edge();
}
if (segment2)
{
BRepBuilderAPI_MakeEdge mkSegment2;
- mkSegment2.Init(AC2.Curve().Curve(), p1, p2);
+ mkSegment2.Init(AC2.Curve()->Curve(), p1, p2);
if (mkSegment2.IsDone())
shrinke2 = mkSegment2.Edge();
}
else
{
BRepBuilderAPI_MakeEdge mkCirc2;
- mkCirc2.Init(AC2.Curve().Curve(), p1, p2);
+ mkCirc2.Init(AC2.Curve()->Curve(), p1, p2);
if (mkCirc2.IsDone())
shrinke2 = mkCirc2.Edge();
}
} // else ...
Standard_Real Tol = Precision::Confusion();
- Geom2dGcc_Circ2d2TanRad Fillet(Geom2dGcc_QualifiedCurve(basisC1,Qual1),
- Geom2dGcc_QualifiedCurve(basisC2,Qual2),
+ Geom2dGcc_Circ2d2TanRad Fillet(Geom2dGcc_QualifiedCurve(new Geom2dAdaptor_Curve(basisC1),Qual1),
+ Geom2dGcc_QualifiedCurve(new Geom2dAdaptor_Curve(basisC2),Qual2),
Radius, Tol);
if (!Fillet.IsDone() || Fillet.NbSolutions()==0) {
status = ChFi2d_ComputationError;
p = BRep_Tool::Pnt(v2);
}
- GeomAdaptor_Curve cc = c.Curve();
+ Handle(GeomAdaptor_Curve) cc = c.Curve();
if (p.Distance(c.Value(first)) <= Precision::Confusion()) {
GCPnts_AbscissaPoint computePoint(cc, D, first);
Param = computePoint.Parameter();
GCPnts_AbscissaPoint computePoint(cc, D, last);
Param = computePoint.Parameter();
}
- thePoint = cc.Value(Param);
+ thePoint = cc->Value(Param);
return thePoint;
} // else ...
} // ComputePoint
Handle(Geom2d_Curve) c2d;
Standard_Real first, last;
c2d = BRep_Tool::CurveOnSurface(E, F, first, last);
- Geom2dAdaptor_Curve adaptorL(lin2d);
- Geom2dAdaptor_Curve adaptorC(c2d);
+ Handle(Geom2dAdaptor_Curve) adaptorL = new Geom2dAdaptor_Curve(lin2d);
+ Handle(Geom2dAdaptor_Curve) adaptorC = new Geom2dAdaptor_Curve(c2d);
Geom2dInt_GInter Intersection(adaptorL, adaptorC,
Precision::PIntersection(),
Precision::PIntersection());
//purpose : calculate the concave face at the neighborhood of the border of
// 2 faces.
//=======================================================================
-Standard_Integer ChFi3d::ConcaveSide(const BRepAdaptor_Surface& S1,
- const BRepAdaptor_Surface& S2,
+Standard_Integer ChFi3d::ConcaveSide(const Handle(BRepAdaptor_Surface)& S1,
+ const Handle(BRepAdaptor_Surface)& S2,
const TopoDS_Edge& E,
TopAbs_Orientation& Or1,
TopAbs_Orientation& Or2)
Standard_Real par = 0.691254*first + 0.308746*last;
gp_Pnt pt, pt1, pt2; gp_Vec tgE, tgE1, tgE2, ns1, ns2, dint1, dint2;
- TopoDS_Face F1 = S1.Face();
- TopoDS_Face F2 = S2.Face();
+ TopoDS_Face F1 = S1->Face();
+ TopoDS_Face F2 = S2->Face();
//F1.Orientation(TopAbs_FORWARD);
//F2.Orientation(TopAbs_FORWARD);
gp_Vec DU1,DV1,DU2,DV2;
p2d1 = pc1.Value(par);
p2d2 = pc2.Value(par);
- S1.D1(p2d1.X(),p2d1.Y(),pt1,DU1,DV1);
+ S1->D1(p2d1.X(),p2d1.Y(),pt1,DU1,DV1);
ns1 = DU1.Crossed(DV1);
ns1.Normalize();
if (F1.Orientation() == TopAbs_REVERSED)
ns1.Reverse();
- S2.D1(p2d2.X(),p2d2.Y(),pt2,DU2,DV2);
+ S2->D1(p2d2.X(),p2d2.Y(),pt2,DU2,DV2);
ns2 = DU2.Crossed(DV2);
ns2.Normalize();
if (F2.Orientation() == TopAbs_REVERSED)
if(dint1.Dot(dint2) < 0.){
//This is a forgotten regularity
gp_Vec DDU, DDV, DDUV;
- S1.D2(p2d1.X(),p2d1.Y(),pt1,DU1,DV1,DDU,DDV,DDUV);
+ S1->D2(p2d1.X(),p2d1.Y(),pt1,DU1,DV1,DDU,DDV,DDUV);
DU1 += ( DU1 * dint1 < 0) ? -DDU : DDU;
DV1 += ( DV1 * dint1 < 0) ? -DDV : DDV;
ns1 = DU1.Crossed(DV1);
ns1.Normalize();
if (F1.Orientation() == TopAbs_REVERSED)
ns1.Reverse();
- S2.D2(p2d2.X(),p2d2.Y(),pt2,DU2,DV2,DDU,DDV,DDUV);
+ S2->D2(p2d2.X(),p2d2.Y(),pt2,DU2,DV2,DDU,DDV,DDUV);
DU2 += ( DU2 * dint2 < 0) ? -DDU : DDU;
DV2 += ( DV2 * dint2 < 0) ? -DDV : DDV;
ns2 = DU2.Crossed(DV2);
p2d1.SetX(p2d1.X() + u); p2d1.SetY(p2d1.Y() + v);
ChFi3d_Coefficient(dint1,DU2,DV2,u,v);
p2d2.SetX(p2d2.X() + u); p2d2.SetY(p2d2.Y() + v);
- S1.D1(p2d1.X(),p2d1.Y(),pt1,DU1,DV1);
+ S1->D1(p2d1.X(),p2d1.Y(),pt1,DU1,DV1);
ns1 = DU1.Crossed(DV1);
if (F1.Orientation() == TopAbs_REVERSED)
ns1.Reverse();
- S2.D1(p2d2.X(),p2d2.Y(),pt2,DU2,DV2);
+ S2->D1(p2d2.X(),p2d2.Y(),pt2,DU2,DV2);
ns2 = DU2.Crossed(DV2);
if (F2.Orientation() == TopAbs_REVERSED)
ns2.Reverse();
//! if not, it returns the number of choice of the fillet
//! or chamfer corresponding to the orientations calculated
//! and to the tangent to the guide line read in E.
- Standard_EXPORT static Standard_Integer ConcaveSide (const BRepAdaptor_Surface& S1, const BRepAdaptor_Surface& S2, const TopoDS_Edge& E, TopAbs_Orientation& Or1, TopAbs_Orientation& Or2);
+ Standard_EXPORT static Standard_Integer ConcaveSide (const Handle(BRepAdaptor_Surface)& S1, const Handle(BRepAdaptor_Surface)& S2, const TopoDS_Edge& E, TopAbs_Orientation& Or1, TopAbs_Orientation& Or2);
//! Same as ConcaveSide, but the orientations are
//! logically deduced from the result of the call of
i=ChFi3d::ConcaveSide(F[0],F[2],E[1],o11,o12);
j=ChFi3d::ConcaveSide(F[1],F[2],E[2],o21,o22);
*/
- i=ChFi3d::ConcaveSide(F1, F2, E[0], o01, o02);
- i=ChFi3d::ConcaveSide(F3, F4, E[1], o11, o12);
- j=ChFi3d::ConcaveSide(F5, F6, E[2], o21, o22);
+ i=ChFi3d::ConcaveSide(new BRepAdaptor_Surface(F1), new BRepAdaptor_Surface(F2), E[0], o01, o02);
+ i=ChFi3d::ConcaveSide(new BRepAdaptor_Surface(F3), new BRepAdaptor_Surface(F4), E[1], o11, o12);
+ j=ChFi3d::ConcaveSide(new BRepAdaptor_Surface(F5), new BRepAdaptor_Surface(F6), E[2], o21, o22);
if(o01==o11 && o02==o21 && o12==o22) sst = ChFiDS_AllSame;
else if(o12==o22 || i ==10 || j ==10) sst = ChFiDS_OnDiff;
//=======================================================================
Standard_Boolean ChFi3d_KParticular (const Handle(ChFiDS_Spine)& Spine,
const Standard_Integer IE,
- const BRepAdaptor_Surface& S1,
- const BRepAdaptor_Surface& S2)
+ const Handle(BRepAdaptor_Surface)& S1,
+ const Handle(BRepAdaptor_Surface)& S2)
{
Standard_Boolean bRet;
//
GeomAbs_CurveType aCT;
GeomAbs_SurfaceType aST1, aST2;
//
- aST1=S1.GetType();
- aST2=S2.GetType();
+ aST1=S1->GetType();
+ aST2=S2->GetType();
bIsPlane1=(aST1==GeomAbs_Plane);
bIsPlane2=(aST2==GeomAbs_Plane);
if (!(bIsPlane1 || bIsPlane2)) {
return !bRet;
}
//
- const BRepAdaptor_Surface& aS1=(bIsPlane1)? S1 : S2;
- const BRepAdaptor_Surface& aS2=(bIsPlane1)? S2 : S1;
- aST1=aS1.GetType();
- aST2=aS2.GetType();
+ const Handle(BRepAdaptor_Surface)& aS1=(bIsPlane1)? S1 : S2;
+ const Handle(BRepAdaptor_Surface)& aS2=(bIsPlane1)? S2 : S1;
+ aST1=aS1->GetType();
+ aST2=aS2->GetType();
//
if (!(aST2==GeomAbs_Plane || aST2==GeomAbs_Cylinder || aST2==GeomAbs_Cone)) {
return !bRet;
}
//
- const BRepAdaptor_Curve& bc = Spine->CurrentElementarySpine(IE);
- aCT = bc.GetType();
+ const Handle(BRepAdaptor_Curve)& bc = Spine->CurrentElementarySpine(IE);
+ aCT = bc->GetType();
if (!(aCT==GeomAbs_Line || aCT==GeomAbs_Circle)) {
return !bRet;
}
}
}
else if (aST2==GeomAbs_Cylinder) {
- const gp_Dir aD1=aS1.Plane().Axis().Direction();
- const gp_Dir aD2=aS2.Cylinder().Axis().Direction();
+ const gp_Dir aD1=aS1->Plane().Axis().Direction();
+ const gp_Dir aD2=aS2->Cylinder().Axis().Direction();
//
if (aCT==GeomAbs_Line && aD1.IsNormal(aD2, aPA)) {
return bRet;
}
}
else if(aST2==GeomAbs_Cone) {
- const gp_Dir aD1=aS1.Plane().Axis().Direction();
- const gp_Dir aD2=aS2.Cone().Axis().Direction();
+ const gp_Dir aD1=aS1->Plane().Axis().Direction();
+ const gp_Dir aD2=aS2->Cone().Axis().Direction();
if (aCT == GeomAbs_Circle && aD1.IsParallel(aD2, aPA)) {
return bRet;
}
//purpose : Resize the limits of surface adjacent to the given box
// Useful for intersections with known extremities.
//=======================================================================
-void ChFi3d_BoundFac(BRepAdaptor_Surface& S,
+void ChFi3d_BoundFac(const Handle(BRepAdaptor_Surface)& S,
const Standard_Real uumin,
const Standard_Real uumax,
const Standard_Real vvmin,
const Standard_Real vvmax,
const Standard_Boolean checknaturalbounds)
{
- ChFi3d_BoundSrf(S.ChangeSurface(), uumin,uumax,vvmin,vvmax,checknaturalbounds);
+ ChFi3d_BoundSrf(S->Surface(), uumin,uumax,vvmin,vvmax,checknaturalbounds);
}
//=======================================================================
//function : ChFi3d_BoundSrf
//purpose : Resize the limits of surface adjacent to the given box
// Useful for intersections with known extremities.
//=======================================================================
-void ChFi3d_BoundSrf(GeomAdaptor_Surface& S,
+void ChFi3d_BoundSrf(const Handle(GeomAdaptor_Surface)& S,
const Standard_Real uumin,
const Standard_Real uumax,
const Standard_Real vvmin,
const Standard_Boolean checknaturalbounds)
{
Standard_Real umin = uumin, umax = uumax, vmin = vvmin, vmax = vvmax;
- Handle(Geom_Surface) surface = S.Surface();
+ Handle(Geom_Surface) surface = S->Surface();
Handle(Geom_RectangularTrimmedSurface)
trs = Handle(Geom_RectangularTrimmedSurface)::DownCast(surface);
if(!trs.IsNull()) surface = trs->BasisSurface();
//It is supposed that box uv is not null in at least
//one direction.
- Standard_Real scalu = S.UResolution(1.);
- Standard_Real scalv = S.VResolution(1.);
+ Standard_Real scalu = S->UResolution(1.);
+ Standard_Real scalv = S->VResolution(1.);
Standard_Real step3du = Stepu/scalu;
Standard_Real step3dv = Stepv/scalv;
Standard_Real vv1 = vmin - Stepv;
Standard_Real vv2 = vmax + Stepv;
if(checknaturalbounds) {
- if(!S.IsUPeriodic()) {uu1 = Max(uu1,u1); uu2 = Min(uu2,u2);}
- if(!S.IsVPeriodic()) {vv1 = Max(vv1,v1); vv2 = Min(vv2,v2);}
+ if(!S->IsUPeriodic()) {uu1 = Max(uu1,u1); uu2 = Min(uu2,u2);}
+ if(!S->IsVPeriodic()) {vv1 = Max(vv1,v1); vv2 = Min(vv2,v2);}
}
- S.Load(surface,uu1,uu2,vv1,vv2);
+ S->Load(surface,uu1,uu2,vv1,vv2);
}
//=======================================================================
//function : ChFi3d_InterPlaneEdge
const Standard_Boolean Check2dDistance,
const Standard_Boolean enlarge)
{
- Geom2dAdaptor_Curve C1;
- Geom2dAdaptor_Curve C2;
+ Handle(Geom2dAdaptor_Curve) C1 = new Geom2dAdaptor_Curve();
+ Handle(Geom2dAdaptor_Curve) C2 = new Geom2dAdaptor_Curve();
// pcurves are enlarged to be sure that there is intersection
// additionally all periodic curves are taken and points on
// them are filtered using a specific criterion.
if(isper1) {
Handle(Geom2d_TrimmedCurve) tr1 = Handle(Geom2d_TrimmedCurve)::DownCast(pcf1);
if(!tr1.IsNull()) pcf1 = tr1->BasisCurve();
- C1.Load(pcf1);
+ C1->Load(pcf1);
}
- else C1.Load(pcf1,first-delta,last+delta);
+ else C1->Load(pcf1,first-delta,last+delta);
Standard_Real first1 = pcf1->FirstParameter(), last1 = pcf1->LastParameter();
first = fd2->Interference(jf2).FirstParameter();
if(isper2) {
Handle(Geom2d_TrimmedCurve) tr2 = Handle(Geom2d_TrimmedCurve)::DownCast(pcf2);
if(!tr2.IsNull()) pcf2 = tr2->BasisCurve();
- C2.Load(pcf2);
+ C2->Load(pcf2);
}
- else C2.Load(fd2->Interference(jf2).PCurveOnFace(),first-delta,last+delta);
+ else C2->Load(fd2->Interference(jf2).PCurveOnFace(),first-delta,last+delta);
Standard_Real first2 = pcf2->FirstParameter(), last2 = pcf2->LastParameter();
IntRes2d_IntersectionPoint int2d;
const Standard_Boolean isfreeboundary)
{
Handle(Geom2dAdaptor_Curve) HC = new Geom2dAdaptor_Curve(curv);
- Adaptor3d_CurveOnSurface COnS(HC,HS);
+ Handle(Adaptor3d_CurveOnSurface) COnS = new Adaptor3d_CurveOnSurface(HC,HS);
if (isfreeboundary) {
- Handle(Adaptor3d_CurveOnSurface) HCOnS = new Adaptor3d_CurveOnSurface(COnS);
- return new GeomFill_SimpleBound(HCOnS,t3d,ta);
+ return new GeomFill_SimpleBound(COnS,t3d,ta);
}
return new GeomFill_BoundWithSurf(COnS,t3d,ta);
}
GeomAdaptor_Surface AS(Surf);
Handle(GeomAdaptor_Surface) AHS =
new GeomAdaptor_Surface(AS);
- Adaptor3d_CurveOnSurface Cs(AHC,AHS);
- Pardeb = Cs.FirstParameter();
- Parfin = Cs.LastParameter();
+ Handle(Adaptor3d_CurveOnSurface) Cs = new Adaptor3d_CurveOnSurface(AHC,AHS);
+ Pardeb = Cs->FirstParameter();
+ Parfin = Cs->LastParameter();
Standard_Real avtol;
GeomLib::BuildCurve3d(tol3d,Cs,Pardeb,Parfin,C3d,tolreached,avtol);
}
// Do not waste time on degenerates
continue;
// Examine for intersections
- Geom2dAdaptor_Curve aPCurve1 (aFI1.PCurveOnFace(),
+ Handle(Geom2dAdaptor_Curve) aPCurve1 = new Geom2dAdaptor_Curve(aFI1.PCurveOnFace(),
aFI1.FirstParameter(),
aFI1.LastParameter());
- Geom2dAdaptor_Curve aPCurve2 (aFI2.PCurveOnFace(),
+ Handle(Geom2dAdaptor_Curve) aPCurve2 = new Geom2dAdaptor_Curve(aFI2.PCurveOnFace(),
aFI2.FirstParameter(),
aFI2.LastParameter());
anIntersector.Perform (aPCurve1,
Handle(BRepAdaptor_Surface) hbs = Handle(BRepAdaptor_Surface)::DownCast(HS);
Handle(GeomAdaptor_Surface) hgs = Handle(GeomAdaptor_Surface)::DownCast(HS);
if(!hbs.IsNull()) {
- res = hbs->Surface().Surface();
+ res = hbs->Surface()->Surface();
gp_Trsf trsf = hbs->Trsf();
res = Handle(Geom_Surface)::DownCast(res->Transformed(trsf));
}
Min(0.1,0.05*(Fi1.LastParameter() - Fi1.FirstParameter()));
Handle(Geom2dAdaptor_Curve) hc2d1 =
new Geom2dAdaptor_Curve(Fi1.PCurveOnSurf(),UInt1-delt1,UInt1+delt1);
- Adaptor3d_CurveOnSurface cons1(hc2d1,HS1);
+ Handle(Adaptor3d_CurveOnSurface) cons1 = new Adaptor3d_CurveOnSurface(hc2d1,HS1);
Standard_Real delt2 =
Min(0.1,0.05*(Fi2.LastParameter() - Fi2.FirstParameter()));
Handle(Geom2dAdaptor_Curve) hc2d2 =
new Geom2dAdaptor_Curve(Fi2.PCurveOnSurf(),UInt2-delt2,UInt2+delt2);
- Adaptor3d_CurveOnSurface cons2(hc2d2,HS2);
+ Handle(Adaptor3d_CurveOnSurface) cons2 = new Adaptor3d_CurveOnSurface(hc2d2,HS2);
Extrema_LocateExtCC ext(cons1,cons2,UInt1,UInt2);
if(ext.IsDone()) {
Standard_Real dist2 = ext.SquareDistance();
cepadur = 0;
E = (IsOffset)? Spine->OffsetEdges(IF) : Spine->Edges(IF);
Bof = BRepLib::BuildCurve3d(E);
- const BRepAdaptor_Curve& edc = Spine->CurrentElementarySpine(IF);
- tolpared = edc.Resolution(tol);
+ const Handle(BRepAdaptor_Curve)& edc = Spine->CurrentElementarySpine(IF);
+ tolpared = edc->Resolution(tol);
Cv = BRep_Tool::Curve(E, First, Last);
//Add vertex with tangent
if (ES.IsPeriodic())
// Traitement des Extremites
Standard_Integer caredeb, carefin;
Standard_Real LocalWL, LocalWF, Angle;
- GeomAdaptor_Curve gacurve;
+ Handle(GeomAdaptor_Curve) gacurve = new GeomAdaptor_Curve();
Handle(Geom_BSplineCurve) newc;
//
caredeb = 0;
Handle(Geom_BoundedCurve) anExtCurve = BSpline;
GeomLib::ExtendCurveToPoint (anExtCurve, Bout, icont, Standard_False);
newc = Handle(Geom_BSplineCurve)::DownCast (anExtCurve);
- gacurve.Load(newc);
+ gacurve->Load(newc);
GCPnts_AbscissaPoint GCP(gacurve,-rabdist,Wrefdeb,WF);
if(GCP.IsDone()) {
WF = GCP.Parameter();
Handle(Geom_BoundedCurve) anExtCurve = BSpline;
GeomLib::ExtendCurveToPoint (anExtCurve, Bout, icont, Standard_True);
newc = Handle(Geom_BSplineCurve)::DownCast (anExtCurve);
- gacurve.Load(newc);
+ gacurve->Load(newc);
GCPnts_AbscissaPoint GCP(gacurve,rabdist,Wreffin,WL);
if(GCP.IsDone()) {
WL = GCP.Parameter();
Standard_Boolean ChFi3d_KParticular
(const Handle(ChFiDS_Spine)& Spine,
const Standard_Integer IE,
- const BRepAdaptor_Surface& S1,
- const BRepAdaptor_Surface& S2);
+ const Handle(BRepAdaptor_Surface)& S1,
+ const Handle(BRepAdaptor_Surface)& S2);
-void ChFi3d_BoundFac(BRepAdaptor_Surface& S,
+void ChFi3d_BoundFac(const Handle(BRepAdaptor_Surface)& S,
const Standard_Real umin,
const Standard_Real umax,
const Standard_Real vmin,
const Standard_Real vmax,
const Standard_Boolean checknaturalbounds = Standard_True);
-void ChFi3d_BoundSrf(GeomAdaptor_Surface& S,
+void ChFi3d_BoundSrf(const Handle(GeomAdaptor_Surface)& S,
const Standard_Real umin,
const Standard_Real umax,
const Standard_Real vmin,
static TopoDS_Edge MakeOffsetEdge(const TopoDS_Edge& theEdge,
const Standard_Real Distance,
- const BRepAdaptor_Surface& S1,
- const BRepAdaptor_Surface& S2)
+ const Handle(BRepAdaptor_Surface)& S1,
+ const Handle(BRepAdaptor_Surface)& S2)
{
TopoDS_Edge OffsetEdge;
- TopoDS_Face F1 = S1.Face();
- TopoDS_Face F2 = S2.Face();
+ TopoDS_Face F1 = S1->Face();
+ TopoDS_Face F2 = S2->Face();
Handle(Geom_Surface) GS1 = BRep_Tool::Surface(F1);
Handle(Geom_Surface) TrGS1 =
new Geom_RectangularTrimmedSurface(GS1,
- S1.FirstUParameter(), S1.LastUParameter(),
- S1.FirstVParameter(), S1.LastVParameter());
+ S1->FirstUParameter(), S1->LastUParameter(),
+ S1->FirstVParameter(), S1->LastVParameter());
Standard_Real Offset = -Distance;
if (F1.Orientation() == TopAbs_REVERSED)
Offset = Distance;
Handle(Geom_Surface) GS2 = BRep_Tool::Surface(F2);
Handle(Geom_Surface) TrGS2 =
new Geom_RectangularTrimmedSurface(GS2,
- S2.FirstUParameter(), S2.LastUParameter(),
- S2.FirstVParameter(), S2.LastVParameter());
+ S2->FirstUParameter(), S2->LastUParameter(),
+ S2->FirstVParameter(), S2->LastVParameter());
GeomInt_IntSS Intersector(OffsetTrGS1, TrGS2, Precision::Confusion());
if (!Intersector.IsDone() || Intersector.NbLines() == 0)
{
Standard_Integer imin = 1;
for (Standard_Integer i = 1; i <= NewCurves.Length(); i++)
{
- GeomAdaptor_Curve GAcurve(NewCurves(i));
+ Handle(GeomAdaptor_Curve) GAcurve = new GeomAdaptor_Curve(NewCurves(i));
Extrema_ExtPC Projector(Ends[0], GAcurve);
if (!Projector.IsDone() || Projector.NbExt() == 0)
continue;
return OffsetEdge;
}
//Projection of extremities onto <IntCurve>
- GeomAdaptor_Curve GAcurve(IntCurve);
+ Handle(GeomAdaptor_Curve) GAcurve = new GeomAdaptor_Curve(IntCurve);
Standard_Real Params [2];
for (Standard_Integer ind_end = 0; ind_end < 2; ind_end++)
{
Extrema_ExtPC Projector(Ends[ind_end], GAcurve);
Standard_Real param[4], dist[4];
gp_Pnt Pnt[4];
- param[1] = GAcurve.FirstParameter();
- param[2] = GAcurve.LastParameter();
+ param[1] = GAcurve->FirstParameter();
+ param[2] = GAcurve->LastParameter();
Projector.TrimmedSquareDistances(dist[1], dist[2], Pnt[1], Pnt[2]);
dist[3] = RealLast();
if (Projector.IsDone() && Projector.NbExt() > 0)
Params[ind_end] = param[imin]; //Projector.Point(imin).Parameter();
}
if (aBAcurve.IsClosed()/*HGuide->IsPeriodic()*//*HGuide->IsClosed()*/)
- Params[1] = GAcurve.LastParameter(); //temporary
+ Params[1] = GAcurve->LastParameter(); //temporary
if (Params[0] > Params[1])
{
Standard_Boolean IsClosed = Standard_False;
gp_Vec n1, n2;// gp_Pnt pt1,pt2;
Handle(Geom2d_Curve) pc1 = BRep_Tool::CurveOnSurface(e1,f1,f,l);
pc1->Value(p1).Coord(u,v);
- BRepLProp_SLProps theProp1 (*hs1, u, v, 1, Eps);
+ BRepLProp_SLProps theProp1 (hs1, u, v, 1, Eps);
if (theProp1.IsNormalDefined()) {
n1.SetXYZ(theProp1.Normal().XYZ());
if (O1 == TopAbs_REVERSED) n1.Reverse();
Handle(Geom2d_Curve) pc2 = BRep_Tool::CurveOnSurface(e2,f2,f,l);
pc2->Value(p2).Coord(u,v);
- BRepLProp_SLProps theProp2 (*hs2, u, v, 1, Eps);
+ BRepLProp_SLProps theProp2 (hs2, u, v, 1, Eps);
if (theProp2.IsNormalDefined()) {
n2.SetXYZ(theProp2.Normal().XYZ());
if(O2 == TopAbs_REVERSED) n2.Reverse();
Spine->SetTypeOfConcavity(TypeOfConcavity);
Standard_Boolean ToRestrict = (Offset > 0)? Standard_True : Standard_False;
- BRepAdaptor_Surface Sb1(ff1, ToRestrict);
- BRepAdaptor_Surface Sb2(ff2, ToRestrict);
+ Handle(BRepAdaptor_Surface) Sb1 = new BRepAdaptor_Surface(ff1, ToRestrict);
+ Handle(BRepAdaptor_Surface) Sb2 = new BRepAdaptor_Surface(ff2, ToRestrict);
if (Offset > 0)
{
TopoDS_Edge OffsetEdge = MakeOffsetEdge(Ec, Offset, Sb1, Sb2);
myEdgeFirstFace.Bind(Ec, CurF1);
if (Offset > 0)
{
- BRepAdaptor_Surface CurSb1(CurF1), CurSb2(CurF2);
+ Handle(BRepAdaptor_Surface) CurSb1 = new BRepAdaptor_Surface(CurF1);
+ Handle(BRepAdaptor_Surface) CurSb2 = new BRepAdaptor_Surface(CurF2);
TopoDS_Edge anOffsetEdge = MakeOffsetEdge(Ec, Offset, CurSb1, CurSb2);
anOffsetEdge.Orientation(Or1);
Spine->SetOffsetEdges(anOffsetEdge);
myEdgeFirstFace.Bind(Ec, CurF1);
if (Offset > 0)
{
- BRepAdaptor_Surface CurSb1(CurF1), CurSb2(CurF2);
+ Handle(BRepAdaptor_Surface) CurSb1 = new BRepAdaptor_Surface(CurF1);
+ Handle(BRepAdaptor_Surface) CurSb2 = new BRepAdaptor_Surface(CurF2);
TopoDS_Edge anOffsetEdge = MakeOffsetEdge(Ec, Offset, CurSb1, CurSb2);
anOffsetEdge.Orientation(Or1);
Spine->PutInFirstOffset(anOffsetEdge);
Handle(GeomAdaptor_Surface) HPlan=new GeomAdaptor_Surface(Plan);
Handle(Geom2d_Curve) C2dint2;
TColStd_Array1OfReal Pdeb(1,4),Pfin(1,4);
- GeomAdaptor_Surface AS(Plan);
+ Handle(GeomAdaptor_Surface) AS = new GeomAdaptor_Surface(Plan);
Extrema_ExtPS ext(P1,AS,1.e-3,1.e-3);
Extrema_ExtPS ext1 (P2,AS,1.e-3,1.e-3);
Standard_Real u1,v1;
static Standard_Boolean Projection(Extrema_ExtPC& PExt,
const gp_Pnt& P,
- const Adaptor3d_Curve& C,
+ const Handle(Adaptor3d_Curve)& C,
Standard_Real& W,
Standard_Real Tol)
{
Standard_Real Dist2, daux2;
- Dist2 = C.Value(W).SquareDistance(P);
+ Dist2 = C->Value(W).SquareDistance(P);
// It is checked if it is not already a solution
if (Dist2 < Tol * Tol)
// On essai une resolution initialise
Extrema_LocateExtPC ext(P,C,W,Tol/10);
if(ext.IsDone()) {
- daux2 = C.Value(ext.Point().Parameter()).SquareDistance(P);
+ daux2 = C->Value(ext.Point().Parameter()).SquareDistance(P);
if (daux2 <Dist2 ) {
W = ext.Point().Parameter();
Dist2 = daux2;
gp_Vec& ded)
{
Standard_Real wtg = CD->InterferenceOnS1().Parameter(isfirst);
- const BRepAdaptor_Curve& bc = Spine->CurrentElementarySpine(iedge);
+ const Handle(BRepAdaptor_Curve)& bc = Spine->CurrentElementarySpine(iedge);
if(Spine->Edges(iedge).Orientation() == TopAbs_FORWARD)
- bc.D1(wtg+bc.FirstParameter(),ped,ded);
+ bc->D1(wtg+bc->FirstParameter(),ped,ded);
else{
- bc.D1(-wtg+bc.LastParameter(),ped,ded);
+ bc->D1(-wtg+bc->LastParameter(),ped,ded);
ded.Reverse();
}
ded.Normalize();
Standard_Integer& ChoixConge) const
{
//TopTools_ListIteratorOfListOfShape It;
- BRepAdaptor_Surface Sb1,Sb2;
+ Handle(BRepAdaptor_Surface) Sb1 = new BRepAdaptor_Surface();
+ Handle(BRepAdaptor_Surface) Sb2 = new BRepAdaptor_Surface();
TopAbs_Orientation Of1,Of2;
TopoDS_Face ff1,ff2;
TopoDS_Edge anEdge = Spine->Edges(1);
{ TopoDS_Face TmpFace = ff1; ff1 = ff2; ff2 = TmpFace; }
Of1 = ff1.Orientation();
ff1.Orientation(TopAbs_FORWARD);
- Sb1.Initialize(ff1);
+ Sb1->Initialize(ff1);
Of2 = ff2.Orientation();
ff2.Orientation(TopAbs_FORWARD);
- Sb2.Initialize(ff2);
+ Sb2->Initialize(ff2);
ChoixConge = ChFi3d::ConcaveSide(Sb1,Sb2,Spine->Edges(1),
Or1,Or2);
Standard_Real& First) const
{
Handle(ChFiDS_Spine)& Spine = Stripe->ChangeSpine();
- ChFiDS_ElSpine& els = *HGuide;
Standard_Integer nbed = Spine->NbEdges();
Standard_Integer nbessaimax = 3*nbed;
if (nbessaimax < 10) nbessaimax = 10;
math_Vector SolDep(1,4);
Handle(Geom2d_Curve) PC;
Extrema_ExtPC PExt;
- PExt.Initialize(els,
+ PExt.Initialize(HGuide,
Spine->FirstParameter(1),
Spine->LastParameter(nbed),
Precision::Confusion());
SolDep(1) = P1.X(); SolDep(2) = P1.Y();
SolDep(3) = P2.X(); SolDep(4) = P2.Y();
- const BRepAdaptor_Curve& Ced = Spine->CurrentElementarySpine(iedge);
- gp_Pnt pnt = Ced.Value(woned);
+ const Handle(BRepAdaptor_Curve)& Ced = Spine->CurrentElementarySpine(iedge);
+ gp_Pnt pnt = Ced->Value(woned);
- if (Projection(PExt, pnt, els, w, tolesp) &&
+ if (Projection(PExt, pnt, HGuide, w, tolesp) &&
PerformFirstSection(Spine,HGuide,Choix,HS1,HS2,
I1,I2,w,SolDep,Pos1,Pos2)) {
P1.SetCoord(SolDep(1),SolDep(2));
I2->Initialize(HSon2);
SolDep(1) = P1.X(); SolDep(2) = P1.Y();
SolDep(3) = P2.X(); SolDep(4) = P2.Y();
- const BRepAdaptor_Curve& Ced = Spine->CurrentElementarySpine(iedge);
- gp_Pnt pnt = Ced.Value(woned);
+ const Handle(BRepAdaptor_Curve)& Ced = Spine->CurrentElementarySpine(iedge);
+ gp_Pnt pnt = Ced->Value(woned);
// Extrema_LocateExtPC ext(pnt,els,w,1.e-8);
// if(ext.IsDone()){
// w = ext.Point().Parameter();
- if (Projection(PExt, pnt, els, w, tolesp)) {
+ if (Projection(PExt, pnt, HGuide, w, tolesp)) {
PerformFirstSection(Spine,HGuide,Choix,HS1,HS2,
I1,I2,w,SolDep,Pos1,Pos2);
gp_Pnt P;
Hc = BRep_Tool::CurveOnSurface
(SD->Vertex(isfirst,ons).Arc(),F,u,v);
Hc->Value(SD->Vertex(isfirst,ons).ParameterOnArc()).Coord(u,v);
- BRepLProp_SLProps theProp (*HS, u, v, 1, 1.e-12);
+ BRepLProp_SLProps theProp (HS, u, v, 1, 1.e-12);
if (theProp.IsNormalDefined()) {
P = theProp.Value();
Handle(Geom_Plane) Pln = new Geom_Plane(P, theProp.Normal());
ConexFaces(Spine,iedge,HS1,HS2);
- if (ChFi3d_KParticular (Spine, iedge, *HS1, *HS2)) {
+ if (ChFi3d_KParticular (Spine, iedge, HS1, HS2)) {
intf = ((iedge == 1) && !Spine->IsPeriodic());
intl = ((iedge == Spine->NbEdges()) && !Spine->IsPeriodic());
Or1 = HS1->Face().Orientation();
Standard_Real distinit = pv.Distance(pelsapp);
std::cout<<"distance psp/papp : "<<distinit<<std::endl;
#endif
- Extrema_LocateExtPC ext(pv,*curhels,wi,1.e-8);
+ Extrema_LocateExtPC ext(pv,curhels,wi,1.e-8);
wv(i) = wi;
if(ext.IsDone()){
wv(i) = ext.Point().Parameter();
//
//=======================================================================
-static void CompParam(Geom2dAdaptor_Curve Carc,
+static void CompParam(const Handle(Geom2dAdaptor_Curve)& Carc,
Handle(Geom2d_Curve) Ctg,
Standard_Real& parc,
Standard_Real& ptg,
Standard_Boolean found = 0;
//(1) It is checked if the provided parameters are good
// if pcurves have the same parameters as the spine.
- gp_Pnt2d point = Carc.Value(prefarc);
+ gp_Pnt2d point = Carc->Value(prefarc);
Standard_Real distini = point.Distance(Ctg->Value(preftg));
if (distini <= Precision::PConfusion()) {
parc = prefarc;
IntRes2d_IntersectionPoint int2d;
Geom2dInt_GInter Intersection;
Standard_Integer nbpt,nbseg;
- Intersection.Perform(Geom2dAdaptor_Curve(Ctg),Carc,
+ Intersection.Perform(new Geom2dAdaptor_Curve(Ctg), Carc,
Precision::PIntersection(),
Precision::PIntersection());
#endif
Standard_Real UFirst,ULast,VFirst,VLast,pppdeb,pppfin;
Surf->Bounds(UFirst,ULast,VFirst,VLast);
- BRepAdaptor_Curve2d brc;
- BRepAdaptor_Curve CArc;
+ Handle(BRepAdaptor_Curve2d) brc = new BRepAdaptor_Curve2d();
+ Handle(BRepAdaptor_Curve) CArc = new BRepAdaptor_Curve();
Handle(BRepAdaptor_Surface)
BS1 = Handle(BRepAdaptor_Surface)::DownCast(S1);
Handle(BRepAdaptor_Surface)
if(Gd1){
TopoDS_Face forwfac = BS1->Face();
forwfac.Orientation(TopAbs_FORWARD);
- brc.Initialize(Data->VertexFirstOnS1().Arc(),forwfac);
+ brc->Initialize(Data->VertexFirstOnS1().Arc(),forwfac);
ChFiDS_CommonPoint& V = Data->ChangeVertexFirstOnS1();
- CArc.Initialize(V.Arc());
+ CArc->Initialize(V.Arc());
CompParam(brc,PCurveOnFace,uarc,utg, V.ParameterOnArc(), V.Parameter());
- tolcheck = CArc.Value(uarc).Distance(V.Point());
+ tolcheck = CArc->Value(uarc).Distance(V.Point());
V.SetArc(tolC1+tolcheck,V.Arc(),uarc,V.TransitionOnArc());
pppdeb = utg;
}
TopoDS_Face forwfac = BS1->Face();
forwfac.Orientation(TopAbs_FORWARD);
ChFiDS_CommonPoint& V = Data->ChangeVertexLastOnS1();
- brc.Initialize(V.Arc(),forwfac);
- CArc.Initialize(V.Arc());
+ brc->Initialize(V.Arc(),forwfac);
+ CArc->Initialize(V.Arc());
CompParam(brc,PCurveOnFace,uarc,utg, V.ParameterOnArc(), V.Parameter());
- tolcheck = CArc.Value(uarc).Distance(V.Point());
+ tolcheck = CArc->Value(uarc).Distance(V.Point());
V.SetArc(tolC1+tolcheck,V.Arc(),uarc,V.TransitionOnArc());
pppfin = utg;
}
if(Gd2){
TopoDS_Face forwfac = BS2->Face();
forwfac.Orientation(TopAbs_FORWARD);
- brc.Initialize(Data->VertexFirstOnS2().Arc(),forwfac);
+ brc->Initialize(Data->VertexFirstOnS2().Arc(),forwfac);
ChFiDS_CommonPoint& V = Data->ChangeVertexFirstOnS2();
- CArc.Initialize(V.Arc());
+ CArc->Initialize(V.Arc());
CompParam(brc,PCurveOnFace,uarc,utg, V.ParameterOnArc(), V.Parameter());
- tolcheck = CArc.Value(uarc).Distance(V.Point());
+ tolcheck = CArc->Value(uarc).Distance(V.Point());
V.SetArc(tolC2+tolcheck,V.Arc(),uarc,V.TransitionOnArc());
pppdeb = utg;
}
if(Gf2){
TopoDS_Face forwfac = BS2->Face();
forwfac.Orientation(TopAbs_FORWARD);
- brc.Initialize(Data->VertexLastOnS2().Arc(),forwfac);
+ brc->Initialize(Data->VertexLastOnS2().Arc(),forwfac);
ChFiDS_CommonPoint& V = Data->ChangeVertexLastOnS2();
- CArc.Initialize(V.Arc());
+ CArc->Initialize(V.Arc());
CompParam(brc,PCurveOnFace,uarc,utg, V.ParameterOnArc(), V.Parameter());
- tolcheck = CArc.Value(uarc).Distance(V.Point());
+ tolcheck = CArc->Value(uarc).Distance(V.Point());
V.SetArc(tolC2+tolcheck,V.Arc(),uarc,V.TransitionOnArc());
pppfin = utg;
}
Standard_Real& wop,
const Standard_Real tol)
{
- Adaptor3d_CurveOnSurface c1(pcfb,fb);
+ Handle(Adaptor3d_CurveOnSurface) c1 = new Adaptor3d_CurveOnSurface(pcfb,fb);
Handle(Geom2d_Curve) pc = fi.PCurveOnSurf();
Handle(Geom2dAdaptor_Curve) hpc = new Geom2dAdaptor_Curve(pc);
- Adaptor3d_CurveOnSurface c2(hpc,surf);
+ Handle(Adaptor3d_CurveOnSurface) c2 = new Adaptor3d_CurveOnSurface(hpc,surf);
Extrema_LocateExtCC ext(c1,c2,pared,wop);
if (ext.IsDone()) {
Standard_Real dist2 = ext.SquareDistance();
const Standard_Boolean isfirst)
{
if (!cp.IsOnArc()) return 0;
- Adaptor3d_CurveOnSurface c1(edonface,face);
+ Handle(Adaptor3d_CurveOnSurface) c1 = new Adaptor3d_CurveOnSurface(edonface,face);
Standard_Real pared = cp.ParameterOnArc();
Standard_Real parltg = fi.Parameter(isfirst);
Handle(Geom2d_Curve) pc = fi.PCurveOnSurf();
f = Max(f-delta,pc->FirstParameter());
l = Min(l+delta,pc->LastParameter());
Handle(Geom2dAdaptor_Curve) hpc = new Geom2dAdaptor_Curve(pc,f,l);
- Adaptor3d_CurveOnSurface c2(hpc,surf);
+ Handle(Adaptor3d_CurveOnSurface) c2 = new Adaptor3d_CurveOnSurface(hpc,surf);
Extrema_LocateExtCC ext(c1,c2,pared,parltg);
if (ext.IsDone()) {
//purpose :
//=======================================================================
-static void ChFi3d_Recale(BRepAdaptor_Surface& Bs,
+static void ChFi3d_Recale(const Handle(BRepAdaptor_Surface)& HBs,
gp_Pnt2d& p1,
gp_Pnt2d& p2,
const Standard_Boolean refon1)
{
- Handle(Geom_Surface) surf = Bs.ChangeSurface().Surface();
+ Handle(Geom_Surface) surf = HBs->Surface()->Surface();
Handle(Geom_RectangularTrimmedSurface)
ts = Handle(Geom_RectangularTrimmedSurface)::DownCast(surf);
if (!ts.IsNull()) surf = ts->BasisSurface();
Handle(BRepAdaptor_Surface) HBs = new BRepAdaptor_Surface();
Handle(BRepAdaptor_Surface) HBad = new BRepAdaptor_Surface();
Handle(BRepAdaptor_Surface) HBop = new BRepAdaptor_Surface();
- BRepAdaptor_Surface& Bs = *HBs;
- BRepAdaptor_Surface& Bad = *HBad;
- BRepAdaptor_Surface& Bop = *HBop;
Handle(Geom_Curve) Cc;
Handle(Geom2d_Curve) Pc,Ps;
Standard_Real Ubid,Vbid;//,mu,Mu,mv,Mv;
tol=BRep_Tool::Tolerance(Fv);
BRE.MakeFace(FFv,Sface,tol);
if (prol) {
- Bs.Initialize(FFv,Standard_False);
+ HBs->Initialize(FFv,Standard_False);
DStr.SetNewSurface(Fv,Sface);
}
- else Bs.Initialize(Fv,Standard_False);
- Bad.Initialize(Fad);
- Bop.Initialize(Fop);
+ else HBs->Initialize(Fv,Standard_False);
+ HBad->Initialize(Fad);
+ HBop->Initialize(Fop);
}
//in case of OnSame it is necessary to modify the CommonPoint
//in the empty and its parameter in the FaceInterference.
PerformIntersectionAtEnd(Index);
return;
}
- Bs.Initialize(Fv);
+ HBs->Initialize(Fv);
Handle(BRepAdaptor_Curve2d) pced = new BRepAdaptor_Curve2d();
pced->Initialize(CV1.Arc(),Fv);
Update(HBs,pced,HGs,Fd->ChangeInterferenceOnS1(),CV1,isfirst);
else {
pfil2 = Fi2.PCurveOnSurf()->Value(Fi2.Parameter(!isfirst));
}
- if (onsame) ChFi3d_Recale(Bs,pfac1,pfac2,(IFadArc == 1));
+ if (onsame) ChFi3d_Recale(HBs,pfac1,pfac2,(IFadArc == 1));
Pardeb(1)= pfil1.X(); Pardeb(2) = pfil1.Y();
Pardeb(3)= pfac1.X(); Pardeb(4) = pfac1.Y();
Standard_Real uu1,uu2,vv1,vv2;
ChFi3d_Boite(pfac1,pfac2,uu1,uu2,vv1,vv2);
- ChFi3d_BoundFac(Bs,uu1,uu2,vv1,vv2);
+ ChFi3d_BoundFac(HBs,uu1,uu2,vv1,vv2);
if (!ChFi3d_ComputeCurves(HGs,HBs,Pardeb,Parfin,Cc,
Ps,
//Standard_Real Ubid,Vbid;
Handle (Geom_Curve) C=BRep_Tool::Curve(edgecouture,Ubid,Vbid);
Handle(Geom_TrimmedCurve) Ctrim=new Geom_TrimmedCurve (C,Ubid,Vbid);
- GeomAdaptor_Curve cur1(Ctrim->BasisCurve());
- GeomAdaptor_Curve cur2(Cc);
+ Handle(GeomAdaptor_Curve) cur1 = new GeomAdaptor_Curve(Ctrim->BasisCurve());
+ Handle(GeomAdaptor_Curve) cur2 = new GeomAdaptor_Curve(Cc);
Extrema_ExtCC extCC (cur1,cur2);
if (extCC.IsDone()&&extCC.NbExt()!=0)
{
// 31/01/02 akm vvv : (OCC119) Prevent the builder from creating
// intersecting fillets - they are bad.
Geom2dInt_GInter anIntersector;
- Geom2dAdaptor_Curve aCorkPCurve (Pc, Udeb, Ufin);
+ Handle(Geom2dAdaptor_Curve) aCorkPCurve = new Geom2dAdaptor_Curve(Pc, Udeb, Ufin);
// Take all the interferences with faces from all the stripes
// and look if their pcurves intersect our cork pcurve.
for (iPart=1; iPart<=aSeqData->Length(); iPart++)
{
Handle(ChFiDS_SurfData) aData = aSeqData->Value(iPart);
- Geom2dAdaptor_Curve anOtherPCurve;
+ Handle(Geom2dAdaptor_Curve) anOtherPCurve = new Geom2dAdaptor_Curve();
if (IShape == aData->IndexOfS1())
{
const Handle(Geom2d_Curve)& aPCurve = aData->InterferenceOnS1().PCurveOnFace();
if(aPCurve.IsNull())
continue;
- anOtherPCurve.Load (aPCurve,
+ anOtherPCurve->Load (aPCurve,
aData->InterferenceOnS1().FirstParameter(),
aData->InterferenceOnS1().LastParameter());
}
if(aPCurve.IsNull())
continue;
- anOtherPCurve.Load (aPCurve,
+ anOtherPCurve->Load (aPCurve,
aData->InterferenceOnS2().FirstParameter(),
aData->InterferenceOnS2().LastParameter());
}
// Normal case - no common surface
continue;
}
- if (IsEqual(anOtherPCurve.LastParameter(),anOtherPCurve.FirstParameter()))
+ if (IsEqual(anOtherPCurve->LastParameter(),anOtherPCurve->FirstParameter()))
// Degenerates
continue;
anIntersector.Perform (aCorkPCurve, anOtherPCurve,
Handle(Geom_TrimmedCurve)::DownCast(DStr.Curve (anOtherIntrf->Geometry()).Curve());
if (anOtherCur.IsNull())
continue;
- Geom2dAdaptor_Curve anOtherPCurve (anOtherIntrf->PCurve(),
+ Handle(Geom2dAdaptor_Curve) anOtherPCurve = new Geom2dAdaptor_Curve(anOtherIntrf->PCurve(),
anOtherCur->FirstParameter(),
anOtherCur->LastParameter());
anIntersector.Perform (aCorkPCurve, anOtherPCurve,
throw Standard_ConstructionError ("Failed to get p-curve of edge");
pv1 = Hc->Value(parVtx);
pv2 = p2dbout;
- ChFi3d_Recale(Bs,pv1,pv2,1);
+ ChFi3d_Recale(HBs,pv1,pv2,1);
TColStd_Array1OfReal Pardeb(1,4),Parfin(1,4);
Pardeb(1) = pop1.X(); Pardeb(2) = pop1.Y();
Pardeb(3) = pv1.X(); Pardeb(4) = pv1.Y();
Parfin(3) = pv2.X(); Parfin(4) = pv2.Y();
Standard_Real uu1,uu2,vv1,vv2;
ChFi3d_Boite(pv1,pv2,uu1,uu2,vv1,vv2);
- ChFi3d_BoundFac(Bs,uu1,uu2,vv1,vv2);
+ ChFi3d_BoundFac(HBs,uu1,uu2,vv1,vv2);
ChFi3d_Boite(pop1,pop2,uu1,uu2,vv1,vv2);
- ChFi3d_BoundFac(Bop,uu1,uu2,vv1,vv2);
+ ChFi3d_BoundFac(HBop,uu1,uu2,vv1,vv2);
Handle(Geom_Curve) zob3d;
Handle(Geom2d_Curve) zob2dop, zob2dv;
// <tol> from <Param>, check points between <Pf> and <Pl>
//=======================================================================
-static Standard_Boolean IsShrink(const Geom2dAdaptor_Curve& PC,
+static Standard_Boolean IsShrink(const Handle(Geom2dAdaptor_Curve)& PC,
const Standard_Real Pf,
const Standard_Real Pl,
const Standard_Real Param,
const Standard_Boolean isU,
const Standard_Real tol)
{
- switch (PC.GetType()) {
+ switch (PC->GetType()) {
case GeomAbs_Line: {
- gp_Pnt2d P1 = PC.Value(Pf);
- gp_Pnt2d P2 = PC.Value(Pl);
+ gp_Pnt2d P1 = PC->Value(Pf);
+ gp_Pnt2d P2 = PC->Value(Pl);
if (Abs(P1.Coord(isU ? 1 : 2) - Param) <= tol &&
Abs(P2.Coord(isU ? 1 : 2) - Param) <= tol )
return Standard_True;
math_FunctionSample aSample (Pf,Pl,10);
Standard_Integer i;
for (i=1; i<=aSample.NbPoints(); i++) {
- gp_Pnt2d P = PC.Value(aSample.GetParameter(i));
+ gp_Pnt2d P = PC->Value(aSample.GetParameter(i));
if (Abs(P.Coord(isU ? 1 : 2) - Param) > tol )
return Standard_False;
}
ChFiDS_FaceInterference Fi2 = Fd->InterferenceOnS2();
GeomAdaptor_Surface& Gs = *HGs;
Handle(BRepAdaptor_Surface) HBs = new BRepAdaptor_Surface();
- BRepAdaptor_Surface& Bs = *HBs;
Handle(Geom_Curve) Cc;
Handle(Geom2d_Curve) Pc,Ps;
Standard_Real Ubid,Vbid;
Hc1 = BRep_Tool::CurveOnSurface(Edge[0],Face[0],Ubid,Ubid);
if (isOnSame1) {
// update interference param on Fi1 and point of CV1
- if (prolface[0]) Bs.Initialize(faceprol[0], Standard_False);
- else Bs.Initialize(Face[0], Standard_False);
+ if (prolface[0]) HBs->Initialize(faceprol[0], Standard_False);
+ else HBs->Initialize(Face[0], Standard_False);
const Handle(Geom_Curve)& c3df = DStr.Curve(Fi1.LineIndex()).Curve();
Standard_Real Ufi= Fi2.Parameter(isfirst);
ChFiDS_FaceInterference& Fi = Fd->ChangeInterferenceOnS1();
Standard_Real tol=BRep_Tool::Tolerance(F);
BRE.MakeFace(faceprol[0],Sfacemoins1,F.Location(),tol);
if (!isOnSame1) {
- GeomAdaptor_Surface Asurf;
- Asurf.Load(Sfacemoins1);
+ Handle(GeomAdaptor_Surface) Asurf = new GeomAdaptor_Surface(Sfacemoins1);
Extrema_ExtPS ext (CV1.Point(),Asurf, tol,tol);
Standard_Real uc1,vc1;
if (ext.IsDone()) {
extend=Standard_True;
Standard_Real tol=BRep_Tool::Tolerance(F);
BRE.MakeFace(faceprol[nb-1],Sfacemoins1,F.Location(),tol);
- GeomAdaptor_Surface Asurf;
- Asurf.Load(Sfacemoins1);
+ Handle(GeomAdaptor_Surface) Asurf = new GeomAdaptor_Surface(Sfacemoins1);
Extrema_ExtPS ext (CV2.Point(),Asurf,tol,tol);
Standard_Real uc2,vc2;
if (ext.IsDone()) {
if (nb==nbface && isOnSame2) {
// update interference param on Fi2 and point of CV2
- if (prolface[nb-1]) Bs.Initialize(faceprol[nb-1]);
- else Bs.Initialize(Face[nb-1]);
+ if (prolface[nb-1]) HBs->Initialize(faceprol[nb-1]);
+ else HBs->Initialize(Face[nb-1]);
const Handle(Geom_Curve)& c3df = DStr.Curve(Fi2.LineIndex()).Curve();
Standard_Real Ufi= Fi1.Parameter(isfirst);
ChFiDS_FaceInterference& Fi = Fd->ChangeInterferenceOnS2();
}
- if (prolface[nb-1]) Bs.Initialize(faceprol[nb-1]);
- else Bs.Initialize(Face[nb-1]);
+ if (prolface[nb-1]) HBs->Initialize(faceprol[nb-1]);
+ else HBs->Initialize(Face[nb-1]);
// offset of parameters if they are not in the same period
Standard_Real uu1,uu2,vv1,vv2;
ChFi3d_Boite(pfac1,pfac2,uu1,uu2,vv1,vv2);
- ChFi3d_BoundFac(Bs,uu1,uu2,vv1,vv2);
+ ChFi3d_BoundFac(HBs,uu1,uu2,vv1,vv2);
//////////////////////////////////////////////////////////////////////
gp_Pnt pext;
Standard_Real ubid,vbid;
pext=BRep_Tool::Pnt(Vtx);
- GeomAdaptor_Curve cad;
+ Handle(GeomAdaptor_Curve) cad = new GeomAdaptor_Curve();
Handle(Geom_Curve) csau;
if ( ! (oneintersection1 || oneintersection2)) {
- cad.Load(cint);
+ cad->Load(cint);
csau=cint;
}
else {
csau=C1;
}
}
- cad.Load(csau);
+ cad->Load(csau);
}
Extrema_ExtPC ext(pext,cad,tolpt);
Standard_Real par1, par2, par, ParVtx;
DStr.SetNewSurface(Face[nb-1],Sfacemoins1);
}
//// for periodic 3d curves ////
- if (cad.IsPeriodic())
+ if (cad->IsPeriodic())
{
gp_Pnt2d P2d = BRep_Tool::Parameters( Vtx, Face[0] );
Geom2dAPI_ProjectPointOnCurve Projector( P2d, C2dint1 );
}
if (checkShrink &&
- IsShrink(Ps,p1,p2,checkShrParam,isUShrink,Precision::Parametric(tolreached)))
+ IsShrink(new Geom2dAdaptor_Curve(Ps),p1,p2,checkShrParam,isUShrink,Precision::Parametric(tolreached)))
{
shrink [nb-1] = 1;
// store section face-chamf curve for previous SurfData
const gp_Pnt& Pvert = Pds.Point();
Standard_Real tol = Pds.Tolerance();
- Geom2dAdaptor_Curve PC1(Ps), PC2(PCend);
+ Handle(Geom2dAdaptor_Curve) PC1 = new Geom2dAdaptor_Curve(Ps);
+ Handle(Geom2dAdaptor_Curve) PC2 = new Geom2dAdaptor_Curve(PCend);
Geom2dInt_GInter Intersector(PC1,PC2,Precision::PConfusion(),Precision::PConfusion());
if (!Intersector.IsDone()) return;
for (nb=1; nb <= Intersector.NbPoints(); nb++) {
Standard_Real aPar=0.;
if (isPextFound) {
- GeomAdaptor_Curve aCad(aCracc);
+ Handle(GeomAdaptor_Curve) aCad = new GeomAdaptor_Curve(aCracc);
Extrema_ExtPC anExt(aPext, aCad, aTol3d);
if (!anExt.IsDone())
Handle(BRepAdaptor_Surface) HBs = new BRepAdaptor_Surface();
Handle(BRepAdaptor_Surface) HBad = new BRepAdaptor_Surface();
Handle(BRepAdaptor_Surface) HBop = new BRepAdaptor_Surface();
- BRepAdaptor_Surface& Bs = *HBs;
- BRepAdaptor_Surface& Bad = *HBad;
- BRepAdaptor_Surface& Bop = *HBop;
Handle(Geom_Curve) Cc;
Handle(Geom2d_Curve) Pc,Ps;
Standard_Real Ubid,Vbid;//,mu,Mu,mv,Mv;
tol=BRep_Tool::Tolerance(Fv);
BRE.MakeFace(FFv,Sface,tol);
if (prol) {
- Bs.Initialize(FFv,Standard_False);
+ HBs->Initialize(FFv,Standard_False);
DStr.SetNewSurface(Fv,Sface);
}
- else Bs.Initialize(Fv,Standard_False);
- Bad.Initialize(Fad);
- Bop.Initialize(Fop);
+ else HBs->Initialize(Fv,Standard_False);
+ HBad->Initialize(Fad);
+ HBop->Initialize(Fop);
}
// it is necessary to modify the CommonPoint
// in the space and its parameter in FaceInterference.
else{
pfil2 = Fi2.PCurveOnSurf()->Value(Fi2.Parameter(!isfirst));
}
- ChFi3d_Recale(Bs,pfac1,pfac2,(IFadArc == 1));
+ ChFi3d_Recale(HBs,pfac1,pfac2,(IFadArc == 1));
Pardeb(1)= pfil1.X();Pardeb(2) = pfil1.Y();
Pardeb(3)= pfac1.X();Pardeb(4) = pfac1.Y();
Parfin(1)= pfil2.X();Parfin(2) = pfil2.Y();
Parfin(3)= pfac2.X();Parfin(4) = pfac2.Y();
Standard_Real uu1,uu2,vv1,vv2;
ChFi3d_Boite(pfac1,pfac2,uu1,uu2,vv1,vv2);
- ChFi3d_BoundFac(Bs,uu1,uu2,vv1,vv2);
+ ChFi3d_BoundFac(HBs,uu1,uu2,vv1,vv2);
if (!ChFi3d_ComputeCurves(HGs,HBs,Pardeb,Parfin,Cc,
Ps,
//Standard_Real Ubid,Vbid;
Handle (Geom_Curve) C=BRep_Tool::Curve(edgecouture,Ubid,Vbid);
Handle(Geom_TrimmedCurve) Ctrim=new Geom_TrimmedCurve (C,Ubid,Vbid);
- GeomAdaptor_Curve cur1(Ctrim->BasisCurve());
- GeomAdaptor_Curve cur2(Cc);
+ Handle(GeomAdaptor_Curve) cur1 = new GeomAdaptor_Curve(Ctrim->BasisCurve());
+ Handle(GeomAdaptor_Curve) cur2 = new GeomAdaptor_Curve(Cc);
Extrema_ExtCC extCC (cur1,cur2);
if (extCC.IsDone()&&extCC.NbExt()!=0)
{
//fin modif
pv1 = Hc->Value(parVtx);
pv2 = p2dbout;
- ChFi3d_Recale(Bs,pv1,pv2,1);
+ ChFi3d_Recale(HBs,pv1,pv2,1);
TColStd_Array1OfReal Pardeb(1,4),Parfin(1,4);
Pardeb(1) = pop1.X(); Pardeb(2) = pop1.Y();
Pardeb(3) = pv1.X(); Pardeb(4) = pv1.Y();
Parfin(3) = pv2.X(); Parfin(4) = pv2.Y();
Standard_Real uu1,uu2,vv1,vv2;
ChFi3d_Boite(pv1,pv2,uu1,uu2,vv1,vv2);
- ChFi3d_BoundFac(Bs,uu1,uu2,vv1,vv2);
+ ChFi3d_BoundFac(HBs,uu1,uu2,vv1,vv2);
ChFi3d_Boite(pop1,pop2,uu1,uu2,vv1,vv2);
- ChFi3d_BoundFac(Bop,uu1,uu2,vv1,vv2);
+ ChFi3d_BoundFac(HBop,uu1,uu2,vv1,vv2);
Handle(Geom_Curve) zob3d;
Handle(Geom2d_Curve) zob2dop, zob2dv;
Handle(Geom_BoundedCurve) C1= Handle(Geom_BoundedCurve)::DownCast(csau);
if (! C1.IsNull()) {
GeomLib::ExtendCurveToPoint(C1,CP2.Point(),1,Standard_False);
- GeomAdaptor_Curve cad;
- cad.Load(C1);
+ Handle(GeomAdaptor_Curve) cad = new GeomAdaptor_Curve(C1);
Extrema_ExtPC ext(CP2.Point(),cad,1.e-4);
parCP2 = ext.Point(1).Parameter();
}
// for the case when two chamfers are on two edges OnSame,
// it is necessary to extend the surface carrying F, or at least
// not to limit it.
- ChFi3d_BoundFac (*HF, uu1, uu2, vv1, vv2, Standard_True);
+ ChFi3d_BoundFac (HF, uu1, uu2, vv1, vv2, Standard_True);
if (!ChFi3d_ComputeCurves(HF,BigHS,Pardeb,Parfin,Gc,
PGc1,PGc2,tolesp,tol2d,tolreached)) {
}
}
for (nb=1;nb<=nbface-1;nb++) {
- BRepAdaptor_Curve C(TopoDS::Edge(Ecom.Value(nb)));
- C.D0(param.Value(nb),p02);
- GeomAdaptor_Curve L (Bezier);
+ Handle(BRepAdaptor_Curve) C = new BRepAdaptor_Curve(TopoDS::Edge(Ecom.Value(nb)));
+ C->D0(param.Value(nb),p02);
+ Handle(GeomAdaptor_Curve) L = new GeomAdaptor_Curve(Bezier);
Extrema_ExtCC ext (C,L);
if (ext.IsDone()){
if (!ext.IsParallel() && ext.NbExt()!=0){
Standard_Real umin,vmin,umax,vmax;
BRepTools::UVBounds(Face,umin,umax,vmin,vmax);
Bnd_Box2d bf,bc;
- Geom2dAdaptor_Curve acur(pcurve);
+ Handle(Geom2dAdaptor_Curve) acur = new Geom2dAdaptor_Curve(pcurve);
BndLib_Add2dCurve::Add(acur,0,bc);
bf.Update(umin,vmin,umax,vmax);
Standard_Real uminc,vminc,umaxc,vmaxc;
Handle(Geom2d_Line) l= new Geom2d_Line (p2d1 ,dir);
Handle (Geom2d_Curve) pcurve = new Geom2d_TrimmedCurve(l,0,l0);
Handle (Geom2dAdaptor_Curve) Acurv = new Geom2dAdaptor_Curve(pcurve);
- Adaptor3d_CurveOnSurface CurvOnS (Acurv,Asurf);
- Handle(Adaptor3d_CurveOnSurface) HCons =
- new Adaptor3d_CurveOnSurface(CurvOnS);
+ Handle(Adaptor3d_CurveOnSurface) CurvOnS = new Adaptor3d_CurveOnSurface(Acurv,Asurf);
//Order.SetValue(ic,1);
Order.SetValue(ic, constr);
Handle(GeomPlate_CurveConstraint) Cont =
- new GeomPlate_CurveConstraint(HCons,Order.Value(ic), nbcurvpnt,tolesp,angular,0.1);
+ new GeomPlate_CurveConstraint(CurvOnS, Order.Value(ic), nbcurvpnt,tolesp,angular,0.1);
PSurf.Add(Cont);
// calculate indexes of points and of the curve for the DS
isfirst=(sens.Value(ic)==1);
- GeomLib::BuildCurve3d(tolapp,CurvOnS,CurvOnS.FirstParameter(),
- CurvOnS.LastParameter(),Curv3d,maxapp,avedev);
+ GeomLib::BuildCurve3d(tolapp,CurvOnS,CurvOnS->FirstParameter(),
+ CurvOnS->LastParameter(),Curv3d,maxapp,avedev);
TopOpeBRepDS_Curve tcurv3d( Curv3d,maxapp);
indcurve3d.SetValue(n3d,DStr.AddCurve(tcurv3d));
gp_Pnt point1,point2;
- point1= CurvOnS.Value(CurvOnS.FirstParameter());
- point2 =CurvOnS.Value(CurvOnS.LastParameter());
+ point1= CurvOnS->Value(CurvOnS->FirstParameter());
+ point2 =CurvOnS->Value(CurvOnS->LastParameter());
TopOpeBRepDS_Point tpoint1 (point1,maxapp);
TopOpeBRepDS_Point tpoint2 (point2,maxapp);
// construction of borders for Plate
Handle (Geom2dAdaptor_Curve) Acurv=new Geom2dAdaptor_Curve(pcurve);
- Adaptor3d_CurveOnSurface CurvOnS (Acurv,Asurf);
- Handle(Adaptor3d_CurveOnSurface) HCons =
- new Adaptor3d_CurveOnSurface(CurvOnS);
+ Handle(Adaptor3d_CurveOnSurface) CurvOnS = new Adaptor3d_CurveOnSurface(Acurv,Asurf);
// constraints G1 are set if edges ic and icplus are not both alive
if (isG1.Value(ic))
Order.SetValue(n3d,1);
Handle(GeomPlate_CurveConstraint) Cont =
- new GeomPlate_CurveConstraint(HCons,Order.Value(n3d),10,tolesp,angular,0.1);
+ new GeomPlate_CurveConstraint(CurvOnS, Order.Value(n3d),10,tolesp,angular,0.1);
PSurf.Add(Cont);
//calculation of curve 3d if it is not a projection
if (curveint.IsNull()) {
- GeomLib::BuildCurve3d(tolapp,CurvOnS,CurvOnS.FirstParameter(),
- CurvOnS.LastParameter(),Curv3d,maxapp1,avedev);
- pardeb=CurvOnS.FirstParameter();
- parfin= CurvOnS.LastParameter();
+ GeomLib::BuildCurve3d(tolapp,CurvOnS,CurvOnS->FirstParameter(),
+ CurvOnS->LastParameter(),Curv3d,maxapp1,avedev);
+ pardeb=CurvOnS->FirstParameter();
+ parfin= CurvOnS->LastParameter();
curveint= new Geom_TrimmedCurve(Curv3d,pardeb,parfin);
}
//purpose :
//=======================================================================
-static Standard_Real ComputeAbscissa(const BRepAdaptor_Curve& C,
+static Standard_Real ComputeAbscissa(const Handle(BRepAdaptor_Curve)& C,
const Standard_Real U)
{
- switch (C.GetType()) {
+ switch (C->GetType()) {
case GeomAbs_Line:
return U;
case GeomAbs_Circle:
- return C.Circle().Radius()*U;
+ return C->Circle().Radius()*U;
default:
return 0;
}
TopoDS_Vertex bout1,bout2,boutemp;
- const BRepAdaptor_Curve& bc = Spine->CurrentElementarySpine(iedge);
+ const Handle(BRepAdaptor_Curve)& bc = Spine->CurrentElementarySpine(iedge);
//Modif against Vertex isolated on spine
- TopoDS_Edge support = bc.Edge();
+ TopoDS_Edge support = bc->Edge();
TopExp::Vertices(support,bout1,bout2);
if (support.Orientation() == TopAbs_REVERSED) {
boutemp = bout2;
bout1 = bout2;
}
//finmodif
- Standard_Real edf = bc.FirstParameter(), edl = bc.LastParameter();
+ Standard_Real edf = bc->FirstParameter(), edl = bc->LastParameter();
Standard_Real edglen = edl - edf;
if(Spine->Edges(iedge).Orientation() == TopAbs_FORWARD) {
- bc.D1(wtg+edf,ped,ded);
+ bc->D1(wtg+edf,ped,ded);
}
else{
- bc.D1(-wtg+edl,ped,ded);
+ bc->D1(-wtg+edl,ped,ded);
ded.Reverse();
}
Spine->D1(wsp,psp,dsp);
const ChFiDS_CommonPoint& cp2 = SD->Vertex(isfirst,2);
if(!((cp1.IsOnArc() && SearchFace(Spine,cp1,F1,FBID)) ||
(cp2.IsOnArc() && SearchFace(Spine,cp2,F2,FBID)))) {
- tron = ChFi3d_KParticular (Spine, ivois, *BS1, *BS2);
+ tron = ChFi3d_KParticular (Spine, ivois, BS1, BS2);
}
}
}
const Standard_Integer iedge,
const Standard_Boolean isfirst)
{
- const BRepAdaptor_Curve& bc = Spine->CurrentElementarySpine(iedge);
- Standard_Real edglen = bc.LastParameter() - bc.FirstParameter();
+ const Handle(BRepAdaptor_Curve)& bc = Spine->CurrentElementarySpine(iedge);
+ Standard_Real edglen = bc->LastParameter() - bc->FirstParameter();
const Handle(Geom_Surface)& surf = DStr.Surface(CD->Surf()).Surface();
Standard_Real par = 0., x, y;
if(!isfirst) par = edglen;
HatchGen_Domain* Dom = ((HatchGen_Domain*) (void*) &H.Domain(iH,Ind(iSansFirst)));
HatchGen_PointOnHatching* PH =
((HatchGen_PointOnHatching*) (void*) &H.Domain(iH,Ind(iSansLast)).FirstPoint());
- Standard_Real NewPar = H.HatchingCurve(iH).FirstParameter() - period +
+ Standard_Real NewPar = H.HatchingCurve(iH)->FirstParameter() - period +
H.Domain(iH,Ind(iSansLast)).FirstPoint().Parameter();
PH->SetParameter(NewPar);
Dom->SetFirstPoint(*PH);
Geom2dHatch_Hatcher H1(Inter,tol2d,tolesp), H2(Inter,tol2d,tolesp);
Standard_Integer ie;
Handle(Geom2d_Curve) C1 = Data->InterferenceOnS1().PCurveOnFace();
- Geom2dAdaptor_Curve ll1;
+ Handle(Geom2dAdaptor_Curve) ll1 = new Geom2dAdaptor_Curve();
if (!C1.IsNull()) {
- ll1.Load(C1);
+ ll1->Load(C1);
for(I1->Init(); I1->More(); I1->Next()) {
Handle(BRepAdaptor_Curve2d)
Bc = Handle(BRepAdaptor_Curve2d)::DownCast(I1->Value());
Handle(Geom2dAdaptor_Curve)
Gc = Handle(Geom2dAdaptor_Curve)::DownCast(I1->Value());
- if(Bc.IsNull()) ie = H1.AddElement (*Gc, TopAbs_FORWARD);
- else ie = H1.AddElement (*Bc, Bc->Edge().Orientation());
+ if(Bc.IsNull()) ie = H1.AddElement (Gc, TopAbs_FORWARD);
+ else ie = H1.AddElement (Bc, Bc->Edge().Orientation());
M1.Bind(ie,I1->Value());
}
iH1 = H1.Trim(ll1);
}
Handle(Geom2d_Curve) C2 = Data->InterferenceOnS2().PCurveOnFace();
- Geom2dAdaptor_Curve ll2;
+ Handle(Geom2dAdaptor_Curve) ll2 = new Geom2dAdaptor_Curve();
if (!C2.IsNull()) {
- ll2.Load(C2);
+ ll2->Load(C2);
for(I2->Init(); I2->More(); I2->Next()) {
Handle(BRepAdaptor_Curve2d)
Bc = Handle(BRepAdaptor_Curve2d)::DownCast(I2->Value());
Handle(Geom2dAdaptor_Curve)
Gc = Handle(Geom2dAdaptor_Curve)::DownCast(I2->Value());
- if(Bc.IsNull()) ie = H2.AddElement (*Gc, TopAbs_FORWARD);
- else ie = H2.AddElement (*Bc, Bc->Edge().Orientation());
+ if(Bc.IsNull()) ie = H2.AddElement (Gc, TopAbs_FORWARD);
+ else ie = H2.AddElement (Bc, Bc->Edge().Orientation());
M2.Bind(ie,I2->Value());
}
iH2 = H2.Trim(ll2);
//Return start and end vertexes of the Spine
TopoDS_Vertex bout1,bout2,boutemp;
- const BRepAdaptor_Curve& bc = Spine->CurrentElementarySpine(Iedge);
- TopoDS_Edge support = bc.Edge();
+ const Handle(BRepAdaptor_Curve)& bc = Spine->CurrentElementarySpine(Iedge);
+ TopoDS_Edge support = bc->Edge();
TopExp::Vertices(support,bout1,bout2);
if(support.Orientation() == TopAbs_REVERSED) {
boutemp = bout2;
// Parsing of domains by increasing parameters,
// if there is a 2d circle on a plane, one goes on 2D line of opposite face.
Standard_Real period1 = 0., period2 = 0.;
- if(ll1.IsPeriodic()) {
+ if(ll1->IsPeriodic()) {
if(!Tri(H2,iH2,Ind2,wref,0.,pitol,Nb2)) return 0;
- period1 = ll1.Period();
+ period1 = ll1->Period();
if(!Tri(H1,iH1,Ind1,wref,period1,pitol,Nb1)) return 0;
}
else{
if(!Tri(H1,iH1,Ind1,wref,0.,pitol,Nb1)) return 0;
- if(ll2.IsPeriodic()) { period2 = ll2.Period(); }
+ if(ll2->IsPeriodic()) { period2 = ll2->Period(); }
if(!Tri(H2,iH2,Ind2,wref,period2,pitol,Nb2)) return 0;
}
//-------------------------
Standard_Integer ifirst = 0;
Standard_Real dist = RealLast(), ptg, dsp;
- const BRepAdaptor_Curve& ed = Spine->CurrentElementarySpine(Iedge);
+ const Handle(BRepAdaptor_Curve)& ed = Spine->CurrentElementarySpine(Iedge);
for (Standard_Integer i1 = 1; i1 <= SetData.Length(); i1++) {
Handle(ChFiDS_SurfData)& CD1 = SetData.ChangeValue(i1);
ChFiDS_CommonPoint& CP1 = CD1->ChangeVertexFirstOnS1();
Standard_Real dist = RealLast(), ptg, dsp;
Standard_Real f = Spine->FirstParameter(Iedge);
Standard_Real l = Spine->LastParameter(Iedge);
- const BRepAdaptor_Curve& ed = Spine->CurrentElementarySpine(Iedge);
+ const Handle(BRepAdaptor_Curve)& ed = Spine->CurrentElementarySpine(Iedge);
for (Standard_Integer i2 = 1; i2<= SetData.Length(); i2++) {
Handle(ChFiDS_SurfData)& CD3 = SetData.ChangeValue(i2);
ChFiDS_CommonPoint& CP1 = CD3->ChangeVertexLastOnS1();
TopoDS_Face F1,F2,FirstF1,FirstF2;
TopAbs_Orientation Or1,Or2;
Standard_Integer Choix, ChoixConge;
- BRepAdaptor_Surface Sb1,Sb2;
+ Handle(BRepAdaptor_Surface) Sb1 = new BRepAdaptor_Surface();
+ Handle(BRepAdaptor_Surface) Sb2 = new BRepAdaptor_Surface();
Standard_Integer i = 1;
Standard_Boolean Found = Standard_False;
while ( (i <= csp->NbEdges()) && (!Found) ) {
F2 = F1;
F1 = F;
}
- Sb1.Initialize(F1);
- Sb2.Initialize(F2);
+ Sb1->Initialize(F1);
+ Sb2->Initialize(F2);
Choix = ChFi3d::ConcaveSide(Sb1,Sb2,
csp->Edges(i-1),
Or1,Or2);
- Sb1.Initialize(FirstF1);
- Sb2.Initialize(FirstF2);
+ Sb1->Initialize(FirstF1);
+ Sb2->Initialize(FirstF2);
ChoixConge = ChFi3d::ConcaveSide(Sb1,Sb2,
csp->Edges(1),
Or1,Or2);
Standard_Real tol = tolesp*1.e2;
// Standard_Real u,v;
- Extrema_GenLocateExtPS proj1(*S1, tol, tol);
+ Extrema_GenLocateExtPS proj1(S1, tol, tol);
proj1.Perform(pt1, SolDep(1), SolDep(2));
- Extrema_GenLocateExtPS proj2(*S2, tol, tol);
+ Extrema_GenLocateExtPS proj2(S2, tol, tol);
proj2.Perform(pt2, SolDep(3), SolDep(4));
if( proj1.IsDone() ){
Standard_Real tol = tolesp*1.e2;
// Standard_Real u,v;
- Extrema_GenLocateExtPS proj1(*S1, tol, tol);
+ Extrema_GenLocateExtPS proj1(S1, tol, tol);
proj1.Perform(pt1, SolDep(1), SolDep(2));
- Extrema_GenLocateExtPS proj2(*S2, tol, tol);
+ Extrema_GenLocateExtPS proj2(S2, tol, tol);
proj2.Perform(pt2, SolDep(3), SolDep(4));
if( proj1.IsDone() ){
Standard_Real tol = tolesp*1.e2;
// Standard_Real u,v;
- Extrema_GenLocateExtPS proj1(*S1, tol, tol);
+ Extrema_GenLocateExtPS proj1(S1, tol, tol);
proj1.Perform(pt1, SolDep(1), SolDep(2));
- Extrema_GenLocateExtPS proj2(*S2, tol, tol);
+ Extrema_GenLocateExtPS proj2(S2, tol, tol);
proj2.Perform(pt2, SolDep(3), SolDep(4));
if( proj1.IsDone() ){
(proj1.Point()).Parameter(SolDep(1),SolDep(2));
TopoDS_Face& F1,
TopoDS_Face& F2) const
{
- BRepAdaptor_Surface Sb1,Sb2;
+ Handle(BRepAdaptor_Surface) Sb1 = new BRepAdaptor_Surface();
+ Handle(BRepAdaptor_Surface) Sb2 = new BRepAdaptor_Surface();
TopAbs_Orientation tmp1,tmp2;
Standard_Integer RC,Choix;
TopoDS_Face f1,f2,ff1,ff2;
// ChFi3d_Builder::StripeOrientations is private
SearchCommonFaces(myEFMap,Spine->Edges(1),ff1,ff2);
ff1.Orientation(TopAbs_FORWARD);
- Sb1.Initialize(ff1);
+ Sb1->Initialize(ff1);
ff2.Orientation(TopAbs_FORWARD);
- Sb2.Initialize(ff2);
+ Sb2->Initialize(ff2);
RC = ChFi3d::ConcaveSide(Sb1,Sb2,Spine->Edges(1),tmp1,tmp2);
//calculate the connected faces
SearchCommonFaces(myEFMap,Spine->Edges(IEdge),f1,f2);
- Sb1.Initialize(f1);
- Sb2.Initialize(f2);
+ Sb1->Initialize(f1);
+ Sb2->Initialize(f2);
Choix = ChFi3d::ConcaveSide(Sb1,Sb2,Spine->Edges(IEdge),tmp1,tmp2);
if (RC%2 != Choix%2) {
// ----------------------------------------------------------
Handle(BRepAdaptor_Surface) Fac = new BRepAdaptor_Surface(face[pivot]);
- Handle(GeomAdaptor_Surface)
- bidsurf = new GeomAdaptor_Surface(Fac->Surface());
- Handle(Adaptor3d_TopolTool) IFac = new Adaptor3d_TopolTool(bidsurf);
Handle(GeomAdaptor_Surface) Surf = ChFi3d_BoundSurf (DStr,fdpiv,jf[pivot][deb],jf[pivot][fin]);
Handle(Adaptor3d_TopolTool) ISurf = new Adaptor3d_TopolTool(Surf);
GeomInt_IntSS inter;
BRepAdaptor_Surface facebid(face[pivot]);
Handle(Geom_Surface)
- surfbid = Handle(Geom_Surface)::DownCast(facebid.Surface().Surface()->Transformed(facebid.Trsf()));
+ surfbid = Handle(Geom_Surface)::DownCast(facebid.Surface()->Surface()->Transformed(facebid.Trsf()));
inter.Perform(gpl,surfbid,Precision::Intersection());
if (inter.IsDone()) {
Standard_Integer nbl = inter.NbLines();
// two others are required.
//=======================================================================
-static Standard_Boolean ToricRotule(const BRepAdaptor_Surface& fac,
- const BRepAdaptor_Surface& s1,
- const BRepAdaptor_Surface& s2,
+static Standard_Boolean ToricRotule(const Handle(BRepAdaptor_Surface)& fac,
+ const Handle(BRepAdaptor_Surface)& s1,
+ const Handle(BRepAdaptor_Surface)& s2,
const Handle(ChFiDS_Stripe)& c1,
const Handle(ChFiDS_Stripe)& c2)
if(sp1.IsNull() || sp2.IsNull()) return Standard_False;
if (!sp1->IsConstant() || !sp2->IsConstant())
return Standard_False;
- if ((fac.GetType() != GeomAbs_Plane) ||
- (s1.GetType() != GeomAbs_Plane) ||
- (s2.GetType() != GeomAbs_Plane)) return Standard_False;
- gp_Dir df = fac.Plane().Position().Direction();
- gp_Dir ds1 = s1.Plane().Position().Direction();
- gp_Dir ds2 = s2.Plane().Position().Direction();
+ if ((fac->GetType() != GeomAbs_Plane) ||
+ (s1->GetType() != GeomAbs_Plane) ||
+ (s2->GetType() != GeomAbs_Plane)) return Standard_False;
+ gp_Dir df = fac->Plane().Position().Direction();
+ gp_Dir ds1 = s1->Plane().Position().Direction();
+ gp_Dir ds2 = s2->Plane().Position().Direction();
if ( Abs(df.Dot(ds1)) >= tolesp || Abs(df.Dot(ds2)) >= tolesp )
return Standard_False;
Standard_Real r1 = sp1->Radius();
if (Sens2==1) E2= st2->Spine()->Edges(1);
else E2= st2->Spine()->Edges( st2->Spine()->NbEdges());
- BRepAdaptor_Curve BCurv1(E1);
- BRepAdaptor_Curve BCurv2(E2);
+ Handle(BRepAdaptor_Curve) BCurv1 = new BRepAdaptor_Curve(E1);
+ Handle(BRepAdaptor_Curve) BCurv2 = new BRepAdaptor_Curve(E2);
parE1=BRep_Tool::Parameter(Vtx,E1);
parE2=BRep_Tool::Parameter(Vtx,E2);
BRepLProp_CLProps CL1(BCurv1,parE1 , 1, 1.e-4);
Handle(BRepAdaptor_Surface) HBRS1 = new BRepAdaptor_Surface();
Handle(BRepAdaptor_Surface) HBRS2 = new BRepAdaptor_Surface();
- BRepAdaptor_Surface& BRS1 = *HBRS1;
- BRepAdaptor_Surface& BRS2 = *HBRS2;
- BRepAdaptor_Surface& BRFaCo = *HFaCo;
- BRFaCo.Initialize(FaCo);
+ HFaCo->Initialize(FaCo);
TopoDS_Face FF1,FF2,F,FaPiv;
TopAbs_Orientation pctrans = TopAbs_FORWARD ;
done=1;
return;
}
- BRS1.Initialize(FF1);
- BRS2.Initialize(FF2);
+ HBRS1->Initialize(FF1);
+ HBRS2->Initialize(FF2);
if(yapiv ) {
TopTools_ListIteratorOfListOfShape Kt;
cornerset->Append(coin);
if (SameSide) {
- if(ToricRotule(BRFaCo,BRS1,BRS2,st1,st2)){
+ if(ToricRotule(HFaCo,HBRS1,HBRS2,st1,st2)){
// Direct construction.
// ---------------------
bid = 1;
bid = ChFi3d::NextSide(ori,OFF1,oriS,oriSFF1,bid);
TopAbs_Orientation op1 = TopAbs_FORWARD,op2 = TopAbs_FORWARD;
- if(yapiv) bid = ChFi3d::ConcaveSide(BRS1,BRS2,pivot,op1,op2);
+ if(yapiv) bid = ChFi3d::ConcaveSide(HBRS1,HBRS2,pivot,op1,op2);
op1 = TopAbs::Reverse(op1);
op2 = TopAbs::Reverse(op2);
#ifdef OCCT_DEBUG
// Try to not classify on the face for cases of reentering fillets which naturally depass
// the border.
Handle(GeomAdaptor_Surface)
- bidsurf = new GeomAdaptor_Surface(Fac->ChangeSurface().Surface());
+ bidsurf = new GeomAdaptor_Surface(Fac->Surface()->Surface());
Handle(Adaptor3d_TopolTool)
IFac = new Adaptor3d_TopolTool(bidsurf);
// end of the attempt.
ChFiDS_Spine::ChFiDS_Spine()
: splitdone (Standard_False),
myMode (ChFiDS_ClassicChamfer),
+ myCurve(new BRepAdaptor_Curve()),
+ myOffsetCurve(new BRepAdaptor_Curve()),
indexofcurve (0),
myTypeOfConcavity (ChFiDS_Other),
firstState (ChFiDS_OnSame),
ChFiDS_Spine::ChFiDS_Spine(const Standard_Real Tol)
: splitdone (Standard_False),
myMode (ChFiDS_ClassicChamfer),
+ myCurve(new BRepAdaptor_Curve()),
+ myOffsetCurve(new BRepAdaptor_Curve()),
indexofcurve (0),
myTypeOfConcavity (ChFiDS_Other),
firstState (ChFiDS_OnSame),
abscissa = new TColStd_HArray1OfReal(1,len);
Standard_Real a1 = 0.;
for (Standard_Integer i = 1; i <= len; i++){
- myCurve.Initialize(TopoDS::Edge(spine.Value(i)));
+ myCurve->Initialize(TopoDS::Edge(spine.Value(i)));
a1 += GCPnts_AbscissaPoint::Length(myCurve);
abscissa->SetValue(i,a1);
}
indexofcurve =1;
- myCurve.Initialize(TopoDS::Edge(spine.Value(1)));
+ myCurve->Initialize(TopoDS::Edge(spine.Value(1)));
}
if(indexofcurve != I){
void* p = (void*)this;
((ChFiDS_Spine*)p)->indexofcurve = I;
- ((ChFiDS_Spine*)p)->myCurve.Initialize(TopoDS::Edge(spine.Value(I)));
+ ((ChFiDS_Spine*)p)->myCurve->Initialize(TopoDS::Edge(spine.Value(I)));
}
Standard_Real L = FirstParameter(I);
if (spine.Value(I).Orientation() == TopAbs_REVERSED) {
- L += GCPnts_AbscissaPoint::Length(myCurve,U,myCurve.LastParameter());
+ L += GCPnts_AbscissaPoint::Length(myCurve,U,myCurve->LastParameter());
}
else{
- L += GCPnts_AbscissaPoint::Length(myCurve,myCurve.FirstParameter(),U);
+ L += GCPnts_AbscissaPoint::Length(myCurve,myCurve->FirstParameter(),U);
}
return L;
}
if (Index != indexofcurve) {
void* p = (void*)this;
((ChFiDS_Spine*)p)->indexofcurve = Index;
- ((ChFiDS_Spine*)p)->myCurve.Initialize(TopoDS::Edge(spine.Value(Index)));
+ ((ChFiDS_Spine*)p)->myCurve->Initialize(TopoDS::Edge(spine.Value(Index)));
}
Standard_Real L;
TopAbs_Orientation Or = spine.Value(Index).Orientation();
L = AbsC - abscissa->Value(indexofcurve-1);
}
Standard_Real t = L/Length(Index);
- Standard_Real uapp = (1. - t) * myCurve.FirstParameter() + t * myCurve.LastParameter();
+ Standard_Real uapp = (1. - t) * myCurve->FirstParameter() + t * myCurve->LastParameter();
// GCPnts_AbscissaPoint GCP;
-// GCP.Perform(myCurve,L,myCurve.FirstParameter(),uapp,BRep_Tool::Tolerance(myCurve.Edge()));
- GCPnts_AbscissaPoint GCP(myCurve,L,myCurve.FirstParameter(),uapp);
+// GCP.Perform(myCurve,L,myCurve->FirstParameter(),uapp,BRep_Tool::Tolerance(myCurve->Edge()));
+ GCPnts_AbscissaPoint GCP(myCurve,L,myCurve->FirstParameter(),uapp);
U = GCP.Parameter();
if (Or == TopAbs_REVERSED && Oriented) {
- U = (myCurve.LastParameter()+myCurve.FirstParameter()) - U;
+ U = (myCurve->LastParameter()+myCurve->FirstParameter()) - U;
}
}
if (Index != indexofcurve) {
void* p = (void*)this;
((ChFiDS_Spine*)p)->indexofcurve = Index;
- ((ChFiDS_Spine*)p)->myCurve.Initialize(TopoDS::Edge(spine.Value(Index)));
+ ((ChFiDS_Spine*)p)->myCurve->Initialize(TopoDS::Edge(spine.Value(Index)));
}
Standard_Real t = L/Length(Index);
- Standard_Real uapp = (1. - t) * myCurve.FirstParameter() + t * myCurve.LastParameter();
+ Standard_Real uapp = (1. - t) * myCurve->FirstParameter() + t * myCurve->LastParameter();
// GCPnts_AbscissaPoint GCP;
-// GCP.Perform(myCurve,L,myCurve.FirstParameter(),uapp,BRep_Tool::Tolerance(myCurve.Edge()));
- GCPnts_AbscissaPoint GCP(myCurve,L,myCurve.FirstParameter(),uapp);
- return myCurve.Value(GCP.Parameter());
+// GCP.Perform(myCurve,L,myCurve->FirstParameter(),uapp,BRep_Tool::Tolerance(myCurve->Edge()));
+ GCPnts_AbscissaPoint GCP(myCurve,L,myCurve->FirstParameter(),uapp);
+ return myCurve->Value(GCP.Parameter());
}
//=======================================================================
if (Index != indexofcurve) {
void* p = (void*)this;
((ChFiDS_Spine*)p)->indexofcurve = Index;
- ((ChFiDS_Spine*)p)->myCurve.Initialize(TopoDS::Edge(spine.Value(Index)));
+ ((ChFiDS_Spine*)p)->myCurve->Initialize(TopoDS::Edge(spine.Value(Index)));
}
Standard_Real t = L/Length(Index);
- Standard_Real uapp = (1. - t) * myCurve.FirstParameter() + t * myCurve.LastParameter();
+ Standard_Real uapp = (1. - t) * myCurve->FirstParameter() + t * myCurve->LastParameter();
// GCPnts_AbscissaPoint GCP;
-// GCP.Perform(myCurve,L,myCurve.FirstParameter(),uapp,BRep_Tool::Tolerance(myCurve.Edge()));
- GCPnts_AbscissaPoint GCP(myCurve,L,myCurve.FirstParameter(),uapp);
- myCurve.D1(GCP.Parameter(),P,V1);
+// GCP.Perform(myCurve,L,myCurve->FirstParameter(),uapp,BRep_Tool::Tolerance(myCurve->Edge()));
+ GCPnts_AbscissaPoint GCP(myCurve,L,myCurve->FirstParameter(),uapp);
+ myCurve->D1(GCP.Parameter(),P,V1);
Standard_Real D1 = 1./V1.Magnitude();
if (spine.Value(Index).Orientation() == TopAbs_REVERSED) D1 = -D1;
V1.Multiply(D1);
if (Index != indexofcurve) {
void* p = (void*)this;
((ChFiDS_Spine*)p)->indexofcurve = Index;
- ((ChFiDS_Spine*)p)->myCurve.Initialize(TopoDS::Edge(spine.Value(Index)));
+ ((ChFiDS_Spine*)p)->myCurve->Initialize(TopoDS::Edge(spine.Value(Index)));
}
Standard_Real t = L/Length(Index);
- Standard_Real uapp = (1. - t) * myCurve.FirstParameter() + t * myCurve.LastParameter();
+ Standard_Real uapp = (1. - t) * myCurve->FirstParameter() + t * myCurve->LastParameter();
// GCPnts_AbscissaPoint GCP;
-// GCP.Perform(myCurve,L,myCurve.FirstParameter(),uapp,BRep_Tool::Tolerance(myCurve.Edge()));
- GCPnts_AbscissaPoint GCP(myCurve,L,myCurve.FirstParameter(),uapp);
- myCurve.D2(GCP.Parameter(),P,V1,V2);
+// GCP.Perform(myCurve,L,myCurve->FirstParameter(),uapp,BRep_Tool::Tolerance(myCurve->Edge()));
+ GCPnts_AbscissaPoint GCP(myCurve,L,myCurve->FirstParameter(),uapp);
+ myCurve->D2(GCP.Parameter(),P,V1,V2);
Standard_Real N1 = V1.SquareMagnitude();
Standard_Real D2 = -(V1.Dot(V2))*(1./N1)*(1./N1);
V2.Multiply(1./N1);
{
if (Index != indexofcurve) {
indexofcurve = Index;
- myCurve.Initialize(TopoDS::Edge(spine.Value(indexofcurve)));
+ myCurve->Initialize(TopoDS::Edge(spine.Value(indexofcurve)));
}
}
//purpose :
//=======================================================================
-const BRepAdaptor_Curve& ChFiDS_Spine::CurrentElementarySpine
+const Handle(BRepAdaptor_Curve)& ChFiDS_Spine::CurrentElementarySpine
(const Standard_Integer Index)
{
if (Index != indexofcurve) {
indexofcurve = Index;
- myCurve.Initialize(TopoDS::Edge(spine.Value(indexofcurve)));
+ myCurve->Initialize(TopoDS::Edge(spine.Value(indexofcurve)));
}
return myCurve;
}
GeomAbs_CurveType ChFiDS_Spine::GetType() const
{
- return myCurve.GetType();
+ return myCurve->GetType();
}
//=======================================================================
gp_Lin ChFiDS_Spine::Line() const
{
- gp_Lin LL(myCurve.Line());
+ gp_Lin LL(myCurve->Line());
if (spine.Value(indexofcurve).Orientation() == TopAbs_REVERSED) {
LL.Reverse();
- LL.SetLocation(myCurve.Value(myCurve.LastParameter()));
+ LL.SetLocation(myCurve->Value(myCurve->LastParameter()));
}
else {
- LL.SetLocation(myCurve.Value(myCurve.FirstParameter()));
+ LL.SetLocation(myCurve->Value(myCurve->FirstParameter()));
}
return LL;
}
gp_Circ ChFiDS_Spine::Circle() const
{
- gp_Ax2 Ac = myCurve.Circle().Position();
- gp_Dir Dc(gp_Vec(Ac.Location(),myCurve.Value(myCurve.FirstParameter())));
+ gp_Ax2 Ac = myCurve->Circle().Position();
+ gp_Dir Dc(gp_Vec(Ac.Location(),myCurve->Value(myCurve->FirstParameter())));
gp_Dir ZZ(Ac.Direction());
if (spine.Value(indexofcurve).Orientation() == TopAbs_REVERSED) {
- Dc = gp_Dir(gp_Vec(Ac.Location(),myCurve.Value(myCurve.LastParameter())));
+ Dc = gp_Dir(gp_Vec(Ac.Location(),myCurve->Value(myCurve->LastParameter())));
ZZ.Reverse();
}
gp_Ax2 A(Ac.Location(),ZZ,Dc);
- return gp_Circ(A,myCurve.Circle().Radius());
+ return gp_Circ(A,myCurve->Circle().Radius());
}
//=======================================================================
//function : SetErrorStatus
Standard_EXPORT void SetCurrent (const Standard_Integer Index);
//! sets the current curve and returns it
- Standard_EXPORT const BRepAdaptor_Curve& CurrentElementarySpine (const Standard_Integer Index);
+ Standard_EXPORT const Handle(BRepAdaptor_Curve)& CurrentElementarySpine (const Standard_Integer Index);
Standard_Integer CurrentIndexOfElementarySpine() const;
Standard_EXPORT void Prepare (Standard_Real& L, Standard_Integer& Index) const;
- BRepAdaptor_Curve myCurve;
- BRepAdaptor_Curve myOffsetCurve;
+ Handle(BRepAdaptor_Curve) myCurve;
+ Handle(BRepAdaptor_Curve) myOffsetCurve;
Standard_Integer indexofcurve;
ChFiDS_TypeOfConcavity myTypeOfConcavity;
ChFiDS_State firstState;
GeomAbs_CurveType ctyp;
if (!Spine.IsNull())
- ctyp = Spine->CurrentElementarySpine(Iedge).GetType();
+ ctyp = Spine->CurrentElementarySpine(Iedge)->GetType();
else
- ctyp = CSpine->CurrentElementarySpine(Iedge).GetType();
+ ctyp = CSpine->CurrentElementarySpine(Iedge)->GetType();
// Return orientations.
TopAbs_Orientation OrFace1 = TopAbs_FORWARD, OrFace2 = TopAbs_FORWARD;
Box1OK = Standard_False;
}
else {
- BndLib_AddSurface::Add (*Surf, 1e-8, B1);
+ BndLib_AddSurface::Add (Surf, 1e-8, B1);
}
Standard_Real x0,y0,z0,x1,y1,z1,dx,dy,dz;
if(Box1OK) {
Standard_Real Tol = 1.e-5;
Standard_Real Dist2;
- Extrema_EPCOfExtPC2d extrema (P, *C, Nbu, epsX, Tol);
+ Extrema_EPCOfExtPC2d extrema (P, C, Nbu, epsX, Tol);
if (!extrema.IsDone()) {
return Standard_False;
}
static void PlotEdge (Draw_Display& dis,
Handle(DBRep_Edge)& E,
- const Adaptor3d_Curve& C,
+ const Handle(Adaptor3d_Curve)& C,
Standard_Real& f,
Standard_Real step,
Standard_Boolean& halt)
gp_Pnt Pl, Pr, Pm;
- C.D0(f, Pl);
- C.D0(f + step/2., Pm);
- C.D0(f + step, Pr);
+ C->D0(f, Pl);
+ C->D0(f + step/2., Pm);
+ C->D0(f + step, Pr);
if (PlotCount > MaxPlotCount) {
dis.DrawTo(Pr);
for (j = 1; j <= myDiscret/2; j++) {
Handle(DBRep_Edge) aLocaLEdge(E);
PlotCount = 0;
- PlotEdge (dis, aLocaLEdge, *HC, t, step*2., halt);
+ PlotEdge (dis, aLocaLEdge, HC, t, step*2., halt);
t += step*2.;
}
break;
Standard_Integer aNbE = anEdgePCurveMap.Extent();
for (Standard_Integer iE = 1; iE <= aNbE; ++iE)
{
- AddElement(Geom2dAdaptor_Curve(anEdgePCurveMap(iE)),
+ AddElement(new Geom2dAdaptor_Curve(anEdgePCurveMap(iE)),
anEdgePCurveMap.FindKey(iE).Orientation());
}
//-----------------------------------------------------------------------
for (IIso = 1 ; IIso <= NbIsos ; IIso++) {
myUPrm(IIso) = UPrm ;
gp_Pnt2d Ori (UPrm, 0.) ;
- Geom2dAdaptor_Curve HCur (new Geom2d_Line (Ori, Dir)) ;
+ Handle(Geom2dAdaptor_Curve) HCur = new Geom2dAdaptor_Curve(new Geom2d_Line (Ori, Dir)) ;
myUInd(IIso) = AddHatching (HCur) ;
UPrm += StepU ;
}
for (IIso = 1 ; IIso <= NbIsos ; IIso++) {
myVPrm(IIso) = VPrm ;
gp_Pnt2d Ori (0., VPrm) ;
- Geom2dAdaptor_Curve HCur (new Geom2d_Line (Ori, Dir)) ;
+ Handle(Geom2dAdaptor_Curve) HCur = new Geom2dAdaptor_Curve(new Geom2d_Line (Ori, Dir)) ;
myVInd(IIso) = AddHatching (HCur) ;
VPrm += StepV ;
}
// And, if they do interfere, avoid creation of the segment.
if (bAddSegment && !aPrevEdge.IsEqual(aCurrEdge))
{
- Geom2dAdaptor_Curve aPrevGC(aPrevC2d, fp, lp), aCurrGC(aCurrC2d, fc, lc);
+ Handle(Geom2dAdaptor_Curve) aPrevGC = new Geom2dAdaptor_Curve(aPrevC2d, fp, lp);
+ Handle(Geom2dAdaptor_Curve) aCurrGC = new Geom2dAdaptor_Curve(aCurrC2d, fc, lc);
Geom2dInt_GInter anInter(aPrevGC, aCurrGC, Precision::PConfusion(), Precision::PConfusion());
if (anInter.IsDone() && !anInter.IsEmpty())
{
// Add segment to the hatcher to trim the iso-lines
Handle(Geom2d_Line) aLine = new Geom2d_Line(aPrevP2d, aV2d);
Handle(Geom2d_TrimmedCurve) aLineSegm = new Geom2d_TrimmedCurve(aLine, 0.0, aSegmLen);
- AddElement(Geom2dAdaptor_Curve(aLineSegm), TopAbs_FORWARD);
+ AddElement(new Geom2dAdaptor_Curve(aLineSegm), TopAbs_FORWARD);
}
}
}
Draft_IndexedDataMapOfEdgeEdgeInfo&,
const TopoDS_Vertex&,
Draft_VertexInfo&,
- GeomAdaptor_Curve&,
- GeomAdaptor_Surface&);
+ const Handle(GeomAdaptor_Curve)&,
+ const Handle(GeomAdaptor_Surface)&);
static Standard_Real Parameter(const Handle(Geom_Curve)&,
const gp_Pnt&,
}
Standard_Real Glob2Min = RealLast();
- GeomAdaptor_Curve TheCurve;
+ Handle(GeomAdaptor_Curve) TheCurve = new GeomAdaptor_Curve();
Standard_Integer i,j; //,jmin;
Standard_Real Dist2Min = RealLast();
imin = 0;
for (i=1; i<= i2s.NbLines(); i++) {
- TheCurve.Load(i2s.Line(i));
+ TheCurve->Load(i2s.Line(i));
Extrema_ExtPC myExtPC(pfv,TheCurve);
Standard_Real locpmin = 0.;
myExtPC.TrimmedSquareDistances(dist1_2,dist2_2,p1b,p2b);
if (dist1_2 < dist2_2) {
Dist2Min = dist1_2;
- locpmin = TheCurve.FirstParameter();
+ locpmin = TheCurve->FirstParameter();
}
else {
Dist2Min = dist2_2;
- locpmin = TheCurve.LastParameter();
+ locpmin = TheCurve->LastParameter();
}
}
newC = Concat.BSplineCurve();
- TheCurve.Load( newC );
+ TheCurve->Load( newC );
Extrema_ExtPC myExtPC( pfv, TheCurve );
Standard_Real Dist2Min = RealLast();
for (i = 1; i <= myExtPC.NbExt(); i++)
// Calculate new vertices.
- Handle(GeomAdaptor_Curve) HAC = new GeomAdaptor_Curve;
- Handle(GeomAdaptor_Surface) HAS = new GeomAdaptor_Surface;
+ Handle(GeomAdaptor_Curve) HAC = new GeomAdaptor_Curve();
+ Handle(GeomAdaptor_Surface) HAS = new GeomAdaptor_Surface();
for (Standard_Integer ii = 1; ii <= myVMap.Extent(); ii++)
{
- GeomAdaptor_Curve& AC = *HAC;
- GeomAdaptor_Surface& AS = *HAS;
-
const TopoDS_Vertex& TVV = myVMap.FindKey(ii);
Draft_VertexInfo& Vinf = myVMap.ChangeFromIndex(ii);
- if (!Choose(myFMap,myEMap,TVV,Vinf,AC,AS)) {
+ if (!Choose(myFMap,myEMap,TVV,Vinf,HAC,HAS)) {
// no concerted edge => alignment of two consecutive edges.
gp_Pnt pvt;
Standard_Integer nbsol = myintcs.NbPoints();
if (nbsol <= 0)
{
- Extrema_ExtCS extr( AC, AS, Precision::PConfusion(), Precision::PConfusion() );
+ Extrema_ExtCS extr( HAC, HAS, Precision::PConfusion(), Precision::PConfusion() );
if(!extr.IsDone() || extr.NbExt() == 0) {
errStat = Draft_VertexRecomputation;
Draft_IndexedDataMapOfEdgeEdgeInfo& theEMap,
const TopoDS_Vertex& Vtx,
Draft_VertexInfo& Vinf,
- GeomAdaptor_Curve& AC,
- GeomAdaptor_Surface& AS)
+ const Handle(GeomAdaptor_Curve)& AC,
+ const Handle(GeomAdaptor_Surface)& AS)
{
gp_Vec tgref;
Vinf.InitEdgeIterator();
//const Draft_EdgeInfo& Einf = theEMap(Eref);
Draft_EdgeInfo& Einf = theEMap.ChangeFromKey(Eref);
- AC.Load(Einf.Geometry());
+ AC->Load(Einf.Geometry());
Standard_Real f,l,prm;
TopLoc_Location Loc;
if (Einf2.FirstFace().IsSame(Einf.FirstFace()) ||
Einf2.FirstFace().IsSame(Einf.SecondFace())) {
- AS.Load(theFMap.FindFromKey(Einf2.SecondFace()).Geometry());
+ AS->Load(theFMap.FindFromKey(Einf2.SecondFace()).Geometry());
}
else {
- AS.Load(theFMap.FindFromKey(Einf2.FirstFace()).Geometry());
+ AS->Load(theFMap.FindFromKey(Einf2.FirstFace()).Geometry());
}
}
else {
if (Einf2.FirstFace().IsSame(Einf.FirstFace())) {
- AS.Load(theFMap.FindFromKey(Einf2.SecondFace()).Geometry());
+ AS->Load(theFMap.FindFromKey(Einf2.SecondFace()).Geometry());
}
else {
- AS.Load(theFMap.FindFromKey(Einf2.FirstFace()).Geometry());
+ AS->Load(theFMap.FindFromKey(Einf2.FirstFace()).Geometry());
}
}
return Standard_True;
param = ElCLib::Parameter(Handle(Geom_Hyperbola)::DownCast(cbase)->Hypr(),P);
}
else {
- GeomAdaptor_Curve TheCurve(C);
+ Handle(GeomAdaptor_Curve) TheCurve = new GeomAdaptor_Curve(C);
Extrema_ExtPC myExtPC(P,TheCurve);
if (!myExtPC.IsDone()) {
throw Standard_Failure("Draft_Modification_1::Parameter: ExtremaPC not done.");
myExtPC.TrimmedSquareDistances(dist1_2,dist2_2,p1b,p2b);
if (dist1_2 < dist2_2) {
done = -1;
- param = TheCurve.FirstParameter();
+ param = TheCurve->FirstParameter();
}
else {
done = 1;
- param = TheCurve.LastParameter();
+ param = TheCurve->LastParameter();
}
}
Standard_Real vMoy = (vFirst + vLast)/2;
gp_Pnt curpos ;
surfAlgo.D0(uMoy, vMoy, curpos);
- const Handle(Geom_Surface)& surf = surfAlgo.Surface().Surface();
+ const Handle(Geom_Surface)& surf = surfAlgo.Surface()->Surface();
Handle(Geom_Curve) aCurve;
if (surf->DynamicType() == STANDARD_TYPE(Geom_ToroidalSurface)) {
aCurve = surf->UIso(uMoy);
Handle(GeomAdaptor_Surface) HS = new GeomAdaptor_Surface();
HS->Load(surf);
- Adaptor3d_IsoCurve C(HS);
+ Handle(Adaptor3d_IsoCurve) C = new Adaptor3d_IsoCurve(HS);
dis.SetColor(isosLook);
first = S->FirstUKnotIndex() + 1;
}
dis.SetColor (look);
- GeomAdaptor_Curve C(curv,First,Last);
+ Handle(GeomAdaptor_Curve) C = new GeomAdaptor_Curve(curv,First,Last);
DrawCurveOn(C,dis);
// mark the orientation
Draw_Bounds = Standard_False;
gp_Pnt P;
gp_Vec V;
- C.D1(Last,P,V);
+ C->D1(Last,P,V);
gp_Pnt2d p1,p2;
dis.Project(P,p1);
P.Translate(V);
Draw_Bounds = Standard_True;
}
// Draw the curvature Radius
- if (dispcurvradius && (C.GetType() != GeomAbs_Line)) {
+ if (dispcurvradius && (C->GetType() != GeomAbs_Line)) {
Standard_Integer ii;
- Standard_Integer intrv, nbintv = C.NbIntervals(GeomAbs_CN);
+ Standard_Integer intrv, nbintv = C->NbIntervals(GeomAbs_CN);
TColStd_Array1OfReal TI(1,nbintv+1);
- C.Intervals(TI,GeomAbs_CN);
+ C->Intervals(TI,GeomAbs_CN);
Standard_Real Resolution = 1.0e-9, Curvature;
GeomLProp_CLProps LProp(curv, 2, Resolution);
gp_Pnt P1, P2;
dis.SetColor (look);
- Geom2dAdaptor_Curve C2d(curv,First,Last);
+ Handle(Geom2dAdaptor_Curve) C2d = new Geom2dAdaptor_Curve(curv,First,Last);
DrawCurve2dOn (C2d, dis);
// mark the origin
Draw_Bounds = Standard_False;
gp_Pnt2d p1,p2;
gp_Vec2d v;
- C2d.D1(Last,p1,v);
+ C2d->D1(Last,p1,v);
if (v.Magnitude() > gp::Resolution()) {
Standard_Real L = 20 / dis.Zoom();
Standard_Real H = 10 / dis.Zoom();
}
// Draw the curvature Radius
- if (dispcurvradius && (C2d.GetType() != GeomAbs_Line)) {
+ if (dispcurvradius && (C2d->GetType() != GeomAbs_Line)) {
Standard_Integer ii;
- Standard_Integer intrv, nbintv = C2d.NbIntervals(GeomAbs_CN);
+ Standard_Integer intrv, nbintv = C2d->NbIntervals(GeomAbs_CN);
TColStd_Array1OfReal TI(1,nbintv+1);
- C2d.Intervals(TI,GeomAbs_CN);
+ C2d->Intervals(TI,GeomAbs_CN);
Standard_Real Resolution = 1.0e-9, Curvature;
Geom2dLProp_CLProps2d LProp(curv, 2, Resolution);
gp_Pnt2d P1, P2;
//purpose : draw a 2D curve
//=======================================================================
-void DrawTrSurf_Drawable::DrawCurve2dOn (Adaptor2d_Curve2d& C,
+void DrawTrSurf_Drawable::DrawCurve2dOn (const Handle(Adaptor2d_Curve2d)& C,
Draw_Display& aDisplay) const
{
gp_Pnt P;
}
}
else {
- Standard_Integer intrv, nbintv = C.NbIntervals(GeomAbs_CN);
+ Standard_Integer intrv, nbintv = C->NbIntervals(GeomAbs_CN);
TColStd_Array1OfReal TI(1,nbintv+1);
- C.Intervals(TI,GeomAbs_CN);
- C.D0(C.FirstParameter(),aPoint2d);
+ C->Intervals(TI,GeomAbs_CN);
+ C->D0(C->FirstParameter(),aPoint2d);
aDisplay.MoveTo(aPoint2d);
for (intrv = 1; intrv <= nbintv; intrv++) {
- if (C.GetType() != GeomAbs_Line) {
+ if (C->GetType() != GeomAbs_Line) {
Standard_Real t = TI(intrv);
Standard_Real step = (TI(intrv+1) - t) / myDiscret;
for (Standard_Integer i = 1; i < myDiscret; i++) {
t += step;
- C.D0(t,aPoint2d);
+ C->D0(t,aPoint2d);
aDisplay.DrawTo(aPoint2d);
}
}
- C.D0(TI(intrv+1),aPoint2d);
+ C->D0(TI(intrv+1),aPoint2d);
aDisplay.DrawTo(aPoint2d);
}
}
//purpose : draw a 3D curve
//=======================================================================
static void PlotCurve (Draw_Display& aDisplay,
- const Adaptor3d_Curve& C,
+ const Handle(Adaptor3d_Curve)& C,
Standard_Real& theFirstParam,
Standard_Real theHalfStep,
const gp_Pnt& theFirstPnt,
Standard_Real IsoRatio = 1.001;
gp_Pnt Pm;
- C.D0 (theFirstParam + theHalfStep, Pm);
+ C->D0 (theFirstParam + theHalfStep, Pm);
Standard_Real dfLength = theFirstPnt.Distance(theLastPnt);
if (dfLength < Precision::Confusion() ||
//purpose : draw a 3D curve
//=======================================================================
-void DrawTrSurf_Drawable::DrawCurveOn (Adaptor3d_Curve& C,
+void DrawTrSurf_Drawable::DrawCurveOn (const Handle(Adaptor3d_Curve)& C,
Draw_Display& aDisplay) const
{
gp_Pnt P;
else
{
Standard_Integer j;
- Standard_Integer intrv, nbintv = C.NbIntervals(GeomAbs_CN);
+ Standard_Integer intrv, nbintv = C->NbIntervals(GeomAbs_CN);
TColStd_Array1OfReal TI(1,nbintv+1);
- C.Intervals(TI,GeomAbs_CN);
- C.D0(C.FirstParameter(),P);
+ C->Intervals(TI,GeomAbs_CN);
+ C->D0(C->FirstParameter(),P);
aDisplay.MoveTo(P);
- GeomAbs_CurveType CurvType = C.GetType();
+ GeomAbs_CurveType CurvType = C->GetType();
gp_Pnt aPPnt=P, aNPnt;
for (intrv = 1; intrv <= nbintv; intrv++)
for (j = 1; j < myDiscret; j++)
{
t += step;
- C.D0(t,P);
+ C->D0(t,P);
aDisplay.DrawTo(P);
}
break;
for (j = 1; j < nIter; j++)
{
const Standard_Real t1 = t+step*2.;
- C.D0 (t1, aNPnt);
+ C->D0 (t1, aNPnt);
PlotCurve (aDisplay, C, t, step, aPPnt, aNPnt);
aPPnt = aNPnt;
t = t1;
break;
}
- C.D0(TI(intrv+1),P);
+ C->D0(TI(intrv+1),P);
PlotCurve (aDisplay, C, t, step, aPPnt, P);
aDisplay.DrawTo(P);
}
//purpose :
//=======================================================================
-void DrawTrSurf_Drawable::DrawIsoCurveOn(Adaptor3d_IsoCurve& C,
+void DrawTrSurf_Drawable::DrawIsoCurveOn(const Handle(Adaptor3d_IsoCurve)& C,
const GeomAbs_IsoType T,
const Standard_Real P,
const Standard_Real F,
const Standard_Real L,
Draw_Display& dis) const
{
- C.Load(T,P,F,L);
- if ((C.GetType() == GeomAbs_BezierCurve) ||
- (C.GetType() == GeomAbs_BSplineCurve)) {
- GeomAdaptor_Curve GC;
- if (C.GetType() == GeomAbs_BezierCurve)
- GC.Load(C.Bezier(),F,L);
+ C->Load(T,P,F,L);
+ if ((C->GetType() == GeomAbs_BezierCurve) ||
+ (C->GetType() == GeomAbs_BSplineCurve)) {
+ Handle(GeomAdaptor_Curve) GC = new GeomAdaptor_Curve();
+ if (C->GetType() == GeomAbs_BezierCurve)
+ GC->Load(C->Bezier(),F,L);
else
- GC.Load(C.BSpline(),F,L);
+ GC->Load(C->BSpline(),F,L);
DrawCurveOn(GC,dis);
}
public:
//! Draw a polygon of the curve on the Display
- Standard_EXPORT void DrawCurve2dOn (Adaptor2d_Curve2d& C, Draw_Display& D) const;
+ Standard_EXPORT void DrawCurve2dOn (const Handle(Adaptor2d_Curve2d)& C, Draw_Display& D) const;
//! Draw a polygon of the curve on the Display
- Standard_EXPORT void DrawCurveOn (Adaptor3d_Curve& C, Draw_Display& D) const;
+ Standard_EXPORT void DrawCurveOn (const Handle(Adaptor3d_Curve)& C, Draw_Display& D) const;
//! Load C with the specified iso and Draw a polygon
//! of the curve on the Display
- Standard_EXPORT void DrawIsoCurveOn (Adaptor3d_IsoCurve& C, const GeomAbs_IsoType T, const Standard_Real P, const Standard_Real F, const Standard_Real L, Draw_Display& D) const;
+ Standard_EXPORT void DrawIsoCurveOn (const Handle(Adaptor3d_IsoCurve)& C, const GeomAbs_IsoType T, const Standard_Real P, const Standard_Real F, const Standard_Real L, Draw_Display& D) const;
//! this is defined only to tell C++ not to complain
//! about inheriting a pure virtual method.
Handle(GeomAdaptor_Surface) HS = new GeomAdaptor_Surface();
HS->Load(surf,UFirst,ULast,VFirst,VLast);
- Adaptor3d_IsoCurve C(HS);
+ Handle(Adaptor3d_IsoCurve) C = new Adaptor3d_IsoCurve(HS);
if (Iso) {
dis.SetColor(isosLook);
Standard_EXPORT Extrema_CCLocFOfLocECC(const Standard_Real thetol = 1.0e-10);
- Standard_EXPORT Extrema_CCLocFOfLocECC(const Adaptor3d_Curve& C1, const Adaptor3d_Curve& C2, const Standard_Real thetol = 1.0e-10);
+ Standard_EXPORT Extrema_CCLocFOfLocECC(const Handle(Adaptor3d_Curve)& C1, const Handle(Adaptor3d_Curve)& C2, const Standard_Real thetol = 1.0e-10);
- Standard_EXPORT void SetCurve (const Standard_Integer theRank, const Adaptor3d_Curve& C1);
+ Standard_EXPORT void SetCurve (const Standard_Integer theRank, const Handle(Adaptor3d_Curve)& C1);
void SetTolerance (const Standard_Real theTol);
};
-#define Curve1 Adaptor3d_Curve
+#define Curve1 Handle(Adaptor3d_Curve)
#define Curve1_hxx <Adaptor3d_Curve.hxx>
#define Tool1 Extrema_CurveTool
#define Tool1_hxx <Extrema_CurveTool.hxx>
-#define Curve2 Adaptor3d_Curve
+#define Curve2 Handle(Adaptor3d_Curve)
#define Curve2_hxx <Adaptor3d_Curve.hxx>
#define Tool2 Extrema_CurveTool
#define Tool2_hxx <Extrema_CurveTool.hxx>
Standard_EXPORT Extrema_CCLocFOfLocECC2d(const Standard_Real thetol = 1.0e-10);
- Standard_EXPORT Extrema_CCLocFOfLocECC2d(const Adaptor2d_Curve2d& C1, const Adaptor2d_Curve2d& C2, const Standard_Real thetol = 1.0e-10);
+ Standard_EXPORT Extrema_CCLocFOfLocECC2d(const Handle(Adaptor2d_Curve2d)& C1, const Handle(Adaptor2d_Curve2d)& C2, const Standard_Real thetol = 1.0e-10);
- Standard_EXPORT void SetCurve (const Standard_Integer theRank, const Adaptor2d_Curve2d& C1);
+ Standard_EXPORT void SetCurve (const Standard_Integer theRank, const Handle(Adaptor2d_Curve2d)& C1);
void SetTolerance (const Standard_Real theTol);
};
-#define Curve1 Adaptor2d_Curve2d
+#define Curve1 Handle(Adaptor2d_Curve2d)
#define Curve1_hxx <Adaptor2d_Curve2d.hxx>
#define Tool1 Extrema_Curve2dTool
#define Tool1_hxx <Extrema_Curve2dTool.hxx>
-#define Curve2 Adaptor2d_Curve2d
+#define Curve2 Handle(Adaptor2d_Curve2d)
#define Curve2_hxx <Adaptor2d_Curve2d.hxx>
#define Tool2 Extrema_Curve2dTool
#define Tool2_hxx <Extrema_Curve2dTool.hxx>
#include <math_Matrix.hxx>
-#define Curve1 Adaptor2d_Curve2d
+#define Curve1 Handle(Adaptor2d_Curve2d)
#define Curve1_hxx <Adaptor2d_Curve2d.hxx>
#define Tool1 Extrema_Curve2dTool
#define Tool1_hxx <Extrema_Curve2dTool.hxx>
-#define Curve2 Adaptor2d_Curve2d
+#define Curve2 Handle(Adaptor2d_Curve2d)
#define Curve2_hxx <Adaptor2d_Curve2d.hxx>
#define Tool2 Extrema_Curve2dTool
#define Tool2_hxx <Extrema_Curve2dTool.hxx>
#include <math_Matrix.hxx>
-#define Curve1 Adaptor3d_Curve
+#define Curve1 Handle(Adaptor3d_Curve)
#define Curve1_hxx <Adaptor3d_Curve.hxx>
#define Tool1 Extrema_CurveTool
#define Tool1_hxx <Extrema_CurveTool.hxx>
-#define Curve2 Adaptor3d_Curve
+#define Curve2 Handle(Adaptor3d_Curve)
#define Curve2_hxx <Adaptor3d_Curve.hxx>
#define Tool2 Extrema_CurveTool
#define Tool2_hxx <Extrema_CurveTool.hxx>
//purpose :
//=======================================================================
Handle(TColStd_HArray1OfReal)
- Extrema_Curve2dTool::DeflCurvIntervals(const Adaptor2d_Curve2d& C)
+ Extrema_Curve2dTool::DeflCurvIntervals(const Handle(Adaptor2d_Curve2d)& C)
{
const Standard_Real epsd = 1.e-3;
const Standard_Real maxdefl = 1.e3;
Handle(TColStd_HArray1OfReal) Intervals;
Standard_Integer nbpnts = 23, i;
Standard_Real L = 0.;
- Standard_Real tf = C.FirstParameter(), tl = C.LastParameter();
- gp_Pnt2d aP = C.Value(tf);
+ Standard_Real tf = C->FirstParameter(), tl = C->LastParameter();
+ gp_Pnt2d aP = C->Value(tf);
for (i = 2; i <= nbpnts; ++i)
{
Standard_Real t = (tf * (nbpnts - i) + (i - 1) * tl) / (nbpnts - 1);
- gp_Pnt2d aP1 = C.Value(t);
+ gp_Pnt2d aP1 = C->Value(t);
L += aP.Distance(aP1);
}
//
DEFINE_STANDARD_ALLOC
- static Standard_Real FirstParameter (const Adaptor2d_Curve2d& C);
+ static Standard_Real FirstParameter (const Handle(Adaptor2d_Curve2d)& C);
- static Standard_Real LastParameter (const Adaptor2d_Curve2d& C);
+ static Standard_Real LastParameter (const Handle(Adaptor2d_Curve2d)& C);
- static GeomAbs_Shape Continuity (const Adaptor2d_Curve2d& C);
+ static GeomAbs_Shape Continuity (const Handle(Adaptor2d_Curve2d)& C);
//! If necessary, breaks the curve in intervals of
//! continuity <S>. And returns the number of
//! intervals.
- static Standard_Integer NbIntervals (const Adaptor2d_Curve2d& C, const GeomAbs_Shape S);
+ static Standard_Integer NbIntervals (const Handle(Adaptor2d_Curve2d)& C, const GeomAbs_Shape S);
//! Stores in <T> the parameters bounding the intervals
//! of continuity <S>.
- static void Intervals (const Adaptor2d_Curve2d& C, TColStd_Array1OfReal& T, const GeomAbs_Shape S);
+ static void Intervals (const Handle(Adaptor2d_Curve2d)& C, TColStd_Array1OfReal& T, const GeomAbs_Shape S);
//! Returns the parameters bounding the intervals of subdivision of curve
//! according to Curvature deflection. Value of deflection is defined in method.
//!
- Standard_EXPORT static Handle(TColStd_HArray1OfReal) DeflCurvIntervals(const Adaptor2d_Curve2d& C);
+ Standard_EXPORT static Handle(TColStd_HArray1OfReal) DeflCurvIntervals(const Handle(Adaptor2d_Curve2d)& C);
- static Standard_Boolean IsClosed (const Adaptor2d_Curve2d& C);
+ static Standard_Boolean IsClosed (const Handle(Adaptor2d_Curve2d)& C);
- static Standard_Boolean IsPeriodic (const Adaptor2d_Curve2d& C);
+ static Standard_Boolean IsPeriodic (const Handle(Adaptor2d_Curve2d)& C);
- static Standard_Real Period (const Adaptor2d_Curve2d& C);
+ static Standard_Real Period (const Handle(Adaptor2d_Curve2d)& C);
//! Computes the point of parameter U on the curve.
- static gp_Pnt2d Value (const Adaptor2d_Curve2d& C, const Standard_Real U);
+ static gp_Pnt2d Value (const Handle(Adaptor2d_Curve2d)& C, const Standard_Real U);
//! Computes the point of parameter U on the curve.
- static void D0 (const Adaptor2d_Curve2d& C, const Standard_Real U, gp_Pnt2d& P);
+ static void D0 (const Handle(Adaptor2d_Curve2d)& C, const Standard_Real U, gp_Pnt2d& P);
//! Computes the point of parameter U on the curve with its
//! first derivative.
- static void D1 (const Adaptor2d_Curve2d& C, const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& V);
+ static void D1 (const Handle(Adaptor2d_Curve2d)& C, const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& V);
//! Returns the point P of parameter U, the first and second
//! derivatives V1 and V2.
- static void D2 (const Adaptor2d_Curve2d& C, const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& V1, gp_Vec2d& V2);
+ static void D2 (const Handle(Adaptor2d_Curve2d)& C, const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& V1, gp_Vec2d& V2);
//! Returns the point P of parameter U, the first, the second
//! and the third derivative.
- static void D3 (const Adaptor2d_Curve2d& C, const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& V1, gp_Vec2d& V2, gp_Vec2d& V3);
+ static void D3 (const Handle(Adaptor2d_Curve2d)& C, const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& V1, gp_Vec2d& V2, gp_Vec2d& V3);
//! The returned vector gives the value of the derivative for the
//! order of derivation N.
- static gp_Vec2d DN (const Adaptor2d_Curve2d& C, const Standard_Real U, const Standard_Integer N);
+ static gp_Vec2d DN (const Handle(Adaptor2d_Curve2d)& C, const Standard_Real U, const Standard_Integer N);
//! Returns the parametric resolution corresponding
//! to the real space resolution <R3d>.
- static Standard_Real Resolution (const Adaptor2d_Curve2d& C, const Standard_Real R3d);
+ static Standard_Real Resolution (const Handle(Adaptor2d_Curve2d)& C, const Standard_Real R3d);
//! Returns the type of the curve in the current
//! interval : Line, Circle, Ellipse, Hyperbola,
//! Parabola, BezierCurve, BSplineCurve, OtherCurve.
- static GeomAbs_CurveType GetType (const Adaptor2d_Curve2d& C);
+ static GeomAbs_CurveType GetType (const Handle(Adaptor2d_Curve2d)& C);
- static gp_Lin2d Line (const Adaptor2d_Curve2d& C);
+ static gp_Lin2d Line (const Handle(Adaptor2d_Curve2d)& C);
- static gp_Circ2d Circle (const Adaptor2d_Curve2d& C);
+ static gp_Circ2d Circle (const Handle(Adaptor2d_Curve2d)& C);
- static gp_Elips2d Ellipse (const Adaptor2d_Curve2d& C);
+ static gp_Elips2d Ellipse (const Handle(Adaptor2d_Curve2d)& C);
- static gp_Hypr2d Hyperbola (const Adaptor2d_Curve2d& C);
+ static gp_Hypr2d Hyperbola (const Handle(Adaptor2d_Curve2d)& C);
- static gp_Parab2d Parabola (const Adaptor2d_Curve2d& C);
+ static gp_Parab2d Parabola (const Handle(Adaptor2d_Curve2d)& C);
- static Standard_Integer Degree (const Adaptor2d_Curve2d& C);
+ static Standard_Integer Degree (const Handle(Adaptor2d_Curve2d)& C);
- static Standard_Boolean IsRational (const Adaptor2d_Curve2d& C);
+ static Standard_Boolean IsRational (const Handle(Adaptor2d_Curve2d)& C);
- static Standard_Integer NbPoles (const Adaptor2d_Curve2d& C);
+ static Standard_Integer NbPoles (const Handle(Adaptor2d_Curve2d)& C);
- static Standard_Integer NbKnots (const Adaptor2d_Curve2d& C);
+ static Standard_Integer NbKnots (const Handle(Adaptor2d_Curve2d)& C);
- static Handle(Geom2d_BezierCurve) Bezier (const Adaptor2d_Curve2d& C);
+ static Handle(Geom2d_BezierCurve) Bezier (const Handle(Adaptor2d_Curve2d)& C);
- static Handle(Geom2d_BSplineCurve) BSpline (const Adaptor2d_Curve2d& C);
+ static Handle(Geom2d_BSplineCurve) BSpline (const Handle(Adaptor2d_Curve2d)& C);
//purpose :
//=======================================================================
-inline Standard_Real Extrema_Curve2dTool::FirstParameter(const Adaptor2d_Curve2d& C)
+inline Standard_Real Extrema_Curve2dTool::FirstParameter(const Handle(Adaptor2d_Curve2d)& C)
{
- return C.FirstParameter();
+ return C->FirstParameter();
}
//=======================================================================
//purpose :
//=======================================================================
- inline Standard_Real Extrema_Curve2dTool::LastParameter(const Adaptor2d_Curve2d& C)
+ inline Standard_Real Extrema_Curve2dTool::LastParameter(const Handle(Adaptor2d_Curve2d)& C)
{
- return C.LastParameter();
+ return C->LastParameter();
}
//=======================================================================
//purpose :
//=======================================================================
- inline GeomAbs_Shape Extrema_Curve2dTool::Continuity(const Adaptor2d_Curve2d& C)
+ inline GeomAbs_Shape Extrema_Curve2dTool::Continuity(const Handle(Adaptor2d_Curve2d)& C)
{
- return C.Continuity();
+ return C->Continuity();
}
//=======================================================================
//purpose :
//=======================================================================
- inline Standard_Integer Extrema_Curve2dTool::NbIntervals(const Adaptor2d_Curve2d& C,
+ inline Standard_Integer Extrema_Curve2dTool::NbIntervals(const Handle(Adaptor2d_Curve2d)& C,
const GeomAbs_Shape S)
{
- return C.NbIntervals(S);
+ return C->NbIntervals(S);
}
//=======================================================================
//purpose :
//=======================================================================
- inline void Extrema_Curve2dTool::Intervals(const Adaptor2d_Curve2d& C,
+ inline void Extrema_Curve2dTool::Intervals(const Handle(Adaptor2d_Curve2d)& C,
TColStd_Array1OfReal& T,
const GeomAbs_Shape S)
{
- C.Intervals(T, S);
+ C->Intervals(T, S);
}
//=======================================================================
//purpose :
//=======================================================================
- inline Standard_Boolean Extrema_Curve2dTool::IsClosed(const Adaptor2d_Curve2d& C)
+ inline Standard_Boolean Extrema_Curve2dTool::IsClosed(const Handle(Adaptor2d_Curve2d)& C)
{
- return C.IsClosed();
+ return C->IsClosed();
}
//=======================================================================
//purpose :
//=======================================================================
- inline Standard_Boolean Extrema_Curve2dTool::IsPeriodic(const Adaptor2d_Curve2d& C)
+ inline Standard_Boolean Extrema_Curve2dTool::IsPeriodic(const Handle(Adaptor2d_Curve2d)& C)
{
- return C.IsPeriodic();
+ return C->IsPeriodic();
}
//=======================================================================
//purpose :
//=======================================================================
- inline Standard_Real Extrema_Curve2dTool::Period(const Adaptor2d_Curve2d& C)
+ inline Standard_Real Extrema_Curve2dTool::Period(const Handle(Adaptor2d_Curve2d)& C)
{
- return C.Period();
+ return C->Period();
}
//=======================================================================
//purpose :
//=======================================================================
- inline gp_Pnt2d Extrema_Curve2dTool::Value(const Adaptor2d_Curve2d& C,
+ inline gp_Pnt2d Extrema_Curve2dTool::Value(const Handle(Adaptor2d_Curve2d)& C,
const Standard_Real U)
{
- return C.Value(U);
+ return C->Value(U);
}
//=======================================================================
//purpose :
//=======================================================================
-inline void Extrema_Curve2dTool::D0(const Adaptor2d_Curve2d& C,
+inline void Extrema_Curve2dTool::D0(const Handle(Adaptor2d_Curve2d)& C,
const Standard_Real U,
gp_Pnt2d& P)
{
- C.D0(U, P);
+ C->D0(U, P);
}
//=======================================================================
//purpose :
//=======================================================================
- inline void Extrema_Curve2dTool::D1(const Adaptor2d_Curve2d& C,
+ inline void Extrema_Curve2dTool::D1(const Handle(Adaptor2d_Curve2d)& C,
const Standard_Real U,
gp_Pnt2d& P,
gp_Vec2d& V)
{
- C.D1(U, P, V);
+ C->D1(U, P, V);
}
//=======================================================================
//purpose :
//=======================================================================
-inline void Extrema_Curve2dTool::D2(const Adaptor2d_Curve2d& C,
+inline void Extrema_Curve2dTool::D2(const Handle(Adaptor2d_Curve2d)& C,
const Standard_Real U,
gp_Pnt2d& P,
gp_Vec2d& V1,
gp_Vec2d& V2)
{
- C.D2(U, P, V1, V2);
+ C->D2(U, P, V1, V2);
}
//=======================================================================
//purpose :
//=======================================================================
- inline void Extrema_Curve2dTool::D3(const Adaptor2d_Curve2d& C,
+ inline void Extrema_Curve2dTool::D3(const Handle(Adaptor2d_Curve2d)& C,
const Standard_Real U,
gp_Pnt2d& P,
gp_Vec2d& V1,
gp_Vec2d& V2,
gp_Vec2d& V3)
{
- C.D3(U, P, V1, V2, V3);
+ C->D3(U, P, V1, V2, V3);
}
//=======================================================================
//purpose :
//=======================================================================
- inline gp_Vec2d Extrema_Curve2dTool::DN(const Adaptor2d_Curve2d& C,
+ inline gp_Vec2d Extrema_Curve2dTool::DN(const Handle(Adaptor2d_Curve2d)& C,
const Standard_Real U,
const Standard_Integer N)
{
- return C.DN(U, N);
+ return C->DN(U, N);
}
//=======================================================================
//purpose :
//=======================================================================
- inline Standard_Real Extrema_Curve2dTool::Resolution(const Adaptor2d_Curve2d& C,
+ inline Standard_Real Extrema_Curve2dTool::Resolution(const Handle(Adaptor2d_Curve2d)& C,
const Standard_Real R3d)
{
- return C.Resolution(R3d);
+ return C->Resolution(R3d);
}
//=======================================================================
//purpose :
//=======================================================================
- inline GeomAbs_CurveType Extrema_Curve2dTool::GetType(const Adaptor2d_Curve2d& C)
+ inline GeomAbs_CurveType Extrema_Curve2dTool::GetType(const Handle(Adaptor2d_Curve2d)& C)
{
- return C.GetType();
+ return C->GetType();
}
//=======================================================================
//purpose :
//=======================================================================
- inline gp_Lin2d Extrema_Curve2dTool::Line(const Adaptor2d_Curve2d& C)
+ inline gp_Lin2d Extrema_Curve2dTool::Line(const Handle(Adaptor2d_Curve2d)& C)
{
- return C.Line();
+ return C->Line();
}
//=======================================================================
//purpose :
//=======================================================================
- inline gp_Circ2d Extrema_Curve2dTool::Circle(const Adaptor2d_Curve2d& C)
+ inline gp_Circ2d Extrema_Curve2dTool::Circle(const Handle(Adaptor2d_Curve2d)& C)
{
- return C.Circle();
+ return C->Circle();
}
//=======================================================================
//purpose :
//=======================================================================
- inline gp_Elips2d Extrema_Curve2dTool::Ellipse(const Adaptor2d_Curve2d& C)
+ inline gp_Elips2d Extrema_Curve2dTool::Ellipse(const Handle(Adaptor2d_Curve2d)& C)
{
- return C.Ellipse();
+ return C->Ellipse();
}
//=======================================================================
//purpose :
//=======================================================================
- inline gp_Hypr2d Extrema_Curve2dTool::Hyperbola(const Adaptor2d_Curve2d& C)
+ inline gp_Hypr2d Extrema_Curve2dTool::Hyperbola(const Handle(Adaptor2d_Curve2d)& C)
{
- return C.Hyperbola();
+ return C->Hyperbola();
}
//=======================================================================
//purpose :
//=======================================================================
- inline gp_Parab2d Extrema_Curve2dTool::Parabola(const Adaptor2d_Curve2d& C)
+ inline gp_Parab2d Extrema_Curve2dTool::Parabola(const Handle(Adaptor2d_Curve2d)& C)
{
- return C.Parabola();
+ return C->Parabola();
}
//=======================================================================
//purpose :
//=======================================================================
- inline Standard_Integer Extrema_Curve2dTool::NbPoles(const Adaptor2d_Curve2d& C)
+ inline Standard_Integer Extrema_Curve2dTool::NbPoles(const Handle(Adaptor2d_Curve2d)& C)
{
- return C.NbPoles();
+ return C->NbPoles();
}
//=======================================================================
//purpose :
//=======================================================================
- inline Standard_Integer Extrema_Curve2dTool::Degree(const Adaptor2d_Curve2d& C)
+ inline Standard_Integer Extrema_Curve2dTool::Degree(const Handle(Adaptor2d_Curve2d)& C)
{
- return C.Degree();
+ return C->Degree();
}
//=======================================================================
//purpose :
//=======================================================================
-inline Standard_Boolean Extrema_Curve2dTool::IsRational(const Adaptor2d_Curve2d& C)
+inline Standard_Boolean Extrema_Curve2dTool::IsRational(const Handle(Adaptor2d_Curve2d)& C)
{
- return C.Degree() != 0;
+ return C->Degree() != 0;
}
//purpose :
//=======================================================================
- inline Standard_Integer Extrema_Curve2dTool::NbKnots(const Adaptor2d_Curve2d& C)
+ inline Standard_Integer Extrema_Curve2dTool::NbKnots(const Handle(Adaptor2d_Curve2d)& C)
{
- return C.NbKnots();
+ return C->NbKnots();
}
//=======================================================================
//purpose :
//=======================================================================
- inline Handle(Geom2d_BezierCurve) Extrema_Curve2dTool::Bezier(const Adaptor2d_Curve2d& C)
+ inline Handle(Geom2d_BezierCurve) Extrema_Curve2dTool::Bezier(const Handle(Adaptor2d_Curve2d)& C)
{
- return C.Bezier();
+ return C->Bezier();
}
//=======================================================================
//purpose :
//=======================================================================
- inline Handle(Geom2d_BSplineCurve) Extrema_Curve2dTool::BSpline(const Adaptor2d_Curve2d& C)
+ inline Handle(Geom2d_BSplineCurve) Extrema_Curve2dTool::BSpline(const Handle(Adaptor2d_Curve2d)& C)
{
- return C.BSpline();
+ return C->BSpline();
}
//function : IsPeriodic
//purpose :
//=======================================================================
-Standard_Boolean Extrema_CurveTool::IsPeriodic(const Adaptor3d_Curve& C)
+Standard_Boolean Extrema_CurveTool::IsPeriodic(const Handle(Adaptor3d_Curve)& C)
{
GeomAbs_CurveType aType = GetType(C);
if (aType == GeomAbs_Circle ||
aType == GeomAbs_Ellipse)
return Standard_True;
else
- return C.IsPeriodic();
+ return C->IsPeriodic();
}
//=======================================================================
//purpose :
//=======================================================================
Handle(TColStd_HArray1OfReal)
-Extrema_CurveTool::DeflCurvIntervals(const Adaptor3d_Curve& C)
+Extrema_CurveTool::DeflCurvIntervals(const Handle(Adaptor3d_Curve)& C)
{
const Standard_Real epsd = 1.e-3;
const Standard_Real maxdefl = 1.e3;
Handle(TColStd_HArray1OfReal) Intervals;
Standard_Integer nbpnts = 23, i;
Standard_Real L = 0.;
- Standard_Real tf = C.FirstParameter(), tl = C.LastParameter();
- gp_Pnt aP = C.Value(tf);
+ Standard_Real tf = C->FirstParameter(), tl = C->LastParameter();
+ gp_Pnt aP = C->Value(tf);
for (i = 2; i <= nbpnts; ++i)
{
Standard_Real t = (tf * (nbpnts - i) + (i - 1) * tl) / (nbpnts - 1);
- gp_Pnt aP1 = C.Value(t);
+ gp_Pnt aP1 = C->Value(t);
L += aP.Distance(aP1);
}
//
DEFINE_STANDARD_ALLOC
- static Standard_Real FirstParameter (const Adaptor3d_Curve& C);
+ static Standard_Real FirstParameter (const Handle(Adaptor3d_Curve)& C);
- static Standard_Real LastParameter (const Adaptor3d_Curve& C);
+ static Standard_Real LastParameter (const Handle(Adaptor3d_Curve)& C);
- static GeomAbs_Shape Continuity (const Adaptor3d_Curve& C);
+ static GeomAbs_Shape Continuity (const Handle(Adaptor3d_Curve)& C);
//! Returns the number of intervals for continuity
//! <S>. May be one if Continuity(me) >= <S>
- static Standard_Integer NbIntervals (Adaptor3d_Curve& C, const GeomAbs_Shape S);
+ static Standard_Integer NbIntervals (Handle(Adaptor3d_Curve)& C, const GeomAbs_Shape S);
//! Stores in <T> the parameters bounding the intervals
//! of continuity <S>.
//!
//! The array must provide enough room to accommodate
//! for the parameters. i.e. T.Length() > NbIntervals()
- static void Intervals (Adaptor3d_Curve& C, TColStd_Array1OfReal& T, const GeomAbs_Shape S);
+ static void Intervals (Handle(Adaptor3d_Curve)& C, TColStd_Array1OfReal& T, const GeomAbs_Shape S);
//! Returns the parameters bounding the intervals of subdivision of curve
//! according to Curvature deflection. Value of deflection is defined in method.
//!
- Standard_EXPORT static Handle(TColStd_HArray1OfReal) DeflCurvIntervals(const Adaptor3d_Curve& C);
+ Standard_EXPORT static Handle(TColStd_HArray1OfReal) DeflCurvIntervals(const Handle(Adaptor3d_Curve)& C);
- Standard_EXPORT static Standard_Boolean IsPeriodic (const Adaptor3d_Curve& C);
+ Standard_EXPORT static Standard_Boolean IsPeriodic (const Handle(Adaptor3d_Curve)& C);
- static Standard_Real Period (const Adaptor3d_Curve& C);
+ static Standard_Real Period (const Handle(Adaptor3d_Curve)& C);
- static Standard_Real Resolution (const Adaptor3d_Curve& C, const Standard_Real R3d);
+ static Standard_Real Resolution (const Handle(Adaptor3d_Curve)& C, const Standard_Real R3d);
- static GeomAbs_CurveType GetType (const Adaptor3d_Curve& C);
+ static GeomAbs_CurveType GetType (const Handle(Adaptor3d_Curve)& C);
- static gp_Pnt Value (const Adaptor3d_Curve& C, const Standard_Real U);
+ static gp_Pnt Value (const Handle(Adaptor3d_Curve)& C, const Standard_Real U);
- static void D0 (const Adaptor3d_Curve& C, const Standard_Real U, gp_Pnt& P);
+ static void D0 (const Handle(Adaptor3d_Curve)& C, const Standard_Real U, gp_Pnt& P);
- static void D1 (const Adaptor3d_Curve& C, const Standard_Real U, gp_Pnt& P, gp_Vec& V);
+ static void D1 (const Handle(Adaptor3d_Curve)& C, const Standard_Real U, gp_Pnt& P, gp_Vec& V);
- static void D2 (const Adaptor3d_Curve& C, const Standard_Real U, gp_Pnt& P, gp_Vec& V1, gp_Vec& V2);
+ static void D2 (const Handle(Adaptor3d_Curve)& C, const Standard_Real U, gp_Pnt& P, gp_Vec& V1, gp_Vec& V2);
- static void D3 (const Adaptor3d_Curve& C, const Standard_Real U, gp_Pnt& P, gp_Vec& V1, gp_Vec& V2, gp_Vec& V3);
+ static void D3 (const Handle(Adaptor3d_Curve)& C, const Standard_Real U, gp_Pnt& P, gp_Vec& V1, gp_Vec& V2, gp_Vec& V3);
- static gp_Vec DN (const Adaptor3d_Curve& C, const Standard_Real U, const Standard_Integer N);
+ static gp_Vec DN (const Handle(Adaptor3d_Curve)& C, const Standard_Real U, const Standard_Integer N);
- static gp_Lin Line (const Adaptor3d_Curve& C);
+ static gp_Lin Line (const Handle(Adaptor3d_Curve)& C);
- static gp_Circ Circle (const Adaptor3d_Curve& C);
+ static gp_Circ Circle (const Handle(Adaptor3d_Curve)& C);
- static gp_Elips Ellipse (const Adaptor3d_Curve& C);
+ static gp_Elips Ellipse (const Handle(Adaptor3d_Curve)& C);
- static gp_Hypr Hyperbola (const Adaptor3d_Curve& C);
+ static gp_Hypr Hyperbola (const Handle(Adaptor3d_Curve)& C);
- static gp_Parab Parabola (const Adaptor3d_Curve& C);
+ static gp_Parab Parabola (const Handle(Adaptor3d_Curve)& C);
- static Standard_Integer Degree (const Adaptor3d_Curve& C);
+ static Standard_Integer Degree (const Handle(Adaptor3d_Curve)& C);
- static Standard_Boolean IsRational (const Adaptor3d_Curve& C);
+ static Standard_Boolean IsRational (const Handle(Adaptor3d_Curve)& C);
- static Standard_Integer NbPoles (const Adaptor3d_Curve& C);
+ static Standard_Integer NbPoles (const Handle(Adaptor3d_Curve)& C);
- static Standard_Integer NbKnots (const Adaptor3d_Curve& C);
+ static Standard_Integer NbKnots (const Handle(Adaptor3d_Curve)& C);
- static Handle(Geom_BezierCurve) Bezier (const Adaptor3d_Curve& C);
+ static Handle(Geom_BezierCurve) Bezier (const Handle(Adaptor3d_Curve)& C);
- static Handle(Geom_BSplineCurve) BSpline (const Adaptor3d_Curve& C);
+ static Handle(Geom_BSplineCurve) BSpline (const Handle(Adaptor3d_Curve)& C);
//purpose :
//=======================================================================
-inline Standard_Real Extrema_CurveTool::FirstParameter(const Adaptor3d_Curve& C)
+inline Standard_Real Extrema_CurveTool::FirstParameter(const Handle(Adaptor3d_Curve)& C)
{
- return C.FirstParameter();
+ return C->FirstParameter();
}
//=======================================================================
//purpose :
//=======================================================================
-inline Standard_Real Extrema_CurveTool::LastParameter(const Adaptor3d_Curve& C)
+inline Standard_Real Extrema_CurveTool::LastParameter(const Handle(Adaptor3d_Curve)& C)
{
- return C.LastParameter();
+ return C->LastParameter();
}
//=======================================================================
//purpose :
//=======================================================================
-inline gp_Pnt Extrema_CurveTool::Value(const Adaptor3d_Curve& C,
+inline gp_Pnt Extrema_CurveTool::Value(const Handle(Adaptor3d_Curve)& C,
const Standard_Real U)
{
- return C.Value(U);
+ return C->Value(U);
}
//=======================================================================
//purpose :
//=======================================================================
-inline void Extrema_CurveTool::D0(const Adaptor3d_Curve& C,
+inline void Extrema_CurveTool::D0(const Handle(Adaptor3d_Curve)& C,
const Standard_Real U,
gp_Pnt& P)
{
- C.D0(U, P);
+ C->D0(U, P);
}
//=======================================================================
//purpose :
//=======================================================================
-inline void Extrema_CurveTool::D1(const Adaptor3d_Curve& C,
+inline void Extrema_CurveTool::D1(const Handle(Adaptor3d_Curve)& C,
const Standard_Real U,
gp_Pnt& P,
gp_Vec& V)
{
- C.D1(U, P, V);
+ C->D1(U, P, V);
}
//=======================================================================
//purpose :
//=======================================================================
-inline void Extrema_CurveTool::D2(const Adaptor3d_Curve& C,
+inline void Extrema_CurveTool::D2(const Handle(Adaptor3d_Curve)& C,
const Standard_Real U,
gp_Pnt& P,
gp_Vec& V1,
gp_Vec& V2)
{
- C.D2(U, P, V1, V2);
+ C->D2(U, P, V1, V2);
}
//=======================================================================
//purpose :
//=======================================================================
- inline void Extrema_CurveTool::D3(const Adaptor3d_Curve& C,
+ inline void Extrema_CurveTool::D3(const Handle(Adaptor3d_Curve)& C,
const Standard_Real U,
gp_Pnt& P,
gp_Vec& V1,
gp_Vec& V2,
gp_Vec& V3)
{
- C.D3(U, P, V1, V2, V3);
+ C->D3(U, P, V1, V2, V3);
}
//=======================================================================
//function : DN
//purpose :
//=======================================================================
-inline gp_Vec Extrema_CurveTool::DN(const Adaptor3d_Curve& C,
+inline gp_Vec Extrema_CurveTool::DN(const Handle(Adaptor3d_Curve)& C,
const Standard_Real U,
const Standard_Integer N)
{
- return C.DN(U, N);
+ return C->DN(U, N);
}
//purpose :
//=======================================================================
-inline GeomAbs_Shape Extrema_CurveTool::Continuity(const Adaptor3d_Curve& C)
+inline GeomAbs_Shape Extrema_CurveTool::Continuity(const Handle(Adaptor3d_Curve)& C)
{
- return C.Continuity();
+ return C->Continuity();
}
//=======================================================================
//purpose :
//=======================================================================
-inline Standard_Integer Extrema_CurveTool::NbIntervals(Adaptor3d_Curve& C,
+inline Standard_Integer Extrema_CurveTool::NbIntervals(Handle(Adaptor3d_Curve)& C,
const GeomAbs_Shape S)
{
- return C.NbIntervals(S);
+ return C->NbIntervals(S);
}
//purpose :
//=======================================================================
-inline void Extrema_CurveTool::Intervals(Adaptor3d_Curve& C,
+inline void Extrema_CurveTool::Intervals(Handle(Adaptor3d_Curve)& C,
TColStd_Array1OfReal& T,
const GeomAbs_Shape S)
{
- C.Intervals(T, S);
+ C->Intervals(T, S);
}
//=======================================================================
//purpose :
//=======================================================================
-inline Standard_Real Extrema_CurveTool::Period(const Adaptor3d_Curve& C)
+inline Standard_Real Extrema_CurveTool::Period(const Handle(Adaptor3d_Curve)& C)
{
- return C.Period();
+ return C->Period();
}
//purpose :
//=======================================================================
-inline GeomAbs_CurveType Extrema_CurveTool::GetType(const Adaptor3d_Curve& C)
+inline GeomAbs_CurveType Extrema_CurveTool::GetType(const Handle(Adaptor3d_Curve)& C)
{
- return C.GetType();
+ return C->GetType();
}
//=======================================================================
//purpose :
//=======================================================================
-inline gp_Lin Extrema_CurveTool::Line(const Adaptor3d_Curve& C)
+inline gp_Lin Extrema_CurveTool::Line(const Handle(Adaptor3d_Curve)& C)
{
- return C.Line();
+ return C->Line();
}
//=======================================================================
//purpose :
//=======================================================================
-inline gp_Circ Extrema_CurveTool::Circle(const Adaptor3d_Curve& C)
+inline gp_Circ Extrema_CurveTool::Circle(const Handle(Adaptor3d_Curve)& C)
{
- return C.Circle();
+ return C->Circle();
}
//=======================================================================
//purpose :
//=======================================================================
-inline gp_Elips Extrema_CurveTool::Ellipse(const Adaptor3d_Curve& C)
+inline gp_Elips Extrema_CurveTool::Ellipse(const Handle(Adaptor3d_Curve)& C)
{
- return C.Ellipse();
+ return C->Ellipse();
}
//=======================================================================
//purpose :
//=======================================================================
-inline gp_Hypr Extrema_CurveTool::Hyperbola(const Adaptor3d_Curve& C)
+inline gp_Hypr Extrema_CurveTool::Hyperbola(const Handle(Adaptor3d_Curve)& C)
{
- return C.Hyperbola();
+ return C->Hyperbola();
}
//=======================================================================
//purpose :
//=======================================================================
-inline gp_Parab Extrema_CurveTool::Parabola(const Adaptor3d_Curve& C)
+inline gp_Parab Extrema_CurveTool::Parabola(const Handle(Adaptor3d_Curve)& C)
{
- return C.Parabola();
+ return C->Parabola();
}
//=======================================================================
//function : NbPoles
//purpose :
//=======================================================================
- inline Standard_Integer Extrema_CurveTool::NbPoles(const Adaptor3d_Curve& C)
+ inline Standard_Integer Extrema_CurveTool::NbPoles(const Handle(Adaptor3d_Curve)& C)
{
- return C.NbPoles();
+ return C->NbPoles();
}
//=======================================================================
//purpose :
//=======================================================================
- inline Standard_Integer Extrema_CurveTool::Degree(const Adaptor3d_Curve& C)
+ inline Standard_Integer Extrema_CurveTool::Degree(const Handle(Adaptor3d_Curve)& C)
{
- return C.Degree();
+ return C->Degree();
}
//=======================================================================
//purpose :
//=======================================================================
- inline Standard_Boolean Extrema_CurveTool::IsRational(const Adaptor3d_Curve& C)
+ inline Standard_Boolean Extrema_CurveTool::IsRational(const Handle(Adaptor3d_Curve)& C)
{
- return C.IsRational();
+ return C->IsRational();
}
//=======================================================================
//purpose :
//=======================================================================
- inline Standard_Integer Extrema_CurveTool::NbKnots(const Adaptor3d_Curve& C)
+ inline Standard_Integer Extrema_CurveTool::NbKnots(const Handle(Adaptor3d_Curve)& C)
{
- return C.NbKnots();
+ return C->NbKnots();
}
//purpose :
//=======================================================================
-inline Handle(Geom_BezierCurve) Extrema_CurveTool::Bezier(const Adaptor3d_Curve& C)
+inline Handle(Geom_BezierCurve) Extrema_CurveTool::Bezier(const Handle(Adaptor3d_Curve)& C)
{
- return C.Bezier();
+ return C->Bezier();
}
//=======================================================================
//purpose :
//=======================================================================
-inline Handle(Geom_BSplineCurve) Extrema_CurveTool::BSpline(const Adaptor3d_Curve& C)
+inline Handle(Geom_BSplineCurve) Extrema_CurveTool::BSpline(const Handle(Adaptor3d_Curve)& C)
{
- return C.BSpline();
+ return C->BSpline();
}
//=======================================================================
//purpose :
//=======================================================================
-inline Standard_Real Extrema_CurveTool::Resolution(const Adaptor3d_Curve& C,
+inline Standard_Real Extrema_CurveTool::Resolution(const Handle(Adaptor3d_Curve)& C,
const Standard_Real R3d)
{
- return C.Resolution(R3d);
+ return C->Resolution(R3d);
}
//! The function F(u,v)=distance(C1(u),C2(v)) has an
//! extremum when gradient(f)=0. The algorithm uses
//! Evtushenko's global optimization solver.
- Standard_EXPORT Extrema_ECC(const Adaptor3d_Curve& C1, const Adaptor3d_Curve& C2);
+ Standard_EXPORT Extrema_ECC(const Handle(Adaptor3d_Curve)& C1, const Handle(Adaptor3d_Curve)& C2);
//! Calculates all the distances as above
//! between Uinf and Usup for C1 and between Vinf and Vsup
//! for C2.
- Standard_EXPORT Extrema_ECC(const Adaptor3d_Curve& C1, const Adaptor3d_Curve& C2, const Standard_Real Uinf, const Standard_Real Usup, const Standard_Real Vinf, const Standard_Real Vsup);
+ Standard_EXPORT Extrema_ECC(const Handle(Adaptor3d_Curve)& C1, const Handle(Adaptor3d_Curve)& C2, const Standard_Real Uinf, const Standard_Real Usup, const Standard_Real Vinf, const Standard_Real Vsup);
//! Set params in case of empty constructor is usage.
- Standard_EXPORT void SetParams (const Adaptor3d_Curve& C1, const Adaptor3d_Curve& C2, const Standard_Real Uinf, const Standard_Real Usup, const Standard_Real Vinf, const Standard_Real Vsup);
+ Standard_EXPORT void SetParams (const Handle(Adaptor3d_Curve)& C1, const Handle(Adaptor3d_Curve)& C2, const Standard_Real Uinf, const Standard_Real Usup, const Standard_Real Vinf, const Standard_Real Vsup);
Standard_EXPORT void SetTolerance (const Standard_Real Tol);
//! The function F(u,v)=distance(C1(u),C2(v)) has an
//! extremum when gradient(f)=0. The algorithm uses
//! Evtushenko's global optimization solver.
- Standard_EXPORT Extrema_ECC2d(const Adaptor2d_Curve2d& C1, const Adaptor2d_Curve2d& C2);
+ Standard_EXPORT Extrema_ECC2d(const Handle(Adaptor2d_Curve2d)& C1, const Handle(Adaptor2d_Curve2d)& C2);
//! Calculates all the distances as above
//! between Uinf and Usup for C1 and between Vinf and Vsup
//! for C2.
- Standard_EXPORT Extrema_ECC2d(const Adaptor2d_Curve2d& C1, const Adaptor2d_Curve2d& C2, const Standard_Real Uinf, const Standard_Real Usup, const Standard_Real Vinf, const Standard_Real Vsup);
+ Standard_EXPORT Extrema_ECC2d(const Handle(Adaptor2d_Curve2d)& C1, const Handle(Adaptor2d_Curve2d)& C2, const Standard_Real Uinf, const Standard_Real Usup, const Standard_Real Vinf, const Standard_Real Vsup);
//! Set params in case of empty constructor is usage.
- Standard_EXPORT void SetParams (const Adaptor2d_Curve2d& C1, const Adaptor2d_Curve2d& C2, const Standard_Real Uinf, const Standard_Real Usup, const Standard_Real Vinf, const Standard_Real Vsup);
+ Standard_EXPORT void SetParams (const Handle(Adaptor2d_Curve2d)& C1, const Handle(Adaptor2d_Curve2d)& C2, const Standard_Real Uinf, const Standard_Real Usup, const Standard_Real Vinf, const Standard_Real Vsup);
Standard_EXPORT void SetTolerance (const Standard_Real Tol);
#include <gp_Vec2d.hxx>
-#define Curve1 Adaptor2d_Curve2d
+#define Curve1 Handle(Adaptor2d_Curve2d)
#define Curve1_hxx <Adaptor2d_Curve2d.hxx>
#define Tool1 Extrema_Curve2dTool
#define Tool1_hxx <Extrema_Curve2dTool.hxx>
-#define Curve2 Adaptor2d_Curve2d
+#define Curve2 Handle(Adaptor2d_Curve2d)
#define Curve2_hxx <Adaptor2d_Curve2d.hxx>
#define Tool2 Extrema_Curve2dTool
#define Tool2_hxx <Extrema_Curve2dTool.hxx>
#include <gp_Vec.hxx>
-#define Curve1 Adaptor3d_Curve
+#define Curve1 Handle(Adaptor3d_Curve)
#define Curve1_hxx <Adaptor3d_Curve.hxx>
#define Tool1 Extrema_CurveTool
#define Tool1_hxx <Extrema_CurveTool.hxx>
-#define Curve2 Adaptor3d_Curve
+#define Curve2 Handle(Adaptor3d_Curve)
#define Curve2_hxx <Adaptor3d_Curve.hxx>
#define Tool2 Extrema_CurveTool
#define Tool2_hxx <Extrema_CurveTool.hxx>
//! iterations according to the following condition:
//! if n is the number of iterations,
//! the algorithm stops when abs(F(Un)-F(Un-1)) < Tol.
- Standard_EXPORT Extrema_ELPCOfLocateExtPC(const gp_Pnt& P, const Adaptor3d_Curve& C, const Standard_Real Uinf, const Standard_Real Usup, const Standard_Real TolF = 1.0e-10);
+ Standard_EXPORT Extrema_ELPCOfLocateExtPC(const gp_Pnt& P, const Handle(Adaptor3d_Curve)& C, const Standard_Real Uinf, const Standard_Real Usup, const Standard_Real TolF = 1.0e-10);
//! It calculates all the distances.
//! The function F(u)=distance(P,C(u)) has an extremum
//! iterations according to the following condition:
//! if n is the number of iterations,
//! the algorithm stops when abs(F(Un)-F(Un-1)) < Tol.
- Standard_EXPORT Extrema_ELPCOfLocateExtPC(const gp_Pnt& P, const Adaptor3d_Curve& C, const Standard_Real TolF = 1.0e-10);
+ Standard_EXPORT Extrema_ELPCOfLocateExtPC(const gp_Pnt& P, const Handle(Adaptor3d_Curve)& C, const Standard_Real TolF = 1.0e-10);
//! initializes the fields of the algorithm.
- Standard_EXPORT void Initialize (const Adaptor3d_Curve& C, const Standard_Real Uinf, const Standard_Real Usup, const Standard_Real TolF = 1.0e-10);
+ Standard_EXPORT void Initialize (const Handle(Adaptor3d_Curve)& C, const Standard_Real Uinf, const Standard_Real Usup, const Standard_Real TolF = 1.0e-10);
//! An exception is raised if the fields have not been
//! initialized.
//! iterations according to the following condition:
//! if n is the number of iterations,
//! the algorithm stops when abs(F(Un)-F(Un-1)) < Tol.
- Standard_EXPORT Extrema_ELPCOfLocateExtPC2d(const gp_Pnt2d& P, const Adaptor2d_Curve2d& C, const Standard_Real Uinf, const Standard_Real Usup, const Standard_Real TolF = 1.0e-10);
+ Standard_EXPORT Extrema_ELPCOfLocateExtPC2d(const gp_Pnt2d& P, const Handle(Adaptor2d_Curve2d)& C, const Standard_Real Uinf, const Standard_Real Usup, const Standard_Real TolF = 1.0e-10);
//! It calculates all the distances.
//! The function F(u)=distance(P,C(u)) has an extremum
//! iterations according to the following condition:
//! if n is the number of iterations,
//! the algorithm stops when abs(F(Un)-F(Un-1)) < Tol.
- Standard_EXPORT Extrema_ELPCOfLocateExtPC2d(const gp_Pnt2d& P, const Adaptor2d_Curve2d& C, const Standard_Real TolF = 1.0e-10);
+ Standard_EXPORT Extrema_ELPCOfLocateExtPC2d(const gp_Pnt2d& P, const Handle(Adaptor2d_Curve2d)& C, const Standard_Real TolF = 1.0e-10);
//! initializes the fields of the algorithm.
- Standard_EXPORT void Initialize (const Adaptor2d_Curve2d& C, const Standard_Real Uinf, const Standard_Real Usup, const Standard_Real TolF = 1.0e-10);
+ Standard_EXPORT void Initialize (const Handle(Adaptor2d_Curve2d)& C, const Standard_Real Uinf, const Standard_Real Usup, const Standard_Real TolF = 1.0e-10);
//! An exception is raised if the fields have not been
//! initialized.
#include <Extrema_PCFOfEPCOfELPCOfLocateExtPC2d.hxx>
-#define TheCurve Adaptor2d_Curve2d
+#define TheCurve Handle(Adaptor2d_Curve2d)
#define TheCurve_hxx <Adaptor2d_Curve2d.hxx>
#define TheCurveTool Extrema_Curve2dTool
#define TheCurveTool_hxx <Extrema_Curve2dTool.hxx>
#include <Extrema_PCFOfEPCOfELPCOfLocateExtPC.hxx>
-#define TheCurve Adaptor3d_Curve
+#define TheCurve Handle(Adaptor3d_Curve)
#define TheCurve_hxx <Adaptor3d_Curve.hxx>
#define TheCurveTool Extrema_CurveTool
#define TheCurveTool_hxx <Extrema_CurveTool.hxx>
//! iterations according to the following condition:
//! if n is the number of iterations,
//! abs(Un-Un-1) < TolU and abs(F(Un)-F(Un-1)) < Tol.
- Standard_EXPORT Extrema_EPCOfELPCOfLocateExtPC(const gp_Pnt& P, const Adaptor3d_Curve& C, const Standard_Integer NbU, const Standard_Real TolU, const Standard_Real TolF);
+ Standard_EXPORT Extrema_EPCOfELPCOfLocateExtPC(const gp_Pnt& P, const Handle(Adaptor3d_Curve)& C, const Standard_Integer NbU, const Standard_Real TolU, const Standard_Real TolF);
//! It calculates all the distances.
//! The function F(u)=distance(P,C(u)) has an extremum
//! iterations according to the following condition:
//! if n is the number of iterations,
//! abs(Un-Un-1) < TolU and abs(F(Un)-F(Un-1)) < Tol.
- Standard_EXPORT Extrema_EPCOfELPCOfLocateExtPC(const gp_Pnt& P, const Adaptor3d_Curve& C, const Standard_Integer NbU, const Standard_Real Umin, const Standard_Real Usup, const Standard_Real TolU, const Standard_Real TolF);
+ Standard_EXPORT Extrema_EPCOfELPCOfLocateExtPC(const gp_Pnt& P, const Handle(Adaptor3d_Curve)& C, const Standard_Integer NbU, const Standard_Real Umin, const Standard_Real Usup, const Standard_Real TolU, const Standard_Real TolF);
//! sets the fields of the algorithm.
- Standard_EXPORT void Initialize (const Adaptor3d_Curve& C, const Standard_Integer NbU, const Standard_Real TolU, const Standard_Real TolF);
+ Standard_EXPORT void Initialize (const Handle(Adaptor3d_Curve)& C, const Standard_Integer NbU, const Standard_Real TolU, const Standard_Real TolF);
//! sets the fields of the algorithm.
- Standard_EXPORT void Initialize (const Adaptor3d_Curve& C, const Standard_Integer NbU, const Standard_Real Umin, const Standard_Real Usup, const Standard_Real TolU, const Standard_Real TolF);
+ Standard_EXPORT void Initialize (const Handle(Adaptor3d_Curve)& C, const Standard_Integer NbU, const Standard_Real Umin, const Standard_Real Usup, const Standard_Real TolU, const Standard_Real TolF);
//! sets the fields of the algorithm.
- Standard_EXPORT void Initialize (const Adaptor3d_Curve& C);
+ Standard_EXPORT void Initialize (const Handle(Adaptor3d_Curve)& C);
//! sets the fields of the algorithm.
Standard_EXPORT void Initialize (const Standard_Integer NbU, const Standard_Real Umin, const Standard_Real Usup, const Standard_Real TolU, const Standard_Real TolF);
//! iterations according to the following condition:
//! if n is the number of iterations,
//! abs(Un-Un-1) < TolU and abs(F(Un)-F(Un-1)) < Tol.
- Standard_EXPORT Extrema_EPCOfELPCOfLocateExtPC2d(const gp_Pnt2d& P, const Adaptor2d_Curve2d& C, const Standard_Integer NbU, const Standard_Real TolU, const Standard_Real TolF);
+ Standard_EXPORT Extrema_EPCOfELPCOfLocateExtPC2d(const gp_Pnt2d& P, const Handle(Adaptor2d_Curve2d)& C, const Standard_Integer NbU, const Standard_Real TolU, const Standard_Real TolF);
//! It calculates all the distances.
//! The function F(u)=distance(P,C(u)) has an extremum
//! iterations according to the following condition:
//! if n is the number of iterations,
//! abs(Un-Un-1) < TolU and abs(F(Un)-F(Un-1)) < Tol.
- Standard_EXPORT Extrema_EPCOfELPCOfLocateExtPC2d(const gp_Pnt2d& P, const Adaptor2d_Curve2d& C, const Standard_Integer NbU, const Standard_Real Umin, const Standard_Real Usup, const Standard_Real TolU, const Standard_Real TolF);
+ Standard_EXPORT Extrema_EPCOfELPCOfLocateExtPC2d(const gp_Pnt2d& P, const Handle(Adaptor2d_Curve2d)& C, const Standard_Integer NbU, const Standard_Real Umin, const Standard_Real Usup, const Standard_Real TolU, const Standard_Real TolF);
//! sets the fields of the algorithm.
- Standard_EXPORT void Initialize (const Adaptor2d_Curve2d& C, const Standard_Integer NbU, const Standard_Real TolU, const Standard_Real TolF);
+ Standard_EXPORT void Initialize (const Handle(Adaptor2d_Curve2d)& C, const Standard_Integer NbU, const Standard_Real TolU, const Standard_Real TolF);
//! sets the fields of the algorithm.
- Standard_EXPORT void Initialize (const Adaptor2d_Curve2d& C, const Standard_Integer NbU, const Standard_Real Umin, const Standard_Real Usup, const Standard_Real TolU, const Standard_Real TolF);
+ Standard_EXPORT void Initialize (const Handle(Adaptor2d_Curve2d)& C, const Standard_Integer NbU, const Standard_Real Umin, const Standard_Real Usup, const Standard_Real TolU, const Standard_Real TolF);
//! sets the fields of the algorithm.
- Standard_EXPORT void Initialize (const Adaptor2d_Curve2d& C);
+ Standard_EXPORT void Initialize (const Handle(Adaptor2d_Curve2d)& C);
//! sets the fields of the algorithm.
Standard_EXPORT void Initialize (const Standard_Integer NbU, const Standard_Real Umin, const Standard_Real Usup, const Standard_Real TolU, const Standard_Real TolF);
#include <Extrema_SequenceOfPOnCurv2d.hxx>
-#define Curve Adaptor2d_Curve2d
+#define Curve Handle(Adaptor2d_Curve2d)
#define Curve_hxx <Adaptor2d_Curve2d.hxx>
#define Tool Extrema_Curve2dTool
#define Tool_hxx <Extrema_Curve2dTool.hxx>
#include <Extrema_SequenceOfPOnCurv.hxx>
-#define Curve Adaptor3d_Curve
+#define Curve Handle(Adaptor3d_Curve)
#define Curve_hxx <Adaptor3d_Curve.hxx>
#define Tool Extrema_CurveTool
#define Tool_hxx <Extrema_CurveTool.hxx>
//! iterations according to the following condition:
//! if n is the number of iterations,
//! abs(Un-Un-1) < TolU and abs(F(Un)-F(Un-1)) < Tol.
- Standard_EXPORT Extrema_EPCOfExtPC(const gp_Pnt& P, const Adaptor3d_Curve& C, const Standard_Integer NbU, const Standard_Real TolU, const Standard_Real TolF);
+ Standard_EXPORT Extrema_EPCOfExtPC(const gp_Pnt& P, const Handle(Adaptor3d_Curve)& C, const Standard_Integer NbU, const Standard_Real TolU, const Standard_Real TolF);
//! It calculates all the distances.
//! The function F(u)=distance(P,C(u)) has an extremum
//! iterations according to the following condition:
//! if n is the number of iterations,
//! abs(Un-Un-1) < TolU and abs(F(Un)-F(Un-1)) < Tol.
- Standard_EXPORT Extrema_EPCOfExtPC(const gp_Pnt& P, const Adaptor3d_Curve& C, const Standard_Integer NbU, const Standard_Real Umin, const Standard_Real Usup, const Standard_Real TolU, const Standard_Real TolF);
+ Standard_EXPORT Extrema_EPCOfExtPC(const gp_Pnt& P, const Handle(Adaptor3d_Curve)& C, const Standard_Integer NbU, const Standard_Real Umin, const Standard_Real Usup, const Standard_Real TolU, const Standard_Real TolF);
//! sets the fields of the algorithm.
- Standard_EXPORT void Initialize (const Adaptor3d_Curve& C, const Standard_Integer NbU, const Standard_Real TolU, const Standard_Real TolF);
+ Standard_EXPORT void Initialize (const Handle(Adaptor3d_Curve)& C, const Standard_Integer NbU, const Standard_Real TolU, const Standard_Real TolF);
//! sets the fields of the algorithm.
- Standard_EXPORT void Initialize (const Adaptor3d_Curve& C, const Standard_Integer NbU, const Standard_Real Umin, const Standard_Real Usup, const Standard_Real TolU, const Standard_Real TolF);
+ Standard_EXPORT void Initialize (const Handle(Adaptor3d_Curve)& C, const Standard_Integer NbU, const Standard_Real Umin, const Standard_Real Usup, const Standard_Real TolU, const Standard_Real TolF);
//! sets the fields of the algorithm.
- Standard_EXPORT void Initialize (const Adaptor3d_Curve& C);
+ Standard_EXPORT void Initialize (const Handle(Adaptor3d_Curve)& C);
//! sets the fields of the algorithm.
Standard_EXPORT void Initialize (const Standard_Integer NbU, const Standard_Real Umin, const Standard_Real Usup, const Standard_Real TolU, const Standard_Real TolF);
//! iterations according to the following condition:
//! if n is the number of iterations,
//! abs(Un-Un-1) < TolU and abs(F(Un)-F(Un-1)) < Tol.
- Standard_EXPORT Extrema_EPCOfExtPC2d(const gp_Pnt2d& P, const Adaptor2d_Curve2d& C, const Standard_Integer NbU, const Standard_Real TolU, const Standard_Real TolF);
+ Standard_EXPORT Extrema_EPCOfExtPC2d(const gp_Pnt2d& P, const Handle(Adaptor2d_Curve2d)& C, const Standard_Integer NbU, const Standard_Real TolU, const Standard_Real TolF);
//! It calculates all the distances.
//! The function F(u)=distance(P,C(u)) has an extremum
//! iterations according to the following condition:
//! if n is the number of iterations,
//! abs(Un-Un-1) < TolU and abs(F(Un)-F(Un-1)) < Tol.
- Standard_EXPORT Extrema_EPCOfExtPC2d(const gp_Pnt2d& P, const Adaptor2d_Curve2d& C, const Standard_Integer NbU, const Standard_Real Umin, const Standard_Real Usup, const Standard_Real TolU, const Standard_Real TolF);
+ Standard_EXPORT Extrema_EPCOfExtPC2d(const gp_Pnt2d& P, const Handle(Adaptor2d_Curve2d)& C, const Standard_Integer NbU, const Standard_Real Umin, const Standard_Real Usup, const Standard_Real TolU, const Standard_Real TolF);
//! sets the fields of the algorithm.
- Standard_EXPORT void Initialize (const Adaptor2d_Curve2d& C, const Standard_Integer NbU, const Standard_Real TolU, const Standard_Real TolF);
+ Standard_EXPORT void Initialize (const Handle(Adaptor2d_Curve2d)& C, const Standard_Integer NbU, const Standard_Real TolU, const Standard_Real TolF);
//! sets the fields of the algorithm.
- Standard_EXPORT void Initialize (const Adaptor2d_Curve2d& C, const Standard_Integer NbU, const Standard_Real Umin, const Standard_Real Usup, const Standard_Real TolU, const Standard_Real TolF);
+ Standard_EXPORT void Initialize (const Handle(Adaptor2d_Curve2d)& C, const Standard_Integer NbU, const Standard_Real Umin, const Standard_Real Usup, const Standard_Real TolU, const Standard_Real TolF);
//! sets the fields of the algorithm.
- Standard_EXPORT void Initialize (const Adaptor2d_Curve2d& C);
+ Standard_EXPORT void Initialize (const Handle(Adaptor2d_Curve2d)& C);
//! sets the fields of the algorithm.
Standard_EXPORT void Initialize (const Standard_Integer NbU, const Standard_Real Umin, const Standard_Real Usup, const Standard_Real TolU, const Standard_Real TolF);
#include <Extrema_SequenceOfPOnCurv2d.hxx>
-#define Curve Adaptor2d_Curve2d
+#define Curve Handle(Adaptor2d_Curve2d)
#define Curve_hxx <Adaptor2d_Curve2d.hxx>
#define Tool Extrema_Curve2dTool
#define Tool_hxx <Extrema_Curve2dTool.hxx>
#include <Extrema_SequenceOfPOnCurv.hxx>
-#define Curve Adaptor3d_Curve
+#define Curve Handle(Adaptor3d_Curve)
#define Curve_hxx <Adaptor3d_Curve.hxx>
#define Tool Extrema_CurveTool
#define Tool_hxx <Extrema_CurveTool.hxx>
//purpose :
//=======================================================================
-Extrema_ExtCC::Extrema_ExtCC(const Adaptor3d_Curve& C1,
- const Adaptor3d_Curve& C2,
+Extrema_ExtCC::Extrema_ExtCC(const Handle(Adaptor3d_Curve)& C1,
+ const Handle(Adaptor3d_Curve)& C2,
const Standard_Real U1,
const Standard_Real U2,
const Standard_Real V1,
//purpose :
//=======================================================================
-Extrema_ExtCC::Extrema_ExtCC(const Adaptor3d_Curve& C1,
- const Adaptor3d_Curve& C2,
+Extrema_ExtCC::Extrema_ExtCC(const Handle(Adaptor3d_Curve)& C1,
+ const Handle(Adaptor3d_Curve)& C2,
const Standard_Real TolC1,
const Standard_Real TolC2)
: myIsFindSingleSolution(Standard_False),
myECC(C1, C2),
myDone (Standard_False)
{
- SetCurve (1, C1, C1.FirstParameter(), C1.LastParameter());
- SetCurve (2, C2, C2.FirstParameter(), C2.LastParameter());
+ SetCurve (1, C1, C1->FirstParameter(), C1->LastParameter());
+ SetCurve (2, C2, C2->FirstParameter(), C2->LastParameter());
SetTolerance (1, TolC1);
SetTolerance (2, TolC2);
mydist11 = mydist12 = mydist21 = mydist22 = RealFirst();
//function : Initialize
//purpose :
//=======================================================================
-void Extrema_ExtCC::Initialize (const Adaptor3d_Curve& C1,
- const Adaptor3d_Curve& C2,
+void Extrema_ExtCC::Initialize (const Handle(Adaptor3d_Curve)& C1,
+ const Handle(Adaptor3d_Curve)& C2,
const Standard_Real TolC1,
const Standard_Real TolC2)
{
// myECC will be re-initialized by Perform()
myDone = Standard_False;
- SetCurve (1, C1, C1.FirstParameter(), C1.LastParameter());
- SetCurve (2, C2, C2.FirstParameter(), C2.LastParameter());
+ SetCurve (1, C1, C1->FirstParameter(), C1->LastParameter());
+ SetCurve (2, C2, C2->FirstParameter(), C2->LastParameter());
SetTolerance (1, TolC1);
SetTolerance (2, TolC2);
mydist11 = mydist12 = mydist21 = mydist22 = RealFirst();
//function : Initialize
//purpose :
//=======================================================================
-void Extrema_ExtCC::Initialize (const Adaptor3d_Curve& C1,
- const Adaptor3d_Curve& C2,
+void Extrema_ExtCC::Initialize (const Handle(Adaptor3d_Curve)& C1,
+ const Handle(Adaptor3d_Curve)& C2,
const Standard_Real U1,
const Standard_Real U2,
const Standard_Real V1,
//purpose :
//=======================================================================
-void Extrema_ExtCC::SetCurve (const Standard_Integer theRank, const Adaptor3d_Curve& C)
+void Extrema_ExtCC::SetCurve (const Standard_Integer theRank, const Handle(Adaptor3d_Curve)& C)
{
Standard_OutOfRange_Raise_if (theRank < 1 || theRank > 2, "Extrema_ExtCC::SetCurve()")
Standard_Integer anInd = theRank - 1;
- myC[anInd] = &C;
+ myC[anInd] = C;
}
//=======================================================================
//purpose :
//=======================================================================
-void Extrema_ExtCC::SetCurve (const Standard_Integer theRank, const Adaptor3d_Curve& C,
+void Extrema_ExtCC::SetCurve (const Standard_Integer theRank, const Handle(Adaptor3d_Curve)& C,
const Standard_Real Uinf, const Standard_Real Usup)
{
SetCurve (theRank, C);
void Extrema_ExtCC::Perform()
{
Standard_NullObject_Raise_if (!myC[0] || !myC[1], "Extrema_ExtCC::Perform()")
- myECC.SetParams(*myC[0], *myC[1], myInf[0], mySup[0], myInf[1], mySup[1]);
+ myECC.SetParams(myC[0], myC[1], myInf[0], mySup[0], myInf[1], mySup[1]);
myECC.SetTolerance(Min(myTol[0], myTol[1]));
myECC.SetSingleSolutionFlag(GetSingleSolutionFlag());
myDone = Standard_False;
U21 = myInf[1];
U22 = mySup[1];
- if (!Precision::IsInfinite(U11)) myP1f = Extrema_CurveTool::Value(*myC[0], U11);
- if (!Precision::IsInfinite(U12)) myP1l = Extrema_CurveTool::Value(*myC[0], U12);
- if (!Precision::IsInfinite(U21)) myP2f = Extrema_CurveTool::Value(*myC[1], U21);
- if (!Precision::IsInfinite(U22)) myP2l = Extrema_CurveTool::Value(*myC[1], U22);
+ if (!Precision::IsInfinite(U11)) myP1f = Extrema_CurveTool::Value(myC[0], U11);
+ if (!Precision::IsInfinite(U12)) myP1l = Extrema_CurveTool::Value(myC[0], U12);
+ if (!Precision::IsInfinite(U21)) myP2f = Extrema_CurveTool::Value(myC[1], U21);
+ if (!Precision::IsInfinite(U22)) myP2l = Extrema_CurveTool::Value(myC[1], U22);
if (Precision::IsInfinite(U11) || Precision::IsInfinite(U21)) mydist11 = RealLast();
if (!myIsParallel)
return;
- const GeomAbs_CurveType aType1 = Extrema_CurveTool::GetType (*myC[0]);
- const GeomAbs_CurveType aType2 = Extrema_CurveTool::GetType (*myC[1]);
+ const GeomAbs_CurveType aType1 = Extrema_CurveTool::GetType (myC[0]);
+ const GeomAbs_CurveType aType2 = Extrema_CurveTool::GetType (myC[1]);
if (((aType1 != GeomAbs_Line) && (aType1 != GeomAbs_Circle)) ||
((aType2 != GeomAbs_Line) && (aType2 != GeomAbs_Circle)))
{
//The projection of the circle's location to the trimmed line must exist.
const Standard_Boolean isReversed = (aType1 != GeomAbs_Circle);
const gp_Pnt aPonC = !isReversed ?
- Extrema_CurveTool::Value (*myC[0], theUt11) :
- Extrema_CurveTool::Value (*myC[1], theUt21);
+ Extrema_CurveTool::Value (myC[0], theUt11) :
+ Extrema_CurveTool::Value (myC[1], theUt21);
const gp_Lin aL = myC[!isReversed ? 1 : 0]->Line();
const Extrema_ExtPElC ExtPLin(aPonC, aL, Precision::Confusion(),
const Standard_Real aPeriod = M_PI + M_PI;
gp_Vec aVTg1;
gp_Pnt aP11;
- const gp_Pnt aP12 = Extrema_CurveTool::Value (*myC[0], theUt12);
- Extrema_CurveTool::D1 (*myC[0], theUt11, aP11, aVTg1);
+ const gp_Pnt aP12 = Extrema_CurveTool::Value (myC[0], theUt12);
+ Extrema_CurveTool::D1 (myC[0], theUt11, aP11, aVTg1);
const Bnd_Range aRange(theUt21, theUt22);
Bnd_Range aProjRng1;
Standard_Real aPar1 = ElCLib::InPeriod(ElCLib::Parameter(aWorkCirc, aP11),
theUt21, theUt21 + aPeriod);
- const gp_Vec aVTg2 = Extrema_CurveTool::DN (*myC[1], aPar1, 1);
+ const gp_Vec aVTg2 = Extrema_CurveTool::DN (myC[1], aPar1, 1);
// Check if circles have same/opposite directions
const Standard_Boolean isOpposite(aVTg1.Dot(aVTg2) < 0.0);
aRng.GetIntermediatePoint(0.5, aPar);
const gp_Pnt aPCirc2 = ElCLib::Value(aPar, aWorkCirc);
Extrema_ExtPElC ExtPCir(aPCirc2,
- Extrema_CurveTool::Circle (*myC[0]),
+ Extrema_CurveTool::Circle (myC[0]),
Precision::Confusion(), theUt11, theUt12);
Standard_Real aMinSqD = ExtPCir.SquareDistance(1);
const Extrema_POnCurv aP2(aPar, aPCirc2);
Extrema_ExtPElC ExtPCir(aPCirc2,
- Extrema_CurveTool::Circle (*myC[0]),
+ Extrema_CurveTool::Circle (myC[0]),
Precision::Confusion(), theUt11, theUt12);
Standard_Boolean isFound = !myIsParallel;
U = P2.Parameter();
}
- if (Extrema_CurveTool::IsPeriodic (*myC[0]))
+ if (Extrema_CurveTool::IsPeriodic (myC[0]))
{
- U = ElCLib::InPeriod(U, Ut11, Ut11+Extrema_CurveTool::Period (*myC[0]));
+ U = ElCLib::InPeriod(U, Ut11, Ut11+Extrema_CurveTool::Period (myC[0]));
}
- if (Extrema_CurveTool::IsPeriodic (*myC[1]))
+ if (Extrema_CurveTool::IsPeriodic (myC[1]))
{
- U2 = ElCLib::InPeriod(U2, Ut21, Ut21+Extrema_CurveTool::Period (*myC[1]));
+ U2 = ElCLib::InPeriod(U2, Ut21, Ut21+Extrema_CurveTool::Period (myC[1]));
}
if ((U >= Ut11 - RealEpsilon()) &&
U2 = P2.Parameter();
// Check points to be into param space.
- if (Extrema_CurveTool::IsPeriodic (*myC[0]))
+ if (Extrema_CurveTool::IsPeriodic (myC[0]))
{
- U = ElCLib::InPeriod(U, Ut11, Ut11 + Extrema_CurveTool::Period (*myC[0]));
+ U = ElCLib::InPeriod(U, Ut11, Ut11 + Extrema_CurveTool::Period (myC[0]));
}
- if (Extrema_CurveTool::IsPeriodic (*myC[1]))
+ if (Extrema_CurveTool::IsPeriodic (myC[1]))
{
- U2 = ElCLib::InPeriod(U2, Ut21, Ut21 + Extrema_CurveTool::Period (*myC[1]));
+ U2 = ElCLib::InPeriod(U2, Ut21, Ut21 + Extrema_CurveTool::Period (myC[1]));
}
if ((U >= Ut11 - RealEpsilon()) &&
const Standard_Real TolC2 = 1.0e-10);
//! It calculates all the distances.
- Standard_EXPORT Extrema_ExtCC(const Adaptor3d_Curve& C1,
- const Adaptor3d_Curve& C2,
+ Standard_EXPORT Extrema_ExtCC(const Handle(Adaptor3d_Curve)& C1,
+ const Handle(Adaptor3d_Curve)& C2,
const Standard_Real TolC1 = 1.0e-10,
const Standard_Real TolC2 = 1.0e-10);
//! It calculates all the distances.
- Standard_EXPORT Extrema_ExtCC(const Adaptor3d_Curve& C1,
- const Adaptor3d_Curve& C2,
+ Standard_EXPORT Extrema_ExtCC(const Handle(Adaptor3d_Curve)& C1,
+ const Handle(Adaptor3d_Curve)& C2,
const Standard_Real U1,
const Standard_Real U2,
const Standard_Real V1,
const Standard_Real TolC2 = 1.0e-10);
//! Initializes but does not perform algorithm.
- Standard_EXPORT void Initialize (const Adaptor3d_Curve& C1,
- const Adaptor3d_Curve& C2,
+ Standard_EXPORT void Initialize (const Handle(Adaptor3d_Curve)& C1,
+ const Handle(Adaptor3d_Curve)& C2,
const Standard_Real TolC1 = 1.0e-10,
const Standard_Real TolC2 = 1.0e-10);
//! Initializes but does not perform algorithm.
- Standard_EXPORT void Initialize (const Adaptor3d_Curve& C1,
- const Adaptor3d_Curve& C2,
+ Standard_EXPORT void Initialize (const Handle(Adaptor3d_Curve)& C1,
+ const Handle(Adaptor3d_Curve)& C2,
const Standard_Real U1,
const Standard_Real U2,
const Standard_Real V1,
const Standard_Real TolC1 = 1.0e-10,
const Standard_Real TolC2 = 1.0e-10);
- Standard_EXPORT void SetCurve (const Standard_Integer theRank, const Adaptor3d_Curve& C);
+ Standard_EXPORT void SetCurve (const Standard_Integer theRank, const Handle(Adaptor3d_Curve)& C);
Standard_EXPORT void SetCurve (const Standard_Integer theRank,
- const Adaptor3d_Curve& C,
+ const Handle(Adaptor3d_Curve)& C,
const Standard_Real Uinf,
const Standard_Real Usup);
Standard_Boolean myIsParallel;
Extrema_SequenceOfPOnCurv mypoints;
TColStd_SequenceOfReal mySqDist;
- const Adaptor3d_Curve* myC[2];
+ Handle(Adaptor3d_Curve) myC[2];
Standard_Real myInf[2];
Standard_Real mySup[2];
Standard_Real myTol[2];
}
-Extrema_ExtCC2d::Extrema_ExtCC2d(const Adaptor2d_Curve2d& C1,
- const Adaptor2d_Curve2d& C2,
+Extrema_ExtCC2d::Extrema_ExtCC2d(const Handle(Adaptor2d_Curve2d)& C1,
+ const Handle(Adaptor2d_Curve2d)& C2,
const Standard_Real TolC1,
const Standard_Real TolC2)
: myIsFindSingleSolution(Standard_False)
Perform(C1, Extrema_Curve2dTool::FirstParameter(C1), Extrema_Curve2dTool::LastParameter(C1));
}
-Extrema_ExtCC2d::Extrema_ExtCC2d(const Adaptor2d_Curve2d& C1,
- const Adaptor2d_Curve2d& C2,
+Extrema_ExtCC2d::Extrema_ExtCC2d(const Handle(Adaptor2d_Curve2d)& C1,
+ const Handle(Adaptor2d_Curve2d)& C2,
const Standard_Real U1,
const Standard_Real U2,
const Standard_Real V1,
-void Extrema_ExtCC2d::Initialize(const Adaptor2d_Curve2d& C2,
+void Extrema_ExtCC2d::Initialize(const Handle(Adaptor2d_Curve2d)& C2,
const Standard_Real V1,
const Standard_Real V2,
const Standard_Real TolC1,
const Standard_Real TolC2)
{
- myC = &C2;
+ myC = C2;
myv1 = V1;
myv2 = V2;
mytolc1 = TolC1;
-void Extrema_ExtCC2d::Perform (const Adaptor2d_Curve2d& C1,
+void Extrema_ExtCC2d::Perform (const Handle(Adaptor2d_Curve2d)& C1,
const Standard_Real U1,
const Standard_Real U2)
{
mypoints.Clear();
mySqDist.Clear();
- GeomAbs_CurveType type1 = Extrema_Curve2dTool::GetType(C1), type2 = Extrema_Curve2dTool::GetType (*myC);
+ GeomAbs_CurveType type1 = Extrema_Curve2dTool::GetType(C1), type2 = Extrema_Curve2dTool::GetType (myC);
Standard_Real U11, U12, U21, U22, Tol = Min(mytolc1, mytolc2);
// Extrema_POnCurv2d P1, P2;
mynbext = 0;
U22 = myv2;
P1f = Extrema_Curve2dTool::Value(C1, U11);
P1l = Extrema_Curve2dTool::Value(C1, U12);
- P2f = Extrema_Curve2dTool::Value(*myC, U21);
- P2l = Extrema_Curve2dTool::Value(*myC, U22);
+ P2f = Extrema_Curve2dTool::Value(myC, U21);
+ P2l = Extrema_Curve2dTool::Value(myC, U22);
switch(type1) {
switch(type2) {
case GeomAbs_Line: {
inverse = Standard_True;
- Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Line(*myC), Extrema_Curve2dTool::Circle(C1), Tol);
+ Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Line(myC), Extrema_Curve2dTool::Circle(C1), Tol);
Results(Xtrem, U11, U12, U21, U22, 2*M_PI, 0.);
}
break;
case GeomAbs_Circle: {
- Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Circle(C1), Extrema_Curve2dTool::Circle(*myC));
+ Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Circle(C1), Extrema_Curve2dTool::Circle(myC));
Results(Xtrem, U11, U12, U21, U22, 2*M_PI, 2*M_PI);
}
break;
case GeomAbs_Ellipse: {
- Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Circle(C1), Extrema_Curve2dTool::Ellipse(*myC));
+ Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Circle(C1), Extrema_Curve2dTool::Ellipse(myC));
Results(Xtrem, U11, U12, U21, U22, 2*M_PI, 2*M_PI );
}
break;
case GeomAbs_Parabola: {
- Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Circle(C1), Extrema_Curve2dTool::Parabola(*myC));
+ Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Circle(C1), Extrema_Curve2dTool::Parabola(myC));
Results(Xtrem, U11, U12, U21, U22, 2*M_PI, 0.);
}
break;
case GeomAbs_Hyperbola: {
- Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Circle(C1), Extrema_Curve2dTool::Hyperbola(*myC));
+ Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Circle(C1), Extrema_Curve2dTool::Hyperbola(myC));
Results(Xtrem, U11, U12, U21, U22, 2*M_PI, 0. );
}
break;
default: {
- Extrema_ECC2d aParamSolver(C1, *myC);
+ Extrema_ECC2d aParamSolver(C1, myC);
aParamSolver.SetSingleSolutionFlag(GetSingleSolutionFlag());
aParamSolver.Perform();
Standard_Real Period2 = 0.;
- if (Extrema_Curve2dTool::IsPeriodic(*myC)) Period2 = Extrema_Curve2dTool::Period(*myC);
+ if (Extrema_Curve2dTool::IsPeriodic(myC)) Period2 = Extrema_Curve2dTool::Period(myC);
Results(aParamSolver, U11, U12, U21, U22, 2*M_PI,Period2);
}
break;
switch(type2) {
case GeomAbs_Line: {
inverse = Standard_True;
- Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Line(*myC), Extrema_Curve2dTool::Ellipse(C1));
+ Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Line(myC), Extrema_Curve2dTool::Ellipse(C1));
Results(Xtrem, U11, U12, U21, U22, 2*M_PI, 0.);
}
break;
case GeomAbs_Circle: {
inverse = Standard_True;
- Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Circle(*myC), Extrema_Curve2dTool::Ellipse(C1));
+ Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Circle(myC), Extrema_Curve2dTool::Ellipse(C1));
Results(Xtrem, U11, U12, U21, U22, 2*M_PI, 2*M_PI);
}
break;
case GeomAbs_Ellipse:
{
- Extrema_ECC2d aParamSolver(C1, *myC);
+ Extrema_ECC2d aParamSolver(C1, myC);
aParamSolver.SetSingleSolutionFlag(GetSingleSolutionFlag());
aParamSolver.Perform();
Results(aParamSolver, U11, U12, U21, U22,2*M_PI, 2*M_PI);
}
break;
case GeomAbs_Parabola: {
- //Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Ellipse(C1), Extrema_Curve2dTool::Parabola(*myC));
- Extrema_ECC2d aParamSolver(C1, *myC);
+ //Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Ellipse(C1), Extrema_Curve2dTool::Parabola(myC));
+ Extrema_ECC2d aParamSolver(C1, myC);
aParamSolver.SetSingleSolutionFlag(GetSingleSolutionFlag());
aParamSolver.Perform();
Results(aParamSolver, U11, U12, U21, U22, 2*M_PI, 0.);
}
break;
case GeomAbs_Hyperbola: {
- //Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Ellipse(C1), Extrema_Curve2dTool::Hyperbola(*myC));
- Extrema_ECC2d aParamSolver(C1, *myC);
+ //Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Ellipse(C1), Extrema_Curve2dTool::Hyperbola(myC));
+ Extrema_ECC2d aParamSolver(C1, myC);
aParamSolver.SetSingleSolutionFlag(GetSingleSolutionFlag());
aParamSolver.Perform();
Results(aParamSolver, U11, U12, U21, U22, 2*M_PI, 0.);
}
break;
default: {
- Extrema_ECC2d aParamSolver(C1, *myC);
+ Extrema_ECC2d aParamSolver(C1, myC);
aParamSolver.SetSingleSolutionFlag(GetSingleSolutionFlag());
aParamSolver.Perform();
Standard_Real Period2 = 0.;
- if (Extrema_Curve2dTool::IsPeriodic(*myC)) Period2 = Extrema_Curve2dTool::Period(*myC);
+ if (Extrema_Curve2dTool::IsPeriodic(myC)) Period2 = Extrema_Curve2dTool::Period(myC);
Results(aParamSolver, U11, U12, U21, U22, 2*M_PI,Period2);
}
break;
switch(type2) {
case GeomAbs_Line: {
inverse = Standard_True;
- Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Line(*myC), Extrema_Curve2dTool::Parabola(C1));
+ Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Line(myC), Extrema_Curve2dTool::Parabola(C1));
Results(Xtrem, U11, U12, U21, U22, 0., 0.);
}
break;
case GeomAbs_Circle: {
inverse = Standard_True;
- Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Circle(*myC), Extrema_Curve2dTool::Parabola(C1));
+ Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Circle(myC), Extrema_Curve2dTool::Parabola(C1));
Results(Xtrem, U11, U12, U21, U22, 0., 2*M_PI);
}
break;
case GeomAbs_Ellipse: {
//inverse = Standard_True;
- //Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Ellipse(*myC), Extrema_Curve2dTool::Parabola(C1));
- Extrema_ECC2d aParamSolver(C1, *myC);
+ //Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Ellipse(myC), Extrema_Curve2dTool::Parabola(C1));
+ Extrema_ECC2d aParamSolver(C1, myC);
aParamSolver.SetSingleSolutionFlag(GetSingleSolutionFlag());
aParamSolver.Perform();
Results(aParamSolver, U11, U12, U21, U22, 0., 2*M_PI);
}
break;
case GeomAbs_Parabola: {
- //Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Parabola(C1), Extrema_Curve2dTool::Parabola(*myC));
- Extrema_ECC2d aParamSolver(C1, *myC);
+ //Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Parabola(C1), Extrema_Curve2dTool::Parabola(myC));
+ Extrema_ECC2d aParamSolver(C1, myC);
aParamSolver.SetSingleSolutionFlag(GetSingleSolutionFlag());
aParamSolver.Perform();
Results(aParamSolver, U11, U12, U21, U22, 0., 0.);
break;
case GeomAbs_Hyperbola: {
//inverse = Standard_True;
- //Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Hyperbola(*myC), Extrema_Curve2dTool::Parabola(C1));
- Extrema_ECC2d aParamSolver(C1, *myC);
+ //Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Hyperbola(myC), Extrema_Curve2dTool::Parabola(C1));
+ Extrema_ECC2d aParamSolver(C1, myC);
aParamSolver.SetSingleSolutionFlag(GetSingleSolutionFlag());
aParamSolver.Perform();
Results(aParamSolver, U11, U12, U21, U22, 0., 0.);
}
break;
default: {
- Extrema_ECC2d aParamSolver(C1, *myC);
+ Extrema_ECC2d aParamSolver(C1, myC);
aParamSolver.SetSingleSolutionFlag(GetSingleSolutionFlag());
aParamSolver.Perform();
Standard_Real Period2 = 0.;
- if (Extrema_Curve2dTool::IsPeriodic(*myC)) Period2 = Extrema_Curve2dTool::Period(*myC);
+ if (Extrema_Curve2dTool::IsPeriodic(myC)) Period2 = Extrema_Curve2dTool::Period(myC);
Results(aParamSolver, U11, U12, U21, U22, 0., Period2);
}
break;
switch(type2) {
case GeomAbs_Line: {
inverse = Standard_True;
- Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Line(*myC), Extrema_Curve2dTool::Hyperbola(C1));
+ Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Line(myC), Extrema_Curve2dTool::Hyperbola(C1));
Results(Xtrem, U11, U12, U21, U22, 0., 0.);
}
break;
case GeomAbs_Circle: {
inverse = Standard_True;
- Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Circle(*myC), Extrema_Curve2dTool::Hyperbola(C1));
+ Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Circle(myC), Extrema_Curve2dTool::Hyperbola(C1));
Results(Xtrem, U11, U12, U21, U22, 0., 2*M_PI);
}
break;
case GeomAbs_Ellipse: {
//inverse = Standard_True;
- //Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Ellipse(*myC), Extrema_Curve2dTool::Hyperbola(C1));
- Extrema_ECC2d aParamSolver(C1, *myC);
+ //Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Ellipse(myC), Extrema_Curve2dTool::Hyperbola(C1));
+ Extrema_ECC2d aParamSolver(C1, myC);
aParamSolver.SetSingleSolutionFlag(GetSingleSolutionFlag());
aParamSolver.Perform();
Results(aParamSolver, U11, U12, U21, U22, 0., 2*M_PI );
}
break;
case GeomAbs_Parabola: {
- //Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Hyperbola(C1), Extrema_Curve2dTool::Parabola(*myC));
- Extrema_ECC2d aParamSolver(C1, *myC);
+ //Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Hyperbola(C1), Extrema_Curve2dTool::Parabola(myC));
+ Extrema_ECC2d aParamSolver(C1, myC);
aParamSolver.SetSingleSolutionFlag(GetSingleSolutionFlag());
aParamSolver.Perform();
Results(aParamSolver, U11, U12, U21, U22, 0., 0.);
}
break;
case GeomAbs_Hyperbola: {
- //Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Hyperbola(C1), Extrema_Curve2dTool::Hyperbola(*myC));
- Extrema_ECC2d aParamSolver(C1, *myC);
+ //Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Hyperbola(C1), Extrema_Curve2dTool::Hyperbola(myC));
+ Extrema_ECC2d aParamSolver(C1, myC);
aParamSolver.SetSingleSolutionFlag(GetSingleSolutionFlag());
aParamSolver.Perform();
Results(aParamSolver, U11, U12, U21, U22, 0., 0.);
}
break;
default: {
- Extrema_ECC2d aParamSolver(C1, *myC);
+ Extrema_ECC2d aParamSolver(C1, myC);
aParamSolver.SetSingleSolutionFlag(GetSingleSolutionFlag());
aParamSolver.Perform();
Standard_Real Period2 = 0.;
- if (Extrema_Curve2dTool::IsPeriodic(*myC)) Period2 = Extrema_Curve2dTool::Period(*myC);
+ if (Extrema_Curve2dTool::IsPeriodic(myC)) Period2 = Extrema_Curve2dTool::Period(myC);
Results(aParamSolver, U11, U12, U21, U22, 0., Period2);
}
break;
switch(type2) {
case GeomAbs_Line: {
- Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Line(C1), Extrema_Curve2dTool::Line(*myC), Tol);
+ Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Line(C1), Extrema_Curve2dTool::Line(myC), Tol);
Results(Xtrem, U11, U12, U21, U22, 0., 0.);
}
break;
case GeomAbs_Circle: {
- Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Line(C1), Extrema_Curve2dTool::Circle(*myC), Tol);
+ Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Line(C1), Extrema_Curve2dTool::Circle(myC), Tol);
Results(Xtrem, U11, U12, U21, U22, 0., 2*M_PI);
}
break;
case GeomAbs_Ellipse: {
- Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Line(C1), Extrema_Curve2dTool::Ellipse(*myC));
+ Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Line(C1), Extrema_Curve2dTool::Ellipse(myC));
Results(Xtrem, U11, U12, U21, U22, 0., 2*M_PI);
}
break;
case GeomAbs_Parabola: {
- Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Line(C1), Extrema_Curve2dTool::Parabola(*myC));
+ Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Line(C1), Extrema_Curve2dTool::Parabola(myC));
Results(Xtrem, U11, U12, U21, U22, 0., 0.);
}
break;
case GeomAbs_Hyperbola: {
- Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Line(C1), Extrema_Curve2dTool::Hyperbola(*myC));
+ Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Line(C1), Extrema_Curve2dTool::Hyperbola(myC));
Results(Xtrem, U11, U12, U21, U22, 0., 0.);
}
break;
default: {
- Extrema_ECC2d aParamSolver(C1, *myC);
+ Extrema_ECC2d aParamSolver(C1, myC);
aParamSolver.SetSingleSolutionFlag(GetSingleSolutionFlag());
aParamSolver.Perform();
Standard_Real Period2 = 0.;
- if (Extrema_Curve2dTool::IsPeriodic(*myC)) Period2 = Extrema_Curve2dTool::Period(*myC);
+ if (Extrema_Curve2dTool::IsPeriodic(myC)) Period2 = Extrema_Curve2dTool::Period(myC);
Results(aParamSolver, U11, U12, U21, U22, 0., Period2);
}
break;
// La premiere courbe est une BezierCurve ou une BSplineCurve:
//
default: {
- Extrema_ECC2d aParamSolver(C1, *myC);
+ Extrema_ECC2d aParamSolver(C1, myC);
aParamSolver.SetSingleSolutionFlag(GetSingleSolutionFlag());
aParamSolver.Perform();
Standard_Real Period1 = 0.;
if (Extrema_Curve2dTool::IsPeriodic(C1)) Period1 = Extrema_Curve2dTool::Period(C1);
Standard_Real Period2 = 0.;
- if (Extrema_Curve2dTool::IsPeriodic(*myC)) Period2 = Extrema_Curve2dTool::Period(*myC);
+ if (Extrema_Curve2dTool::IsPeriodic(myC)) Period2 = Extrema_Curve2dTool::Period(myC);
Results(aParamSolver, U11, U12, U21, U22, Period1, Period2);
}
break;
Standard_EXPORT Extrema_ExtCC2d();
//! It calculates all the distances.
- Standard_EXPORT Extrema_ExtCC2d(const Adaptor2d_Curve2d& C1, const Adaptor2d_Curve2d& C2, const Standard_Real TolC1 = 1.0e-10, const Standard_Real TolC2 = 1.0e-10);
+ Standard_EXPORT Extrema_ExtCC2d(const Handle(Adaptor2d_Curve2d)& C1, const Handle(Adaptor2d_Curve2d)& C2, const Standard_Real TolC1 = 1.0e-10, const Standard_Real TolC2 = 1.0e-10);
//! It calculates all the distances.
- Standard_EXPORT Extrema_ExtCC2d(const Adaptor2d_Curve2d& C1, const Adaptor2d_Curve2d& C2, const Standard_Real U1, const Standard_Real U2, const Standard_Real V1, const Standard_Real V2, const Standard_Real TolC1 = 1.0e-10, const Standard_Real TolC2 = 1.0e-10);
+ Standard_EXPORT Extrema_ExtCC2d(const Handle(Adaptor2d_Curve2d)& C1, const Handle(Adaptor2d_Curve2d)& C2, const Standard_Real U1, const Standard_Real U2, const Standard_Real V1, const Standard_Real V2, const Standard_Real TolC1 = 1.0e-10, const Standard_Real TolC2 = 1.0e-10);
//! initializes the fields.
- Standard_EXPORT void Initialize (const Adaptor2d_Curve2d& C2, const Standard_Real V1, const Standard_Real V2, const Standard_Real TolC1 = 1.0e-10, const Standard_Real TolC2 = 1.0e-10);
+ Standard_EXPORT void Initialize (const Handle(Adaptor2d_Curve2d)& C2, const Standard_Real V1, const Standard_Real V2, const Standard_Real TolC1 = 1.0e-10, const Standard_Real TolC2 = 1.0e-10);
- Standard_EXPORT void Perform (const Adaptor2d_Curve2d& C1, const Standard_Real U1, const Standard_Real U2);
+ Standard_EXPORT void Perform (const Handle(Adaptor2d_Curve2d)& C1, const Standard_Real U1, const Standard_Real U2);
//! Returns True if the distances are found.
Standard_EXPORT Standard_Boolean IsDone() const;
TColStd_SequenceOfReal mySqDist;
Standard_Integer mynbext;
Standard_Boolean inverse;
- const Adaptor2d_Curve2d* myC;
+ Handle(Adaptor2d_Curve2d) myC;
Standard_Real myv1;
Standard_Real myv2;
Standard_Real mytolc1;
{
}
-Extrema_ExtCS::Extrema_ExtCS(const Adaptor3d_Curve& C,
- const Adaptor3d_Surface& S,
+Extrema_ExtCS::Extrema_ExtCS(const Handle(Adaptor3d_Curve)& C,
+ const Handle(Adaptor3d_Surface)& S,
const Standard_Real TolC,
const Standard_Real TolS)
{
Initialize (S, TolC, TolS);
- Perform(C, C.FirstParameter(), C.LastParameter());
+ Perform(C, C->FirstParameter(), C->LastParameter());
}
-Extrema_ExtCS::Extrema_ExtCS(const Adaptor3d_Curve& C,
- const Adaptor3d_Surface& S,
+Extrema_ExtCS::Extrema_ExtCS(const Handle(Adaptor3d_Curve)& C,
+ const Handle(Adaptor3d_Surface)& S,
const Standard_Real UCinf,
const Standard_Real UCsup,
const Standard_Real Uinf,
Perform(C, UCinf, UCsup);
}
-void Extrema_ExtCS::Initialize (const Adaptor3d_Surface& S, const Standard_Real TolC, const Standard_Real TolS)
+void Extrema_ExtCS::Initialize (const Handle(Adaptor3d_Surface)& S, const Standard_Real TolC, const Standard_Real TolS)
{
- Initialize (S, S.FirstUParameter(), S.LastUParameter(),
- S.FirstVParameter(), S.LastVParameter(),
+ Initialize (S, S->FirstUParameter(), S->LastUParameter(),
+ S->FirstVParameter(), S->LastVParameter(),
TolC, TolS);
}
-void Extrema_ExtCS::Initialize(const Adaptor3d_Surface& S,
+void Extrema_ExtCS::Initialize(const Handle(Adaptor3d_Surface)& S,
const Standard_Real Uinf,
const Standard_Real Usup,
const Standard_Real Vinf,
const Standard_Real TolC,
const Standard_Real TolS)
{
- myS = &S;
+ myS = S;
myIsPar = Standard_False;
myuinf = Uinf;
myusup = Usup;
}
-void Extrema_ExtCS::Perform(const Adaptor3d_Curve& C,
+void Extrema_ExtCS::Perform(const Handle(Adaptor3d_Curve)& C,
const Standard_Real Uinf,
const Standard_Real Usup)
{
Standard_Integer i, j;
Standard_Integer NbT, NbU, NbV;
NbT = 12; NbU = NbV = 10;
- GeomAbs_CurveType myCtype = C.GetType();
+ GeomAbs_CurveType myCtype = C->GetType();
myDone = Standard_False;
// Try analytic computation of extrema
switch(myStype) {
case GeomAbs_Sphere:
- myExtElCS.Perform(C.Line(), myS->Sphere());
+ myExtElCS.Perform(C->Line(), myS->Sphere());
break;
case GeomAbs_Cylinder:
- myExtElCS.Perform(C.Line(), myS->Cylinder());
+ myExtElCS.Perform(C->Line(), myS->Cylinder());
break;
case GeomAbs_Plane:
- myExtElCS.Perform(C.Line(), myS->Plane());
+ myExtElCS.Perform(C->Line(), myS->Plane());
if (myExtElCS.IsParallel()) break;
Standard_FALLTHROUGH
Standard_Real tmin = Precision::Infinite(), tmax = -tmin;
Standard_Real xmin, ymin, zmin, xmax, ymax, zmax;
Bnd_Box aSurfBox;
- BndLib_AddSurface::Add(*myS, ufirst, ulast, vfirst, vlast, Precision::Confusion(), aSurfBox);
+ BndLib_AddSurface::Add(myS, ufirst, ulast, vfirst, vlast, Precision::Confusion(), aSurfBox);
aSurfBox.Get(xmin, ymin, zmin, xmax, ymax, zmax);
- gp_Lin aLin = C.Line();
+ gp_Lin aLin = C->Line();
Standard_Real aParOnLin;
gp_Pnt aLimPntArray[8];
if (clast - cfirst <= Precision::Confusion())
{
Standard_Real aCPar = (cfirst + clast) / 2.;
- gp_Pnt aPm = C.Value(aCPar);
- Extrema_ExtPS anExtPS(aPm, *myS, ufirst, ulast,
+ gp_Pnt aPm = C->Value(aCPar);
+ Extrema_ExtPS anExtPS(aPm, myS, ufirst, ulast,
vfirst, vlast, mytolS, mytolS, Extrema_ExtFlag_MIN);
myDone = anExtPS.IsDone();
if (myDone) {
return;
}
- Extrema_GenExtCS Ext(C, *myS, NbT, NbU, NbV, cfirst, clast, ufirst, ulast,
+ Extrema_GenExtCS Ext(C, myS, NbT, NbU, NbV, cfirst, clast, ufirst, ulast,
vfirst, vlast, mytolC, mytolS);
myDone = Ext.IsDone();
case GeomAbs_Circle:
{
if(myStype == GeomAbs_Cylinder) {
- myExtElCS.Perform(C.Circle(), myS->Cylinder());
+ myExtElCS.Perform(C->Circle(), myS->Cylinder());
break;
}
else if(myStype == GeomAbs_Plane)
{
- myExtElCS.Perform(C.Circle(), myS->Plane());
+ myExtElCS.Perform(C->Circle(), myS->Plane());
break;
}
else if (myStype == GeomAbs_Sphere)
{
- myExtElCS.Perform(C.Circle(), myS->Sphere());
+ myExtElCS.Perform(C->Circle(), myS->Sphere());
break;
}
}
{
if(myCtype == GeomAbs_Hyperbola && myStype == GeomAbs_Plane) {
// Modified by skv - Thu Jul 7 12:29:34 2005 OCC9134 End
- myExtElCS.Perform(C.Hyperbola(), myS->Plane());
+ myExtElCS.Perform(C->Hyperbola(), myS->Plane());
break;
}
}
if (Precision::IsInfinite(aT[i]))
continue;
- aPOnC[i] = C.Value(aT[i]);
+ aPOnC[i] = C->Value(aT[i]);
switch (myStype)
{
case GeomAbs_Plane:
// Elementary extrema is not done, try generic solution
Extrema_GenExtCS Ext;
- Ext.Initialize(*myS, NbU, NbV, mytolS);
+ Ext.Initialize(myS, NbU, NbV, mytolS);
if (myCtype == GeomAbs_Hyperbola) {
- Standard_Real tmin = Max(-20., C.FirstParameter());
- Standard_Real tmax = Min(20., C.LastParameter());
+ Standard_Real tmin = Max(-20., C->FirstParameter());
+ Standard_Real tmax = Min(20., C->LastParameter());
Ext.Perform(C, NbT, tmin, tmax, mytolC); // to avoid overflow
}
else {
//Add sharp points
Standard_Integer SolNumber = mySqDist.Length();
- Standard_Address CopyC = (Standard_Address)&C;
- Adaptor3d_Curve& aC = *(Adaptor3d_Curve*)CopyC;
- Standard_Integer NbIntervals = aC.NbIntervals(GeomAbs_C1);
+ Standard_Integer NbIntervals = C->NbIntervals(GeomAbs_C1);
TColStd_Array1OfReal SharpPoints(1, NbIntervals + 1);
- aC.Intervals(SharpPoints, GeomAbs_C1);
+ C->Intervals(SharpPoints, GeomAbs_C1);
Extrema_ExtPS aProjPS;
- aProjPS.Initialize(*myS,
+ aProjPS.Initialize(myS,
myS->FirstUParameter(),
myS->LastUParameter(),
myS->FirstVParameter(),
for (i = 2; i < SharpPoints.Upper(); ++i)
{
T = SharpPoints(i);
- gp_Pnt aPnt = C.Value(T);
+ gp_Pnt aPnt = C->Value(T);
aProjPS.Perform(aPnt);
if (!aProjPS.IsDone())
continue;
P2 = myPOnS.Value(N);
}
-Standard_Boolean Extrema_ExtCS::AddSolution(const Adaptor3d_Curve& theCurve,
+Standard_Boolean Extrema_ExtCS::AddSolution(const Handle(Adaptor3d_Curve)& theCurve,
const Standard_Real aT,
const Standard_Real aU,
const Standard_Real aV,
Standard_Real T = aT, U = aU, V = aV;
- if (theCurve.IsPeriodic())
- T = ElCLib::InPeriod(T, myucinf, myucinf + theCurve.Period());
+ if (theCurve->IsPeriodic())
+ T = ElCLib::InPeriod(T, myucinf, myucinf + theCurve->Period());
if (myS->IsUPeriodic())
U = ElCLib::InPeriod(U, myuinf, myuinf + myS->UPeriod());
if (myS->IsVPeriodic())
Standard_EXPORT Extrema_ExtCS();
//! It calculates all the distances between C and S.
- Standard_EXPORT Extrema_ExtCS(const Adaptor3d_Curve& C, const Adaptor3d_Surface& S, const Standard_Real TolC, const Standard_Real TolS);
+ Standard_EXPORT Extrema_ExtCS(const Handle(Adaptor3d_Curve)& C, const Handle(Adaptor3d_Surface)& S, const Standard_Real TolC, const Standard_Real TolS);
//! It calculates all the distances between C and S.
//! UCinf and UCmax are the start and end parameters
//! of the curve.
- Standard_EXPORT Extrema_ExtCS(const Adaptor3d_Curve& C, const Adaptor3d_Surface& S, const Standard_Real UCinf, const Standard_Real UCsup, const Standard_Real Uinf, const Standard_Real Usup, const Standard_Real Vinf, const Standard_Real Vsup, const Standard_Real TolC, const Standard_Real TolS);
+ Standard_EXPORT Extrema_ExtCS(const Handle(Adaptor3d_Curve)& C, const Handle(Adaptor3d_Surface)& S, const Standard_Real UCinf, const Standard_Real UCsup, const Standard_Real Uinf, const Standard_Real Usup, const Standard_Real Vinf, const Standard_Real Vsup, const Standard_Real TolC, const Standard_Real TolS);
//! Initializes the fields of the algorithm.
- Standard_EXPORT void Initialize (const Adaptor3d_Surface& S, const Standard_Real TolC, const Standard_Real TolS);
+ Standard_EXPORT void Initialize (const Handle(Adaptor3d_Surface)& S, const Standard_Real TolC, const Standard_Real TolS);
//! Initializes the fields of the algorithm.
- Standard_EXPORT void Initialize (const Adaptor3d_Surface& S, const Standard_Real Uinf, const Standard_Real Usup, const Standard_Real Vinf, const Standard_Real Vsup, const Standard_Real TolC, const Standard_Real TolS);
+ Standard_EXPORT void Initialize (const Handle(Adaptor3d_Surface)& S, const Standard_Real Uinf, const Standard_Real Usup, const Standard_Real Vinf, const Standard_Real Vsup, const Standard_Real TolC, const Standard_Real TolS);
//! Computes the distances.
//! An exception is raised if the fieds have not been
//! initialized.
- Standard_EXPORT void Perform (const Adaptor3d_Curve& C, const Standard_Real Uinf, const Standard_Real Usup);
+ Standard_EXPORT void Perform (const Handle(Adaptor3d_Curve)& C, const Standard_Real Uinf, const Standard_Real Usup);
//! Returns True if the distances are found.
Standard_EXPORT Standard_Boolean IsDone() const;
private:
- Standard_EXPORT Standard_Boolean AddSolution (const Adaptor3d_Curve& Curve, const Standard_Real T, const Standard_Real U, const Standard_Real V, const gp_Pnt& PointOnCurve, const gp_Pnt& PointOnSurf, const Standard_Real SquareDist);
+ Standard_EXPORT Standard_Boolean AddSolution (const Handle(Adaptor3d_Curve)& Curve, const Standard_Real T, const Standard_Real U, const Standard_Real V, const gp_Pnt& PointOnCurve, const gp_Pnt& PointOnSurf, const Standard_Real SquareDist);
private:
private:
- const Adaptor3d_Surface* myS;
+ Handle(Adaptor3d_Surface) myS;
Standard_Boolean myDone;
Standard_Boolean myIsPar;
Extrema_ExtElCS myExtElCS;
//! iterations according to the following condition:
//! if n is the number of iterations,
//! the algorithm stops when abs(F(Un)-F(Un-1)) < Tol.
- Standard_EXPORT Extrema_ExtPC(const gp_Pnt& P, const Adaptor3d_Curve& C, const Standard_Real Uinf, const Standard_Real Usup, const Standard_Real TolF = 1.0e-10);
+ Standard_EXPORT Extrema_ExtPC(const gp_Pnt& P, const Handle(Adaptor3d_Curve)& C, const Standard_Real Uinf, const Standard_Real Usup, const Standard_Real TolF = 1.0e-10);
//! It calculates all the distances.
//! The function F(u)=distance(P,C(u)) has an extremum
//! iterations according to the following condition:
//! if n is the number of iterations,
//! the algorithm stops when abs(F(Un)-F(Un-1)) < Tol.
- Standard_EXPORT Extrema_ExtPC(const gp_Pnt& P, const Adaptor3d_Curve& C, const Standard_Real TolF = 1.0e-10);
+ Standard_EXPORT Extrema_ExtPC(const gp_Pnt& P, const Handle(Adaptor3d_Curve)& C, const Standard_Real TolF = 1.0e-10);
//! initializes the fields of the algorithm.
- Standard_EXPORT void Initialize (const Adaptor3d_Curve& C, const Standard_Real Uinf, const Standard_Real Usup, const Standard_Real TolF = 1.0e-10);
+ Standard_EXPORT void Initialize (const Handle(Adaptor3d_Curve)& C, const Standard_Real Uinf, const Standard_Real Usup, const Standard_Real TolF = 1.0e-10);
//! An exception is raised if the fields have not been
//! initialized.
//! iterations according to the following condition:
//! if n is the number of iterations,
//! the algorithm stops when abs(F(Un)-F(Un-1)) < Tol.
- Standard_EXPORT Extrema_ExtPC2d(const gp_Pnt2d& P, const Adaptor2d_Curve2d& C, const Standard_Real Uinf, const Standard_Real Usup, const Standard_Real TolF = 1.0e-10);
+ Standard_EXPORT Extrema_ExtPC2d(const gp_Pnt2d& P, const Handle(Adaptor2d_Curve2d)& C, const Standard_Real Uinf, const Standard_Real Usup, const Standard_Real TolF = 1.0e-10);
//! It calculates all the distances.
//! The function F(u)=distance(P,C(u)) has an extremum
//! iterations according to the following condition:
//! if n is the number of iterations,
//! the algorithm stops when abs(F(Un)-F(Un-1)) < Tol.
- Standard_EXPORT Extrema_ExtPC2d(const gp_Pnt2d& P, const Adaptor2d_Curve2d& C, const Standard_Real TolF = 1.0e-10);
+ Standard_EXPORT Extrema_ExtPC2d(const gp_Pnt2d& P, const Handle(Adaptor2d_Curve2d)& C, const Standard_Real TolF = 1.0e-10);
//! initializes the fields of the algorithm.
- Standard_EXPORT void Initialize (const Adaptor2d_Curve2d& C, const Standard_Real Uinf, const Standard_Real Usup, const Standard_Real TolF = 1.0e-10);
+ Standard_EXPORT void Initialize (const Handle(Adaptor2d_Curve2d)& C, const Standard_Real Uinf, const Standard_Real Usup, const Standard_Real TolF = 1.0e-10);
//! An exception is raised if the fields have not been
//! initialized.
#include <Extrema_PCFOfEPCOfExtPC2d.hxx>
-#define TheCurve Adaptor2d_Curve2d
+#define TheCurve Handle(Adaptor2d_Curve2d)
#define TheCurve_hxx <Adaptor2d_Curve2d.hxx>
#define TheCurveTool Extrema_Curve2dTool
#define TheCurveTool_hxx <Extrema_Curve2dTool.hxx>
#include <Extrema_PCFOfEPCOfExtPC.hxx>
-#define TheCurve Adaptor3d_Curve
+#define TheCurve Handle(Adaptor3d_Curve)
#define TheCurve_hxx <Adaptor3d_Curve.hxx>
#define TheCurveTool Extrema_CurveTool
#define TheCurveTool_hxx <Extrema_CurveTool.hxx>
Handle(Adaptor3d_Curve) anACurve = theS->BasisCurve();
- myF.Initialize (*theS);
+ myF.Initialize (theS);
myC = anACurve;
myS = theS;
myPosition = GetPosition(myC);
if (!myIsAnalyticallyComputable)
{
- myExtPS.Initialize (*theS,
+ myExtPS.Initialize (theS,
32,
32,
theUinf,
//=======================================================================
static Standard_Boolean IsExtremum (const Standard_Real U, const Standard_Real V,
- const gp_Pnt& P, const Adaptor3d_Surface* S,
+ const gp_Pnt& P, const Handle(Adaptor3d_Surface) S,
gp_Pnt& E, Standard_Real& Dist2,
const Standard_Boolean IsVSup,
const Standard_Boolean IsMin)
aNbv = 100;
}
- myExtPS.Initialize (*theS,
+ myExtPS.Initialize (theS,
aNbu,
aNbv,
theUmin,
//function : IsoIsDeg
//purpose :
//=======================================================================
-static Standard_Boolean IsoIsDeg (const Adaptor3d_Surface& S,
+static Standard_Boolean IsoIsDeg (const Handle(Adaptor3d_Surface)& S,
const Standard_Real Param,
const GeomAbs_IsoType IT,
const Standard_Real TolMin,
{
Standard_Real U1=0.,U2=0.,V1=0.,V2=0.,T;
Standard_Boolean Along = Standard_True;
- U1 = S.FirstUParameter();
- U2 = S.LastUParameter();
- V1 = S.FirstVParameter();
- V2 = S.LastVParameter();
+ U1 = S->FirstUParameter();
+ U2 = S->LastUParameter();
+ V1 = S->FirstVParameter();
+ V2 = S->LastVParameter();
gp_Vec D1U,D1V;
gp_Pnt P;
Standard_Real Step,D1NormMax;
for (T=U1;T<=U2;T=T+Step)
{
- S.D1(T,Param,P,D1U,D1V);
+ S->D1(T,Param,P,D1U,D1V);
D1NormMax=Max(D1NormMax,D1U.Magnitude());
}
D1NormMax=0.;
for (T=V1;T<=V2;T=T+Step)
{
- S.D1(Param,T,P,D1U,D1V);
+ S->D1(Param,T,P,D1U,D1V);
D1NormMax=Max(D1NormMax,D1V.Magnitude());
}
//=======================================================================
Extrema_ExtPS::Extrema_ExtPS (const gp_Pnt& theP,
- const Adaptor3d_Surface& theS,
+ const Handle(Adaptor3d_Surface)& theS,
const Standard_Real theTolU,
const Standard_Real theTolV,
const Extrema_ExtFlag theF,
myExtPS.SetAlgo (theA);
Initialize (theS,
- theS.FirstUParameter(),
- theS.LastUParameter(),
- theS.FirstVParameter(),
- theS.LastVParameter(),
+ theS->FirstUParameter(),
+ theS->LastUParameter(),
+ theS->FirstVParameter(),
+ theS->LastVParameter(),
theTolU,
theTolV);
//=======================================================================
Extrema_ExtPS::Extrema_ExtPS (const gp_Pnt& theP,
- const Adaptor3d_Surface& theS,
+ const Handle(Adaptor3d_Surface)& theS,
const Standard_Real theUinf,
const Standard_Real theUsup,
const Standard_Real theVinf,
//purpose :
//=======================================================================
-void Extrema_ExtPS::Initialize (const Adaptor3d_Surface& theS,
+void Extrema_ExtPS::Initialize (const Handle(Adaptor3d_Surface)& theS,
const Standard_Real theUinf,
const Standard_Real theUsup,
const Standard_Real theVinf,
const Standard_Real theTolU,
const Standard_Real theTolV)
{
- myS = &theS;
+ myS = theS;
myuinf = theUinf;
myusup = theUsup;
myvinf = theVinf;
if(bUIsoIsDeg) nbU = 300;
if(bVIsoIsDeg) nbV = 300;
- myExtPS.Initialize(*myS, nbU, nbV, myuinf, myusup, myvinf, myvsup, mytolu, mytolv);
+ myExtPS.Initialize(myS, nbU, nbV, myuinf, myusup, myvinf, myvsup, mytolu, mytolv);
myExtPExtS.Nullify();
myExtPRevS.Nullify();
//! TolU et TolV are used to determine the conditions
//! to stop the iterations; at the iteration number n:
//! (Un - Un-1) < TolU and (Vn - Vn-1) < TolV .
- Standard_EXPORT Extrema_ExtPS(const gp_Pnt& P, const Adaptor3d_Surface& S, const Standard_Real TolU, const Standard_Real TolV, const Extrema_ExtFlag F = Extrema_ExtFlag_MINMAX, const Extrema_ExtAlgo A = Extrema_ExtAlgo_Grad);
+ Standard_EXPORT Extrema_ExtPS(const gp_Pnt& P, const Handle(Adaptor3d_Surface)& S, const Standard_Real TolU, const Standard_Real TolV, const Extrema_ExtFlag F = Extrema_ExtFlag_MINMAX, const Extrema_ExtAlgo A = Extrema_ExtAlgo_Grad);
//! It calculates all the distances.
//! NbU and NbV are used to locate the close points
//! TolU et TolV are used to determine the conditions
//! to stop the iterations; at the iteration number n:
//! (Un - Un-1) < TolU and (Vn - Vn-1) < TolV .
- Standard_EXPORT Extrema_ExtPS(const gp_Pnt& P, const Adaptor3d_Surface& S, const Standard_Real Uinf, const Standard_Real Usup, const Standard_Real Vinf, const Standard_Real Vsup, const Standard_Real TolU, const Standard_Real TolV, const Extrema_ExtFlag F = Extrema_ExtFlag_MINMAX, const Extrema_ExtAlgo A = Extrema_ExtAlgo_Grad);
+ Standard_EXPORT Extrema_ExtPS(const gp_Pnt& P, const Handle(Adaptor3d_Surface)& S, const Standard_Real Uinf, const Standard_Real Usup, const Standard_Real Vinf, const Standard_Real Vsup, const Standard_Real TolU, const Standard_Real TolV, const Extrema_ExtFlag F = Extrema_ExtFlag_MINMAX, const Extrema_ExtAlgo A = Extrema_ExtAlgo_Grad);
//! Initializes the fields of the algorithm.
- Standard_EXPORT void Initialize (const Adaptor3d_Surface& S, const Standard_Real Uinf, const Standard_Real Usup, const Standard_Real Vinf, const Standard_Real Vsup, const Standard_Real TolU, const Standard_Real TolV);
+ Standard_EXPORT void Initialize (const Handle(Adaptor3d_Surface)& S, const Standard_Real Uinf, const Standard_Real Usup, const Standard_Real Vinf, const Standard_Real Vsup, const Standard_Real TolU, const Standard_Real TolV);
//! Computes the distances.
//! An exception is raised if the fieds have not been
private:
- const Adaptor3d_Surface* myS;
+ Handle(Adaptor3d_Surface) myS;
Standard_Boolean myDone;
Extrema_ExtPElS myExtPElS;
Extrema_GenExtPS myExtPS;
{
}
-Extrema_ExtSS::Extrema_ExtSS(const Adaptor3d_Surface& S1,
- const Adaptor3d_Surface& S2,
+Extrema_ExtSS::Extrema_ExtSS(const Handle(Adaptor3d_Surface)& S1,
+ const Handle(Adaptor3d_Surface)& S2,
const Standard_Real TolS1,
const Standard_Real TolS2)
{
- Initialize(S2, S2.FirstUParameter(),
- S2.LastUParameter(),
- S2.FirstVParameter(),
- S2.LastVParameter(), TolS2);
+ Initialize(S2, S2->FirstUParameter(),
+ S2->LastUParameter(),
+ S2->FirstVParameter(),
+ S2->LastVParameter(), TolS2);
- Perform(S1, S1.FirstUParameter(),
- S1.LastUParameter(),
- S1.FirstVParameter(),
- S1.LastVParameter(), TolS1);
+ Perform(S1, S1->FirstUParameter(),
+ S1->LastUParameter(),
+ S1->FirstVParameter(),
+ S1->LastVParameter(), TolS1);
}
-Extrema_ExtSS::Extrema_ExtSS(const Adaptor3d_Surface& S1,
- const Adaptor3d_Surface& S2,
+Extrema_ExtSS::Extrema_ExtSS(const Handle(Adaptor3d_Surface)& S1,
+ const Handle(Adaptor3d_Surface)& S2,
const Standard_Real Uinf1,
const Standard_Real Usup1,
const Standard_Real Vinf1,
}
-void Extrema_ExtSS::Initialize(const Adaptor3d_Surface& S2,
+void Extrema_ExtSS::Initialize(const Handle(Adaptor3d_Surface)& S2,
const Standard_Real Uinf2,
const Standard_Real Usup2,
const Standard_Real Vinf2,
const Standard_Real Vsup2,
const Standard_Real TolS2)
{
- myS2 = &S2;
+ myS2 = S2;
myIsPar = Standard_False;
myuinf2 = Uinf2;
myusup2 = Usup2;
myvinf2 = Vinf2;
myvsup2 = Vsup2;
mytolS2 = TolS2;
- myStype = S2.GetType();
+ myStype = S2->GetType();
}
-void Extrema_ExtSS::Perform(const Adaptor3d_Surface& S1,
+void Extrema_ExtSS::Perform(const Handle(Adaptor3d_Surface)& S1,
const Standard_Real Uinf1,
const Standard_Real Usup1,
const Standard_Real Vinf1,
myPOnS2.Clear();
mySqDist.Clear();
Standard_Integer i;
- GeomAbs_SurfaceType myS1type = S1.GetType();
+ GeomAbs_SurfaceType myS1type = S1->GetType();
const Standard_Integer NbU = 20, NbV = 20;
switch(myS1type) {
switch(myStype) {
case GeomAbs_Plane:
{
- myExtElSS.Perform(S1.Plane(),myS2->Plane());
+ myExtElSS.Perform(S1->Plane(),myS2->Plane());
}
break;
default:
{
- Extrema_GenExtSS Ext(S1, *myS2, NbU, NbV, mytolS1, mytolS2);
+ Extrema_GenExtSS Ext(S1, myS2, NbU, NbV, mytolS1, mytolS2);
myDone = Ext.IsDone();
if (myDone) {
Standard_Integer NbExt = Ext.NbExt();
PS2 = Ext.PointOnS2(i);
PS1.Parameter(U1, V1);
PS2.Parameter(U2, V2);
- if (S1.IsUPeriodic())
- U1 = ElCLib::InPeriod(U1, myuinf1, myuinf1+S1.UPeriod());
- if (S1.IsVPeriodic())
- V1 = ElCLib::InPeriod(V1, myvinf1, myvinf1+S1.VPeriod());
+ if (S1->IsUPeriodic())
+ U1 = ElCLib::InPeriod(U1, myuinf1, myuinf1 + S1->UPeriod());
+ if (S1->IsVPeriodic())
+ V1 = ElCLib::InPeriod(V1, myvinf1, myvinf1 + S1->VPeriod());
if (myS2->IsUPeriodic())
U2 = ElCLib::InPeriod(U2, myuinf2, myuinf2+myS2->UPeriod());
if (myS2->IsVPeriodic())
}
default:
{
- Extrema_GenExtSS Ext(S1, *myS2, NbU, NbV, mytolS1, mytolS2);
+ Extrema_GenExtSS Ext(S1, myS2, NbU, NbV, mytolS1, mytolS2);
myDone = Ext.IsDone();
if (myDone) {
Standard_Integer NbExt = Ext.NbExt();
PS2 = Ext.PointOnS2(i);
PS1.Parameter(U1, V1);
PS2.Parameter(U2, V2);
- if (S1.IsUPeriodic())
- U1 = ElCLib::InPeriod(U1, myuinf1, myuinf1+S1.UPeriod());
- if (S1.IsVPeriodic())
- V1 = ElCLib::InPeriod(V1, myvinf1, myvinf1+S1.VPeriod());
+ if (S1->IsUPeriodic())
+ U1 = ElCLib::InPeriod(U1, myuinf1, myuinf1 + S1->UPeriod());
+ if (S1->IsVPeriodic())
+ V1 = ElCLib::InPeriod(V1, myvinf1, myvinf1 + S1->VPeriod());
if (myS2->IsUPeriodic())
U2 = ElCLib::InPeriod(U2, myuinf2, myuinf2+myS2->UPeriod());
if (myS2->IsVPeriodic())
Standard_EXPORT Extrema_ExtSS();
//! It calculates all the distances between S1 and S2.
- Standard_EXPORT Extrema_ExtSS(const Adaptor3d_Surface& S1, const Adaptor3d_Surface& S2, const Standard_Real TolS1, const Standard_Real TolS2);
+ Standard_EXPORT Extrema_ExtSS(const Handle(Adaptor3d_Surface)& S1, const Handle(Adaptor3d_Surface)& S2, const Standard_Real TolS1, const Standard_Real TolS2);
//! It calculates all the distances between S1 and S2.
- Standard_EXPORT Extrema_ExtSS(const Adaptor3d_Surface& S1, const Adaptor3d_Surface& S2, const Standard_Real Uinf1, const Standard_Real Usup1, const Standard_Real Vinf1, const Standard_Real Vsup1, const Standard_Real Uinf2, const Standard_Real Usup2, const Standard_Real Vinf2, const Standard_Real Vsup2, const Standard_Real TolS1, const Standard_Real TolS2);
+ Standard_EXPORT Extrema_ExtSS(const Handle(Adaptor3d_Surface)& S1, const Handle(Adaptor3d_Surface)& S2, const Standard_Real Uinf1, const Standard_Real Usup1, const Standard_Real Vinf1, const Standard_Real Vsup1, const Standard_Real Uinf2, const Standard_Real Usup2, const Standard_Real Vinf2, const Standard_Real Vsup2, const Standard_Real TolS1, const Standard_Real TolS2);
//! Initializes the fields of the algorithm.
- Standard_EXPORT void Initialize (const Adaptor3d_Surface& S2, const Standard_Real Uinf2, const Standard_Real Usup2, const Standard_Real Vinf2, const Standard_Real Vsup2, const Standard_Real TolS1);
+ Standard_EXPORT void Initialize (const Handle(Adaptor3d_Surface)& S2, const Standard_Real Uinf2, const Standard_Real Usup2, const Standard_Real Vinf2, const Standard_Real Vsup2, const Standard_Real TolS1);
//! Computes the distances.
//! An exception is raised if the fieds have not been
//! initialized.
- Standard_EXPORT void Perform (const Adaptor3d_Surface& S1, const Standard_Real Uinf1, const Standard_Real Usup1, const Standard_Real Vinf1, const Standard_Real Vsup1, const Standard_Real TolS1);
+ Standard_EXPORT void Perform (const Handle(Adaptor3d_Surface)& S1, const Standard_Real Uinf1, const Standard_Real Usup1, const Standard_Real Vinf1, const Standard_Real Vsup1, const Standard_Real TolS1);
//! Returns True if the distances are found.
Standard_EXPORT Standard_Boolean IsDone() const;
private:
- const Adaptor3d_Surface* myS2;
+ Handle(Adaptor3d_Surface) myS2;
Standard_Boolean myDone;
Standard_Boolean myIsPar;
Extrema_ExtElSS myExtElSS;
Pnt Ptemp; //empty point (is not used below)
Vec VDer; // 1st derivative vector
- Tool1::D1(*((Curve1*)C), u, Ptemp, VDer);
+ Tool1::D1((Curve1::element_type*)(C), u, Ptemp, VDer);
Standard_Real vm = VDer.Magnitude();
if(vm > aMax)
aMax = vm;
Extrema_FuncExtCC::Extrema_FuncExtCC (const Curve1& C1,
const Curve2& C2,
const Standard_Real thetol) :
-myC1 ((Standard_Address)&C1), myC2 ((Standard_Address)&C2),
+myC1 (C1.get()), myC2 (C2.get()),
myTol (thetol)
{
math_Vector V1(1,2), V2(1,2);
- V1(1) = Tool1::FirstParameter(*((Curve1*)myC1));
- V2(1) = Tool1::LastParameter(*((Curve1*)myC1));
- V1(2) = Tool2::FirstParameter(*((Curve2*)myC2));
- V2(2) = Tool2::LastParameter(*((Curve2*)myC2));
+ V1(1) = Tool1::FirstParameter((Curve1::element_type*)(myC1));
+ V2(1) = Tool1::LastParameter((Curve1::element_type*)(myC1));
+ V1(2) = Tool2::FirstParameter((Curve2::element_type*)(myC2));
+ V2(2) = Tool2::LastParameter((Curve2::element_type*)(myC2));
SubIntervalInitialize(V1, V2);
- switch(Tool1::GetType(*((Curve1*)myC1)))
+ switch(Tool1::GetType((Curve1::element_type*)(myC1)))
{
case GeomAbs_BezierCurve:
case GeomAbs_BSplineCurve:
case GeomAbs_OffsetCurve:
case GeomAbs_OtherCurve:
myMaxDerivOrderC1 = MaxOrder;
- myTolC1 = SearchOfTolerance((Standard_Address)&C1);
+ myTolC1 = SearchOfTolerance(C1.get());
break;
default:
myMaxDerivOrderC1 = 0;
break;
}
- switch(Tool2::GetType(*((Curve2*)myC2)))
+ switch(Tool2::GetType((Curve2::element_type*)(myC2)))
{
case GeomAbs_BezierCurve:
case GeomAbs_BSplineCurve:
case GeomAbs_OffsetCurve:
case GeomAbs_OtherCurve:
myMaxDerivOrderC2 = MaxOrder;
- myTolC2 = SearchOfTolerance((Standard_Address)&C2);
+ myTolC2 = SearchOfTolerance(C2.get());
break;
default:
myMaxDerivOrderC2 = 0;
if (theRank == 1)
{
- myC1 = (Standard_Address)&C;
- switch(/*Tool1::GetType(*((Curve1*)myC1))*/ C.GetType())
+ myC1 = C.get();
+ switch(/*Tool1::GetType((Curve1::element_type*)(myC1))*/ C->GetType())
{
case GeomAbs_BezierCurve:
case GeomAbs_BSplineCurve:
case GeomAbs_OffsetCurve:
case GeomAbs_OtherCurve:
myMaxDerivOrderC1 = MaxOrder;
- myTolC1 = SearchOfTolerance((Standard_Address)&C);
+ myTolC1 = SearchOfTolerance(C.get());
break;
default:
myMaxDerivOrderC1 = 0;
}
else if (theRank == 2)
{
- myC2 = (Standard_Address)&C;
- switch(/*Tool2::GetType(*((Curve2*)myC2))*/C.GetType())
+ myC2 = C.get();
+ switch(/*Tool2::GetType((Curve2::element_type*)(myC2))*/C->GetType())
{
case GeomAbs_BezierCurve:
case GeomAbs_BSplineCurve:
case GeomAbs_OffsetCurve:
case GeomAbs_OtherCurve:
myMaxDerivOrderC2 = MaxOrder;
- myTolC2 = SearchOfTolerance((Standard_Address)&C);
+ myTolC2 = SearchOfTolerance(C.get());
break;
default:
myMaxDerivOrderC2 = 0;
{
myU = UV(1);
myV = UV(2);
- Tool1::D1(*((Curve1*)myC1), myU,myP1,myDu);
- Tool2::D1(*((Curve2*)myC2), myV,myP2,myDv);
+ Tool1::D1((Curve1::element_type*)(myC1), myU,myP1,myDu);
+ Tool2::D1((Curve2::element_type*)(myC2), myV,myP2,myDv);
Vec P1P2 (myP1,myP2);
do
{
- V = Tool1::DN(*((Curve1*)myC1),myU,++n);
+ V = Tool1::DN((Curve1::element_type*)(myC1),myU,++n);
Ndu = V.Magnitude();
IsDeriveFound = (Ndu > myTolC1);
}
u = myU-aDelta;
Pnt P1, P2;
- Tool1::D0(*((Curve1*)myC1),Min(myU, u),P1);
- Tool1::D0(*((Curve1*)myC1),Max(myU, u),P2);
+ Tool1::D0((Curve1::element_type*)(myC1),Min(myU, u),P1);
+ Tool1::D0((Curve1::element_type*)(myC1),Max(myU, u),P2);
Vec V1(P1,P2);
Standard_Real aDirFactor = V.Dot(V1);
if(myU-myUinfium < 2*aDelta)
{
- Tool1::D0(*((Curve1*)myC1),myU,P1);
- Tool1::D0(*((Curve1*)myC1),myU+aDelta,P2);
- Tool1::D0(*((Curve1*)myC1),myU+2*aDelta,P3);
+ Tool1::D0((Curve1::element_type*)(myC1), myU, P1);
+ Tool1::D0((Curve1::element_type*)(myC1), myU + aDelta, P2);
+ Tool1::D0((Curve1::element_type*)(myC1), myU + 2*aDelta, P3);
IsParameterGrown = Standard_True;
}
else
{
- Tool1::D0(*((Curve1*)myC1),myU-2*aDelta,P1);
- Tool1::D0(*((Curve1*)myC1),myU-aDelta,P2);
- Tool1::D0(*((Curve1*)myC1),myU,P3);
+ Tool1::D0((Curve1::element_type*)(myC1), myU - 2*aDelta, P1);
+ Tool1::D0((Curve1::element_type*)(myC1), myU - aDelta, P2);
+ Tool1::D0((Curve1::element_type*)(myC1), myU, P3);
IsParameterGrown = Standard_False;
}
do
{
- V = Tool2::DN(*((Curve2*)myC2),myV,++n);
+ V = Tool2::DN((Curve2::element_type*)(myC2),myV,++n);
Ndv = V.Magnitude();
IsDeriveFound = (Ndv > myTolC2);
}
v = myV-aDelta;
Pnt P1, P2;
- Tool2::D0(*((Curve2*)myC2),Min(myV, v),P1);
- Tool2::D0(*((Curve2*)myC2),Max(myV, v),P2);
+ Tool2::D0((Curve2::element_type*)(myC2),Min(myV, v),P1);
+ Tool2::D0((Curve2::element_type*)(myC2),Max(myV, v),P2);
Vec V1(P1,P2);
Standard_Real aDirFactor = V.Dot(V1);
if(myV-myVinfium < 2*aDelta)
{
- Tool2::D0(*((Curve2*)myC2),myV,P1);
- Tool2::D0(*((Curve2*)myC2),myV+aDelta,P2);
- Tool2::D0(*((Curve2*)myC2),myV+2*aDelta,P3);
+ Tool2::D0((Curve2::element_type*)(myC2),myV,P1);
+ Tool2::D0((Curve2::element_type*)(myC2),myV+aDelta,P2);
+ Tool2::D0((Curve2::element_type*)(myC2),myV+2*aDelta,P3);
IsParameterGrown = Standard_True;
}
else
{
- Tool2::D0(*((Curve2*)myC2),myV-2*aDelta,P1);
- Tool2::D0(*((Curve2*)myC2),myV-aDelta,P2);
- Tool2::D0(*((Curve2*)myC2),myV,P3);
+ Tool2::D0((Curve2::element_type*)(myC2),myV-2*aDelta,P1);
+ Tool2::D0((Curve2::element_type*)(myC2),myV-aDelta,P2);
+ Tool2::D0((Curve2::element_type*)(myC2),myV,P3);
IsParameterGrown = Standard_False;
}
}//if(Value(UV, F) == Standard_False)
Vec Du, Dv, Duu, Dvv;
- Tool1::D2(*((Curve1*)myC1), myU,myP1,Du,Duu);
- Tool2::D2(*((Curve2*)myC2), myV,myP2,Dv,Dvv);
+ Tool1::D2((Curve1::element_type*)(myC1), myU,myP1,Du,Duu);
+ Tool2::D2((Curve2::element_type*)(myC2), myV,myP2,Dv,Dvv);
//Calling of "Value(...)" function change class member values.
//After running it is necessary to return to previous values.
//purpose :
//=======================================================================
- Extrema_FuncExtCS::Extrema_FuncExtCS(const Adaptor3d_Curve& C,
- const Adaptor3d_Surface& S)
+ Extrema_FuncExtCS::Extrema_FuncExtCS(const Handle(Adaptor3d_Curve)& C,
+ const Handle(Adaptor3d_Surface)& S)
{
Initialize(C, S);
}
//purpose :
//=======================================================================
-void Extrema_FuncExtCS::Initialize(const Adaptor3d_Curve& C,
- const Adaptor3d_Surface& S)
+void Extrema_FuncExtCS::Initialize(const Handle(Adaptor3d_Curve)& C,
+ const Handle(Adaptor3d_Surface)& S)
{
- myC = &C;
- myS = &S;
+ myC = C;
+ myS = S;
myCinit = Standard_True;
mySinit = Standard_True;
myPoint1.Clear();
Standard_EXPORT Extrema_FuncExtCS();
- Standard_EXPORT Extrema_FuncExtCS(const Adaptor3d_Curve& C, const Adaptor3d_Surface& S);
+ Standard_EXPORT Extrema_FuncExtCS(const Handle(Adaptor3d_Curve)& C, const Handle(Adaptor3d_Surface)& S);
//! sets the field mysurf of the function.
- Standard_EXPORT void Initialize (const Adaptor3d_Curve& C, const Adaptor3d_Surface& S);
+ Standard_EXPORT void Initialize (const Handle(Adaptor3d_Curve)& C, const Handle(Adaptor3d_Surface)& S);
Standard_EXPORT Standard_Integer NbVariables() const Standard_OVERRIDE;
private:
- const Adaptor3d_Curve* myC;
- const Adaptor3d_Surface* myS;
+ Handle(Adaptor3d_Curve) myC;
+ Handle(Adaptor3d_Surface) myS;
gp_Pnt myP1;
gp_Pnt myP2;
Standard_Real myt;
//purpose :
//=======================================================================
-Extrema_FuncExtSS::Extrema_FuncExtSS (const Adaptor3d_Surface& S1,
- const Adaptor3d_Surface& S2)
+Extrema_FuncExtSS::Extrema_FuncExtSS (const Handle(Adaptor3d_Surface)& S1,
+ const Handle(Adaptor3d_Surface)& S2)
: myU1(0.0),
myV1(0.0),
myU2(0.0),
myV2(0.0)
{
- myS1 = &S1;
- myS2 = &S2;
+ myS1 = S1;
+ myS2 = S2;
myS1init = Standard_True;
myS2init = Standard_True;
}
//purpose :
//=======================================================================
-void Extrema_FuncExtSS::Initialize(const Adaptor3d_Surface& S1,
- const Adaptor3d_Surface& S2)
+void Extrema_FuncExtSS::Initialize(const Handle(Adaptor3d_Surface)& S1,
+ const Handle(Adaptor3d_Surface)& S2)
{
- myS1 = &S1;
- myS2 = &S2;
+ myS1 = S1;
+ myS2 = S2;
myS1init = Standard_True;
myS2init = Standard_True;
myPoint1.Clear();
Standard_EXPORT Extrema_FuncExtSS();
- Standard_EXPORT Extrema_FuncExtSS(const Adaptor3d_Surface& S1, const Adaptor3d_Surface& S2);
+ Standard_EXPORT Extrema_FuncExtSS(const Handle(Adaptor3d_Surface)& S1, const Handle(Adaptor3d_Surface)& S2);
//! sets the field mysurf of the function.
- Standard_EXPORT void Initialize (const Adaptor3d_Surface& S1, const Adaptor3d_Surface& S2);
+ Standard_EXPORT void Initialize (const Handle(Adaptor3d_Surface)& S1, const Handle(Adaptor3d_Surface)& S2);
Standard_EXPORT Standard_Integer NbVariables() const Standard_OVERRIDE;
private:
- const Adaptor3d_Surface* myS1;
- const Adaptor3d_Surface* myS2;
+ Handle(Adaptor3d_Surface) myS1;
+ Handle(Adaptor3d_Surface) myS2;
gp_Pnt myP1;
gp_Pnt myP2;
Standard_Real myU1;
//function : Extrema_FuncPSDist
//purpose :
//=======================================================================
-Extrema_FuncPSDist::Extrema_FuncPSDist(const Adaptor3d_Surface& theS,
+Extrema_FuncPSDist::Extrema_FuncPSDist(const Handle(Adaptor3d_Surface)& theS,
const gp_Pnt& theP)
: mySurf(theS),
myP(theP)
if (!IsInside(X))
return Standard_False;
- F = mySurf.Value(X(1), X(2)).SquareDistance(myP);
+ F = mySurf->Value(X(1), X(2)).SquareDistance(myP);
return Standard_True;
}
gp_Pnt aP;
gp_Vec Du1s, Dv1s;
- mySurf.D1(X(1),X(2),aP,Du1s,Dv1s);
+ mySurf->D1(X(1),X(2),aP,Du1s,Dv1s);
gp_Vec P1P2 (aP, myP);
gp_Pnt aP;
gp_Vec Du1s, Dv1s;
- mySurf.D1(X(1),X(2),aP,Du1s,Dv1s);
+ mySurf->D1(X(1),X(2),aP,Du1s,Dv1s);
gp_Vec P1P2 (aP, myP);
G(1) = P1P2.Dot(Du1s);
G(2) = P1P2.Dot(Dv1s);
- F = mySurf.Value(X(1), X(2)).SquareDistance(myP);
+ F = mySurf->Value(X(1), X(2)).SquareDistance(myP);
return true;
}
//=======================================================================
Standard_Boolean Extrema_FuncPSDist::IsInside(const math_Vector& X)
{
- if (X(1) < mySurf.FirstUParameter() ||
- X(1) > mySurf.LastUParameter() ||
- X(2) < mySurf.FirstVParameter() ||
- X(2) > mySurf.LastVParameter() )
+ if (X(1) < mySurf->FirstUParameter() ||
+ X(1) > mySurf->LastUParameter() ||
+ X(2) < mySurf->FirstVParameter() ||
+ X(2) > mySurf->LastVParameter() )
{
// Point out of borders.
return Standard_False;
DEFINE_STANDARD_ALLOC
//! Constructor.
- Standard_EXPORT Extrema_FuncPSDist(const Adaptor3d_Surface& theS,
+ Standard_EXPORT Extrema_FuncPSDist(const Handle(Adaptor3d_Surface)& theS,
const gp_Pnt& theP);
//! Number of variables.
const Extrema_FuncPSDist& operator=(const Extrema_FuncPSDist&);
Extrema_FuncPSDist(const Extrema_FuncPSDist&);
- const Adaptor3d_Surface &mySurf;
+ const Handle(Adaptor3d_Surface) &mySurf;
const gp_Pnt &myP;
};
#endif // _Extrema_FuncPSDsit_HeaderFile
//=============================================================================
Extrema_FuncPSNorm::Extrema_FuncPSNorm (const gp_Pnt& P,
- const Adaptor3d_Surface& S)
+ const Handle(Adaptor3d_Surface)& S)
: myU(0.0),
myV(0.0)
{
myP = P;
- myS = &S;
+ myS = S;
myPinit = Standard_True;
mySinit = Standard_True;
}
//=============================================================================
-void Extrema_FuncPSNorm::Initialize(const Adaptor3d_Surface& S)
+void Extrema_FuncPSNorm::Initialize(const Handle(Adaptor3d_Surface)& S)
{
- myS = &S;
+ myS = S;
mySinit = Standard_True;
myPoint.Clear();
mySqDist.Clear();
Standard_EXPORT Extrema_FuncPSNorm();
- Standard_EXPORT Extrema_FuncPSNorm(const gp_Pnt& P, const Adaptor3d_Surface& S);
+ Standard_EXPORT Extrema_FuncPSNorm(const gp_Pnt& P, const Handle(Adaptor3d_Surface)& S);
//! sets the field mysurf of the function.
- Standard_EXPORT void Initialize (const Adaptor3d_Surface& S);
+ Standard_EXPORT void Initialize (const Handle(Adaptor3d_Surface)& S);
//! sets the field mysurf of the function.
Standard_EXPORT void SetPoint (const gp_Pnt& P);
private:
gp_Pnt myP;
- const Adaptor3d_Surface* myS;
+ Handle(Adaptor3d_Surface) myS;
Standard_Real myU;
Standard_Real myV;
gp_Pnt myPs;
Standard_Real t3d = Precision::Confusion();
if (Precision::IsInfinite(myuinf)) mydist1 = RealLast();
else {
- Pf = TheCurveTool::Value(*((TheCurve*)myC), myuinf);
+ Pf = TheCurveTool::Value((TheCurve::element_type*)(myC), myuinf);
mydist1 = P.SquareDistance(Pf);
}
if (Precision::IsInfinite(myusup)) mydist2 = RealLast();
else {
- Pl = TheCurveTool::Value(*((TheCurve*)myC), myusup);
+ Pl = TheCurveTool::Value((TheCurve::element_type*)(myC), myusup);
mydist2 = P.SquareDistance(Pl);
}
- TheCurve & aCurve = *((TheCurve*)myC);
+ TheCurve aCurve = (TheCurve::element_type*)(myC);
switch(type) {
case GeomAbs_Circle:
const Standard_Real Usup,
const Standard_Real TolF)
{
- myC = (Standard_Address)&C;
+ myC = (Standard_Address)(C.get());
myintuinf = myuinf = Uinf;
myintusup = myusup = Usup;
mytolf = TolF;
- mytolu = TheCurveTool::Resolution(*((TheCurve*)myC), Precision::Confusion());
+ mytolu = TheCurveTool::Resolution((TheCurve::element_type*)(myC), Precision::Confusion());
type = TheCurveTool::GetType(C);
mydone = Standard_False;
mydist1 = RealLast();
// Verification de la validite des parametres pour le cas trimme:
ThePOnC PC = myExtPC.Point(i);
U = PC.Parameter();
- if (TheCurveTool::IsPeriodic(*((TheCurve*)myC)))
+ if (TheCurveTool::IsPeriodic((TheCurve::element_type*)(myC)))
{
- U = ElCLib::InPeriod(U, myuinf, myuinf+TheCurveTool::Period(*((TheCurve*)myC)));
+ U = ElCLib::InPeriod(U, myuinf, myuinf+TheCurveTool::Period((TheCurve::element_type*)(myC)));
}
if ((U >= myuinf - mytolu) && (U <= myusup + mytolu))
{
myUppBorder(1,2),
myDone(Standard_False)
{
- myC[0] = (Standard_Address)&C1;
- myC[1] = (Standard_Address)&C2;
- myLowBorder(1) = C1.FirstParameter();
- myLowBorder(2) = C2.FirstParameter();
- myUppBorder(1) = C1.LastParameter();
- myUppBorder(2) = C2.LastParameter();
+ myC[0] = (Standard_Address)(C1.get());
+ myC[1] = (Standard_Address)(C2.get());
+ myLowBorder(1) = C1->FirstParameter();
+ myLowBorder(2) = C2->FirstParameter();
+ myUppBorder(1) = C1->LastParameter();
+ myUppBorder(2) = C2->LastParameter();
}
//=======================================================================
myUppBorder(1,2),
myDone(Standard_False)
{
- myC[0] = (Standard_Address)&C1;
- myC[1] = (Standard_Address)&C2;
+ myC[0] = (Standard_Address)(C1.get());
+ myC[1] = (Standard_Address)(C2.get());
myLowBorder(1) = Uinf;
myLowBorder(2) = Vinf;
myUppBorder(1) = Usup;
const Standard_Real Vinf,
const Standard_Real Vsup)
{
- myC[0] = (Standard_Address)&C1;
- myC[1] = (Standard_Address)&C2;
+ myC[0] = (Standard_Address)(C1.get());
+ myC[1] = (Standard_Address)(C2.get());
myLowBorder(1) = Uinf;
myLowBorder(2) = Vinf;
myUppBorder(1) = Usup;
myDone = Standard_False;
myParallel = Standard_False;
- Curve1 &C1 = *(Curve1*)myC[0];
- Curve2 &C2 = *(Curve2*)myC[1];
+ Curve1 C1 = (Curve1::element_type*)(myC[0]);
+ Curve2 C2 = (Curve2::element_type*)(myC[1]);
Standard_Integer aNbInter[2];
GeomAbs_Shape aContinuity = GeomAbs_C2;
- aNbInter[0] = C1.NbIntervals(aContinuity);
- aNbInter[1] = C2.NbIntervals(aContinuity);
+ aNbInter[0] = C1->NbIntervals(aContinuity);
+ aNbInter[1] = C2->NbIntervals(aContinuity);
if (aNbInter[0] * aNbInter[1] > 100)
{
aContinuity = GeomAbs_C1;
- aNbInter[0] = C1.NbIntervals(aContinuity);
- aNbInter[1] = C2.NbIntervals(aContinuity);
+ aNbInter[0] = C1->NbIntervals(aContinuity);
+ aNbInter[1] = C2->NbIntervals(aContinuity);
}
Standard_Real anL[2];
Standard_Integer indmax = -1, indmin = -1;
const Standard_Real mult = 20.;
- if (!(Precision::IsInfinite(C1.FirstParameter()) || Precision::IsInfinite(C1.LastParameter()) ||
- Precision::IsInfinite(C2.FirstParameter()) || Precision::IsInfinite(C2.LastParameter())))
+ if (!(Precision::IsInfinite(C1->FirstParameter()) || Precision::IsInfinite(C1->LastParameter()) ||
+ Precision::IsInfinite(C2->FirstParameter()) || Precision::IsInfinite(C2->LastParameter())))
{
anL[0] = GCPnts_AbscissaPoint::Length(C1);
anL[1] = GCPnts_AbscissaPoint::Length(C2);
Handle(TColStd_HArray1OfReal) anIntervals1 = new TColStd_HArray1OfReal(1, aNbInter[0] + 1);
Handle(TColStd_HArray1OfReal) anIntervals2 = new TColStd_HArray1OfReal(1, aNbInter[1] + 1);
- C1.Intervals(anIntervals1->ChangeArray1(), aContinuity);
- C2.Intervals(anIntervals2->ChangeArray1(), aContinuity);
+ C1->Intervals(anIntervals1->ChangeArray1(), aContinuity);
+ C2->Intervals(anIntervals2->ChangeArray1(), aContinuity);
if (indmax >= 0)
{
if (indmax == 0)
aNbInter[1] = anIntervals2->Length() - 1;
}
}
- if (C1.IsClosed() && aNbInter[0] == 1)
+ if (C1->IsClosed() && aNbInter[0] == 1)
{
ChangeIntervals(anIntervals1, 3);
aNbInter[0] = anIntervals1->Length() - 1;
}
- if (C2.IsClosed() && aNbInter[1] == 1)
+ if (C2->IsClosed() && aNbInter[1] == 1)
{
ChangeIntervals(anIntervals2, 3);
aNbInter[1] = anIntervals2->Length() - 1;
// Lipchitz constant computation.
const Standard_Real aMaxLC = 10000.;
Standard_Real aLC = 100.0; // Default value.
- const Standard_Real aMaxDer1 = 1.0 / C1.Resolution(1.0);
- const Standard_Real aMaxDer2 = 1.0 / C2.Resolution(1.0);
+ const Standard_Real aMaxDer1 = 1.0 / C1->Resolution(1.0);
+ const Standard_Real aMaxDer2 = 1.0 / C2->Resolution(1.0);
Standard_Real aMaxDer = Max(aMaxDer1, aMaxDer2) * Sqrt(2.0);
if (aLC > aMaxDer)
aLC = aMaxDer;
aLC = aMaxLC;
isConstLockedFlag = Standard_True;
}
- if (C1.GetType() == GeomAbs_Line)
+ if (C1->GetType() == GeomAbs_Line)
{
- aMaxDer = 1.0 / C2.Resolution(1.0);
+ aMaxDer = 1.0 / C2->Resolution(1.0);
if (aLC > aMaxDer)
{
isConstLockedFlag = Standard_True;
aLC = aMaxDer;
}
}
- if (C2.GetType() == GeomAbs_Line)
+ if (C2->GetType() == GeomAbs_Line)
{
- aMaxDer = 1.0 / C1.Resolution(1.0);
+ aMaxDer = 1.0 / C1->Resolution(1.0);
if (aLC > aMaxDer)
{
isConstLockedFlag = Standard_True;
Standard_Real aF, aMaxG = 0.;
Standard_Real t1, t2, dt1, dt2;
Standard_Integer n1 = 21, n2 = 21, i1, i2;
- dt1 = (C1.LastParameter() - C1.FirstParameter()) / (n1 - 1);
- dt2 = (C2.LastParameter() - C2.FirstParameter()) / (n2 - 1);
- for (i1 = 1, t1 = C1.FirstParameter(); i1 <= n1; ++i1, t1 += dt1)
+ dt1 = (C1->LastParameter() - C1->FirstParameter()) / (n1 - 1);
+ dt2 = (C2->LastParameter() - C2->FirstParameter()) / (n2 - 1);
+ for (i1 = 1, t1 = C1->FirstParameter(); i1 <= n1; ++i1, t1 += dt1)
{
aT(1) = t1;
- for (i2 = 1, t2 = C2.FirstParameter(); i2 <= n2; ++i2, t2 += dt2)
+ for (i2 = 1, t2 = C2->FirstParameter(); i2 <= n2; ++i2, t2 += dt2)
{
aT(2) = t2;
aFunc.Values(aT, aF, aG);
for (Standard_Integer iT = 0; isParallel && (iT < 2); ++iT)
{
- Standard_Real aDist1 = ProjPOnC(C1.Value(aT1[iT]), anExtPC2);
- Standard_Real aDist2 = ProjPOnC(C2.Value(aT2[iT]), anExtPC1);
+ Standard_Real aDist1 = ProjPOnC(C1->Value(aT1[iT]), anExtPC2);
+ Standard_Real aDist2 = ProjPOnC(C2->Value(aT2[iT]), anExtPC1);
isParallel = (Abs(Min(aDist1, aDist2) - aF) < Precision::Confusion());
}
}
throw Standard_OutOfRange();
}
- return Tool1::Value(*((Curve1*)myC[0]), myPoints1(N)).SquareDistance(Tool2::Value(*((Curve2*)myC[1]), myPoints2(N)));
+ return Tool1::Value((Curve1::element_type*)(myC[0]), myPoints1(N)).SquareDistance(Tool2::Value((Curve2::element_type*)(myC[1]), myPoints2(N)));
}
//=======================================================================
throw Standard_OutOfRange();
}
- P1.SetValues(myPoints1(N), Tool1::Value(*((Curve1*)myC[0]), myPoints1(N)));
- P2.SetValues(myPoints2(N), Tool2::Value(*((Curve2*)myC[1]), myPoints2(N)));
+ P1.SetValues(myPoints1(N), Tool1::Value((Curve1::element_type*)(myC[0]), myPoints1(N)));
+ P2.SetValues(myPoints2(N), Tool2::Value((Curve2::element_type*)(myC[1]), myPoints2(N)));
}
//=======================================================================
return Standard_False;
}
// restrict maximal parameter on hyperbola to avoid FPE
-static Standard_Real GetCurvMaxParamVal (const Adaptor3d_Curve& theC)
+static Standard_Real GetCurvMaxParamVal (const Handle(Adaptor3d_Curve)& theC)
{
- if (theC.GetType() == GeomAbs_Hyperbola)
+ if (theC->GetType() == GeomAbs_Hyperbola)
{
return HyperbolaLimit;
}
- if (theC.GetType() == GeomAbs_OffsetCurve)
+ if (theC->GetType() == GeomAbs_OffsetCurve)
{
- Handle(Geom_Curve) aBC (theC.OffsetCurve()->BasisCurve());
+ Handle(Geom_Curve) aBC (theC->OffsetCurve()->BasisCurve());
Handle(Geom_TrimmedCurve) aTC = Handle(Geom_TrimmedCurve)::DownCast (aBC);
if (! aTC.IsNull())
{
}
// restrict maximal parameter on surfaces based on hyperbola to avoid FPE
-static void GetSurfMaxParamVals (const Adaptor3d_Surface& theS,
+static void GetSurfMaxParamVals (const Handle(Adaptor3d_Surface)& theS,
Standard_Real& theUmax, Standard_Real& theVmax)
{
theUmax = theVmax = MaxParamVal;
- if (theS.GetType() == GeomAbs_SurfaceOfExtrusion)
+ if (theS->GetType() == GeomAbs_SurfaceOfExtrusion)
{
- theUmax = GetCurvMaxParamVal (*theS.BasisCurve());
+ theUmax = GetCurvMaxParamVal (theS->BasisCurve());
}
- else if (theS.GetType() == GeomAbs_SurfaceOfRevolution)
+ else if (theS->GetType() == GeomAbs_SurfaceOfRevolution)
{
- theVmax = GetCurvMaxParamVal (*theS.BasisCurve());
+ theVmax = GetCurvMaxParamVal (theS->BasisCurve());
}
- else if (theS.GetType() == GeomAbs_OffsetSurface)
+ else if (theS->GetType() == GeomAbs_OffsetSurface)
{
- GetSurfMaxParamVals (*theS.BasisSurface(), theUmax, theVmax);
+ GetSurfMaxParamVals (theS->BasisSurface(), theUmax, theVmax);
}
}
//function : Extrema_GenExtCS
//purpose :
//=======================================================================
-Extrema_GenExtCS::Extrema_GenExtCS(const Adaptor3d_Curve& C,
- const Adaptor3d_Surface& S,
+Extrema_GenExtCS::Extrema_GenExtCS(const Handle(Adaptor3d_Curve)& C,
+ const Handle(Adaptor3d_Surface)& S,
const Standard_Integer NbT,
const Standard_Integer NbU,
const Standard_Integer NbV,
//purpose :
//=======================================================================
-Extrema_GenExtCS::Extrema_GenExtCS (const Adaptor3d_Curve& C,
- const Adaptor3d_Surface& S,
+Extrema_GenExtCS::Extrema_GenExtCS (const Handle(Adaptor3d_Curve)& C,
+ const Handle(Adaptor3d_Surface)& S,
const Standard_Integer NbT,
const Standard_Integer NbU,
const Standard_Integer NbV,
//function : Initialize
//purpose :
//=======================================================================
-void Extrema_GenExtCS::Initialize (const Adaptor3d_Surface& S,
+void Extrema_GenExtCS::Initialize (const Handle(Adaptor3d_Surface)& S,
const Standard_Integer NbU,
const Standard_Integer NbV,
const Standard_Real Tol2)
{
- myumin = S.FirstUParameter();
- myusup = S.LastUParameter();
- myvmin = S.FirstVParameter();
- myvsup = S.LastVParameter();
+ myumin = S->FirstUParameter();
+ myusup = S->LastUParameter();
+ myvmin = S->FirstVParameter();
+ myvsup = S->LastVParameter();
Initialize(S,NbU,NbV,myumin,myusup,myvmin,myvsup,Tol2);
}
//function : Initialize
//purpose :
//=======================================================================
-void Extrema_GenExtCS::Initialize (const Adaptor3d_Surface& S,
+void Extrema_GenExtCS::Initialize (const Handle(Adaptor3d_Surface)& S,
const Standard_Integer NbU,
const Standard_Integer NbV,
const Standard_Real Umin,
const Standard_Real Vsup,
const Standard_Real Tol2)
{
- myS = &S;
+ myS = S;
myusample = NbU;
myvsample = NbV;
myumin = Umin;
mytol2 = Tol2;
Standard_Real umaxpar, vmaxpar;
- GetSurfMaxParamVals(*myS, umaxpar, vmaxpar);
+ GetSurfMaxParamVals(myS, umaxpar, vmaxpar);
if(Precision::IsInfinite (myusup))
{
//function : Perform
//purpose :
//=======================================================================
-void Extrema_GenExtCS::Perform(const Adaptor3d_Curve& C,
+void Extrema_GenExtCS::Perform(const Handle(Adaptor3d_Curve)& C,
const Standard_Integer NbT,
const Standard_Real Tol1)
{
- mytmin = C.FirstParameter();
- mytsup = C.LastParameter();
+ mytmin = C->FirstParameter();
+ mytsup = C->LastParameter();
Perform(C, NbT, mytmin, mytsup,Tol1);
}
//function : Perform
//purpose :
//=======================================================================
-void Extrema_GenExtCS::Perform (const Adaptor3d_Curve& C,
+void Extrema_GenExtCS::Perform (const Handle(Adaptor3d_Curve)& C,
const Standard_Integer NbT,
const Standard_Real tmin,
const Standard_Real tsup,
const Standard_Real Tol1)
{
myDone = Standard_False;
- myF.Initialize(C,*myS);
+ myF.Initialize(C, myS);
mytmin = tmin;
mytsup = tsup;
mytol1 = Tol1;
}
else
{
- GeomAbs_CurveType aCType = C.GetType();
+ GeomAbs_CurveType aCType = C->GetType();
if (IsConic(aCType))
{
aNbVar = 2;
const Standard_Integer aNbParticles = 48;
Standard_Integer aNbIntC = 1;
- if (C.IsClosed() || C.IsPeriodic())
+ if (C->IsClosed() || C->IsPeriodic())
{
- Standard_Real aPeriod = C.Period();
- if (C.LastParameter() - C.FirstParameter() > 2. * aPeriod / 3.)
+ Standard_Real aPeriod = C->Period();
+ if (C->LastParameter() - C->FirstParameter() > 2. * aPeriod / 3.)
{
aNbIntC = 2;
}
//function : GlobMinGenCS
//purpose :
//=======================================================================
-void Extrema_GenExtCS::GlobMinGenCS(const Adaptor3d_Curve& theC,
+void Extrema_GenExtCS::GlobMinGenCS(const Handle(Adaptor3d_Curve)& theC,
const Standard_Integer theNbParticles,
const math_Vector& theTUVinf,
const math_Vector& theTUVsup,
// Correct number of curve samples in case of low resolution
Standard_Integer aNewCsample = mytsample;
Standard_Real aScaleFactor = 5.0;
- Standard_Real aResolutionCU = aStepCU / theC.Resolution(1.0);
+ Standard_Real aResolutionCU = aStepCU / theC->Resolution(1.0);
Standard_Real aMinResolution = aScaleFactor * Min(aResolutionCU,
Min(aStepSU / myS->UResolution(1.0), aStepSV / myS->VResolution(1.0)));
Standard_Real aCU1 = aMinTUV(1);
for (Standard_Integer aCUI = 0; aCUI <= aNewCsample; aCUI++, aCU1 += aStepCU)
- aCurvPnts.SetValue(aCUI, theC.Value(aCU1));
+ aCurvPnts.SetValue(aCUI, theC->Value(aCU1));
PSO_Particle* aParticle = aParticles.GetWorstParticle();
// Select specified number of particles from pre-computed set of samples
// Find min approximation
Standard_Real aValue;
- Extrema_GlobOptFuncCS aFunc(&theC, myS);
+ Extrema_GlobOptFuncCS aFunc(theC, myS);
math_PSO aPSO(&aFunc, theTUVinf, theTUVsup, aStep);
aPSO.Perform(aParticles, theNbParticles, aValue, theTUV);
//function : GlobMinConicS
//purpose :
//=======================================================================
-void Extrema_GenExtCS::GlobMinConicS(const Adaptor3d_Curve& theC,
+void Extrema_GenExtCS::GlobMinConicS(const Handle(Adaptor3d_Curve)& theC,
const Standard_Integer theNbParticles,
const math_Vector& theTUVinf,
const math_Vector& theTUVsup,
Standard_Real aStepSV = (aMaxUV(2) - aMinUV(2)) / aVsample;
//
Extrema_GlobOptFuncConicS aFunc(myS, anUVinf(1), anUVsup(1), anUVinf(2), anUVsup(2));
- aFunc.LoadConic(&theC, theTUVinf(1), theTUVsup(1));
+ aFunc.LoadConic(theC, theTUVinf(1), theTUVsup(1));
PSO_Particle* aParticle = aParticles.GetWorstParticle();
aPSO.Perform(aParticles, theNbParticles, aValue, anUV);
//
Standard_Real aCT = aFunc.ConicParameter(anUV);
- if (theC.IsPeriodic())
+ if (theC->IsPeriodic())
{
if (aCT < theTUVinf(1) - Precision::PConfusion() || aCT > theTUVsup(1) + Precision::PConfusion())
{
gp_Vec aDU, aDV, aDT;
gp_Pnt aPOnS, aPOnC;
myS->D1(anUV(1), anUV(2), aPOnS, aDU, aDV);
- theC.D1(aCT, aPOnC, aDT);
+ theC->D1(aCT, aPOnC, aDT);
Standard_Real aSqDist = aPOnC.SquareDistance(aPOnS);
if (aSqDist <= Precision::SquareConfusion())
return;
aF(3) = PcPs.Dot(aDV);
Standard_Real aFF = aF.Norm2();
- Extrema_GenLocateExtPS anExtPS(*myS, mytol2, mytol2);
+ Extrema_GenLocateExtPS anExtPS(myS, mytol2, mytol2);
anExtPS.Perform(aPOnC, anUV(1), anUV(2), Standard_False);
if (anExtPS.IsDone())
{
//function : GlobMinCQuadric
//purpose :
//=======================================================================
-void Extrema_GenExtCS::GlobMinCQuadric(const Adaptor3d_Curve& theC,
+void Extrema_GenExtCS::GlobMinCQuadric(const Handle(Adaptor3d_Curve)& theC,
const Standard_Integer theNbParticles,
const math_Vector& theTUVinf,
const math_Vector& theTUVsup,
Standard_Real aStepSU = (theTUVsup(2) - theTUVinf(2)) / myusample;
Standard_Real aStepSV = (theTUVsup(3) - theTUVinf(3)) / myvsample;
Standard_Real aScaleFactor = 5.0;
- Standard_Real aResolutionCU = aStepCT / theC.Resolution(1.0);
+ Standard_Real aResolutionCU = aStepCT / theC->Resolution(1.0);
Standard_Real aMinResolution = aScaleFactor * Min(aResolutionCU,
Min(aStepSU / myS->UResolution(1.0), aStepSV / myS->VResolution(1.0)));
}
//
- Extrema_GlobOptFuncCQuadric aFunc(&theC, aTinf(1), aTsup(1));
+ Extrema_GlobOptFuncCQuadric aFunc(theC, aTinf(1), aTsup(1));
aFunc.LoadQuad(myS, theTUVinf(2), theTUVsup(2), theTUVinf(3), theTUVsup(3));
PSO_Particle* aParticle = aParticles.GetWorstParticle();
//! surfaces.
//! NbU and NbV are used to locate the close points on the
//! surface and NbT on the curve to find the zeros.
- Standard_EXPORT Extrema_GenExtCS(const Adaptor3d_Curve& C, const Adaptor3d_Surface& S, const Standard_Integer NbT, const Standard_Integer NbU, const Standard_Integer NbV, const Standard_Real Tol1, const Standard_Real Tol2);
+ Standard_EXPORT Extrema_GenExtCS(const Handle(Adaptor3d_Curve)& C, const Handle(Adaptor3d_Surface)& S, const Standard_Integer NbT, const Standard_Integer NbU, const Standard_Integer NbV, const Standard_Real Tol1, const Standard_Real Tol2);
//! It calculates all the distances.
//! The function F(u,v)=distance(P,S(u,v)) has an
//! surface.
//! NbT,NbU and NbV are used to locate the close points
//! to find the zeros.
- Standard_EXPORT Extrema_GenExtCS(const Adaptor3d_Curve& C, const Adaptor3d_Surface& S, const Standard_Integer NbT, const Standard_Integer NbU, const Standard_Integer NbV, const Standard_Real tmin, const Standard_Real tsup, const Standard_Real Umin, const Standard_Real Usup, const Standard_Real Vmin, const Standard_Real Vsup, const Standard_Real Tol1, const Standard_Real Tol2);
+ Standard_EXPORT Extrema_GenExtCS(const Handle(Adaptor3d_Curve)& C, const Handle(Adaptor3d_Surface)& S, const Standard_Integer NbT, const Standard_Integer NbU, const Standard_Integer NbV, const Standard_Real tmin, const Standard_Real tsup, const Standard_Real Umin, const Standard_Real Usup, const Standard_Real Vmin, const Standard_Real Vsup, const Standard_Real Tol1, const Standard_Real Tol2);
- Standard_EXPORT void Initialize (const Adaptor3d_Surface& S, const Standard_Integer NbU, const Standard_Integer NbV, const Standard_Real Tol2);
+ Standard_EXPORT void Initialize (const Handle(Adaptor3d_Surface)& S, const Standard_Integer NbU, const Standard_Integer NbV, const Standard_Real Tol2);
- Standard_EXPORT void Initialize (const Adaptor3d_Surface& S, const Standard_Integer NbU, const Standard_Integer NbV, const Standard_Real Umin, const Standard_Real Usup, const Standard_Real Vmin, const Standard_Real Vsup, const Standard_Real Tol2);
+ Standard_EXPORT void Initialize (const Handle(Adaptor3d_Surface)& S, const Standard_Integer NbU, const Standard_Integer NbV, const Standard_Real Umin, const Standard_Real Usup, const Standard_Real Vmin, const Standard_Real Vsup, const Standard_Real Tol2);
//! the algorithm is done with S
//! An exception is raised if the fields have not
//! been initialized.
- Standard_EXPORT void Perform (const Adaptor3d_Curve& C, const Standard_Integer NbT, const Standard_Real Tol1);
+ Standard_EXPORT void Perform (const Handle(Adaptor3d_Curve)& C, const Standard_Integer NbT, const Standard_Real Tol1);
//! the algorithm is done with C
//! An exception is raised if the fields have not
//! been initialized.
- Standard_EXPORT void Perform (const Adaptor3d_Curve& C, const Standard_Integer NbT, const Standard_Real tmin, const Standard_Real tsup, const Standard_Real Tol1);
+ Standard_EXPORT void Perform (const Handle(Adaptor3d_Curve)& C, const Standard_Integer NbT, const Standard_Real tmin, const Standard_Real tsup, const Standard_Real Tol1);
//! Returns True if the distances are found.
Standard_EXPORT Standard_Boolean IsDone() const;
private:
- Standard_EXPORT void GlobMinGenCS(const Adaptor3d_Curve& theC,
+ Standard_EXPORT void GlobMinGenCS(const Handle(Adaptor3d_Curve)& theC,
const Standard_Integer theNbParticles,
const math_Vector& theTUVinf,
const math_Vector& theTUVsup,
math_Vector& theTUV);
- Standard_EXPORT void GlobMinConicS(const Adaptor3d_Curve& theC,
+ Standard_EXPORT void GlobMinConicS(const Handle(Adaptor3d_Curve)& theC,
const Standard_Integer theNbParticles,
const math_Vector& theTUVinf,
const math_Vector& theTUVsup,
math_Vector& theTUV);
- Standard_EXPORT void GlobMinCQuadric(const Adaptor3d_Curve& theC,
+ Standard_EXPORT void GlobMinCQuadric(const Handle(Adaptor3d_Curve)& theC,
const Standard_Integer theNbParticles,
const math_Vector& theTUVinf,
const math_Vector& theTUVsup,
Standard_Real mytol1;
Standard_Real mytol2;
Extrema_FuncExtCS myF;
- const Adaptor3d_Surface* myS;
+ Handle(Adaptor3d_Surface) myS;
Handle(TColgp_HArray2OfPnt) mySurfPnts;
};
// purpose :
// =======================================================================
Extrema_GenExtPS::Extrema_GenExtPS (const gp_Pnt& P,
- const Adaptor3d_Surface& S,
+ const Handle(Adaptor3d_Surface)& S,
const Standard_Integer NbU,
const Standard_Integer NbV,
const Standard_Real TolU,
}
Extrema_GenExtPS::Extrema_GenExtPS (const gp_Pnt& P,
- const Adaptor3d_Surface& S,
+ const Handle(Adaptor3d_Surface)& S,
const Standard_Integer NbU,
const Standard_Integer NbV,
const Standard_Real Umin,
}
-void Extrema_GenExtPS::Initialize(const Adaptor3d_Surface& S,
+void Extrema_GenExtPS::Initialize(const Handle(Adaptor3d_Surface)& S,
const Standard_Integer NbU,
const Standard_Integer NbV,
const Standard_Real TolU,
const Standard_Real TolV)
{
- myumin = S.FirstUParameter();
- myusup = S.LastUParameter();
- myvmin = S.FirstVParameter();
- myvsup = S.LastVParameter();
+ myumin = S->FirstUParameter();
+ myusup = S->LastUParameter();
+ myvmin = S->FirstVParameter();
+ myvsup = S->LastVParameter();
Initialize(S,NbU,NbV,myumin,myusup,myvmin,myvsup,TolU,TolV);
}
-void Extrema_GenExtPS::Initialize(const Adaptor3d_Surface& S,
+void Extrema_GenExtPS::Initialize(const Handle(Adaptor3d_Surface)& S,
const Standard_Integer NbU,
const Standard_Integer NbV,
const Standard_Real Umin,
const Standard_Real TolU,
const Standard_Real TolV)
{
- myS = &S;
+ myS = S;
myusample = NbU;
myvsample = NbV;
mytolu = TolU;
theParams->SetValue(i+1,aParams(i));
}
-void Extrema_GenExtPS::GetGridPoints( const Adaptor3d_Surface& theSurf)
+void Extrema_GenExtPS::GetGridPoints( const Handle(Adaptor3d_Surface)& theSurf)
{
//creation parametric points for BSpline and Bezier surfaces
//with taking into account of Degree and NbKnots of BSpline or Bezier geometry
- if (theSurf.GetType() == GeomAbs_OffsetSurface)
+ if (theSurf->GetType() == GeomAbs_OffsetSurface)
{
- GetGridPoints (*theSurf.BasisSurface());
+ GetGridPoints (theSurf->BasisSurface());
}
//parametric points for BSpline surfaces
- else if( theSurf.GetType() == GeomAbs_BSplineSurface)
+ else if( theSurf->GetType() == GeomAbs_BSplineSurface)
{
- Handle(Geom_BSplineSurface) aBspl = theSurf.BSpline();
+ Handle(Geom_BSplineSurface) aBspl = theSurf->BSpline();
if(!aBspl.IsNull())
{
TColStd_Array1OfReal aUKnots(1, aBspl->NbUKnots());
}
}
//calculation parametric points for Bezier surfaces
- else if(theSurf.GetType() == GeomAbs_BezierSurface)
+ else if(theSurf->GetType() == GeomAbs_BezierSurface)
{
- Handle(Geom_BezierSurface) aBezier = theSurf.Bezier();
+ Handle(Geom_BezierSurface) aBezier = theSurf->Bezier();
if(aBezier.IsNull())
return;
}
//creation points for surfaces based on BSpline or Bezier curves
- else if(theSurf.GetType() == GeomAbs_SurfaceOfRevolution ||
- theSurf.GetType() == GeomAbs_SurfaceOfExtrusion)
+ else if(theSurf->GetType() == GeomAbs_SurfaceOfRevolution ||
+ theSurf->GetType() == GeomAbs_SurfaceOfExtrusion)
{
Handle(TColStd_HArray1OfReal) anArrKnots;
Standard_Integer aDegree = 0;
- if(theSurf.BasisCurve()->GetType() == GeomAbs_BSplineCurve)
+ if(theSurf->BasisCurve()->GetType() == GeomAbs_BSplineCurve)
{
- Handle(Geom_BSplineCurve) aBspl = theSurf.BasisCurve()->BSpline();
+ Handle(Geom_BSplineCurve) aBspl = theSurf->BasisCurve()->BSpline();
if(!aBspl.IsNull())
{
anArrKnots = new TColStd_HArray1OfReal(1,aBspl->NbKnots());
}
}
- if(theSurf.BasisCurve()->GetType() == GeomAbs_BezierCurve)
+ if(theSurf->BasisCurve()->GetType() == GeomAbs_BezierCurve)
{
- Handle(Geom_BezierCurve) aBez = theSurf.BasisCurve()->Bezier();
+ Handle(Geom_BezierCurve) aBez = theSurf->BasisCurve()->Bezier();
if(!aBez.IsNull())
{
anArrKnots = new TColStd_HArray1OfReal(1,2);
}
if(anArrKnots.IsNull())
return;
- if( theSurf.GetType() == GeomAbs_SurfaceOfRevolution )
+ if( theSurf->GetType() == GeomAbs_SurfaceOfRevolution )
fillParams( anArrKnots->Array1(), aDegree, myvmin, myvsup, myVParams, myvsample);
else
fillParams( anArrKnots->Array1(), aDegree, myumin, myusup, myUParams, myusample);
//if grid was already built skip its creation
if (!myInit) {
//build parametric grid in case of a complex surface geometry (BSpline and Bezier surfaces)
- GetGridPoints(*myS);
+ GetGridPoints(myS);
//build grid in other cases
if( myUParams.IsNull() )
}
}
-static Standard_Real LengthOfIso(const Adaptor3d_Surface& theS, const GeomAbs_IsoType theIso,
+static Standard_Real LengthOfIso(const Handle(Adaptor3d_Surface)& theS, const GeomAbs_IsoType theIso,
const Standard_Real thePar1, const Standard_Real thePar2,
const Standard_Integer theNbPnts, const Standard_Real thePar)
{
Standard_Real aPar = thePar1 + dPar;
if(theIso == GeomAbs_IsoU)
{
- aP1 = theS.Value(thePar, thePar1);
+ aP1 = theS->Value(thePar, thePar1);
}
else
{
- aP1 = theS.Value(thePar1, thePar);
+ aP1 = theS->Value(thePar1, thePar);
}
for (i = 2; i <= theNbPnts; ++i)
{
if (theIso == GeomAbs_IsoU)
{
- aP2 = theS.Value(thePar, aPar);
+ aP2 = theS->Value(thePar, aPar);
}
else
{
- aP2 = theS.Value(aPar, thePar);
+ aP2 = theS->Value(aPar, thePar);
}
aLen += aP1.Distance(aP2);
aP1 = aP2;
}
return aLen;
}
-static void CorrectNbSamples(const Adaptor3d_Surface& theS,
+static void CorrectNbSamples(const Handle(Adaptor3d_Surface)& theS,
const Standard_Real theU1, const Standard_Real theU2, Standard_Integer& theNbU,
const Standard_Real theV1, const Standard_Real theV2, Standard_Integer& theNbV)
{
myvsample = Min(aVValue, 300);
}
//
- CorrectNbSamples(*myS, myumin, myusup, myusample, myvmin, myvsup, myvsample);
+ CorrectNbSamples(myS, myumin, myusup, myusample, myvmin, myvsup, myvsample);
//
Standard_Real PasU = myusup - myumin;
Standard_Real PasV = myvsup - myvmin;
//! TolU et TolV are used to determine the conditions
//! to stop the iterations; at the iteration number n:
//! (Un - Un-1) < TolU and (Vn - Vn-1) < TolV .
- Standard_EXPORT Extrema_GenExtPS(const gp_Pnt& P, const Adaptor3d_Surface& S, const Standard_Integer NbU, const Standard_Integer NbV, const Standard_Real TolU, const Standard_Real TolV, const Extrema_ExtFlag F = Extrema_ExtFlag_MINMAX, const Extrema_ExtAlgo A = Extrema_ExtAlgo_Grad);
+ Standard_EXPORT Extrema_GenExtPS(const gp_Pnt& P, const Handle(Adaptor3d_Surface)& S, const Standard_Integer NbU, const Standard_Integer NbV, const Standard_Real TolU, const Standard_Real TolV, const Extrema_ExtFlag F = Extrema_ExtFlag_MINMAX, const Extrema_ExtAlgo A = Extrema_ExtAlgo_Grad);
//! It calculates all the distances.
//! The function F(u,v)=distance(P,S(u,v)) has an
//! TolU et TolV are used to determine the conditions
//! to stop the iterations; at the iteration number n:
//! (Un - Un-1) < TolU and (Vn - Vn-1) < TolV .
- Standard_EXPORT Extrema_GenExtPS(const gp_Pnt& P, const Adaptor3d_Surface& S, const Standard_Integer NbU, const Standard_Integer NbV, const Standard_Real Umin, const Standard_Real Usup, const Standard_Real Vmin, const Standard_Real Vsup, const Standard_Real TolU, const Standard_Real TolV, const Extrema_ExtFlag F = Extrema_ExtFlag_MINMAX, const Extrema_ExtAlgo A = Extrema_ExtAlgo_Grad);
+ Standard_EXPORT Extrema_GenExtPS(const gp_Pnt& P, const Handle(Adaptor3d_Surface)& S, const Standard_Integer NbU, const Standard_Integer NbV, const Standard_Real Umin, const Standard_Real Usup, const Standard_Real Vmin, const Standard_Real Vsup, const Standard_Real TolU, const Standard_Real TolV, const Extrema_ExtFlag F = Extrema_ExtFlag_MINMAX, const Extrema_ExtAlgo A = Extrema_ExtAlgo_Grad);
- Standard_EXPORT void Initialize (const Adaptor3d_Surface& S, const Standard_Integer NbU, const Standard_Integer NbV, const Standard_Real TolU, const Standard_Real TolV);
+ Standard_EXPORT void Initialize (const Handle(Adaptor3d_Surface)& S, const Standard_Integer NbU, const Standard_Integer NbV, const Standard_Real TolU, const Standard_Real TolV);
- Standard_EXPORT void Initialize (const Adaptor3d_Surface& S, const Standard_Integer NbU, const Standard_Integer NbV, const Standard_Real Umin, const Standard_Real Usup, const Standard_Real Vmin, const Standard_Real Vsup, const Standard_Real TolU, const Standard_Real TolV);
+ Standard_EXPORT void Initialize (const Handle(Adaptor3d_Surface)& S, const Standard_Integer NbU, const Standard_Integer NbV, const Standard_Real Umin, const Standard_Real Usup, const Standard_Real Vmin, const Standard_Real Vsup, const Standard_Real TolU, const Standard_Real TolV);
//! the algorithm is done with the point P.
//! An exception is raised if the fields have not
Standard_EXPORT void FindSolution (const gp_Pnt& P, const Extrema_POnSurfParams& theParams);
//! Selection of points to build grid, depending on the type of surface
- Standard_EXPORT void GetGridPoints (const Adaptor3d_Surface& theSurf);
+ Standard_EXPORT void GetGridPoints (const Handle(Adaptor3d_Surface)& theSurf);
//! Creation of grid of parametric points
Standard_EXPORT void BuildGrid (const gp_Pnt& thePoint);
Extrema_HUBTreeOfSphere mySphereUBTree;
Handle(Bnd_HArray1OfSphere) mySphereArray;
Extrema_FuncPSNorm myF;
- const Adaptor3d_Surface* myS;
+ Handle(Adaptor3d_Surface) myS;
Extrema_ExtFlag myFlag;
Extrema_ExtAlgo myAlgo;
Handle(TColStd_HArray1OfReal) myUParams;
public:
DEFINE_STANDARD_ALLOC
- Standard_EXPORT Extrema_FuncDistSS(const Adaptor3d_Surface& S1,
- const Adaptor3d_Surface& S2)
- : myS1(&S1),
- myS2(&S2)
+ Standard_EXPORT Extrema_FuncDistSS(const Handle(Adaptor3d_Surface)& S1,
+ const Handle(Adaptor3d_Surface)& S2)
+ : myS1(S1),
+ myS2(S2)
{
}
private:
- const Adaptor3d_Surface *myS1;
- const Adaptor3d_Surface *myS2;
+ const Handle(Adaptor3d_Surface) myS1;
+ const Handle(Adaptor3d_Surface) myS2;
};
//=======================================================================
//purpose :
//=======================================================================
-Extrema_GenExtSS::Extrema_GenExtSS(const Adaptor3d_Surface& S1,
- const Adaptor3d_Surface& S2,
+Extrema_GenExtSS::Extrema_GenExtSS(const Handle(Adaptor3d_Surface)& S1,
+ const Handle(Adaptor3d_Surface)& S2,
const Standard_Integer NbU,
const Standard_Integer NbV,
const Standard_Real Tol1,
//purpose :
//=======================================================================
-Extrema_GenExtSS::Extrema_GenExtSS(const Adaptor3d_Surface& S1,
- const Adaptor3d_Surface& S2,
+Extrema_GenExtSS::Extrema_GenExtSS(const Handle(Adaptor3d_Surface)& S1,
+ const Handle(Adaptor3d_Surface)& S2,
const Standard_Integer NbU,
const Standard_Integer NbV,
const Standard_Real U1min,
//purpose :
//=======================================================================
-void Extrema_GenExtSS::Initialize(const Adaptor3d_Surface& S2,
+void Extrema_GenExtSS::Initialize(const Handle(Adaptor3d_Surface)& S2,
const Standard_Integer NbU,
const Standard_Integer NbV,
const Standard_Real Tol2)
{
- myu2min = S2.FirstUParameter();
- myu2sup = S2.LastUParameter();
- myv2min = S2.FirstVParameter();
- myv2sup = S2.LastVParameter();
+ myu2min = S2->FirstUParameter();
+ myu2sup = S2->LastUParameter();
+ myv2min = S2->FirstVParameter();
+ myv2sup = S2->LastVParameter();
Initialize(S2,NbU,NbV,myu2min,myu2sup,myv2min,myv2sup,Tol2);
}
//purpose :
//=======================================================================
-void Extrema_GenExtSS::Initialize(const Adaptor3d_Surface& S2,
+void Extrema_GenExtSS::Initialize(const Handle(Adaptor3d_Surface)& S2,
const Standard_Integer NbU,
const Standard_Integer NbV,
const Standard_Real U2min,
const Standard_Real V2sup,
const Standard_Real Tol2)
{
- myS2 = &S2;
+ myS2 = S2;
mypoints1 = new TColgp_HArray2OfPnt(0,NbU+1,0,NbV+1);
mypoints2 = new TColgp_HArray2OfPnt(0,NbU+1,0,NbV+1);
myusample = NbU;
//purpose :
//=======================================================================
-void Extrema_GenExtSS::Perform(const Adaptor3d_Surface& S1,
+void Extrema_GenExtSS::Perform(const Handle(Adaptor3d_Surface)& S1,
const Standard_Real Tol1)
{
- myu1min = S1.FirstUParameter();
- myu1sup = S1.LastUParameter();
- myv1min = S1.FirstVParameter();
- myv1sup = S1.LastVParameter();
+ myu1min = S1->FirstUParameter();
+ myu1sup = S1->LastUParameter();
+ myv1min = S1->FirstVParameter();
+ myv1sup = S1->LastVParameter();
Perform(S1, myu1min, myu1sup,myv1min,myv1sup,Tol1);
}
//purpose :
//=======================================================================
-void Extrema_GenExtSS::Perform(const Adaptor3d_Surface& S1,
+void Extrema_GenExtSS::Perform(const Handle(Adaptor3d_Surface)& S1,
const Standard_Real U1min,
const Standard_Real U1sup,
const Standard_Real V1min,
const Standard_Real V1sup,
const Standard_Real Tol1)
{
- myF.Initialize(S1,*myS2);
+ myF.Initialize(S1, myS2);
myu1min = U1min;
myu1sup = U1sup;
myv1min = V1min;
for ( NoU1 = 1, U1 = U10; NoU1 <= myusample; NoU1++, U1 += PasU1) {
for ( NoV1 = 1, V1 = V10; NoV1 <= myvsample; NoV1++, V1 += PasV1) {
- P1 = S1.Value(U1, V1);
+ P1 = S1->Value(U1, V1);
mypoints1->SetValue(NoU1,NoV1,P1);
}
}
UV(3) = U20 + (N2Umin - 1) * PasU2;
UV(4) = V20 + (N2Vmin - 1) * PasV2;
- Extrema_FuncDistSS aGFSS(S1, *myS2);
+ Extrema_FuncDistSS aGFSS(S1, myS2);
math_BFGS aBFGSSolver(4);
aBFGSSolver.Perform(aGFSS, UV);
if (aBFGSSolver.IsDone())
//! surfaces.
//! NbU and NbV are used to locate the close points
//! to find the zeros.
- Standard_EXPORT Extrema_GenExtSS(const Adaptor3d_Surface& S1, const Adaptor3d_Surface& S2, const Standard_Integer NbU, const Standard_Integer NbV, const Standard_Real Tol1, const Standard_Real Tol2);
+ Standard_EXPORT Extrema_GenExtSS(const Handle(Adaptor3d_Surface)& S1, const Handle(Adaptor3d_Surface)& S2, const Standard_Integer NbU, const Standard_Integer NbV, const Standard_Real Tol1, const Standard_Real Tol2);
//! It calculates all the distances.
//! The function F(u,v)=distance(P,S(u,v)) has an
//! surface.
//! NbU and NbV are used to locate the close points
//! to find the zeros.
- Standard_EXPORT Extrema_GenExtSS(const Adaptor3d_Surface& S1, const Adaptor3d_Surface& S2, const Standard_Integer NbU, const Standard_Integer NbV, const Standard_Real U1min, const Standard_Real U1sup, const Standard_Real V1min, const Standard_Real V1sup, const Standard_Real U2min, const Standard_Real U2sup, const Standard_Real V2min, const Standard_Real V2sup, const Standard_Real Tol1, const Standard_Real Tol2);
+ Standard_EXPORT Extrema_GenExtSS(const Handle(Adaptor3d_Surface)& S1, const Handle(Adaptor3d_Surface)& S2, const Standard_Integer NbU, const Standard_Integer NbV, const Standard_Real U1min, const Standard_Real U1sup, const Standard_Real V1min, const Standard_Real V1sup, const Standard_Real U2min, const Standard_Real U2sup, const Standard_Real V2min, const Standard_Real V2sup, const Standard_Real Tol1, const Standard_Real Tol2);
- Standard_EXPORT void Initialize (const Adaptor3d_Surface& S2, const Standard_Integer NbU, const Standard_Integer NbV, const Standard_Real Tol2);
+ Standard_EXPORT void Initialize (const Handle(Adaptor3d_Surface)& S2, const Standard_Integer NbU, const Standard_Integer NbV, const Standard_Real Tol2);
- Standard_EXPORT void Initialize (const Adaptor3d_Surface& S2, const Standard_Integer NbU, const Standard_Integer NbV, const Standard_Real U2min, const Standard_Real U2sup, const Standard_Real V2min, const Standard_Real V2sup, const Standard_Real Tol2);
+ Standard_EXPORT void Initialize (const Handle(Adaptor3d_Surface)& S2, const Standard_Integer NbU, const Standard_Integer NbV, const Standard_Real U2min, const Standard_Real U2sup, const Standard_Real V2min, const Standard_Real V2sup, const Standard_Real Tol2);
//! the algorithm is done with S1
//! An exception is raised if the fields have not
//! been initialized.
- Standard_EXPORT void Perform (const Adaptor3d_Surface& S1, const Standard_Real Tol1);
+ Standard_EXPORT void Perform (const Handle(Adaptor3d_Surface)& S1, const Standard_Real Tol1);
//! the algorithm is done withS1
//! An exception is raised if the fields have not
//! been initialized.
- Standard_EXPORT void Perform (const Adaptor3d_Surface& S1, const Standard_Real U1min, const Standard_Real U1sup, const Standard_Real V1min, const Standard_Real V1sup, const Standard_Real Tol1);
+ Standard_EXPORT void Perform (const Handle(Adaptor3d_Surface)& S1, const Standard_Real U1min, const Standard_Real U1sup, const Standard_Real V1min, const Standard_Real V1sup, const Standard_Real Tol1);
//! Returns True if the distances are found.
Standard_EXPORT Standard_Boolean IsDone() const;
Standard_Real mytol1;
Standard_Real mytol2;
Extrema_FuncExtSS myF;
- const Adaptor3d_Surface* myS2;
+ Handle(Adaptor3d_Surface) myS2;
};
//purpose :
//=======================================================================
- Extrema_GenLocateExtCS::Extrema_GenLocateExtCS(const Adaptor3d_Curve& C,
- const Adaptor3d_Surface& S,
+ Extrema_GenLocateExtCS::Extrema_GenLocateExtCS(const Handle(Adaptor3d_Curve)& C,
+ const Handle(Adaptor3d_Surface)& S,
const Standard_Real T,
const Standard_Real U,
const Standard_Real V,
//purpose :
//=======================================================================
-void Extrema_GenLocateExtCS::Perform(const Adaptor3d_Curve& C,
- const Adaptor3d_Surface& S,
+void Extrema_GenLocateExtCS::Perform(const Handle(Adaptor3d_Curve)& C,
+ const Handle(Adaptor3d_Surface)& S,
const Standard_Real T,
const Standard_Real U,
const Standard_Real V,
myDone = Standard_False;
Standard_Real Tinf, Tsup;
- Tinf = C.FirstParameter();
- Tsup = C.LastParameter();
+ Tinf = C->FirstParameter();
+ Tsup = C->LastParameter();
Standard_Real Uinf, Usup, Vinf, Vsup;
- Uinf = S.FirstUParameter();
- Usup = S.LastUParameter();
- Vinf = S.FirstVParameter();
- Vsup = S.LastVParameter();
+ Uinf = S->FirstUParameter();
+ Usup = S->LastUParameter();
+ Vinf = S->FirstVParameter();
+ Vsup = S->LastVParameter();
Extrema_FuncExtCS F (C,S);
math_Vector Tol(1, 3), Start(1, 3), BInf(1, 3), BSup(1, 3);
//! The function F(t,u,v)=distance(C(t),S(u,v))
//! has an extremun when gradient(F)=0. The algorithm searches
//! a zero near the close points.
- Standard_EXPORT Extrema_GenLocateExtCS(const Adaptor3d_Curve& C, const Adaptor3d_Surface& S, const Standard_Real T, const Standard_Real U, const Standard_Real V, const Standard_Real Tol1, const Standard_Real Tol2);
+ Standard_EXPORT Extrema_GenLocateExtCS(const Handle(Adaptor3d_Curve)& C, const Handle(Adaptor3d_Surface)& S, const Standard_Real T, const Standard_Real U, const Standard_Real V, const Standard_Real Tol1, const Standard_Real Tol2);
- Standard_EXPORT void Perform (const Adaptor3d_Curve& C, const Adaptor3d_Surface& S, const Standard_Real T, const Standard_Real U, const Standard_Real V, const Standard_Real Tol1, const Standard_Real Tol2);
+ Standard_EXPORT void Perform (const Handle(Adaptor3d_Curve)& C, const Handle(Adaptor3d_Surface)& S, const Standard_Real T, const Standard_Real U, const Standard_Real V, const Standard_Real Tol1, const Standard_Real Tol2);
//! Returns True if the distance is found.
Standard_EXPORT Standard_Boolean IsDone() const;
//purpose :
//=======================================================================
-Standard_Boolean Extrema_GenLocateExtPS::IsMinDist(const gp_Pnt& theP, const Adaptor3d_Surface& theS,
+Standard_Boolean Extrema_GenLocateExtPS::IsMinDist(const gp_Pnt& theP, const Handle(Adaptor3d_Surface)& theS,
const Standard_Real theU0, const Standard_Real theV0)
{
- Standard_Real du = Max(theS.UResolution(10.*Precision::Confusion()), 10.*Precision::PConfusion());
- Standard_Real dv = Max(theS.VResolution(10.*Precision::Confusion()), 10.*Precision::PConfusion());
+ Standard_Real du = Max(theS->UResolution(10.*Precision::Confusion()), 10.*Precision::PConfusion());
+ Standard_Real dv = Max(theS->VResolution(10.*Precision::Confusion()), 10.*Precision::PConfusion());
Standard_Real u, v;
- gp_Pnt aP0 = theS.Value(theU0, theV0);
+ gp_Pnt aP0 = theS->Value(theU0, theV0);
Standard_Real d0 = theP.SquareDistance(aP0);
Standard_Integer iu, iv;
for (iu = -1; iu <= 1; ++iu)
{
u = theU0 + iu * du;
- if (!theS.IsUPeriodic())
+ if (!theS->IsUPeriodic())
{
- u = Max(u, theS.FirstUParameter());
- u = Min(u, theS.LastUParameter());
+ u = Max(u, theS->FirstUParameter());
+ u = Min(u, theS->LastUParameter());
}
for (iv = -1; iv <= 1; ++iv)
{
continue;
v = theV0 + iv * dv;
- if (!theS.IsVPeriodic())
+ if (!theS->IsVPeriodic())
{
- v = Max(v, theS.FirstVParameter());
- v = Min(v, theS.LastVParameter());
+ v = Max(v, theS->FirstVParameter());
+ v = Min(v, theS->LastVParameter());
}
- Standard_Real d = theP.SquareDistance(theS.Value(u, v));
+ Standard_Real d = theP.SquareDistance(theS->Value(u, v));
if (d < d0)
return Standard_False;
}
//function : Extrema_GenLocateExtPS
//purpose :
//=======================================================================
-Extrema_GenLocateExtPS::Extrema_GenLocateExtPS(const Adaptor3d_Surface& theS,
+Extrema_GenLocateExtPS::Extrema_GenLocateExtPS(const Handle(Adaptor3d_Surface)& theS,
const Standard_Real theTolU,
const Standard_Real theTolV)
: mySurf(theS),
aStart(2) = theV0;
// Borders.
- aBoundInf(1) = mySurf.FirstUParameter();
- aBoundInf(2) = mySurf.FirstVParameter();
- aBoundSup(1) = mySurf.LastUParameter();
- aBoundSup(2) = mySurf.LastVParameter();
+ aBoundInf(1) = mySurf->FirstUParameter();
+ aBoundInf(2) = mySurf->FirstVParameter();
+ aBoundSup(1) = mySurf->LastUParameter();
+ aBoundSup(2) = mySurf->LastVParameter();
if (isDistanceCriteria)
{
mySqDist = aSolver.Minimum();
}
- myPoint.SetParameters(aResPnt(1), aResPnt(2), mySurf.Value(aResPnt(1), aResPnt(2)));
+ myPoint.SetParameters(aResPnt(1), aResPnt(2), mySurf->Value(aResPnt(1), aResPnt(2)));
myDone = Standard_True;
}
else
// Normal projection criteria.
Extrema_FuncPSNorm F(theP, mySurf);
- if (mySurf.GetType() == GeomAbs_BSplineSurface)
+ if (mySurf->GetType() == GeomAbs_BSplineSurface)
{
aTol(1) = myTolU;
aTol(2) = myTolV;
DEFINE_STANDARD_ALLOC
//! Constructor.
- Standard_EXPORT Extrema_GenLocateExtPS(const Adaptor3d_Surface& theS,
+ Standard_EXPORT Extrema_GenLocateExtPS(const Handle(Adaptor3d_Surface)& theS,
const Standard_Real theTolU = Precision::PConfusion(),
const Standard_Real theTolV = Precision::PConfusion());
//! Returns True if UV point theU0, theV0 is point of local minimum of square distance between
//! point theP and points theS(U, V), U, V are in small area around theU0, theV0
- Standard_EXPORT static Standard_Boolean IsMinDist(const gp_Pnt& theP, const Adaptor3d_Surface& theS,
+ Standard_EXPORT static Standard_Boolean IsMinDist(const gp_Pnt& theP, const Handle(Adaptor3d_Surface)& theS,
const Standard_Real theU0, const Standard_Real theV0);
private:
Extrema_GenLocateExtPS(const Extrema_GenLocateExtPS&);
// Input.
- const Adaptor3d_Surface& mySurf;
+ const Handle(Adaptor3d_Surface)& mySurf;
Standard_Real myTolU, myTolV;
// State.
//purpose :
//=======================================================================
- Extrema_GenLocateExtSS::Extrema_GenLocateExtSS(const Adaptor3d_Surface& S1,
- const Adaptor3d_Surface& S2,
+ Extrema_GenLocateExtSS::Extrema_GenLocateExtSS(const Handle(Adaptor3d_Surface)& S1,
+ const Handle(Adaptor3d_Surface)& S2,
const Standard_Real U1,
const Standard_Real V1,
const Standard_Real U2,
//purpose :
//=======================================================================
-void Extrema_GenLocateExtSS::Perform(const Adaptor3d_Surface& S1,
- const Adaptor3d_Surface& S2,
+void Extrema_GenLocateExtSS::Perform(const Handle(Adaptor3d_Surface)& S1,
+ const Handle(Adaptor3d_Surface)& S2,
const Standard_Real U1,
const Standard_Real V1,
const Standard_Real U2,
myDone = Standard_False;
Standard_Real Uinf1, Usup1, Vinf1, Vsup1;
- Uinf1 = S1.FirstUParameter();
- Usup1 = S1.LastUParameter();
- Vinf1 = S1.FirstVParameter();
- Vsup1 = S1.LastVParameter();
+ Uinf1 = S1->FirstUParameter();
+ Usup1 = S1->LastUParameter();
+ Vinf1 = S1->FirstVParameter();
+ Vsup1 = S1->LastVParameter();
Standard_Real Uinf2, Usup2, Vinf2, Vsup2;
- Uinf2 = S2.FirstUParameter();
- Usup2 = S2.LastUParameter();
- Vinf2 = S2.FirstVParameter();
- Vsup2 = S2.LastVParameter();
+ Uinf2 = S2->FirstUParameter();
+ Usup2 = S2->LastUParameter();
+ Vinf2 = S2->FirstVParameter();
+ Vsup2 = S2->LastVParameter();
Extrema_FuncExtSS F (S1,S2);
math_Vector Tol(1, 4), Start(1, 4), BInf(1, 4), BSup(1, 4);
//! The function F(u1,v1,u2,v2)=distance(S1(u1,v1),S2(u2,v2))
//! has an extremun when gradient(F)=0. The algorithm searches
//! a zero near the close points.
- Standard_EXPORT Extrema_GenLocateExtSS(const Adaptor3d_Surface& S1, const Adaptor3d_Surface& S2, const Standard_Real U1, const Standard_Real V1, const Standard_Real U2, const Standard_Real V2, const Standard_Real Tol1, const Standard_Real Tol2);
+ Standard_EXPORT Extrema_GenLocateExtSS(const Handle(Adaptor3d_Surface)& S1, const Handle(Adaptor3d_Surface)& S2, const Standard_Real U1, const Standard_Real V1, const Standard_Real U2, const Standard_Real V2, const Standard_Real Tol1, const Standard_Real Tol2);
- Standard_EXPORT void Perform (const Adaptor3d_Surface& S1, const Adaptor3d_Surface& S2, const Standard_Real U1, const Standard_Real V1, const Standard_Real U2, const Standard_Real V2, const Standard_Real Tol1, const Standard_Real Tol2);
+ Standard_EXPORT void Perform (const Handle(Adaptor3d_Surface)& S1, const Handle(Adaptor3d_Surface)& S2, const Standard_Real U1, const Standard_Real V1, const Standard_Real U2, const Standard_Real V2, const Standard_Real Tol1, const Standard_Real Tol2);
//! Returns True if the distance is found.
Standard_EXPORT Standard_Boolean IsDone() const;
}
// 3d _Value
-static Standard_Boolean _Value(const Adaptor3d_Curve& C1,
- const Adaptor3d_Curve& C2,
+static Standard_Boolean _Value(const Handle(Adaptor3d_Curve)& C1,
+ const Handle(Adaptor3d_Curve)& C2,
const math_Vector& X,
Standard_Real& F)
{
Standard_Real u = X(1);
Standard_Real v = X(2);
- if (u < C1.FirstParameter() ||
- u > C1.LastParameter() ||
- v < C2.FirstParameter() ||
- v > C2.LastParameter())
+ if (u < C1->FirstParameter() ||
+ u > C1->LastParameter() ||
+ v < C2->FirstParameter() ||
+ v > C2->LastParameter())
{
return Standard_False;
}
- F = C2.Value(v).SquareDistance(C1.Value(u));
+ F = C2->Value(v).SquareDistance(C1->Value(u));
return Standard_True;
}
// 2d _Value
-static Standard_Boolean _Value(const Adaptor2d_Curve2d& C1,
- const Adaptor2d_Curve2d& C2,
+static Standard_Boolean _Value(const Handle(Adaptor2d_Curve2d)& C1,
+ const Handle(Adaptor2d_Curve2d)& C2,
const math_Vector& X,
Standard_Real& F)
{
Standard_Real u = X(1);
Standard_Real v = X(2);
- if (u < C1.FirstParameter() ||
- u > C1.LastParameter() ||
- v < C2.FirstParameter() ||
- v > C2.LastParameter())
+ if (u < C1->FirstParameter() ||
+ u > C1->LastParameter() ||
+ v < C2->FirstParameter() ||
+ v > C2->LastParameter())
{
return Standard_False;
}
- F = C2.Value(v).SquareDistance(C1.Value(u));
+ F = C2->Value(v).SquareDistance(C1->Value(u));
return Standard_True;
}
//! F = (x2(v) - x1(u))^2 + (y2(v) - y1(u))^2 + (z2(v) - z1(u))^2
// 3d _Gradient
-static Standard_Boolean _Gradient(const Adaptor3d_Curve& C1,
- const Adaptor3d_Curve& C2,
+static Standard_Boolean _Gradient(const Handle(Adaptor3d_Curve)& C1,
+ const Handle(Adaptor3d_Curve)& C2,
const math_Vector& X,
math_Vector& G)
{
gp_Pnt C1D0, C2D0;
gp_Vec C1D1, C2D1;
- if(X(1) < C1.FirstParameter() ||
- X(1) > C1.LastParameter() ||
- X(2) < C2.FirstParameter() ||
- X(2) > C2.LastParameter())
+ if(X(1) < C1->FirstParameter() ||
+ X(1) > C1->LastParameter() ||
+ X(2) < C2->FirstParameter() ||
+ X(2) > C2->LastParameter())
{
return Standard_False;
}
- C1.D1(X(1), C1D0, C1D1);
- C2.D1(X(2), C2D0, C2D1);
+ C1->D1(X(1), C1D0, C1D1);
+ C2->D1(X(2), C2D0, C2D1);
G(1) = - (C2D0.X() - C1D0.X()) * C1D1.X()
- (C2D0.Y() - C1D0.Y()) * C1D1.Y()
}
// 2d _Graient
-static Standard_Boolean _Gradient(const Adaptor2d_Curve2d& C1,
- const Adaptor2d_Curve2d& C2,
+static Standard_Boolean _Gradient(const Handle(Adaptor2d_Curve2d)& C1,
+ const Handle(Adaptor2d_Curve2d)& C2,
const math_Vector& X,
math_Vector& G)
{
gp_Pnt2d C1D0, C2D0;
gp_Vec2d C1D1, C2D1;
- if(X(1) < C1.FirstParameter() ||
- X(1) > C1.LastParameter() ||
- X(2) < C2.FirstParameter() ||
- X(2) > C2.LastParameter())
+ if(X(1) < C1->FirstParameter() ||
+ X(1) > C1->LastParameter() ||
+ X(2) < C2->FirstParameter() ||
+ X(2) > C2->LastParameter())
{
return Standard_False;
}
- C1.D1(X(1), C1D0, C1D1);
- C2.D1(X(2), C2D0, C2D1);
+ C1->D1(X(1), C1D0, C1D1);
+ C2->D1(X(2), C2D0, C2D1);
G(1) = - (C2D0.X() - C1D0.X()) * C1D1.X()
- (C2D0.Y() - C1D0.Y()) * C1D1.Y();
}
// 3d _Hessian
-static Standard_Boolean _Hessian (const Adaptor3d_Curve& C1,
- const Adaptor3d_Curve& C2,
+static Standard_Boolean _Hessian (const Handle(Adaptor3d_Curve)& C1,
+ const Handle(Adaptor3d_Curve)& C2,
const math_Vector& X,
math_Matrix & H)
{
gp_Vec C1D1, C2D1;
gp_Vec C1D2, C2D2;
- if(X(1) < C1.FirstParameter() ||
- X(1) > C1.LastParameter() ||
- X(2) < C2.FirstParameter() ||
- X(2) > C2.LastParameter())
+ if(X(1) < C1->FirstParameter() ||
+ X(1) > C1->LastParameter() ||
+ X(2) < C2->FirstParameter() ||
+ X(2) > C2->LastParameter())
{
return Standard_False;
}
- C1.D2(X(1), C1D0, C1D1, C1D2);
- C2.D2(X(2), C2D0, C2D1, C2D2);
+ C1->D2(X(1), C1D0, C1D1, C1D2);
+ C2->D2(X(2), C2D0, C2D1, C2D2);
H(1, 1) = C1D1.X() * C1D1.X()
+ C1D1.Y() * C1D1.Y()
}
// 2d _Hessian
-static Standard_Boolean _Hessian (const Adaptor2d_Curve2d& C1,
- const Adaptor2d_Curve2d& C2,
+static Standard_Boolean _Hessian (const Handle(Adaptor2d_Curve2d)& C1,
+ const Handle(Adaptor2d_Curve2d)& C2,
const math_Vector& X,
math_Matrix & H)
{
gp_Vec2d C1D1, C2D1;
gp_Vec2d C1D2, C2D2;
- if(X(1) < C1.FirstParameter() ||
- X(1) > C1.LastParameter() ||
- X(2) < C2.FirstParameter() ||
- X(2) > C2.LastParameter())
+ if(X(1) < C1->FirstParameter() ||
+ X(1) > C1->LastParameter() ||
+ X(2) < C2->FirstParameter() ||
+ X(2) > C2->LastParameter())
{
return Standard_False;
}
- C1.D2(X(1), C1D0, C1D1, C1D2);
- C2.D2(X(2), C2D0, C2D1, C2D2);
+ C1->D2(X(1), C1D0, C1D1, C1D2);
+ C2->D2(X(2), C2D0, C2D1, C2D2);
H(1, 1) = C1D1.X() * C1D1.X()
+ C1D1.Y() * C1D1.Y()
//function : Extrema_GlobOptFuncCCC0
//purpose : Constructor
//=======================================================================
-Extrema_GlobOptFuncCCC0::Extrema_GlobOptFuncCCC0(const Adaptor3d_Curve& C1,
- const Adaptor3d_Curve& C2)
-: myC1_3d(&C1),
- myC2_3d(&C2),
+Extrema_GlobOptFuncCCC0::Extrema_GlobOptFuncCCC0(const Handle(Adaptor3d_Curve)& C1,
+ const Handle(Adaptor3d_Curve)& C2)
+: myC1_3d(C1),
+ myC2_3d(C2),
myC1_2d(NULL),
myC2_2d(NULL)
{
//function : Extrema_GlobOptFuncCCC0
//purpose : Constructor
//=======================================================================
-Extrema_GlobOptFuncCCC0::Extrema_GlobOptFuncCCC0(const Adaptor2d_Curve2d& C1,
- const Adaptor2d_Curve2d& C2)
+Extrema_GlobOptFuncCCC0::Extrema_GlobOptFuncCCC0(const Handle(Adaptor2d_Curve2d)& C1,
+ const Handle(Adaptor2d_Curve2d)& C2)
: myC1_3d(NULL),
myC2_3d(NULL),
- myC1_2d(&C1),
- myC2_2d(&C2)
+ myC1_2d(C1),
+ myC2_2d(C2)
{
myType = 2;
}
Standard_Boolean Extrema_GlobOptFuncCCC0::Value(const math_Vector& X,Standard_Real& F)
{
if (myType == 1)
- return _Value(*myC1_3d, *myC2_3d, X, F);
+ return _Value(myC1_3d, myC2_3d, X, F);
else
- return _Value(*myC1_2d, *myC2_2d, X, F);
+ return _Value(myC1_2d, myC2_2d, X, F);
}
// C1
//function : Extrema_GlobOptFuncCCC1
//purpose : Constructor
//=======================================================================
-Extrema_GlobOptFuncCCC1::Extrema_GlobOptFuncCCC1(const Adaptor3d_Curve& C1,
- const Adaptor3d_Curve& C2)
-: myC1_3d(&C1),
- myC2_3d(&C2),
+Extrema_GlobOptFuncCCC1::Extrema_GlobOptFuncCCC1(const Handle(Adaptor3d_Curve)& C1,
+ const Handle(Adaptor3d_Curve)& C2)
+: myC1_3d(C1),
+ myC2_3d(C2),
myC1_2d(NULL),
myC2_2d(NULL)
{
//function : Extrema_GlobOptFuncCCC1
//purpose : Constructor
//=======================================================================
-Extrema_GlobOptFuncCCC1::Extrema_GlobOptFuncCCC1(const Adaptor2d_Curve2d& C1,
- const Adaptor2d_Curve2d& C2)
+Extrema_GlobOptFuncCCC1::Extrema_GlobOptFuncCCC1(const Handle(Adaptor2d_Curve2d)& C1,
+ const Handle(Adaptor2d_Curve2d)& C2)
: myC1_3d(NULL),
myC2_3d(NULL),
- myC1_2d(&C1),
- myC2_2d(&C2)
+ myC1_2d(C1),
+ myC2_2d(C2)
{
myType = 2;
}
Standard_Boolean Extrema_GlobOptFuncCCC1::Value(const math_Vector& X,Standard_Real& F)
{
if (myType == 1)
- return _Value(*myC1_3d, *myC2_3d, X, F);
+ return _Value(myC1_3d, myC2_3d, X, F);
else
- return _Value(*myC1_2d, *myC2_2d, X, F);
+ return _Value(myC1_2d, myC2_2d, X, F);
}
//=======================================================================
Standard_Boolean Extrema_GlobOptFuncCCC1::Gradient(const math_Vector& X,math_Vector& G)
{
if (myType == 1)
- return _Gradient(*myC1_3d, *myC2_3d, X, G);
+ return _Gradient(myC1_3d, myC2_3d, X, G);
else
- return _Gradient(*myC1_2d, *myC2_2d, X, G);
+ return _Gradient(myC1_2d, myC2_2d, X, G);
}
//=======================================================================
//function : Extrema_GlobOptFuncCCC2
//purpose : Constructor
//=======================================================================
-Extrema_GlobOptFuncCCC2::Extrema_GlobOptFuncCCC2(const Adaptor3d_Curve& C1,
- const Adaptor3d_Curve& C2)
-: myC1_3d(&C1),
- myC2_3d(&C2),
+Extrema_GlobOptFuncCCC2::Extrema_GlobOptFuncCCC2(const Handle(Adaptor3d_Curve)& C1,
+ const Handle(Adaptor3d_Curve)& C2)
+: myC1_3d(C1),
+ myC2_3d(C2),
myC1_2d(NULL),
myC2_2d(NULL)
{
//function : Extrema_GlobOptFuncCCC2
//purpose : Constructor
//=======================================================================
-Extrema_GlobOptFuncCCC2::Extrema_GlobOptFuncCCC2(const Adaptor2d_Curve2d& C1,
- const Adaptor2d_Curve2d& C2)
+Extrema_GlobOptFuncCCC2::Extrema_GlobOptFuncCCC2(const Handle(Adaptor2d_Curve2d)& C1,
+ const Handle(Adaptor2d_Curve2d)& C2)
: myC1_3d(NULL),
myC2_3d(NULL),
- myC1_2d(&C1),
- myC2_2d(&C2)
+ myC1_2d(C1),
+ myC2_2d(C2)
{
myType = 2;
}
Standard_Boolean Extrema_GlobOptFuncCCC2::Value(const math_Vector& X,Standard_Real& F)
{
if (myType == 1)
- return _Value(*myC1_3d, *myC2_3d, X, F);
+ return _Value(myC1_3d, myC2_3d, X, F);
else
- return _Value(*myC1_2d, *myC2_2d, X, F);
+ return _Value(myC1_2d, myC2_2d, X, F);
}
//=======================================================================
Standard_Boolean Extrema_GlobOptFuncCCC2::Gradient(const math_Vector& X,math_Vector& G)
{
if (myType == 1)
- return _Gradient(*myC1_3d, *myC2_3d, X, G);
+ return _Gradient(myC1_3d, myC2_3d, X, G);
else
- return _Gradient(*myC1_2d, *myC2_2d, X, G);
+ return _Gradient(myC1_2d, myC2_2d, X, G);
}
//=======================================================================
{
Standard_Boolean isHessianComputed = Standard_False;
if (myType == 1)
- isHessianComputed = _Hessian(*myC1_3d, *myC2_3d, X, H);
+ isHessianComputed = _Hessian(myC1_3d, myC2_3d, X, H);
else
- isHessianComputed = _Hessian(*myC1_2d, *myC2_2d, X, H);
+ isHessianComputed = _Hessian(myC1_2d, myC2_2d, X, H);
return (Value(X, F) && Gradient(X, G) && isHessianComputed);
}
{
public:
- Standard_EXPORT Extrema_GlobOptFuncCCC0(const Adaptor3d_Curve& C1,
- const Adaptor3d_Curve& C2);
+ Standard_EXPORT Extrema_GlobOptFuncCCC0(const Handle(Adaptor3d_Curve)& C1,
+ const Handle(Adaptor3d_Curve)& C2);
- Standard_EXPORT Extrema_GlobOptFuncCCC0(const Adaptor2d_Curve2d& C1,
- const Adaptor2d_Curve2d& C2);
+ Standard_EXPORT Extrema_GlobOptFuncCCC0(const Handle(Adaptor2d_Curve2d)& C1,
+ const Handle(Adaptor2d_Curve2d)& C2);
Extrema_GlobOptFuncCCC0 & operator = (const Extrema_GlobOptFuncCCC0 & theOther);
- const Adaptor3d_Curve *myC1_3d, *myC2_3d;
- const Adaptor2d_Curve2d *myC1_2d, *myC2_2d;
+ const Handle(Adaptor3d_Curve) myC1_3d, myC2_3d;
+ const Handle(Adaptor2d_Curve2d) myC1_2d, myC2_2d;
Standard_Integer myType;
};
{
public:
- Standard_EXPORT Extrema_GlobOptFuncCCC1(const Adaptor3d_Curve& C1,
- const Adaptor3d_Curve& C2);
+ Standard_EXPORT Extrema_GlobOptFuncCCC1(const Handle(Adaptor3d_Curve)& C1,
+ const Handle(Adaptor3d_Curve)& C2);
- Standard_EXPORT Extrema_GlobOptFuncCCC1(const Adaptor2d_Curve2d& C1,
- const Adaptor2d_Curve2d& C2);
+ Standard_EXPORT Extrema_GlobOptFuncCCC1(const Handle(Adaptor2d_Curve2d)& C1,
+ const Handle(Adaptor2d_Curve2d)& C2);
Standard_EXPORT virtual Standard_Integer NbVariables() const;
Extrema_GlobOptFuncCCC1 & operator = (const Extrema_GlobOptFuncCCC1 & theOther);
- const Adaptor3d_Curve *myC1_3d, *myC2_3d;
- const Adaptor2d_Curve2d *myC1_2d, *myC2_2d;
+ const Handle(Adaptor3d_Curve) myC1_3d, myC2_3d;
+ const Handle(Adaptor2d_Curve2d) myC1_2d, myC2_2d;
Standard_Integer myType;
};
{
public:
- Standard_EXPORT Extrema_GlobOptFuncCCC2(const Adaptor3d_Curve& C1,
- const Adaptor3d_Curve& C2);
+ Standard_EXPORT Extrema_GlobOptFuncCCC2(const Handle(Adaptor3d_Curve)& C1,
+ const Handle(Adaptor3d_Curve)& C2);
- Standard_EXPORT Extrema_GlobOptFuncCCC2(const Adaptor2d_Curve2d& C1,
- const Adaptor2d_Curve2d& C2);
+ Standard_EXPORT Extrema_GlobOptFuncCCC2(const Handle(Adaptor2d_Curve2d)& C1,
+ const Handle(Adaptor2d_Curve2d)& C2);
Standard_EXPORT virtual Standard_Integer NbVariables() const;
Extrema_GlobOptFuncCCC2 & operator = (const Extrema_GlobOptFuncCCC2 & theOther);
- const Adaptor3d_Curve *myC1_3d, *myC2_3d;
- const Adaptor2d_Curve2d *myC1_2d, *myC2_2d;
+ const Handle(Adaptor3d_Curve) myC1_3d, myC2_3d;
+ const Handle(Adaptor2d_Curve2d) myC1_2d, myC2_2d;
Standard_Integer myType;
};
//function : Extrema_GlobOptFuncCQuadric
//purpose : Constructor
//=======================================================================
-Extrema_GlobOptFuncCQuadric::Extrema_GlobOptFuncCQuadric(const Adaptor3d_Curve *C,
- const Adaptor3d_Surface *S)
+Extrema_GlobOptFuncCQuadric::Extrema_GlobOptFuncCQuadric(const Handle(Adaptor3d_Curve) C,
+ const Handle(Adaptor3d_Surface) S)
: myC(C)
{
myTf = myC->FirstParameter();
//function : Extrema_GlobOptFuncCQuadric
//purpose : Constructor
//=======================================================================
-Extrema_GlobOptFuncCQuadric::Extrema_GlobOptFuncCQuadric(const Adaptor3d_Curve *C)
+Extrema_GlobOptFuncCQuadric::Extrema_GlobOptFuncCQuadric(const Handle(Adaptor3d_Curve) C)
: myC(C)
{
myTf = myC->FirstParameter();
//function : Extrema_GlobOptFuncCQuadric
//purpose : Constructor
//=======================================================================
-Extrema_GlobOptFuncCQuadric::Extrema_GlobOptFuncCQuadric(const Adaptor3d_Curve *C,
+Extrema_GlobOptFuncCQuadric::Extrema_GlobOptFuncCQuadric(const Handle(Adaptor3d_Curve) C,
const Standard_Real theTf, const Standard_Real theTl)
: myC(C), myTf(theTf), myTl(theTl)
{
//function : LoadQuad
//purpose :
//=======================================================================
-void Extrema_GlobOptFuncCQuadric::LoadQuad( const Adaptor3d_Surface *S,
+void Extrema_GlobOptFuncCQuadric::LoadQuad( const Handle(Adaptor3d_Surface) S,
const Standard_Real theUf, const Standard_Real theUl,
const Standard_Real theVf, const Standard_Real theVl)
{
public:
//! Curve and surface should exist during all the lifetime of Extrema_GlobOptFuncCQuadric.
- Standard_EXPORT Extrema_GlobOptFuncCQuadric(const Adaptor3d_Curve *C);
+ Standard_EXPORT Extrema_GlobOptFuncCQuadric(const Handle(Adaptor3d_Curve) C);
- Standard_EXPORT Extrema_GlobOptFuncCQuadric(const Adaptor3d_Curve *C,
+ Standard_EXPORT Extrema_GlobOptFuncCQuadric(const Handle(Adaptor3d_Curve) C,
const Standard_Real theTf,
const Standard_Real theTl);
- Standard_EXPORT Extrema_GlobOptFuncCQuadric(const Adaptor3d_Curve *C,
- const Adaptor3d_Surface *S);
+ Standard_EXPORT Extrema_GlobOptFuncCQuadric(const Handle(Adaptor3d_Curve) C,
+ const Handle(Adaptor3d_Surface) S);
- Standard_EXPORT void LoadQuad(const Adaptor3d_Surface *S,
+ Standard_EXPORT void LoadQuad(const Handle(Adaptor3d_Surface) S,
const Standard_Real theUf,
const Standard_Real theUl,
const Standard_Real theVf,
Standard_Real &F);
- const Adaptor3d_Curve *myC;
- const Adaptor3d_Surface *myS;
+ Handle(Adaptor3d_Curve) myC;
+ Handle(Adaptor3d_Surface) myS;
GeomAbs_SurfaceType mySType;
gp_Pln myPln;
gp_Cone myCone;
//function : Extrema_GlobOptFuncCS
//purpose : Constructor
//=======================================================================
-Extrema_GlobOptFuncCS::Extrema_GlobOptFuncCS(const Adaptor3d_Curve *C,
- const Adaptor3d_Surface *S)
+Extrema_GlobOptFuncCS::Extrema_GlobOptFuncCS(const Handle(Adaptor3d_Curve) C,
+ const Handle(Adaptor3d_Surface) S)
: myC(C),
myS(S)
{
public:
//! Curve and surface should exist during all the lifetime of Extrema_GlobOptFuncCS.
- Standard_EXPORT Extrema_GlobOptFuncCS(const Adaptor3d_Curve *C,
- const Adaptor3d_Surface *S);
+ Standard_EXPORT Extrema_GlobOptFuncCS(const Handle(Adaptor3d_Curve) C,
+ const Handle(Adaptor3d_Surface) S);
Standard_EXPORT virtual Standard_Integer NbVariables() const;
Extrema_GlobOptFuncCS & operator = (const Extrema_GlobOptFuncCS & theOther);
- const Adaptor3d_Curve *myC;
- const Adaptor3d_Surface *myS;
+ const Handle(Adaptor3d_Curve) myC;
+ const Handle(Adaptor3d_Surface) myS;
};
#endif
//function : Extrema_GlobOptFuncConicS
//purpose : Constructor
//=======================================================================
-Extrema_GlobOptFuncConicS::Extrema_GlobOptFuncConicS(const Adaptor3d_Surface *S,
+Extrema_GlobOptFuncConicS::Extrema_GlobOptFuncConicS(const Handle(Adaptor3d_Surface) S,
const Standard_Real theUf, const Standard_Real theUl,
const Standard_Real theVf, const Standard_Real theVl)
: myS(S), myUf(theUf), myUl(theUl),
//function : Extrema_GlobOptFuncConicS
//purpose : Constructor
//=======================================================================
-Extrema_GlobOptFuncConicS::Extrema_GlobOptFuncConicS(const Adaptor3d_Surface *S)
+Extrema_GlobOptFuncConicS::Extrema_GlobOptFuncConicS(const Handle(Adaptor3d_Surface) S)
: myS(S), myUf(S->FirstUParameter()), myUl(S->LastUParameter()),
myVf(S->FirstVParameter()), myVl(S->LastVParameter())
{
//function : Extrema_GlobOptFuncConicS
//purpose : Constructor
//=======================================================================
-Extrema_GlobOptFuncConicS::Extrema_GlobOptFuncConicS(const Adaptor3d_Curve *C,
- const Adaptor3d_Surface *S)
+Extrema_GlobOptFuncConicS::Extrema_GlobOptFuncConicS(const Handle(Adaptor3d_Curve) C,
+ const Handle(Adaptor3d_Surface) S)
: myS(S), myUf(S->FirstUParameter()), myUl(S->LastUParameter()),
myVf(S->FirstVParameter()), myVl(S->LastVParameter())
{
//function : LoadConic
//purpose :
//=======================================================================
-void Extrema_GlobOptFuncConicS::LoadConic(const Adaptor3d_Curve *C,
+void Extrema_GlobOptFuncConicS::LoadConic(const Handle(Adaptor3d_Curve) C,
const Standard_Real theTf, const Standard_Real theTl)
{
myC = C;
public:
//! Curve and surface should exist during all the lifetime of Extrema_GlobOptFuncConicS.
- Standard_EXPORT Extrema_GlobOptFuncConicS(const Adaptor3d_Curve *C,
- const Adaptor3d_Surface *S);
+ Standard_EXPORT Extrema_GlobOptFuncConicS(const Handle(Adaptor3d_Curve) C,
+ const Handle(Adaptor3d_Surface) S);
- Standard_EXPORT Extrema_GlobOptFuncConicS(const Adaptor3d_Surface *S);
+ Standard_EXPORT Extrema_GlobOptFuncConicS(const Handle(Adaptor3d_Surface) S);
- Standard_EXPORT Extrema_GlobOptFuncConicS(const Adaptor3d_Surface *S,
+ Standard_EXPORT Extrema_GlobOptFuncConicS(const Handle(Adaptor3d_Surface) S,
const Standard_Real theUf,
const Standard_Real theUl,
const Standard_Real theVf,
const Standard_Real theVl);
- Standard_EXPORT void LoadConic(const Adaptor3d_Curve *S, const Standard_Real theTf, const Standard_Real theTl);
+ Standard_EXPORT void LoadConic(const Handle(Adaptor3d_Curve) S, const Standard_Real theTf, const Standard_Real theTl);
Standard_EXPORT virtual Standard_Integer NbVariables() const;
Standard_Real &F);
- const Adaptor3d_Curve *myC;
- const Adaptor3d_Surface *myS;
+ Handle(Adaptor3d_Curve) myC;
+ Handle(Adaptor3d_Surface) myS;
GeomAbs_CurveType myCType;
gp_Lin myLin;
gp_Circ myCirc;
//! The function F(u,v)=distance(C1(u),C2(v)) has an
//! extremun when gradient(f)=0. The algorithm searches
//! the zero near the close point.
- Standard_EXPORT Extrema_LocECC(const Adaptor3d_Curve& C1, const Adaptor3d_Curve& C2, const Standard_Real U0, const Standard_Real V0, const Standard_Real TolU, const Standard_Real TolV);
+ Standard_EXPORT Extrema_LocECC(const Handle(Adaptor3d_Curve)& C1, const Handle(Adaptor3d_Curve)& C2, const Standard_Real U0, const Standard_Real V0, const Standard_Real TolU, const Standard_Real TolV);
//! Returns True if the distance is found.
Standard_EXPORT Standard_Boolean IsDone() const;
//! The function F(u,v)=distance(C1(u),C2(v)) has an
//! extremun when gradient(f)=0. The algorithm searches
//! the zero near the close point.
- Standard_EXPORT Extrema_LocECC2d(const Adaptor2d_Curve2d& C1, const Adaptor2d_Curve2d& C2, const Standard_Real U0, const Standard_Real V0, const Standard_Real TolU, const Standard_Real TolV);
+ Standard_EXPORT Extrema_LocECC2d(const Handle(Adaptor2d_Curve2d)& C1, const Handle(Adaptor2d_Curve2d)& C2, const Standard_Real U0, const Standard_Real V0, const Standard_Real TolU, const Standard_Real TolV);
//! Returns True if the distance is found.
Standard_EXPORT Standard_Boolean IsDone() const;
#include <Extrema_SequenceOfPOnCurv2d.hxx>
-#define Curve1 Adaptor2d_Curve2d
+#define Curve1 Handle(Adaptor2d_Curve2d)
#define Curve1_hxx <Adaptor2d_Curve2d.hxx>
#define Tool1 Extrema_Curve2dTool
#define Tool1_hxx <Extrema_Curve2dTool.hxx>
-#define Curve2 Adaptor2d_Curve2d
+#define Curve2 Handle(Adaptor2d_Curve2d)
#define Curve2_hxx <Adaptor2d_Curve2d.hxx>
#define Tool2 Extrema_Curve2dTool
#define Tool2_hxx <Extrema_Curve2dTool.hxx>
#include <Extrema_SequenceOfPOnCurv.hxx>
-#define Curve1 Adaptor3d_Curve
+#define Curve1 Handle(Adaptor3d_Curve)
#define Curve1_hxx <Adaptor3d_Curve.hxx>
#define Tool1 Extrema_CurveTool
#define Tool1_hxx <Extrema_CurveTool.hxx>
-#define Curve2 Adaptor3d_Curve
+#define Curve2 Handle(Adaptor3d_Curve)
#define Curve2_hxx <Adaptor3d_Curve.hxx>
#define Tool2 Extrema_CurveTool
#define Tool2_hxx <Extrema_CurveTool.hxx>
//! TolU is used to decide to stop the iterations.
//! At the nth iteration, the criteria is:
//! abs(Un - Un-1) < TolU.
- Standard_EXPORT Extrema_LocEPCOfLocateExtPC(const gp_Pnt& P, const Adaptor3d_Curve& C, const Standard_Real U0, const Standard_Real TolU);
+ Standard_EXPORT Extrema_LocEPCOfLocateExtPC(const gp_Pnt& P, const Handle(Adaptor3d_Curve)& C, const Standard_Real U0, const Standard_Real TolU);
//! Calculates the distance with a close point.
//! The close point is defined by the parameter value
//! TolU is used to decide to stop the iterations.
//! At the nth iteration, the criteria is:
//! abs(Un - Un-1) < TolU.
- Standard_EXPORT Extrema_LocEPCOfLocateExtPC(const gp_Pnt& P, const Adaptor3d_Curve& C, const Standard_Real U0, const Standard_Real Umin, const Standard_Real Usup, const Standard_Real TolU);
+ Standard_EXPORT Extrema_LocEPCOfLocateExtPC(const gp_Pnt& P, const Handle(Adaptor3d_Curve)& C, const Standard_Real U0, const Standard_Real Umin, const Standard_Real Usup, const Standard_Real TolU);
//! sets the fields of the algorithm.
- Standard_EXPORT void Initialize (const Adaptor3d_Curve& C, const Standard_Real Umin, const Standard_Real Usup, const Standard_Real TolU);
+ Standard_EXPORT void Initialize (const Handle(Adaptor3d_Curve)& C, const Standard_Real Umin, const Standard_Real Usup, const Standard_Real TolU);
//! the algorithm is done with the point P.
//! An exception is raised if the fields have not
//! TolU is used to decide to stop the iterations.
//! At the nth iteration, the criteria is:
//! abs(Un - Un-1) < TolU.
- Standard_EXPORT Extrema_LocEPCOfLocateExtPC2d(const gp_Pnt2d& P, const Adaptor2d_Curve2d& C, const Standard_Real U0, const Standard_Real TolU);
+ Standard_EXPORT Extrema_LocEPCOfLocateExtPC2d(const gp_Pnt2d& P, const Handle(Adaptor2d_Curve2d)& C, const Standard_Real U0, const Standard_Real TolU);
//! Calculates the distance with a close point.
//! The close point is defined by the parameter value
//! TolU is used to decide to stop the iterations.
//! At the nth iteration, the criteria is:
//! abs(Un - Un-1) < TolU.
- Standard_EXPORT Extrema_LocEPCOfLocateExtPC2d(const gp_Pnt2d& P, const Adaptor2d_Curve2d& C, const Standard_Real U0, const Standard_Real Umin, const Standard_Real Usup, const Standard_Real TolU);
+ Standard_EXPORT Extrema_LocEPCOfLocateExtPC2d(const gp_Pnt2d& P, const Handle(Adaptor2d_Curve2d)& C, const Standard_Real U0, const Standard_Real Umin, const Standard_Real Usup, const Standard_Real TolU);
//! sets the fields of the algorithm.
- Standard_EXPORT void Initialize (const Adaptor2d_Curve2d& C, const Standard_Real Umin, const Standard_Real Usup, const Standard_Real TolU);
+ Standard_EXPORT void Initialize (const Handle(Adaptor2d_Curve2d)& C, const Standard_Real Umin, const Standard_Real Usup, const Standard_Real TolU);
//! the algorithm is done with the point P.
//! An exception is raised if the fields have not
#include <Extrema_SequenceOfPOnCurv2d.hxx>
-#define Curve Adaptor2d_Curve2d
+#define Curve Handle(Adaptor2d_Curve2d)
#define Curve_hxx <Adaptor2d_Curve2d.hxx>
#define Tool Extrema_Curve2dTool
#define Tool_hxx <Extrema_Curve2dTool.hxx>
#include <Extrema_SequenceOfPOnCurv.hxx>
-#define Curve Adaptor3d_Curve
+#define Curve Handle(Adaptor3d_Curve)
#define Curve_hxx <Adaptor3d_Curve.hxx>
#define Tool Extrema_CurveTool
#define Tool_hxx <Extrema_CurveTool.hxx>
#include <Precision.hxx>
#include <StdFail_NotDone.hxx>
-Extrema_LocateExtCC::Extrema_LocateExtCC (const Adaptor3d_Curve& C1,
- const Adaptor3d_Curve& C2,
+Extrema_LocateExtCC::Extrema_LocateExtCC (const Handle(Adaptor3d_Curve)& C1,
+ const Handle(Adaptor3d_Curve)& C2,
const Standard_Real U0,
const Standard_Real V0)
: mySqDist(RealLast())
{
- Standard_Real TolU = C1.Resolution(Precision::Confusion());
- Standard_Real TolV = C2.Resolution(Precision::Confusion());
+ Standard_Real TolU = C1->Resolution(Precision::Confusion());
+ Standard_Real TolV = C2->Resolution(Precision::Confusion());
Extrema_POnCurv P1, P2;
// Non implemente pour l instant: l appel a Extrema_ELCC.
- Extrema_LocECC Xtrem(C1, C2,
- U0, V0, TolU, TolV);
+ Extrema_LocECC Xtrem(C1, C2, U0, V0, TolU, TolV);
// Exploitation
myDone = Xtrem.IsDone();
//! The function F(u,v)=distance(C1(u),C2(v)) has an
//! extremun when gradient(f)=0. The algorithm searches
//! the zero near the close point.
- Standard_EXPORT Extrema_LocateExtCC(const Adaptor3d_Curve& C1, const Adaptor3d_Curve& C2, const Standard_Real U0, const Standard_Real V0);
+ Standard_EXPORT Extrema_LocateExtCC(const Handle(Adaptor3d_Curve)& C1, const Handle(Adaptor3d_Curve)& C2, const Standard_Real U0, const Standard_Real V0);
//! Returns True if the distance is found.
Standard_EXPORT Standard_Boolean IsDone() const;
//purpose :
//=======================================================================
-Extrema_LocateExtCC2d::Extrema_LocateExtCC2d (const Adaptor2d_Curve2d& C1,
- const Adaptor2d_Curve2d& C2,
+Extrema_LocateExtCC2d::Extrema_LocateExtCC2d (const Handle(Adaptor2d_Curve2d)& C1,
+ const Handle(Adaptor2d_Curve2d)& C2,
const Standard_Real U0,
const Standard_Real V0)
: mySqDist(RealLast())
//! The function F(u,v)=distance(C1(u),C2(v)) has an
//! extremun when gradient(f)=0. The algorithm searches
//! the zero near the close point.
- Standard_EXPORT Extrema_LocateExtCC2d(const Adaptor2d_Curve2d& C1, const Adaptor2d_Curve2d& C2, const Standard_Real U0, const Standard_Real V0);
+ Standard_EXPORT Extrema_LocateExtCC2d(const Handle(Adaptor2d_Curve2d)& C1, const Handle(Adaptor2d_Curve2d)& C2, const Standard_Real U0, const Standard_Real V0);
//! Returns True if the distance is found.
Standard_EXPORT Standard_Boolean IsDone() const;
//! TolF is used to decide to stop the iterations.
//! At the nth iteration, the criteria is:
//! abs(Un - Un-1) < TolF.
- Standard_EXPORT Extrema_LocateExtPC(const gp_Pnt& P, const Adaptor3d_Curve& C, const Standard_Real U0, const Standard_Real TolF);
+ Standard_EXPORT Extrema_LocateExtPC(const gp_Pnt& P, const Handle(Adaptor3d_Curve)& C, const Standard_Real U0, const Standard_Real TolF);
//! Calculates the distance with a close point.
//! The close point is defined by the parameter value
//! TolF is used to decide to stop the iterations.
//! At the nth iteration, the criteria is:
//! abs(Un - Un-1) < TolF.
- Standard_EXPORT Extrema_LocateExtPC(const gp_Pnt& P, const Adaptor3d_Curve& C, const Standard_Real U0, const Standard_Real Umin, const Standard_Real Usup, const Standard_Real TolF);
+ Standard_EXPORT Extrema_LocateExtPC(const gp_Pnt& P, const Handle(Adaptor3d_Curve)& C, const Standard_Real U0, const Standard_Real Umin, const Standard_Real Usup, const Standard_Real TolF);
//! sets the fields of the algorithm.
- Standard_EXPORT void Initialize (const Adaptor3d_Curve& C, const Standard_Real Umin, const Standard_Real Usup, const Standard_Real TolF);
+ Standard_EXPORT void Initialize (const Handle(Adaptor3d_Curve)& C, const Standard_Real Umin, const Standard_Real Usup, const Standard_Real TolF);
Standard_EXPORT void Perform (const gp_Pnt& P, const Standard_Real U0);
//! TolF is used to decide to stop the iterations.
//! At the nth iteration, the criteria is:
//! abs(Un - Un-1) < TolF.
- Standard_EXPORT Extrema_LocateExtPC2d(const gp_Pnt2d& P, const Adaptor2d_Curve2d& C, const Standard_Real U0, const Standard_Real TolF);
+ Standard_EXPORT Extrema_LocateExtPC2d(const gp_Pnt2d& P, const Handle(Adaptor2d_Curve2d)& C, const Standard_Real U0, const Standard_Real TolF);
//! Calculates the distance with a close point.
//! The close point is defined by the parameter value
//! TolF is used to decide to stop the iterations.
//! At the nth iteration, the criteria is:
//! abs(Un - Un-1) < TolF.
- Standard_EXPORT Extrema_LocateExtPC2d(const gp_Pnt2d& P, const Adaptor2d_Curve2d& C, const Standard_Real U0, const Standard_Real Umin, const Standard_Real Usup, const Standard_Real TolF);
+ Standard_EXPORT Extrema_LocateExtPC2d(const gp_Pnt2d& P, const Handle(Adaptor2d_Curve2d)& C, const Standard_Real U0, const Standard_Real Umin, const Standard_Real Usup, const Standard_Real TolF);
//! sets the fields of the algorithm.
- Standard_EXPORT void Initialize (const Adaptor2d_Curve2d& C, const Standard_Real Umin, const Standard_Real Usup, const Standard_Real TolF);
+ Standard_EXPORT void Initialize (const Handle(Adaptor2d_Curve2d)& C, const Standard_Real Umin, const Standard_Real Usup, const Standard_Real TolF);
Standard_EXPORT void Perform (const gp_Pnt2d& P, const Standard_Real U0);
#include <Extrema_PCLocFOfLocEPCOfLocateExtPC2d.hxx>
-#define TheCurve Adaptor2d_Curve2d
+#define TheCurve Handle(Adaptor2d_Curve2d)
#define TheCurve_hxx <Adaptor2d_Curve2d.hxx>
#define TheCurveTool Extrema_Curve2dTool
#define TheCurveTool_hxx <Extrema_Curve2dTool.hxx>
#include <Extrema_PCLocFOfLocEPCOfLocateExtPC.hxx>
-#define TheCurve Adaptor3d_Curve
+#define TheCurve Handle(Adaptor3d_Curve)
#define TheCurve_hxx <Adaptor3d_Curve.hxx>
#define TheCurveTool Extrema_CurveTool
#define TheCurveTool_hxx <Extrema_CurveTool.hxx>
Standard_EXPORT Extrema_PCFOfEPCOfELPCOfLocateExtPC();
- Standard_EXPORT Extrema_PCFOfEPCOfELPCOfLocateExtPC(const gp_Pnt& P, const Adaptor3d_Curve& C);
+ Standard_EXPORT Extrema_PCFOfEPCOfELPCOfLocateExtPC(const gp_Pnt& P, const Handle(Adaptor3d_Curve)& C);
//! sets the field mycurve of the function.
- Standard_EXPORT void Initialize (const Adaptor3d_Curve& C);
+ Standard_EXPORT void Initialize (const Handle(Adaptor3d_Curve)& C);
//! sets the field P of the function.
Standard_EXPORT void SetPoint (const gp_Pnt& P);
Standard_EXPORT Extrema_PCFOfEPCOfELPCOfLocateExtPC2d();
- Standard_EXPORT Extrema_PCFOfEPCOfELPCOfLocateExtPC2d(const gp_Pnt2d& P, const Adaptor2d_Curve2d& C);
+ Standard_EXPORT Extrema_PCFOfEPCOfELPCOfLocateExtPC2d(const gp_Pnt2d& P, const Handle(Adaptor2d_Curve2d)& C);
//! sets the field mycurve of the function.
- Standard_EXPORT void Initialize (const Adaptor2d_Curve2d& C);
+ Standard_EXPORT void Initialize (const Handle(Adaptor2d_Curve2d)& C);
//! sets the field P of the function.
Standard_EXPORT void SetPoint (const gp_Pnt2d& P);
#include <gp_Vec2d.hxx>
#include <Extrema_SequenceOfPOnCurv2d.hxx>
-#define Curve Adaptor2d_Curve2d
+#define Curve Handle(Adaptor2d_Curve2d)
#define Curve_hxx <Adaptor2d_Curve2d.hxx>
#define Tool Extrema_Curve2dTool
#define Tool_hxx <Extrema_Curve2dTool.hxx>
#include <gp_Vec.hxx>
#include <Extrema_SequenceOfPOnCurv.hxx>
-#define Curve Adaptor3d_Curve
+#define Curve Handle(Adaptor3d_Curve)
#define Curve_hxx <Adaptor3d_Curve.hxx>
#define Tool Extrema_CurveTool
#define Tool_hxx <Extrema_CurveTool.hxx>
Standard_EXPORT Extrema_PCFOfEPCOfExtPC();
- Standard_EXPORT Extrema_PCFOfEPCOfExtPC(const gp_Pnt& P, const Adaptor3d_Curve& C);
+ Standard_EXPORT Extrema_PCFOfEPCOfExtPC(const gp_Pnt& P, const Handle(Adaptor3d_Curve)& C);
//! sets the field mycurve of the function.
- Standard_EXPORT void Initialize (const Adaptor3d_Curve& C);
+ Standard_EXPORT void Initialize (const Handle(Adaptor3d_Curve)& C);
//! sets the field P of the function.
Standard_EXPORT void SetPoint (const gp_Pnt& P);
Standard_EXPORT Extrema_PCFOfEPCOfExtPC2d();
- Standard_EXPORT Extrema_PCFOfEPCOfExtPC2d(const gp_Pnt2d& P, const Adaptor2d_Curve2d& C);
+ Standard_EXPORT Extrema_PCFOfEPCOfExtPC2d(const gp_Pnt2d& P, const Handle(Adaptor2d_Curve2d)& C);
//! sets the field mycurve of the function.
- Standard_EXPORT void Initialize (const Adaptor2d_Curve2d& C);
+ Standard_EXPORT void Initialize (const Handle(Adaptor2d_Curve2d)& C);
//! sets the field P of the function.
Standard_EXPORT void SetPoint (const gp_Pnt2d& P);
#include <gp_Vec2d.hxx>
#include <Extrema_SequenceOfPOnCurv2d.hxx>
-#define Curve Adaptor2d_Curve2d
+#define Curve Handle(Adaptor2d_Curve2d)
#define Curve_hxx <Adaptor2d_Curve2d.hxx>
#define Tool Extrema_Curve2dTool
#define Tool_hxx <Extrema_Curve2dTool.hxx>
#include <gp_Vec.hxx>
#include <Extrema_SequenceOfPOnCurv.hxx>
-#define Curve Adaptor3d_Curve
+#define Curve Handle(Adaptor3d_Curve)
#define Curve_hxx <Adaptor3d_Curve.hxx>
#define Tool Extrema_CurveTool
#define Tool_hxx <Extrema_CurveTool.hxx>
Standard_EXPORT Extrema_PCLocFOfLocEPCOfLocateExtPC();
- Standard_EXPORT Extrema_PCLocFOfLocEPCOfLocateExtPC(const gp_Pnt& P, const Adaptor3d_Curve& C);
+ Standard_EXPORT Extrema_PCLocFOfLocEPCOfLocateExtPC(const gp_Pnt& P, const Handle(Adaptor3d_Curve)& C);
//! sets the field mycurve of the function.
- Standard_EXPORT void Initialize (const Adaptor3d_Curve& C);
+ Standard_EXPORT void Initialize (const Handle(Adaptor3d_Curve)& C);
//! sets the field P of the function.
Standard_EXPORT void SetPoint (const gp_Pnt& P);
Standard_EXPORT Extrema_PCLocFOfLocEPCOfLocateExtPC2d();
- Standard_EXPORT Extrema_PCLocFOfLocEPCOfLocateExtPC2d(const gp_Pnt2d& P, const Adaptor2d_Curve2d& C);
+ Standard_EXPORT Extrema_PCLocFOfLocEPCOfLocateExtPC2d(const gp_Pnt2d& P, const Handle(Adaptor2d_Curve2d)& C);
//! sets the field mycurve of the function.
- Standard_EXPORT void Initialize (const Adaptor2d_Curve2d& C);
+ Standard_EXPORT void Initialize (const Handle(Adaptor2d_Curve2d)& C);
//! sets the field P of the function.
Standard_EXPORT void SetPoint (const gp_Pnt2d& P);
#include <gp_Vec2d.hxx>
#include <Extrema_SequenceOfPOnCurv2d.hxx>
-#define Curve Adaptor2d_Curve2d
+#define Curve Handle(Adaptor2d_Curve2d)
#define Curve_hxx <Adaptor2d_Curve2d.hxx>
#define Tool Extrema_Curve2dTool
#define Tool_hxx <Extrema_Curve2dTool.hxx>
#include <gp_Vec.hxx>
#include <Extrema_SequenceOfPOnCurv.hxx>
-#define Curve Adaptor3d_Curve
+#define Curve Handle(Adaptor3d_Curve)
#define Curve_hxx <Adaptor3d_Curve.hxx>
#define Tool Extrema_CurveTool
#define Tool_hxx <Extrema_CurveTool.hxx>
gp_Pnt P; gp_Vec V;
Guide->D1(pelsp,P,V);
gp_Pln pln(P,V);
- Handle(BRepAdaptor_Curve) ed = new BRepAdaptor_Curve (Spine->CurrentElementarySpine(ind));
+ Handle(BRepAdaptor_Curve) ed = Handle(BRepAdaptor_Curve)::DownCast(Spine->CurrentElementarySpine(ind)->ShallowCopy());
return IntPlanEdge(ed,pln,ped,tol3d);
}
static GCPnts_AbscissaType computeType (const TheCurve& theC,
Standard_Real& theRatio)
{
- if (theC.NbIntervals (GeomAbs_CN) > 1)
+ if (theC->NbIntervals (GeomAbs_CN) > 1)
{
return GCPnts_AbsComposite;
}
- switch (theC.GetType())
+ switch (theC->GetType())
{
case GeomAbs_Line:
{
}
case GeomAbs_Circle:
{
- theRatio = theC.Circle().Radius();
+ theRatio = theC->Circle().Radius();
return GCPnts_LengthParametrized;
}
case GeomAbs_BezierCurve:
{
- Handle(typename GCPnts_TCurveTypes<TheCurve>::BezierCurve) aBz = theC.Bezier();
+ Handle(typename GCPnts_TCurveTypes<TheCurve>::BezierCurve) aBz = theC->Bezier();
if (aBz->NbPoles() == 2
&& !aBz->IsRational())
{
}
case GeomAbs_BSplineCurve:
{
- Handle(typename GCPnts_TCurveTypes<TheCurve>::BSplineCurve) aBs = theC.BSpline();
+ Handle(typename GCPnts_TCurveTypes<TheCurve>::BSplineCurve) aBs = theC->BSpline();
if (aBs->NbPoles() == 2
&& !aBs->IsRational())
{
}
case GCPnts_AbsComposite:
{
- const Standard_Integer aNbIntervals = theC.NbIntervals (GeomAbs_CN);
+ const Standard_Integer aNbIntervals = theC->NbIntervals (GeomAbs_CN);
TColStd_Array1OfReal aTI (1, aNbIntervals + 1);
- theC.Intervals (aTI, GeomAbs_CN);
+ theC->Intervals (aTI, GeomAbs_CN);
Standard_Real aL = 0.0, aSign = 1.0;
Standard_Integer anIndex = 1;
BSplCLib::Hunt (aTI, theU0, anIndex);
}
case GCPnts_AbsComposite:
{
- const Standard_Integer aNbIntervals = theC.NbIntervals (GeomAbs_CN);
+ const Standard_Integer aNbIntervals = theC->NbIntervals (GeomAbs_CN);
TColStd_Array1OfReal aTI (1, aNbIntervals + 1);
- theC.Intervals (aTI, GeomAbs_CN);
+ theC->Intervals (aTI, GeomAbs_CN);
Standard_Real aL = 0.0, aSign = 1.0;
Standard_Integer anIndex = 1;
BSplCLib::Hunt (aTI, theU0, anIndex);
}
// Push a little bit outside the limits (hairy !!!)
- const Standard_Boolean isNonPeriodic = !theC.IsPeriodic();
+ const Standard_Boolean isNonPeriodic = !theC->IsPeriodic();
theUi = theU0 + aSign * 0.1;
Standard_Real aU1 = theU0 + aSign * 0.2;
if (isNonPeriodic)
{
if (aSign > 0)
{
- theUi = Min (theUi, theC.LastParameter());
- aU1 = Min (aU1, theC.LastParameter());
+ theUi = Min (theUi, theC->LastParameter());
+ aU1 = Min (aU1, theC->LastParameter());
}
else
{
- theUi = Max (theUi, theC.FirstParameter());
- aU1 = Max (aU1, theC.FirstParameter());
+ theUi = Max (theUi, theC->FirstParameter());
+ aU1 = Max (aU1, theC->FirstParameter());
}
}
//function : Length
//purpose :
//=======================================================================
-Standard_Real GCPnts_AbscissaPoint::Length (const Adaptor3d_Curve& theC)
+Standard_Real GCPnts_AbscissaPoint::Length (const Handle(Adaptor3d_Curve)& theC)
{
- return GCPnts_AbscissaPoint::Length (theC, theC.FirstParameter(), theC.LastParameter());
+ return GCPnts_AbscissaPoint::Length (theC, theC->FirstParameter(), theC->LastParameter());
}
//=======================================================================
//function : Length
//purpose :
//=======================================================================
-Standard_Real GCPnts_AbscissaPoint::Length (const Adaptor2d_Curve2d& theC)
+Standard_Real GCPnts_AbscissaPoint::Length (const Handle(Adaptor2d_Curve2d)& theC)
{
- return GCPnts_AbscissaPoint::Length (theC, theC.FirstParameter(), theC.LastParameter());
+ return GCPnts_AbscissaPoint::Length (theC, theC->FirstParameter(), theC->LastParameter());
}
//=======================================================================
//function : Length
//purpose :
//=======================================================================
-Standard_Real GCPnts_AbscissaPoint::Length (const Adaptor3d_Curve& theC,
+Standard_Real GCPnts_AbscissaPoint::Length (const Handle(Adaptor3d_Curve)& theC,
const Standard_Real theTol)
{
- return GCPnts_AbscissaPoint::Length (theC, theC.FirstParameter(), theC.LastParameter(), theTol);
+ return GCPnts_AbscissaPoint::Length (theC, theC->FirstParameter(), theC->LastParameter(), theTol);
}
//=======================================================================
//function : Length
//purpose :
//=======================================================================
-Standard_Real GCPnts_AbscissaPoint::Length (const Adaptor2d_Curve2d& theC,
+Standard_Real GCPnts_AbscissaPoint::Length (const Handle(Adaptor2d_Curve2d)& theC,
const Standard_Real theTol)
{
- return GCPnts_AbscissaPoint::Length (theC, theC.FirstParameter(), theC.LastParameter(), theTol);
+ return GCPnts_AbscissaPoint::Length (theC, theC->FirstParameter(), theC->LastParameter(), theTol);
}
//=======================================================================
//function : Length
//purpose :
//=======================================================================
-Standard_Real GCPnts_AbscissaPoint::Length (const Adaptor3d_Curve& theC,
+Standard_Real GCPnts_AbscissaPoint::Length (const Handle(Adaptor3d_Curve)& theC,
const Standard_Real theU1, const Standard_Real theU2)
{
return length (theC, theU1, theU2, NULL);
//function : Length
//purpose :
//=======================================================================
-Standard_Real GCPnts_AbscissaPoint::Length (const Adaptor2d_Curve2d& theC,
+Standard_Real GCPnts_AbscissaPoint::Length (const Handle(Adaptor2d_Curve2d)& theC,
const Standard_Real theU1, const Standard_Real theU2)
{
return length (theC, theU1, theU2, NULL);
//function : Length
//purpose :
//=======================================================================
-Standard_Real GCPnts_AbscissaPoint::Length (const Adaptor3d_Curve& theC,
+Standard_Real GCPnts_AbscissaPoint::Length (const Handle(Adaptor3d_Curve)& theC,
const Standard_Real theU1, const Standard_Real theU2,
const Standard_Real theTol)
{
//function : Length
//purpose :
//=======================================================================
-Standard_Real GCPnts_AbscissaPoint::Length (const Adaptor2d_Curve2d& theC,
+Standard_Real GCPnts_AbscissaPoint::Length (const Handle(Adaptor2d_Curve2d)& theC,
const Standard_Real theU1, const Standard_Real theU2,
const Standard_Real theTol)
{
}
case GCPnts_AbsComposite:
{
- const Standard_Integer aNbIntervals = theC.NbIntervals (GeomAbs_CN);
+ const Standard_Integer aNbIntervals = theC->NbIntervals (GeomAbs_CN);
TColStd_Array1OfReal aTI (1, aNbIntervals + 1);
- theC.Intervals (aTI, GeomAbs_CN);
+ theC->Intervals (aTI, GeomAbs_CN);
const Standard_Real aUU1 = Min (theU1, theU2);
const Standard_Real aUU2 = Max (theU1, theU2);
Standard_Real aL = 0.0;
Standard_Real anAbscis = theAbscissa;
Standard_Real aUU0 = theU0;
- Standard_Real aUUi = theU0 + (anAbscis / aL) * (theC.LastParameter() - theC.FirstParameter());
+ Standard_Real aUUi = theU0 + (anAbscis / aL) * (theC->LastParameter() - theC->FirstParameter());
Compute (myComputer, theC, anAbscis, aUU0, aUUi,
- theC.Resolution (Precision::Confusion()));
+ theC->Resolution (Precision::Confusion()));
}
//=======================================================================
//function : GCPnts_AbscissaPoint
//purpose :
//=======================================================================
-GCPnts_AbscissaPoint::GCPnts_AbscissaPoint (const Adaptor3d_Curve& theC,
+GCPnts_AbscissaPoint::GCPnts_AbscissaPoint (const Handle(Adaptor3d_Curve)& theC,
const Standard_Real theAbscissa,
const Standard_Real theU0)
{
//function : GCPnts_AbscissaPoint
//purpose :
//=======================================================================
-GCPnts_AbscissaPoint::GCPnts_AbscissaPoint (const Adaptor2d_Curve2d& theC,
+GCPnts_AbscissaPoint::GCPnts_AbscissaPoint (const Handle(Adaptor2d_Curve2d)& theC,
const Standard_Real theAbscissa,
const Standard_Real theU0)
{
Standard_Real aUUi = 0.0;
if (aL >= Precision::Confusion())
{
- aUUi= theU0 + (anAbscis / aL) * (theC.LastParameter() - theC.FirstParameter());
+ aUUi= theU0 + (anAbscis / aL) * (theC->LastParameter() - theC->FirstParameter());
}
else
{
//purpose :
//=======================================================================
GCPnts_AbscissaPoint::GCPnts_AbscissaPoint (const Standard_Real theTol,
- const Adaptor3d_Curve& theC,
+ const Handle(Adaptor3d_Curve)& theC,
const Standard_Real theAbscissa,
const Standard_Real theU0)
{
//purpose :
//=======================================================================
GCPnts_AbscissaPoint::GCPnts_AbscissaPoint (const Standard_Real theTol,
- const Adaptor2d_Curve2d& theC,
+ const Handle(Adaptor2d_Curve2d)& theC,
const Standard_Real theAbscissa,
const Standard_Real theU0)
{
//function : GCPnts_AbscissaPoint
//purpose :
//=======================================================================
-GCPnts_AbscissaPoint::GCPnts_AbscissaPoint (const Adaptor3d_Curve& theC,
+GCPnts_AbscissaPoint::GCPnts_AbscissaPoint (const Handle(Adaptor3d_Curve)& theC,
const Standard_Real theAbscissa,
const Standard_Real theU0, const Standard_Real theUi)
{
Standard_Real anAbscis = theAbscissa, aUU0 = theU0, aUUi = theUi;
- Compute (myComputer, theC, anAbscis, aUU0, aUUi, theC.Resolution (Precision::Confusion()));
+ Compute (myComputer, theC, anAbscis, aUU0, aUUi, theC->Resolution (Precision::Confusion()));
}
//=======================================================================
//function : GCPnts_AbscissaPoint
//purpose :
//=======================================================================
-GCPnts_AbscissaPoint::GCPnts_AbscissaPoint (const Adaptor2d_Curve2d& theC,
+GCPnts_AbscissaPoint::GCPnts_AbscissaPoint (const Handle(Adaptor2d_Curve2d)& theC,
const Standard_Real theAbscissa,
const Standard_Real theU0, const Standard_Real theUi)
{
Standard_Real anAbscis = theAbscissa, aUU0 = theU0, aUUi = theUi;
- Compute (myComputer, theC, anAbscis, aUU0, aUUi, theC.Resolution (Precision::Confusion()));
+ Compute (myComputer, theC, anAbscis, aUU0, aUUi, theC->Resolution (Precision::Confusion()));
}
//=======================================================================
//function : GCPnts_AbscissaPoint
//purpose :
//=======================================================================
-GCPnts_AbscissaPoint::GCPnts_AbscissaPoint (const Adaptor3d_Curve& theC,
+GCPnts_AbscissaPoint::GCPnts_AbscissaPoint (const Handle(Adaptor3d_Curve)& theC,
const Standard_Real theAbscissa,
const Standard_Real theU0, const Standard_Real theUi,
const Standard_Real theTol)
//function : GCPnts_AbscissaPoint
//purpose :
//=======================================================================
-GCPnts_AbscissaPoint::GCPnts_AbscissaPoint (const Adaptor2d_Curve2d& theC,
+GCPnts_AbscissaPoint::GCPnts_AbscissaPoint (const Handle(Adaptor2d_Curve2d)& theC,
const Standard_Real theAbscissa,
const Standard_Real theU0, const Standard_Real theUi,
const Standard_Real theTol)
DEFINE_STANDARD_ALLOC
//! Computes the length of the 3D Curve.
- Standard_EXPORT static Standard_Real Length (const Adaptor3d_Curve& theC);
+ Standard_EXPORT static Standard_Real Length (const Handle(Adaptor3d_Curve)& theC);
//! Computes the length of the 2D Curve.
- Standard_EXPORT static Standard_Real Length (const Adaptor2d_Curve2d& theC);
+ Standard_EXPORT static Standard_Real Length (const Handle(Adaptor2d_Curve2d)& theC);
//! Computes the length of the 3D Curve with the given tolerance.
- Standard_EXPORT static Standard_Real Length (const Adaptor3d_Curve& theC,
+ Standard_EXPORT static Standard_Real Length (const Handle(Adaptor3d_Curve)& theC,
const Standard_Real theTol);
//! Computes the length of the 2D Curve with the given tolerance.
- Standard_EXPORT static Standard_Real Length (const Adaptor2d_Curve2d& theC,
+ Standard_EXPORT static Standard_Real Length (const Handle(Adaptor2d_Curve2d)& theC,
const Standard_Real theTol);
//! Computes the length of the 3D Curve.
- Standard_EXPORT static Standard_Real Length (const Adaptor3d_Curve& theC,
+ Standard_EXPORT static Standard_Real Length (const Handle(Adaptor3d_Curve)& theC,
const Standard_Real theU1, const Standard_Real theU2);
//! Computes the length of the 2D Curve.
- Standard_EXPORT static Standard_Real Length (const Adaptor2d_Curve2d& theC,
+ Standard_EXPORT static Standard_Real Length (const Handle(Adaptor2d_Curve2d)& theC,
const Standard_Real theU1, const Standard_Real theU2);
//! Computes the length of the 3D Curve with the given tolerance.
- Standard_EXPORT static Standard_Real Length (const Adaptor3d_Curve& theC,
+ Standard_EXPORT static Standard_Real Length (const Handle(Adaptor3d_Curve)& theC,
const Standard_Real theU1, const Standard_Real theU2,
const Standard_Real theTol);
//! Computes the length of the Curve with the given tolerance.
- Standard_EXPORT static Standard_Real Length (const Adaptor2d_Curve2d& theC,
+ Standard_EXPORT static Standard_Real Length (const Handle(Adaptor2d_Curve2d)& theC,
const Standard_Real theU1, const Standard_Real theU2,
const Standard_Real theTol);
//! The algorithm computes a point on a curve at the
//! distance theAbscissa from the point of parameter theU0.
- Standard_EXPORT GCPnts_AbscissaPoint (const Adaptor3d_Curve& theC,
+ Standard_EXPORT GCPnts_AbscissaPoint (const Handle(Adaptor3d_Curve)& theC,
const Standard_Real theAbscissa,
const Standard_Real theU0);
//! the distance theAbscissa from the point of parameter
//! theU0 with the given tolerance.
Standard_EXPORT GCPnts_AbscissaPoint (const Standard_Real theTol,
- const Adaptor3d_Curve& theC,
+ const Handle(Adaptor3d_Curve)& theC,
const Standard_Real theAbscissa,
const Standard_Real theU0);
//! the distance theAbscissa from the point of parameter
//! theU0 with the given tolerance.
Standard_EXPORT GCPnts_AbscissaPoint (const Standard_Real theTol,
- const Adaptor2d_Curve2d& theC,
+ const Handle(Adaptor2d_Curve2d)& theC,
const Standard_Real theAbscissa,
const Standard_Real theU0);
//! The algorithm computes a point on a curve at the
//! distance theAbscissa from the point of parameter theU0.
- Standard_EXPORT GCPnts_AbscissaPoint (const Adaptor2d_Curve2d& theC,
+ Standard_EXPORT GCPnts_AbscissaPoint (const Handle(Adaptor2d_Curve2d)& theC,
const Standard_Real theAbscissa,
const Standard_Real theU0);
//! distance theAbscissa from the point of parameter theU0.
//! theUi is the starting value used in the iterative process
//! which find the solution, it must be close to the final solution.
- Standard_EXPORT GCPnts_AbscissaPoint (const Adaptor3d_Curve& theC,
+ Standard_EXPORT GCPnts_AbscissaPoint (const Handle(Adaptor3d_Curve)& theC,
const Standard_Real theAbscissa,
const Standard_Real theU0, const Standard_Real theUi);
//! distance theAbscissa from the point of parameter theU0.
//! theUi is the starting value used in the iterative process
//! which find the solution, it must be closed to the final solution
- Standard_EXPORT GCPnts_AbscissaPoint (const Adaptor2d_Curve2d& theC,
+ Standard_EXPORT GCPnts_AbscissaPoint (const Handle(Adaptor2d_Curve2d)& theC,
const Standard_Real theAbscissa,
const Standard_Real theU0, const Standard_Real theUi);
//! distance theAbscissa from the point of parameter theU0.
//! theUi is the starting value used in the iterative process
//! which find the solution, it must be close to the final solution
- Standard_EXPORT GCPnts_AbscissaPoint (const Adaptor3d_Curve& theC,
+ Standard_EXPORT GCPnts_AbscissaPoint (const Handle(Adaptor3d_Curve)& theC,
const Standard_Real theAbscissa,
const Standard_Real theU0, const Standard_Real theUi,
const Standard_Real theTol);
//! distance theAbscissa from the point of parameter theU0.
//! theUi is the starting value used in the iterative process
//! which find the solution, it must be close to the final solution
- Standard_EXPORT GCPnts_AbscissaPoint (const Adaptor2d_Curve2d& theC,
+ Standard_EXPORT GCPnts_AbscissaPoint (const Handle(Adaptor2d_Curve2d)& theC,
const Standard_Real theAbscissa,
const Standard_Real theU0, const Standard_Real theUi,
const Standard_Real theTol);
//function : MaxCurvLinDist
//purpose :
//=======================================================================
-GCPnts_DistFunction::GCPnts_DistFunction(const Adaptor3d_Curve& theCurve,
+GCPnts_DistFunction::GCPnts_DistFunction(const Handle(Adaptor3d_Curve)& theCurve,
const Standard_Real U1, const Standard_Real U2)
: myCurve(theCurve),
myU1(U1), myU2(U2)
{
- gp_Pnt P1 = theCurve.Value(U1), P2 = theCurve.Value(U2);
+ gp_Pnt P1 = theCurve->Value(U1), P2 = theCurve->Value(U2);
if (P1.SquareDistance(P2) > gp::Resolution())
{
myLin = gp_Lin(P1, P2.XYZ() - P1.XYZ());
else
{
//For #28812
- theCurve.D0(U1 + .01*(U2-U1), P2);
+ theCurve->D0(U1 + .01*(U2-U1), P2);
myLin = gp_Lin(P1, P2.XYZ() - P1.XYZ());
}
}
if (X < myU1 || X > myU2)
return Standard_False;
//
- F = -myLin.SquareDistance(myCurve.Value(X));
+ F = -myLin.SquareDistance(myCurve->Value(X));
return Standard_True;
}
class GCPnts_DistFunction : public math_Function
{
public:
- Standard_EXPORT GCPnts_DistFunction(const Adaptor3d_Curve& theCurve,
+ Standard_EXPORT GCPnts_DistFunction(const Handle(Adaptor3d_Curve)& theCurve,
const Standard_Real U1, const Standard_Real U2);
//
Standard_EXPORT GCPnts_DistFunction(const GCPnts_DistFunction& theOther);
private:
GCPnts_DistFunction & operator = (const GCPnts_DistFunction & theOther);
- const Adaptor3d_Curve& myCurve;
+ const Handle(Adaptor3d_Curve)& myCurve;
gp_Lin myLin;
Standard_Real myU1;
Standard_Real myU2;
//function : GCPnts_DistFunction2d
//purpose :
//=======================================================================
-GCPnts_DistFunction2d::GCPnts_DistFunction2d(const Adaptor2d_Curve2d& theCurve,
+GCPnts_DistFunction2d::GCPnts_DistFunction2d(const Handle(Adaptor2d_Curve2d)& theCurve,
const Standard_Real U1, const Standard_Real U2)
: myCurve(theCurve),
myU1(U1), myU2(U2)
{
- gp_Pnt2d P2d1 = theCurve.Value(U1), P2d2 = theCurve.Value(U2);
+ gp_Pnt2d P2d1 = theCurve->Value(U1), P2d2 = theCurve->Value(U2);
if (P2d1.SquareDistance(P2d2) > gp::Resolution())
{
myLin = gp_Lin2d(P2d1, P2d2.XY() - P2d1.XY());
else
{
//For #28812
- theCurve.D0(U1 + .01*(U2 - U1), P2d2);
+ theCurve->D0(U1 + .01*(U2 - U1), P2d2);
myLin = gp_Lin2d(P2d1, P2d2.XY() - P2d1.XY());
}
if (X < myU1 || X > myU2)
return Standard_False;
//
- gp_Pnt2d aP2d = myCurve.Value(X);
+ gp_Pnt2d aP2d = myCurve->Value(X);
F = -myLin.SquareDistance(aP2d);
return Standard_True;
}
class GCPnts_DistFunction2d : public math_Function
{
public:
- Standard_EXPORT GCPnts_DistFunction2d(const Adaptor2d_Curve2d& theCurve,
+ Standard_EXPORT GCPnts_DistFunction2d(const Handle(Adaptor2d_Curve2d)& theCurve,
const Standard_Real U1, const Standard_Real U2);
//
Standard_EXPORT GCPnts_DistFunction2d(const GCPnts_DistFunction2d& theOther);
private:
GCPnts_DistFunction2d & operator = (const GCPnts_DistFunction2d & theOther);
- const Adaptor2d_Curve2d& myCurve;
+ const Handle(Adaptor2d_Curve2d)& myCurve;
gp_Lin2d myLin;
Standard_Real myU1;
Standard_Real myU2;
//function : GCPnts_QuasiUniformAbscissa
//purpose :
//=======================================================================
-GCPnts_QuasiUniformAbscissa::GCPnts_QuasiUniformAbscissa (const Adaptor3d_Curve& theC,
+GCPnts_QuasiUniformAbscissa::GCPnts_QuasiUniformAbscissa (const Handle(Adaptor3d_Curve)& theC,
const Standard_Integer theNbPoints)
: myDone (Standard_False),
myNbPoints (0)
//function : GCPnts_QuasiUniformAbscissa
//purpose :
//=======================================================================
-GCPnts_QuasiUniformAbscissa::GCPnts_QuasiUniformAbscissa (const Adaptor3d_Curve& theC,
+GCPnts_QuasiUniformAbscissa::GCPnts_QuasiUniformAbscissa (const Handle(Adaptor3d_Curve)& theC,
const Standard_Integer theNbPoints,
const Standard_Real theU1,
const Standard_Real theU2)
//function : GCPnts_QuasiUniformAbscissa
//purpose :
//=======================================================================
-GCPnts_QuasiUniformAbscissa::GCPnts_QuasiUniformAbscissa (const Adaptor2d_Curve2d& theC,
+GCPnts_QuasiUniformAbscissa::GCPnts_QuasiUniformAbscissa (const Handle(Adaptor2d_Curve2d)& theC,
const Standard_Integer theNbPoints)
: myDone (Standard_False),
myNbPoints (0)
//function : GCPnts_QuasiUniformAbscissa
//purpose :
//=======================================================================
-GCPnts_QuasiUniformAbscissa::GCPnts_QuasiUniformAbscissa (const Adaptor2d_Curve2d& theC,
+GCPnts_QuasiUniformAbscissa::GCPnts_QuasiUniformAbscissa (const Handle(Adaptor2d_Curve2d)& theC,
const Standard_Integer theNbPoints,
const Standard_Real theU1,
const Standard_Real theU2)
//function : Initialize
//purpose :
//=======================================================================
-void GCPnts_QuasiUniformAbscissa::Initialize (const Adaptor3d_Curve& theC,
+void GCPnts_QuasiUniformAbscissa::Initialize (const Handle(Adaptor3d_Curve)& theC,
const Standard_Integer theNbPoints)
{
- Initialize (theC, theNbPoints, theC.FirstParameter(), theC.LastParameter());
+ Initialize (theC, theNbPoints, theC->FirstParameter(), theC->LastParameter());
}
//=======================================================================
//function : Initialize
//purpose :
//=======================================================================
-void GCPnts_QuasiUniformAbscissa::Initialize (const Adaptor2d_Curve2d& theC,
+void GCPnts_QuasiUniformAbscissa::Initialize (const Handle(Adaptor2d_Curve2d)& theC,
const Standard_Integer theNbPoints)
{
- Initialize (theC, theNbPoints, theC.FirstParameter(), theC.LastParameter());
+ Initialize (theC, theNbPoints, theC->FirstParameter(), theC->LastParameter());
}
//=======================================================================
//function : Initialize
//purpose :
//=======================================================================
-void GCPnts_QuasiUniformAbscissa::Initialize (const Adaptor3d_Curve& theC,
+void GCPnts_QuasiUniformAbscissa::Initialize (const Handle(Adaptor3d_Curve)& theC,
const Standard_Integer theNbPoints,
const Standard_Real theU1,
const Standard_Real theU2)
//function : Initialize
//purpose :
//=======================================================================
-void GCPnts_QuasiUniformAbscissa::Initialize (const Adaptor2d_Curve2d& theC,
+void GCPnts_QuasiUniformAbscissa::Initialize (const Handle(Adaptor2d_Curve2d)& theC,
const Standard_Integer theNbPoints,
const Standard_Real theU1,
const Standard_Real theU2)
const Standard_Real theU1,
const Standard_Real theU2)
{
- if (theC.GetType() != GeomAbs_BezierCurve
- && theC.GetType() != GeomAbs_BSplineCurve)
+ if (theC->GetType() != GeomAbs_BezierCurve
+ && theC->GetType() != GeomAbs_BSplineCurve)
{
GCPnts_UniformAbscissa aUA (theC, theNbPoints, theU1, theU2);
myDone = aUA.IsDone();
TColgp_Array1OfPnt2d aLP (1, 2 * theNbPoints); // table Length <-> Param
typename GCPnts_TCurveTypes<TheCurve>::Point aP1, aP2;
- aP1 = theC.Value (theU1);
+ aP1 = theC->Value (theU1);
// On additionne toutes les distances
for (Standard_Integer i = 0; i < 2 * theNbPoints; ++i)
{
- aP2 = theC.Value (theU1 + i * dU);
+ aP2 = theC->Value (theU1 + i * dU);
const Standard_Real aDist = aP1.Distance (aP2);
aLength += aDist;
aLP(i+1) = gp_Pnt2d (aLength, theU1 + (i * dU));
//! Computes a uniform abscissa distribution of points
//! - on the curve where Abscissa is the curvilinear distance between
//! two consecutive points of the distribution.
- Standard_EXPORT GCPnts_QuasiUniformAbscissa (const Adaptor3d_Curve& theC,
+ Standard_EXPORT GCPnts_QuasiUniformAbscissa (const Handle(Adaptor3d_Curve)& theC,
const Standard_Integer theNbPoints);
//! Computes a uniform abscissa distribution of points
//! @param theNbPoints [in] defines the number of desired points
//! @param theU1 [in] first parameter on curve
//! @param theU2 [in] last parameter on curve
- Standard_EXPORT GCPnts_QuasiUniformAbscissa (const Adaptor3d_Curve& theC,
+ Standard_EXPORT GCPnts_QuasiUniformAbscissa (const Handle(Adaptor3d_Curve)& theC,
const Standard_Integer theNbPoints,
const Standard_Real theU1, const Standard_Real theU2);
//! Initialize the algorithms with 3D curve and target number of points.
//! @param theC [in] input 3D curve
//! @param theNbPoints [in] defines the number of desired points
- Standard_EXPORT void Initialize (const Adaptor3d_Curve& theC,
+ Standard_EXPORT void Initialize (const Handle(Adaptor3d_Curve)& theC,
const Standard_Integer theNbPoints);
//! Initialize the algorithms with 3D curve, target number of points and curve parameter range.
//! @param theNbPoints [in] defines the number of desired points
//! @param theU1 [in] first parameter on curve
//! @param theU2 [in] last parameter on curve
- Standard_EXPORT void Initialize (const Adaptor3d_Curve& theC,
+ Standard_EXPORT void Initialize (const Handle(Adaptor3d_Curve)& theC,
const Standard_Integer theNbPoints,
const Standard_Real theU1, const Standard_Real theU2);
//! Computes a uniform abscissa distribution of points on the 2D curve.
//! @param theC [in] input 2D curve
//! @param theNbPoints [in] defines the number of desired points
- Standard_EXPORT GCPnts_QuasiUniformAbscissa (const Adaptor2d_Curve2d& theC,
+ Standard_EXPORT GCPnts_QuasiUniformAbscissa (const Handle(Adaptor2d_Curve2d)& theC,
const Standard_Integer theNbPoints);
//! Computes a Uniform abscissa distribution of points on a part of the 2D curve.
//! @param theNbPoints [in] defines the number of desired points
//! @param theU1 [in] first parameter on curve
//! @param theU2 [in] last parameter on curve
- Standard_EXPORT GCPnts_QuasiUniformAbscissa (const Adaptor2d_Curve2d& theC,
+ Standard_EXPORT GCPnts_QuasiUniformAbscissa (const Handle(Adaptor2d_Curve2d)& theC,
const Standard_Integer theNbPoints,
const Standard_Real theU1, const Standard_Real theU2);
//! Initialize the algorithms with 2D curve and target number of points.
//! @param theC [in] input 2D curve
//! @param theNbPoints [in] defines the number of desired points
- Standard_EXPORT void Initialize (const Adaptor2d_Curve2d& theC,
+ Standard_EXPORT void Initialize (const Handle(Adaptor2d_Curve2d)& theC,
const Standard_Integer theNbPoints);
//! Initialize the algorithms with 2D curve, target number of points and curve parameter range.
//! @param theNbPoints [in] defines the number of desired points
//! @param theU1 [in] first parameter on curve
//! @param theU2 [in] last parameter on curve
- Standard_EXPORT void Initialize (const Adaptor2d_Curve2d& theC,
+ Standard_EXPORT void Initialize (const Handle(Adaptor2d_Curve2d)& theC,
const Standard_Integer theNbPoints,
const Standard_Real theU1, const Standard_Real theU2);
static const Standard_Integer MyMaxQuasiFleshe = 2000;
// mask the return of a Adaptor2d_Curve2d as a gp_Pnt
-static gp_Pnt Value (const Adaptor3d_Curve& theC,
+static gp_Pnt Value (const Handle(Adaptor3d_Curve)& theC,
const Standard_Real theParameter)
{
- return theC.Value (theParameter);
+ return theC->Value (theParameter);
}
-static gp_Pnt Value (const Adaptor2d_Curve2d& theC,
+static gp_Pnt Value (const Handle(Adaptor2d_Curve2d)& theC,
const Standard_Real theParameter)
{
gp_Pnt aPoint;
- gp_Pnt2d a2dPoint (theC.Value (theParameter));
+ gp_Pnt2d a2dPoint (theC->Value (theParameter));
aPoint.SetCoord (a2dPoint.X(), a2dPoint.Y(), 0.0);
return aPoint;
}
-static void D1 (const Adaptor3d_Curve& theC,
+static void D1 (const Handle(Adaptor3d_Curve)& theC,
const Standard_Real theParameter,
gp_Pnt& theP,
gp_Vec& theV)
{
- theC.D1 (theParameter, theP, theV);
+ theC->D1 (theParameter, theP, theV);
}
-static void D1 (const Adaptor2d_Curve2d& theC,
+static void D1 (const Handle(Adaptor2d_Curve2d)& theC,
const Standard_Real theParameter,
gp_Pnt& theP,
gp_Vec& theV)
{
gp_Pnt2d a2dPoint;
gp_Vec2d a2dVec;
- theC.D1 (theParameter, a2dPoint, a2dVec);
+ theC->D1 (theParameter, a2dPoint, a2dVec);
theP.SetCoord (a2dPoint.X(), a2dPoint.Y(), 0.0);
theV.SetCoord (a2dVec.X(), a2dVec.Y(), 0.0);
}
const Standard_Real theU1,
const Standard_Real theU2)
{
- Standard_Real anAngle = Max (1.0 - (theDeflection / theC.Circle().Radius()), 0.0);
+ Standard_Real anAngle = Max (1.0 - (theDeflection / theC->Circle().Radius()), 0.0);
anAngle = 2.0 * ACos (anAngle);
Standard_Integer aNbPoints = (Standard_Integer )((theU2 - theU1) / anAngle);
aNbPoints += 2;
template<class TheCurve>
static GCPnts_DeflectionType GetDefType (const TheCurve& theC)
{
- if (theC.NbIntervals (GeomAbs_C1) > 1)
+ if (theC->NbIntervals (GeomAbs_C1) > 1)
{
return GCPnts_DefComposite;
}
// pour forcer les decoupages aux cassures.
// G1 devrait marcher, mais donne des exceptions...
- switch (theC.GetType())
+ switch (theC->GetType())
{
case GeomAbs_Line: return GCPnts_Linear;
case GeomAbs_Circle: return GCPnts_Circular;
case GeomAbs_BSplineCurve:
{
- Handle(typename GCPnts_TCurveTypes<TheCurve>::BSplineCurve) aBS = theC.BSpline();
+ Handle(typename GCPnts_TCurveTypes<TheCurve>::BSplineCurve) aBS = theC->BSpline();
return (aBS->NbPoles() == 2) ? GCPnts_Linear : GCPnts_Curved;
}
case GeomAbs_BezierCurve:
{
- Handle(typename GCPnts_TCurveTypes<TheCurve>::BezierCurve) aBZ = theC.Bezier();
+ Handle(typename GCPnts_TCurveTypes<TheCurve>::BezierCurve) aBZ = theC->Bezier();
return (aBZ->NbPoles() == 2) ? GCPnts_Linear : GCPnts_Curved;
}
default: return GCPnts_Curved;
//
// coherence avec Intervals
//
- const Standard_Integer aNbIntervals = theC.NbIntervals (GeomAbs_C2);
+ const Standard_Integer aNbIntervals = theC->NbIntervals (GeomAbs_C2);
Standard_Integer aPIndex = 0;
TColStd_Array1OfReal aTI (1, aNbIntervals + 1);
- theC.Intervals (aTI, GeomAbs_C2);
+ theC->Intervals (aTI, GeomAbs_C2);
BSplCLib::Hunt (aTI, theU1, aPIndex);
// iterate by continuous segments
//function : GCPnts_QuasiUniformDeflection
//purpose :
//=======================================================================
-GCPnts_QuasiUniformDeflection::GCPnts_QuasiUniformDeflection (const Adaptor3d_Curve& theC,
+GCPnts_QuasiUniformDeflection::GCPnts_QuasiUniformDeflection (const Handle(Adaptor3d_Curve)& theC,
const Standard_Real theDeflection,
const Standard_Real theU1, const Standard_Real theU2,
const GeomAbs_Shape theContinuity)
//function : GCPnts_QuasiUniformDeflection
//purpose :
//=======================================================================
-GCPnts_QuasiUniformDeflection::GCPnts_QuasiUniformDeflection (const Adaptor2d_Curve2d& theC,
+GCPnts_QuasiUniformDeflection::GCPnts_QuasiUniformDeflection (const Handle(Adaptor2d_Curve2d)& theC,
const Standard_Real theDeflection,
const Standard_Real theU1, const Standard_Real theU2,
const GeomAbs_Shape theContinuity)
//function : GCPnts_QuasiUniformDeflection
//purpose :
//=======================================================================
-GCPnts_QuasiUniformDeflection::GCPnts_QuasiUniformDeflection (const Adaptor3d_Curve& theC,
+GCPnts_QuasiUniformDeflection::GCPnts_QuasiUniformDeflection (const Handle(Adaptor3d_Curve)& theC,
const Standard_Real theDeflection,
const GeomAbs_Shape theContinuity)
: myDone (Standard_False),
//function : GCPnts_QuasiUniformDeflection
//purpose :
//=======================================================================
-GCPnts_QuasiUniformDeflection::GCPnts_QuasiUniformDeflection (const Adaptor2d_Curve2d& theC,
+GCPnts_QuasiUniformDeflection::GCPnts_QuasiUniformDeflection (const Handle(Adaptor2d_Curve2d)& theC,
const Standard_Real theDeflection,
const GeomAbs_Shape theContinuity)
: myDone (Standard_False),
//function : Initialize
//purpose :
//=======================================================================
-void GCPnts_QuasiUniformDeflection::Initialize (const Adaptor3d_Curve& theC,
+void GCPnts_QuasiUniformDeflection::Initialize (const Handle(Adaptor3d_Curve)& theC,
const Standard_Real theDeflection,
const GeomAbs_Shape theContinuity)
{
- Initialize (theC, theDeflection, theC.FirstParameter(), theC.LastParameter(), theContinuity);
+ Initialize (theC, theDeflection, theC->FirstParameter(), theC->LastParameter(), theContinuity);
}
//=======================================================================
//function : Initialize
//purpose :
//=======================================================================
-void GCPnts_QuasiUniformDeflection::Initialize (const Adaptor2d_Curve2d& theC,
+void GCPnts_QuasiUniformDeflection::Initialize (const Handle(Adaptor2d_Curve2d)& theC,
const Standard_Real theDeflection,
const GeomAbs_Shape theContinuity)
{
- Initialize (theC, theDeflection, theC.FirstParameter(), theC.LastParameter(), theContinuity);
+ Initialize (theC, theDeflection, theC->FirstParameter(), theC->LastParameter(), theContinuity);
}
//=======================================================================
//function : Initialize
//purpose :
//=======================================================================
-void GCPnts_QuasiUniformDeflection::Initialize (const Adaptor3d_Curve& theC,
+void GCPnts_QuasiUniformDeflection::Initialize (const Handle(Adaptor3d_Curve)& theC,
const Standard_Real theDeflection,
const Standard_Real theU1, const Standard_Real theU2,
const GeomAbs_Shape theContinuity)
//function : Initialize
//purpose :
//=======================================================================
-void GCPnts_QuasiUniformDeflection::Initialize (const Adaptor2d_Curve2d& theC,
+void GCPnts_QuasiUniformDeflection::Initialize (const Handle(Adaptor2d_Curve2d)& theC,
const Standard_Real theDeflection,
const Standard_Real theU1, const Standard_Real theU2,
const GeomAbs_Shape theContinuity)
myParams.Clear();
myPoints.Clear();
- const Standard_Real anEPSILON = Min (theC.Resolution (Precision::Confusion()), 1.e50);
+ const Standard_Real anEPSILON = Min (theC->Resolution (Precision::Confusion()), 1.e50);
const GCPnts_DeflectionType aType = GetDefType (theC);
const Standard_Real aU1 = Min (theU1, theU2);
const Standard_Real aU2 = Max (theU1, theU2);
if (aType == GCPnts_Curved
|| aType == GCPnts_DefComposite)
{
- if (theC.GetType() == GeomAbs_BSplineCurve
- || theC.GetType() == GeomAbs_BezierCurve)
+ if (theC->GetType() == GeomAbs_BSplineCurve
+ || theC->GetType() == GeomAbs_BezierCurve)
{
- const Standard_Real aMaxPar = Max (Abs (theC.FirstParameter()), Abs (theC.LastParameter()));
+ const Standard_Real aMaxPar = Max (Abs (theC->FirstParameter()), Abs (theC->LastParameter()));
if (anEPSILON < Epsilon (aMaxPar))
{
return;
Standard_EXPORT GCPnts_QuasiUniformDeflection();
//! Computes a QuasiUniform Deflection distribution of points on the Curve.
- Standard_EXPORT GCPnts_QuasiUniformDeflection (const Adaptor3d_Curve& theC,
+ Standard_EXPORT GCPnts_QuasiUniformDeflection (const Handle(Adaptor3d_Curve)& theC,
const Standard_Real theDeflection,
const GeomAbs_Shape theContinuity = GeomAbs_C1);
//! Computes a QuasiUniform Deflection distribution of points on the Curve.
- Standard_EXPORT GCPnts_QuasiUniformDeflection (const Adaptor2d_Curve2d& theC,
+ Standard_EXPORT GCPnts_QuasiUniformDeflection (const Handle(Adaptor2d_Curve2d)& theC,
const Standard_Real theDeflection,
const GeomAbs_Shape theContinuity = GeomAbs_C1);
//! Computes a QuasiUniform Deflection distribution of points on a part of the Curve.
- Standard_EXPORT GCPnts_QuasiUniformDeflection (const Adaptor3d_Curve& theC,
+ Standard_EXPORT GCPnts_QuasiUniformDeflection (const Handle(Adaptor3d_Curve)& theC,
const Standard_Real theDeflection,
const Standard_Real theU1, const Standard_Real theU2,
const GeomAbs_Shape theContinuity = GeomAbs_C1);
//! the package Geom2d (in the case of an Adaptor2d_Curve2d curve)
//! or a 3D curve from the package Geom (in the case of an Adaptor3d_Curve curve),
//! - and those required on the curve by the computation algorithm.
- Standard_EXPORT GCPnts_QuasiUniformDeflection (const Adaptor2d_Curve2d& theC,
+ Standard_EXPORT GCPnts_QuasiUniformDeflection (const Handle(Adaptor2d_Curve2d)& theC,
const Standard_Real theDeflection,
const Standard_Real theU1, const Standard_Real theU2,
const GeomAbs_Shape theContinuity = GeomAbs_C1);
//! Initialize the algorithms with 3D curve and deflection.
- Standard_EXPORT void Initialize (const Adaptor3d_Curve& theC,
+ Standard_EXPORT void Initialize (const Handle(Adaptor3d_Curve)& theC,
const Standard_Real theDeflection,
const GeomAbs_Shape theContinuity = GeomAbs_C1);
//! Initialize the algorithms with 2D curve and deflection.
- Standard_EXPORT void Initialize (const Adaptor2d_Curve2d& theC,
+ Standard_EXPORT void Initialize (const Handle(Adaptor2d_Curve2d)& theC,
const Standard_Real theDeflection,
const GeomAbs_Shape theContinuity = GeomAbs_C1);
//! Initialize the algorithms with 3D curve, deflection and parameter range.
- Standard_EXPORT void Initialize (const Adaptor3d_Curve& theC,
+ Standard_EXPORT void Initialize (const Handle(Adaptor3d_Curve)& theC,
const Standard_Real theDeflection,
const Standard_Real theU1, const Standard_Real theU2,
const GeomAbs_Shape theContinuity = GeomAbs_C1);
//! the package Geom2d (in the case of an Adaptor2d_Curve2d curve)
//! or a 3D curve from the package Geom (in the case of an Adaptor3d_Curve curve),
//! and those required on the curve by the computation algorithm.
- Standard_EXPORT void Initialize (const Adaptor2d_Curve2d& theC,
+ Standard_EXPORT void Initialize (const Handle(Adaptor2d_Curve2d)& theC,
const Standard_Real theDeflection,
const Standard_Real theU1, const Standard_Real theU2,
const GeomAbs_Shape theContinuity = GeomAbs_C1);
template<class TheCurve> struct GCPnts_TCurveTypes {};
//! Auxiliary tool to resolve 3D curve classes.
-template<> struct GCPnts_TCurveTypes<Adaptor3d_Curve>
+template<> struct GCPnts_TCurveTypes<Handle(Adaptor3d_Curve)>
{
typedef gp_Pnt Point;
typedef Geom_BezierCurve BezierCurve;
};
//! Auxiliary tool to resolve 2D curve classes.
-template<> struct GCPnts_TCurveTypes<Adaptor2d_Curve2d>
+template<> struct GCPnts_TCurveTypes<Handle(Adaptor2d_Curve2d)>
{
typedef gp_Pnt2d Point;
typedef Geom2d_BezierCurve BezierCurve;
{
static const Standard_Real Us3 = 0.3333333333333333333333333333;
- inline static void D0 (const Adaptor3d_Curve& C, const Standard_Real U, gp_Pnt& P)
+ inline static void D0 (const Handle(Adaptor3d_Curve)& C, const Standard_Real U, gp_Pnt& P)
{
- C.D0 (U, P);
+ C->D0 (U, P);
}
- inline static void D2 (const Adaptor3d_Curve& C, const Standard_Real U,
+ inline static void D2 (const Handle(Adaptor3d_Curve)& C, const Standard_Real U,
gp_Pnt& P, gp_Vec& V1, gp_Vec& V2)
{
- C.D2 (U, P, V1, V2);
+ C->D2 (U, P, V1, V2);
}
- static void D0 (const Adaptor2d_Curve2d& C, const Standard_Real U, gp_Pnt& PP)
+ static void D0 (const Handle(Adaptor2d_Curve2d)& C, const Standard_Real U, gp_Pnt& PP)
{
Standard_Real X, Y;
gp_Pnt2d P;
- C.D0 (U, P);
+ C->D0 (U, P);
P.Coord (X, Y);
PP.SetCoord (X, Y, 0.0);
}
- static void D2 (const Adaptor2d_Curve2d& C, const Standard_Real U,
+ static void D2 (const Handle(Adaptor2d_Curve2d)& C, const Standard_Real U,
gp_Pnt& PP, gp_Vec& VV1, gp_Vec& VV2)
{
Standard_Real X, Y;
gp_Pnt2d P;
gp_Vec2d V1,V2;
- C.D2 (U, P, V1, V2);
+ C->D2 (U, P, V1, V2);
P.Coord (X, Y);
PP.SetCoord (X, Y, 0.0);
V1.Coord (X, Y);
//function : GCPnts_TangentialDeflection
//purpose :
//=======================================================================
-GCPnts_TangentialDeflection::GCPnts_TangentialDeflection (const Adaptor3d_Curve& theC,
+GCPnts_TangentialDeflection::GCPnts_TangentialDeflection (const Handle(Adaptor3d_Curve)& theC,
const Standard_Real theAngularDeflection, const Standard_Real theCurvatureDeflection,
const Standard_Integer theMinimumOfPoints,
const Standard_Real theUTol,
//function : GCPnts_TangentialDeflection
//purpose :
//=======================================================================
-GCPnts_TangentialDeflection::GCPnts_TangentialDeflection (const Adaptor3d_Curve& theC,
+GCPnts_TangentialDeflection::GCPnts_TangentialDeflection (const Handle(Adaptor3d_Curve)& theC,
const Standard_Real theFirstParameter, const Standard_Real theLastParameter,
const Standard_Real theAngularDeflection, const Standard_Real theCurvatureDeflection,
const Standard_Integer theMinimumOfPoints,
//function : GCPnts_TangentialDeflection
//purpose :
//=======================================================================
-GCPnts_TangentialDeflection::GCPnts_TangentialDeflection (const Adaptor2d_Curve2d& theC,
+GCPnts_TangentialDeflection::GCPnts_TangentialDeflection (const Handle(Adaptor2d_Curve2d)& theC,
const Standard_Real theAngularDeflection, const Standard_Real theCurvatureDeflection,
const Standard_Integer theMinimumOfPoints,
const Standard_Real theUTol,
//function : GCPnts_TangentialDeflection
//purpose :
//=======================================================================
-GCPnts_TangentialDeflection::GCPnts_TangentialDeflection (const Adaptor2d_Curve2d& theC,
+GCPnts_TangentialDeflection::GCPnts_TangentialDeflection (const Handle(Adaptor2d_Curve2d)& theC,
const Standard_Real theFirstParameter, const Standard_Real theLastParameter,
const Standard_Real theAngularDeflection, const Standard_Real theCurvatureDeflection,
const Standard_Integer theMinimumOfPoints,
//function : Initialize
//purpose :
//=======================================================================
-void GCPnts_TangentialDeflection::Initialize (const Adaptor3d_Curve& theC,
+void GCPnts_TangentialDeflection::Initialize (const Handle(Adaptor3d_Curve)& theC,
const Standard_Real theAngularDeflection, const Standard_Real theCurvatureDeflection,
const Standard_Integer theMinimumOfPoints,
const Standard_Real theUTol,
const Standard_Real theMinLen)
{
- Initialize (theC, theC.FirstParameter(), theC.LastParameter(),
+ Initialize (theC, theC->FirstParameter(), theC->LastParameter(),
theAngularDeflection, theCurvatureDeflection,
theMinimumOfPoints,
theUTol, theMinLen);
//function : Initialize
//purpose :
//=======================================================================
-void GCPnts_TangentialDeflection::Initialize (const Adaptor2d_Curve2d& theC,
+void GCPnts_TangentialDeflection::Initialize (const Handle(Adaptor2d_Curve2d)& theC,
const Standard_Real theAngularDeflection, const Standard_Real theCurvatureDeflection,
const Standard_Integer theMinimumOfPoints,
const Standard_Real theUTol,
const Standard_Real theMinLen)
{
- Initialize (theC, theC.FirstParameter(), theC.LastParameter(),
+ Initialize (theC, theC->FirstParameter(), theC->LastParameter(),
theAngularDeflection, theCurvatureDeflection,
theMinimumOfPoints,
theUTol, theMinLen);
//function : Initialize
//purpose :
//=======================================================================
-void GCPnts_TangentialDeflection::Initialize (const Adaptor3d_Curve& theC,
+void GCPnts_TangentialDeflection::Initialize (const Handle(Adaptor3d_Curve)& theC,
const Standard_Real theFirstParameter, const Standard_Real theLastParameter,
const Standard_Real theAngularDeflection, const Standard_Real theCurvatureDeflection,
const Standard_Integer theMinimumOfPoints,
//function : Initialize
//purpose :
//=======================================================================
-void GCPnts_TangentialDeflection::Initialize (const Adaptor2d_Curve2d& theC,
+void GCPnts_TangentialDeflection::Initialize (const Handle(Adaptor2d_Curve2d)& theC,
const Standard_Real theFirstParameter, const Standard_Real theLastParameter,
const Standard_Real theAngularDeflection, const Standard_Real theCurvatureDeflection,
const Standard_Integer theMinimumOfPoints,
void GCPnts_TangentialDeflection::PerformCircular (const TheCurve& theC)
{
// akm 8/01/02 : check the radius before divide by it
- Standard_Real dfR = theC.Circle().Radius();
+ Standard_Real dfR = theC->Circle().Radius();
Standard_Real Du = GCPnts_TangentialDeflection::ArcAngularStep (dfR, myCurvatureDeflection, myAngularDeflection, myMinLen);
const Standard_Real aDiff = myLastU - myFirstu;
myMinNbPnts = Max (theMinimumOfPoints, 2);
myMinLen = Max (theMinLen, Precision::Confusion());
- switch (theC.GetType())
+ switch (theC->GetType())
{
case GeomAbs_Line:
{
}
case GeomAbs_BSplineCurve:
{
- Handle(typename GCPnts_TCurveTypes<TheCurve>::BSplineCurve) aBS = theC.BSpline();
+ Handle(typename GCPnts_TCurveTypes<TheCurve>::BSplineCurve) aBS = theC->BSpline();
if (aBS->NbPoles() == 2) PerformLinear (theC);
else PerformCurve (theC);
break;
}
case GeomAbs_BezierCurve:
{
- Handle(typename GCPnts_TCurveTypes<TheCurve>::BezierCurve) aBZ = theC.Bezier();
+ Handle(typename GCPnts_TCurveTypes<TheCurve>::BezierCurve) aBZ = theC->Bezier();
if (aBZ->NbPoles() == 2) PerformLinear (theC);
else PerformCurve (theC);
break;
myPoints .Append (CurrentPoint);
// Used to detect "isLine" current bspline and in Du computation in general handling.
- const Standard_Integer NbInterv = theC.NbIntervals (GeomAbs_CN);
+ const Standard_Integer NbInterv = theC->NbIntervals (GeomAbs_CN);
TColStd_Array1OfReal Intervs (1, NbInterv + 1);
- theC.Intervals (Intervs, GeomAbs_CN);
+ theC->Intervals (Intervs, GeomAbs_CN);
if (NotDone || Du > 5. * Dusave)
{
// Si c'est une droite on verifie en calculant minNbPoints :
Standard_Boolean IsLine = Standard_True;
Standard_Integer NbPoints = (myMinNbPnts > 3) ? myMinNbPnts : 3;
- switch (theC.GetType())
+ switch (theC->GetType())
{
case GeomAbs_BSplineCurve:
{
- Handle(typename GCPnts_TCurveTypes<TheCurve>::BSplineCurve) BS = theC.BSpline();
+ Handle(typename GCPnts_TCurveTypes<TheCurve>::BSplineCurve) BS = theC->BSpline();
NbPoints = Max(BS->Degree() + 1, NbPoints);
break;
}
case GeomAbs_BezierCurve:
{
- Handle(typename GCPnts_TCurveTypes<TheCurve>::BezierCurve) BZ = theC.Bezier();
+ Handle(typename GCPnts_TCurveTypes<TheCurve>::BezierCurve) BZ = theC->Bezier();
NbPoints = Max(BZ->Degree() + 1, NbPoints);
break;
}
//! @param theMinimumOfPoints [in] minimum number of points
//! @param theUTol [in] tolerance in curve parametric scope
//! @param theMinLen [in] minimal length
- Standard_EXPORT GCPnts_TangentialDeflection (const Adaptor3d_Curve& theC,
+ Standard_EXPORT GCPnts_TangentialDeflection (const Handle(Adaptor3d_Curve)& theC,
const Standard_Real theAngularDeflection, const Standard_Real theCurvatureDeflection,
const Standard_Integer theMinimumOfPoints = 2,
const Standard_Real theUTol = 1.0e-9,
//! @param theMinimumOfPoints [in] minimum number of points
//! @param theUTo l [in] tolerance in curve parametric scope
//! @param theMinLen [in] minimal length
- Standard_EXPORT GCPnts_TangentialDeflection (const Adaptor3d_Curve& theC,
+ Standard_EXPORT GCPnts_TangentialDeflection (const Handle(Adaptor3d_Curve)& theC,
const Standard_Real theFirstParameter, const Standard_Real theLastParameter,
const Standard_Real theAngularDeflection, const Standard_Real theCurvatureDeflection,
const Standard_Integer theMinimumOfPoints = 2,
//! @param theMinimumOfPoints [in] minimum number of points
//! @param theUTol [in] tolerance in curve parametric scope
//! @param theMinLen [in] minimal length
- Standard_EXPORT GCPnts_TangentialDeflection (const Adaptor2d_Curve2d& theC,
+ Standard_EXPORT GCPnts_TangentialDeflection (const Handle(Adaptor2d_Curve2d)& theC,
const Standard_Real theAngularDeflection, const Standard_Real theCurvatureDeflection,
const Standard_Integer theMinimumOfPoints = 2,
const Standard_Real theUTol = 1.0e-9,
//! @param theMinimumOfPoints [in] minimum number of points
//! @param theUTol [in] tolerance in curve parametric scope
//! @param theMinLen [in] minimal length
- Standard_EXPORT GCPnts_TangentialDeflection (const Adaptor2d_Curve2d& theC,
+ Standard_EXPORT GCPnts_TangentialDeflection (const Handle(Adaptor2d_Curve2d)& theC,
const Standard_Real theFirstParameter, const Standard_Real theLastParameter,
const Standard_Real theAngularDeflection, const Standard_Real theCurvatureDeflection,
const Standard_Integer theMinimumOfPoints = 2,
//! @param theMinimumOfPoints [in] minimum number of points
//! @param theUTol [in] tolerance in curve parametric scope
//! @param theMinLen [in] minimal length
- Standard_EXPORT void Initialize (const Adaptor3d_Curve& theC,
+ Standard_EXPORT void Initialize (const Handle(Adaptor3d_Curve)& theC,
const Standard_Real theAngularDeflection, const Standard_Real theCurvatureDeflection,
const Standard_Integer theMinimumOfPoints = 2,
const Standard_Real theUTol = 1.0e-9,
//! @param theMinimumOfPoints [in] minimum number of points
//! @param theUTol [in] tolerance in curve parametric scope
//! @param theMinLen [in] minimal length
- Standard_EXPORT void Initialize (const Adaptor3d_Curve& theC,
+ Standard_EXPORT void Initialize (const Handle(Adaptor3d_Curve)& theC,
const Standard_Real theFirstParameter, const Standard_Real theLastParameter,
const Standard_Real theAngularDeflection, const Standard_Real theCurvatureDeflection,
const Standard_Integer theMinimumOfPoints = 2,
//! @param theMinimumOfPoints [in] minimum number of points
//! @param theUTol [in] tolerance in curve parametric scope
//! @param theMinLen [in] minimal length
- Standard_EXPORT void Initialize (const Adaptor2d_Curve2d& theC,
+ Standard_EXPORT void Initialize (const Handle(Adaptor2d_Curve2d)& theC,
const Standard_Real theAngularDeflection, const Standard_Real theCurvatureDeflection,
const Standard_Integer theMinimumOfPoints = 2,
const Standard_Real theUTol = 1.0e-9,
//! @param theMinimumOfPoints [in] minimum number of points
//! @param theUTol [in] tolerance in curve parametric scope
//! @param theMinLen [in] minimal length
- Standard_EXPORT void Initialize (const Adaptor2d_Curve2d& theC,
+ Standard_EXPORT void Initialize (const Handle(Adaptor2d_Curve2d)& theC,
const Standard_Real theFirstParameter, const Standard_Real theLastParameter,
const Standard_Real theAngularDeflection, const Standard_Real theCurvatureDeflection,
const Standard_Integer theMinimumOfPoints = 2,
template<class TheCurve>
static Standard_Real GetParameterLengthRatio (const TheCurve& theC)
{
- switch (theC.GetType())
+ switch (theC->GetType())
{
case GeomAbs_Circle:
{
- return theC.Circle().Radius();
+ return theC->Circle().Radius();
}
case GeomAbs_Line:
{
case GeomAbs_BezierCurve:
case GeomAbs_BSplineCurve:
{
- if (!theC.IsRational())
+ if (!theC->IsRational())
{
- return theC.DN (0.0, 1).Magnitude();
+ return theC->DN (0.0, 1).Magnitude();
}
return RealLast();
}
template<class TheCurve>
static GCPnts_AbscissaType GetAbsType (const TheCurve& theC)
{
- if (theC.NbIntervals (GeomAbs_C1) > 1)
+ if (theC->NbIntervals (GeomAbs_C1) > 1)
{
return GCPnts_AbsComposite;
}
- switch (theC.GetType())
+ switch (theC->GetType())
{
case GeomAbs_Line:
case GeomAbs_Circle:
}
case GeomAbs_BezierCurve:
{
- Handle(typename GCPnts_TCurveTypes<TheCurve>::BezierCurve) aBZ = theC.Bezier();
+ Handle(typename GCPnts_TCurveTypes<TheCurve>::BezierCurve) aBZ = theC->Bezier();
if (aBZ->NbPoles() == 2 && !aBZ->IsRational())
{
return GCPnts_LengthParametrized;
}
case GeomAbs_BSplineCurve:
{
- Handle(typename GCPnts_TCurveTypes<TheCurve>::BSplineCurve) aBS = theC.BSpline();
+ Handle(typename GCPnts_TCurveTypes<TheCurve>::BSplineCurve) aBS = theC->BSpline();
if (aBS->NbPoles() == 2 && !aBS->IsRational())
{
return GCPnts_LengthParametrized;
//function : GCPnts_UniformAbscissa
//purpose :
//=======================================================================
-GCPnts_UniformAbscissa::GCPnts_UniformAbscissa (const Adaptor3d_Curve& theC,
+GCPnts_UniformAbscissa::GCPnts_UniformAbscissa (const Handle(Adaptor3d_Curve)& theC,
const Standard_Real theAbscissa,
const Standard_Real theTol)
: myDone (Standard_False),
//function : GCPnts_UniformAbscissa
//purpose :
//=======================================================================
-GCPnts_UniformAbscissa::GCPnts_UniformAbscissa (const Adaptor2d_Curve2d& theC,
+GCPnts_UniformAbscissa::GCPnts_UniformAbscissa (const Handle(Adaptor2d_Curve2d)& theC,
const Standard_Real theAbscissa,
const Standard_Real theTol)
: myDone (Standard_False),
//function : GCPnts_UniformAbscissa
//purpose :
//=======================================================================
-GCPnts_UniformAbscissa::GCPnts_UniformAbscissa (const Adaptor3d_Curve& theC,
+GCPnts_UniformAbscissa::GCPnts_UniformAbscissa (const Handle(Adaptor3d_Curve)& theC,
const Standard_Real theAbscissa,
const Standard_Real theU1, const Standard_Real theU2,
const Standard_Real theTol)
//function : GCPnts_UniformAbscissa
//purpose :
//=======================================================================
-GCPnts_UniformAbscissa::GCPnts_UniformAbscissa (const Adaptor2d_Curve2d& theC,
+GCPnts_UniformAbscissa::GCPnts_UniformAbscissa (const Handle(Adaptor2d_Curve2d)& theC,
const Standard_Real theAbscissa,
const Standard_Real theU1, const Standard_Real theU2,
const Standard_Real theTol)
//function : GCPnts_UniformAbscissa
//purpose :
//=======================================================================
-GCPnts_UniformAbscissa::GCPnts_UniformAbscissa (const Adaptor3d_Curve& theC,
+GCPnts_UniformAbscissa::GCPnts_UniformAbscissa (const Handle(Adaptor3d_Curve)& theC,
const Standard_Integer theNbPoints,
const Standard_Real theTol)
: myDone (Standard_False),
//function : GCPnts_UniformAbscissa
//purpose :
//=======================================================================
-GCPnts_UniformAbscissa::GCPnts_UniformAbscissa (const Adaptor2d_Curve2d& theC,
+GCPnts_UniformAbscissa::GCPnts_UniformAbscissa (const Handle(Adaptor2d_Curve2d)& theC,
const Standard_Integer theNbPoints,
const Standard_Real theTol)
: myDone (Standard_False),
//function : GCPnts_UniformAbscissa
//purpose :
//=======================================================================
-GCPnts_UniformAbscissa::GCPnts_UniformAbscissa (const Adaptor3d_Curve& theC,
+GCPnts_UniformAbscissa::GCPnts_UniformAbscissa (const Handle(Adaptor3d_Curve)& theC,
const Standard_Integer theNbPoints,
const Standard_Real theU1, const Standard_Real theU2,
const Standard_Real theTol)
//function : GCPnts_UniformAbscissa
//purpose :
//=======================================================================
-GCPnts_UniformAbscissa::GCPnts_UniformAbscissa (const Adaptor2d_Curve2d& theC,
+GCPnts_UniformAbscissa::GCPnts_UniformAbscissa (const Handle(Adaptor2d_Curve2d)& theC,
const Standard_Integer theNbPoints,
const Standard_Real theU1, const Standard_Real theU2,
const Standard_Real theTol)
//function : Initialize
//purpose :
//=======================================================================
-void GCPnts_UniformAbscissa::Initialize (const Adaptor3d_Curve& theC,
+void GCPnts_UniformAbscissa::Initialize (const Handle(Adaptor3d_Curve)& theC,
const Standard_Real theAbscissa,
const Standard_Real theTol)
{
- Initialize (theC, theAbscissa, theC.FirstParameter(), theC.LastParameter(), theTol);
+ Initialize (theC, theAbscissa, theC->FirstParameter(), theC->LastParameter(), theTol);
}
//=======================================================================
//function : Initialize
//purpose :
//=======================================================================
-void GCPnts_UniformAbscissa::Initialize (const Adaptor2d_Curve2d& theC,
+void GCPnts_UniformAbscissa::Initialize (const Handle(Adaptor2d_Curve2d)& theC,
const Standard_Real theAbscissa,
const Standard_Real theTol)
{
- Initialize (theC, theAbscissa, theC.FirstParameter(), theC.LastParameter(), theTol);
+ Initialize (theC, theAbscissa, theC->FirstParameter(), theC->LastParameter(), theTol);
}
//=======================================================================
//function : Initialize
//purpose :
//=======================================================================
-void GCPnts_UniformAbscissa::Initialize (const Adaptor3d_Curve& theC,
+void GCPnts_UniformAbscissa::Initialize (const Handle(Adaptor3d_Curve)& theC,
const Standard_Real theAbscissa,
const Standard_Real theU1, const Standard_Real theU2,
const Standard_Real theTol)
//function : Initialize
//purpose :
//=======================================================================
-void GCPnts_UniformAbscissa::Initialize (const Adaptor2d_Curve2d& theC,
+void GCPnts_UniformAbscissa::Initialize (const Handle(Adaptor2d_Curve2d)& theC,
const Standard_Real theAbscissa,
const Standard_Real theU1, const Standard_Real theU2,
const Standard_Real theTol)
myNbPoints = 0;
myDone = Standard_False;
- const Standard_Real anEPSILON = theC.Resolution (Max (theTol, Precision::Confusion()));
+ const Standard_Real anEPSILON = theC->Resolution (Max (theTol, Precision::Confusion()));
const Standard_Real aL = GCPnts_AbscissaPoint::Length (theC, theU1, theU2, anEPSILON);
if (aL <= Precision::Confusion())
{
//function : Initialize
//purpose :
//=======================================================================
-void GCPnts_UniformAbscissa::Initialize (const Adaptor3d_Curve& theC,
+void GCPnts_UniformAbscissa::Initialize (const Handle(Adaptor3d_Curve)& theC,
const Standard_Integer theNbPoints,
const Standard_Real theTol)
{
- Initialize (theC, theNbPoints, theC.FirstParameter(), theC.LastParameter(), theTol);
+ Initialize (theC, theNbPoints, theC->FirstParameter(), theC->LastParameter(), theTol);
}
//=======================================================================
//function : Initialize
//purpose :
//=======================================================================
-void GCPnts_UniformAbscissa::Initialize (const Adaptor2d_Curve2d& theC,
+void GCPnts_UniformAbscissa::Initialize (const Handle(Adaptor2d_Curve2d)& theC,
const Standard_Integer theNbPoints,
const Standard_Real theTol)
{
- Initialize (theC, theNbPoints, theC.FirstParameter(), theC.LastParameter(), theTol);
+ Initialize (theC, theNbPoints, theC->FirstParameter(), theC->LastParameter(), theTol);
}
//=======================================================================
//function : Initialize
//purpose :
//=======================================================================
-void GCPnts_UniformAbscissa::Initialize (const Adaptor3d_Curve& theC,
+void GCPnts_UniformAbscissa::Initialize (const Handle(Adaptor3d_Curve)& theC,
const Standard_Integer theNbPoints,
const Standard_Real theU1, const Standard_Real theU2,
const Standard_Real theTol)
//function : Initialize
//purpose :
//=======================================================================
-void GCPnts_UniformAbscissa::Initialize (const Adaptor2d_Curve2d& theC,
+void GCPnts_UniformAbscissa::Initialize (const Handle(Adaptor2d_Curve2d)& theC,
const Standard_Integer theNbPoints,
const Standard_Real theU1, const Standard_Real theU2,
const Standard_Real theTol)
myNbPoints = 0;
myDone = Standard_False;
- const Standard_Real anEPSILON = theC.Resolution (Max (theTol, Precision::Confusion()));
+ const Standard_Real anEPSILON = theC->Resolution (Max (theTol, Precision::Confusion()));
// although very similar to Initialize with Abscissa this avoid
// the computation of the total length of the curve twice
const Standard_Real aL = GCPnts_AbscissaPoint::Length (theC, theU1, theU2, anEPSILON);
//! @param theAbscissa [in] abscissa (distance between two consecutive points)
//! @param theToler [in] used for more precise calculation of curve length
//! (Precision::Confusion() by default)
- Standard_EXPORT GCPnts_UniformAbscissa (const Adaptor3d_Curve& theC,
+ Standard_EXPORT GCPnts_UniformAbscissa (const Handle(Adaptor3d_Curve)& theC,
const Standard_Real theAbscissa,
const Standard_Real theToler = -1);
//! @param theU2 [in] last parameter on curve
//! @param theToler [in] used for more precise calculation of curve length
//! (Precision::Confusion() by default)
- Standard_EXPORT GCPnts_UniformAbscissa (const Adaptor3d_Curve& theC,
+ Standard_EXPORT GCPnts_UniformAbscissa (const Handle(Adaptor3d_Curve)& theC,
const Standard_Real theAbscissa,
const Standard_Real theU1, const Standard_Real theU2,
const Standard_Real theToler = -1);
//! @param theNbPoints [in] defines the number of desired points
//! @param theToler [in] used for more precise calculation of curve length
//! (Precision::Confusion() by default)
- Standard_EXPORT GCPnts_UniformAbscissa (const Adaptor3d_Curve& theC,
+ Standard_EXPORT GCPnts_UniformAbscissa (const Handle(Adaptor3d_Curve)& theC,
const Standard_Integer theNbPoints,
const Standard_Real theToler = -1);
//! @param theU2 [in] last parameter on curve
//! @param theToler [in] used for more precise calculation of curve length
//! (Precision::Confusion() by default)
- Standard_EXPORT GCPnts_UniformAbscissa (const Adaptor3d_Curve& theC,
+ Standard_EXPORT GCPnts_UniformAbscissa (const Handle(Adaptor3d_Curve)& theC,
const Standard_Integer theNbPoints,
const Standard_Real theU1, const Standard_Real theU2,
const Standard_Real theToler = -1);
//! @param theAbscissa [in] abscissa (distance between two consecutive points)
//! @param theToler [in] used for more precise calculation of curve length
//! (Precision::Confusion() by default)
- Standard_EXPORT void Initialize (const Adaptor3d_Curve& theC,
+ Standard_EXPORT void Initialize (const Handle(Adaptor3d_Curve)& theC,
const Standard_Real theAbscissa,
const Standard_Real theToler = -1);
//! @param theU2 [in] last parameter on curve
//! @param theToler [in] used for more precise calculation of curve length
//! (Precision::Confusion() by default)
- Standard_EXPORT void Initialize (const Adaptor3d_Curve& theC,
+ Standard_EXPORT void Initialize (const Handle(Adaptor3d_Curve)& theC,
const Standard_Real theAbscissa,
const Standard_Real theU1, const Standard_Real theU2,
const Standard_Real theToler = -1);
//! @param theNbPoints [in] defines the number of desired points
//! @param theToler [in] used for more precise calculation of curve length
//! (Precision::Confusion() by default)
- Standard_EXPORT void Initialize (const Adaptor3d_Curve& theC,
+ Standard_EXPORT void Initialize (const Handle(Adaptor3d_Curve)& theC,
const Standard_Integer theNbPoints,
const Standard_Real theToler = -1);
//! @param theU2 [in] last parameter on curve
//! @param theToler [in] used for more precise calculation of curve length
//! (Precision::Confusion() by default)
- Standard_EXPORT void Initialize (const Adaptor3d_Curve& theC,
+ Standard_EXPORT void Initialize (const Handle(Adaptor3d_Curve)& theC,
const Standard_Integer theNbPoints,
const Standard_Real theU1, const Standard_Real theU2,
const Standard_Real theToler = -1);
//! @param theAbscissa [in] abscissa (distance between two consecutive points)
//! @param theToler [in] used for more precise calculation of curve length
//! (Precision::Confusion() by default)
- Standard_EXPORT GCPnts_UniformAbscissa (const Adaptor2d_Curve2d& theC,
+ Standard_EXPORT GCPnts_UniformAbscissa (const Handle(Adaptor2d_Curve2d)& theC,
const Standard_Real theAbscissa,
const Standard_Real theToler = -1);
//! @param theU2 [in] last parameter on curve
//! @param theToler [in] used for more precise calculation of curve length
//! (Precision::Confusion() by default)
- Standard_EXPORT GCPnts_UniformAbscissa (const Adaptor2d_Curve2d& theC,
+ Standard_EXPORT GCPnts_UniformAbscissa (const Handle(Adaptor2d_Curve2d)& theC,
const Standard_Real theAbscissa,
const Standard_Real theU1, const Standard_Real theU2,
const Standard_Real theToler = -1);
//! @param theNbPoints [in] defines the number of desired points
//! @param theToler [in] used for more precise calculation of curve length
//! (Precision::Confusion() by default)
- Standard_EXPORT GCPnts_UniformAbscissa (const Adaptor2d_Curve2d& theC,
+ Standard_EXPORT GCPnts_UniformAbscissa (const Handle(Adaptor2d_Curve2d)& theC,
const Standard_Integer theNbPoints,
const Standard_Real theToler = -1);
//! @param theU2 [in] last parameter on curve
//! @param theToler [in] used for more precise calculation of curve length
//! (Precision::Confusion() by default)
- Standard_EXPORT GCPnts_UniformAbscissa (const Adaptor2d_Curve2d& theC,
+ Standard_EXPORT GCPnts_UniformAbscissa (const Handle(Adaptor2d_Curve2d)& theC,
const Standard_Integer theNbPoints,
const Standard_Real theU1, const Standard_Real theU2,
const Standard_Real theToler = -1);
//! @param theAbscissa [in] abscissa (distance between two consecutive points)
//! @param theToler [in] used for more precise calculation of curve length
//! (Precision::Confusion() by default)
- Standard_EXPORT void Initialize (const Adaptor2d_Curve2d& theC,
+ Standard_EXPORT void Initialize (const Handle(Adaptor2d_Curve2d)& theC,
const Standard_Real theAbscissa,
const Standard_Real theToler = -1);
//! @param theU2 [in] last parameter on curve
//! @param theToler [in] used for more precise calculation of curve length
//! (Precision::Confusion() by default)
- Standard_EXPORT void Initialize (const Adaptor2d_Curve2d& theC,
+ Standard_EXPORT void Initialize (const Handle(Adaptor2d_Curve2d)& theC,
const Standard_Real theAbscissa,
const Standard_Real theU1, const Standard_Real theU2,
const Standard_Real theToler = -1);
//! @param theNbPoints [in] defines the number of desired points
//! @param theToler [in] used for more precise calculation of curve length
//! (Precision::Confusion() by default)
- Standard_EXPORT void Initialize (const Adaptor2d_Curve2d& theC,
+ Standard_EXPORT void Initialize (const Handle(Adaptor2d_Curve2d)& theC,
const Standard_Integer theNbPoints,
const Standard_Real theToler = -1);
//! @param theU2 [in] last parameter on curve
//! @param theToler [in] used for more precise calculation of curve length
//! (Precision::Confusion() by default)
- Standard_EXPORT void Initialize (const Adaptor2d_Curve2d& theC,
+ Standard_EXPORT void Initialize (const Handle(Adaptor2d_Curve2d)& theC,
const Standard_Integer theNbPoints,
const Standard_Real theU1, const Standard_Real theU2,
const Standard_Real theToler = -1);
#include <StdFail_NotDone.hxx>
// mask the return of a Adaptor2d_Curve2d as a gp_Pnt
-static gp_Pnt Value (const Adaptor3d_Curve& theC,
+static gp_Pnt Value (const Handle(Adaptor3d_Curve)& theC,
const Standard_Real theParameter)
{
- return theC.Value (theParameter);
+ return theC->Value (theParameter);
}
-static gp_Pnt Value (const Adaptor2d_Curve2d& theC,
+static gp_Pnt Value (const Handle(Adaptor2d_Curve2d)& theC,
const Standard_Real theParameter)
{
- const gp_Pnt2d a2dPoint = theC.Value (theParameter);
+ const gp_Pnt2d a2dPoint = theC->Value (theParameter);
return gp_Pnt (a2dPoint.X(), a2dPoint.Y(), 0.0);
}
//function : GCPnts_UniformDeflection
//purpose :
//=======================================================================
-GCPnts_UniformDeflection::GCPnts_UniformDeflection (const Adaptor3d_Curve& theC,
+GCPnts_UniformDeflection::GCPnts_UniformDeflection (const Handle(Adaptor3d_Curve)& theC,
const Standard_Real theDeflection,
const Standard_Real theU1,
const Standard_Real theU2,
//function : GCPnts_UniformDeflection
//purpose :
//=======================================================================
-GCPnts_UniformDeflection::GCPnts_UniformDeflection (const Adaptor3d_Curve& theC,
+GCPnts_UniformDeflection::GCPnts_UniformDeflection (const Handle(Adaptor3d_Curve)& theC,
const Standard_Real theDeflection,
const Standard_Boolean theWithControl)
: myDone (Standard_False),
//function : GCPnts_UniformDeflection
//purpose :
//=======================================================================
-GCPnts_UniformDeflection::GCPnts_UniformDeflection (const Adaptor2d_Curve2d& theC,
+GCPnts_UniformDeflection::GCPnts_UniformDeflection (const Handle(Adaptor2d_Curve2d)& theC,
const Standard_Real theDeflection,
const Standard_Real theU1,
const Standard_Real theU2,
//function : GCPnts_UniformDeflection
//purpose :
//=======================================================================
-GCPnts_UniformDeflection::GCPnts_UniformDeflection (const Adaptor2d_Curve2d& theC,
+GCPnts_UniformDeflection::GCPnts_UniformDeflection (const Handle(Adaptor2d_Curve2d)& theC,
const Standard_Real theDeflection,
const Standard_Boolean theWithControl)
: myDone (Standard_False),
//function : Initialize
//purpose :
//=======================================================================
-void GCPnts_UniformDeflection::Initialize (const Adaptor3d_Curve& theC,
+void GCPnts_UniformDeflection::Initialize (const Handle(Adaptor3d_Curve)& theC,
const Standard_Real theDeflection,
const Standard_Boolean theWithControl)
{
- Initialize (theC, theDeflection, theC.FirstParameter(), theC.LastParameter(), theWithControl);
+ Initialize (theC, theDeflection, theC->FirstParameter(), theC->LastParameter(), theWithControl);
}
//=======================================================================
//function : Initialize
//purpose :
//=======================================================================
-void GCPnts_UniformDeflection::Initialize (const Adaptor2d_Curve2d& theC,
+void GCPnts_UniformDeflection::Initialize (const Handle(Adaptor2d_Curve2d)& theC,
const Standard_Real theDeflection,
const Standard_Boolean theWithControl)
{
- Initialize (theC, theDeflection, theC.FirstParameter(), theC.LastParameter(), theWithControl);
+ Initialize (theC, theDeflection, theC->FirstParameter(), theC->LastParameter(), theWithControl);
}
//=======================================================================
//function : Initialize
//purpose :
//=======================================================================
-void GCPnts_UniformDeflection::Initialize (const Adaptor3d_Curve& theC,
+void GCPnts_UniformDeflection::Initialize (const Handle(Adaptor3d_Curve)& theC,
const Standard_Real theDeflection,
const Standard_Real theU1,
const Standard_Real theU2,
//function : Initialize
//purpose :
//=======================================================================
-void GCPnts_UniformDeflection::Initialize (const Adaptor2d_Curve2d& theC,
+void GCPnts_UniformDeflection::Initialize (const Handle(Adaptor2d_Curve2d)& theC,
const Standard_Real theDeflection,
const Standard_Real theU1,
const Standard_Real theU2,
const Standard_Real theU2)
{
gp_Pnt aPoint;
- Standard_Real anAngle = Max (1.0 - (theDeflection / theC.Circle().Radius()), 0.0);
+ Standard_Real anAngle = Max (1.0 - (theDeflection / theC->Circle().Radius()), 0.0);
anAngle = 2.0e0 * ACos (anAngle);
Standard_Integer aNbPoints = (Standard_Integer )((theU2 - theU1) / anAngle);
aNbPoints += 2;
template<class TheCurve>
static GCPnts_DeflectionType GetDefType (const TheCurve& theC)
{
- if (theC.NbIntervals (GeomAbs_C2) > 1)
+ if (theC->NbIntervals (GeomAbs_C2) > 1)
{
return GCPnts_DefComposite;
}
- switch (theC.GetType())
+ switch (theC->GetType())
{
case GeomAbs_Line: return GCPnts_Linear;
case GeomAbs_Circle: return GCPnts_Circular;
case GeomAbs_BSplineCurve:
{
- Handle(typename GCPnts_TCurveTypes<TheCurve>::BSplineCurve) aBSpline = theC.BSpline();
+ Handle(typename GCPnts_TCurveTypes<TheCurve>::BSplineCurve) aBSpline = theC->BSpline();
return (aBSpline->NbPoles() == 2) ? GCPnts_Linear : GCPnts_Curved;
}
case GeomAbs_BezierCurve:
{
- Handle(typename GCPnts_TCurveTypes<TheCurve>::BezierCurve) aBezier = theC.Bezier();
+ Handle(typename GCPnts_TCurveTypes<TheCurve>::BezierCurve) aBezier = theC->Bezier();
return (aBezier->NbPoles() == 2) ? GCPnts_Linear : GCPnts_Curved;
}
default:
const Standard_Real theEPSILON,
const Standard_Boolean theWithControl)
{
- const Standard_Integer aNbIntervals = theC.NbIntervals (GeomAbs_C2);
+ const Standard_Integer aNbIntervals = theC->NbIntervals (GeomAbs_C2);
Standard_Integer aPIndex = 0;
TColStd_Array1OfReal aTI (1, aNbIntervals + 1);
- theC.Intervals (aTI, GeomAbs_C2);
+ theC->Intervals (aTI, GeomAbs_C2);
BSplCLib::Hunt (aTI, theU1, aPIndex);
// iterate by continuous segments
const Standard_Real theU2,
const Standard_Boolean theWithControl)
{
- const Standard_Real anEPSILON = theC.Resolution (Precision::Confusion());
+ const Standard_Real anEPSILON = theC->Resolution (Precision::Confusion());
myDeflection = theDeflection;
myDone = Standard_False;
myParams.Clear();
//! @param theC [in] input 3D curve
//! @param theDeflection [in] target deflection
//! @param theWithControl [in] when TRUE, the algorithm controls the estimate deflection
- Standard_EXPORT GCPnts_UniformDeflection (const Adaptor3d_Curve& theC,
+ Standard_EXPORT GCPnts_UniformDeflection (const Handle(Adaptor3d_Curve)& theC,
const Standard_Real theDeflection,
const Standard_Boolean theWithControl = Standard_True);
//! @param theC [in] input 2D curve
//! @param theDeflection [in] target deflection
//! @param theWithControl [in] when TRUE, the algorithm controls the estimate deflection
- Standard_EXPORT GCPnts_UniformDeflection (const Adaptor2d_Curve2d& theC,
+ Standard_EXPORT GCPnts_UniformDeflection (const Handle(Adaptor2d_Curve2d)& theC,
const Standard_Real theDeflection,
const Standard_Boolean theWithControl = Standard_True);
//! @param theU1 [in] first parameter on curve
//! @param theU2 [in] last parameter on curve
//! @param theWithControl [in] when TRUE, the algorithm controls the estimate deflection
- Standard_EXPORT GCPnts_UniformDeflection (const Adaptor3d_Curve& theC,
+ Standard_EXPORT GCPnts_UniformDeflection (const Handle(Adaptor3d_Curve)& theC,
const Standard_Real theDeflection,
const Standard_Real theU1, const Standard_Real theU2,
const Standard_Boolean theWithControl = Standard_True);
//! @param theU1 [in] first parameter on curve
//! @param theU2 [in] last parameter on curve
//! @param theWithControl [in] when TRUE, the algorithm controls the estimate deflection
- Standard_EXPORT GCPnts_UniformDeflection (const Adaptor2d_Curve2d& theC,
+ Standard_EXPORT GCPnts_UniformDeflection (const Handle(Adaptor2d_Curve2d)& theC,
const Standard_Real theDeflection,
const Standard_Real theU1, const Standard_Real theU2,
const Standard_Boolean theWithControl = Standard_True);
//! Initialize the algorithms with 3D curve and deflection.
- Standard_EXPORT void Initialize (const Adaptor3d_Curve& theC,
+ Standard_EXPORT void Initialize (const Handle(Adaptor3d_Curve)& theC,
const Standard_Real theDeflection,
const Standard_Boolean theWithControl = Standard_True);
//! Initialize the algorithms with 2D curve and deflection.
- Standard_EXPORT void Initialize (const Adaptor2d_Curve2d& theC,
+ Standard_EXPORT void Initialize (const Handle(Adaptor2d_Curve2d)& theC,
const Standard_Real theDeflection,
const Standard_Boolean theWithControl = Standard_True);
//! Initialize the algorithms with 3D curve, deflection, parameter range.
- Standard_EXPORT void Initialize (const Adaptor3d_Curve& theC,
+ Standard_EXPORT void Initialize (const Handle(Adaptor3d_Curve)& theC,
const Standard_Real theDeflection,
const Standard_Real theU1, const Standard_Real theU2,
const Standard_Boolean theWithControl = Standard_True);
//! the package Geom2d (in the case of an Adaptor2d_Curve2d curve)
//! or a 3D curve from the package Geom (in the case of an Adaptor3d_Curve curve),
//! - and those required on the curve by the computation algorithm.
- Standard_EXPORT void Initialize (const Adaptor2d_Curve2d& theC,
+ Standard_EXPORT void Initialize (const Handle(Adaptor2d_Curve2d)& theC,
const Standard_Real theDeflection,
const Standard_Real theU1, const Standard_Real theU2,
const Standard_Boolean theWithControl = Standard_True);
const Standard_Real U2min,
const Standard_Real U2max)
{
- myC1.Load(C1, U1min, U1max);
- myC2.Load(C2, U2min, U2max);
+ myC1 = new Geom2dAdaptor_Curve(C1, U1min, U1max);
+ myC2 = new Geom2dAdaptor_Curve(C2, U2min, U2max);
Extrema_ExtCC2d theExtCC( myC1, myC2 );
myExtCC = theExtCC;
Standard_Boolean myIsDone;
Standard_Integer myIndex;
Extrema_ExtCC2d myExtCC;
- Geom2dAdaptor_Curve myC1;
- Geom2dAdaptor_Curve myC2;
+ Handle(Geom2dAdaptor_Curve) myC1;
+ Handle(Geom2dAdaptor_Curve) myC2;
};
myCurve1 = Handle(Geom2d_Curve)::DownCast(C1->Copy());
myCurve2 = Handle(Geom2d_Curve)::DownCast(C2->Copy());
- Geom2dAdaptor_Curve AC1(C1);
- Geom2dAdaptor_Curve AC2(C2);
+ Handle(Geom2dAdaptor_Curve) AC1 = new Geom2dAdaptor_Curve(C1);
+ Handle(Geom2dAdaptor_Curve) AC2 = new Geom2dAdaptor_Curve(C2);
myIntersector = Geom2dInt_GInter( AC1, AC2, Tol, Tol);
myIsDone = myIntersector.IsDone();
myCurve1 = Handle(Geom2d_Curve)::DownCast(C1->Copy());
myCurve2.Nullify();
- Geom2dAdaptor_Curve AC1(C1);
+ Handle(Geom2dAdaptor_Curve) AC1 = new Geom2dAdaptor_Curve(C1);
myIntersector = Geom2dInt_GInter( AC1, Tol, Tol);
myIsDone = myIntersector.IsDone();
//purpose :
//=======================================================================
Geom2dAPI_ProjectPointOnCurve::Geom2dAPI_ProjectPointOnCurve()
-: myIndex(-1)
+: myIndex(-1),
+ myC(new Geom2dAdaptor_Curve())
{
myIsDone = Standard_False;
}
const Standard_Real Umin,
const Standard_Real Usup )
{
- myC.Load(Curve,Umin,Usup);
+ myC = new Geom2dAdaptor_Curve(Curve,Umin,Usup);
Extrema_ExtPC2d theExtPC2d(P, myC);
Standard_Boolean myIsDone;
Standard_Integer myIndex;
Extrema_ExtPC2d myExtPC;
- Geom2dAdaptor_Curve myC;
+ Handle(Geom2dAdaptor_Curve) myC;
};
//purpose :
//=======================================================================
Handle(Geom2d_Curve) Geom2dAdaptor::MakeCurve
- (const Adaptor2d_Curve2d& HC)
+ (const Handle(Adaptor2d_Curve2d)& HC)
{
Handle(Geom2d_Curve) C2D;
- switch (HC.GetType()) {
+ switch (HC->GetType()) {
case GeomAbs_Line:
{
- Handle(Geom2d_Line) GL = new Geom2d_Line(HC.Line());
+ Handle(Geom2d_Line) GL = new Geom2d_Line(HC->Line());
C2D = GL;
}
break;
case GeomAbs_Circle:
{
- Handle(Geom2d_Circle) GL = new Geom2d_Circle(HC.Circle());
+ Handle(Geom2d_Circle) GL = new Geom2d_Circle(HC->Circle());
C2D = GL;
}
break;
case GeomAbs_Ellipse:
{
- Handle(Geom2d_Ellipse) GL = new Geom2d_Ellipse(HC.Ellipse());
+ Handle(Geom2d_Ellipse) GL = new Geom2d_Ellipse(HC->Ellipse());
C2D = GL;
}
break;
case GeomAbs_Parabola:
{
- Handle(Geom2d_Parabola) GL = new Geom2d_Parabola(HC.Parabola());
+ Handle(Geom2d_Parabola) GL = new Geom2d_Parabola(HC->Parabola());
C2D = GL;
}
break;
case GeomAbs_Hyperbola:
{
- Handle(Geom2d_Hyperbola) GL = new Geom2d_Hyperbola(HC.Hyperbola());
+ Handle(Geom2d_Hyperbola) GL = new Geom2d_Hyperbola(HC->Hyperbola());
C2D = GL;
}
break;
case GeomAbs_BezierCurve:
{
- C2D = HC.Bezier();
+ C2D = HC->Bezier();
}
break;
case GeomAbs_BSplineCurve:
{
- C2D = HC.BSpline();
+ C2D = HC->BSpline();
}
break;
case GeomAbs_OffsetCurve:
{
- const Geom2dAdaptor_Curve* pGAC = dynamic_cast<const Geom2dAdaptor_Curve*>(&HC);
- if (pGAC != 0)
+ const Handle(Geom2dAdaptor_Curve) pGAC = Handle(Geom2dAdaptor_Curve)::DownCast(HC);
+ if (!pGAC.IsNull())
{
C2D = pGAC->Curve();
}
// trim the curve if necassary.
if (! C2D.IsNull() &&
- ((HC.FirstParameter() != C2D->FirstParameter()) ||
- (HC.LastParameter() != C2D->LastParameter()))) {
+ ((HC->FirstParameter() != C2D->FirstParameter()) ||
+ (HC->LastParameter() != C2D->LastParameter()))) {
if (C2D->IsPeriodic() ||
- (HC.FirstParameter() >= C2D->FirstParameter() &&
- HC.LastParameter() <= C2D->LastParameter()))
+ (HC->FirstParameter() >= C2D->FirstParameter() &&
+ HC->LastParameter() <= C2D->LastParameter()))
{
C2D = new Geom2d_TrimmedCurve
- (C2D, HC.FirstParameter(), HC.LastParameter());
+ (C2D, HC->FirstParameter(), HC->LastParameter());
}
else
{
- Standard_Real tf = Max(HC.FirstParameter(), C2D->FirstParameter());
- Standard_Real tl = Min(HC.LastParameter(), C2D->LastParameter());
+ Standard_Real tf = Max(HC->FirstParameter(), C2D->FirstParameter());
+ Standard_Real tl = Min(HC->LastParameter(), C2D->LastParameter());
C2D = new Geom2d_TrimmedCurve(C2D, tf, tl);
}
}
//! handled by reference.
//! Creates a 2d curve from a HCurve2d. This
//! cannot process the OtherCurves.
- Standard_EXPORT static Handle(Geom2d_Curve) MakeCurve (const Adaptor2d_Curve2d& HC);
+ Standard_EXPORT static Handle(Geom2d_Curve) MakeCurve (const Handle(Adaptor2d_Curve2d)& HC);
};
#include <Geom2dGcc_QualifiedCurve.hxx>
Geom2dGcc_QualifiedCurve
- Geom2dGcc::Unqualified(const Geom2dAdaptor_Curve& Curve) {
+ Geom2dGcc::Unqualified(const Handle(Geom2dAdaptor_Curve)& Curve) {
return Geom2dGcc_QualifiedCurve(Curve,GccEnt_unqualified);
}
Geom2dGcc_QualifiedCurve
- Geom2dGcc::Enclosing(const Geom2dAdaptor_Curve& Curve) {
+ Geom2dGcc::Enclosing(const Handle(Geom2dAdaptor_Curve)& Curve) {
return Geom2dGcc_QualifiedCurve(Curve,GccEnt_enclosing);
}
Geom2dGcc_QualifiedCurve
- Geom2dGcc::Enclosed(const Geom2dAdaptor_Curve& Curve) {
+ Geom2dGcc::Enclosed(const Handle(Geom2dAdaptor_Curve)& Curve) {
return Geom2dGcc_QualifiedCurve(Curve,GccEnt_enclosed);
}
Geom2dGcc_QualifiedCurve
- Geom2dGcc::Outside(const Geom2dAdaptor_Curve& Curve) {
+ Geom2dGcc::Outside(const Handle(Geom2dAdaptor_Curve)& Curve) {
return Geom2dGcc_QualifiedCurve(Curve,GccEnt_outside);
}
//! The qualified curve is then constructed with this object:
//! Geom2dGcc_QualifiedCurve
//! myQCurve = Geom2dGcc::Unqualified(Obj);
- Standard_EXPORT static Geom2dGcc_QualifiedCurve Unqualified (const Geom2dAdaptor_Curve& Obj);
+ Standard_EXPORT static Geom2dGcc_QualifiedCurve Unqualified (const Handle(Geom2dAdaptor_Curve)& Obj);
//! Constructs such a qualified curve that the solution
//! computed by a construction algorithm using the qualified
//! The qualified curve is then constructed with this object:
//! Geom2dGcc_QualifiedCurve
//! myQCurve = Geom2dGcc::Enclosing(Obj);
- Standard_EXPORT static Geom2dGcc_QualifiedCurve Enclosing (const Geom2dAdaptor_Curve& Obj);
+ Standard_EXPORT static Geom2dGcc_QualifiedCurve Enclosing (const Handle(Geom2dAdaptor_Curve)& Obj);
//! Constructs such a qualified curve that the solution
//! computed by a construction algorithm using the qualified
//! The qualified curve is then constructed with this object:
//! Geom2dGcc_QualifiedCurve
//! myQCurve = Geom2dGcc::Enclosed(Obj);
- Standard_EXPORT static Geom2dGcc_QualifiedCurve Enclosed (const Geom2dAdaptor_Curve& Obj);
+ Standard_EXPORT static Geom2dGcc_QualifiedCurve Enclosed (const Handle(Geom2dAdaptor_Curve)& Obj);
//! Constructs such a qualified curve that the solution
//! computed by a construction algorithm using the qualified
//! The qualified curve is then constructed with this object:
//! Geom2dGcc_QualifiedCurve
//! myQCurve = Geom2dGcc::Outside(Obj);
- Standard_EXPORT static Geom2dGcc_QualifiedCurve Outside (const Geom2dAdaptor_Curve& Obj);
+ Standard_EXPORT static Geom2dGcc_QualifiedCurve Outside (const Handle(Geom2dAdaptor_Curve)& Obj);
};
Geom2dGcc_Circ2d2TanOn::
Geom2dGcc_Circ2d2TanOn (const Geom2dGcc_QualifiedCurve& Qualified1 ,
const Geom2dGcc_QualifiedCurve& Qualified2 ,
- const Geom2dAdaptor_Curve& OnCurve ,
+ const Handle(Geom2dAdaptor_Curve)& OnCurve ,
const Standard_Real Tolerance ,
const Standard_Real Param1 ,
const Standard_Real Param2 ,
pararg2(1,8) ,
parcen3(1,8)
{
- Geom2dAdaptor_Curve C1 = Qualified1.Qualified();
- Geom2dAdaptor_Curve C2 = Qualified2.Qualified();
- GeomAbs_CurveType Type1 = C1.GetType();
- GeomAbs_CurveType Type2 = C2.GetType();
- GeomAbs_CurveType Type3 = OnCurve.GetType();
- Handle(Geom2d_Curve) CC1 = C1.Curve();
- Handle(Geom2d_Curve) CC2 = C2.Curve();
- Handle(Geom2d_Curve) Con = OnCurve.Curve();
+ Handle(Geom2dAdaptor_Curve) C1 = Qualified1.Qualified();
+ Handle(Geom2dAdaptor_Curve) C2 = Qualified2.Qualified();
+ GeomAbs_CurveType Type1 = C1->GetType();
+ GeomAbs_CurveType Type2 = C2->GetType();
+ GeomAbs_CurveType Type3 = OnCurve->GetType();
+ Handle(Geom2d_Curve) CC1 = C1->Curve();
+ Handle(Geom2d_Curve) CC2 = C2->Curve();
+ Handle(Geom2d_Curve) Con = OnCurve->Curve();
//=============================================================================
// Appel a GccAna. +
Geom2dGcc_Circ2d2TanOn::
Geom2dGcc_Circ2d2TanOn (const Geom2dGcc_QualifiedCurve& Qualified1 ,
const Handle(Geom2d_Point)& Point ,
- const Geom2dAdaptor_Curve& OnCurve ,
+ const Handle(Geom2dAdaptor_Curve)& OnCurve ,
const Standard_Real Tolerance ,
const Standard_Real Param1 ,
const Standard_Real ParamOn ):
pararg2(1,8) ,
parcen3(1,8)
{
- Geom2dAdaptor_Curve C1 = Qualified1.Qualified();
- GeomAbs_CurveType Type1 = C1.GetType();
- GeomAbs_CurveType Type3 = OnCurve.GetType();
- Handle(Geom2d_Curve) CC1 = C1.Curve();
- Handle(Geom2d_Curve) Con = OnCurve.Curve();
+ Handle(Geom2dAdaptor_Curve) C1 = Qualified1.Qualified();
+ GeomAbs_CurveType Type1 = C1->GetType();
+ GeomAbs_CurveType Type3 = OnCurve->GetType();
+ Handle(Geom2d_Curve) CC1 = C1->Curve();
+ Handle(Geom2d_Curve) Con = OnCurve->Curve();
//=============================================================================
// Appel a GccAna. +
Geom2dGcc_Circ2d2TanOn::
Geom2dGcc_Circ2d2TanOn (const Handle(Geom2d_Point)& Point1 ,
const Handle(Geom2d_Point)& Point2 ,
- const Geom2dAdaptor_Curve& OnCurve ,
+ const Handle(Geom2dAdaptor_Curve)& OnCurve ,
const Standard_Real Tolerance ):
WellDone(Standard_False),
cirsol(1,8) ,
pararg2(1,8) ,
parcen3(1,8)
{
- GeomAbs_CurveType Type3 = OnCurve.GetType();
- Handle(Geom2d_Curve) Con = OnCurve.Curve();
+ GeomAbs_CurveType Type3 = OnCurve->GetType();
+ Handle(Geom2d_Curve) Con = OnCurve->Curve();
//=============================================================================
// Appel a GccAna. +
//! Param1 is the initial guess on the second curve QualifiedCurv.
//! ParamOn is the initial guess on the center curve OnCurv.
//! Tolerance is used for the limit cases.
- Standard_EXPORT Geom2dGcc_Circ2d2TanOn(const Geom2dGcc_QualifiedCurve& Qualified1, const Geom2dGcc_QualifiedCurve& Qualified2, const Geom2dAdaptor_Curve& OnCurve, const Standard_Real Tolerance, const Standard_Real Param1, const Standard_Real Param2, const Standard_Real ParamOn);
+ Standard_EXPORT Geom2dGcc_Circ2d2TanOn(const Geom2dGcc_QualifiedCurve& Qualified1, const Geom2dGcc_QualifiedCurve& Qualified2, const Handle(Geom2dAdaptor_Curve)& OnCurve, const Standard_Real Tolerance, const Standard_Real Param1, const Standard_Real Param2, const Standard_Real ParamOn);
//! This method implements the algorithms used to
//! create 2d circles TANgent to one curve and one point and
//! Param1 is the initial guess on the first curve QualifiedCurv.
//! ParamOn is the initial guess on the center curve OnCurv.
//! Tolerance is used for the limit cases.
- Standard_EXPORT Geom2dGcc_Circ2d2TanOn(const Geom2dGcc_QualifiedCurve& Qualified1, const Handle(Geom2d_Point)& Point, const Geom2dAdaptor_Curve& OnCurve, const Standard_Real Tolerance, const Standard_Real Param1, const Standard_Real ParamOn);
+ Standard_EXPORT Geom2dGcc_Circ2d2TanOn(const Geom2dGcc_QualifiedCurve& Qualified1, const Handle(Geom2d_Point)& Point, const Handle(Geom2dAdaptor_Curve)& OnCurve, const Standard_Real Tolerance, const Standard_Real Param1, const Standard_Real ParamOn);
//! This method implements the algorithms used to
//! create 2d circles TANgent to two points and
//! having the center ON a 2d curve.
//! Tolerance is used for the limit cases.
- Standard_EXPORT Geom2dGcc_Circ2d2TanOn(const Handle(Geom2d_Point)& Point1, const Handle(Geom2d_Point)& Point2, const Geom2dAdaptor_Curve& OnCurve, const Standard_Real Tolerance);
+ Standard_EXPORT Geom2dGcc_Circ2d2TanOn(const Handle(Geom2d_Point)& Point1, const Handle(Geom2d_Point)& Point2, const Handle(Geom2dAdaptor_Curve)& OnCurve, const Standard_Real Tolerance);
Standard_EXPORT void Results (const GccAna_Circ2d2TanOn& Circ);
Geom2dGcc_Circ2d2TanOnGeo::
Geom2dGcc_Circ2d2TanOnGeo (const GccEnt_QualifiedCirc& Qualified1 ,
const GccEnt_QualifiedCirc& Qualified2 ,
- const Geom2dAdaptor_Curve& OnCurv ,
+ const Handle(Geom2dAdaptor_Curve)& OnCurv ,
const Standard_Real Tolerance ):
cirsol(1, aNbSolMAX) ,
qualifier1(1, aNbSolMAX),
if (Bis.IsDone()) {
Geom2dInt_TheIntConicCurveOfGInter Intp;
Standard_Integer nbsolution = Bis.NbSolutions();
- Handle(Geom2dAdaptor_Curve) HCu2 = new Geom2dAdaptor_Curve(OnCurv);
- Adaptor2d_OffsetCurve Cu2(HCu2,0.);
- firstparam = Max(Cu2.FirstParameter(),thefirst);
- lastparam = Min(Cu2.LastParameter(),thelast);
- IntRes2d_Domain D2(Cu2.Value(firstparam), firstparam, Tol,
- Cu2.Value(lastparam), lastparam, Tol);
+ Handle(Adaptor2d_OffsetCurve) Cu2 = new Adaptor2d_OffsetCurve(OnCurv,0.);
+ firstparam = Max(Cu2->FirstParameter(),thefirst);
+ lastparam = Min(Cu2->LastParameter(),thelast);
+ IntRes2d_Domain D2(Cu2->Value(firstparam), firstparam, Tol,
+ Cu2->Value(lastparam), lastparam, Tol);
Standard_Real Tol1 = Abs(Tolerance);
Standard_Real Tol2 = Tol1;
for (Standard_Integer i = 1 ; i <= nbsolution; i++) {
Geom2dGcc_Circ2d2TanOnGeo::
Geom2dGcc_Circ2d2TanOnGeo (const GccEnt_QualifiedCirc& Qualified1 ,
const GccEnt_QualifiedLin& Qualified2 ,
- const Geom2dAdaptor_Curve& OnCurv ,
+ const Handle(Geom2dAdaptor_Curve)& OnCurv ,
const Standard_Real Tolerance ):
cirsol(1, aNbSolMAX) ,
qualifier1(1, aNbSolMAX),
Standard_Real Tol2 = Tol1;
Geom2dInt_TheIntConicCurveOfGInter Intp;
Standard_Integer nbsolution = Bis.NbSolutions();
- Handle(Geom2dAdaptor_Curve) HCu2 = new Geom2dAdaptor_Curve(OnCurv);
- Adaptor2d_OffsetCurve C2(HCu2,0.);
- firstparam = Max(C2.FirstParameter(),thefirst);
- lastparam = Min(C2.LastParameter(),thelast);
- IntRes2d_Domain D2(C2.Value(firstparam), firstparam, Tol,
- C2.Value(lastparam), lastparam, Tol);
+ Handle(Adaptor2d_OffsetCurve) C2 = new Adaptor2d_OffsetCurve(OnCurv,0.);
+ firstparam = Max(C2->FirstParameter(),thefirst);
+ lastparam = Min(C2->LastParameter(),thelast);
+ IntRes2d_Domain D2(C2->Value(firstparam), firstparam, Tol,
+ C2->Value(lastparam), lastparam, Tol);
for (Standard_Integer i = 1 ; i <= nbsolution; i++) {
Handle(GccInt_Bisec) Sol = Bis.ThisSolution(i);
GccInt_IType type = Sol->ArcType();
Geom2dGcc_Circ2d2TanOnGeo::
Geom2dGcc_Circ2d2TanOnGeo (const GccEnt_QualifiedLin& Qualified1 ,
const GccEnt_QualifiedLin& Qualified2 ,
- const Geom2dAdaptor_Curve& OnCurv ,
+ const Handle(Geom2dAdaptor_Curve)& OnCurv ,
const Standard_Real Tolerance ):
cirsol(1, aNbSolMAX) ,
qualifier1(1, aNbSolMAX),
Standard_Real Tol2 = Tol1;
Geom2dInt_TheIntConicCurveOfGInter Intp;
Standard_Integer nbsolution = Bis.NbSolutions();
- Handle(Geom2dAdaptor_Curve) HCu2 = new Geom2dAdaptor_Curve(OnCurv);
- Adaptor2d_OffsetCurve C2(HCu2,0.);
- firstparam = Max(C2.FirstParameter(),thefirst);
- lastparam = Min(C2.LastParameter(),thelast);
- IntRes2d_Domain D2(C2.Value(firstparam), firstparam, Tol,
- C2.Value(lastparam), lastparam, Tol);
+ Handle(Adaptor2d_OffsetCurve) C2 = new Adaptor2d_OffsetCurve(OnCurv,0.);
+ firstparam = Max(C2->FirstParameter(),thefirst);
+ lastparam = Min(C2->LastParameter(),thelast);
+ IntRes2d_Domain D2(C2->Value(firstparam), firstparam, Tol,
+ C2->Value(lastparam), lastparam, Tol);
IntRes2d_Domain D1;
for (Standard_Integer i = 1 ; i <= nbsolution; i++) {
Intp.Perform(Bis.ThisSolution(i),D1,C2,D2,Tol1,Tol2);
Geom2dGcc_Circ2d2TanOnGeo::
Geom2dGcc_Circ2d2TanOnGeo (const GccEnt_QualifiedCirc& Qualified1 ,
const gp_Pnt2d& Point2 ,
- const Geom2dAdaptor_Curve& OnCurv ,
+ const Handle(Geom2dAdaptor_Curve)& OnCurv ,
const Standard_Real Tolerance ):
cirsol(1, aNbSolMAX) ,
qualifier1(1, aNbSolMAX),
Standard_Real Tol2 = Tol1;
Geom2dInt_TheIntConicCurveOfGInter Intp;
Standard_Integer nbsolution = Bis.NbSolutions();
- Handle(Geom2dAdaptor_Curve) HCu2 = new Geom2dAdaptor_Curve(OnCurv);
- Adaptor2d_OffsetCurve C2(HCu2,0.);
- firstparam = Max(C2.FirstParameter(),thefirst);
- lastparam = Min(C2.LastParameter(),thelast);
- IntRes2d_Domain D2(C2.Value(firstparam), firstparam, Tol,
- C2.Value(lastparam), lastparam, Tol);
+ Handle(Adaptor2d_OffsetCurve) C2 = new Adaptor2d_OffsetCurve(OnCurv,0.);
+ firstparam = Max(C2->FirstParameter(),thefirst);
+ lastparam = Min(C2->LastParameter(),thelast);
+ IntRes2d_Domain D2(C2->Value(firstparam), firstparam, Tol,
+ C2->Value(lastparam), lastparam, Tol);
for (Standard_Integer i = 1 ; i <= nbsolution; i++) {
Handle(GccInt_Bisec) Sol = Bis.ThisSolution(i);
GccInt_IType type = Sol->ArcType();
Geom2dGcc_Circ2d2TanOnGeo::
Geom2dGcc_Circ2d2TanOnGeo (const GccEnt_QualifiedLin& Qualified1 ,
const gp_Pnt2d& Point2 ,
- const Geom2dAdaptor_Curve& OnCurv ,
+ const Handle(Geom2dAdaptor_Curve)& OnCurv ,
const Standard_Real Tolerance ):
cirsol(1, aNbSolMAX) ,
qualifier1(1, aNbSolMAX),
Standard_Real Tol1 = Abs(Tolerance);
Standard_Real Tol2 = Tol1;
Geom2dInt_TheIntConicCurveOfGInter Intp;
- Handle(Geom2dAdaptor_Curve) HCu2 = new Geom2dAdaptor_Curve(OnCurv);
- Adaptor2d_OffsetCurve C2(HCu2,0.);
- firstparam = Max(C2.FirstParameter(),thefirst);
- lastparam = Min(C2.LastParameter(),thelast);
- IntRes2d_Domain D2(C2.Value(firstparam), firstparam, Tol,
- C2.Value(lastparam), lastparam, Tol);
+ Handle(Adaptor2d_OffsetCurve) C2 = new Adaptor2d_OffsetCurve(OnCurv,0.);
+ firstparam = Max(C2->FirstParameter(),thefirst);
+ lastparam = Min(C2->LastParameter(),thelast);
+ IntRes2d_Domain D2(C2->Value(firstparam), firstparam, Tol,
+ C2->Value(lastparam), lastparam, Tol);
Handle(GccInt_Bisec) Sol = Bis.ThisSolution();
GccInt_IType type = Sol->ArcType();
switch (type) {
Geom2dGcc_Circ2d2TanOnGeo::
Geom2dGcc_Circ2d2TanOnGeo (const gp_Pnt2d& Point1 ,
const gp_Pnt2d& Point2 ,
- const Geom2dAdaptor_Curve& OnCurv ,
+ const Handle(Geom2dAdaptor_Curve)& OnCurv ,
const Standard_Real Tolerance ):
cirsol(1, aNbSolMAX) ,
qualifier1(1, aNbSolMAX),
Standard_Real Tol1 = Abs(Tolerance);
Standard_Real Tol2 = Tol1;
Geom2dInt_TheIntConicCurveOfGInter Intp;
- Handle(Geom2dAdaptor_Curve) HCu2 = new Geom2dAdaptor_Curve(OnCurv);
- Adaptor2d_OffsetCurve Cu2(HCu2,0.);
- firstparam = Max(Cu2.FirstParameter(),thefirst);
- lastparam = Min(Cu2.LastParameter(),thelast);
- IntRes2d_Domain D2(Cu2.Value(firstparam), firstparam, Tol,
- Cu2.Value(lastparam), lastparam, Tol);
+ Handle(Adaptor2d_OffsetCurve) Cu2 = new Adaptor2d_OffsetCurve(OnCurv,0.);
+ firstparam = Max(Cu2->FirstParameter(),thefirst);
+ lastparam = Min(Cu2->LastParameter(),thelast);
+ IntRes2d_Domain D2(Cu2->Value(firstparam), firstparam, Tol,
+ Cu2->Value(lastparam), lastparam, Tol);
IntRes2d_Domain D1;
if (Bis.HasSolution()) {
Intp.Perform(Bis.ThisSolution(),D1,Cu2,D2,Tol1,Tol2);
//! This method implements the algorithms used to
//! create 2d circles TANgent to two 2d circles and
//! having the center ON a curve.
- Standard_EXPORT Geom2dGcc_Circ2d2TanOnGeo(const GccEnt_QualifiedCirc& Qualified1, const GccEnt_QualifiedCirc& Qualified2, const Geom2dAdaptor_Curve& OnCurv, const Standard_Real Tolerance);
+ Standard_EXPORT Geom2dGcc_Circ2d2TanOnGeo(const GccEnt_QualifiedCirc& Qualified1, const GccEnt_QualifiedCirc& Qualified2, const Handle(Geom2dAdaptor_Curve)& OnCurv, const Standard_Real Tolerance);
//! This method implements the algorithms used to
//! create 2d circles TANgent to a 2d circle and a 2d line
//! having the center ON a curve.
- Standard_EXPORT Geom2dGcc_Circ2d2TanOnGeo(const GccEnt_QualifiedCirc& Qualified1, const GccEnt_QualifiedLin& Qualified2, const Geom2dAdaptor_Curve& OnCurv, const Standard_Real Tolerance);
+ Standard_EXPORT Geom2dGcc_Circ2d2TanOnGeo(const GccEnt_QualifiedCirc& Qualified1, const GccEnt_QualifiedLin& Qualified2, const Handle(Geom2dAdaptor_Curve)& OnCurv, const Standard_Real Tolerance);
//! This method implements the algorithms used to
//! create 2d circles TANgent to a 2d circle and a point
//! having the center ON a curve.
- Standard_EXPORT Geom2dGcc_Circ2d2TanOnGeo(const GccEnt_QualifiedCirc& Qualified1, const gp_Pnt2d& Point2, const Geom2dAdaptor_Curve& OnCurv, const Standard_Real Tolerance);
+ Standard_EXPORT Geom2dGcc_Circ2d2TanOnGeo(const GccEnt_QualifiedCirc& Qualified1, const gp_Pnt2d& Point2, const Handle(Geom2dAdaptor_Curve)& OnCurv, const Standard_Real Tolerance);
//! This method implements the algorithms used to
//! create 2d circles TANgent to two 2d lines
//! having the center ON a curve.
- Standard_EXPORT Geom2dGcc_Circ2d2TanOnGeo(const GccEnt_QualifiedLin& Qualified1, const GccEnt_QualifiedLin& Qualified2, const Geom2dAdaptor_Curve& OnCurv, const Standard_Real Tolerance);
+ Standard_EXPORT Geom2dGcc_Circ2d2TanOnGeo(const GccEnt_QualifiedLin& Qualified1, const GccEnt_QualifiedLin& Qualified2, const Handle(Geom2dAdaptor_Curve)& OnCurv, const Standard_Real Tolerance);
//! This method implements the algorithms used to
//! create 2d circles TANgent to a 2d line and a point
//! having the center ON a 2d line.
- Standard_EXPORT Geom2dGcc_Circ2d2TanOnGeo(const GccEnt_QualifiedLin& Qualified1, const gp_Pnt2d& Qualified2, const Geom2dAdaptor_Curve& OnCurv, const Standard_Real Tolerance);
+ Standard_EXPORT Geom2dGcc_Circ2d2TanOnGeo(const GccEnt_QualifiedLin& Qualified1, const gp_Pnt2d& Qualified2, const Handle(Geom2dAdaptor_Curve)& OnCurv, const Standard_Real Tolerance);
//! This method implements the algorithms used to
//! create 2d circles TANgent to two points
//! having the center ON a 2d line.
- Standard_EXPORT Geom2dGcc_Circ2d2TanOnGeo(const gp_Pnt2d& Point1, const gp_Pnt2d& Point2, const Geom2dAdaptor_Curve& OnCurv, const Standard_Real Tolerance);
+ Standard_EXPORT Geom2dGcc_Circ2d2TanOnGeo(const gp_Pnt2d& Point1, const gp_Pnt2d& Point2, const Handle(Geom2dAdaptor_Curve)& OnCurv, const Standard_Real Tolerance);
//! This method returns True if the construction
//! algorithm succeeded.
}
gp_Dir2d dirx(1.,0.);
gp_Lin2d L1 = Qualified1.Qualified();
- Geom2dAdaptor_Curve Cu2 = Qualified2.Qualified();
+ Handle(Geom2dAdaptor_Curve) Cu2 = Qualified2.Qualified();
math_Vector Umin(1,4);
math_Vector Umax(1,4);
math_Vector Ufirst(1,4);
}
Standard_Real Tol = Abs(Tolerance);
gp_Dir2d dirx(1.,0.);
- Geom2dAdaptor_Curve Cu1 = Qualified1.Qualified();
- Geom2dAdaptor_Curve Cu2 = Qualified2.Qualified();
+ Handle(Geom2dAdaptor_Curve) Cu1 = Qualified1.Qualified();
+ Handle(Geom2dAdaptor_Curve) Cu2 = Qualified2.Qualified();
math_Vector Umin(1,4);
math_Vector Umax(1,4);
math_Vector Ufirst(1,4);
}
Standard_Real Tol = Abs(Tolerance);
gp_Dir2d dirx(1.,0.);
- Geom2dAdaptor_Curve Cu1 = Qualified1.Qualified();
+ Handle(Geom2dAdaptor_Curve) Cu1 = Qualified1.Qualified();
math_Vector Umin(1,3);
math_Vector Umax(1,3);
math_Vector Ufirst(1,3);
gp_Dir2d dirx(1.,0.);
gp_Circ2d C1 = Qualified1.Qualified();
Standard_Real R1 = C1.Radius();
- Geom2dAdaptor_Curve Cu2 = Qualified2.Qualified();
+ Handle(Geom2dAdaptor_Curve) Cu2 = Qualified2.Qualified();
math_Vector Umin(1,4);
math_Vector Umax(1,4);
math_Vector Ufirst(1,4);
gp_Dir2d dirx(1.,0.);
gp_Circ2d C1 = Qualified1.Qualified();
Standard_Real R1 = C1.Radius();
- Geom2dAdaptor_Curve Cu2 = Qualified2.Qualified();
+ Handle(Geom2dAdaptor_Curve) Cu2 = Qualified2.Qualified();
math_Vector Umin(1,4);
math_Vector Umax(1,4);
math_Vector Ufirst(1,4);
Standard_Real Tol = Abs(Tolerance);
gp_Dir2d dirx(1.,0.);
gp_Lin2d L1 = Qualified1.Qualified();
- Geom2dAdaptor_Curve Cu2 = Qualified2.Qualified();
+ Handle(Geom2dAdaptor_Curve) Cu2 = Qualified2.Qualified();
math_Vector Umin(1,4);
math_Vector Umax(1,4);
math_Vector Ufirst(1,4);
}
Standard_Real Tol = Abs(Tolerance);
gp_Dir2d dirx(1.,0.);
- Geom2dAdaptor_Curve Cu1 = Qualified1.Qualified();
- Geom2dAdaptor_Curve Cu2 = Qualified2.Qualified();
+ Handle(Geom2dAdaptor_Curve) Cu1 = Qualified1.Qualified();
+ Handle(Geom2dAdaptor_Curve) Cu2 = Qualified2.Qualified();
math_Vector Umin(1,4);
math_Vector Umax(1,4);
math_Vector Ufirst(1,4);
}
Standard_Real Tol = Abs(Tolerance);
gp_Dir2d dirx(1.,0.);
- Geom2dAdaptor_Curve Cu1 = Qualified1.Qualified();
+ Handle(Geom2dAdaptor_Curve) Cu1 = Qualified1.Qualified();
math_Vector Umin(1,3);
math_Vector Umax(1,3);
math_Vector Ufirst(1,3);
Geom2dGcc_Circ2d2TanOnIter::
Geom2dGcc_Circ2d2TanOnIter (const Geom2dGcc_QCurve& Qualified1 ,
const Geom2dGcc_QCurve& Qualified2 ,
- const Geom2dAdaptor_Curve& OnCurv ,
+ const Handle(Geom2dAdaptor_Curve)& OnCurv ,
const Standard_Real Param1 ,
const Standard_Real Param2 ,
const Standard_Real Param3 ,
return;
}
gp_Dir2d dirx(1.,0.);
- Geom2dAdaptor_Curve Cu1 = Qualified1.Qualified();
- Geom2dAdaptor_Curve Cu2 = Qualified2.Qualified();
+ Handle(Geom2dAdaptor_Curve) Cu1 = Qualified1.Qualified();
+ Handle(Geom2dAdaptor_Curve) Cu2 = Qualified2.Qualified();
math_Vector Umin(1,4);
math_Vector Umax(1,4);
math_Vector Ufirst(1,4);
Geom2dGcc_Circ2d2TanOnIter::
Geom2dGcc_Circ2d2TanOnIter (const GccEnt_QualifiedCirc& Qualified1 ,
const Geom2dGcc_QCurve& Qualified2 ,
- const Geom2dAdaptor_Curve& OnCurv ,
+ const Handle(Geom2dAdaptor_Curve)& OnCurv ,
const Standard_Real Param1 ,
const Standard_Real Param2 ,
const Standard_Real ParamOn ,
Standard_Real Tol = Abs(Tolerance);
gp_Circ2d C1 = Qualified1.Qualified();
Standard_Real R1 = C1.Radius();
- Geom2dAdaptor_Curve Cu2 = Qualified2.Qualified();
+ Handle(Geom2dAdaptor_Curve) Cu2 = Qualified2.Qualified();
math_Vector Umin(1,4);
math_Vector Umax(1,4);
math_Vector Ufirst(1,4);
Geom2dGcc_Circ2d2TanOnIter::
Geom2dGcc_Circ2d2TanOnIter (const GccEnt_QualifiedLin& Qualified1 ,
const Geom2dGcc_QCurve& Qualified2 ,
- const Geom2dAdaptor_Curve& OnCurv ,
+ const Handle(Geom2dAdaptor_Curve)& OnCurv ,
const Standard_Real Param1 ,
const Standard_Real Param2 ,
const Standard_Real ParamOn ,
Standard_Real Tol = Abs(Tolerance);
gp_Dir2d dirx(1.,0.);
gp_Lin2d L1 = Qualified1.Qualified();
- Geom2dAdaptor_Curve Cu2 = Qualified2.Qualified();
+ Handle(Geom2dAdaptor_Curve) Cu2 = Qualified2.Qualified();
math_Vector Umin(1,4);
math_Vector Umax(1,4);
math_Vector Ufirst(1,4);
Geom2dGcc_Circ2d2TanOnIter::
Geom2dGcc_Circ2d2TanOnIter (const Geom2dGcc_QCurve& Qualified1 ,
const gp_Pnt2d& Point2 ,
- const Geom2dAdaptor_Curve& OnCurv ,
+ const Handle(Geom2dAdaptor_Curve)& OnCurv ,
const Standard_Real Param1 ,
const Standard_Real ParamOn ,
const Standard_Real Tolerance )
}
Standard_Real Tol = Abs(Tolerance);
gp_Dir2d dirx(1.,0.);
- Geom2dAdaptor_Curve Cu1 = Qualified1.Qualified();
+ Handle(Geom2dAdaptor_Curve) Cu1 = Qualified1.Qualified();
math_Vector Umin(1,3);
math_Vector Umax(1,3);
math_Vector Ufirst(1,3);
//! Param2 is the initial guess on the curve QualifiedCurv.
//! ParamOn is the initial guess on the center curve OnCurv.
//! Tolerance is used for the limit cases.
- Standard_EXPORT Geom2dGcc_Circ2d2TanOnIter(const GccEnt_QualifiedCirc& Qualified1, const Geom2dGcc_QCurve& Qualified2, const Geom2dAdaptor_Curve& OnCurv, const Standard_Real Param1, const Standard_Real Param2, const Standard_Real ParamOn, const Standard_Real Tolerance);
+ Standard_EXPORT Geom2dGcc_Circ2d2TanOnIter(const GccEnt_QualifiedCirc& Qualified1, const Geom2dGcc_QCurve& Qualified2, const Handle(Geom2dAdaptor_Curve)& OnCurv, const Standard_Real Param1, const Standard_Real Param2, const Standard_Real ParamOn, const Standard_Real Tolerance);
//! This method implements the algorithms used to
//! create 2d circles TANgent to a 2d line and a curve and
//! Param2 is the initial guess on the curve QualifiedCurv.
//! ParamOn is the initial guess on the center curve OnCurv.
//! Tolerance is used for the limit cases.
- Standard_EXPORT Geom2dGcc_Circ2d2TanOnIter(const GccEnt_QualifiedLin& Qualified1, const Geom2dGcc_QCurve& Qualified2, const Geom2dAdaptor_Curve& OnCurve, const Standard_Real Param1, const Standard_Real Param2, const Standard_Real ParamOn, const Standard_Real Tolerance);
+ Standard_EXPORT Geom2dGcc_Circ2d2TanOnIter(const GccEnt_QualifiedLin& Qualified1, const Geom2dGcc_QCurve& Qualified2, const Handle(Geom2dAdaptor_Curve)& OnCurve, const Standard_Real Param1, const Standard_Real Param2, const Standard_Real ParamOn, const Standard_Real Tolerance);
//! This method implements the algorithms used to
//! create 2d circles TANgent to a 2d Point and a curve and
//! Param1 is the initial guess on the curve QualifiedCurv.
//! ParamOn is the initial guess on the center curve OnCurv.
//! Tolerance is used for the limit cases.
- Standard_EXPORT Geom2dGcc_Circ2d2TanOnIter(const Geom2dGcc_QCurve& Qualified1, const gp_Pnt2d& Point2, const Geom2dAdaptor_Curve& OnCurve, const Standard_Real Param1, const Standard_Real ParamOn, const Standard_Real Tolerance);
+ Standard_EXPORT Geom2dGcc_Circ2d2TanOnIter(const Geom2dGcc_QCurve& Qualified1, const gp_Pnt2d& Point2, const Handle(Geom2dAdaptor_Curve)& OnCurve, const Standard_Real Param1, const Standard_Real ParamOn, const Standard_Real Tolerance);
//! This method implements the algorithms used to
//! create 2d circles TANgent to two curves and
//! Param1 is the initial guess on the second curve QualifiedCurv.
//! ParamOn is the initial guess on the center curve OnCurv.
//! Tolerance is used for the limit cases.
- Standard_EXPORT Geom2dGcc_Circ2d2TanOnIter(const Geom2dGcc_QCurve& Qualified1, const Geom2dGcc_QCurve& Qualified2, const Geom2dAdaptor_Curve& OnCurve, const Standard_Real Param1, const Standard_Real Param2, const Standard_Real ParamOn, const Standard_Real Tolerance);
+ Standard_EXPORT Geom2dGcc_Circ2d2TanOnIter(const Geom2dGcc_QCurve& Qualified1, const Geom2dGcc_QCurve& Qualified2, const Handle(Geom2dAdaptor_Curve)& OnCurve, const Standard_Real Param1, const Standard_Real Param2, const Standard_Real ParamOn, const Standard_Real Tolerance);
//! This method returns True if the construction
//! algorithm succeeded.
{
if (Radius < 0.) { throw Standard_NegativeValue(); }
else {
- Geom2dAdaptor_Curve C1 = Qualified1.Qualified();
- Geom2dAdaptor_Curve C2 = Qualified2.Qualified();
- Handle(Geom2d_Curve) CC1 = C1.Curve();
- Handle(Geom2d_Curve) CC2 = C2.Curve();
- GeomAbs_CurveType Type1 = C1.GetType();
- GeomAbs_CurveType Type2 = C2.GetType();
+ Handle(Geom2dAdaptor_Curve) C1 = Qualified1.Qualified();
+ Handle(Geom2dAdaptor_Curve) C2 = Qualified2.Qualified();
+ Handle(Geom2d_Curve) CC1 = C1->Curve();
+ Handle(Geom2d_Curve) CC2 = C2->Curve();
+ GeomAbs_CurveType Type1 = C1->GetType();
+ GeomAbs_CurveType Type2 = C2->GetType();
//=============================================================================
// Appel a GccAna. +
{
if (Radius < 0.) { throw Standard_NegativeValue(); }
else {
- Geom2dAdaptor_Curve C1 = Qualified1.Qualified();
- Handle(Geom2d_Curve) CC1 = C1.Curve();
- GeomAbs_CurveType Type1 = C1.GetType();
+ Handle(Geom2dAdaptor_Curve) C1 = Qualified1.Qualified();
+ Handle(Geom2d_Curve) CC1 = C1->Curve();
+ GeomAbs_CurveType Type1 = C1->GetType();
//=============================================================================
// Appel a GccAna. +
Standard_Real lyloc = (L1.Location()).Y();
gp_Pnt2d origin1(lxloc,lyloc);
gp_Dir2d normL1(-y1dir,x1dir);
- Geom2dAdaptor_Curve Cu2= Qualified2.Qualified();
+ Handle(Geom2dAdaptor_Curve) Cu2 = Qualified2.Qualified();
if (Radius < 0.0) { throw Standard_NegativeValue(); }
else {
if (Qualified1.IsEnclosed() && Qualified2.IsEnclosed()) {
gp_Lin2d Line(Point,L1.Direction()); // ligne avec deport.
IntRes2d_Domain D1;
for (Standard_Integer jcote2 = 1; jcote2 <= nbrcote2 && NbrSol < aNbSolMAX; jcote2++) {
- Handle(Geom2dAdaptor_Curve) HCu2 = new Geom2dAdaptor_Curve(Cu2);
//Adaptor2d_OffsetCurve C2(HCu2,cote2(jcote2));
- Adaptor2d_OffsetCurve C2(HCu2, -cote2(jcote2));
- firstparam = Max(C2.FirstParameter(),thefirst);
- lastparam = Min(C2.LastParameter(),thelast);
- IntRes2d_Domain D2(C2.Value(firstparam), firstparam, Tol,
- C2.Value(lastparam), lastparam, Tol);
+ Handle(Adaptor2d_OffsetCurve) C2 = new Adaptor2d_OffsetCurve(Cu2, -cote2(jcote2));
+ firstparam = Max(C2->FirstParameter(),thefirst);
+ lastparam = Min(C2->LastParameter(),thelast);
+ IntRes2d_Domain D2(C2->Value(firstparam), firstparam, Tol,
+ C2->Value(lastparam), lastparam, Tol);
Geom2dInt_TheIntConicCurveOfGInter Intp(Line,D1,C2,D2,Tol,Tol);
if (Intp.IsDone()) {
if (!Intp.IsEmpty()) {
}
gp_Circ2d C1 = Qualified1.Qualified();
gp_Pnt2d center1(C1.Location());
- Geom2dAdaptor_Curve Cu2 = Qualified2.Qualified();
+ Handle(Geom2dAdaptor_Curve) Cu2 = Qualified2.Qualified();
if (Radius < 0.0) { throw Standard_NegativeValue(); }
else {
if (Qualified1.IsEnclosed() && Qualified2.IsEnclosed()) {
ElCLib::Value(2.*M_PI,Circ),2.*M_PI,Tol);
D1.SetEquivalentParameters(0.,2.*M_PI);
for (Standard_Integer jcote2 = 1 ; jcote2 <= nbrcote2 ; jcote2++) {
- Handle(Geom2dAdaptor_Curve) HCu2 = new Geom2dAdaptor_Curve(Cu2);
//Adaptor2d_OffsetCurve C2(HCu2,cote2(jcote2));
- Adaptor2d_OffsetCurve C2(HCu2, -cote2(jcote2));
- firstparam = Max(C2.FirstParameter(),thefirst);
- lastparam = Min(C2.LastParameter(),thelast);
- IntRes2d_Domain D2(C2.Value(firstparam), firstparam, Tol,
- C2.Value(lastparam), lastparam, Tol);
+ Handle(Adaptor2d_OffsetCurve) C2 = new Adaptor2d_OffsetCurve(Cu2, -cote2(jcote2));
+ firstparam = Max(C2->FirstParameter(),thefirst);
+ lastparam = Min(C2->LastParameter(),thelast);
+ IntRes2d_Domain D2(C2->Value(firstparam), firstparam, Tol,
+ C2->Value(lastparam), lastparam, Tol);
Intp.Perform(Circ,D1,C2,D2,Tol,Tol);
if (Intp.IsDone()) {
if (!Intp.IsEmpty()) {
throw GccEnt_BadQualifier();
return;
}
- Geom2dAdaptor_Curve Cu1 = Qualified1.Qualified();
+ Handle(Geom2dAdaptor_Curve) Cu1 = Qualified1.Qualified();
if (Radius < 0.0) { throw Standard_NegativeValue(); }
else {
if (Qualified1.IsEnclosed()) {
D1.SetEquivalentParameters(0.,M_PI+M_PI);
Geom2dInt_TheIntConicCurveOfGInter Intp;
for (Standard_Integer jcote1 = 1; jcote1 <= nbrcote1 && NbrSol < aNbSolMAX; jcote1++) {
- Handle(Geom2dAdaptor_Curve) HCu1 = new Geom2dAdaptor_Curve(Cu1);
//Adaptor2d_OffsetCurve Cu2(HCu1,cote1(jcote1));
- Adaptor2d_OffsetCurve Cu2(HCu1,-cote1(jcote1));
- firstparam = Max(Cu2.FirstParameter(),thefirst);
- lastparam = Min(Cu2.LastParameter(),thelast);
- IntRes2d_Domain D2(Cu2.Value(firstparam), firstparam, Tol,
- Cu2.Value(lastparam), lastparam, Tol);
+ Handle(Adaptor2d_OffsetCurve) Cu2 = new Adaptor2d_OffsetCurve(Cu1,-cote1(jcote1));
+ firstparam = Max(Cu2->FirstParameter(),thefirst);
+ lastparam = Min(Cu2->LastParameter(),thelast);
+ IntRes2d_Domain D2(Cu2->Value(firstparam), firstparam, Tol,
+ Cu2->Value(lastparam), lastparam, Tol);
Intp.Perform(Circ,D1,Cu2,D2,Tol,Tol);
if (Intp.IsDone()) {
if (!Intp.IsEmpty()) {
// tangent vector and vector between points in two curves must
// be equal to zero).
//=======================================================================
-static void PrecRoot(const Adaptor2d_OffsetCurve& theC1,
- const Adaptor2d_OffsetCurve& theC2,
+static void PrecRoot(const Handle(Adaptor2d_OffsetCurve)& theC1,
+ const Handle(Adaptor2d_OffsetCurve)& theC2,
const Standard_Real theU0,
const Standard_Real theV0,
Standard_Real& theUfinal,
Standard_Real aSQDistPrev = RealFirst();
- theC1.D2(aU, aPu, aD1u, aD2u);
- theC2.D2(aV, aPv, aD1v, aD2v);
+ theC1->D2(aU, aPu, aD1u, aD2u);
+ theC2->D2(aV, aPv, aD1v, aD2v);
const Standard_Real aCrProd = Abs(aD1u.Crossed(aD1v));
if(aCrProd*aCrProd > 1.0e-6*
aV += aStepV;
}
- theC1.D2(aU, aPu, aD1u, aD2u);
- theC2.D2(aV, aPv, aD1v, aD2v);
+ theC1->D2(aU, aPu, aD1u, aD2u);
+ theC2->D2(aV, aPv, aD1v, aD2v);
}
while(aNbIter <= aNbIterMax);
}
throw GccEnt_BadQualifier();
return;
}
- Geom2dAdaptor_Curve Cu1 = Qualified1.Qualified();
- Geom2dAdaptor_Curve Cu2 = Qualified2.Qualified();
+ Handle(Geom2dAdaptor_Curve) Cu1 = Qualified1.Qualified();
+ Handle(Geom2dAdaptor_Curve) Cu2 = Qualified2.Qualified();
if (Radius < 0.0) { throw Standard_NegativeValue(); }
else {
if (Qualified1.IsEnclosed() && Qualified2.IsEnclosed()) {
}
Geom2dInt_GInter Intp;
for (Standard_Integer jcote1 = 1 ; jcote1 <= nbrcote1 ; jcote1++) {
- Handle(Geom2dAdaptor_Curve) HCu1 = new Geom2dAdaptor_Curve(Cu1);
//Adaptor2d_OffsetCurve C1(HCu1,cote1(jcote1));
- Adaptor2d_OffsetCurve C1(HCu1, -cote1(jcote1));
+ Handle(Adaptor2d_OffsetCurve) C1 = new Adaptor2d_OffsetCurve(Cu1, -cote1(jcote1));
#ifdef OCCT_DEBUG
Standard_Real firstparam = Max(C1.FirstParameter(), thefirst);
Standard_Real lastparam = Min(C1.LastParameter(), thelast);
C1.Value(lastparam),lastparam,Tol);
#endif
for (Standard_Integer jcote2 = 1; jcote2 <= nbrcote2 && NbrSol < aNbSolMAX; jcote2++) {
- Handle(Geom2dAdaptor_Curve) HCu2 = new Geom2dAdaptor_Curve(Cu2);
//Adaptor2d_OffsetCurve C2(HCu2,cote2(jcote2));
- Adaptor2d_OffsetCurve C2(HCu2, -cote2(jcote2));
+ Handle(Adaptor2d_OffsetCurve) C2 = new Adaptor2d_OffsetCurve(Cu2, -cote2(jcote2));
#ifdef OCCT_DEBUG
firstparam = Max(C2.FirstParameter(), thefirst);
lastparam = Min(C2.LastParameter(),thelast);
Standard_Real aU2 = aU0+Precision::PApproximation();
Standard_Real aV2 = aV0+Precision::PApproximation();
- gp_Pnt2d P11 = C1.Value(aU1);
- gp_Pnt2d P12 = C2.Value(aV1);
- gp_Pnt2d P21 = C1.Value(aU2);
- gp_Pnt2d P22 = C2.Value(aV2);
+ gp_Pnt2d P11 = C1->Value(aU1);
+ gp_Pnt2d P12 = C2->Value(aV1);
+ gp_Pnt2d P21 = C1->Value(aU2);
+ gp_Pnt2d P22 = C2->Value(aV2);
Standard_Real aDist1112 = P11.SquareDistance(P12);
Standard_Real aDist1122 = P11.SquareDistance(P22);
}
NbrSol++;
- gp_Pnt2d Center(C1.Value(aU0));
+ gp_Pnt2d Center(C1->Value(aU0));
cirsol(NbrSol) = gp_Circ2d(gp_Ax2d(Center,dirx),Radius);
// =======================================================
qualifier1(NbrSol) = Qualified1.Qualifier();
pararg2(1,16) ,
pararg3(1,16)
{
- Geom2dAdaptor_Curve C1 = Qualified1.Qualified();
- Geom2dAdaptor_Curve C2 = Qualified2.Qualified();
- Geom2dAdaptor_Curve C3 = Qualified3.Qualified();
- Handle(Geom2d_Curve) CC1 = C1.Curve();
- Handle(Geom2d_Curve) CC2 = C2.Curve();
- Handle(Geom2d_Curve) CC3 = C3.Curve();
- GeomAbs_CurveType Type1 = C1.GetType();
- GeomAbs_CurveType Type2 = C2.GetType();
- GeomAbs_CurveType Type3 = C3.GetType();
+ Handle(Geom2dAdaptor_Curve) C1 = Qualified1.Qualified();
+ Handle(Geom2dAdaptor_Curve) C2 = Qualified2.Qualified();
+ Handle(Geom2dAdaptor_Curve) C3 = Qualified3.Qualified();
+ Handle(Geom2d_Curve) CC1 = C1->Curve();
+ Handle(Geom2d_Curve) CC2 = C2->Curve();
+ Handle(Geom2d_Curve) CC3 = C3->Curve();
+ GeomAbs_CurveType Type1 = C1->GetType();
+ GeomAbs_CurveType Type2 = C2->GetType();
+ GeomAbs_CurveType Type3 = C3->GetType();
//=============================================================================
// Appel a GccAna. +
pararg2(1,20) ,
pararg3(1,20)
{
- Geom2dAdaptor_Curve C1 = Qualified1.Qualified();
- Geom2dAdaptor_Curve C2 = Qualified2.Qualified();
- Handle(Geom2d_Curve) CC1 = C1.Curve();
- Handle(Geom2d_Curve) CC2 = C2.Curve();
- GeomAbs_CurveType Type1 = C1.GetType();
- GeomAbs_CurveType Type2 = C2.GetType();
+ Handle(Geom2dAdaptor_Curve) C1 = Qualified1.Qualified();
+ Handle(Geom2dAdaptor_Curve) C2 = Qualified2.Qualified();
+ Handle(Geom2d_Curve) CC1 = C1->Curve();
+ Handle(Geom2d_Curve) CC2 = C2->Curve();
+ GeomAbs_CurveType Type1 = C1->GetType();
+ GeomAbs_CurveType Type2 = C2->GetType();
//=============================================================================
// Appel a GccAna. +
pararg2(1,16) ,
pararg3(1,16)
{
- Geom2dAdaptor_Curve C1 = Qualified1.Qualified();
- Handle(Geom2d_Curve) CC1 = C1.Curve();
- GeomAbs_CurveType Type1 = C1.GetType();
+ Handle(Geom2dAdaptor_Curve) C1 = Qualified1.Qualified();
+ Handle(Geom2d_Curve) CC1 = C1->Curve();
+ GeomAbs_CurveType Type1 = C1->GetType();
//=============================================================================
// Appel a GccAna. +
throw GccEnt_BadQualifier();
return;
}
- Geom2dAdaptor_Curve Cu1 = Qualified1.Qualified();
- Geom2dAdaptor_Curve Cu2 = Qualified2.Qualified();
- Geom2dAdaptor_Curve Cu3 = Qualified3.Qualified();
+ Handle(Geom2dAdaptor_Curve) Cu1 = Qualified1.Qualified();
+ Handle(Geom2dAdaptor_Curve) Cu2 = Qualified2.Qualified();
+ Handle(Geom2dAdaptor_Curve) Cu3 = Qualified3.Qualified();
Geom2dGcc_FunctionTanCuCuCu Func(Cu1,Cu2,Cu3);
math_Vector Umin(1,3);
math_Vector Umax(1,3);
return;
}
gp_Circ2d C1 = Qualified1.Qualified();
- Geom2dAdaptor_Curve Cu2 = Qualified2.Qualified();
- Geom2dAdaptor_Curve Cu3 = Qualified3.Qualified();
+ Handle(Geom2dAdaptor_Curve) Cu2 = Qualified2.Qualified();
+ Handle(Geom2dAdaptor_Curve) Cu3 = Qualified3.Qualified();
Geom2dGcc_FunctionTanCuCuCu Func(C1,Cu2,Cu3);
math_Vector Umin(1,3);
math_Vector Umax(1,3);
}
gp_Circ2d C1 = Qualified1.Qualified();
gp_Circ2d C2 = Qualified2.Qualified();
- Geom2dAdaptor_Curve Cu3 = Qualified3.Qualified();
+ Handle(Geom2dAdaptor_Curve) Cu3 = Qualified3.Qualified();
Geom2dGcc_FunctionTanCuCuCu Func(C1,C2,Cu3);
math_Vector Umin(1,3);
math_Vector Umax(1,3);
return;
}
gp_Lin2d L1 = Qualified1.Qualified();
- Geom2dAdaptor_Curve Cu2 = Qualified2.Qualified();
- Geom2dAdaptor_Curve Cu3 = Qualified3.Qualified();
+ Handle(Geom2dAdaptor_Curve) Cu2 = Qualified2.Qualified();
+ Handle(Geom2dAdaptor_Curve) Cu3 = Qualified3.Qualified();
Geom2dGcc_FunctionTanCuCuCu Func(L1,Cu2,Cu3);
math_Vector Umin(1,3);
math_Vector Umax(1,3);
}
gp_Lin2d L1 = Qualified1.Qualified();
gp_Lin2d L2 = Qualified2.Qualified();
- Geom2dAdaptor_Curve Cu3 = Qualified3.Qualified();
+ Handle(Geom2dAdaptor_Curve) Cu3 = Qualified3.Qualified();
Geom2dGcc_FunctionTanCuCuCu Func(L1,L2,Cu3);
math_Vector Umin(1,3);
math_Vector Umax(1,3);
return;
}
gp_Circ2d C1(gp_Ax2d(Point3,gp_Dir2d(1.,0.)),0.);
- Geom2dAdaptor_Curve Cu1 = Qualified1.Qualified();
- Geom2dAdaptor_Curve Cu2 = Qualified2.Qualified();
+ Handle(Geom2dAdaptor_Curve) Cu1 = Qualified1.Qualified();
+ Handle(Geom2dAdaptor_Curve) Cu2 = Qualified2.Qualified();
Geom2dGcc_FunctionTanCuCuCu Func(C1,Cu1,Cu2);
math_Vector Umin(1,3);
math_Vector Umax(1,3);
gp_Dir2d dirx(1.,0.);
gp_Circ2d C1(gp_Ax2d(Point2,dirx),0.);
gp_Circ2d C2(gp_Ax2d(Point3,dirx),0.);
- Geom2dAdaptor_Curve Cu1 = Qualified1.Qualified();
+ Handle(Geom2dAdaptor_Curve) Cu1 = Qualified1.Qualified();
Geom2dGcc_FunctionTanCuCuCu Func(C1,C2,Cu1);
math_Vector Umin(1,3);
math_Vector Umax(1,3);
}
gp_Dir2d dirx(1.,0.);
gp_Lin2d L1 = Qualified1.Qualified();
- Geom2dAdaptor_Curve Cu2 = Qualified2.Qualified();
+ Handle(Geom2dAdaptor_Curve) Cu2 = Qualified2.Qualified();
gp_Circ2d C3(gp_Ax2d(Point3,dirx),0.);
Geom2dGcc_FunctionTanCuCuCu Func(C3,L1,Cu2);
math_Vector Umin(1,3);
}
gp_Circ2d C1 = Qualified1.Qualified();
gp_Lin2d L2 = Qualified2.Qualified();
- Geom2dAdaptor_Curve Cu3 = Qualified3.Qualified();
+ Handle(Geom2dAdaptor_Curve) Cu3 = Qualified3.Qualified();
Geom2dGcc_FunctionTanCuCuCu Func(C1,L2,Cu3);
math_Vector Umin(1,3);
math_Vector Umax(1,3);
return;
}
gp_Circ2d C1 = Qualified1.Qualified();
- Geom2dAdaptor_Curve Cu2 = Qualified2.Qualified();
+ Handle(Geom2dAdaptor_Curve) Cu2 = Qualified2.Qualified();
gp_Dir2d dirx(1.,0.);
gp_Circ2d C3(gp_Ax2d(Point3,dirx),0.);
Geom2dGcc_FunctionTanCuCuCu Func(C1,C3,Cu2);
par1sol(1,2) ,
pararg1(1,2)
{
- Geom2dAdaptor_Curve C1 = Qualified1.Qualified();
- Handle(Geom2d_Curve) CC1 = C1.Curve();
- GeomAbs_CurveType Type1 = C1.GetType();
+ Handle(Geom2dAdaptor_Curve) C1 = Qualified1.Qualified();
+ Handle(Geom2d_Curve) CC1 = C1->Curve();
+ GeomAbs_CurveType Type1 = C1->GetType();
//=============================================================================
// Appel a GccAna. +
Standard_Integer nbsol = 0;
gp_Dir2d dirx(1.0,0.0);
Standard_Real thePar;
- Geom2dAdaptor_Curve curve = Qualified1.Qualified();
+ Handle(Geom2dAdaptor_Curve) curve = Qualified1.Qualified();
Extrema_ExtPC2d distmin(Pcenter, curve, Geom2dGcc_CurveTool::FirstParameter(curve),
Geom2dGcc_CurveTool::LastParameter(curve), Tol);
if (!distmin.IsDone() ) { throw Standard_Failure(); }
Geom2dGcc_Circ2dTanOnRad::
Geom2dGcc_Circ2dTanOnRad (const Geom2dGcc_QualifiedCurve& Qualified1 ,
- const Geom2dAdaptor_Curve& OnCurve ,
+ const Handle(Geom2dAdaptor_Curve)& OnCurve ,
const Standard_Real Radius ,
const Standard_Real Tolerance ):
cirsol(1,8) ,
throw Standard_NegativeValue();
}
else {
- Geom2dAdaptor_Curve C1 = Qualified1.Qualified();
- GeomAbs_CurveType Type1 = C1.GetType();
- GeomAbs_CurveType Type2 = OnCurve.GetType();
- Handle(Geom2d_Curve) CC1 = C1.Curve();
- Handle(Geom2d_Curve) Con = OnCurve.Curve();
+ Handle(Geom2dAdaptor_Curve) C1 = Qualified1.Qualified();
+ GeomAbs_CurveType Type1 = C1->GetType();
+ GeomAbs_CurveType Type2 = OnCurve->GetType();
+ Handle(Geom2d_Curve) CC1 = C1->Curve();
+ Handle(Geom2d_Curve) Con = OnCurve->Curve();
//=============================================================================
// Appel a GccAna. +
Geom2dGcc_Circ2dTanOnRad::
Geom2dGcc_Circ2dTanOnRad (const Handle(Geom2d_Point)& Point1 ,
- const Geom2dAdaptor_Curve& OnCurve ,
+ const Handle(Geom2dAdaptor_Curve)& OnCurve ,
const Standard_Real Radius ,
const Standard_Real Tolerance ):
cirsol(1,8) ,
}
else {
gp_Pnt2d point1(Point1->Pnt2d());
- GeomAbs_CurveType Type2 = OnCurve.GetType();
- Handle(Geom2d_Curve) Con = OnCurve.Curve();
+ GeomAbs_CurveType Type2 = OnCurve->GetType();
+ Handle(Geom2d_Curve) Con = OnCurve->Curve();
//=============================================================================
// Appel a GccAna. +
//! Constructs one or more 2D circles of radius Radius,
//! centered on the 2D curve OnCurv and:
//! - tangential to the curve Qualified1
- Standard_EXPORT Geom2dGcc_Circ2dTanOnRad(const Geom2dGcc_QualifiedCurve& Qualified1, const Geom2dAdaptor_Curve& OnCurv, const Standard_Real Radius, const Standard_Real Tolerance);
+ Standard_EXPORT Geom2dGcc_Circ2dTanOnRad(const Geom2dGcc_QualifiedCurve& Qualified1, const Handle(Geom2dAdaptor_Curve)& OnCurv, const Standard_Real Radius, const Standard_Real Tolerance);
//! Constructs one or more 2D circles of radius Radius,
//! centered on the 2D curve OnCurv and:
//! ...
//! }
//! }
- Standard_EXPORT Geom2dGcc_Circ2dTanOnRad(const Handle(Geom2d_Point)& Point1, const Geom2dAdaptor_Curve& OnCurv, const Standard_Real Radius, const Standard_Real Tolerance);
+ Standard_EXPORT Geom2dGcc_Circ2dTanOnRad(const Handle(Geom2d_Point)& Point1, const Handle(Geom2dAdaptor_Curve)& OnCurv, const Standard_Real Radius, const Standard_Real Tolerance);
Standard_EXPORT void Results (const GccAna_Circ2dTanOnRad& Circ);
}
Standard_Integer nbrcote1 = 0;
TColStd_Array1OfReal Coef(1,2);
- Geom2dAdaptor_Curve Cu1 = Qualified1.Qualified();
+ Handle(Geom2dAdaptor_Curve) Cu1 = Qualified1.Qualified();
if (Radius < 0.0) { throw Standard_NegativeValue(); }
else {
IntRes2d_Domain D1;
Geom2dInt_TheIntConicCurveOfGInter Intp;
for (Standard_Integer jcote1 = 1 ; jcote1 <= nbrcote1 ; jcote1++) {
- Handle(Geom2dAdaptor_Curve) HCu1 = new Geom2dAdaptor_Curve(Cu1);
//Adaptor2d_OffsetCurve C2(HCu1,Coef(jcote1));
- Adaptor2d_OffsetCurve C2(HCu1, -Coef(jcote1));
- firstparam = Max(C2.FirstParameter(),thefirst);
- lastparam = Min(C2.LastParameter(),thelast);
- IntRes2d_Domain D2(C2.Value(firstparam), firstparam, Tol,
- C2.Value(lastparam), lastparam, Tol);
+ Handle(Adaptor2d_OffsetCurve) C2 = new Adaptor2d_OffsetCurve(Cu1, -Coef(jcote1));
+ firstparam = Max(C2->FirstParameter(),thefirst);
+ lastparam = Min(C2->LastParameter(),thelast);
+ IntRes2d_Domain D2(C2->Value(firstparam), firstparam, Tol,
+ C2->Value(lastparam), lastparam, Tol);
Intp.Perform(OnLine,D1,C2,D2,Tol,Tol);
if (Intp.IsDone()) {
if (!Intp.IsEmpty()) {
return;
}
TColStd_Array1OfReal cote1(1,2);
- Geom2dAdaptor_Curve Cu1 = Qualified1.Qualified();
+ Handle(Geom2dAdaptor_Curve) Cu1 = Qualified1.Qualified();
if (Radius < 0.0) {
throw Standard_NegativeValue();
D1.SetEquivalentParameters(0.,2.*M_PI);
Geom2dInt_TheIntConicCurveOfGInter Intp;
for (Standard_Integer jcote1 = 1 ; jcote1 <= nbrcote1 ; jcote1++) {
- Handle(Geom2dAdaptor_Curve) HCu1 = new Geom2dAdaptor_Curve(Cu1);
- //Adaptor2d_OffsetCurve C2(HCu1,cote1(jcote1));
- Adaptor2d_OffsetCurve C2(HCu1, -cote1(jcote1));
- firstparam = Max(C2.FirstParameter(),thefirst);
- lastparam = Min(C2.LastParameter(),thelast);
- IntRes2d_Domain D2(C2.Value(firstparam),firstparam,Tol,
- C2.Value(lastparam),lastparam,Tol);
+ //Adaptor2d_OffsetCurve C2(Cu1,cote1(jcote1));
+ Handle(Adaptor2d_OffsetCurve) C2 = new Adaptor2d_OffsetCurve(Cu1, -cote1(jcote1));
+ firstparam = Max(C2->FirstParameter(),thefirst);
+ lastparam = Min(C2->LastParameter(),thelast);
+ IntRes2d_Domain D2(C2->Value(firstparam),firstparam,Tol,
+ C2->Value(lastparam),lastparam,Tol);
Intp.Perform(OnCirc,D1,C2,D2,Tol,Tol);
if (Intp.IsDone()) {
if (!Intp.IsEmpty()) {
Geom2dGcc_Circ2dTanOnRadGeo::
Geom2dGcc_Circ2dTanOnRadGeo (const GccEnt_QualifiedCirc& Qualified1,
- const Geom2dAdaptor_Curve& OnCurv ,
+ const Handle(Geom2dAdaptor_Curve)& OnCurv ,
const Standard_Real Radius ,
const Standard_Real Tolerance ):
Geom2dGcc_Circ2dTanOnRadGeo::
Geom2dGcc_Circ2dTanOnRadGeo (const GccEnt_QualifiedLin& Qualified1,
- const Geom2dAdaptor_Curve& OnCurv ,
+ const Handle(Geom2dAdaptor_Curve)& OnCurv ,
const Standard_Real Radius ,
const Standard_Real Tolerance ):
Geom2dGcc_Circ2dTanOnRadGeo::
Geom2dGcc_Circ2dTanOnRadGeo (const Geom2dGcc_QCurve& Qualified1,
- const Geom2dAdaptor_Curve& OnCurv ,
+ const Handle(Geom2dAdaptor_Curve)& OnCurv ,
const Standard_Real Radius ,
const Standard_Real Tolerance ):
return;
}
TColStd_Array1OfReal cote1(1,2);
- Geom2dAdaptor_Curve Cu1 = Qualified1.Qualified();
+ Handle(Geom2dAdaptor_Curve) Cu1 = Qualified1.Qualified();
if (Radius < 0.0) {
throw Standard_NegativeValue();
}
Geom2dInt_GInter Intp;
for (Standard_Integer jcote1 = 1 ; jcote1 <= nbrcote1 ; jcote1++) {
- Handle(Geom2dAdaptor_Curve) HCu1 = new Geom2dAdaptor_Curve(Cu1);
- //Adaptor2d_OffsetCurve C1(HCu1,cote1(jcote1));
- Adaptor2d_OffsetCurve C1(HCu1, -cote1(jcote1));
- firstparam = Max(C1.FirstParameter(),thefirst);
- lastparam = Min(C1.LastParameter(),thelast);
- IntRes2d_Domain D1(C1.Value(firstparam), firstparam, Tol,
- C1.Value(lastparam), lastparam, Tol);
- Handle(Geom2dAdaptor_Curve) HOnCurv = new Geom2dAdaptor_Curve(OnCurv);
- Adaptor2d_OffsetCurve C2(HOnCurv);
- firstparam = Max(C2.FirstParameter(),thefirst);
- lastparam = Min(C2.LastParameter(),thelast);
- IntRes2d_Domain D2(C2.Value(firstparam), firstparam, Tol,
- C2.Value(lastparam), lastparam, Tol);
+ //Adaptor2d_OffsetCurve C1(Cu1,cote1(jcote1));
+ Handle(Adaptor2d_OffsetCurve) C1 = new Adaptor2d_OffsetCurve(Cu1, -cote1(jcote1));
+ firstparam = Max(C1->FirstParameter(),thefirst);
+ lastparam = Min(C1->LastParameter(),thelast);
+ IntRes2d_Domain D1(C1->Value(firstparam), firstparam, Tol,
+ C1->Value(lastparam), lastparam, Tol);
+ Handle(Adaptor2d_OffsetCurve) C2 = new Adaptor2d_OffsetCurve(OnCurv);
+ firstparam = Max(C2->FirstParameter(),thefirst);
+ lastparam = Min(C2->LastParameter(),thelast);
+ IntRes2d_Domain D2(C2->Value(firstparam), firstparam, Tol,
+ C2->Value(lastparam), lastparam, Tol);
Intp.Perform(C1,D1,C2,D2,Tol,Tol);
if (Intp.IsDone()) {
if (!Intp.IsEmpty()) {
Geom2dGcc_Circ2dTanOnRadGeo::
Geom2dGcc_Circ2dTanOnRadGeo (const gp_Pnt2d& Point1 ,
- const Geom2dAdaptor_Curve& OnCurv ,
+ const Handle(Geom2dAdaptor_Curve)& OnCurv ,
const Standard_Real Radius ,
const Standard_Real Tolerance ):
//! with a given radius.
//! Tolerance is used to find solution in every limit cases.
//! raises NegativeValue in case of NegativeRadius.
- Standard_EXPORT Geom2dGcc_Circ2dTanOnRadGeo(const GccEnt_QualifiedCirc& Qualified1, const Geom2dAdaptor_Curve& OnCurv, const Standard_Real Radius, const Standard_Real Tolerance);
+ Standard_EXPORT Geom2dGcc_Circ2dTanOnRadGeo(const GccEnt_QualifiedCirc& Qualified1, const Handle(Geom2dAdaptor_Curve)& OnCurv, const Standard_Real Radius, const Standard_Real Tolerance);
//! This methods implements the algorithms used to create
//! 2d Circles tangent to a 2d Line and centered on a 2d curve
//! with a given radius.
//! Tolerance is used to find solution in every limit cases.
//! raises NegativeValue in case of NegativeRadius.
- Standard_EXPORT Geom2dGcc_Circ2dTanOnRadGeo(const GccEnt_QualifiedLin& Qualified1, const Geom2dAdaptor_Curve& OnCurv, const Standard_Real Radius, const Standard_Real Tolerance);
+ Standard_EXPORT Geom2dGcc_Circ2dTanOnRadGeo(const GccEnt_QualifiedLin& Qualified1, const Handle(Geom2dAdaptor_Curve)& OnCurv, const Standard_Real Radius, const Standard_Real Tolerance);
//! This methods implements the algorithms used to create
//! 2d Circles tangent to a 2d curve and centered on a 2d curve
//! with a given radius.
//! Tolerance is used to find solution in every limit cases.
//! raises NegativeValue in case of NegativeRadius.
- Standard_EXPORT Geom2dGcc_Circ2dTanOnRadGeo(const Geom2dGcc_QCurve& Qualified1, const Geom2dAdaptor_Curve& OnCurv, const Standard_Real Radius, const Standard_Real Tolerance);
+ Standard_EXPORT Geom2dGcc_Circ2dTanOnRadGeo(const Geom2dGcc_QCurve& Qualified1, const Handle(Geom2dAdaptor_Curve)& OnCurv, const Standard_Real Radius, const Standard_Real Tolerance);
//! This methods implements the algorithms used to create
//! 2d Circles passing through a 2d point and centered on a
//! 2d curve with a given radius.
//! Tolerance is used to find solution in every limit cases.
//! raises NegativeValue in case of NegativeRadius.
- Standard_EXPORT Geom2dGcc_Circ2dTanOnRadGeo(const gp_Pnt2d& Point1, const Geom2dAdaptor_Curve& OnCurv, const Standard_Real Radius, const Standard_Real Tolerance);
+ Standard_EXPORT Geom2dGcc_Circ2dTanOnRadGeo(const gp_Pnt2d& Point1, const Handle(Geom2dAdaptor_Curve)& OnCurv, const Standard_Real Radius, const Standard_Real Tolerance);
//! This method returns True if the construction
//! algorithm succeeded.
//Template a respecter
Standard_Real Geom2dGcc_CurveTool::
- EpsX (const Geom2dAdaptor_Curve& C ,
+ EpsX (const Handle(Geom2dAdaptor_Curve)& C ,
const Standard_Real Tol) {
- return C.Resolution(Tol);
+ return C->Resolution(Tol);
}
Standard_Integer Geom2dGcc_CurveTool::
- NbSamples (const Geom2dAdaptor_Curve& /*C*/) {
+ NbSamples (const Handle(Geom2dAdaptor_Curve)& /*C*/) {
return 20;
}
-gp_Pnt2d Geom2dGcc_CurveTool::Value (const Geom2dAdaptor_Curve& C,
+gp_Pnt2d Geom2dGcc_CurveTool::Value (const Handle(Geom2dAdaptor_Curve)& C,
const Standard_Real U) {
- return C.Value(U);
+ return C->Value(U);
}
Standard_Real
- Geom2dGcc_CurveTool::FirstParameter (const Geom2dAdaptor_Curve& C) {
- return C.FirstParameter();
+ Geom2dGcc_CurveTool::FirstParameter (const Handle(Geom2dAdaptor_Curve)& C) {
+ return C->FirstParameter();
}
Standard_Real
- Geom2dGcc_CurveTool::LastParameter (const Geom2dAdaptor_Curve& C) {
- return C.LastParameter();
+ Geom2dGcc_CurveTool::LastParameter (const Handle(Geom2dAdaptor_Curve)& C) {
+ return C->LastParameter();
}
-void Geom2dGcc_CurveTool::D1 (const Geom2dAdaptor_Curve& C,
+void Geom2dGcc_CurveTool::D1 (const Handle(Geom2dAdaptor_Curve)& C,
const Standard_Real U,
gp_Pnt2d& P,
gp_Vec2d& T) {
- C.D1(U,P,T);
+ C->D1(U,P,T);
}
-void Geom2dGcc_CurveTool::D2 (const Geom2dAdaptor_Curve& C,
+void Geom2dGcc_CurveTool::D2 (const Handle(Geom2dAdaptor_Curve)& C,
const Standard_Real U,
gp_Pnt2d& P,
gp_Vec2d& T,
gp_Vec2d& N) {
- C.D2(U,P,T,N);
+ C->D2(U,P,T,N);
}
-void Geom2dGcc_CurveTool::D3 (const Geom2dAdaptor_Curve& C ,
+void Geom2dGcc_CurveTool::D3 (const Handle(Geom2dAdaptor_Curve)& C ,
const Standard_Real U ,
gp_Pnt2d& P ,
gp_Vec2d& T ,
gp_Vec2d& N ,
gp_Vec2d& dN) {
- C.D3(U,P,T,N,dN);
+ C->D3(U,P,T,N,dN);
}
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
#include <Standard_Integer.hxx>
class Geom2dAdaptor_Curve;
DEFINE_STANDARD_ALLOC
- Standard_EXPORT static Standard_Real FirstParameter (const Geom2dAdaptor_Curve& C);
+ Standard_EXPORT static Standard_Real FirstParameter (const Handle(Geom2dAdaptor_Curve)& C);
- Standard_EXPORT static Standard_Real LastParameter (const Geom2dAdaptor_Curve& C);
+ Standard_EXPORT static Standard_Real LastParameter (const Handle(Geom2dAdaptor_Curve)& C);
- Standard_EXPORT static Standard_Real EpsX (const Geom2dAdaptor_Curve& C, const Standard_Real Tol);
+ Standard_EXPORT static Standard_Real EpsX (const Handle(Geom2dAdaptor_Curve)& C, const Standard_Real Tol);
- Standard_EXPORT static Standard_Integer NbSamples (const Geom2dAdaptor_Curve& C);
+ Standard_EXPORT static Standard_Integer NbSamples (const Handle(Geom2dAdaptor_Curve)& C);
- Standard_EXPORT static gp_Pnt2d Value (const Geom2dAdaptor_Curve& C, const Standard_Real X);
+ Standard_EXPORT static gp_Pnt2d Value (const Handle(Geom2dAdaptor_Curve)& C, const Standard_Real X);
- Standard_EXPORT static void D1 (const Geom2dAdaptor_Curve& C, const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& T);
+ Standard_EXPORT static void D1 (const Handle(Geom2dAdaptor_Curve)& C, const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& T);
- Standard_EXPORT static void D2 (const Geom2dAdaptor_Curve& C, const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& T, gp_Vec2d& N);
+ Standard_EXPORT static void D2 (const Handle(Geom2dAdaptor_Curve)& C, const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& T, gp_Vec2d& N);
- Standard_EXPORT static void D3 (const Geom2dAdaptor_Curve& C, const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& T, gp_Vec2d& N, gp_Vec2d& dN);
+ Standard_EXPORT static void D3 (const Handle(Geom2dAdaptor_Curve)& C, const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& T, gp_Vec2d& N, gp_Vec2d& dN);
//=========================================================================
Geom2dGcc_FunctionTanCirCu::
Geom2dGcc_FunctionTanCirCu(const gp_Circ2d& Circ ,
- const Geom2dAdaptor_Curve& Curv ) {
+ const Handle(Geom2dAdaptor_Curve)& Curv ) {
Curve = Curv;
TheCirc = Circ;
DEFINE_STANDARD_ALLOC
- Standard_EXPORT Geom2dGcc_FunctionTanCirCu(const gp_Circ2d& Circ, const Geom2dAdaptor_Curve& Curv);
+ Standard_EXPORT Geom2dGcc_FunctionTanCirCu(const gp_Circ2d& Circ, const Handle(Geom2dAdaptor_Curve)& Curv);
//! Computes the value of the function F for the variable X.
//! It returns True if the computation is successfully done,
gp_Circ2d TheCirc;
- Geom2dAdaptor_Curve Curve;
+ Handle(Geom2dAdaptor_Curve) Curve;
Standard_Real myWeight;
}
Geom2dGcc_FunctionTanCuCu::
-Geom2dGcc_FunctionTanCuCu(const Geom2dAdaptor_Curve& C1 ,
- const Geom2dAdaptor_Curve& C2 ) {
+Geom2dGcc_FunctionTanCuCu(const Handle(Geom2dAdaptor_Curve)& C1 ,
+ const Handle(Geom2dAdaptor_Curve)& C2 ) {
TheCurve1 = C1;
TheCurve2 = C2;
TheType = Geom2dGcc_CuCu;
Geom2dGcc_FunctionTanCuCu::
Geom2dGcc_FunctionTanCuCu(const gp_Circ2d& C1 ,
- const Geom2dAdaptor_Curve& C2 ) {
+ const Handle(Geom2dAdaptor_Curve)& C2 ) {
TheCirc1 = C1;
+ TheCurve1 = new Geom2dAdaptor_Curve();
TheCurve2 = C2;
TheType = Geom2dGcc_CiCu;
}
DEFINE_STANDARD_ALLOC
- Standard_EXPORT Geom2dGcc_FunctionTanCuCu(const Geom2dAdaptor_Curve& Curv1, const Geom2dAdaptor_Curve& Curv2);
+ Standard_EXPORT Geom2dGcc_FunctionTanCuCu(const Handle(Geom2dAdaptor_Curve)& Curv1, const Handle(Geom2dAdaptor_Curve)& Curv2);
- Standard_EXPORT Geom2dGcc_FunctionTanCuCu(const gp_Circ2d& Circ1, const Geom2dAdaptor_Curve& Curv2);
+ Standard_EXPORT Geom2dGcc_FunctionTanCuCu(const gp_Circ2d& Circ1, const Handle(Geom2dAdaptor_Curve)& Curv2);
Standard_EXPORT void InitDerivative (const math_Vector& X, gp_Pnt2d& Point1, gp_Pnt2d& Point2, gp_Vec2d& Tan1, gp_Vec2d& Tan2, gp_Vec2d& D21, gp_Vec2d& D22);
- Geom2dAdaptor_Curve TheCurve1;
- Geom2dAdaptor_Curve TheCurve2;
+ Handle(Geom2dAdaptor_Curve) TheCurve1;
+ Handle(Geom2dAdaptor_Curve) TheCurve2;
gp_Circ2d TheCirc1;
Geom2dGcc_Type3 TheType;
}
Geom2dGcc_FunctionTanCuCuCu::
-Geom2dGcc_FunctionTanCuCuCu(const Geom2dAdaptor_Curve& C1 ,
- const Geom2dAdaptor_Curve& C2 ,
- const Geom2dAdaptor_Curve& C3 ) {
+Geom2dGcc_FunctionTanCuCuCu(const Handle(Geom2dAdaptor_Curve)& C1 ,
+ const Handle(Geom2dAdaptor_Curve)& C2 ,
+ const Handle(Geom2dAdaptor_Curve)& C3 ) {
Curv1 = C1;
Curv2 = C2;
Curv3 = C3;
Geom2dGcc_FunctionTanCuCuCu::
Geom2dGcc_FunctionTanCuCuCu(const gp_Circ2d& C1 ,
- const Geom2dAdaptor_Curve& C2 ,
- const Geom2dAdaptor_Curve& C3 ) {
+ const Handle(Geom2dAdaptor_Curve)& C2 ,
+ const Handle(Geom2dAdaptor_Curve)& C3 ) {
Circ1 = C1;
+ Curv1 = new Geom2dAdaptor_Curve();
Curv2 = C2;
Curv3 = C3;
TheType = Geom2dGcc_CiCuCu;
Geom2dGcc_FunctionTanCuCuCu::
Geom2dGcc_FunctionTanCuCuCu(const gp_Circ2d& C1 ,
const gp_Circ2d& C2 ,
- const Geom2dAdaptor_Curve& C3 ) {
+ const Handle(Geom2dAdaptor_Curve)& C3 ) {
Circ1 = C1;
Circ2 = C2;
Curv3 = C3;
Geom2dGcc_FunctionTanCuCuCu::
Geom2dGcc_FunctionTanCuCuCu(const gp_Circ2d& C1 ,
const gp_Lin2d& L2 ,
- const Geom2dAdaptor_Curve& C3 ) {
+ const Handle(Geom2dAdaptor_Curve)& C3 ) {
Circ1 = C1;
Lin2 = L2;
+ Curv1 = new Geom2dAdaptor_Curve();
+ Curv2 = new Geom2dAdaptor_Curve();
Curv3 = C3;
TheType = Geom2dGcc_CiLiCu;
}
Geom2dGcc_FunctionTanCuCuCu::
Geom2dGcc_FunctionTanCuCuCu(const gp_Lin2d& L1 ,
const gp_Lin2d& L2 ,
- const Geom2dAdaptor_Curve& C3 ) {
+ const Handle(Geom2dAdaptor_Curve)& C3 ) {
Lin1 = L1;
Lin2 = L2;
+ Curv1 = new Geom2dAdaptor_Curve();
+ Curv2 = new Geom2dAdaptor_Curve();
Curv3 = C3;
TheType = Geom2dGcc_LiLiCu;
}
Geom2dGcc_FunctionTanCuCuCu::
Geom2dGcc_FunctionTanCuCuCu(const gp_Lin2d& L1 ,
- const Geom2dAdaptor_Curve& C2 ,
- const Geom2dAdaptor_Curve& C3 ) {
+ const Handle(Geom2dAdaptor_Curve)& C2 ,
+ const Handle(Geom2dAdaptor_Curve)& C3 ) {
Lin1 = L1;
+ Curv1 = new Geom2dAdaptor_Curve();
Curv2 = C2;
Curv3 = C3;
TheType = Geom2dGcc_LiCuCu;
DEFINE_STANDARD_ALLOC
- Standard_EXPORT Geom2dGcc_FunctionTanCuCuCu(const Geom2dAdaptor_Curve& C1, const Geom2dAdaptor_Curve& C2, const Geom2dAdaptor_Curve& C3);
+ Standard_EXPORT Geom2dGcc_FunctionTanCuCuCu(const Handle(Geom2dAdaptor_Curve)& C1, const Handle(Geom2dAdaptor_Curve)& C2, const Handle(Geom2dAdaptor_Curve)& C3);
- Standard_EXPORT Geom2dGcc_FunctionTanCuCuCu(const gp_Circ2d& C1, const Geom2dAdaptor_Curve& C2, const Geom2dAdaptor_Curve& C3);
+ Standard_EXPORT Geom2dGcc_FunctionTanCuCuCu(const gp_Circ2d& C1, const Handle(Geom2dAdaptor_Curve)& C2, const Handle(Geom2dAdaptor_Curve)& C3);
- Standard_EXPORT Geom2dGcc_FunctionTanCuCuCu(const gp_Circ2d& C1, const gp_Circ2d& C2, const Geom2dAdaptor_Curve& C3);
+ Standard_EXPORT Geom2dGcc_FunctionTanCuCuCu(const gp_Circ2d& C1, const gp_Circ2d& C2, const Handle(Geom2dAdaptor_Curve)& C3);
- Standard_EXPORT Geom2dGcc_FunctionTanCuCuCu(const gp_Circ2d& C1, const gp_Lin2d& L2, const Geom2dAdaptor_Curve& C3);
+ Standard_EXPORT Geom2dGcc_FunctionTanCuCuCu(const gp_Circ2d& C1, const gp_Lin2d& L2, const Handle(Geom2dAdaptor_Curve)& C3);
- Standard_EXPORT Geom2dGcc_FunctionTanCuCuCu(const gp_Lin2d& L1, const gp_Lin2d& L2, const Geom2dAdaptor_Curve& C3);
+ Standard_EXPORT Geom2dGcc_FunctionTanCuCuCu(const gp_Lin2d& L1, const gp_Lin2d& L2, const Handle(Geom2dAdaptor_Curve)& C3);
- Standard_EXPORT Geom2dGcc_FunctionTanCuCuCu(const gp_Lin2d& L1, const Geom2dAdaptor_Curve& C2, const Geom2dAdaptor_Curve& C3);
+ Standard_EXPORT Geom2dGcc_FunctionTanCuCuCu(const gp_Lin2d& L1, const Handle(Geom2dAdaptor_Curve)& C2, const Handle(Geom2dAdaptor_Curve)& C3);
- Standard_EXPORT Geom2dGcc_FunctionTanCuCuCu(const gp_Circ2d& C1, const Geom2dAdaptor_Curve& C2, const gp_Pnt2d& P3);
+ Standard_EXPORT Geom2dGcc_FunctionTanCuCuCu(const gp_Circ2d& C1, const Handle(Geom2dAdaptor_Curve)& C2, const gp_Pnt2d& P3);
- Standard_EXPORT Geom2dGcc_FunctionTanCuCuCu(const gp_Lin2d& L1, const Geom2dAdaptor_Curve& C2, const gp_Pnt2d& P3);
+ Standard_EXPORT Geom2dGcc_FunctionTanCuCuCu(const gp_Lin2d& L1, const Handle(Geom2dAdaptor_Curve)& C2, const gp_Pnt2d& P3);
- Standard_EXPORT Geom2dGcc_FunctionTanCuCuCu(const Geom2dAdaptor_Curve& C1, const gp_Pnt2d& P2, const gp_Pnt2d& P3);
+ Standard_EXPORT Geom2dGcc_FunctionTanCuCuCu(const Handle(Geom2dAdaptor_Curve)& C1, const gp_Pnt2d& P2, const gp_Pnt2d& P3);
Standard_EXPORT void InitDerivative (const math_Vector& X, gp_Pnt2d& Point1, gp_Pnt2d& Point2, gp_Pnt2d& Point3, gp_Vec2d& Tan1, gp_Vec2d& Tan2, gp_Vec2d& Tan3, gp_Vec2d& D21, gp_Vec2d& D22, gp_Vec2d& D23);
- Geom2dAdaptor_Curve Curv1;
- Geom2dAdaptor_Curve Curv2;
- Geom2dAdaptor_Curve Curv3;
+ Handle(Geom2dAdaptor_Curve) Curv1;
+ Handle(Geom2dAdaptor_Curve) Curv2;
+ Handle(Geom2dAdaptor_Curve) Curv3;
gp_Circ2d Circ1;
gp_Circ2d Circ2;
gp_Lin2d Lin1;
}
Geom2dGcc_FunctionTanCuCuOnCu::
- Geom2dGcc_FunctionTanCuCuOnCu(const Geom2dAdaptor_Curve& C1 ,
- const Geom2dAdaptor_Curve& C2 ,
- const Geom2dAdaptor_Curve& C3 ,
+ Geom2dGcc_FunctionTanCuCuOnCu(const Handle(Geom2dAdaptor_Curve)& C1 ,
+ const Handle(Geom2dAdaptor_Curve)& C2 ,
+ const Handle(Geom2dAdaptor_Curve)& C3 ,
const Standard_Real Rad ) {
Curv1 = C1;
Curv2 = C2;
Geom2dGcc_FunctionTanCuCuOnCu::
Geom2dGcc_FunctionTanCuCuOnCu(const gp_Circ2d& C1 ,
- const Geom2dAdaptor_Curve& C2 ,
- const Geom2dAdaptor_Curve& C3 ,
+ const Handle(Geom2dAdaptor_Curve)& C2 ,
+ const Handle(Geom2dAdaptor_Curve)& C3 ,
const Standard_Real Rad ) {
Circ1 = C1;
+ Curv1 = new Geom2dAdaptor_Curve();
Curv2 = C2;
Curvon = C3;
FirstRad = Rad;
Geom2dGcc_FunctionTanCuCuOnCu::
Geom2dGcc_FunctionTanCuCuOnCu(const gp_Lin2d& L1 ,
- const Geom2dAdaptor_Curve& C2 ,
- const Geom2dAdaptor_Curve& C3 ,
+ const Handle(Geom2dAdaptor_Curve)& C2 ,
+ const Handle(Geom2dAdaptor_Curve)& C3 ,
const Standard_Real Rad ) {
Lin1 = L1;
+ Curv1 = new Geom2dAdaptor_Curve();
Curv2 = C2;
Curvon = C3;
FirstRad = Rad;
}
Geom2dGcc_FunctionTanCuCuOnCu::
- Geom2dGcc_FunctionTanCuCuOnCu(const Geom2dAdaptor_Curve& C1 ,
+ Geom2dGcc_FunctionTanCuCuOnCu(const Handle(Geom2dAdaptor_Curve)& C1 ,
const gp_Pnt2d& P2 ,
- const Geom2dAdaptor_Curve& C3 ,
+ const Handle(Geom2dAdaptor_Curve)& C3 ,
const Standard_Real Rad ) {
Curv1 = C1;
+ Curv2 = new Geom2dAdaptor_Curve();
Pnt2 = P2;
Curvon = C3;
FirstRad = Rad;
}
Geom2dGcc_FunctionTanCuCuOnCu::
- Geom2dGcc_FunctionTanCuCuOnCu(const Geom2dAdaptor_Curve& C1 ,
- const Geom2dAdaptor_Curve& C2 ,
+ Geom2dGcc_FunctionTanCuCuOnCu(const Handle(Geom2dAdaptor_Curve)& C1 ,
+ const Handle(Geom2dAdaptor_Curve)& C2 ,
const gp_Lin2d& OnLi ,
const Standard_Real Rad ) {
Curv1 = C1;
Curv2 = C2;
+ Curvon = new Geom2dAdaptor_Curve();
Linon = OnLi;
FirstRad = Rad;
TheType = Geom2dGcc_CuCuOnLi;
Geom2dGcc_FunctionTanCuCuOnCu::
Geom2dGcc_FunctionTanCuCuOnCu(const gp_Circ2d& C1 ,
- const Geom2dAdaptor_Curve& C2 ,
+ const Handle(Geom2dAdaptor_Curve)& C2 ,
const gp_Lin2d& OnLi ,
const Standard_Real Rad ) {
Circ1 = C1;
+ Curv1 = new Geom2dAdaptor_Curve();
Curv2 = C2;
+ Curvon = new Geom2dAdaptor_Curve();
Linon = OnLi;
FirstRad = Rad;
TheType = Geom2dGcc_CiCuOnLi;
Geom2dGcc_FunctionTanCuCuOnCu::
Geom2dGcc_FunctionTanCuCuOnCu(const gp_Lin2d& L1 ,
- const Geom2dAdaptor_Curve& C2 ,
+ const Handle(Geom2dAdaptor_Curve)& C2 ,
const gp_Lin2d& OnLi ,
const Standard_Real Rad ) {
Lin1 = L1;
+ Curv1 = new Geom2dAdaptor_Curve();
Curv2 = C2;
+ Curvon = new Geom2dAdaptor_Curve();
Linon = OnLi;
FirstRad = Rad;
TheType = Geom2dGcc_LiCuOnLi;
}
Geom2dGcc_FunctionTanCuCuOnCu::
- Geom2dGcc_FunctionTanCuCuOnCu(const Geom2dAdaptor_Curve& C1 ,
+ Geom2dGcc_FunctionTanCuCuOnCu(const Handle(Geom2dAdaptor_Curve)& C1 ,
const gp_Pnt2d& P2 ,
const gp_Lin2d& OnLi ,
const Standard_Real Rad ) {
Curv1 = C1;
+ Curv2 = new Geom2dAdaptor_Curve();
+ Curvon = new Geom2dAdaptor_Curve();
Pnt2 = P2;
Linon = OnLi;
FirstRad = Rad;
}
Geom2dGcc_FunctionTanCuCuOnCu::
- Geom2dGcc_FunctionTanCuCuOnCu(const Geom2dAdaptor_Curve& C1 ,
- const Geom2dAdaptor_Curve& C2 ,
+ Geom2dGcc_FunctionTanCuCuOnCu(const Handle(Geom2dAdaptor_Curve)& C1 ,
+ const Handle(Geom2dAdaptor_Curve)& C2 ,
const gp_Circ2d& OnCi ,
const Standard_Real Rad ) {
Curv1 = C1;
Curv2 = C2;
+ Curvon = new Geom2dAdaptor_Curve();
Circon = OnCi;
FirstRad = Rad;
TheType = Geom2dGcc_CuCuOnCi;
Geom2dGcc_FunctionTanCuCuOnCu::
Geom2dGcc_FunctionTanCuCuOnCu(const gp_Circ2d& C1 ,
- const Geom2dAdaptor_Curve& C2 ,
+ const Handle(Geom2dAdaptor_Curve)& C2 ,
const gp_Circ2d& OnCi ,
const Standard_Real Rad ) {
Circ1 = C1;
+ Curv1 = new Geom2dAdaptor_Curve();
Curv2 = C2;
+ Curvon = new Geom2dAdaptor_Curve();
Circon = OnCi;
FirstRad = Rad;
TheType = Geom2dGcc_CuCuOnCi;
Geom2dGcc_FunctionTanCuCuOnCu::
Geom2dGcc_FunctionTanCuCuOnCu(const gp_Lin2d& L1 ,
- const Geom2dAdaptor_Curve& C2 ,
+ const Handle(Geom2dAdaptor_Curve)& C2 ,
const gp_Circ2d& OnCi ,
const Standard_Real Rad ) {
Lin1 = L1;
+ Curv1 = new Geom2dAdaptor_Curve();
Curv2 = C2;
+ Curvon = new Geom2dAdaptor_Curve();
Circon = OnCi;
FirstRad = Rad;
TheType = Geom2dGcc_LiCuOnCi;
}
Geom2dGcc_FunctionTanCuCuOnCu::
- Geom2dGcc_FunctionTanCuCuOnCu(const Geom2dAdaptor_Curve& C1 ,
+ Geom2dGcc_FunctionTanCuCuOnCu(const Handle(Geom2dAdaptor_Curve)& C1 ,
const gp_Pnt2d& P2 ,
const gp_Circ2d& OnCi ,
const Standard_Real Rad ) {
Curv1 = C1;
+ Curv2 = new Geom2dAdaptor_Curve();
+ Curvon = new Geom2dAdaptor_Curve();
Pnt2 = P2;
Circon = OnCi;
FirstRad = Rad;
DEFINE_STANDARD_ALLOC
- Standard_EXPORT Geom2dGcc_FunctionTanCuCuOnCu(const Geom2dAdaptor_Curve& C1, const Geom2dAdaptor_Curve& C2, const gp_Circ2d& OnCi, const Standard_Real Rad);
+ Standard_EXPORT Geom2dGcc_FunctionTanCuCuOnCu(const Handle(Geom2dAdaptor_Curve)& C1, const Handle(Geom2dAdaptor_Curve)& C2, const gp_Circ2d& OnCi, const Standard_Real Rad);
- Standard_EXPORT Geom2dGcc_FunctionTanCuCuOnCu(const gp_Circ2d& C1, const Geom2dAdaptor_Curve& C2, const gp_Circ2d& OnCi, const Standard_Real Rad);
+ Standard_EXPORT Geom2dGcc_FunctionTanCuCuOnCu(const gp_Circ2d& C1, const Handle(Geom2dAdaptor_Curve)& C2, const gp_Circ2d& OnCi, const Standard_Real Rad);
- Standard_EXPORT Geom2dGcc_FunctionTanCuCuOnCu(const gp_Lin2d& L1, const Geom2dAdaptor_Curve& C2, const gp_Circ2d& OnCi, const Standard_Real Rad);
+ Standard_EXPORT Geom2dGcc_FunctionTanCuCuOnCu(const gp_Lin2d& L1, const Handle(Geom2dAdaptor_Curve)& C2, const gp_Circ2d& OnCi, const Standard_Real Rad);
- Standard_EXPORT Geom2dGcc_FunctionTanCuCuOnCu(const Geom2dAdaptor_Curve& C1, const gp_Pnt2d& P2, const gp_Circ2d& OnCi, const Standard_Real Rad);
+ Standard_EXPORT Geom2dGcc_FunctionTanCuCuOnCu(const Handle(Geom2dAdaptor_Curve)& C1, const gp_Pnt2d& P2, const gp_Circ2d& OnCi, const Standard_Real Rad);
- Standard_EXPORT Geom2dGcc_FunctionTanCuCuOnCu(const Geom2dAdaptor_Curve& C1, const Geom2dAdaptor_Curve& C2, const gp_Lin2d& OnLi, const Standard_Real Rad);
+ Standard_EXPORT Geom2dGcc_FunctionTanCuCuOnCu(const Handle(Geom2dAdaptor_Curve)& C1, const Handle(Geom2dAdaptor_Curve)& C2, const gp_Lin2d& OnLi, const Standard_Real Rad);
- Standard_EXPORT Geom2dGcc_FunctionTanCuCuOnCu(const gp_Circ2d& C1, const Geom2dAdaptor_Curve& C2, const gp_Lin2d& OnLi, const Standard_Real Rad);
+ Standard_EXPORT Geom2dGcc_FunctionTanCuCuOnCu(const gp_Circ2d& C1, const Handle(Geom2dAdaptor_Curve)& C2, const gp_Lin2d& OnLi, const Standard_Real Rad);
- Standard_EXPORT Geom2dGcc_FunctionTanCuCuOnCu(const gp_Lin2d& L1, const Geom2dAdaptor_Curve& C2, const gp_Lin2d& OnLi, const Standard_Real Rad);
+ Standard_EXPORT Geom2dGcc_FunctionTanCuCuOnCu(const gp_Lin2d& L1, const Handle(Geom2dAdaptor_Curve)& C2, const gp_Lin2d& OnLi, const Standard_Real Rad);
- Standard_EXPORT Geom2dGcc_FunctionTanCuCuOnCu(const Geom2dAdaptor_Curve& C1, const gp_Pnt2d& P2, const gp_Lin2d& OnLi, const Standard_Real Rad);
+ Standard_EXPORT Geom2dGcc_FunctionTanCuCuOnCu(const Handle(Geom2dAdaptor_Curve)& C1, const gp_Pnt2d& P2, const gp_Lin2d& OnLi, const Standard_Real Rad);
- Standard_EXPORT Geom2dGcc_FunctionTanCuCuOnCu(const Geom2dAdaptor_Curve& C1, const Geom2dAdaptor_Curve& C2, const Geom2dAdaptor_Curve& OnCu, const Standard_Real Rad);
+ Standard_EXPORT Geom2dGcc_FunctionTanCuCuOnCu(const Handle(Geom2dAdaptor_Curve)& C1, const Handle(Geom2dAdaptor_Curve)& C2, const Handle(Geom2dAdaptor_Curve)& OnCu, const Standard_Real Rad);
- Standard_EXPORT Geom2dGcc_FunctionTanCuCuOnCu(const gp_Circ2d& C1, const Geom2dAdaptor_Curve& C2, const Geom2dAdaptor_Curve& OnCu, const Standard_Real Rad);
+ Standard_EXPORT Geom2dGcc_FunctionTanCuCuOnCu(const gp_Circ2d& C1, const Handle(Geom2dAdaptor_Curve)& C2, const Handle(Geom2dAdaptor_Curve)& OnCu, const Standard_Real Rad);
- Standard_EXPORT Geom2dGcc_FunctionTanCuCuOnCu(const gp_Lin2d& L1, const Geom2dAdaptor_Curve& C2, const Geom2dAdaptor_Curve& OnCu, const Standard_Real Rad);
+ Standard_EXPORT Geom2dGcc_FunctionTanCuCuOnCu(const gp_Lin2d& L1, const Handle(Geom2dAdaptor_Curve)& C2, const Handle(Geom2dAdaptor_Curve)& OnCu, const Standard_Real Rad);
- Standard_EXPORT Geom2dGcc_FunctionTanCuCuOnCu(const Geom2dAdaptor_Curve& C1, const gp_Pnt2d& P1, const Geom2dAdaptor_Curve& OnCu, const Standard_Real Rad);
+ Standard_EXPORT Geom2dGcc_FunctionTanCuCuOnCu(const Handle(Geom2dAdaptor_Curve)& C1, const gp_Pnt2d& P1, const Handle(Geom2dAdaptor_Curve)& OnCu, const Standard_Real Rad);
Standard_EXPORT void InitDerivative (const math_Vector& X, gp_Pnt2d& Point1, gp_Pnt2d& Point2, gp_Pnt2d& Point3, gp_Vec2d& Tan1, gp_Vec2d& Tan2, gp_Vec2d& Tan3, gp_Vec2d& D21, gp_Vec2d& D22, gp_Vec2d& D23);
- Geom2dAdaptor_Curve Curv1;
- Geom2dAdaptor_Curve Curv2;
+ Handle(Geom2dAdaptor_Curve) Curv1;
+ Handle(Geom2dAdaptor_Curve) Curv2;
gp_Circ2d Circ1;
gp_Lin2d Lin1;
gp_Pnt2d Pnt2;
gp_Circ2d Circon;
gp_Lin2d Linon;
- Geom2dAdaptor_Curve Curvon;
+ Handle(Geom2dAdaptor_Curve) Curvon;
Standard_Real FirstRad;
Geom2dGcc_Type2 TheType;
// N.N N*N*N*CP1*CP1*CP1 +
//=========================================================================
Geom2dGcc_FunctionTanCuPnt::
-Geom2dGcc_FunctionTanCuPnt(const Geom2dAdaptor_Curve& C ,
+Geom2dGcc_FunctionTanCuPnt(const Handle(Geom2dAdaptor_Curve)& C ,
const gp_Pnt2d& Point ) {
TheCurv = C;
ThePoint = Point;
DEFINE_STANDARD_ALLOC
- Standard_EXPORT Geom2dGcc_FunctionTanCuPnt(const Geom2dAdaptor_Curve& C, const gp_Pnt2d& Point);
+ Standard_EXPORT Geom2dGcc_FunctionTanCuPnt(const Handle(Geom2dAdaptor_Curve)& C, const gp_Pnt2d& Point);
//! Computes the value of the function F for the variable X.
//! It returns True if the computation is successfully done,
- Geom2dAdaptor_Curve TheCurv;
+ Handle(Geom2dAdaptor_Curve) TheCurv;
gp_Pnt2d ThePoint;
#include <gp_Vec2d.hxx>
Geom2dGcc_FunctionTanObl::
-Geom2dGcc_FunctionTanObl(const Geom2dAdaptor_Curve& C,
+Geom2dGcc_FunctionTanObl(const Handle(Geom2dAdaptor_Curve)& C,
const gp_Dir2d& Dir )
{
TheCurv = C;
DEFINE_STANDARD_ALLOC
- Standard_EXPORT Geom2dGcc_FunctionTanObl(const Geom2dAdaptor_Curve& Curve, const gp_Dir2d& Dir);
+ Standard_EXPORT Geom2dGcc_FunctionTanObl(const Handle(Geom2dAdaptor_Curve)& Curve, const gp_Dir2d& Dir);
//! Computes the value of the function F for the variable X.
//! It returns True if the computation is successfully done,
- Geom2dAdaptor_Curve TheCurv;
+ Handle(Geom2dAdaptor_Curve) TheCurv;
gp_Dir2d TheDirection;
pararg1(1,4) ,
pararg2(1,4)
{
- Geom2dAdaptor_Curve C1 = Qualified1.Qualified();
- Geom2dAdaptor_Curve C2 = Qualified2.Qualified();
- Handle(Geom2d_Curve) CC1 = C1.Curve();
- Handle(Geom2d_Curve) CC2 = C2.Curve();
- GeomAbs_CurveType Type1 = C1.GetType();
- GeomAbs_CurveType Type2 = C2.GetType();
+ Handle(Geom2dAdaptor_Curve) C1 = Qualified1.Qualified();
+ Handle(Geom2dAdaptor_Curve) C2 = Qualified2.Qualified();
+ Handle(Geom2d_Curve) CC1 = C1->Curve();
+ Handle(Geom2d_Curve) CC2 = C2->Curve();
+ GeomAbs_CurveType Type1 = C1->GetType();
+ GeomAbs_CurveType Type2 = C2->GetType();
//=============================================================================
// Appel a GccAna. +
pararg1(1,2) ,
pararg2(1,2)
{
- Geom2dAdaptor_Curve C1 = Qualified1.Qualified();
- Handle(Geom2d_Curve) CC1 = C1.Curve();
- GeomAbs_CurveType Type1 = C1.GetType();
+ Handle(Geom2dAdaptor_Curve) C1 = Qualified1.Qualified();
+ Handle(Geom2d_Curve) CC1 = C1->Curve();
+ GeomAbs_CurveType Type1 = C1->GetType();
//=============================================================================
// Appel a GccAna. +
Geom2dGcc_Lin2d2TanIter Lin(Qc1,ThePoint,Param1,Tolang);
if (Lin.IsDone()) {
- if (Add(NbrSol + 1, Lin, Tolang, C1, Geom2dAdaptor_Curve()))
+ if (Add(NbrSol + 1, Lin, Tolang, C1, new Geom2dAdaptor_Curve()))
NbrSol++;
}
pararg1(1,4) ,
pararg2(1,4)
{
- Geom2dAdaptor_Curve C1 = Qualified1.Qualified();
- Geom2dAdaptor_Curve C2 = Qualified2.Qualified();
- Handle(Geom2d_Curve) CC1 = C1.Curve();
- Handle(Geom2d_Curve) CC2 = C2.Curve();
- GeomAbs_CurveType Type1 = C1.GetType();
- GeomAbs_CurveType Type2 = C2.GetType();
+ Handle(Geom2dAdaptor_Curve) C1 = Qualified1.Qualified();
+ Handle(Geom2dAdaptor_Curve) C2 = Qualified2.Qualified();
+ Handle(Geom2d_Curve) CC1 = C1->Curve();
+ Handle(Geom2d_Curve) CC2 = C2->Curve();
+ GeomAbs_CurveType Type1 = C1->GetType();
+ GeomAbs_CurveType Type2 = C2->GetType();
//=============================================================================
// Appel a GccAna. +
pararg1(1,2) ,
pararg2(1,2)
{
- Geom2dAdaptor_Curve C1 = Qualified1.Qualified();
- Handle(Geom2d_Curve) CC1 = C1.Curve();
- GeomAbs_CurveType Type1 = C1.GetType();
+ Handle(Geom2dAdaptor_Curve) C1 = Qualified1.Qualified();
+ Handle(Geom2d_Curve) CC1 = C1->Curve();
+ GeomAbs_CurveType Type1 = C1->GetType();
//=============================================================================
// Appel a GccAna. +
Standard_Boolean Geom2dGcc_Lin2d2Tan::Add(const Standard_Integer theIndex,
const Geom2dGcc_Lin2d2TanIter &theLin,
const Standard_Real theTol,
- const Geom2dAdaptor_Curve &theC1,
- const Geom2dAdaptor_Curve &theC2)
+ const Handle(Geom2dAdaptor_Curve) &theC1,
+ const Handle(Geom2dAdaptor_Curve) &theC2)
{
Standard_Integer i;
Standard_Real aPar1sol;
if (Abs(aLinDir.Crossed(gp_Dir2d(aVTan))) > theTol)
return Standard_False;
- if (!theC2.Curve().IsNull()) {
+ if (!theC2->Curve().IsNull()) {
Geom2dGcc_CurveTool::D1(theC2, aPar2arg, aPoint, aVTan);
if (Abs(aLinDir.Crossed(gp_Dir2d(aVTan))) > theTol)
private:
- Standard_EXPORT Standard_Boolean Add (const Standard_Integer theIndex, const Geom2dGcc_Lin2d2TanIter& theLin, const Standard_Real theTol, const Geom2dAdaptor_Curve& theC1, const Geom2dAdaptor_Curve& theC2);
+ Standard_EXPORT Standard_Boolean Add (const Standard_Integer theIndex, const Geom2dGcc_Lin2d2TanIter& theLin, const Standard_Real theTol, const Handle(Geom2dAdaptor_Curve)& theC1, const Handle(Geom2dAdaptor_Curve)& theC2);
Standard_Boolean WellDone;
qualifier2 = GccEnt_noqualifier;
if (Qualified1.IsEnclosed()) { throw GccEnt_BadQualifier(); }
gp_Circ2d C1 = Qualified1.Qualified();
- Geom2dAdaptor_Curve Cu2 = Qualified2.Qualified();
+ Handle(Geom2dAdaptor_Curve) Cu2 = Qualified2.Qualified();
Standard_Real U1 = Geom2dGcc_CurveTool::FirstParameter(Cu2);
Standard_Real U2 = Geom2dGcc_CurveTool::LastParameter(Cu2);
Geom2dGcc_FunctionTanCirCu func(C1,Cu2);
throw GccEnt_BadQualifier();
return;
}
- Geom2dAdaptor_Curve Cu1 = Qualified1.Qualified();
- Geom2dAdaptor_Curve Cu2 = Qualified2.Qualified();
+ Handle(Geom2dAdaptor_Curve) Cu1 = Qualified1.Qualified();
+ Handle(Geom2dAdaptor_Curve) Cu2 = Qualified2.Qualified();
Geom2dGcc_FunctionTanCuCu Func(Cu1,Cu2);
math_Vector Umin(1,2);
math_Vector Umax(1,2);
throw GccEnt_BadQualifier();
return;
}
- Geom2dAdaptor_Curve Cu1 = Qualified1.Qualified();
+ Handle(Geom2dAdaptor_Curve) Cu1 = Qualified1.Qualified();
Standard_Real U1 = Geom2dGcc_CurveTool::FirstParameter(Cu1);
Standard_Real U2 = Geom2dGcc_CurveTool::LastParameter(Cu1);
Geom2dGcc_FunctionTanCuPnt func(Cu1,ThePoint);
pararg1(1,2) ,
pararg2(1,2)
{
- Geom2dAdaptor_Curve C1 = Qualified1.Qualified();
- Handle(Geom2d_Curve) CC1 = C1.Curve();
- GeomAbs_CurveType Type1 = C1.GetType();
+ Handle(Geom2dAdaptor_Curve) C1 = Qualified1.Qualified();
+ Handle(Geom2d_Curve) CC1 = C1->Curve();
+ GeomAbs_CurveType Type1 = C1->GetType();
//=============================================================================
// Appel a GccAna. +
pararg1(1,2) ,
pararg2(1,2)
{
- Geom2dAdaptor_Curve C1 = Qualified1.Qualified();
- Handle(Geom2d_Curve) CC1 = C1.Curve();
- GeomAbs_CurveType Type1 = C1.GetType();
+ Handle(Geom2dAdaptor_Curve) C1 = Qualified1.Qualified();
+ Handle(Geom2d_Curve) CC1 = C1->Curve();
+ GeomAbs_CurveType Type1 = C1->GetType();
//=============================================================================
// Appel a GccAna. +
(const Standard_Integer theIndex,
const Geom2dGcc_Lin2dTanOblIter &theLin,
const Standard_Real theTol,
- const Geom2dAdaptor_Curve &theC1)
+ const Handle(Geom2dAdaptor_Curve) &theC1)
{
Standard_Integer i;
Standard_Real aPar1sol;
private:
- Standard_EXPORT Standard_Boolean Add (const Standard_Integer theIndex, const Geom2dGcc_Lin2dTanOblIter& theLin, const Standard_Real theTol, const Geom2dAdaptor_Curve& theC1);
+ Standard_EXPORT Standard_Boolean Add (const Standard_Integer theIndex, const Geom2dGcc_Lin2dTanOblIter& theLin, const Standard_Real theTol, const Handle(Geom2dAdaptor_Curve)& theC1);
Standard_Boolean WellDone;
return;
}
Paral2 = Standard_False;
- Geom2dAdaptor_Curve Cu1 = Qualified1.Qualified();
+ Handle(Geom2dAdaptor_Curve) Cu1 = Qualified1.Qualified();
Standard_Real U1 = Geom2dGcc_CurveTool::FirstParameter(Cu1);
Standard_Real U2 = Geom2dGcc_CurveTool::LastParameter(Cu1);
gp_Dir2d Dir(TheLin.Direction());
#include <Geom2dGcc_QCurve.hxx>
//#include <Geom2dAdaptor_Curve.hxx>
-Geom2dAdaptor_Curve Geom2dGcc_QCurve::
+Handle(Geom2dAdaptor_Curve) Geom2dGcc_QCurve::
Qualified () const { return TheQualified; }
GccEnt_Position Geom2dGcc_QCurve::
}
Geom2dGcc_QCurve::
- Geom2dGcc_QCurve (const Geom2dAdaptor_Curve& Curve,
+ Geom2dGcc_QCurve (const Handle(Geom2dAdaptor_Curve)& Curve,
const GccEnt_Position Qualifier) {
TheQualified = Curve;
TheQualifier = Qualifier;
DEFINE_STANDARD_ALLOC
- Standard_EXPORT Geom2dGcc_QCurve(const Geom2dAdaptor_Curve& Curve, const GccEnt_Position Qualifier);
+ Standard_EXPORT Geom2dGcc_QCurve(const Handle(Geom2dAdaptor_Curve)& Curve, const GccEnt_Position Qualifier);
- Standard_EXPORT Geom2dAdaptor_Curve Qualified() const;
+ Standard_EXPORT Handle(Geom2dAdaptor_Curve) Qualified() const;
Standard_EXPORT GccEnt_Position Qualifier() const;
GccEnt_Position TheQualifier;
- Geom2dAdaptor_Curve TheQualified;
+ Handle(Geom2dAdaptor_Curve) TheQualified;
};
#include <Geom2dGcc_QualifiedCurve.hxx>
Geom2dGcc_QualifiedCurve::
- Geom2dGcc_QualifiedCurve (const Geom2dAdaptor_Curve& Curve ,
+ Geom2dGcc_QualifiedCurve (const Handle(Geom2dAdaptor_Curve)& Curve ,
const GccEnt_Position Qualifier) {
TheQualified = Curve;
TheQualifier = Qualifier;
}
-Geom2dAdaptor_Curve Geom2dGcc_QualifiedCurve::
+const Handle(Geom2dAdaptor_Curve)& Geom2dGcc_QualifiedCurve::
Qualified () const { return TheQualified; }
GccEnt_Position Geom2dGcc_QualifiedCurve::
//! GccEnt_Position myQualif = GccEnt_outside ;
//! Geom2dGcc_QualifiedCurve myQCurve ( Curve, myQualif );
//! is private;
- Standard_EXPORT Geom2dGcc_QualifiedCurve(const Geom2dAdaptor_Curve& Curve, const GccEnt_Position Qualifier);
+ Standard_EXPORT Geom2dGcc_QualifiedCurve(const Handle(Geom2dAdaptor_Curve)& Curve, const GccEnt_Position Qualifier);
//! Returns a 2D curve to which the qualifier is assigned.
//! Warning
//! The Geom2d curve on which the adapted curve is
//! based can be obtained in the following way:
//! myQualifiedCurve = ... ;
- //! Geom2dAdaptor_Curve myAdaptedCurve = myQualifiedCurve.Qualified();
- //! Handle(Geom2d_Curve) = myAdaptedCurve.Curve();
- Standard_EXPORT Geom2dAdaptor_Curve Qualified() const;
+ //! Handle(Geom2dAdaptor_Curve) myAdaptedCurve = myQualifiedCurve->Qualified();
+ //! Handle(Geom2d_Curve) = myAdaptedCurve->Curve();
+ Standard_EXPORT const Handle(Geom2dAdaptor_Curve)& Qualified() const;
//! Returns
//! - the qualifier of this qualified curve if it is enclosing,
GccEnt_Position TheQualifier;
- Geom2dAdaptor_Curve TheQualified;
+ Handle(Geom2dAdaptor_Curve) TheQualified;
};
//! Returns the Edge used to determine the
//! classification. When the State is ON this is the
//! Edge containing the point.
- Standard_EXPORT const Geom2dAdaptor_Curve& Edge() const;
+ Standard_EXPORT const Handle(Geom2dAdaptor_Curve)& Edge() const;
//! Returns the parameter on Edge() used to determine the
//! classification.
Geom2dHatch_FClass2dOfClassifier myClassifier;
- Geom2dAdaptor_Curve myEdge;
+ Handle(Geom2dAdaptor_Curve) myEdge;
Standard_Real myEdgeParameter;
IntRes2d_Position myPosition;
Standard_Boolean rejected;
#define TheFaceExplorer Geom2dHatch_Elements
#define TheFaceExplorer_hxx <Geom2dHatch_Elements.hxx>
-#define TheEdge Geom2dAdaptor_Curve
+#define TheEdge Handle(Geom2dAdaptor_Curve)
#define TheEdge_hxx <Geom2dAdaptor_Curve.hxx>
#define TheIntersection2d Geom2dHatch_Intersector
#define TheIntersection2d_hxx <Geom2dHatch_Intersector.hxx>
//=======================================================================
Geom2dHatch_Element::Geom2dHatch_Element () {
+ myCurve = new Geom2dAdaptor_Curve();
}
//=======================================================================
// Purpose : Constructor.
//=======================================================================
-Geom2dHatch_Element::Geom2dHatch_Element (const Geom2dAdaptor_Curve& Curve,
+Geom2dHatch_Element::Geom2dHatch_Element (const Handle(Geom2dAdaptor_Curve)& Curve,
const TopAbs_Orientation Orientation) :
myCurve (Curve),
myOrientation (Orientation)
// Purpose : Returns the curve associated to the hatching.
//=======================================================================
-const Geom2dAdaptor_Curve& Geom2dHatch_Element::Curve () const
+const Handle(Geom2dAdaptor_Curve)& Geom2dHatch_Element::Curve () const
{
- return myCurve ;
-}
-
-//=======================================================================
-// Function : ChangeCurve
-// Purpose : Returns the curve associated to the hatching.
-//=======================================================================
-
-Geom2dAdaptor_Curve& Geom2dHatch_Element::ChangeCurve ()
-{
- return myCurve ;
+ return myCurve;
}
//=======================================================================
Standard_EXPORT Geom2dHatch_Element();
//! Creates an element.
- Standard_EXPORT Geom2dHatch_Element(const Geom2dAdaptor_Curve& Curve, const TopAbs_Orientation Orientation = TopAbs_FORWARD);
+ Standard_EXPORT Geom2dHatch_Element(const Handle(Geom2dAdaptor_Curve)& Curve, const TopAbs_Orientation Orientation = TopAbs_FORWARD);
//! Returns the curve associated to the element.
- Standard_EXPORT const Geom2dAdaptor_Curve& Curve() const;
-
- //! Returns the curve associated to the element.
- Standard_EXPORT Geom2dAdaptor_Curve& ChangeCurve();
+ Standard_EXPORT const Handle(Geom2dAdaptor_Curve)& Curve() const;
//! Sets the orientation of the element.
Standard_EXPORT void Orientation (const TopAbs_Orientation Orientation);
- Geom2dAdaptor_Curve myCurve;
+ Handle(Geom2dAdaptor_Curve) myCurve;
TopAbs_Orientation myOrientation;
void *ptrmyMap = (void *)(&myMap);
Geom2dHatch_Element& Item = ((Geom2dHatch_MapOfElements*)ptrmyMap)->ChangeFind (Itertemp.Key());
- Geom2dAdaptor_Curve& E = Item.ChangeCurve();
+ Handle(Geom2dAdaptor_Curve) E = Item.Curve();
TopAbs_Orientation Or = Item.Orientation();
if (Or == TopAbs_FORWARD || Or == TopAbs_REVERSED)
{
- Standard_Real aFPar = E.FirstParameter(), aLPar = E.LastParameter();
+ Standard_Real aFPar = E->FirstParameter(), aLPar = E->LastParameter();
if (Precision::IsNegativeInfinite (aFPar))
{
if (Precision::IsPositiveInfinite (aLPar))
Standard_Real aParam = myCurEdgePar * aFPar + (1. - myCurEdgePar) * aLPar;
gp_Vec2d aTanVec;
gp_Pnt2d aPOnC;
- E.D1 (aParam, aPOnC, aTanVec);
+ E->D1 (aParam, aPOnC, aTanVec);
gp_Vec2d aLinVec (P, aPOnC);
Par = aLinVec.SquareMagnitude();
if (Par > Precision::SquarePConfusion())
L = gp_Lin2d (P, aLinDir);
- aPOnC = E.Value (aFPar);
+ aPOnC = E->Value (aFPar);
if (L.SquareDistance (aPOnC) > Precision::SquarePConfusion())
{
- aPOnC = E.Value (aLPar);
+ aPOnC = E->Value (aLPar);
if (L.SquareDistance (aPOnC) > Precision::SquarePConfusion())
{
myCurEdgePar += Probing_Step;
//purpose :
//=======================================================================
-void Geom2dHatch_Elements::CurrentEdge(Geom2dAdaptor_Curve& E,
+void Geom2dHatch_Elements::CurrentEdge(Handle(Geom2dAdaptor_Curve)& E,
TopAbs_Orientation& Or) const
{
void *ptrmyMap = (void *)(&myMap);
Geom2dHatch_Element& Item=((Geom2dHatch_MapOfElements*)ptrmyMap)->ChangeFind(Iter.Key());
- E = Item.ChangeCurve();
+ E = Item.Curve();
Or= Item.Orientation();
#if 0
- E.Edge() = TopoDS::Edge(myEExplorer.Current());
- E.Face() = myFace;
- Or = E.Edge().Orientation();
+ E->Edge() = TopoDS::Edge(myEExplorer.Current());
+ E->Face() = myFace;
+ Or = E->Edge().Orientation();
#endif
}
Standard_EXPORT Standard_Boolean RejectEdge (const gp_Lin2d& L, const Standard_Real Par) const;
- Standard_EXPORT void CurrentEdge (Geom2dAdaptor_Curve& E, TopAbs_Orientation& Or) const;
+ Standard_EXPORT void CurrentEdge (Handle(Geom2dAdaptor_Curve)& E, TopAbs_Orientation& Or) const;
//! Updates the classification process with the edge
//! <E> from the boundary.
- Standard_EXPORT void Compare (const Geom2dAdaptor_Curve& E, const TopAbs_Orientation Or);
+ Standard_EXPORT void Compare (const Handle(Geom2dAdaptor_Curve)& E, const TopAbs_Orientation Or);
//! Returns the current value of the parameter.
Standard_Real Parameter() const;
#include <gp_Lin2d.hxx>
-#define TheEdge Geom2dAdaptor_Curve
+#define TheEdge Handle(Geom2dAdaptor_Curve)
#define TheEdge_hxx <Geom2dAdaptor_Curve.hxx>
#define TheIntersector Geom2dHatch_Intersector
#define TheIntersector_hxx <Geom2dHatch_Intersector.hxx>
// Purpose : Adds an element to the Hatcher and returns its index.
//=======================================================================
-Standard_Integer Geom2dHatch_Hatcher::AddElement (const Geom2dAdaptor_Curve& Curve,
+Standard_Integer Geom2dHatch_Hatcher::AddElement (const Handle(Geom2dAdaptor_Curve)& Curve,
const TopAbs_Orientation Orientation)
{
Standard_Integer IndE ;
// Purpose : Adds a hatching to the hatcher and returns its index.
//=======================================================================
-Standard_Integer Geom2dHatch_Hatcher::AddHatching (const Geom2dAdaptor_Curve& Curve)
+Standard_Integer Geom2dHatch_Hatcher::AddHatching (const Handle(Geom2dAdaptor_Curve)& Curve)
{
Standard_Integer IndH ;
for (IndH = 1 ; IndH <= myNbHatchings && myHatchings.IsBound(IndH) ; IndH++) ;
// already given and returns its index.
//=======================================================================
-Standard_Integer Geom2dHatch_Hatcher::Trim (const Geom2dAdaptor_Curve& Curve)
+Standard_Integer Geom2dHatch_Hatcher::Trim (const Handle(Geom2dAdaptor_Curve)& Curve)
{
Standard_Integer IndH = AddHatching (Curve) ;
Trim (IndH) ;
Geom2dHatch_Hatching& Hatching = myHatchings.ChangeFind (IndH) ;
Geom2dHatch_Element& Element = myElements.ChangeFind (IndE) ;
- Geom2dAdaptor_Curve hatching = Hatching.ChangeCurve() ;
- Geom2dAdaptor_Curve element = Element.ChangeCurve() ;
+ Handle(Geom2dAdaptor_Curve) hatching = Hatching.Curve();
+ Handle(Geom2dAdaptor_Curve) element = Element.Curve();
myIntersector.Intersect (hatching, element) ;
gp_Dir Tangente, Normale ;
Standard_Real Courbure ;
- const Geom2dAdaptor_Curve& CurveH = HatchingCurve (Point.Index()) ;
+ const Handle(Geom2dAdaptor_Curve)& CurveH = HatchingCurve (Point.Index()) ;
- myIntersector.LocalGeometry(CurveH.Curve(), Point.Parameter(), Tangente2d, Normale2d, Courbure);
+ myIntersector.LocalGeometry(new Geom2dAdaptor_Curve(CurveH->Curve()), Point.Parameter(), Tangente2d, Normale2d, Courbure);
Tangente.SetCoord (Tangente2d.X(), Tangente2d.Y(), 0.0) ;
if (Courbure < Precision::Confusion()) {
SegmentEnd = SegmentEnd || PntE.SegmentEnd() ;
const Geom2dHatch_Element& Element = myElements.Find (PntE.Index()) ;
- const Geom2dAdaptor_Curve& CurveE = Element.Curve() ;
+ const Handle(Geom2dAdaptor_Curve)& CurveE = Element.Curve() ;
TopAbs_Orientation ElementOrientation = Element.Orientation() ;
Standard_Boolean ToReverse = (ElementOrientation == TopAbs_REVERSED);
switch (PntE.Position())
{
case TopAbs_FORWARD :
- Param = ToReverse ? CurveE.LastParameter() : CurveE.FirstParameter() ;
+ Param = ToReverse ? CurveE->LastParameter() : CurveE->FirstParameter() ;
break ;
case TopAbs_INTERNAL :
break ;
case TopAbs_REVERSED :
- Param = ToReverse ? CurveE.FirstParameter() : CurveE.LastParameter() ;
+ Param = ToReverse ? CurveE->FirstParameter() : CurveE->LastParameter() ;
break ;
default:
#endif
Param = PntE.Parameter();
- myIntersector.LocalGeometry(CurveE.Curve(), Param, Tangente2d, Normale2d, Courbure);
+ myIntersector.LocalGeometry(new Geom2dAdaptor_Curve(CurveE->Curve()), Param, Tangente2d, Normale2d, Courbure);
//-----------------------------------------------------------------------
// Calcul de la transition locale. On suppose les relations suivantes :
void Clear();
//! Returns the curve associated to the IndE-th element.
- const Geom2dAdaptor_Curve& ElementCurve (const Standard_Integer IndE) const;
+ const Handle(Geom2dAdaptor_Curve)& ElementCurve (const Standard_Integer IndE) const;
//! Adds an element to the hatcher and returns its index.
- Standard_EXPORT Standard_Integer AddElement (const Geom2dAdaptor_Curve& Curve, const TopAbs_Orientation Orientation = TopAbs_FORWARD);
+ Standard_EXPORT Standard_Integer AddElement (const Handle(Geom2dAdaptor_Curve)& Curve, const TopAbs_Orientation Orientation = TopAbs_FORWARD);
//! Adds an element to the hatcher and returns its index.
Standard_Integer AddElement (const Handle(Geom2d_Curve)& Curve, const TopAbs_Orientation Orientation = TopAbs_FORWARD)
{
- Geom2dAdaptor_Curve aGAC (Curve);
+ Handle(Geom2dAdaptor_Curve) aGAC = new Geom2dAdaptor_Curve(Curve);
return AddElement (aGAC, Orientation);
}
Standard_EXPORT void ClrElements();
//! Returns the curve associated to the IndH-th hatching.
- const Geom2dAdaptor_Curve& HatchingCurve (const Standard_Integer IndH) const;
+ const Handle(Geom2dAdaptor_Curve)& HatchingCurve (const Standard_Integer IndH) const;
//! Adds a hatching to the hatcher and returns its index.
- Standard_EXPORT Standard_Integer AddHatching (const Geom2dAdaptor_Curve& Curve);
+ Standard_EXPORT Standard_Integer AddHatching (const Handle(Geom2dAdaptor_Curve)& Curve);
//! Removes the IndH-th hatching from the hatcher.
Standard_EXPORT void RemHatching (const Standard_Integer IndH);
//! Adds a hatching to the hatcher and trims it by
//! the elements already given and returns its index.
- Standard_EXPORT Standard_Integer Trim (const Geom2dAdaptor_Curve& Curve);
+ Standard_EXPORT Standard_Integer Trim (const Handle(Geom2dAdaptor_Curve)& Curve);
//! Trims the IndH-th hatching by the elements
//! already given.
// Purpose : Returns the curve associated to the IndE-th element.
//=======================================================================
-inline const Geom2dAdaptor_Curve& Geom2dHatch_Hatcher::ElementCurve (const Standard_Integer IndE) const
+inline const Handle(Geom2dAdaptor_Curve)& Geom2dHatch_Hatcher::ElementCurve (const Standard_Integer IndE) const
{
#if RAISE_IF_NOSUCHOBJECT
Standard_NoSuchObject_Raise_if (!myElements.IsBound (IndE), "") ;
// Purpose : Returns the curve associated to the IndH-th hatching.
//=======================================================================
-inline const Geom2dAdaptor_Curve& Geom2dHatch_Hatcher::HatchingCurve (const Standard_Integer IndH) const
+inline const Handle(Geom2dAdaptor_Curve)& Geom2dHatch_Hatcher::HatchingCurve (const Standard_Integer IndH) const
{
#if RAISE_IF_NOSUCHOBJECT
Standard_NoSuchObject_Raise_if (!myHatchings.IsBound (IndH), "") ;
myIsDone(Standard_False),
myStatus(HatchGen_NoProblem)
{
+ myCurve = new Geom2dAdaptor_Curve();
}
//=======================================================================
// Purpose : Constructor.
//=======================================================================
-Geom2dHatch_Hatching::Geom2dHatch_Hatching (const Geom2dAdaptor_Curve& Curve) :
+Geom2dHatch_Hatching::Geom2dHatch_Hatching (const Handle(Geom2dAdaptor_Curve)& Curve) :
myCurve (Curve),
myTrimDone (Standard_False),
myTrimFailed (Standard_False),
// Purpose : Returns the curve associated to the hatching.
//=======================================================================
-const Geom2dAdaptor_Curve& Geom2dHatch_Hatching::Curve () const
+const Handle(Geom2dAdaptor_Curve)& Geom2dHatch_Hatching::Curve () const
{
return myCurve ;
}
-
-//=======================================================================
-// Function : ChangeCurve
-// Purpose : Returns the curve associated to the hatching.
-//=======================================================================
-Geom2dAdaptor_Curve& Geom2dHatch_Hatching::ChangeCurve ()
-{
- return myCurve ;
-}
-
//=======================================================================
// Function : TrimDone
// Purpose : Sets the flag about the trimmings computation to the given
//=======================================================================
gp_Pnt2d Geom2dHatch_Hatching::ClassificationPoint () const {
Standard_Real t,a,b;
- a = myCurve.FirstParameter();
- b = myCurve.LastParameter();
+ a = myCurve->FirstParameter();
+ b = myCurve->LastParameter();
if(b >= Precision::Infinite()) {
if(a <= -Precision::Infinite()) {
t=0;
else {
t = b;
}
- return(myCurve.Value(t));
+ return(myCurve->Value(t));
}
Standard_EXPORT Geom2dHatch_Hatching();
//! Creates a hatching.
- Standard_EXPORT Geom2dHatch_Hatching(const Geom2dAdaptor_Curve& Curve);
+ Standard_EXPORT Geom2dHatch_Hatching(const Handle(Geom2dAdaptor_Curve)& Curve);
//! Returns the curve associated to the hatching.
- Standard_EXPORT const Geom2dAdaptor_Curve& Curve() const;
-
- //! Returns the curve associated to the hatching.
- Standard_EXPORT Geom2dAdaptor_Curve& ChangeCurve();
+ Standard_EXPORT const Handle(Geom2dAdaptor_Curve)& Curve() const;
//! Sets the flag about the trimming computations to the
//! given value.
- Geom2dAdaptor_Curve myCurve;
+ Handle(Geom2dAdaptor_Curve) myCurve;
Standard_Boolean myTrimDone;
Standard_Boolean myTrimFailed;
HatchGen_PointsOnHatching myPoints;
void Geom2dHatch_Intersector::Perform(const gp_Lin2d& L,
const Standard_Real P,
const Standard_Real Tol,
- const Geom2dAdaptor_Curve& C)
+ const Handle(Geom2dAdaptor_Curve)& C)
{
//Standard_Real pfbid,plbid;
else
DL.SetValues(L.Location(),0.,Tol,Standard_True);
- IntRes2d_Domain DE(C.Value(C.FirstParameter()),
- C.FirstParameter(),Precision::PIntersection(),
- C.Value(C.LastParameter()),
- C.LastParameter(),Precision::PIntersection());
+ IntRes2d_Domain DE(C->Value(C->FirstParameter()),
+ C->FirstParameter(),Precision::PIntersection(),
+ C->Value(C->LastParameter()),
+ C->LastParameter(),Precision::PIntersection());
Handle(Geom2d_Line) GL= new Geom2d_Line(L);
- Geom2dAdaptor_Curve CGA(GL);
- void *ptrpoureviterlesproblemesdeconst = (void *)(&C);
+ Handle(Geom2dAdaptor_Curve) CGA = new Geom2dAdaptor_Curve(GL);
Geom2dInt_GInter Inter(CGA,
DL,
- *((Geom2dAdaptor_Curve *)ptrpoureviterlesproblemesdeconst),
+ C,
DE,
Precision::PConfusion(),
Precision::PIntersection());
//purpose :
//=======================================================================
-void Geom2dHatch_Intersector::LocalGeometry(const Geom2dAdaptor_Curve& E,
+void Geom2dHatch_Intersector::LocalGeometry(const Handle(Geom2dAdaptor_Curve)& E,
const Standard_Real U,
gp_Dir2d& Tang,
gp_Dir2d& Norm,
Standard_Real& C) const
{
//Standard_Real f,l;
- Geom2dLProp_CLProps2d Prop(E.Curve(),U,2,Precision::PConfusion());
+ Geom2dLProp_CLProps2d Prop(E->Curve(),U,2,Precision::PConfusion());
if(!Prop.IsTangentDefined()) return;
//! The results are retrieved by the usual methods
//! described in IntRes2d_Intersection.
//! Creates an intersector.
- void Intersect (const Geom2dAdaptor_Curve& C1, const Geom2dAdaptor_Curve& C2);
+ void Intersect (const Handle(Geom2dAdaptor_Curve)& C1, const Handle(Geom2dAdaptor_Curve)& C2);
Standard_EXPORT Geom2dHatch_Intersector();
//! RealLast()). Tol is the Tolerance on the segment.
//! The order is relevant, the first argument is the
//! segment, the second the Edge.
- Standard_EXPORT void Perform (const gp_Lin2d& L, const Standard_Real P, const Standard_Real Tol, const Geom2dAdaptor_Curve& E);
+ Standard_EXPORT void Perform (const gp_Lin2d& L, const Standard_Real P, const Standard_Real Tol, const Handle(Geom2dAdaptor_Curve)& E);
//! Returns in <T>, <N> and <C> the tangent, normal
//! and curvature of the edge <E> at parameter value
//! <U>.
- Standard_EXPORT void LocalGeometry (const Geom2dAdaptor_Curve& E, const Standard_Real U, gp_Dir2d& T, gp_Dir2d& N, Standard_Real& C) const;
+ Standard_EXPORT void LocalGeometry (const Handle(Geom2dAdaptor_Curve)& E, const Standard_Real U, gp_Dir2d& T, gp_Dir2d& N, Standard_Real& C) const;
#include <Geom2dAdaptor_Curve.hxx>
inline void Geom2dHatch_Intersector::Intersect
- (const Geom2dAdaptor_Curve& C1,
- const Geom2dAdaptor_Curve& C2)
+ (const Handle(Geom2dAdaptor_Curve)& C1,
+ const Handle(Geom2dAdaptor_Curve)& C2)
{
Geom2dInt_GInter::Perform(C1,
C2,
DEFINE_STANDARD_ALLOC
- Standard_EXPORT Geom2dInt_ExactIntersectionPointOfTheIntPCurvePCurveOfGInter(const Adaptor2d_Curve2d& C1, const Adaptor2d_Curve2d& C2, const Standard_Real Tol);
+ Standard_EXPORT Geom2dInt_ExactIntersectionPointOfTheIntPCurvePCurveOfGInter(const Handle(Adaptor2d_Curve2d)& C1, const Handle(Adaptor2d_Curve2d)& C2, const Standard_Real Tol);
Standard_EXPORT void Perform (const Geom2dInt_ThePolygon2dOfTheIntPCurvePCurveOfGInter& Poly1, const Geom2dInt_ThePolygon2dOfTheIntPCurvePCurveOfGInter& Poly2, Standard_Integer& NumSegOn1, Standard_Integer& NumSegOn2, Standard_Real& ParamOnSeg1, Standard_Real& ParamOnSeg2);
#include <Geom2dInt_TheDistBetweenPCurvesOfTheIntPCurvePCurveOfGInter.hxx>
-#define TheCurve Adaptor2d_Curve2d
+#define TheCurve Handle(Adaptor2d_Curve2d)
#define TheCurve_hxx <Adaptor2d_Curve2d.hxx>
#define TheCurveTool Geom2dInt_Geom2dCurveTool
#define TheCurveTool_hxx <Geom2dInt_Geom2dCurveTool.hxx>
Geom2dInt_GInter();
//! Self Intersection of a curve
- Geom2dInt_GInter(const Adaptor2d_Curve2d& C, const Standard_Real TolConf, const Standard_Real Tol);
+ Geom2dInt_GInter(const Handle(Adaptor2d_Curve2d)& C, const Standard_Real TolConf, const Standard_Real Tol);
//! Self Intersection of a curve with a domain.
- Geom2dInt_GInter(const Adaptor2d_Curve2d& C, const IntRes2d_Domain& D, const Standard_Real TolConf, const Standard_Real Tol);
+ Geom2dInt_GInter(const Handle(Adaptor2d_Curve2d)& C, const IntRes2d_Domain& D, const Standard_Real TolConf, const Standard_Real Tol);
//! Intersection between 2 curves.
- Geom2dInt_GInter(const Adaptor2d_Curve2d& C1, const Adaptor2d_Curve2d& C2, const Standard_Real TolConf, const Standard_Real Tol);
+ Geom2dInt_GInter(const Handle(Adaptor2d_Curve2d)& C1, const Handle(Adaptor2d_Curve2d)& C2, const Standard_Real TolConf, const Standard_Real Tol);
//! Intersection between 2 curves.
- Geom2dInt_GInter(const Adaptor2d_Curve2d& C1, const IntRes2d_Domain& D1, const Adaptor2d_Curve2d& C2, const Standard_Real TolConf, const Standard_Real Tol);
+ Geom2dInt_GInter(const Handle(Adaptor2d_Curve2d)& C1, const IntRes2d_Domain& D1, const Handle(Adaptor2d_Curve2d)& C2, const Standard_Real TolConf, const Standard_Real Tol);
//! Intersection between 2 curves.
- Geom2dInt_GInter(const Adaptor2d_Curve2d& C1, const Adaptor2d_Curve2d& C2, const IntRes2d_Domain& D2, const Standard_Real TolConf, const Standard_Real Tol);
+ Geom2dInt_GInter(const Handle(Adaptor2d_Curve2d)& C1, const Handle(Adaptor2d_Curve2d)& C2, const IntRes2d_Domain& D2, const Standard_Real TolConf, const Standard_Real Tol);
//! Intersection between 2 curves.
- Geom2dInt_GInter(const Adaptor2d_Curve2d& C1, const IntRes2d_Domain& D1, const Adaptor2d_Curve2d& C2, const IntRes2d_Domain& D2, const Standard_Real TolConf, const Standard_Real Tol);
+ Geom2dInt_GInter(const Handle(Adaptor2d_Curve2d)& C1, const IntRes2d_Domain& D1, const Handle(Adaptor2d_Curve2d)& C2, const IntRes2d_Domain& D2, const Standard_Real TolConf, const Standard_Real Tol);
//! Intersection between 2 curves.
- Standard_EXPORT void Perform (const Adaptor2d_Curve2d& C1, const IntRes2d_Domain& D1, const Adaptor2d_Curve2d& C2, const IntRes2d_Domain& D2, const Standard_Real TolConf, const Standard_Real Tol);
+ Standard_EXPORT void Perform (const Handle(Adaptor2d_Curve2d)& C1, const IntRes2d_Domain& D1, const Handle(Adaptor2d_Curve2d)& C2, const IntRes2d_Domain& D2, const Standard_Real TolConf, const Standard_Real Tol);
//! Intersection between 2 curves.
- void Perform (const Adaptor2d_Curve2d& C1, const Adaptor2d_Curve2d& C2, const Standard_Real TolConf, const Standard_Real Tol);
+ void Perform (const Handle(Adaptor2d_Curve2d)& C1, const Handle(Adaptor2d_Curve2d)& C2, const Standard_Real TolConf, const Standard_Real Tol);
//! Intersection between 2 curves.
- Standard_EXPORT void Perform (const Adaptor2d_Curve2d& C1, const IntRes2d_Domain& D1, const Standard_Real TolConf, const Standard_Real Tol);
+ Standard_EXPORT void Perform (const Handle(Adaptor2d_Curve2d)& C1, const IntRes2d_Domain& D1, const Standard_Real TolConf, const Standard_Real Tol);
//! Intersection between 2 curves.
- Standard_EXPORT void Perform (const Adaptor2d_Curve2d& C1, const Standard_Real TolConf, const Standard_Real Tol);
+ Standard_EXPORT void Perform (const Handle(Adaptor2d_Curve2d)& C1, const Standard_Real TolConf, const Standard_Real Tol);
//! Intersection between 2 curves.
- void Perform (const Adaptor2d_Curve2d& C1, const IntRes2d_Domain& D1, const Adaptor2d_Curve2d& C2, const Standard_Real TolConf, const Standard_Real Tol);
+ void Perform (const Handle(Adaptor2d_Curve2d)& C1, const IntRes2d_Domain& D1, const Handle(Adaptor2d_Curve2d)& C2, const Standard_Real TolConf, const Standard_Real Tol);
//! Intersection between 2 curves.
- void Perform (const Adaptor2d_Curve2d& C1, const Adaptor2d_Curve2d& C2, const IntRes2d_Domain& D2, const Standard_Real TolConf, const Standard_Real Tol);
+ void Perform (const Handle(Adaptor2d_Curve2d)& C1, const Handle(Adaptor2d_Curve2d)& C2, const IntRes2d_Domain& D2, const Standard_Real TolConf, const Standard_Real Tol);
//! Create a domain from a curve
- Standard_EXPORT IntRes2d_Domain ComputeDomain (const Adaptor2d_Curve2d& C1, const Standard_Real TolDomain) const;
+ Standard_EXPORT IntRes2d_Domain ComputeDomain (const Handle(Adaptor2d_Curve2d)& C1, const Standard_Real TolDomain) const;
//! Set / get minimum number of points in polygon intersection.
Standard_EXPORT void SetMinNbSamples (const Standard_Integer theMinNbSamples);
//! Intersection between 2 curves.
- Standard_EXPORT void InternalPerform (const Adaptor2d_Curve2d& C1, const IntRes2d_Domain& D1, const Adaptor2d_Curve2d& C2, const IntRes2d_Domain& D2, const Standard_Real TolConf, const Standard_Real Tol, const Standard_Boolean Composite);
+ Standard_EXPORT void InternalPerform (const Handle(Adaptor2d_Curve2d)& C1, const IntRes2d_Domain& D1, const Handle(Adaptor2d_Curve2d)& C2, const IntRes2d_Domain& D2, const Standard_Real TolConf, const Standard_Real Tol, const Standard_Boolean Composite);
//! Part of InternalCompositePerform function
- Standard_EXPORT void InternalCompositePerform_noRecurs (const Standard_Integer NbInterC1, const Adaptor2d_Curve2d& C1, const Standard_Integer NumInterC1, const TColStd_Array1OfReal& Tab1, const IntRes2d_Domain& D1, const Standard_Integer NbInterC2, const Adaptor2d_Curve2d& C2, const Standard_Integer NumInterC2, const TColStd_Array1OfReal& Tab2, const IntRes2d_Domain& D2, const Standard_Real TolConf, const Standard_Real Tol);
+ Standard_EXPORT void InternalCompositePerform_noRecurs (const Standard_Integer NbInterC1, const Handle(Adaptor2d_Curve2d)& C1, const Standard_Integer NumInterC1, const TColStd_Array1OfReal& Tab1, const IntRes2d_Domain& D1, const Standard_Integer NbInterC2, const Handle(Adaptor2d_Curve2d)& C2, const Standard_Integer NumInterC2, const TColStd_Array1OfReal& Tab2, const IntRes2d_Domain& D2, const Standard_Real TolConf, const Standard_Real Tol);
//! Intersection between 2 curves.
- Standard_EXPORT void InternalCompositePerform (const Adaptor2d_Curve2d& C1, const IntRes2d_Domain& D1, const Standard_Integer N1, const Standard_Integer NB1, const TColStd_Array1OfReal& Tab1, const Adaptor2d_Curve2d& C2, const IntRes2d_Domain& D2, const Standard_Integer N2, const Standard_Integer NB2, const TColStd_Array1OfReal& Tab2, const Standard_Real TolConf, const Standard_Real Tol, const Standard_Boolean Composite);
+ Standard_EXPORT void InternalCompositePerform (const Handle(Adaptor2d_Curve2d)& C1, const IntRes2d_Domain& D1, const Standard_Integer N1, const Standard_Integer NB1, const TColStd_Array1OfReal& Tab1, const Handle(Adaptor2d_Curve2d)& C2, const IntRes2d_Domain& D2, const Standard_Integer N2, const Standard_Integer NB2, const TColStd_Array1OfReal& Tab2, const Standard_Real TolConf, const Standard_Real Tol, const Standard_Boolean Composite);
Standard_Real param1inf;
};
-#define TheCurve Adaptor2d_Curve2d
+#define TheCurve Handle(Adaptor2d_Curve2d)
#define TheCurve_hxx <Adaptor2d_Curve2d.hxx>
#define TheCurveTool Geom2dInt_Geom2dCurveTool
#define TheCurveTool_hxx <Geom2dInt_Geom2dCurveTool.hxx>
#include <IntRes2d_Domain.hxx>
-#define TheCurve Adaptor2d_Curve2d
+#define TheCurve Handle(Adaptor2d_Curve2d)
#define TheCurve_hxx <Adaptor2d_Curve2d.hxx>
#define TheCurveTool Geom2dInt_Geom2dCurveTool
#define TheCurveTool_hxx <Geom2dInt_Geom2dCurveTool.hxx>
#include <Precision.hxx>
//============================================================
-Standard_Integer Geom2dInt_Geom2dCurveTool::NbSamples (const Adaptor2d_Curve2d& C,
+Standard_Integer Geom2dInt_Geom2dCurveTool::NbSamples (const Handle(Adaptor2d_Curve2d)& C,
const Standard_Real U0,
const Standard_Real U1)
{
- GeomAbs_CurveType typC = C.GetType();
- Standard_Integer nbs = C.NbSamples();
+ GeomAbs_CurveType typC = C->GetType();
+ Standard_Integer nbs = C->NbSamples();
if(typC == GeomAbs_BSplineCurve)
{
- Standard_Real t=C.LastParameter()-C.FirstParameter();
+ 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();
+ nbs = C->NbKnots();
+ nbs*= C->Degree();
Standard_Real anb = t1 / t * nbs;
nbs = (Standard_Integer)anb;
- Standard_Integer aMinPntNb = Max(C.Degree() + 1, 4);
+ Standard_Integer aMinPntNb = Max(C->Degree() + 1, 4);
if(nbs < aMinPntNb)
nbs = aMinPntNb;
}
{
//Try to reach deflection = eps*R, eps = 0.01
const Standard_Real minR = 1.; //eps = 0.01
- Standard_Real R = C.Circle().Radius();
+ Standard_Real R = C->Circle().Radius();
if(R > minR)
{
Standard_Real angl = 0.283079; //2.*ACos(1. - eps);
}
//============================================================
-Standard_Integer Geom2dInt_Geom2dCurveTool::NbSamples (const Adaptor2d_Curve2d& C) {
- Standard_Integer nbs = C.NbSamples();
- GeomAbs_CurveType typC = C.GetType();
+Standard_Integer Geom2dInt_Geom2dCurveTool::NbSamples (const Handle(Adaptor2d_Curve2d)& C) {
+ Standard_Integer nbs = C->NbSamples();
+ GeomAbs_CurveType typC = C->GetType();
if (typC == GeomAbs_Circle)
{
//Try to reach deflection = eps*R, eps = 0.01
const Standard_Real minR = 1.; //eps = 0.01
- Standard_Real R = C.Circle().Radius();
+ Standard_Real R = C->Circle().Radius();
if(R > minR)
{
Standard_Real angl = 0.283079; //2.*ACos(1. - eps);
- Standard_Integer n = RealToInt((C.LastParameter()-C.FirstParameter()) / angl);
+ Standard_Integer n = RealToInt((C->LastParameter()-C->FirstParameter()) / angl);
nbs = Max(n, nbs);
}
}
DEFINE_STANDARD_ALLOC
- static GeomAbs_CurveType GetType (const Adaptor2d_Curve2d& C);
+ static GeomAbs_CurveType GetType (const Handle(Adaptor2d_Curve2d)& C);
- static Standard_Boolean IsComposite (const Adaptor2d_Curve2d& C);
+ static Standard_Boolean IsComposite (const Handle(Adaptor2d_Curve2d)& C);
//! Returns the Lin2d from gp corresponding to the curve C.
//! This method is called only when TheType returns
//! GeomAbs_Line.
- static gp_Lin2d Line (const Adaptor2d_Curve2d& C);
+ static gp_Lin2d Line (const Handle(Adaptor2d_Curve2d)& C);
//! Returns the Circ2d from gp corresponding to the curve C.
//! This method is called only when TheType returns
//! GeomAbs_Circle.
- static gp_Circ2d Circle (const Adaptor2d_Curve2d& C);
+ static gp_Circ2d Circle (const Handle(Adaptor2d_Curve2d)& C);
//! Returns the Elips2d from gp corresponding to the curve C.
//! This method is called only when TheType returns
//! GeomAbs_Ellipse.
- static gp_Elips2d Ellipse (const Adaptor2d_Curve2d& C);
+ static gp_Elips2d Ellipse (const Handle(Adaptor2d_Curve2d)& C);
//! Returns the Parab2d from gp corresponding to the curve C.
//! This method is called only when TheType returns
//! GeomAbs_Parabola.
- static gp_Parab2d Parabola (const Adaptor2d_Curve2d& C);
+ static gp_Parab2d Parabola (const Handle(Adaptor2d_Curve2d)& C);
//! Returns the Hypr2d from gp corresponding to the curve C.
//! This method is called only when TheType returns
//! GeomAbs_Hyperbola.
- static gp_Hypr2d Hyperbola (const Adaptor2d_Curve2d& C);
+ static gp_Hypr2d Hyperbola (const Handle(Adaptor2d_Curve2d)& C);
- static Standard_Real EpsX (const Adaptor2d_Curve2d& C);
+ static Standard_Real EpsX (const Handle(Adaptor2d_Curve2d)& C);
- static Standard_Real EpsX (const Adaptor2d_Curve2d& C, const Standard_Real Eps_XYZ);
+ static Standard_Real EpsX (const Handle(Adaptor2d_Curve2d)& C, const Standard_Real Eps_XYZ);
- Standard_EXPORT static Standard_Integer NbSamples (const Adaptor2d_Curve2d& C);
+ Standard_EXPORT static Standard_Integer NbSamples (const Handle(Adaptor2d_Curve2d)& C);
- Standard_EXPORT static Standard_Integer NbSamples (const Adaptor2d_Curve2d& C, const Standard_Real U0, const Standard_Real U1);
+ Standard_EXPORT static Standard_Integer NbSamples (const Handle(Adaptor2d_Curve2d)& C, const Standard_Real U0, const Standard_Real U1);
- static Standard_Real FirstParameter (const Adaptor2d_Curve2d& C);
+ static Standard_Real FirstParameter (const Handle(Adaptor2d_Curve2d)& C);
- static Standard_Real LastParameter (const Adaptor2d_Curve2d& C);
+ static Standard_Real LastParameter (const Handle(Adaptor2d_Curve2d)& C);
- static gp_Pnt2d Value (const Adaptor2d_Curve2d& C, const Standard_Real X);
+ static gp_Pnt2d Value (const Handle(Adaptor2d_Curve2d)& C, const Standard_Real X);
- static void D0 (const Adaptor2d_Curve2d& C, const Standard_Real U, gp_Pnt2d& P);
+ static void D0 (const Handle(Adaptor2d_Curve2d)& C, const Standard_Real U, gp_Pnt2d& P);
- static void D1 (const Adaptor2d_Curve2d& C, const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& T);
+ static void D1 (const Handle(Adaptor2d_Curve2d)& C, const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& T);
- static void D2 (const Adaptor2d_Curve2d& C, const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& T, gp_Vec2d& N);
+ static void D2 (const Handle(Adaptor2d_Curve2d)& C, const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& T, gp_Vec2d& N);
- static void D3 (const Adaptor2d_Curve2d& C, const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& T, gp_Vec2d& N, gp_Vec2d& V);
+ static void D3 (const Handle(Adaptor2d_Curve2d)& C, const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& T, gp_Vec2d& N, gp_Vec2d& V);
- static gp_Vec2d DN (const Adaptor2d_Curve2d& C, const Standard_Real U, const Standard_Integer N);
+ static gp_Vec2d DN (const Handle(Adaptor2d_Curve2d)& C, const Standard_Real U, const Standard_Integer N);
//! output the number of interval of continuity C2 of
//! the curve
- static Standard_Integer NbIntervals (const Adaptor2d_Curve2d& C);
+ static Standard_Integer NbIntervals (const Handle(Adaptor2d_Curve2d)& C);
//! compute Tab.
- static void Intervals (const Adaptor2d_Curve2d& C, TColStd_Array1OfReal& Tab);
+ static void Intervals (const Handle(Adaptor2d_Curve2d)& C, TColStd_Array1OfReal& Tab);
//! output the bounds of interval of index <Index>
//! used if Type == Composite.
- static void GetInterval (const Adaptor2d_Curve2d& C, const Standard_Integer Index, const TColStd_Array1OfReal& Tab, Standard_Real& U1, Standard_Real& U2);
+ static void GetInterval (const Handle(Adaptor2d_Curve2d)& C, const Standard_Integer Index, const TColStd_Array1OfReal& Tab, Standard_Real& U1, Standard_Real& U2);
- static Standard_Integer Degree (const Adaptor2d_Curve2d& C);
+ static Standard_Integer Degree (const Handle(Adaptor2d_Curve2d)& C);
#define IS_C2_COMPOSITE 0
//============================================================
-inline GeomAbs_CurveType Geom2dInt_Geom2dCurveTool::GetType(const Adaptor2d_Curve2d& C) {
- return(C.GetType());
+inline GeomAbs_CurveType Geom2dInt_Geom2dCurveTool::GetType(const Handle(Adaptor2d_Curve2d)& C) {
+ return(C->GetType());
}
//============================================================
-inline gp_Lin2d Geom2dInt_Geom2dCurveTool::Line (const Adaptor2d_Curve2d& C) {
- return(C.Line());
+inline gp_Lin2d Geom2dInt_Geom2dCurveTool::Line (const Handle(Adaptor2d_Curve2d)& C) {
+ return(C->Line());
}
//============================================================
-inline gp_Circ2d Geom2dInt_Geom2dCurveTool::Circle (const Adaptor2d_Curve2d& C) {
- return(C.Circle());
+inline gp_Circ2d Geom2dInt_Geom2dCurveTool::Circle (const Handle(Adaptor2d_Curve2d)& C) {
+ return(C->Circle());
}
//============================================================
-inline gp_Elips2d Geom2dInt_Geom2dCurveTool::Ellipse (const Adaptor2d_Curve2d& C) {
- return(C.Ellipse());
+inline gp_Elips2d Geom2dInt_Geom2dCurveTool::Ellipse (const Handle(Adaptor2d_Curve2d)& C) {
+ return(C->Ellipse());
}
//============================================================
-inline gp_Parab2d Geom2dInt_Geom2dCurveTool::Parabola (const Adaptor2d_Curve2d& C) {
- return(C.Parabola());
+inline gp_Parab2d Geom2dInt_Geom2dCurveTool::Parabola (const Handle(Adaptor2d_Curve2d)& C) {
+ return(C->Parabola());
}
//============================================================
-inline gp_Hypr2d Geom2dInt_Geom2dCurveTool::Hyperbola (const Adaptor2d_Curve2d& C) {
- return(C.Hyperbola());
+inline gp_Hypr2d Geom2dInt_Geom2dCurveTool::Hyperbola (const Handle(Adaptor2d_Curve2d)& C) {
+ return(C->Hyperbola());
}
//============================================================
-inline gp_Pnt2d Geom2dInt_Geom2dCurveTool::Value (const Adaptor2d_Curve2d& C,
+inline gp_Pnt2d Geom2dInt_Geom2dCurveTool::Value (const Handle(Adaptor2d_Curve2d)& C,
const Standard_Real U) {
- return(C.Value(U));
+ return(C->Value(U));
}
//============================================================
-inline void Geom2dInt_Geom2dCurveTool::D0(const Adaptor2d_Curve2d& C,
+inline void Geom2dInt_Geom2dCurveTool::D0(const Handle(Adaptor2d_Curve2d)& C,
const Standard_Real U,
gp_Pnt2d& P) {
- C.D0(U,P);
+ C->D0(U,P);
}
//============================================================
-inline void Geom2dInt_Geom2dCurveTool::D1 (const Adaptor2d_Curve2d& C,
+inline void Geom2dInt_Geom2dCurveTool::D1 (const Handle(Adaptor2d_Curve2d)& C,
const Standard_Real U,
gp_Pnt2d& P,
gp_Vec2d& T) {
- C.D1(U,P,T);
+ C->D1(U,P,T);
}
//============================================================
-inline void Geom2dInt_Geom2dCurveTool::D2 (const Adaptor2d_Curve2d& C,
+inline void Geom2dInt_Geom2dCurveTool::D2 (const Handle(Adaptor2d_Curve2d)& C,
const Standard_Real U,
gp_Pnt2d& P,
gp_Vec2d& T,
gp_Vec2d& N) {
- C.D2(U,P,T,N);
+ C->D2(U,P,T,N);
}
//============================================================
-inline void Geom2dInt_Geom2dCurveTool::D3 (const Adaptor2d_Curve2d& C,
+inline void Geom2dInt_Geom2dCurveTool::D3 (const Handle(Adaptor2d_Curve2d)& C,
const Standard_Real U,
gp_Pnt2d& P,
gp_Vec2d& T,
gp_Vec2d& N,
gp_Vec2d& V) {
- C.D3(U,P,T,N,V);
+ C->D3(U,P,T,N,V);
}
//============================================================
-inline gp_Vec2d Geom2dInt_Geom2dCurveTool::DN(const Adaptor2d_Curve2d& C,
+inline gp_Vec2d Geom2dInt_Geom2dCurveTool::DN(const Handle(Adaptor2d_Curve2d)& C,
const Standard_Real U,
const Standard_Integer N)
{
- return C.DN(U,N);
+ return C->DN(U,N);
}
//============================================================
-inline Standard_Real Geom2dInt_Geom2dCurveTool::FirstParameter (const Adaptor2d_Curve2d& C) {
- return(C.FirstParameter());
+inline Standard_Real Geom2dInt_Geom2dCurveTool::FirstParameter (const Handle(Adaptor2d_Curve2d)& C) {
+ return(C->FirstParameter());
}
//============================================================
-inline Standard_Real Geom2dInt_Geom2dCurveTool::LastParameter (const Adaptor2d_Curve2d& C) {
- return(C.LastParameter());
+inline Standard_Real Geom2dInt_Geom2dCurveTool::LastParameter (const Handle(Adaptor2d_Curve2d)& C) {
+ return(C->LastParameter());
}
//============================================================
//== tolerance used by mathemetical algorithms
//==
-inline Standard_Real Geom2dInt_Geom2dCurveTool::EpsX (const Adaptor2d_Curve2d& ) {
+inline Standard_Real Geom2dInt_Geom2dCurveTool::EpsX (const Handle(Adaptor2d_Curve2d)& ) {
return(1.0e-10);
}
//------------------------------------------------------------
-inline Standard_Real Geom2dInt_Geom2dCurveTool::EpsX (const Adaptor2d_Curve2d& C,const Standard_Real Eps_XYZ) {
- return(C.Resolution(Eps_XYZ));
+inline Standard_Real Geom2dInt_Geom2dCurveTool::EpsX (const Handle(Adaptor2d_Curve2d)& C,const Standard_Real Eps_XYZ) {
+ return(C->Resolution(Eps_XYZ));
}
//============================================================
-inline void Geom2dInt_Geom2dCurveTool::Intervals(const Adaptor2d_Curve2d& C,
+inline void Geom2dInt_Geom2dCurveTool::Intervals(const Handle(Adaptor2d_Curve2d)& C,
TColStd_Array1OfReal& Tab) {
#if IS_C2_COMPOSITE
- C.Intervals(Tab,GeomAbs_C2);
+ C->Intervals(Tab,GeomAbs_C2);
#else
- C.Intervals(Tab,GeomAbs_C1);
+ C->Intervals(Tab,GeomAbs_C1);
#endif
}
//============================================================
-//inline void Geom2dInt_Geom2dCurveTool::GetInterval(const Adaptor2d_Curve2d& C,
-inline void Geom2dInt_Geom2dCurveTool::GetInterval(const Adaptor2d_Curve2d& ,
+//inline void Geom2dInt_Geom2dCurveTool::GetInterval(const Handle(Adaptor2d_Curve2d)& C,
+inline void Geom2dInt_Geom2dCurveTool::GetInterval(const Handle(Adaptor2d_Curve2d)& ,
const Standard_Integer i,
const TColStd_Array1OfReal& Tab,
Standard_Real& a,
b = Tab.Value(i+1);
}
//============================================================
-inline Standard_Integer Geom2dInt_Geom2dCurveTool::NbIntervals(const Adaptor2d_Curve2d& C) {
+inline Standard_Integer Geom2dInt_Geom2dCurveTool::NbIntervals(const Handle(Adaptor2d_Curve2d)& C) {
Standard_Integer N=1;
#if IS_C2_COMPOSITE
- N = C.NbIntervals(GeomAbs_C2);
+ N = C->NbIntervals(GeomAbs_C2);
#else
- N = C.NbIntervals(GeomAbs_C1);
+ N = C->NbIntervals(GeomAbs_C1);
#endif
return(N);
}
//============================================================
- inline Standard_Integer Geom2dInt_Geom2dCurveTool::Degree(const Adaptor2d_Curve2d& C)
+ inline Standard_Integer Geom2dInt_Geom2dCurveTool::Degree(const Handle(Adaptor2d_Curve2d)& C)
{
- return C.Degree();
+ return C->Degree();
}
Standard_EXPORT Geom2dInt_IntConicCurveOfGInter();
//! Intersection between a line and a parametric curve.
- Standard_EXPORT Geom2dInt_IntConicCurveOfGInter(const gp_Lin2d& L, const IntRes2d_Domain& D1, const Adaptor2d_Curve2d& PCurve, const IntRes2d_Domain& D2, const Standard_Real TolConf, const Standard_Real Tol);
+ Standard_EXPORT Geom2dInt_IntConicCurveOfGInter(const gp_Lin2d& L, const IntRes2d_Domain& D1, const Handle(Adaptor2d_Curve2d)& PCurve, const IntRes2d_Domain& D2, const Standard_Real TolConf, const Standard_Real Tol);
//! Intersection between a line and a parametric curve.
- Standard_EXPORT Geom2dInt_IntConicCurveOfGInter(const gp_Circ2d& C, const IntRes2d_Domain& D1, const Adaptor2d_Curve2d& PCurve, const IntRes2d_Domain& D2, const Standard_Real TolConf, const Standard_Real Tol);
+ Standard_EXPORT Geom2dInt_IntConicCurveOfGInter(const gp_Circ2d& C, const IntRes2d_Domain& D1, const Handle(Adaptor2d_Curve2d)& PCurve, const IntRes2d_Domain& D2, const Standard_Real TolConf, const Standard_Real Tol);
//! Intersection between an ellipse and a parametric curve.
- Standard_EXPORT Geom2dInt_IntConicCurveOfGInter(const gp_Elips2d& E, const IntRes2d_Domain& D1, const Adaptor2d_Curve2d& PCurve, const IntRes2d_Domain& D2, const Standard_Real TolConf, const Standard_Real Tol);
+ Standard_EXPORT Geom2dInt_IntConicCurveOfGInter(const gp_Elips2d& E, const IntRes2d_Domain& D1, const Handle(Adaptor2d_Curve2d)& PCurve, const IntRes2d_Domain& D2, const Standard_Real TolConf, const Standard_Real Tol);
//! Intersection between a parabola and a parametric curve.
- Standard_EXPORT Geom2dInt_IntConicCurveOfGInter(const gp_Parab2d& Prb, const IntRes2d_Domain& D1, const Adaptor2d_Curve2d& PCurve, const IntRes2d_Domain& D2, const Standard_Real TolConf, const Standard_Real Tol);
+ Standard_EXPORT Geom2dInt_IntConicCurveOfGInter(const gp_Parab2d& Prb, const IntRes2d_Domain& D1, const Handle(Adaptor2d_Curve2d)& PCurve, const IntRes2d_Domain& D2, const Standard_Real TolConf, const Standard_Real Tol);
//! Intersection between the main branch of an hyperbola
//! and a parametric curve.
- Standard_EXPORT Geom2dInt_IntConicCurveOfGInter(const gp_Hypr2d& H, const IntRes2d_Domain& D1, const Adaptor2d_Curve2d& PCurve, const IntRes2d_Domain& D2, const Standard_Real TolConf, const Standard_Real Tol);
+ Standard_EXPORT Geom2dInt_IntConicCurveOfGInter(const gp_Hypr2d& H, const IntRes2d_Domain& D1, const Handle(Adaptor2d_Curve2d)& PCurve, const IntRes2d_Domain& D2, const Standard_Real TolConf, const Standard_Real Tol);
//! Intersection between a line and a parametric curve.
- Standard_EXPORT void Perform (const gp_Lin2d& L, const IntRes2d_Domain& D1, const Adaptor2d_Curve2d& PCurve, const IntRes2d_Domain& D2, const Standard_Real TolConf, const Standard_Real Tol);
+ Standard_EXPORT void Perform (const gp_Lin2d& L, const IntRes2d_Domain& D1, const Handle(Adaptor2d_Curve2d)& PCurve, const IntRes2d_Domain& D2, const Standard_Real TolConf, const Standard_Real Tol);
//! Intersection between a line and a parametric curve.
- Standard_EXPORT void Perform (const gp_Circ2d& C, const IntRes2d_Domain& D1, const Adaptor2d_Curve2d& PCurve, const IntRes2d_Domain& D2, const Standard_Real TolConf, const Standard_Real Tol);
+ Standard_EXPORT void Perform (const gp_Circ2d& C, const IntRes2d_Domain& D1, const Handle(Adaptor2d_Curve2d)& PCurve, const IntRes2d_Domain& D2, const Standard_Real TolConf, const Standard_Real Tol);
//! Intersection between an ellipse and a parametric curve.
- Standard_EXPORT void Perform (const gp_Elips2d& E, const IntRes2d_Domain& D1, const Adaptor2d_Curve2d& PCurve, const IntRes2d_Domain& D2, const Standard_Real TolConf, const Standard_Real Tol);
+ Standard_EXPORT void Perform (const gp_Elips2d& E, const IntRes2d_Domain& D1, const Handle(Adaptor2d_Curve2d)& PCurve, const IntRes2d_Domain& D2, const Standard_Real TolConf, const Standard_Real Tol);
//! Intersection between a parabola and a parametric curve.
- Standard_EXPORT void Perform (const gp_Parab2d& Prb, const IntRes2d_Domain& D1, const Adaptor2d_Curve2d& PCurve, const IntRes2d_Domain& D2, const Standard_Real TolConf, const Standard_Real Tol);
+ Standard_EXPORT void Perform (const gp_Parab2d& Prb, const IntRes2d_Domain& D1, const Handle(Adaptor2d_Curve2d)& PCurve, const IntRes2d_Domain& D2, const Standard_Real TolConf, const Standard_Real Tol);
//! Intersection between the main branch of an hyperbola
//! and a parametric curve.
- Standard_EXPORT void Perform (const gp_Hypr2d& H, const IntRes2d_Domain& D1, const Adaptor2d_Curve2d& PCurve, const IntRes2d_Domain& D2, const Standard_Real TolConf, const Standard_Real Tol);
+ Standard_EXPORT void Perform (const gp_Hypr2d& H, const IntRes2d_Domain& D1, const Handle(Adaptor2d_Curve2d)& PCurve, const IntRes2d_Domain& D2, const Standard_Real TolConf, const Standard_Real Tol);
private:
- Standard_EXPORT void InternalPerform (const gp_Lin2d& Lin1, const IntRes2d_Domain& D1, const Adaptor2d_Curve2d& PCurve, const IntRes2d_Domain& D2, const Standard_Real TolConf, const Standard_Real Tol, const Standard_Boolean Composite);
+ Standard_EXPORT void InternalPerform (const gp_Lin2d& Lin1, const IntRes2d_Domain& D1, const Handle(Adaptor2d_Curve2d)& PCurve, const IntRes2d_Domain& D2, const Standard_Real TolConf, const Standard_Real Tol, const Standard_Boolean Composite);
- Standard_EXPORT void InternalPerform (const gp_Circ2d& Circ1, const IntRes2d_Domain& D1, const Adaptor2d_Curve2d& PCurve, const IntRes2d_Domain& D2, const Standard_Real TolConf, const Standard_Real Tol, const Standard_Boolean Composite);
+ Standard_EXPORT void InternalPerform (const gp_Circ2d& Circ1, const IntRes2d_Domain& D1, const Handle(Adaptor2d_Curve2d)& PCurve, const IntRes2d_Domain& D2, const Standard_Real TolConf, const Standard_Real Tol, const Standard_Boolean Composite);
- Standard_EXPORT void InternalPerform (const gp_Elips2d& Eli1, const IntRes2d_Domain& D1, const Adaptor2d_Curve2d& PCurve, const IntRes2d_Domain& D2, const Standard_Real TolConf, const Standard_Real Tol, const Standard_Boolean Composite);
+ Standard_EXPORT void InternalPerform (const gp_Elips2d& Eli1, const IntRes2d_Domain& D1, const Handle(Adaptor2d_Curve2d)& PCurve, const IntRes2d_Domain& D2, const Standard_Real TolConf, const Standard_Real Tol, const Standard_Boolean Composite);
- Standard_EXPORT void InternalPerform (const gp_Parab2d& Prb1, const IntRes2d_Domain& D1, const Adaptor2d_Curve2d& PCurve, const IntRes2d_Domain& D2, const Standard_Real TolConf, const Standard_Real Tol, const Standard_Boolean Composite);
+ Standard_EXPORT void InternalPerform (const gp_Parab2d& Prb1, const IntRes2d_Domain& D1, const Handle(Adaptor2d_Curve2d)& PCurve, const IntRes2d_Domain& D2, const Standard_Real TolConf, const Standard_Real Tol, const Standard_Boolean Composite);
- Standard_EXPORT void InternalPerform (const gp_Hypr2d& Hpr1, const IntRes2d_Domain& D1, const Adaptor2d_Curve2d& PCurve, const IntRes2d_Domain& D2, const Standard_Real TolConf, const Standard_Real Tol, const Standard_Boolean Composite);
+ Standard_EXPORT void InternalPerform (const gp_Hypr2d& Hpr1, const IntRes2d_Domain& D1, const Handle(Adaptor2d_Curve2d)& PCurve, const IntRes2d_Domain& D2, const Standard_Real TolConf, const Standard_Real Tol, const Standard_Boolean Composite);
Standard_Real param1inf;
#define TheImpTool IntCurve_IConicTool
#define TheImpTool_hxx <IntCurve_IConicTool.hxx>
-#define ThePCurve Adaptor2d_Curve2d
+#define ThePCurve Handle(Adaptor2d_Curve2d)
#define ThePCurve_hxx <Adaptor2d_Curve2d.hxx>
#define ThePCurveTool Geom2dInt_Geom2dCurveTool
#define ThePCurveTool_hxx <Geom2dInt_Geom2dCurveTool.hxx>
//! Constructor of the class.
- Standard_EXPORT Geom2dInt_MyImpParToolOfTheIntersectorOfTheIntConicCurveOfGInter(const IntCurve_IConicTool& IT, const Adaptor2d_Curve2d& PC);
+ Standard_EXPORT Geom2dInt_MyImpParToolOfTheIntersectorOfTheIntConicCurveOfGInter(const IntCurve_IConicTool& IT, const Handle(Adaptor2d_Curve2d)& PC);
//! Computes the value of the signed distance between
//! the implicit curve and the point at parameter Param
#define ImpTool IntCurve_IConicTool
#define ImpTool_hxx <IntCurve_IConicTool.hxx>
-#define ParCurve Adaptor2d_Curve2d
+#define ParCurve Handle(Adaptor2d_Curve2d)
#define ParCurve_hxx <Adaptor2d_Curve2d.hxx>
#define ParTool Geom2dInt_Geom2dCurveTool
#define ParTool_hxx <Geom2dInt_Geom2dCurveTool.hxx>
Standard_EXPORT Geom2dInt_PCLocFOfTheLocateExtPCOfTheProjPCurOfGInter();
- Standard_EXPORT Geom2dInt_PCLocFOfTheLocateExtPCOfTheProjPCurOfGInter(const gp_Pnt2d& P, const Adaptor2d_Curve2d& C);
+ Standard_EXPORT Geom2dInt_PCLocFOfTheLocateExtPCOfTheProjPCurOfGInter(const gp_Pnt2d& P, const Handle(Adaptor2d_Curve2d)& C);
//! sets the field mycurve of the function.
- Standard_EXPORT void Initialize (const Adaptor2d_Curve2d& C);
+ Standard_EXPORT void Initialize (const Handle(Adaptor2d_Curve2d)& C);
//! sets the field P of the function.
Standard_EXPORT void SetPoint (const gp_Pnt2d& P);
#include <gp_Vec2d.hxx>
#include <Extrema_SequenceOfPOnCurv2d.hxx>
-#define Curve Adaptor2d_Curve2d
+#define Curve Handle(Adaptor2d_Curve2d)
#define Curve_hxx <Adaptor2d_Curve2d.hxx>
#define Tool Geom2dInt_Geom2dCurveTool
#define Tool_hxx <Geom2dInt_Geom2dCurveTool.hxx>
//! Among a set of points {C(ui),i=1,NbU}, locate the point
//! P=C(uj) such that:
//! distance(P,C) = Min{distance(P,C(ui))}
- Standard_EXPORT static void Locate (const gp_Pnt2d& P, const Adaptor2d_Curve2d& C, const Standard_Integer NbU, Extrema_POnCurv2d& Papp);
+ Standard_EXPORT static void Locate (const gp_Pnt2d& P, const Handle(Adaptor2d_Curve2d)& C, const Standard_Integer NbU, Extrema_POnCurv2d& Papp);
//! Among a set of points {C(ui),i=1,NbU}, locate the point
//! P=C(uj) such that:
//! distance(P,C) = Min{distance(P,C(ui))}
//! The research is done between umin and usup.
- Standard_EXPORT static void Locate (const gp_Pnt2d& P, const Adaptor2d_Curve2d& C, const Standard_Integer NbU, const Standard_Real Umin, const Standard_Real Usup, Extrema_POnCurv2d& Papp);
+ Standard_EXPORT static void Locate (const gp_Pnt2d& P, const Handle(Adaptor2d_Curve2d)& C, const Standard_Integer NbU, const Standard_Real Umin, const Standard_Real Usup, Extrema_POnCurv2d& Papp);
//! Among two sets of points {C1(ui),i=1,NbU} and
//! {C2(vj),j=1,NbV}, locate the two points P1=C1(uk) and
//! P2=C2(vl) such that:
//! distance(P1,P2) = Min {distance(C1(ui),C2(vj))}.
- Standard_EXPORT static void Locate (const Adaptor2d_Curve2d& C1, const Adaptor2d_Curve2d& C2, const Standard_Integer NbU, const Standard_Integer NbV, Extrema_POnCurv2d& Papp1, Extrema_POnCurv2d& Papp2);
+ Standard_EXPORT static void Locate (const Handle(Adaptor2d_Curve2d)& C1, const Handle(Adaptor2d_Curve2d)& C2, const Standard_Integer NbU, const Standard_Integer NbV, Extrema_POnCurv2d& Papp1, Extrema_POnCurv2d& Papp2);
#include <gp_Pnt2d.hxx>
-#define Curve1 Adaptor2d_Curve2d
+#define Curve1 Handle(Adaptor2d_Curve2d)
#define Curve1_hxx <Adaptor2d_Curve2d.hxx>
#define Tool1 Geom2dInt_Geom2dCurveTool
#define Tool1_hxx <Geom2dInt_Geom2dCurveTool.hxx>
-#define Curve2 Adaptor2d_Curve2d
+#define Curve2 Handle(Adaptor2d_Curve2d)
#define Curve2_hxx <Adaptor2d_Curve2d.hxx>
#define Tool2 Geom2dInt_Geom2dCurveTool
#define Tool2_hxx <Geom2dInt_Geom2dCurveTool.hxx>
DEFINE_STANDARD_ALLOC
- Standard_EXPORT Geom2dInt_TheDistBetweenPCurvesOfTheIntPCurvePCurveOfGInter(const Adaptor2d_Curve2d& curve1, const Adaptor2d_Curve2d& curve2);
+ Standard_EXPORT Geom2dInt_TheDistBetweenPCurvesOfTheIntPCurvePCurveOfGInter(const Handle(Adaptor2d_Curve2d)& curve1, const Handle(Adaptor2d_Curve2d)& curve2);
//! returns 2.
Standard_EXPORT Standard_Integer NbVariables() const;
#include <math_Matrix.hxx>
-#define TheCurve Adaptor2d_Curve2d
+#define TheCurve Handle(Adaptor2d_Curve2d)
#define TheCurve_hxx <Adaptor2d_Curve2d.hxx>
#define TheCurveTool Geom2dInt_Geom2dCurveTool
#define TheCurveTool_hxx <Geom2dInt_Geom2dCurveTool.hxx>
Geom2dInt_TheIntConicCurveOfGInter();
//! Intersection between a line and a parametric curve.
- Geom2dInt_TheIntConicCurveOfGInter(const gp_Lin2d& L, const IntRes2d_Domain& D1, const Adaptor2d_Curve2d& PCurve, const IntRes2d_Domain& D2, const Standard_Real TolConf, const Standard_Real Tol);
+ Geom2dInt_TheIntConicCurveOfGInter(const gp_Lin2d& L, const IntRes2d_Domain& D1, const Handle(Adaptor2d_Curve2d)& PCurve, const IntRes2d_Domain& D2, const Standard_Real TolConf, const Standard_Real Tol);
//! Intersection between a line and a parametric curve.
- Standard_EXPORT Geom2dInt_TheIntConicCurveOfGInter(const gp_Circ2d& C, const IntRes2d_Domain& D1, const Adaptor2d_Curve2d& PCurve, const IntRes2d_Domain& D2, const Standard_Real TolConf, const Standard_Real Tol);
+ Standard_EXPORT Geom2dInt_TheIntConicCurveOfGInter(const gp_Circ2d& C, const IntRes2d_Domain& D1, const Handle(Adaptor2d_Curve2d)& PCurve, const IntRes2d_Domain& D2, const Standard_Real TolConf, const Standard_Real Tol);
//! Intersection between an ellipse and a parametric curve.
- Standard_EXPORT Geom2dInt_TheIntConicCurveOfGInter(const gp_Elips2d& E, const IntRes2d_Domain& D1, const Adaptor2d_Curve2d& PCurve, const IntRes2d_Domain& D2, const Standard_Real TolConf, const Standard_Real Tol);
+ Standard_EXPORT Geom2dInt_TheIntConicCurveOfGInter(const gp_Elips2d& E, const IntRes2d_Domain& D1, const Handle(Adaptor2d_Curve2d)& PCurve, const IntRes2d_Domain& D2, const Standard_Real TolConf, const Standard_Real Tol);
//! Intersection between a parabola and a parametric curve.
- Standard_EXPORT Geom2dInt_TheIntConicCurveOfGInter(const gp_Parab2d& Prb, const IntRes2d_Domain& D1, const Adaptor2d_Curve2d& PCurve, const IntRes2d_Domain& D2, const Standard_Real TolConf, const Standard_Real Tol);
+ Standard_EXPORT Geom2dInt_TheIntConicCurveOfGInter(const gp_Parab2d& Prb, const IntRes2d_Domain& D1, const Handle(Adaptor2d_Curve2d)& PCurve, const IntRes2d_Domain& D2, const Standard_Real TolConf, const Standard_Real Tol);
//! Intersection between the main branch of an hyperbola
//! and a parametric curve.
- Standard_EXPORT Geom2dInt_TheIntConicCurveOfGInter(const gp_Hypr2d& H, const IntRes2d_Domain& D1, const Adaptor2d_Curve2d& PCurve, const IntRes2d_Domain& D2, const Standard_Real TolConf, const Standard_Real Tol);
+ Standard_EXPORT Geom2dInt_TheIntConicCurveOfGInter(const gp_Hypr2d& H, const IntRes2d_Domain& D1, const Handle(Adaptor2d_Curve2d)& PCurve, const IntRes2d_Domain& D2, const Standard_Real TolConf, const Standard_Real Tol);
//! Intersection between a line and a parametric curve.
- void Perform (const gp_Lin2d& L, const IntRes2d_Domain& D1, const Adaptor2d_Curve2d& PCurve, const IntRes2d_Domain& D2, const Standard_Real TolConf, const Standard_Real Tol);
+ void Perform (const gp_Lin2d& L, const IntRes2d_Domain& D1, const Handle(Adaptor2d_Curve2d)& PCurve, const IntRes2d_Domain& D2, const Standard_Real TolConf, const Standard_Real Tol);
//! Intersection between a line and a parametric curve.
- void Perform (const gp_Circ2d& C, const IntRes2d_Domain& D1, const Adaptor2d_Curve2d& PCurve, const IntRes2d_Domain& D2, const Standard_Real TolConf, const Standard_Real Tol);
+ void Perform (const gp_Circ2d& C, const IntRes2d_Domain& D1, const Handle(Adaptor2d_Curve2d)& PCurve, const IntRes2d_Domain& D2, const Standard_Real TolConf, const Standard_Real Tol);
//! Intersection between an ellipse and a parametric curve.
- void Perform (const gp_Elips2d& E, const IntRes2d_Domain& D1, const Adaptor2d_Curve2d& PCurve, const IntRes2d_Domain& D2, const Standard_Real TolConf, const Standard_Real Tol);
+ void Perform (const gp_Elips2d& E, const IntRes2d_Domain& D1, const Handle(Adaptor2d_Curve2d)& PCurve, const IntRes2d_Domain& D2, const Standard_Real TolConf, const Standard_Real Tol);
//! Intersection between a parabola and a parametric curve.
- void Perform (const gp_Parab2d& Prb, const IntRes2d_Domain& D1, const Adaptor2d_Curve2d& PCurve, const IntRes2d_Domain& D2, const Standard_Real TolConf, const Standard_Real Tol);
+ void Perform (const gp_Parab2d& Prb, const IntRes2d_Domain& D1, const Handle(Adaptor2d_Curve2d)& PCurve, const IntRes2d_Domain& D2, const Standard_Real TolConf, const Standard_Real Tol);
//! Intersection between the main branch of an hyperbola
//! and a parametric curve.
- void Perform (const gp_Hypr2d& H, const IntRes2d_Domain& D1, const Adaptor2d_Curve2d& PCurve, const IntRes2d_Domain& D2, const Standard_Real TolConf, const Standard_Real Tol);
+ void Perform (const gp_Hypr2d& H, const IntRes2d_Domain& D1, const Handle(Adaptor2d_Curve2d)& PCurve, const IntRes2d_Domain& D2, const Standard_Real TolConf, const Standard_Real Tol);
//! Intersection between a conic fom gp
//! and a parametric curve.
- void Perform (const IntCurve_IConicTool& ICurve, const IntRes2d_Domain& D1, const Adaptor2d_Curve2d& PCurve, const IntRes2d_Domain& D2, const Standard_Real TolConf, const Standard_Real Tol);
+ void Perform (const IntCurve_IConicTool& ICurve, const IntRes2d_Domain& D1, const Handle(Adaptor2d_Curve2d)& PCurve, const IntRes2d_Domain& D2, const Standard_Real TolConf, const Standard_Real Tol);
#define TheImpTool IntCurve_IConicTool
#define TheImpTool_hxx <IntCurve_IConicTool.hxx>
-#define ThePCurve Adaptor2d_Curve2d
+#define ThePCurve Handle(Adaptor2d_Curve2d)
#define ThePCurve_hxx <Adaptor2d_Curve2d.hxx>
#define ThePCurveTool Geom2dInt_Geom2dCurveTool
#define ThePCurveTool_hxx <Geom2dInt_Geom2dCurveTool.hxx>
#define TheImpTool IntCurve_IConicTool
#define TheImpTool_hxx <IntCurve_IConicTool.hxx>
-#define ThePCurve Adaptor2d_Curve2d
+#define ThePCurve Handle(Adaptor2d_Curve2d)
#define ThePCurve_hxx <Adaptor2d_Curve2d.hxx>
#define ThePCurveTool Geom2dInt_Geom2dCurveTool
#define ThePCurveTool_hxx <Geom2dInt_Geom2dCurveTool.hxx>
Standard_EXPORT Geom2dInt_TheIntPCurvePCurveOfGInter();
- Standard_EXPORT void Perform (const Adaptor2d_Curve2d& Curve1, const IntRes2d_Domain& Domain1, const Adaptor2d_Curve2d& Curve2, const IntRes2d_Domain& Domain2, const Standard_Real TolConf, const Standard_Real Tol);
+ Standard_EXPORT void Perform (const Handle(Adaptor2d_Curve2d)& Curve1, const IntRes2d_Domain& Domain1, const Handle(Adaptor2d_Curve2d)& Curve2, const IntRes2d_Domain& Domain2, const Standard_Real TolConf, const Standard_Real Tol);
- Standard_EXPORT void Perform (const Adaptor2d_Curve2d& Curve1, const IntRes2d_Domain& Domain1, const Standard_Real TolConf, const Standard_Real Tol);
+ Standard_EXPORT void Perform (const Handle(Adaptor2d_Curve2d)& Curve1, const IntRes2d_Domain& Domain1, const Standard_Real TolConf, const Standard_Real Tol);
//! Set / get minimum number of points in polygon for intersection.
Standard_EXPORT void SetMinNbSamples (const Standard_Integer theMinNbSamples);
protected:
- Standard_EXPORT void Perform (const Adaptor2d_Curve2d& Curve1, const IntRes2d_Domain& Domain1, const Adaptor2d_Curve2d& Curve2, const IntRes2d_Domain& Domain2, const Standard_Real TolConf, const Standard_Real Tol, const Standard_Integer NbIter, const Standard_Real DeltaU, const Standard_Real DeltaV);
+ Standard_EXPORT void Perform (const Handle(Adaptor2d_Curve2d)& Curve1, const IntRes2d_Domain& Domain1, const Handle(Adaptor2d_Curve2d)& Curve2, const IntRes2d_Domain& Domain2, const Standard_Real TolConf, const Standard_Real Tol, const Standard_Integer NbIter, const Standard_Real DeltaU, const Standard_Real DeltaV);
- Standard_EXPORT void Perform (const Adaptor2d_Curve2d& Curve1, const IntRes2d_Domain& Domain1, const Standard_Real TolConf, const Standard_Real Tol, const Standard_Integer NbIter, const Standard_Real DeltaU, const Standard_Real DeltaV);
+ Standard_EXPORT void Perform (const Handle(Adaptor2d_Curve2d)& Curve1, const IntRes2d_Domain& Domain1, const Standard_Real TolConf, const Standard_Real Tol, const Standard_Integer NbIter, const Standard_Real DeltaU, const Standard_Real DeltaV);
private:
//! : were replaced on line and exact point of intersection was not found
//! : for case when point of intersection was found
//! : during prelimanary search for line (case of bad paramerization of Bspline for example).
- Standard_EXPORT Standard_Boolean findIntersect (const Adaptor2d_Curve2d& Curve1, const IntRes2d_Domain& Domain1, const Adaptor2d_Curve2d& Curve2, const IntRes2d_Domain& Domain2, const Standard_Real TolConf, const Standard_Real Tol, const Standard_Integer NbIter, const Standard_Real DeltaU, const Standard_Real DeltaV, const Geom2dInt_ThePolygon2dOfTheIntPCurvePCurveOfGInter& thePoly1, const Geom2dInt_ThePolygon2dOfTheIntPCurvePCurveOfGInter& thePoly2, const Standard_Boolean isFullRepresentation);
+ Standard_EXPORT Standard_Boolean findIntersect (const Handle(Adaptor2d_Curve2d)& Curve1, const IntRes2d_Domain& Domain1, const Handle(Adaptor2d_Curve2d)& Curve2, const IntRes2d_Domain& Domain2, const Standard_Real TolConf, const Standard_Real Tol, const Standard_Integer NbIter, const Standard_Real DeltaU, const Standard_Real DeltaV, const Geom2dInt_ThePolygon2dOfTheIntPCurvePCurveOfGInter& thePoly1, const Geom2dInt_ThePolygon2dOfTheIntPCurvePCurveOfGInter& thePoly2, const Standard_Boolean isFullRepresentation);
IntRes2d_Domain DomainOnCurve1;
IntRes2d_Domain DomainOnCurve2;
#include <IntRes2d_Domain.hxx>
-#define TheCurve Adaptor2d_Curve2d
+#define TheCurve Handle(Adaptor2d_Curve2d)
#define TheCurve_hxx <Adaptor2d_Curve2d.hxx>
#define TheCurveTool Geom2dInt_Geom2dCurveTool
#define TheCurveTool_hxx <Geom2dInt_Geom2dCurveTool.hxx>
//! The exception ConstructionError is raised if the domain
//! of the parametrised curve does not verify HasFirstPoint
//! and HasLastPoint return True.
- Standard_EXPORT Geom2dInt_TheIntersectorOfTheIntConicCurveOfGInter(const IntCurve_IConicTool& ITool, const IntRes2d_Domain& Dom1, const Adaptor2d_Curve2d& PCurve, const IntRes2d_Domain& Dom2, const Standard_Real TolConf, const Standard_Real Tol);
+ Standard_EXPORT Geom2dInt_TheIntersectorOfTheIntConicCurveOfGInter(const IntCurve_IConicTool& ITool, const IntRes2d_Domain& Dom1, const Handle(Adaptor2d_Curve2d)& PCurve, const IntRes2d_Domain& Dom2, const Standard_Real TolConf, const Standard_Real Tol);
//! Intersection between an implicit curve and
//! a parametrised curve.
//! The exception ConstructionError is raised if the domain
//! of the parametrised curve does not verify HasFirstPoint
//! and HasLastPoint return True.
- Standard_EXPORT void Perform (const IntCurve_IConicTool& ITool, const IntRes2d_Domain& Dom1, const Adaptor2d_Curve2d& PCurve, const IntRes2d_Domain& Dom2, const Standard_Real TolConf, const Standard_Real Tol);
+ Standard_EXPORT void Perform (const IntCurve_IConicTool& ITool, const IntRes2d_Domain& Dom1, const Handle(Adaptor2d_Curve2d)& PCurve, const IntRes2d_Domain& Dom2, const Standard_Real TolConf, const Standard_Real Tol);
- Standard_EXPORT Standard_Real FindU (const Standard_Real parameter, gp_Pnt2d& point, const Adaptor2d_Curve2d& TheParCurev, const IntCurve_IConicTool& TheImpTool) const;
+ Standard_EXPORT Standard_Real FindU (const Standard_Real parameter, gp_Pnt2d& point, const Handle(Adaptor2d_Curve2d)& TheParCurev, const IntCurve_IConicTool& TheImpTool) const;
- Standard_EXPORT Standard_Real FindV (const Standard_Real parameter, gp_Pnt2d& point, const IntCurve_IConicTool& TheImpTool, const Adaptor2d_Curve2d& ParCurve, const IntRes2d_Domain& TheParCurveDomain, const Standard_Real V0, const Standard_Real V1, const Standard_Real Tolerance) const;
+ Standard_EXPORT Standard_Real FindV (const Standard_Real parameter, gp_Pnt2d& point, const IntCurve_IConicTool& TheImpTool, const Handle(Adaptor2d_Curve2d)& ParCurve, const IntRes2d_Domain& TheParCurveDomain, const Standard_Real V0, const Standard_Real V1, const Standard_Real Tolerance) const;
- Standard_EXPORT void And_Domaine_Objet1_Intersections (const IntCurve_IConicTool& TheImpTool, const Adaptor2d_Curve2d& TheParCurve, const IntRes2d_Domain& TheImpCurveDomain, const IntRes2d_Domain& TheParCurveDomain, Standard_Integer& NbResultats, TColStd_Array1OfReal& Inter2_And_Domain2, TColStd_Array1OfReal& Inter1, TColStd_Array1OfReal& Resultat1, TColStd_Array1OfReal& Resultat2, const Standard_Real EpsNul) const;
+ Standard_EXPORT void And_Domaine_Objet1_Intersections (const IntCurve_IConicTool& TheImpTool, const Handle(Adaptor2d_Curve2d)& TheParCurve, const IntRes2d_Domain& TheImpCurveDomain, const IntRes2d_Domain& TheParCurveDomain, Standard_Integer& NbResultats, TColStd_Array1OfReal& Inter2_And_Domain2, TColStd_Array1OfReal& Inter1, TColStd_Array1OfReal& Resultat1, TColStd_Array1OfReal& Resultat2, const Standard_Real EpsNul) const;
#define ImpTool IntCurve_IConicTool
#define ImpTool_hxx <IntCurve_IConicTool.hxx>
-#define ParCurve Adaptor2d_Curve2d
+#define ParCurve Handle(Adaptor2d_Curve2d)
#define ParCurve_hxx <Adaptor2d_Curve2d.hxx>
#define ParTool Geom2dInt_Geom2dCurveTool
#define ParTool_hxx <Geom2dInt_Geom2dCurveTool.hxx>
//! TolU is used to decide to stop the iterations.
//! At the nth iteration, the criteria is:
//! abs(Un - Un-1) < TolU.
- Standard_EXPORT Geom2dInt_TheLocateExtPCOfTheProjPCurOfGInter(const gp_Pnt2d& P, const Adaptor2d_Curve2d& C, const Standard_Real U0, const Standard_Real TolU);
+ Standard_EXPORT Geom2dInt_TheLocateExtPCOfTheProjPCurOfGInter(const gp_Pnt2d& P, const Handle(Adaptor2d_Curve2d)& C, const Standard_Real U0, const Standard_Real TolU);
//! Calculates the distance with a close point.
//! The close point is defined by the parameter value
//! TolU is used to decide to stop the iterations.
//! At the nth iteration, the criteria is:
//! abs(Un - Un-1) < TolU.
- Standard_EXPORT Geom2dInt_TheLocateExtPCOfTheProjPCurOfGInter(const gp_Pnt2d& P, const Adaptor2d_Curve2d& C, const Standard_Real U0, const Standard_Real Umin, const Standard_Real Usup, const Standard_Real TolU);
+ Standard_EXPORT Geom2dInt_TheLocateExtPCOfTheProjPCurOfGInter(const gp_Pnt2d& P, const Handle(Adaptor2d_Curve2d)& C, const Standard_Real U0, const Standard_Real Umin, const Standard_Real Usup, const Standard_Real TolU);
//! sets the fields of the algorithm.
- Standard_EXPORT void Initialize (const Adaptor2d_Curve2d& C, const Standard_Real Umin, const Standard_Real Usup, const Standard_Real TolU);
+ Standard_EXPORT void Initialize (const Handle(Adaptor2d_Curve2d)& C, const Standard_Real Umin, const Standard_Real Usup, const Standard_Real TolU);
//! the algorithm is done with the point P.
//! An exception is raised if the fields have not
#include <Extrema_SequenceOfPOnCurv2d.hxx>
-#define Curve Adaptor2d_Curve2d
+#define Curve Handle(Adaptor2d_Curve2d)
#define Curve_hxx <Adaptor2d_Curve2d.hxx>
#define Tool Geom2dInt_Geom2dCurveTool
#define Tool_hxx <Geom2dInt_Geom2dCurveTool.hxx>
//! Compute a polygon on the domain of the curve.
- Standard_EXPORT Geom2dInt_ThePolygon2dOfTheIntPCurvePCurveOfGInter(const Adaptor2d_Curve2d& Curve, const Standard_Integer NbPnt, const IntRes2d_Domain& Domain, const Standard_Real Tol);
+ Standard_EXPORT Geom2dInt_ThePolygon2dOfTheIntPCurvePCurveOfGInter(const Handle(Adaptor2d_Curve2d)& Curve, const Standard_Integer NbPnt, const IntRes2d_Domain& Domain, const Standard_Real Tol);
//! The current polygon is modified if most
//! of the points of the polygon are
//! outside the box <OtherBox>. In this
//! situation, bounds are computed to build
//! a polygon inside or near the OtherBox.
- Standard_EXPORT void ComputeWithBox (const Adaptor2d_Curve2d& Curve, const Bnd_Box2d& OtherBox);
+ Standard_EXPORT void ComputeWithBox (const Handle(Adaptor2d_Curve2d)& Curve, const Bnd_Box2d& OtherBox);
virtual Standard_Real DeflectionOverEstimation() const Standard_OVERRIDE;
};
-#define TheCurve Adaptor2d_Curve2d
+#define TheCurve Handle(Adaptor2d_Curve2d)
#define TheCurve_hxx <Adaptor2d_Curve2d.hxx>
#define TheCurveTool Geom2dInt_Geom2dCurveTool
#define TheCurveTool_hxx <Geom2dInt_Geom2dCurveTool.hxx>
#include <gp_Pnt2d.hxx>
-#define TheCurve Adaptor2d_Curve2d
+#define TheCurve Handle(Adaptor2d_Curve2d)
#define TheCurve_hxx <Adaptor2d_Curve2d.hxx>
#define TheCurveTool Geom2dInt_Geom2dCurveTool
#define TheCurveTool_hxx <Geom2dInt_Geom2dCurveTool.hxx>
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
class Adaptor2d_Curve2d;
class Geom2dInt_Geom2dCurveTool;
//! In that case, no bounds are given. The research of
//! the right parameter has to be made on the natural
//! parametric domain of the curve.
- Standard_EXPORT static Standard_Real FindParameter (const Adaptor2d_Curve2d& C, const gp_Pnt2d& Pnt, const Standard_Real Tol);
+ Standard_EXPORT static Standard_Real FindParameter (const Handle(Adaptor2d_Curve2d)& C, const gp_Pnt2d& Pnt, const Standard_Real Tol);
//! Returns the parameter V of the point on the
//! parametric curve corresponding to the Point Pnt.
//! implement a more efficient algorithm. So, it is not
//! necessary to check that the returned value verifies
//! LowParameter <= Value <= HighParameter.
- Standard_EXPORT static Standard_Real FindParameter (const Adaptor2d_Curve2d& C, const gp_Pnt2d& Pnt, const Standard_Real LowParameter, const Standard_Real HighParameter, const Standard_Real Tol);
+ Standard_EXPORT static Standard_Real FindParameter (const Handle(Adaptor2d_Curve2d)& C, const gp_Pnt2d& Pnt, const Standard_Real LowParameter, const Standard_Real HighParameter, const Standard_Real Tol);
#include <gp_Pnt2d.hxx>
-#define TheCurve Adaptor2d_Curve2d
+#define TheCurve Handle(Adaptor2d_Curve2d)
#define TheCurve_hxx <Adaptor2d_Curve2d.hxx>
#define TheCurveTool Geom2dInt_Geom2dCurveTool
#define TheCurveTool_hxx <Geom2dInt_Geom2dCurveTool.hxx>
Handle(Geom_Plane) Plane = new Geom_Plane(P);
Handle(GeomAdaptor_Surface) HS = new GeomAdaptor_Surface(Plane);
- ProjLib_ProjectedCurve Proj(HS,HC);
+ Handle(ProjLib_ProjectedCurve) Proj = new ProjLib_ProjectedCurve(HS,HC);
- if (Proj.GetType() != GeomAbs_OffsetCurve &&
- Proj.GetType() != GeomAbs_OtherCurve) {
+ if (Proj->GetType() != GeomAbs_OffsetCurve &&
+ Proj->GetType() != GeomAbs_OtherCurve) {
result = Geom2dAdaptor::MakeCurve(Proj);
}
Handle(Geom_Plane) ThePlane = new Geom_Plane(P);
Handle(GeomAdaptor_Surface) AHS = new GeomAdaptor_Surface(ThePlane);
- Adaptor3d_CurveOnSurface COS(AHC,AHS);
- return GeomAdaptor::MakeCurve(COS);
+ Handle(Adaptor3d_CurveOnSurface) aCOS = new Adaptor3d_CurveOnSurface(AHC,AHS);
+ return GeomAdaptor::MakeCurve(aCOS);
}
GeomAPI_ExtremaCurveCurve::GeomAPI_ExtremaCurveCurve()
: myIsDone(Standard_False),
myIndex(0),
+ myC1(new GeomAdaptor_Curve()),
+ myC2(new GeomAdaptor_Curve()),
myTotalExt(Standard_False),
myIsInfinite(Standard_False),
myTotalDist(0.0)
myTotalExt = Standard_False;
Standard_Real Tol = Precision::PConfusion();
- myC1.Load(C1);
- myC2.Load(C2);
+ myC1 = new GeomAdaptor_Curve(C1);
+ myC2 = new GeomAdaptor_Curve(C2);
myExtCC.Initialize (myC1, myC2, Tol,Tol);
myExtCC.Perform();
myTotalExt = Standard_False;
Standard_Real Tol = Precision::PConfusion();
- myC1.Load(C1);
- myC2.Load(C2);
+ myC1 = new GeomAdaptor_Curve(C1);
+ myC2 = new GeomAdaptor_Curve(C2);
myExtCC.Initialize (myC1,myC2,U1min,U1max,U2min,U2max,Tol,Tol);
myExtCC.Perform();
// StdFail_NotDone_Raise_if
// (!myExtCC.IsDone(), "GeomAPI_ExtremaCurveCurve::TotalPerform");
- Standard_Real u11 = myC1.FirstParameter();
- Standard_Real u12 = myC1.LastParameter();
- Standard_Real u21 = myC2.FirstParameter();
- Standard_Real u22 = myC2.LastParameter();
+ Standard_Real u11 = myC1->FirstParameter();
+ Standard_Real u12 = myC1->LastParameter();
+ Standard_Real u21 = myC2->FirstParameter();
+ Standard_Real u22 = myC2->LastParameter();
Standard_Boolean infinite = Precision::IsInfinite(u11) &&
Precision::IsInfinite(u12) &&
//calculate distance between any suitable point on C1 and C2
- gp_Pnt PonC1 = myC1.Value(0.);
- GeomAPI_ProjectPointOnCurve proj(PonC1, myC2.Curve());
+ gp_Pnt PonC1 = myC1->Value(0.);
+ GeomAPI_ProjectPointOnCurve proj(PonC1, myC2->Curve());
myTotalDist = proj.LowerDistance();
return;
// calculate distances between extremities one curve and other curve
if(!Precision::IsInfinite(u11)) {
- GeomAPI_ProjectPointOnCurve proj(P11, myC2.Curve(), u21, u22);
+ GeomAPI_ProjectPointOnCurve proj(P11, myC2->Curve(), u21, u22);
if(proj.NbPoints() > 0) {
}
if(!Precision::IsInfinite(u12)) {
- GeomAPI_ProjectPointOnCurve proj(P12, myC2.Curve(), u21, u22);
+ GeomAPI_ProjectPointOnCurve proj(P12, myC2->Curve(), u21, u22);
if(proj.NbPoints() > 0) {
}
if(!Precision::IsInfinite(u21)) {
- GeomAPI_ProjectPointOnCurve proj(P21, myC1.Curve(), u11, u12);
+ GeomAPI_ProjectPointOnCurve proj(P21, myC1->Curve(), u11, u12);
if(proj.NbPoints() > 0) {
}
if(!Precision::IsInfinite(u22)) {
- GeomAPI_ProjectPointOnCurve proj(P22, myC1.Curve(), u11, u12);
+ GeomAPI_ProjectPointOnCurve proj(P22, myC1->Curve(), u11, u12);
if(proj.NbPoints() > 0) {
Standard_Boolean myIsDone;
Standard_Integer myIndex;
Extrema_ExtCC myExtCC;
- GeomAdaptor_Curve myC1;
- GeomAdaptor_Curve myC2;
+ Handle(GeomAdaptor_Curve) myC1;
+ Handle(GeomAdaptor_Curve) myC2;
Standard_Boolean myTotalExt;
Standard_Boolean myIsInfinite;
Standard_Real myTotalDist;
(const Handle(Geom_Curve)& Curve,
const Handle(Geom_Surface)& Surface)
{
- GeomAdaptor_Curve TheCurve (Curve);
- GeomAdaptor_Surface TheSurface (Surface);
+ Handle(GeomAdaptor_Curve) TheCurve = new GeomAdaptor_Curve(Curve);
+ Handle(GeomAdaptor_Surface) TheSurface = new GeomAdaptor_Surface(Surface);
Standard_Real Tol = Precision::PConfusion();
myExtCS.Initialize (TheSurface, Tol, Tol);
- myExtCS.Perform (TheCurve, TheCurve.FirstParameter(), TheCurve.LastParameter());
+ myExtCS.Perform (TheCurve, TheCurve->FirstParameter(), TheCurve->LastParameter());
myIsDone = myExtCS.IsDone() && (myExtCS.IsParallel() || myExtCS.NbExt() > 0);
if ( myIsDone) {
const Standard_Real Vmin,
const Standard_Real Vmax)
{
- GeomAdaptor_Curve TheCurve (Curve, Wmin, Wmax);
- GeomAdaptor_Surface TheSurface (Surface, Umin, Umax, Vmin, Vmax);
+ Handle(GeomAdaptor_Curve) TheCurve = new GeomAdaptor_Curve(Curve, Wmin, Wmax);
+ Handle(GeomAdaptor_Surface) TheSurface = new GeomAdaptor_Surface(Surface, Umin, Umax, Vmin, Vmax);
Standard_Real Tol = Precision::PConfusion();
myExtCS.Initialize (TheSurface,
(const Handle(Geom_Surface)& S1,
const Handle(Geom_Surface)& S2)
{
- GeomAdaptor_Surface TheSurface1 (S1);
- GeomAdaptor_Surface TheSurface2 (S2);
+ Handle(GeomAdaptor_Surface) TheSurface1 = new GeomAdaptor_Surface(S1);
+ Handle(GeomAdaptor_Surface) TheSurface2 = new GeomAdaptor_Surface(S2);
Standard_Real Tol = Precision::PConfusion();
const Standard_Real V2min,
const Standard_Real V2max)
{
- GeomAdaptor_Surface TheSurface1 (S1,U1min,U1max,V1min,V1max);
- GeomAdaptor_Surface TheSurface2 (S2,U2min,U2max,V2min,V2max);
+ Handle(GeomAdaptor_Surface) TheSurface1 = new GeomAdaptor_Surface(S1,U1min,U1max,V1min,V1max);
+ Handle(GeomAdaptor_Surface) TheSurface2 = new GeomAdaptor_Surface(S2,U2min,U2max,V2min,V2max);
Standard_Real Tol = Precision::PConfusion();
Extrema_ExtSS theExtSS(TheSurface1, TheSurface2,
//=======================================================================
GeomAPI_ProjectPointOnCurve::GeomAPI_ProjectPointOnCurve()
: myIsDone(Standard_False),
- myIndex(0)
+ myIndex(0),
+ myC(new GeomAdaptor_Curve())
{
}
//=======================================================================
(const gp_Pnt& P,
const Handle(Geom_Curve)& Curve)
{
- myC.Load(Curve);
+ myC = new GeomAdaptor_Curve(Curve);
/*
Extrema_ExtPC theExtPC(P, myC);
myExtPC = theExtPC;
*/
- myExtPC.Initialize(myC, myC.FirstParameter(), myC.LastParameter());
+ myExtPC.Initialize(myC, myC->FirstParameter(), myC->LastParameter());
myExtPC.Perform(P);
myIsDone = myExtPC.IsDone() && ( myExtPC.NbExt() > 0);
const Standard_Real Umin,
const Standard_Real Usup )
{
- myC.Load(Curve,Umin,Usup);
+ myC = new GeomAdaptor_Curve(Curve,Umin,Usup);
/*
Extrema_ExtPC theExtPC(P, myC);
myExtPC = theExtPC;
*/
- myExtPC.Initialize(myC, myC.FirstParameter(), myC.LastParameter());
+ myExtPC.Initialize(myC, myC->FirstParameter(), myC->LastParameter());
myExtPC.Perform(P);
myIsDone = myExtPC.IsDone() && ( myExtPC.NbExt() > 0);
const Standard_Real Umin,
const Standard_Real Usup )
{
- myC.Load(Curve,Umin,Usup);
+ myC = new GeomAdaptor_Curve(Curve,Umin,Usup);
//myExtPC = Extrema_ExtPC(P, myC);
myExtPC.Initialize(myC, Umin, Usup);
myIsDone = Standard_False;
Standard_Boolean myIsDone;
Standard_Integer myIndex;
Extrema_ExtPC myExtPC;
- GeomAdaptor_Curve myC;
+ Handle(GeomAdaptor_Curve) myC;
};
//=======================================================================
GeomAPI_ProjectPointOnSurf::GeomAPI_ProjectPointOnSurf()
: myIsDone (Standard_False),
- myIndex(0)
+ myIndex(0),
+ myGeomAdaptor(new GeomAdaptor_Surface())
{
}
//modified by NIZNHY-PKV Mon Apr 8 11:13:37 2002 f XXX
Standard_Real Umin, Usup, Vmin, Vsup;
Surface->Bounds(Umin, Usup, Vmin, Vsup);
- myGeomAdaptor.Load(Surface, Umin, Usup, Vmin, Vsup);
+ myGeomAdaptor = new GeomAdaptor_Surface(Surface, Umin, Usup, Vmin, Vsup);
//
//myExtPS = Extrema_ExtPS();
myExtPS.SetAlgo(theProjAlgo);
//modified by NIZNHY-PKV Thu Apr 4 10:38:23 2002 f
//GeomAdaptor_Surface TheSurface (Surface,Umin,Usup,Vmin,Vsup);
//myExtPS = Extrema_ExtPS (P, TheSurface, Tol, Tol);
- myGeomAdaptor.Load(Surface, Umin,Usup,Vmin,Vsup);
+ myGeomAdaptor = new GeomAdaptor_Surface(Surface, Umin,Usup,Vmin,Vsup);
//myExtPS = Extrema_ExtPS();
myExtPS.SetAlgo(theProjAlgo);
myExtPS.Initialize(myGeomAdaptor, Umin, Usup, Vmin, Vsup, Tolerance, Tolerance);
//modified by NIZNHY-PKV Thu Apr 4 10:39:10 2002 f
//GeomAdaptor_Surface TheSurface (Surface,Umin,Usup,Vmin,Vsup);
//myExtPS = Extrema_ExtPS (P, TheSurface, Tolerance, Tolerance);
- myGeomAdaptor.Load(Surface, Umin,Usup,Vmin,Vsup);
+ myGeomAdaptor = new GeomAdaptor_Surface(Surface, Umin,Usup,Vmin,Vsup);
//myExtPS = Extrema_ExtPS();
myExtPS.SetAlgo(theProjAlgo);
myExtPS.Initialize(myGeomAdaptor, Umin, Usup, Vmin, Vsup, Tolerance, Tolerance);
Standard_Real Tolerance = Precision::PConfusion();
//modified by NIZNHY-PKV Thu Apr 4 10:41:50 2002 f
//GeomAdaptor_Surface TheSurface (Surface,Umin,Usup,Vmin,Vsup);
- myGeomAdaptor.Load(Surface, Umin,Usup,Vmin,Vsup);
+ myGeomAdaptor = new GeomAdaptor_Surface(Surface, Umin,Usup,Vmin,Vsup);
//modified by NIZNHY-PKV Thu Apr 4 10:42:29 2002 t
//myExtPS = Extrema_ExtPS();
//modified by NIZNHY-PKV Thu Apr 4 10:42:32 2002 f
{
//modified by NIZNHY-PKV Thu Apr 4 10:43:00 2002 f
//GeomAdaptor_Surface TheSurface (Surface,Umin,Usup,Vmin,Vsup);
- myGeomAdaptor.Load(Surface, Umin,Usup,Vmin,Vsup);
+ myGeomAdaptor = new GeomAdaptor_Surface(Surface, Umin,Usup,Vmin,Vsup);
//modified by NIZNHY-PKV Thu Apr 4 10:43:16 2002 t
//myExtPS = Extrema_ExtPS();
//modified by NIZNHY-PKV Thu Apr 4 10:43:18 2002 f
Standard_Boolean myIsDone;
Standard_Integer myIndex;
Extrema_ExtPS myExtPS;
- GeomAdaptor_Surface myGeomAdaptor;
+ Handle(GeomAdaptor_Surface) myGeomAdaptor;
};
//function : MakeCurve
//purpose :
//=======================================================================
-Handle(Geom_Curve) GeomAdaptor::MakeCurve (const Adaptor3d_Curve& HC)
+Handle(Geom_Curve) GeomAdaptor::MakeCurve (const Handle(Adaptor3d_Curve)& HC)
{
Handle(Geom_Curve) C;
- switch (HC.GetType())
+ switch (HC->GetType())
{
case GeomAbs_Line:
- C = new Geom_Line(HC.Line());
+ C = new Geom_Line(HC->Line());
break;
case GeomAbs_Circle:
- C = new Geom_Circle(HC.Circle());
+ C = new Geom_Circle(HC->Circle());
break;
case GeomAbs_Ellipse:
- C = new Geom_Ellipse(HC.Ellipse());
+ C = new Geom_Ellipse(HC->Ellipse());
break;
case GeomAbs_Parabola:
- C = new Geom_Parabola(HC.Parabola());
+ C = new Geom_Parabola(HC->Parabola());
break;
case GeomAbs_Hyperbola:
- C = new Geom_Hyperbola(HC.Hyperbola());
+ C = new Geom_Hyperbola(HC->Hyperbola());
break;
case GeomAbs_BezierCurve:
- C = Handle(Geom_BezierCurve)::DownCast(HC.Bezier()->Copy());
+ C = Handle(Geom_BezierCurve)::DownCast(HC->Bezier()->Copy());
break;
case GeomAbs_BSplineCurve:
- C = Handle(Geom_BSplineCurve)::DownCast(HC.BSpline()->Copy());
+ C = Handle(Geom_BSplineCurve)::DownCast(HC->BSpline()->Copy());
break;
default:
// trim the curve if necassary.
if ((! C.IsNull() &&
- (HC.FirstParameter() != C->FirstParameter())) ||
- (HC.LastParameter() != C->LastParameter())) {
+ (HC->FirstParameter() != C->FirstParameter())) ||
+ (HC->LastParameter() != C->LastParameter())) {
- C = new Geom_TrimmedCurve(C,HC.FirstParameter(),HC.LastParameter());
+ C = new Geom_TrimmedCurve(C, HC->FirstParameter(), HC->LastParameter());
}
return C;
//function : MakeSurface
//purpose :
//=======================================================================
-Handle(Geom_Surface) GeomAdaptor::MakeSurface(const Adaptor3d_Surface& HS,
+Handle(Geom_Surface) GeomAdaptor::MakeSurface(const Handle(Adaptor3d_Surface)& HS,
const Standard_Boolean theTrimFlag)
{
Handle(Geom_Surface) S;
- switch ( HS.GetType())
+ switch (HS->GetType())
{
case GeomAbs_Plane:
- S = new Geom_Plane(HS.Plane());
+ S = new Geom_Plane(HS->Plane());
break;
case GeomAbs_Cylinder:
- S = new Geom_CylindricalSurface(HS.Cylinder());
+ S = new Geom_CylindricalSurface(HS->Cylinder());
break;
case GeomAbs_Cone:
- S = new Geom_ConicalSurface(HS.Cone());
+ S = new Geom_ConicalSurface(HS->Cone());
break;
case GeomAbs_Sphere:
- S = new Geom_SphericalSurface(HS.Sphere());
+ S = new Geom_SphericalSurface(HS->Sphere());
break;
case GeomAbs_Torus:
- S = new Geom_ToroidalSurface(HS.Torus());
+ S = new Geom_ToroidalSurface(HS->Torus());
break;
case GeomAbs_BezierSurface:
- S = Handle(Geom_BezierSurface)::DownCast(HS.Bezier()->Copy());
+ S = Handle(Geom_BezierSurface)::DownCast(HS->Bezier()->Copy());
break;
case GeomAbs_BSplineSurface:
- S = Handle(Geom_BSplineSurface)::DownCast(HS.BSpline()->Copy());
+ S = Handle(Geom_BSplineSurface)::DownCast(HS->BSpline()->Copy());
break;
case GeomAbs_SurfaceOfRevolution:
S = new Geom_SurfaceOfRevolution
- (GeomAdaptor::MakeCurve(*HS.BasisCurve()),HS.AxeOfRevolution());
+ (GeomAdaptor::MakeCurve(HS->BasisCurve()), HS->AxeOfRevolution());
break;
case GeomAbs_SurfaceOfExtrusion:
S = new Geom_SurfaceOfLinearExtrusion
- (GeomAdaptor::MakeCurve(*HS.BasisCurve()),HS.Direction());
+ (GeomAdaptor::MakeCurve(HS->BasisCurve()), HS->Direction());
break;
case GeomAbs_OffsetSurface:
- S = new Geom_OffsetSurface(GeomAdaptor::MakeSurface (*HS.BasisSurface()),
- HS.OffsetValue());
+ S = new Geom_OffsetSurface(GeomAdaptor::MakeSurface (HS->BasisSurface()),
+ HS->OffsetValue());
break;
case GeomAbs_OtherSurface:
// trim the surface if necassary.
Standard_Real U1, U2, V1, V2;
S->Bounds(U1, U2, V1, V2);
- if ((HS.FirstUParameter() != U1 ) ||
- (HS.LastUParameter () != U2 ) ||
- (HS.FirstVParameter() != V1 ) ||
- (HS.LastVParameter () != V2 ) ) {
+ if ((HS->FirstUParameter() != U1 ) ||
+ (HS->LastUParameter () != U2 ) ||
+ (HS->FirstVParameter() != V1 ) ||
+ (HS->LastVParameter () != V2 )) {
S = new Geom_RectangularTrimmedSurface
- (S,HS.FirstUParameter(),HS.LastUParameter(),
- HS.FirstVParameter(),HS.LastVParameter());
+ (S,HS->FirstUParameter(), HS->LastUParameter(),
+ HS->FirstVParameter(), HS->LastVParameter());
}
return S;
//! handled by reference.
//! Build a Geom_Curve using the information from the
//! Curve from Adaptor3d
- Standard_EXPORT static Handle(Geom_Curve) MakeCurve (const Adaptor3d_Curve& C);
+ Standard_EXPORT static Handle(Geom_Curve) MakeCurve (const Handle(Adaptor3d_Curve)& C);
//! Build a Geom_Surface using the information from the Surface from Adaptor3d
//! @param theS - Surface adaptor to convert.
//! @param theTrimFlag - True if perform trim surface values by adaptor and false otherwise.
- Standard_EXPORT static Handle(Geom_Surface) MakeSurface (const Adaptor3d_Surface& theS,
+ Standard_EXPORT static Handle(Geom_Surface) MakeSurface (const Handle(Adaptor3d_Surface)& theS,
const Standard_Boolean theTrimFlag = Standard_True);
};
//purpose :
//=======================================================================
GeomFill_BoundWithSurf::GeomFill_BoundWithSurf
-(const Adaptor3d_CurveOnSurface& CurveOnSurf,
+(const Handle(Adaptor3d_CurveOnSurface)& CurveOnSurf,
const Standard_Real Tol3d,
const Standard_Real Tolang) :
GeomFill_Boundary(Tol3d,Tolang), myConS(CurveOnSurf)
{
Standard_Real x = U;
if(!myPar.IsNull()) x = myPar->Value(U);
- return myConS.Value(x);
+ return myConS->Value(x);
}
{
Standard_Real x = U, dx = 1.;
if(!myPar.IsNull()) myPar->D1(U,x,dx);
- myConS.D1(x, P, V);
+ myConS->D1(x, P, V);
V.Multiply(dx);
}
if (!HasNormals())
throw Standard_Failure("BoundWithSurf Norm : pas de contrainte");
-// Handle(Adaptor3d_Surface)& S = myConS.GetSurface();
-// Handle(Adaptor2d_Curve2d)& C2d = myConS.GetCurve();
+// Handle(Adaptor3d_Surface)& S = myConS->GetSurface();
+// Handle(Adaptor2d_Curve2d)& C2d = myConS->GetCurve();
Standard_Real x,y;
Standard_Real w = U;
if(!myPar.IsNull()) w = myPar->Value(U);
- myConS.GetCurve()->Value(w).Coord(x,y);
+ myConS->GetCurve()->Value(w).Coord(x,y);
gp_Pnt P;
gp_Vec Su, Sv;
- myConS.GetSurface()->D1(x,y,P,Su,Sv);
+ myConS->GetSurface()->D1(x,y,P,Su,Sv);
Su.Cross(Sv);
Su.Normalize();
return Su;
{
if (!HasNormals())
throw Standard_Failure("BoundWithSurf Norm : pas de contrainte");
-// Handle(Adaptor3d_Surface)& S = myConS.GetSurface();
-// Handle(Adaptor2d_Curve2d)& C2d = myConS.GetCurve();
+// Handle(Adaptor3d_Surface)& S = myConS->GetSurface();
+// Handle(Adaptor2d_Curve2d)& C2d = myConS->GetCurve();
gp_Pnt2d P2d;
gp_Vec2d V2d;
Standard_Real x,y,dx,dy;
Standard_Real w = U, dw = 1.;
if(!myPar.IsNull()) myPar->D1(U,w,dw);
- myConS.GetCurve()->D1(w,P2d,V2d);
+ myConS->GetCurve()->D1(w,P2d,V2d);
P2d.Coord(x,y);
V2d.Multiply(dw);
V2d.Coord(dx,dy);
gp_Pnt P;
gp_Vec Su, Sv, Suu, Suv, Svv;
- myConS.GetSurface()->D2(x,y,P,Su,Sv, Suu, Svv, Suv);
+ myConS->GetSurface()->D2(x,y,P,Su,Sv, Suu, Svv, Suv);
N = Su.Crossed(Sv);
N.Normalize();
Standard_Real nsuu = N.Dot(Suu), nsuv = N.Dot(Suv), nsvv = N.Dot(Svv);
{
if(!myPar.IsNull()) myPar->Bounds(First,Last);
else{
- First = myConS.FirstParameter();
- Last = myConS.LastParameter();
+ First = myConS->FirstParameter();
+ Last = myConS->LastParameter();
}
}
//! Standard_Real TolAng = ... ;
//! myBoundary = GeomFill_BoundWithSurf (
//! CurveOnSurf, Tol, TolAng );
- Standard_EXPORT GeomFill_BoundWithSurf(const Adaptor3d_CurveOnSurface& CurveOnSurf, const Standard_Real Tol3d, const Standard_Real Tolang);
+ Standard_EXPORT GeomFill_BoundWithSurf(const Handle(Adaptor3d_CurveOnSurface)& CurveOnSurf, const Standard_Real Tol3d, const Standard_Real Tolang);
Standard_EXPORT gp_Pnt Value (const Standard_Real U) const Standard_OVERRIDE;
private:
- Adaptor3d_CurveOnSurface myConS;
+ Handle(Adaptor3d_CurveOnSurface) myConS;
Handle(Law_Function) myPar;
Standard_Real Fleche = 1.e-2 * L;
Standard_Real Angle, Cosa, Percent;
GCPnts_QuasiUniformDeflection Samp;
- Samp.Initialize (*C, Fleche);
+ Samp.Initialize (C, Fleche);
myBary.SetCoord(0.,0.,0.);
gp_Vec ns1, ns2;
gp_Vec D1;
frenet->SetInterval(First, Last); //To have right evaluation at bounds
- GeomFill_SnglrFunc CS(myCurve);
+ Handle(GeomFill_SnglrFunc) CS = new GeomFill_SnglrFunc(myCurve);
BndLib_Add3dCurve::Add(CS, First, Last, 1.e-2, Boite);
LengthMin = Boite.GetGap()*1.e-4;
i++;
//Evaluate the Next step
- CS.D1(Param, PonC, D1);
+ CS->D1(Param, PonC, D1);
L = Max(PonC.XYZ().Modulus()/2, LengthMin);
norm = D1.Magnitude();
if (norm < Precision::Confusion()) {
{
Standard_Real L, val, max, U, Delta;
Standard_Integer ii;
- GeomAdaptor_Curve AC (mySection);
+ Handle(GeomAdaptor_Curve) AC = new GeomAdaptor_Curve(mySection);
L = GCPnts_AbscissaPoint::Length(AC);
Delta = ( Last - First) / 20;
void GeomFill_Frenet::Init()
{
Standard_Integer i, j;
- GeomFill_SnglrFunc Func(myCurve);
+ Handle(GeomFill_SnglrFunc) Func = new GeomFill_SnglrFunc(myCurve);
Standard_Real TolF = 1.0e-10, Tol = 10*TolF, Tol2 = Tol * Tol,
PTol = Precision::PConfusion();
IsLin->ChangeValue(i) = Standard_True;
IsConst->ChangeValue(i) = Standard_True;
for(j = 1; j <= NbControl; j++) {
- Func.D0(myC2Disc->Value(i) + (j-1)*Step, C);
+ Func->D0(myC2Disc->Value(i) + (j-1)*Step, C);
if(j == 1) C1 = C;
modulus = C.XYZ().Modulus();
if(modulus > Tol) {
for(i = 1; i <= NbIntC2; i++) {
if (!IsLin->Value(i) && !IsConst->Value(i))
{
- Func.SetRatio(1./AveFunc(i)); // Normalization
+ Func->SetRatio(1./AveFunc(i)); // Normalization
Ext.Initialize(Func, myC2Disc->Value(i), myC2Disc->Value(i+1), TolF);
Ext.Perform(Origin);
if(Ext.IsDone() && Ext.NbExt() != 0)
{
SeqArray[i].Prepend( myC2Disc->Value(i+1) );
SeqArray[i].Append( myC2Disc->Value(i+2) );
- Func.SetRatio(1./AveFunc(i+1)); // Normalization
+ Func->SetRatio(1./AveFunc(i+1)); // Normalization
for (j = 1; j < SeqArray[i].Length(); j++)
if (SeqArray[i](j+1) - SeqArray[i](j) > PTol)
{
gp_Vec SnglDer, SnglDer2;
Standard_Real norm;
for(i = 1; i <= mySngl->Length(); i++) {
- Func.D2(mySngl->Value(i), C, SnglDer, SnglDer2);
+ Func->D2(mySngl->Value(i), C, SnglDer, SnglDer2);
if ((norm = SnglDer.Magnitude()) > gp::Resolution())
mySnglLen->ChangeValue(i) = Min(NullTol/norm, MaxSingular);
else if ((norm = SnglDer2.Magnitude()) > gp::Resolution())
{
Standard_Real s = myCurveAC->GetSParameter(Param); // abscisse curviligne <=> Param
Standard_Real OrigG = Orig1 + s*(Orig2-Orig1); // abscisse curv sur le guide (cas multi-edges)
- Standard_Real tG = myGuideAC->GetUParameter (*myGuide, OrigG, 1); // param <=> s sur theGuide
+ Standard_Real tG = myGuideAC->GetUParameter (myGuide, OrigG, 1); // param <=> s sur theGuide
gp_Pnt P, PG;
gp_Vec To, B;
// parametre <=> s sur theGuide
OrigG = Orig1 + s*(Orig2-Orig1);
// parametre <=> s sur theGuide
- tG = myGuideAC->GetUParameter (*myGuide, OrigG, 1);
+ tG = myGuideAC->GetUParameter (myGuide, OrigG, 1);
gp_Pnt P, PG;
gp_Vec To, DTo, TG, B, BPrim;
Standard_Real s = myCurveAC->GetSParameter(Param);
// parametre <=> s sur theGuide
Standard_Real OrigG = Orig1 + s*(Orig2-Orig1);
- Standard_Real tG = myGuideAC->GetUParameter (*myGuide, OrigG, 1);
+ Standard_Real tG = myGuideAC->GetUParameter (myGuide, OrigG, 1);
gp_Pnt P,PG;
gp_Vec TG,DTG;
Nb = Seq.Length();
for (ii=1; ii<=Nb; ii++) {
- TT(ii) = myCurveAC->GetUParameter (*myCurve, Seq(ii), 1);
+ TT(ii) = myCurveAC->GetUParameter (myCurve, Seq(ii), 1);
}
}
// myCurveAC->Trim(Sf, Sl, UTol);
U = Orig1 + Sf*(Orig2-Orig1);
- Sf = myGuideAC->GetUParameter(*myGuide, U, 1);
+ Sf = myGuideAC->GetUParameter(myGuide, U, 1);
U = Orig1 + Sl*(Orig2-Orig1);
- Sl = myGuideAC->GetUParameter(*myGuide, U, 1);
+ Sl = myGuideAC->GetUParameter(myGuide, U, 1);
myTrimG = myGuide->Trim(Sf, Sl, UTol);
}
// Surface de revolution
Revol = new(Geom_SurfaceOfRevolution) (S, Ax);
- GeomAdaptor_Surface GArevol(Revol);
- Extrema_ExtCS DistMini(*myGuide, GArevol,
+ Handle(GeomAdaptor_Surface) GArevol = new GeomAdaptor_Surface(Revol);
+ Extrema_ExtCS DistMini(myGuide, GArevol,
Precision::Confusion(), Precision::Confusion());
Extrema_POnCurv Pc;
Extrema_POnSurf Ps;
Standard_Real L, Lmax=0.;
Standard_Integer ii;
for (ii=1; ii <=mySections.Length(); ii++) {
- GeomAdaptor_Curve AC (mySections(ii));
+ Handle(GeomAdaptor_Curve) AC = new GeomAdaptor_Curve(mySections(ii));
L = GCPnts_AbscissaPoint::Length(AC);
if (L>Lmax) Lmax = L;
}
// Function :
// Purpose :
//===============================================================
-static void Tangente(const Adaptor3d_Curve& Path,
+static void Tangente(const Handle(Adaptor3d_Curve)& Path,
const Standard_Real Param,
gp_Pnt& P,
gp_Vec& Tang)
{
- Path.D1(Param, P, Tang);
+ Path->D1(Param, P, Tang);
Standard_Real Norm = Tang.Magnitude();
for (Standard_Integer ii=2; (ii<12) && (Norm < Precision::Confusion());
ii++) {
- Tang = Path.DN(Param, ii);
+ Tang = Path->DN(Param, ii);
Norm = Tang.Magnitude();
}
// Purpose : Examine un extrema pour updater <Dist> & <Param>
//===============================================================
static void DistMini(const Extrema_ExtPC& Ext,
- const Adaptor3d_Curve& C,
+ const Handle(Adaptor3d_Curve)& C,
Standard_Real& Dist,
Standard_Real& Param)
{
if ( (dist1<Dist2) || (dist2<Dist2) ) {
if (dist1 < dist2) {
Dist2 = dist1;
- Param = C.FirstParameter();
+ Param = C->FirstParameter();
}
else {
Dist2 = dist2;
- Param = C.LastParameter();
+ Param = C->LastParameter();
}
}
else
{
Handle(Geom_Curve) CurveSection = Handle(Geom_Curve)::DownCast(Section);
- myAdpSection.Load(CurveSection);
+ myAdpSection = new GeomAdaptor_Curve(CurveSection);
mySection = CurveSection;
}
gp_Pnt P;
gp_Vec V;
Tangente(myAdpSection,
- (myAdpSection.FirstParameter()+myAdpSection.LastParameter())/2,
+ (myAdpSection->FirstParameter()+myAdpSection->LastParameter())/2,
P, V);
TheAxe.SetLocation(P);
TheAxe.SetDirection(V);
// y a t'il un Plan moyen ?
- GeomAbs_CurveType TheType = myAdpSection.GetType();
+ GeomAbs_CurveType TheType = myAdpSection->GetType();
switch (TheType) {
case GeomAbs_Circle:
{
isplan = Standard_True;
- TheAxe = myAdpSection.Circle().Axis();
+ TheAxe = myAdpSection->Circle().Axis();
break;
}
case GeomAbs_Ellipse:
{
isplan = Standard_True;
- TheAxe = myAdpSection.Ellipse().Axis();
+ TheAxe = myAdpSection->Ellipse().Axis();
break;
}
case GeomAbs_Hyperbola:
{
isplan = Standard_True;
- TheAxe = myAdpSection.Hyperbola().Axis();
+ TheAxe = myAdpSection->Hyperbola().Axis();
break;
}
case GeomAbs_Parabola:
{
isplan = Standard_True;
- TheAxe = myAdpSection.Parabola().Axis();
+ TheAxe = myAdpSection->Parabola().Axis();
break;
}
case GeomAbs_Line:
case GeomAbs_BezierCurve:
case GeomAbs_BSplineCurve:
{
- NbPoles = myAdpSection.NbPoles();
+ NbPoles = myAdpSection->NbPoles();
break;
}
default:
{
// Calcul d'un plan moyen.
Handle(TColgp_HArray1OfPnt) Pnts;
- Standard_Real first = myAdpSection.FirstParameter();
- Standard_Real last = myAdpSection.LastParameter();
- if (myAdpSection.IsPeriodic())
+ Standard_Real first = myAdpSection->FirstParameter();
+ Standard_Real last = myAdpSection->LastParameter();
+ if (myAdpSection->IsPeriodic())
{
//Correct boundaries to avoid mistake of LocateU
- Handle(Geom_Curve) aCurve = myAdpSection.Curve();
+ Handle(Geom_Curve) aCurve = myAdpSection->Curve();
if (aCurve->IsInstance(STANDARD_TYPE(Geom_TrimmedCurve)))
aCurve = (Handle(Geom_TrimmedCurve)::DownCast(aCurve))->BasisCurve();
Standard_Real Ufirst = aCurve->FirstParameter();
last = U2;
}
Standard_Real t, delta;
- if (myAdpSection.GetType() == GeomAbs_BSplineCurve)
+ if (myAdpSection->GetType() == GeomAbs_BSplineCurve)
{
Handle(Geom_BSplineCurve) BC =
- Handle(Geom_BSplineCurve)::DownCast(myAdpSection.Curve());
+ Handle(Geom_BSplineCurve)::DownCast(myAdpSection->Curve());
Standard_Integer I1, I2, I3, I4;
BC->LocateU( first, Precision::Confusion(), I1, I2 );
BC->LocateU( last, Precision::Confusion(), I3, I4 );
NbPnts += NbLocalPnts;
if (I3 != I4 && first < BC->Knot(I3))
NbPnts += NbLocalPnts;
- if (!myAdpSection.IsClosed())
+ if (!myAdpSection->IsClosed())
NbPnts++;
Pnts = new TColgp_HArray1OfPnt(1, NbPnts);
Standard_Integer nb = 1;
for (j = 0; j < NbLocalPnts; j++)
{
t = first + j*delta;
- Pnts->SetValue( nb++, myAdpSection.Value(t) );
+ Pnts->SetValue( nb++, myAdpSection->Value(t) );
}
}
for (i = I2; i < I3; i++)
delta = (BC->Knot(i+1) - t) / NbLocalPnts;
for (j = 0; j < NbLocalPnts; j++)
{
- Pnts->SetValue( nb++, myAdpSection.Value(t) );
+ Pnts->SetValue( nb++, myAdpSection->Value(t) );
t += delta;
}
}
delta = (last - t) / NbLocalPnts;
for (j = 0; j < NbLocalPnts; j++)
{
- Pnts->SetValue( nb++, myAdpSection.Value(t) );
+ Pnts->SetValue( nb++, myAdpSection->Value(t) );
t += delta;
}
}
- if (!myAdpSection.IsClosed())
- Pnts->SetValue( nb, myAdpSection.Value(last) );
+ if (!myAdpSection->IsClosed())
+ Pnts->SetValue( nb, myAdpSection->Value(last) );
}
else // other type
{
Standard_Integer NbPnts = NbPoles-1;
- if (!myAdpSection.IsClosed())
+ if (!myAdpSection->IsClosed())
NbPnts++;
Pnts = new TColgp_HArray1OfPnt(1, NbPnts);
delta = (last - first) / (NbPoles-1);
for (i = 0; i < NbPoles-1; i++)
{
t = first + i*delta;
- Pnts->SetValue( i+1, myAdpSection.Value(t) );
+ Pnts->SetValue( i+1, myAdpSection->Value(t) );
}
- if (!myAdpSection.IsClosed())
- Pnts->SetValue( NbPnts, myAdpSection.Value(last) );
+ if (!myAdpSection->IsClosed())
+ Pnts->SetValue( NbPnts, myAdpSection->Value(last) );
}
Standard_Boolean issing;
myExt.Initialize(myAdpSection,
- myAdpSection.FirstParameter(),
- myAdpSection.LastParameter(),
+ myAdpSection->FirstParameter(),
+ myAdpSection->LastParameter(),
Precision::Confusion());
}
}
if (myIsPoint)
{
- Extrema_ExtPC Projector(myPoint, *Path, Precision::Confusion());
- DistMini( Projector, *Path, Dist, PathParam );
+ Extrema_ExtPC Projector(myPoint, Path, Precision::Confusion());
+ DistMini( Projector, Path, Dist, PathParam );
AngleMax = M_PI/2;
}
else
{
PathParam = Path->FirstParameter();
- SecParam = myAdpSection.FirstParameter();
+ SecParam = myAdpSection->FirstParameter();
Standard_Real distaux, taux = 0.0, alpha;
gp_Pnt PonPath, PonSec, P;
gp_Vec VRef, dp1;
VRef.SetXYZ(TheAxe.Direction().XYZ());
- Tangente (*Path, PathParam, PonPath, dp1);
- PonSec = myAdpSection.Value(SecParam);
+ Tangente (Path, PathParam, PonPath, dp1);
+ PonSec = myAdpSection->Value(SecParam);
Dist = PonPath.Distance(PonSec);
if (Dist > Tol) { // On Cherche un meilleur point sur la section
myExt.Perform(PonPath);
if ( myExt.IsDone() ) {
DistMini(myExt, myAdpSection, Dist, SecParam);
- PonSec = myAdpSection.Value(SecParam);
+ PonSec = myAdpSection->Value(SecParam);
}
}
AngleMax = EvalAngle(VRef, dp1);
else
{
PathParam = Path->LastParameter();
- Tangente (*Path, PathParam, PonPath, dp1);
- PonSec = myAdpSection.Value(SecParam);
+ Tangente (Path, PathParam, PonPath, dp1);
+ PonSec = myAdpSection->Value(SecParam);
Dist = PonPath.Distance(PonSec);
if (Dist > Tol) { // On Cherche un meilleur point sur la section
myExt.Perform(PonPath);
if ( myExt.IsDone() ) {
DistMini(myExt, myAdpSection, Dist, SecParam);
- PonSec = myAdpSection.Value(SecParam);
+ PonSec = myAdpSection->Value(SecParam);
}
}
AngleMax = EvalAngle(VRef, dp1);
AngleMax = alpha;
PonPath = P;
PathParam = w;
- PonSec = myAdpSection.Value(SecParam);
+ PonSec = myAdpSection->Value(SecParam);
}
}
else {
}
Trouve = (Dist <= Tol);
if (!Trouve) {
- Tangente (*Path, Path->LastParameter(), P, dp1);
+ Tangente (Path, Path->LastParameter(), P, dp1);
alpha = EvalAngle(VRef, dp1);
myExt.Perform(P);
if ( myExt.IsDone() ) {
// (2.2) Distance courbe-courbe
if (!Trouve) {
- Extrema_ExtCC Ext(*Path, myAdpSection,
+ Extrema_ExtCC Ext(Path, myAdpSection,
Path->FirstParameter(), Path->LastParameter(),
- myAdpSection.FirstParameter(),
- myAdpSection.LastParameter(),
+ myAdpSection->FirstParameter(),
+ myAdpSection->LastParameter(),
Path->Resolution(Tol/100),
- myAdpSection.Resolution(Tol/100));
+ myAdpSection->Resolution(Tol/100));
if (Ext.IsDone()) {
Extrema_POnCurv P1, P2;
for (ii=1; ii<=Ext.NbExt(); ii++) {
distaux = sqrt (Ext.SquareDistance(ii));
Ext.Points(ii, P1, P2);
- Tangente (*Path, P1.Parameter(), P, dp1);
+ Tangente (Path, P1.Parameter(), P, dp1);
alpha = EvalAngle(VRef, dp1);
if (Choix(distaux, alpha)) {
Trouve = Standard_True;
// Si l'on a toujours rien, on essai une distance point/path
// c'est la derniere chance.
Extrema_ExtPC PExt;
- PExt.Initialize (*Path,
+ PExt.Initialize (Path,
Path->FirstParameter(),
Path->LastParameter(),
Precision::Confusion());
if ( PExt.IsDone() ) {
// modified for OCC13595 Tue Oct 17 15:00:08 2006.BEGIN
// DistMini(PExt, myAdpSection, distaux, taux);
- DistMini(PExt, *Path, distaux, taux);
+ DistMini(PExt, Path, distaux, taux);
// modified for OCC13595 Tue Oct 17 15:00:11 2006.END
- Tangente (*Path, taux, P, dp1);
+ Tangente (Path, taux, P, dp1);
alpha = EvalAngle(VRef, dp1);
if (Choix(distaux, alpha)) {
Dist = distaux;
}
else
{
- SecParam = myAdpSection.FirstParameter();
+ SecParam = myAdpSection->FirstParameter();
// Standard_Real distaux, taux, alpha;
// gp_Pnt PonPath, PonSec, P;
gp_Vec VRef, dp1;
VRef.SetXYZ(TheAxe.Direction().XYZ());
- Tangente (*Path, PathParam, PonPath, dp1);
- PonSec = myAdpSection.Value(SecParam);
+ Tangente (Path, PathParam, PonPath, dp1);
+ PonSec = myAdpSection->Value(SecParam);
Dist = PonPath.Distance(PonSec);
if (Dist > Tol) { // On Cherche un meilleur point sur la section
myExt.Perform(PonPath);
if ( myExt.IsDone() ) {
DistMini(myExt, myAdpSection, Dist, SecParam);
- PonSec = myAdpSection.Value(SecParam);
+ PonSec = myAdpSection->Value(SecParam);
}
}
AngleMax = EvalAngle(VRef, dp1);
gp_Ax1 TheAxe;
Standard_Real Gabarit;
Handle(GeomFill_LocationLaw) myLaw;
- GeomAdaptor_Curve myAdpSection;
+ Handle(GeomAdaptor_Curve) myAdpSection;
Handle(Geom_Curve) mySection;
Standard_Real SecParam;
Standard_Real PathParam;
const Standard_Real DL,
const Standard_Boolean Rev)
{
- Handle(Law_BSpline) curve = Law::Reparametrize(*myC3d,
+ Handle(Law_BSpline) curve = Law::Reparametrize(myC3d,
First,Last,
HasDF,HasDL,DF,DL,
Rev,30);
myRadius = Radius;
myType = 0;
- Handle(Geom_Curve) CC = GeomAdaptor::MakeCurve(*Path);
+ Handle(Geom_Curve) CC = GeomAdaptor::MakeCurve(Path);
myPath = GeomConvert::CurveToBSplineCurve(CC);
myAdpPath = Path;
myAdpFirstSect = Curve1;
GCPnts_QuasiUniformDeflection Samp;
// Calcul de la longueur approximative de la courbe
- GeomAdaptor_Curve AdpPath(myPath);
- gp_Pnt P1 = AdpPath.Value(U1);
- gp_Pnt P2 = AdpPath.Value((U1+U2)/2.);
- gp_Pnt P3 = AdpPath.Value(U2);
+ Handle(GeomAdaptor_Curve) AdpPath = new GeomAdaptor_Curve(myPath);
+ gp_Pnt P1 = AdpPath->Value(U1);
+ gp_Pnt P2 = AdpPath->Value((U1+U2)/2.);
+ gp_Pnt P3 = AdpPath->Value(U2);
Standard_Real Length =
P1.Distance(P2) + P2.Distance(P3);
Standard_Real Fleche = 1.e-5 * Length;
Standard_Real GeomFill_UniformSection::MaximalSection() const
{
- GeomAdaptor_Curve AC (mySection);
+ Handle(GeomAdaptor_Curve) AC = new GeomAdaptor_Curve(mySection);
return GCPnts_AbscissaPoint::Length(AC);
}
if(theC2d.IsNull())
return;
- Geom2dAdaptor_Curve anAC1(theC2d);
+ Handle(Geom2dAdaptor_Curve) anAC1 = new Geom2dAdaptor_Curve(theC2d);
for(Standard_Integer aCurID = 0; aCurID < theNumberOfCurves; aCurID++)
{
if(theArrBounds[aCurID].IsNull())
continue;
- Geom2dAdaptor_Curve anAC2(theArrBounds[aCurID]);
+ Handle(Geom2dAdaptor_Curve) anAC2 = new Geom2dAdaptor_Curve(theArrBounds[aCurID]);
Geom2dInt_GInter anIntCC2d(anAC1, anAC2, theTol, theTol);
if(!anIntCC2d.IsDone() || anIntCC2d.IsEmpty())
aGAHS = theHS1;
anAHC2d = theRL->ArcOnS1();
theRL->ParamOnS1(tf, tl);
- theC2d1 = Geom2dAdaptor::MakeCurve (*anAHC2d);
+ theC2d1 = Geom2dAdaptor::MakeCurve (anAHC2d);
tf = Max(tf, theC2d1->FirstParameter());
tl = Min(tl, theC2d1->LastParameter());
theC2d1 = new Geom2d_TrimmedCurve(theC2d1, tf, tl);
aGAHS = theHS2;
anAHC2d = theRL->ArcOnS2();
theRL->ParamOnS2(tf, tl);
- theC2d2 = Geom2dAdaptor::MakeCurve (*anAHC2d);
+ theC2d2 = Geom2dAdaptor::MakeCurve (anAHC2d);
tf = Max(tf, theC2d2->FirstParameter());
tl = Min(tl, theC2d2->LastParameter());
theC2d2 = new Geom2d_TrimmedCurve(theC2d2, tf, tl);
Standard_Real aTol = Precision::Confusion();
if(theRL->IsArcOnS1())
{
- Handle(Geom_Surface) aS = GeomAdaptor::MakeSurface (*theHS2);
+ Handle(Geom_Surface) aS = GeomAdaptor::MakeSurface (theHS2);
BuildPCurves (tf, tl, aTol,
aS, theC3d, theC2d2);
}
if(theRL->IsArcOnS2())
{
- Handle(Geom_Surface) aS = GeomAdaptor::MakeSurface (*theHS1);
+ Handle(Geom_Surface) aS = GeomAdaptor::MakeSurface (theHS1);
BuildPCurves (tf, tl, aTol,
aS, theC3d, theC2d1);
}
//of line.
Standard_Real aU=0., aV=0.;
- GeomAdaptor_Surface anAS;
- anAS.Load(S);
+ Handle(GeomAdaptor_Surface) anAS = new GeomAdaptor_Surface(S);
Extrema_ExtPS anExtr;
const gp_Pnt aP3d1 = C->Value(f);
const gp_Pnt aP3d2 = C->Value(l);
//Check same parameter in middle point .begin
const gp_Pnt PMid(C->Value(0.5*(f+l)));
const gp_Pnt2d pmidcurve2d(0.5*(aP2d1.XY() + aP2d2.XY()));
- const gp_Pnt aPC(anAS.Value(pmidcurve2d.X(), pmidcurve2d.Y()));
+ const gp_Pnt aPC(anAS->Value(pmidcurve2d.X(), pmidcurve2d.Y()));
const Standard_Real aDist = PMid.Distance(aPC);
Tol = Max(aDist, Tol);
//Check same parameter in middle point .end
Standard_Boolean myIsDone;
Standard_Integer myIndex;
Extrema_ExtPS myExtPS;
- GeomAdaptor_Surface myGeomAdaptor;
+ Handle(GeomAdaptor_Surface) myGeomAdaptor;
};
//=======================================================================
{
const Standard_Real Tolerance = Precision::PConfusion();
//
- myGeomAdaptor.Load(Surface, Umin,Usup,Vmin,Vsup);
+ myGeomAdaptor = new GeomAdaptor_Surface(Surface, Umin,Usup,Vmin,Vsup);
myExtPS.Initialize(myGeomAdaptor, Umin, Usup, Vmin, Vsup, Tolerance, Tolerance);
myIsDone = Standard_False;
}
gp_Dir2d DirectionOnS2() const;
- const Handle(Adaptor3d_Surface)& AuxillarSurface1() const;
+ const Handle(Adaptor3d_Surface) AuxillarSurface1() const;
- const Handle(Adaptor3d_Surface)& AuxillarSurface2() const;
+ const Handle(Adaptor3d_Surface) AuxillarSurface2() const;
const gp_Dir2d& Direction2d();
- const Handle(Adaptor3d_Surface)& PSurface() const;
+ const Handle(Adaptor3d_Surface) PSurface() const;
const IntSurf_Quadric& ISurface() const;
//purpose :
//=======================================================================
-void GeomLib::EvalMaxParametricDistance(const Adaptor3d_Curve& ACurve,
- const Adaptor3d_Curve& AReferenceCurve,
+void GeomLib::EvalMaxParametricDistance(const Handle(Adaptor3d_Curve)& ACurve,
+ const Handle(Adaptor3d_Curve)& AReferenceCurve,
// const Standard_Real Tolerance,
const Standard_Real ,
const TColStd_Array1OfReal& Parameters,
gp_Pnt Point1 ;
gp_Pnt Point2 ;
for (ii = Parameters.Lower() ; ii <= Parameters.Upper() ; ii++) {
- ACurve.D0(Parameters(ii),
+ ACurve->D0(Parameters(ii),
Point1) ;
- AReferenceCurve.D0(Parameters(ii),
+ AReferenceCurve->D0(Parameters(ii),
Point2) ;
local_distance_squared =
Point1.SquareDistance (Point2) ;
//purpose :
//=======================================================================
-void GeomLib::EvalMaxDistanceAlongParameter(const Adaptor3d_Curve& ACurve,
- const Adaptor3d_Curve& AReferenceCurve,
+void GeomLib::EvalMaxDistanceAlongParameter(const Handle(Adaptor3d_Curve)& ACurve,
+ const Handle(Adaptor3d_Curve)& AReferenceCurve,
const Standard_Real Tolerance,
const TColStd_Array1OfReal& Parameters,
Standard_Real& MaxDistance)
para_tolerance =
- AReferenceCurve.Resolution(Tolerance) ;
+ AReferenceCurve->Resolution(Tolerance) ;
other_parameter = Parameters(Parameters.Lower()) ;
- ACurve.D0(other_parameter,
+ ACurve->D0(other_parameter,
Point1) ;
Extrema_LocateExtPC a_projector(Point1,
AReferenceCurve,
other_parameter,
para_tolerance) ;
for (ii = Parameters.Lower() ; ii <= Parameters.Upper() ; ii++) {
- ACurve.D0(Parameters(ii),
+ ACurve->D0(Parameters(ii),
Point1) ;
- AReferenceCurve.D0(Parameters(ii),
+ AReferenceCurve->D0(Parameters(ii),
Point2) ;
local_distance_squared =
Point1.SquareDistance (Point2) ;
if (a_projector.IsDone()) {
other_parameter =
a_projector.Point().Parameter() ;
- AReferenceCurve.D0(other_parameter,
+ AReferenceCurve->D0(other_parameter,
Point2) ;
local_distance_squared =
Point1.SquareDistance (Point2) ;
class GeomLib_CurveOnSurfaceEvaluator : public AdvApprox_EvaluatorFunction
{
public:
- GeomLib_CurveOnSurfaceEvaluator (Adaptor3d_CurveOnSurface& theCurveOnSurface,
+ GeomLib_CurveOnSurfaceEvaluator (Handle(Adaptor3d_CurveOnSurface)& theCurveOnSurface,
Standard_Real theFirst, Standard_Real theLast)
: CurveOnSurface(theCurveOnSurface), FirstParam(theFirst), LastParam(theLast) {}
Standard_Integer *ErrorCode);
private:
- Adaptor3d_CurveOnSurface& CurveOnSurface;
+ Handle(Adaptor3d_CurveOnSurface)& CurveOnSurface;
Standard_Real FirstParam;
Standard_Real LastParam;
//Gestion des positionnements gauche / droite
if ((DebutFin[0] != FirstParam) || (DebutFin[1] != LastParam))
{
- TrimCurve = CurveOnSurface.Trim(DebutFin[0], DebutFin[1], Precision::PConfusion());
+ TrimCurve = CurveOnSurface->Trim(DebutFin[0], DebutFin[1], Precision::PConfusion());
FirstParam = DebutFin[0];
LastParam = DebutFin[1];
}
//=======================================================================
void GeomLib::BuildCurve3d(const Standard_Real Tolerance,
- Adaptor3d_CurveOnSurface& Curve,
+ Handle(Adaptor3d_CurveOnSurface)& Curve,
const Standard_Real FirstParameter,
const Standard_Real LastParameter,
Handle(Geom_Curve)& NewCurvePtr,
MaxDeviation = 0.0e0 ;
AverageDeviation = 0.0e0 ;
- Handle(GeomAdaptor_Surface) geom_adaptor_surface_ptr (Handle(GeomAdaptor_Surface)::DownCast(Curve.GetSurface()) );
- Handle(Geom2dAdaptor_Curve) geom_adaptor_curve_ptr (Handle(Geom2dAdaptor_Curve)::DownCast(Curve.GetCurve()) );
+ Handle(GeomAdaptor_Surface) geom_adaptor_surface_ptr (Handle(GeomAdaptor_Surface)::DownCast(Curve->GetSurface()) );
+ Handle(Geom2dAdaptor_Curve) geom_adaptor_curve_ptr (Handle(Geom2dAdaptor_Curve)::DownCast(Curve->GetCurve()) );
if (! geom_adaptor_curve_ptr.IsNull() &&
! geom_adaptor_surface_ptr.IsNull()) {
if (! P.IsNull()) {
// compute the 3d curve
gp_Ax2 axes = P->Position().Ax2();
- const Geom2dAdaptor_Curve& geom2d_curve = *geom_adaptor_curve_ptr;
- NewCurvePtr =
- GeomLib::To3d(axes,
- geom2d_curve.Curve());
+ NewCurvePtr = GeomLib::To3d(axes, geom_adaptor_curve_ptr->Curve());
return;
}
Tolerance3DPtr->SetValue(1,Tolerance);
// Recherche des discontinuitees
- Standard_Integer NbIntervalC2 = Curve.NbIntervals(GeomAbs_C2);
+ Standard_Integer NbIntervalC2 = Curve->NbIntervals(GeomAbs_C2);
TColStd_Array1OfReal Param_de_decoupeC2 (1, NbIntervalC2+1);
- Curve.Intervals(Param_de_decoupeC2, GeomAbs_C2);
+ Curve->Intervals(Param_de_decoupeC2, GeomAbs_C2);
- Standard_Integer NbIntervalC3 = Curve.NbIntervals(GeomAbs_C3);
+ Standard_Integer NbIntervalC3 = Curve->NbIntervals(GeomAbs_C3);
TColStd_Array1OfReal Param_de_decoupeC3 (1, NbIntervalC3+1);
- Curve.Intervals(Param_de_decoupeC3, GeomAbs_C3);
+ Curve->Intervals(Param_de_decoupeC3, GeomAbs_C3);
// Note extension of the parameteric range
// Pour forcer le Trim au premier appel de l'evaluateur
//! curve that has the required range
Standard_EXPORT static void SameRange (const Standard_Real Tolerance, const Handle(Geom2d_Curve)& Curve2dPtr, const Standard_Real First, const Standard_Real Last, const Standard_Real RequestedFirst, const Standard_Real RequestedLast, Handle(Geom2d_Curve)& NewCurve2dPtr);
- Standard_EXPORT static void BuildCurve3d (const Standard_Real Tolerance, Adaptor3d_CurveOnSurface& CurvePtr, const Standard_Real FirstParameter, const Standard_Real LastParameter, Handle(Geom_Curve)& NewCurvePtr, Standard_Real& MaxDeviation, Standard_Real& AverageDeviation, const GeomAbs_Shape Continuity = GeomAbs_C1, const Standard_Integer MaxDegree = 14, const Standard_Integer MaxSegment = 30);
+ Standard_EXPORT static void BuildCurve3d (const Standard_Real Tolerance, Handle(Adaptor3d_CurveOnSurface)& CurvePtr, const Standard_Real FirstParameter, const Standard_Real LastParameter, Handle(Geom_Curve)& NewCurvePtr, Standard_Real& MaxDeviation, Standard_Real& AverageDeviation, const GeomAbs_Shape Continuity = GeomAbs_C1, const Standard_Integer MaxDegree = 14, const Standard_Integer MaxSegment = 30);
Standard_EXPORT static void AdjustExtremity (Handle(Geom_BoundedCurve)& Curve, const gp_Pnt& P1, const gp_Pnt& P2, const gp_Vec& T1, const gp_Vec& T2);
//! parameters given in the Parameters array by
//! evaluating each parameter the two curves and taking
//! the maximum of the evaluated distance
- Standard_EXPORT static void EvalMaxParametricDistance (const Adaptor3d_Curve& Curve, const Adaptor3d_Curve& AReferenceCurve, const Standard_Real Tolerance, const TColStd_Array1OfReal& Parameters, Standard_Real& MaxDistance);
+ Standard_EXPORT static void EvalMaxParametricDistance (const Handle(Adaptor3d_Curve)& Curve, const Handle(Adaptor3d_Curve)& AReferenceCurve, const Standard_Real Tolerance, const TColStd_Array1OfReal& Parameters, Standard_Real& MaxDistance);
//! this will compute the maximum distance at the parameters
//! given in the Parameters array by projecting from the Curve
//! to the reference curve and taking the minimum distance
//! Than the maximum will be taken on those minimas.
- Standard_EXPORT static void EvalMaxDistanceAlongParameter (const Adaptor3d_Curve& Curve, const Adaptor3d_Curve& AReferenceCurve, const Standard_Real Tolerance, const TColStd_Array1OfReal& Parameters, Standard_Real& MaxDistance);
+ Standard_EXPORT static void EvalMaxDistanceAlongParameter (const Handle(Adaptor3d_Curve)& Curve, const Handle(Adaptor3d_Curve)& AReferenceCurve, const Standard_Real Tolerance, const TColStd_Array1OfReal& Parameters, Standard_Real& MaxDistance);
//! Cancel,on the boundaries,the denominator first derivative
//! in the directions wished by the user and set its value to 1.
public math_MultipleVarFunctionWithHessian
{
public:
- GeomLib_CheckCurveOnSurface_TargetFunc( const Adaptor3d_Curve& theC3D,
- const Adaptor3d_Curve& theCurveOnSurface,
+ GeomLib_CheckCurveOnSurface_TargetFunc( const Handle(Adaptor3d_Curve)& theC3D,
+ const Handle(Adaptor3d_Curve)& theCurveOnSurface,
const Standard_Real theFirst,
const Standard_Real theLast):
myCurve1(theC3D),
if (!CheckParameter(theX))
return Standard_False;
- const gp_Pnt aP1(myCurve1.Value(theX)),
- aP2(myCurve2.Value(theX));
+ const gp_Pnt aP1(myCurve1->Value(theX)),
+ aP2(myCurve2->Value(theX));
theFVal = -1.0*aP1.SquareDistance(aP2);
}
//
if (!theDeriv2)
{
- myCurve1.D1(theX, aP1, aDC1);
- myCurve2.D1(theX, aP2, aDC2);
+ myCurve1->D1(theX, aP1, aDC1);
+ myCurve2->D1(theX, aP2, aDC2);
}
else
{
- myCurve1.D2(theX, aP1, aDC1, aDCC1);
- myCurve2.D2(theX, aP2, aDC2, aDCC2);
+ myCurve1->D2(theX, aP1, aDC1, aDCC1);
+ myCurve2->D2(theX, aP2, aDC2, aDCC2);
}
const gp_Vec aVec1(aP1, aP2), aVec2(aDC2-aDC1);
return ((myFirst <= theParam) && (theParam <= myLast));
}
- const Adaptor3d_Curve& myCurve1;
- const Adaptor3d_Curve& myCurve2;
+ const Handle(Adaptor3d_Curve) myCurve1;
+ const Handle(Adaptor3d_Curve) myCurve2;
const Standard_Real myFirst;
const Standard_Real myLast;
};
//This optimal value will be put in corresponding (depending on theIndex - the
//identificator of the current interval in mySubIntervals array) cell of
//myArrOfDist and myArrOfParam arrays.
- GeomLib_CheckCurveOnSurface_TargetFunc aFunc(*(myCurveArray.Value(theThreadIndex).get()),
- *(myCurveOnSurfaceArray.Value(theThreadIndex).get()),
+ GeomLib_CheckCurveOnSurface_TargetFunc aFunc(myCurveArray.Value(theThreadIndex).get(),
+ myCurveOnSurfaceArray.Value(theThreadIndex).get(),
mySubIntervals.Value(theElemIndex),
mySubIntervals.Value(theElemIndex + 1));
U = 0.;
Standard_Real aTol = MaxDist * MaxDist;
//
- GeomAdaptor_Curve aGAC(Curve);
+ Handle(GeomAdaptor_Curve) aGAC = new GeomAdaptor_Curve(Curve);
Extrema_ExtPC extrema(Point,aGAC);
//
if( !extrema.IsDone() ) return Standard_False;
V = 0.;
Standard_Real aTol = MaxDist * MaxDist;
//
- GeomAdaptor_Surface aGAS(Surface);
+ Handle(GeomAdaptor_Surface) aGAS = new GeomAdaptor_Surface(Surface);
Standard_Real aTolU = PARTOLERANCE, aTolV = PARTOLERANCE;
//
Extrema_ExtPS extrema(Point,aGAS,aTolU,aTolV);
U = 0.;
Standard_Real aTol = MaxDist * MaxDist;
//
- Geom2dAdaptor_Curve aGAC(Curve);
+ Handle(Geom2dAdaptor_Curve) aGAC = new Geom2dAdaptor_Curve(Curve);
Extrema_ExtPC2d extrema(Point,aGAC);
if( !extrema.IsDone() ) return Standard_False;
Standard_Integer n = extrema.NbExt();
//! Constructor. Initializes the curve and the line
//! going through two given points.
- FuncSolveDeviation(const Geom2dAdaptor_Curve& theCurve,
+ FuncSolveDeviation(const Handle(Geom2dAdaptor_Curve)& theCurve,
const gp_XY& thePf,
const gp_XY& thePl):
myCurve(theCurve),
//! of *this
void UpdateFields(const Standard_Real theParam)
{
- myCurve.D0(theParam, myPointOnCurve);
+ myCurve->D0(theParam, myPointOnCurve);
const gp_XY aVt = myPointOnCurve.XY() - myPRef;
myVecCurvLine = aVt.Dot(myDirRef) * myDirRef / mySqMod - aVt;
}
{
gp_Vec2d aD1;
gp_Vec2d aD2;
- myCurve.D2(theParam, myPointOnCurve, aD1, aD2);
+ myCurve->D2(theParam, myPointOnCurve, aD1, aD2);
const gp_XY aVt = myPointOnCurve.XY() - myPRef;
theVal = aVt.Crossed(myDirRef);
private:
//! The curve
- Geom2dAdaptor_Curve myCurve;
+ Handle(Geom2dAdaptor_Curve) myCurve;
//! Square modulus of myDirRef (it is constant)
Standard_Real mySqMod;
// where D1 and D2 are 1st and 2nd derivative of the function, computed in
// the point U(n). U(0) = theStartParameter.
//=======================================================================
-Standard_Real GeomLib_Tool::ComputeDeviation(const Geom2dAdaptor_Curve& theCurve,
+Standard_Real GeomLib_Tool::ComputeDeviation(const Handle(Geom2dAdaptor_Curve)& theCurve,
const Standard_Real theFPar,
const Standard_Real theLPar,
const Standard_Real theStartParameter,
return -1.0;
}
- const gp_Pnt2d aPf(theCurve.Value(theFPar));
- const gp_Pnt2d aPl(theCurve.Value(theLPar));
+ const gp_Pnt2d aPf(theCurve->Value(theFPar));
+ const gp_Pnt2d aPl(theCurve->Value(theLPar));
FuncSolveDeviation aFunc(theCurve, aPf.XY(), aPl.XY());
// (fast but not precisely).
// math_PSO Algorithm is used.
//=======================================================================
-Standard_Real GeomLib_Tool::ComputeDeviation(const Geom2dAdaptor_Curve& theCurve,
+Standard_Real GeomLib_Tool::ComputeDeviation(const Handle(Geom2dAdaptor_Curve)& theCurve,
const Standard_Real theFPar,
const Standard_Real theLPar,
const Standard_Integer theNbSubIntervals,
Standard_Real* const thePrmOnCurve)
{
// Computed maximal deflection
- const gp_Pnt2d aPf(theCurve.Value(theFPar));
- const gp_Pnt2d aPl(theCurve.Value(theLPar));
+ const gp_Pnt2d aPf(theCurve->Value(theFPar));
+ const gp_Pnt2d aPl(theCurve->Value(theLPar));
FuncSolveDeviation aFunc(theCurve, aPf.XY(), aPl.XY());
//! @param theLine - the linear segment joining the point of theCurve having parameters
//! theFPar and theLPar.
Standard_EXPORT static
- Standard_Real ComputeDeviation(const Geom2dAdaptor_Curve& theCurve,
+ Standard_Real ComputeDeviation(const Handle(Geom2dAdaptor_Curve)& theCurve,
const Standard_Real theFPar,
const Standard_Real theLPar,
const Standard_Real theStartParameter,
//! setting big value of theNbIters). But it can give some start point for
//! the overloaded method.
Standard_EXPORT static
- Standard_Real ComputeDeviation(const Geom2dAdaptor_Curve& theCurve,
+ Standard_Real ComputeDeviation(const Handle(Geom2dAdaptor_Curve)& theCurve,
const Standard_Real theFPar,
const Standard_Real theLPar,
const Standard_Integer theNbSubIntervals,
Standard_Real u1,v1,u2,v2;
mySurfInit->Bounds(u1,v1,u2,v2);
- GeomAdaptor_Surface aSurfInit(mySurfInit);
- myTolU = aSurfInit.UResolution(myTol3d);
- myTolV = aSurfInit.VResolution(myTol3d);
+ Handle(GeomAdaptor_Surface) aSurfInit = new GeomAdaptor_Surface(mySurfInit);
+ myTolU = aSurfInit->UResolution(myTol3d);
+ myTolV = aSurfInit->VResolution(myTol3d);
myProj.Initialize(aSurfInit,u1,v1,u2,v2,
myTolU,myTolV);
mySurfInit = App.Surface();
mySurfInit->Bounds(u1,v1,u2,v2);
- GeomAdaptor_Surface Surf(mySurfInit);
- myTolU = Surf.UResolution(myTol3d);
- myTolV = Surf.VResolution(myTol3d);
+ Handle(GeomAdaptor_Surface) Surf = new GeomAdaptor_Surface(mySurfInit);
+ myTolU = Surf->UResolution(myTol3d);
+ myTolV = Surf->VResolution(myTol3d);
myProj.Initialize(Surf,u1,v1,u2,v2,
myTolU,myTolV);
mySurfInit = myPlanarSurfInit;
mySurfInit->Bounds(u1,v1,u2,v2);
- GeomAdaptor_Surface SurfNew(mySurfInit);
- myTolU = SurfNew.UResolution(myTol3d);
- myTolV = SurfNew.VResolution(myTol3d);
+ Handle(GeomAdaptor_Surface) SurfNew = new GeomAdaptor_Surface(mySurfInit);
+ myTolU = SurfNew->UResolution(myTol3d);
+ myTolV = SurfNew->VResolution(myTol3d);
myProj.Initialize(SurfNew,u1,v1,u2,v2,
myTolU,myTolV);
Standard_Integer i ;
mySurfInit->Bounds(u1,v1,u2,v2);
- GeomAdaptor_Surface Surf(mySurfInit);
+ Handle(GeomAdaptor_Surface) Surf = new GeomAdaptor_Surface(mySurfInit);
myProj.Initialize(Surf,u1,v1,u2,v2,
myTolU,myTolV);
// sampling in "cosine" + 3 points on each interval
Standard_Real u1,v1,u2,v2;
mySurfInit->Bounds(u1,v1,u2,v2);
- GeomAdaptor_Surface Surf(mySurfInit);
+ Handle(GeomAdaptor_Surface) Surf = new GeomAdaptor_Surface(mySurfInit);
myProj.Initialize(Surf,u1,v1,u2,v2,
- Surf.UResolution(myTol3d),
- Surf.VResolution(myTol3d));
+ Surf->UResolution(myTol3d),
+ Surf->VResolution(myTol3d));
Standard_Integer NTCurve = myLinCont->Length();
Standard_Integer NTPntCont = myPntCont->Length();
// gp_Pnt2d P2d;
#endif
Standard_Real u1,v1,u2,v2;
mySurfInit->Bounds(u1,v1,u2,v2);
- GeomAdaptor_Surface Surf(mySurfInit);
- myTolU = Surf.UResolution(myTol3d);
- myTolV = Surf.VResolution(myTol3d);
+ Handle(GeomAdaptor_Surface) Surf = new GeomAdaptor_Surface(mySurfInit);
+ myTolU = Surf->UResolution(myTol3d);
+ myTolV = Surf->VResolution(myTol3d);
myProj.Initialize(Surf,u1,v1,u2,v2,
myTolU,myTolV);
{
Standard_Integer NTLinCont = myLinCont->Length();
Geom2dInt_GInter Intersection;
- Geom2dAdaptor_Curve Ci, Cj;
+ Handle(Geom2dAdaptor_Curve) Ci = new Geom2dAdaptor_Curve();
+ Handle(Geom2dAdaptor_Curve) Cj = new Geom2dAdaptor_Curve();
IntRes2d_IntersectionPoint int2d;
gp_Pnt P1,P2;
gp_Pnt2d P2d;
{
//Standard_Real NbPnt_i=myLinCont->Value(i)->NbPoints();
// Find the intersection with each curve including the curve itself
- Ci.Load(myLinCont->Value(i)->Curve2dOnSurf());
+ Ci->Load(myLinCont->Value(i)->Curve2dOnSurf());
for(Standard_Integer j=i; j<=NTLinCont; j++)
{
- Cj.Load(myLinCont->Value(j)->Curve2dOnSurf());
+ Cj->Load(myLinCont->Value(j)->Curve2dOnSurf());
if (i==j)
Intersection.Perform(Ci, myTol2d*10, myTol2d*10);
else
// the point on curve j is preserved;
// the length of interval is a length 2d
// corresponding in 3d to myTol3d
- Standard_Real tolint = Ci.Resolution(myTol3d);
- Ci.D1(int2d.ParamOnFirst(),P2d, V2d);
+ Standard_Real tolint = Ci->Resolution(myTol3d);
+ Ci->D1(int2d.ParamOnFirst(),P2d, V2d);
Standard_Real aux = V2d.Magnitude();
if (aux > 1.e-7)
{
<<" "<<Abs(Abs(A1)-M_PI)<<std::endl;
#endif
- coin = Ci.Resolution(Tol);
+ coin = Ci->Resolution(Tol);
Standard_Real Par1=int2d.ParamOnFirst()-coin,
Par2=int2d.ParamOnFirst()+coin;
// Storage of the interval for curve i
PntG1G1->ChangeValue(i).Append(Par1);
PntG1G1->ChangeValue(i).Append(Par2);
- coin = Cj.Resolution(Tol);
+ coin = Cj->Resolution(Tol);
Par1=int2d.ParamOnSecond()-coin;
Par2=int2d.ParamOnSecond()+coin;
// Storage of the interval for curve j
#endif
if (myLinCont->Value(i)->Order() == 1)
{
- coin = Ci.Resolution(Tol);
+ coin = Ci->Resolution(Tol);
coin *= Angle / myTolAng * 10.;
#ifdef OCCT_DEBUG
std::cout<<std::endl<<"coin = "<<coin<<std::endl;
}
else
{
- coin = Cj.Resolution(Tol);
+ coin = Cj->Resolution(Tol);
coin *= Angle / myTolAng * 10.;
#ifdef OCCT_DEBUG
std::cout<<std::endl<<"coin = "<<coin<<std::endl;
// corresponding to the distance of points in 3D to myTol3d
Standard_Real tolint, Dist;
Dist = P1.Distance(P2);
- tolint = Ci.Resolution(Dist);
+ tolint = Ci->Resolution(Dist);
PntInter->ChangeValue(i).Append( int2d.ParamOnFirst() - tolint);
PntInter->ChangeValue(i).Append( int2d.ParamOnFirst() + tolint);
if (j!=i)
{
- tolint = Cj.Resolution(Dist);
+ tolint = Cj->Resolution(Dist);
PntInter->ChangeValue(j).
Append( int2d.ParamOnSecond() - tolint);
PntInter->ChangeValue(j).
Standard_Integer NTLinCont = myLinCont->Length();
Standard_Boolean ACR;
Handle(Geom2d_Curve) C2d;
- Geom2dAdaptor_Curve AC2d;
+ Handle(Geom2dAdaptor_Curve) AC2d = new Geom2dAdaptor_Curve();
// Handle(Adaptor_HCurve2d) HC2d;
Handle(Law_Interpol) acrlaw = new (Law_Interpol) ();
myPlateCont = new GeomPlate_HArray1OfSequenceOfReal(1,NTLinCont);
ACR = (!C2d.IsNull());
if (ACR) {
// Construct a law close to curvilinear abscissa
- if(!C2d.IsNull()) AC2d.Load(C2d);
+ if(!C2d.IsNull()) AC2d->Load(C2d);
// AC2d.Load(LinCont->Curve2dOnSurf());
Standard_Integer ii, Nbint = 20;
Standard_Real U;
gp_Pnt P3d,PP,Pdif;
gp_Pnt2d P2d;
- AC2d.D0(Inter, P2d);
+ AC2d->D0(Inter, P2d);
LinCont->D0(Inter,P3d);
mySurfInit->D0(P2d.Coord(1),P2d.Coord(2),PP);
Pdif.SetCoord(-PP.Coord(1)+P3d.Coord(1),
gp_Pnt P3d,PP,Pdif;
gp_Pnt2d P2d;
- AC2d.D0(Inter, P2d);
+ AC2d->D0(Inter, P2d);
LinCont->D0(Inter,P3d);
mySurfInit->D0(P2d.Coord(1),P2d.Coord(2),PP);
Pdif.SetCoord(-PP.Coord(1)+P3d.Coord(1),
{// GCPnts_AbscissaPoint A(myFrontiere->Curve(),AP.Length(myFrontiere->Curve())/2,myFrontiere->FirstParameter());
// Standard_Real toto=A.Parameter();
//std::cout<<toto<<std::endl;
-return AP.Length (*myFrontiere);
+return AP.Length (myFrontiere);
}
else
// Standard_Real toto=A.Parameter();
//std::cout<<toto<<std::endl;
- return AP.Length (*my3dCurve);
+ return AP.Length (my3dCurve);
}
else if (n == 7)
{
const gp_XY aP2d(Draw::Atof(a[5]), Draw::Atof(a[6]));
- GeomAdaptor_Surface aGAS(GS);
+ Handle(GeomAdaptor_Surface) aGAS = new GeomAdaptor_Surface(GS);
Extrema_GenLocateExtPS aProjector(aGAS, Precision::PConfusion(), Precision::PConfusion());
aProjector.Perform(P, aP2d.X(), aP2d.Y(), Standard_False);
if (!aProjector.IsDone())
if (aNbCurves == 3)
{
// C-C-C
- Geom2dGcc_Circ2d3Tan aCt3(Geom2dGcc::Unqualified(aC[0]),
- Geom2dGcc::Unqualified(aC[1]),
- Geom2dGcc::Unqualified(aC[2]),
+ Geom2dGcc_Circ2d3Tan aCt3(Geom2dGcc::Unqualified(new Geom2dAdaptor_Curve(aC[0])),
+ Geom2dGcc::Unqualified(new Geom2dAdaptor_Curve(aC[1])),
+ Geom2dGcc::Unqualified(new Geom2dAdaptor_Curve(aC[2])),
aTol, 0, 0, 0);
theDI << "Solution of type C-C-C is: ";
return solutions(theDI, aCt3, theArgVals[1]);
if (aNbPnts >= 1)
{
// C-C-P
- Geom2dGcc_Circ2d3Tan aCt3(Geom2dGcc::Unqualified(aC[0]),
- Geom2dGcc::Unqualified(aC[1]),
+ Geom2dGcc_Circ2d3Tan aCt3(Geom2dGcc::Unqualified(new Geom2dAdaptor_Curve(aC[0])),
+ Geom2dGcc::Unqualified(new Geom2dAdaptor_Curve(aC[1])),
new Geom2d_CartesianPoint(aP[0]),
aTol, 0, 0);
theDI << "Solution of type C-C-P is: ";
else if (aRadius > 0)
{
// C-C-R
- Geom2dGcc_Circ2d2TanRad aCt3(Geom2dGcc::Unqualified(aC[0]),
- Geom2dGcc::Unqualified(aC[1]),
+ Geom2dGcc_Circ2d2TanRad aCt3(Geom2dGcc::Unqualified(new Geom2dAdaptor_Curve(aC[0])),
+ Geom2dGcc::Unqualified(new Geom2dAdaptor_Curve(aC[1])),
aRadius, aTol);
theDI << "Solution of type C-C-R is: ";
return solutions(theDI, aCt3, theArgVals[1]);
if (aNbPnts == 2)
{
//C-P-P
- Geom2dGcc_Circ2d3Tan aCt3(Geom2dGcc::Unqualified(aC[0]),
+ Geom2dGcc_Circ2d3Tan aCt3(Geom2dGcc::Unqualified(new Geom2dAdaptor_Curve(aC[0])),
new Geom2d_CartesianPoint(aP[0]),
new Geom2d_CartesianPoint(aP[1]),
aTol,0);
if (aRadius > 0.0)
{
//C-P-R
- Geom2dGcc_Circ2d2TanRad aCt3(Geom2dGcc::Unqualified(aC[0]),
+ Geom2dGcc_Circ2d2TanRad aCt3(Geom2dGcc::Unqualified(new Geom2dAdaptor_Curve(aC[0])),
new Geom2d_CartesianPoint(aP[0]),
aRadius, aTol);
theDI << "Solution of type C-P-R is: ";
else
{
// C-P
- Geom2dGcc_Circ2dTanCen aCt2(Geom2dGcc::Unqualified(aC[0]),
+ Geom2dGcc_Circ2dTanCen aCt2(Geom2dGcc::Unqualified(new Geom2dAdaptor_Curve(aC[0])),
new Geom2d_CartesianPoint(aP[0]), aTol);
theDI << "Solution of type C-P is: ";
return solutions(theDI, aCt2, theArgVals[1]);
return 1;
}
Standard_Real ang = Draw::Atof(a[4]) * (M_PI / 180.0);
- Geom2dGcc_Lin2dTanObl ct3(Geom2dGcc::Unqualified(C1),
+ Geom2dGcc_Lin2dTanObl ct3(Geom2dGcc::Unqualified(new Geom2dAdaptor_Curve(C1)),
L->Lin2d(),
Precision::Angular(),
(C1->FirstParameter()+C1->LastParameter())/2.,
di << "Lin2dTanObl Not done\n";
}
else {
- Geom2dGcc_Lin2d2Tan ct3(Geom2dGcc::Unqualified(C1),
- Geom2dGcc::Unqualified(C2),
+ Geom2dGcc_Lin2d2Tan ct3(Geom2dGcc::Unqualified(new Geom2dAdaptor_Curve(C1)),
+ Geom2dGcc::Unqualified(new Geom2dAdaptor_Curve(C2)),
Precision::Angular(),
(C1->FirstParameter()+C1->LastParameter())/2.,
(C2->FirstParameter()+C2->LastParameter())/2.);
#include <math_MultipleVarFunction.hxx>
#include <math_BrentMinimum.hxx>
-static Standard_Real CompLocalDev(const Adaptor3d_Curve& theCurve,
+static Standard_Real CompLocalDev(const Handle(Adaptor3d_Curve)& theCurve,
const Standard_Real u1, const Standard_Real u2);
-static void ComputeDeviation(const Adaptor3d_Curve& theCurve,
+static void ComputeDeviation(const Handle(Adaptor3d_Curve)& theCurve,
const Handle(Geom_BSplineCurve)& thePnts,
Standard_Real& theDmax,
Standard_Real& theUfMax,
}
}
-Standard_Real CompLocalDev(const Adaptor3d_Curve& theCurve,
+Standard_Real CompLocalDev(const Handle(Adaptor3d_Curve)& theCurve,
const Standard_Real u1, const Standard_Real u2)
{
math_Vector aLowBorder(1,1);
defl = Draw::Atof(a[3]);
- GCPnts_QuasiUniformDeflection PntGen (*aHCurve, defl);
+ GCPnts_QuasiUniformDeflection PntGen (aHCurve, defl);
if(!PntGen.IsDone()) {
di << "Points generation failed\n";
Standard_Integer imax = 0;
//check deviation
- ComputeDeviation (*aHCurve, aPnts, dmax, ufmax, ulmax, imax);
+ ComputeDeviation (aHCurve, aPnts, dmax, ufmax, ulmax, imax);
di << "Max defl: " << dmax << " " << ufmax << " " << ulmax << " " << imax << "\n";
return 0;
if(n > 5)
aMinPntsNb = Draw::Atoi (a[5]);
- GCPnts_TangentialDeflection PntGen (*aHCurve, angle, defl, aMinPntsNb);
+ GCPnts_TangentialDeflection PntGen (aHCurve, angle, defl, aMinPntsNb);
nbp = PntGen.NbPoints();
di << "Nb points : " << nbp << "\n";
Standard_Integer imax = 0;
//check deviation
- ComputeDeviation (*aHCurve, aPnts, dmax, ufmax, ulmax, imax);
+ ComputeDeviation (aHCurve, aPnts, dmax, ufmax, ulmax, imax);
//
di << "Max defl: " << dmax << " " << ufmax << " " << ulmax << " " << imax << "\n";
GeomLProp_CLProps Prop(ellip,2,Precision::Intersection());
Prop.SetCurve(ellip);
- GeomAdaptor_Curve GAC(ellip);
- di<<"Type Of curve: "<<GAC.GetType()<<"\n";
+ Handle(GeomAdaptor_Curve) GAC = new GeomAdaptor_Curve(ellip);
+ di<<"Type Of curve: "<<GAC->GetType()<<"\n";
Standard_Real Tol = Precision::Confusion();
Standard_Real L;
- L = GCPnts_AbscissaPoint::Length(GAC, GAC.FirstParameter(), GAC.LastParameter(), Tol);
+ L = GCPnts_AbscissaPoint::Length(GAC, GAC->FirstParameter(), GAC->LastParameter(), Tol);
di<<"Ellipse length = "<<L<<"\n";
Standard_Real Abscissa = L/(nocp-1);
di << " CUR : Abscissa " << Abscissa << "\n";
GeomLProp_CLProps Prop(ellip,2,Precision::Intersection());
Prop.SetCurve(ellip);
- GeomAdaptor_Curve GAC(ellip);
- di<<"Type Of curve: "<<GAC.GetType()<<"\n";
+ Handle(GeomAdaptor_Curve) GAC = new GeomAdaptor_Curve(ellip);
+ di<<"Type Of curve: "<<GAC->GetType()<<"\n";
Standard_Real Tol = Precision::Confusion();
Standard_Real L;
- L = GCPnts_AbscissaPoint::Length(GAC, GAC.FirstParameter(), GAC.LastParameter(), Tol);
+ L = GCPnts_AbscissaPoint::Length(GAC, GAC->FirstParameter(), GAC->LastParameter(), Tol);
di<<"Ellipse length = "<<L<<"\n";
Standard_Real Abscissa = L/(nocp-1);
di << " CUR : Abscissa " << Abscissa << "\n";
return 1;
}
- GeomAdaptor_Curve aCurveAdaptor(aCurve);
+ Handle(GeomAdaptor_Curve) aCurveAdaptor = new GeomAdaptor_Curve(aCurve);
GCPnts_UniformAbscissa aSplitter(aCurveAdaptor, aSrcNbPnts, Precision::Confusion());
if (!aSplitter.IsDone())
{
for (Standard_Integer aPntIter = 1; aPntIter <= aDstNbPnts; ++aPntIter)
{
- aPoles.ChangeValue(aPntIter) = aCurveAdaptor.Value(aSplitter.Parameter(aPntIter));
+ aPoles.ChangeValue(aPntIter) = aCurveAdaptor->Value(aSplitter.Parameter(aPntIter));
aKnots.ChangeValue(aPntIter) = (aPntIter - 1) / (aDstNbPnts - 1.0);
aMultiplicities.ChangeValue(aPntIter) = 1;
}
Standard_Real dmax = 0., ufmax = 0., ulmax = 0.;
Standard_Integer imax = 0;
- ComputeDeviation(GeomAdaptor_Curve(C),aPnts,dmax,ufmax,ulmax,imax);
+ ComputeDeviation(new GeomAdaptor_Curve(C),aPnts,dmax,ufmax,ulmax,imax);
di << "Max defl: " << dmax << " " << ufmax << " " << ulmax << " " << imax << "\n";
return 0;
return 1;
}
- Geom2dAdaptor_Curve anAC(aC);
+ Handle(Geom2dAdaptor_Curve) anAC = new Geom2dAdaptor_Curve(aC);
Standard_Integer aNbInterv = 2;
Standard_Real aU0 = RealLast();
}
}
- const Standard_Real aU1 = anAC.FirstParameter();
- const Standard_Real aU2 = anAC.LastParameter();
+ const Standard_Real aU1 = anAC->FirstParameter();
+ const Standard_Real aU2 = anAC->LastParameter();
Standard_Real aRetCurvParam = aU0;
gp_Pnt2d aPtOnCurv;
if (n==3) Tol = Draw::Atof(a[2]);
if (!GC.IsNull()) {
- GeomAdaptor_Curve AC(GC);
+ Handle(GeomAdaptor_Curve) AC = new GeomAdaptor_Curve(GC);
L = GCPnts_AbscissaPoint::Length(AC, Tol);
}
else if (!GC2d.IsNull()) {
- Geom2dAdaptor_Curve AC(GC2d);
+ Handle(Geom2dAdaptor_Curve) AC = new Geom2dAdaptor_Curve(GC2d);
L = GCPnts_AbscissaPoint::Length(AC, Tol);
}
else {
case GeomAbs_BSplineCurve: {
Handle(Geom2d_BSplineCurve) ec2d;
- GeomAdaptor_Curve GAcurve = ec.GetCurve().Curve();
- TopoDS_Edge anEdge = ec.GetCurve().Edge();
+ const Handle(GeomAdaptor_Curve)& GAcurve = ec.Curve()->Curve();
+ TopoDS_Edge anEdge = ec.Curve()->Edge();
Standard_Real fpar, lpar;
Handle(Geom_Curve) aCurve = BRep_Tool::Curve(anEdge, fpar, lpar);
if (aCurve->DynamicType() == STANDARD_TYPE(Geom_TrimmedCurve))
aCurve = (Handle(Geom_TrimmedCurve)::DownCast(aCurve))->BasisCurve();
Handle(Geom_BSplineCurve) BSplCurve (Handle(Geom_BSplineCurve)::DownCast(aCurve));
Handle(Geom_BSplineCurve) theCurve = Handle(Geom_BSplineCurve)::DownCast(BSplCurve->Copy());
- if (theCurve->IsPeriodic() && !GAcurve.IsClosed())
+ if (theCurve->IsPeriodic() && !GAcurve->IsClosed())
{
theCurve->Segment(sta, end);
TColgp_Array1OfPnt2d Poles(1, theCurve->NbPoles());
//const Standard_Real sta = ec.Parameter2d(U1);
//const Standard_Real end = ec.Parameter2d(U2);
- TopoDS_Edge anEdge = ec.GetCurve().Edge();
+ TopoDS_Edge anEdge = ec.Curve()->Edge();
Standard_Real fpar, lpar;
//BRep_Tool::Range(anEdge, fpar, lpar);
//Handle(Geom_Curve) aCurve = BRep_Tool::Curve(anEdge, fpar, lpar);
//purpose :
//=======================================================================
Standard_Integer
-HLRBRep_BCurveTool::NbSamples (const BRepAdaptor_Curve& C,
+HLRBRep_BCurveTool::NbSamples (const Handle(BRepAdaptor_Curve)& C,
const Standard_Real U0,
const Standard_Real U1)
{
- GeomAbs_CurveType typC = C.GetType();
+ GeomAbs_CurveType typC = C->GetType();
static Standard_Real nbsOther = 10.0;
Standard_Real nbs = nbsOther;
if(typC == GeomAbs_Line)
nbs = 2;
else if(typC == GeomAbs_BezierCurve)
- nbs = 3 + C.NbPoles();
+ nbs = 3 + C->NbPoles();
else if(typC == GeomAbs_BSplineCurve) {
- nbs = C.NbKnots();
- nbs*= C.Degree();
- nbs*= C.LastParameter()- C.FirstParameter();
+ nbs = C->NbKnots();
+ nbs*= C->Degree();
+ nbs*= C->LastParameter()- C->FirstParameter();
nbs/= U1-U0;
if(nbs < 2.0) nbs=2;
}
//purpose :
//=======================================================================
-void HLRBRep_BCurveTool::Poles(const BRepAdaptor_Curve& C,
+void HLRBRep_BCurveTool::Poles(const Handle(BRepAdaptor_Curve)& C,
TColgp_Array1OfPnt& T)
{
- if(C.GetType() == GeomAbs_BezierCurve)
- C.Bezier()->Poles(T);
- else if(C.GetType() == GeomAbs_BSplineCurve)
- C.BSpline()->Poles(T);
+ if(C->GetType() == GeomAbs_BezierCurve)
+ C->Bezier()->Poles(T);
+ else if(C->GetType() == GeomAbs_BSplineCurve)
+ C->BSpline()->Poles(T);
}
//=======================================================================
//purpose :
//=======================================================================
-void HLRBRep_BCurveTool::PolesAndWeights(const BRepAdaptor_Curve& C,
+void HLRBRep_BCurveTool::PolesAndWeights(const Handle(BRepAdaptor_Curve)& C,
TColgp_Array1OfPnt& T,
TColStd_Array1OfReal& W)
{
- if(C.GetType() == GeomAbs_BezierCurve) {
- const Handle(Geom_BezierCurve) HB = C.Bezier();
+ if(C->GetType() == GeomAbs_BezierCurve) {
+ const Handle(Geom_BezierCurve) HB = C->Bezier();
HB->Poles(T);
HB->Weights(W);
}
- else if(C.GetType() == GeomAbs_BSplineCurve) {
- const Handle(Geom_BSplineCurve) HB = C.BSpline();
+ else if(C->GetType() == GeomAbs_BSplineCurve) {
+ const Handle(Geom_BSplineCurve) HB = C->BSpline();
HB->Poles(T);
HB->Weights(W);
}
//=======================================================================
Handle(Geom_BezierCurve)
- HLRBRep_BCurveTool::Bezier (const BRepAdaptor_Curve& C)
-{ return(C.Bezier()); }
+ HLRBRep_BCurveTool::Bezier (const Handle(BRepAdaptor_Curve)& C)
+{ return(C->Bezier()); }
//=======================================================================
//function : BSpline
//=======================================================================
Handle(Geom_BSplineCurve)
- HLRBRep_BCurveTool::BSpline (const BRepAdaptor_Curve& C)
-{ return(C.BSpline()); }
+ HLRBRep_BCurveTool::BSpline (const Handle(BRepAdaptor_Curve)& C)
+{ return(C->BSpline()); }
DEFINE_STANDARD_ALLOC
- static Standard_Real FirstParameter (const BRepAdaptor_Curve& C);
+ static Standard_Real FirstParameter (const Handle(BRepAdaptor_Curve)& C);
- static Standard_Real LastParameter (const BRepAdaptor_Curve& C);
+ static Standard_Real LastParameter (const Handle(BRepAdaptor_Curve)& C);
- static GeomAbs_Shape Continuity (const BRepAdaptor_Curve& C);
+ static GeomAbs_Shape Continuity (const Handle(BRepAdaptor_Curve)& C);
//! Returns the number of intervals for continuity
//! <S>. May be one if Continuity(myclass) >= <S>
- static Standard_Integer NbIntervals (const BRepAdaptor_Curve& C, const GeomAbs_Shape S);
+ static Standard_Integer NbIntervals (const Handle(BRepAdaptor_Curve)& C, const GeomAbs_Shape S);
//! Stores in <T> the parameters bounding the intervals
//! of continuity <S>.
//!
//! The array must provide enough room to accommodate
//! for the parameters. i.e. T.Length() > NbIntervals()
- static void Intervals (const BRepAdaptor_Curve& C, TColStd_Array1OfReal& T, const GeomAbs_Shape S);
+ static void Intervals (const Handle(BRepAdaptor_Curve)& C, TColStd_Array1OfReal& T, const GeomAbs_Shape S);
- static Standard_Boolean IsClosed (const BRepAdaptor_Curve& C);
+ static Standard_Boolean IsClosed (const Handle(BRepAdaptor_Curve)& C);
- static Standard_Boolean IsPeriodic (const BRepAdaptor_Curve& C);
+ static Standard_Boolean IsPeriodic (const Handle(BRepAdaptor_Curve)& C);
- static Standard_Real Period (const BRepAdaptor_Curve& C);
+ static Standard_Real Period (const Handle(BRepAdaptor_Curve)& C);
//! Computes the point of parameter U on the curve.
- static gp_Pnt Value (const BRepAdaptor_Curve& C, const Standard_Real U);
+ static gp_Pnt Value (const Handle(BRepAdaptor_Curve)& C, const Standard_Real U);
//! Computes the point of parameter U on the curve.
- static void D0 (const BRepAdaptor_Curve& C, const Standard_Real U, gp_Pnt& P);
+ static void D0 (const Handle(BRepAdaptor_Curve)& C, const Standard_Real U, gp_Pnt& P);
//! Computes the point of parameter U on the curve with its
//! first derivative.
//! Raised if the continuity of the current interval
//! is not C1.
- static void D1 (const BRepAdaptor_Curve& C, const Standard_Real U, gp_Pnt& P, gp_Vec& V);
+ static void D1 (const Handle(BRepAdaptor_Curve)& C, const Standard_Real U, gp_Pnt& P, gp_Vec& V);
//! Returns the point P of parameter U, the first and second
//! derivatives V1 and V2.
//! Raised if the continuity of the current interval
//! is not C2.
- static void D2 (const BRepAdaptor_Curve& C, const Standard_Real U, gp_Pnt& P, gp_Vec& V1, gp_Vec& V2);
+ static void D2 (const Handle(BRepAdaptor_Curve)& C, const Standard_Real U, gp_Pnt& P, gp_Vec& V1, gp_Vec& V2);
//! Returns the point P of parameter U, the first, the second
//! and the third derivative.
//! Raised if the continuity of the current interval
//! is not C3.
- static void D3 (const BRepAdaptor_Curve& C, const Standard_Real U, gp_Pnt& P, gp_Vec& V1, gp_Vec& V2, gp_Vec& V3);
+ static void D3 (const Handle(BRepAdaptor_Curve)& C, const Standard_Real U, gp_Pnt& P, gp_Vec& V1, gp_Vec& V2, gp_Vec& V3);
//! The returned vector gives the value of the derivative for the
//! Raised if the continuity of the current interval
//! is not CN.
//! Raised if N < 1.
- static gp_Vec DN (const BRepAdaptor_Curve& C, const Standard_Real U, const Standard_Integer N);
+ static gp_Vec DN (const Handle(BRepAdaptor_Curve)& C, const Standard_Real U, const Standard_Integer N);
//! Returns the parametric resolution corresponding
//! to the real space resolution <R3d>.
- static Standard_Real Resolution (const BRepAdaptor_Curve& C, const Standard_Real R3d);
+ static Standard_Real Resolution (const Handle(BRepAdaptor_Curve)& C, const Standard_Real R3d);
//! Returns the type of the curve in the current
//! interval : Line, Circle, Ellipse, Hyperbola,
//! Parabola, BezierCurve, BSplineCurve, OtherCurve.
- static GeomAbs_CurveType GetType (const BRepAdaptor_Curve& C);
+ static GeomAbs_CurveType GetType (const Handle(BRepAdaptor_Curve)& C);
- static gp_Lin Line (const BRepAdaptor_Curve& C);
+ static gp_Lin Line (const Handle(BRepAdaptor_Curve)& C);
- static gp_Circ Circle (const BRepAdaptor_Curve& C);
+ static gp_Circ Circle (const Handle(BRepAdaptor_Curve)& C);
- static gp_Elips Ellipse (const BRepAdaptor_Curve& C);
+ static gp_Elips Ellipse (const Handle(BRepAdaptor_Curve)& C);
- static gp_Hypr Hyperbola (const BRepAdaptor_Curve& C);
+ static gp_Hypr Hyperbola (const Handle(BRepAdaptor_Curve)& C);
- static gp_Parab Parabola (const BRepAdaptor_Curve& C);
+ static gp_Parab Parabola (const Handle(BRepAdaptor_Curve)& C);
- Standard_EXPORT static Handle(Geom_BezierCurve) Bezier (const BRepAdaptor_Curve& C);
+ Standard_EXPORT static Handle(Geom_BezierCurve) Bezier (const Handle(BRepAdaptor_Curve)& C);
- Standard_EXPORT static Handle(Geom_BSplineCurve) BSpline (const BRepAdaptor_Curve& C);
+ Standard_EXPORT static Handle(Geom_BSplineCurve) BSpline (const Handle(BRepAdaptor_Curve)& C);
- static Standard_Integer Degree (const BRepAdaptor_Curve& C);
+ static Standard_Integer Degree (const Handle(BRepAdaptor_Curve)& C);
- static Standard_Boolean IsRational (const BRepAdaptor_Curve& C);
+ static Standard_Boolean IsRational (const Handle(BRepAdaptor_Curve)& C);
- static Standard_Integer NbPoles (const BRepAdaptor_Curve& C);
+ static Standard_Integer NbPoles (const Handle(BRepAdaptor_Curve)& C);
- static Standard_Integer NbKnots (const BRepAdaptor_Curve& C);
+ static Standard_Integer NbKnots (const Handle(BRepAdaptor_Curve)& C);
- Standard_EXPORT static void Poles (const BRepAdaptor_Curve& C, TColgp_Array1OfPnt& T);
+ Standard_EXPORT static void Poles (const Handle(BRepAdaptor_Curve)& C, TColgp_Array1OfPnt& T);
- Standard_EXPORT static void PolesAndWeights (const BRepAdaptor_Curve& C, TColgp_Array1OfPnt& T, TColStd_Array1OfReal& W);
+ Standard_EXPORT static void PolesAndWeights (const Handle(BRepAdaptor_Curve)& C, TColgp_Array1OfPnt& T, TColStd_Array1OfReal& W);
- Standard_EXPORT static Standard_Integer NbSamples (const BRepAdaptor_Curve& C, const Standard_Real U0, const Standard_Real U1);
+ Standard_EXPORT static Standard_Integer NbSamples (const Handle(BRepAdaptor_Curve)& C, const Standard_Real U0, const Standard_Real U1);
//=======================================================================
inline Standard_Real
-HLRBRep_BCurveTool::FirstParameter (const BRepAdaptor_Curve& C)
-{ return(C.FirstParameter()); }
+HLRBRep_BCurveTool::FirstParameter (const Handle(BRepAdaptor_Curve)& C)
+{ return(C->FirstParameter()); }
//=======================================================================
//function : LastParameter
//=======================================================================
inline Standard_Real
-HLRBRep_BCurveTool::LastParameter (const BRepAdaptor_Curve& C)
-{ return(C.LastParameter()); }
+HLRBRep_BCurveTool::LastParameter (const Handle(BRepAdaptor_Curve)& C)
+{ return(C->LastParameter()); }
//=======================================================================
//function : Continuity
//=======================================================================
inline GeomAbs_Shape
-HLRBRep_BCurveTool::Continuity (const BRepAdaptor_Curve& C)
-{ return(C.Continuity()); }
+HLRBRep_BCurveTool::Continuity (const Handle(BRepAdaptor_Curve)& C)
+{ return(C->Continuity()); }
//=======================================================================
//function : NbIntervals
//=======================================================================
inline Standard_Integer
-HLRBRep_BCurveTool::NbIntervals(const BRepAdaptor_Curve& C,
+HLRBRep_BCurveTool::NbIntervals(const Handle(BRepAdaptor_Curve)& C,
const GeomAbs_Shape Sh)
-{ return(C.NbIntervals(Sh)); }
+{ return(C->NbIntervals(Sh)); }
//=======================================================================
//function : Intervals
//=======================================================================
inline void
-HLRBRep_BCurveTool::Intervals(const BRepAdaptor_Curve& C,
+HLRBRep_BCurveTool::Intervals(const Handle(BRepAdaptor_Curve)& C,
TColStd_Array1OfReal& Tab,
const GeomAbs_Shape Sh)
-{ C.Intervals(Tab,Sh); }
+{ C->Intervals(Tab,Sh); }
//=======================================================================
//function : IsClosed
//=======================================================================
inline Standard_Boolean
-HLRBRep_BCurveTool::IsClosed(const BRepAdaptor_Curve& C)
-{ return(C.IsClosed()); }
+HLRBRep_BCurveTool::IsClosed(const Handle(BRepAdaptor_Curve)& C)
+{ return(C->IsClosed()); }
//=======================================================================
//function : IsPeriodic
//=======================================================================
inline Standard_Boolean
-HLRBRep_BCurveTool::IsPeriodic(const BRepAdaptor_Curve& C)
-{ return(C.IsPeriodic()); }
+HLRBRep_BCurveTool::IsPeriodic(const Handle(BRepAdaptor_Curve)& C)
+{ return(C->IsPeriodic()); }
//=======================================================================
//function : Period
//=======================================================================
inline Standard_Real
-HLRBRep_BCurveTool::Period(const BRepAdaptor_Curve& C)
-{ return(C.Period()); }
+HLRBRep_BCurveTool::Period(const Handle(BRepAdaptor_Curve)& C)
+{ return(C->Period()); }
//=======================================================================
//function : Value
//=======================================================================
inline gp_Pnt
-HLRBRep_BCurveTool::Value (const BRepAdaptor_Curve& C,
+HLRBRep_BCurveTool::Value (const Handle(BRepAdaptor_Curve)& C,
const Standard_Real U)
-{ return(C.Value(U)); }
+{ return(C->Value(U)); }
//=======================================================================
//function : D0
//=======================================================================
inline void
-HLRBRep_BCurveTool::D0(const BRepAdaptor_Curve& C,
+HLRBRep_BCurveTool::D0(const Handle(BRepAdaptor_Curve)& C,
const Standard_Real U,
gp_Pnt& P)
-{ C.D0(U,P); }
+{ C->D0(U,P); }
//=======================================================================
//function : D1
//=======================================================================
inline void
-HLRBRep_BCurveTool::D1 (const BRepAdaptor_Curve& C,
+HLRBRep_BCurveTool::D1 (const Handle(BRepAdaptor_Curve)& C,
const Standard_Real U,
gp_Pnt& P,
gp_Vec& T)
-{ C.D1(U,P,T); }
+{ C->D1(U,P,T); }
inline void
-HLRBRep_BCurveTool::D2 (const BRepAdaptor_Curve& C,
+HLRBRep_BCurveTool::D2 (const Handle(BRepAdaptor_Curve)& C,
const Standard_Real U,
gp_Pnt& P,
gp_Vec& T,
gp_Vec& N)
-{ C.D2(U,P,T,N); }
+{ C->D2(U,P,T,N); }
//=======================================================================
//function : D3
//=======================================================================
inline void
-HLRBRep_BCurveTool::D3 (const BRepAdaptor_Curve& C,
+HLRBRep_BCurveTool::D3 (const Handle(BRepAdaptor_Curve)& C,
const Standard_Real U,
gp_Pnt& P,
gp_Vec& V1,
gp_Vec& V2,
gp_Vec& V3)
-{ C.D3(U,P,V1,V2,V3); }
+{ C->D3(U,P,V1,V2,V3); }
//=======================================================================
//function : DN
//=======================================================================
inline gp_Vec
-HLRBRep_BCurveTool::DN (const BRepAdaptor_Curve& C,
+HLRBRep_BCurveTool::DN (const Handle(BRepAdaptor_Curve)& C,
const Standard_Real U,
const Standard_Integer N)
-{ return(C.DN(U,N)); }
+{ return(C->DN(U,N)); }
//=======================================================================
//function : Resolution
//=======================================================================
inline Standard_Real
-HLRBRep_BCurveTool::Resolution(const BRepAdaptor_Curve& C,
+HLRBRep_BCurveTool::Resolution(const Handle(BRepAdaptor_Curve)& C,
const Standard_Real R3d)
-{ return(C.Resolution(R3d)); }
+{ return(C->Resolution(R3d)); }
//=======================================================================
//function : GetType
//=======================================================================
inline GeomAbs_CurveType
- HLRBRep_BCurveTool::GetType(const BRepAdaptor_Curve& C)
-{ return(C.GetType()); }
+ HLRBRep_BCurveTool::GetType(const Handle(BRepAdaptor_Curve)& C)
+{ return(C->GetType()); }
//=======================================================================
//function : Line
//=======================================================================
inline gp_Lin
-HLRBRep_BCurveTool::Line (const BRepAdaptor_Curve& C)
-{ return(C.Line()); }
+HLRBRep_BCurveTool::Line (const Handle(BRepAdaptor_Curve)& C)
+{ return(C->Line()); }
//=======================================================================
//function : Circle
//=======================================================================
inline gp_Circ
-HLRBRep_BCurveTool::Circle (const BRepAdaptor_Curve& C)
-{ return(C.Circle()); }
+HLRBRep_BCurveTool::Circle (const Handle(BRepAdaptor_Curve)& C)
+{ return(C->Circle()); }
//=======================================================================
//function : Ellipse
//=======================================================================
inline gp_Elips
-HLRBRep_BCurveTool::Ellipse (const BRepAdaptor_Curve& C)
-{ return(C.Ellipse()); }
+HLRBRep_BCurveTool::Ellipse (const Handle(BRepAdaptor_Curve)& C)
+{ return(C->Ellipse()); }
//=======================================================================
//function : Parabola
//=======================================================================
inline gp_Parab
-HLRBRep_BCurveTool::Parabola (const BRepAdaptor_Curve& C)
-{ return(C.Parabola()); }
+HLRBRep_BCurveTool::Parabola (const Handle(BRepAdaptor_Curve)& C)
+{ return(C->Parabola()); }
//=======================================================================
//function : Hyperbola
//=======================================================================
inline gp_Hypr
-HLRBRep_BCurveTool::Hyperbola (const BRepAdaptor_Curve& C)
-{ return(C.Hyperbola()); }
+HLRBRep_BCurveTool::Hyperbola (const Handle(BRepAdaptor_Curve)& C)
+{ return(C->Hyperbola()); }
//=======================================================================
//function : Degree
//=======================================================================
inline Standard_Integer
-HLRBRep_BCurveTool::Degree (const BRepAdaptor_Curve& C)
-{ return(C.Degree()); }
+HLRBRep_BCurveTool::Degree (const Handle(BRepAdaptor_Curve)& C)
+{ return(C->Degree()); }
//=======================================================================
//function : IsRational
//=======================================================================
inline Standard_Boolean
-HLRBRep_BCurveTool::IsRational (const BRepAdaptor_Curve& C)
-{ return(C.IsRational()); }
+HLRBRep_BCurveTool::IsRational (const Handle(BRepAdaptor_Curve)& C)
+{ return(C->IsRational()); }
//=======================================================================
//function : NbPoles
//=======================================================================
inline Standard_Integer
-HLRBRep_BCurveTool::NbPoles (const BRepAdaptor_Curve& C)
-{ return(C.NbPoles()); }
+HLRBRep_BCurveTool::NbPoles (const Handle(BRepAdaptor_Curve)& C)
+{ return(C->NbPoles()); }
//=======================================================================
//function : NbKnots
//=======================================================================
inline Standard_Integer
-HLRBRep_BCurveTool::NbKnots(const BRepAdaptor_Curve& C)
-{ return(C.NbKnots()); }
+HLRBRep_BCurveTool::NbKnots(const Handle(BRepAdaptor_Curve)& C)
+{ return(C->NbKnots()); }
//purpose :
//=======================================================================
Standard_Integer
-HLRBRep_BSurfaceTool::NbSamplesU(const BRepAdaptor_Surface& S)
+HLRBRep_BSurfaceTool::NbSamplesU(const Handle(BRepAdaptor_Surface)& S)
{
Standard_Integer nbs;
- GeomAbs_SurfaceType typS = S.GetType();
+ GeomAbs_SurfaceType typS = S->GetType();
switch(typS) {
case GeomAbs_Plane:
{
break;
case GeomAbs_BezierSurface:
{
- nbs = 3 + S.NbUPoles();
+ nbs = 3 + S->NbUPoles();
}
break;
case GeomAbs_BSplineSurface:
{
- nbs = S.NbUKnots();
- nbs*= S.UDegree();
+ nbs = S->NbUKnots();
+ nbs*= S->UDegree();
if(nbs < 2) nbs=2;
}
//=======================================================================
Standard_Integer
-HLRBRep_BSurfaceTool::NbSamplesV(const BRepAdaptor_Surface& S)
+HLRBRep_BSurfaceTool::NbSamplesV(const Handle(BRepAdaptor_Surface)& S)
{
Standard_Integer nbs;
- GeomAbs_SurfaceType typS = S.GetType();
+ GeomAbs_SurfaceType typS = S->GetType();
switch(typS) {
case GeomAbs_Plane:
{
break;
case GeomAbs_BezierSurface:
{
- nbs = 3 + S.NbVPoles();
+ nbs = 3 + S->NbVPoles();
}
break;
case GeomAbs_BSplineSurface:
{
- nbs = S.NbVKnots();
- nbs*= S.VDegree();
+ nbs = S->NbVKnots();
+ nbs*= S->VDegree();
if(nbs < 2) nbs=2;
}
//=======================================================================
Standard_Integer
-HLRBRep_BSurfaceTool::NbSamplesU(const BRepAdaptor_Surface& S,
+HLRBRep_BSurfaceTool::NbSamplesU(const Handle(BRepAdaptor_Surface)& S,
const Standard_Real u1,
const Standard_Real u2)
{
//=======================================================================
Standard_Integer
-HLRBRep_BSurfaceTool::NbSamplesV(const BRepAdaptor_Surface& S,
+HLRBRep_BSurfaceTool::NbSamplesV(const Handle(BRepAdaptor_Surface)& S,
const Standard_Real v1,
const Standard_Real v2)
{
DEFINE_STANDARD_ALLOC
- static Standard_Real FirstUParameter (const BRepAdaptor_Surface& S);
+ static Standard_Real FirstUParameter (const Handle(BRepAdaptor_Surface)& S);
- static Standard_Real FirstVParameter (const BRepAdaptor_Surface& S);
+ static Standard_Real FirstVParameter (const Handle(BRepAdaptor_Surface)& S);
- static Standard_Real LastUParameter (const BRepAdaptor_Surface& S);
+ static Standard_Real LastUParameter (const Handle(BRepAdaptor_Surface)& S);
- static Standard_Real LastVParameter (const BRepAdaptor_Surface& S);
+ static Standard_Real LastVParameter (const Handle(BRepAdaptor_Surface)& S);
- static Standard_Integer NbUIntervals (const BRepAdaptor_Surface& S, const GeomAbs_Shape Sh);
+ static Standard_Integer NbUIntervals (const Handle(BRepAdaptor_Surface)& S, const GeomAbs_Shape Sh);
- static Standard_Integer NbVIntervals (const BRepAdaptor_Surface& S, const GeomAbs_Shape Sh);
+ static Standard_Integer NbVIntervals (const Handle(BRepAdaptor_Surface)& S, const GeomAbs_Shape Sh);
- static void UIntervals (const BRepAdaptor_Surface& S, TColStd_Array1OfReal& T, const GeomAbs_Shape Sh);
+ static void UIntervals (const Handle(BRepAdaptor_Surface)& S, TColStd_Array1OfReal& T, const GeomAbs_Shape Sh);
- static void VIntervals (const BRepAdaptor_Surface& S, TColStd_Array1OfReal& T, const GeomAbs_Shape Sh);
+ static void VIntervals (const Handle(BRepAdaptor_Surface)& S, TColStd_Array1OfReal& T, const GeomAbs_Shape Sh);
//! If <First> >= <Last>
- static Handle(Adaptor3d_Surface) UTrim (const BRepAdaptor_Surface& S, const Standard_Real First, const Standard_Real Last, const Standard_Real Tol);
+ static Handle(Adaptor3d_Surface) UTrim (const Handle(BRepAdaptor_Surface)& S, const Standard_Real First, const Standard_Real Last, const Standard_Real Tol);
//! If <First> >= <Last>
- static Handle(Adaptor3d_Surface) VTrim (const BRepAdaptor_Surface& S, const Standard_Real First, const Standard_Real Last, const Standard_Real Tol);
+ static Handle(Adaptor3d_Surface) VTrim (const Handle(BRepAdaptor_Surface)& S, const Standard_Real First, const Standard_Real Last, const Standard_Real Tol);
- static Standard_Boolean IsUClosed (const BRepAdaptor_Surface& S);
+ static Standard_Boolean IsUClosed (const Handle(BRepAdaptor_Surface)& S);
- static Standard_Boolean IsVClosed (const BRepAdaptor_Surface& S);
+ static Standard_Boolean IsVClosed (const Handle(BRepAdaptor_Surface)& S);
- static Standard_Boolean IsUPeriodic (const BRepAdaptor_Surface& S);
+ static Standard_Boolean IsUPeriodic (const Handle(BRepAdaptor_Surface)& S);
- static Standard_Real UPeriod (const BRepAdaptor_Surface& S);
+ static Standard_Real UPeriod (const Handle(BRepAdaptor_Surface)& S);
- static Standard_Boolean IsVPeriodic (const BRepAdaptor_Surface& S);
+ static Standard_Boolean IsVPeriodic (const Handle(BRepAdaptor_Surface)& S);
- static Standard_Real VPeriod (const BRepAdaptor_Surface& S);
+ static Standard_Real VPeriod (const Handle(BRepAdaptor_Surface)& S);
- static gp_Pnt Value (const BRepAdaptor_Surface& S, const Standard_Real u, const Standard_Real v);
+ static gp_Pnt Value (const Handle(BRepAdaptor_Surface)& S, const Standard_Real u, const Standard_Real v);
- static void D0 (const BRepAdaptor_Surface& S, const Standard_Real u, const Standard_Real v, gp_Pnt& P);
+ static void D0 (const Handle(BRepAdaptor_Surface)& S, const Standard_Real u, const Standard_Real v, gp_Pnt& P);
- static void D1 (const BRepAdaptor_Surface& S, const Standard_Real u, const Standard_Real v, gp_Pnt& P, gp_Vec& D1u, gp_Vec& D1v);
+ static void D1 (const Handle(BRepAdaptor_Surface)& S, const Standard_Real u, const Standard_Real v, gp_Pnt& P, gp_Vec& D1u, gp_Vec& D1v);
- static void D2 (const BRepAdaptor_Surface& S, const Standard_Real u, const Standard_Real v, gp_Pnt& P, gp_Vec& D1U, gp_Vec& D1V, gp_Vec& D2U, gp_Vec& D2V, gp_Vec& D2UV);
+ static void D2 (const Handle(BRepAdaptor_Surface)& S, const Standard_Real u, const Standard_Real v, gp_Pnt& P, gp_Vec& D1U, gp_Vec& D1V, gp_Vec& D2U, gp_Vec& D2V, gp_Vec& D2UV);
- static void D3 (const BRepAdaptor_Surface& S, const Standard_Real u, const Standard_Real v, gp_Pnt& P, gp_Vec& D1U, gp_Vec& D1V, gp_Vec& D2U, gp_Vec& D2V, gp_Vec& D2UV, gp_Vec& D3U, gp_Vec& D3V, gp_Vec& D3UUV, gp_Vec& D3UVV);
+ static void D3 (const Handle(BRepAdaptor_Surface)& S, const Standard_Real u, const Standard_Real v, gp_Pnt& P, gp_Vec& D1U, gp_Vec& D1V, gp_Vec& D2U, gp_Vec& D2V, gp_Vec& D2UV, gp_Vec& D3U, gp_Vec& D3V, gp_Vec& D3UUV, gp_Vec& D3UVV);
- static gp_Vec DN (const BRepAdaptor_Surface& S, const Standard_Real u, const Standard_Real v, const Standard_Integer Nu, const Standard_Integer Nv);
+ static gp_Vec DN (const Handle(BRepAdaptor_Surface)& S, const Standard_Real u, const Standard_Real v, const Standard_Integer Nu, const Standard_Integer Nv);
- static GeomAbs_Shape UContinuity (const BRepAdaptor_Surface& S);
+ static GeomAbs_Shape UContinuity (const Handle(BRepAdaptor_Surface)& S);
- static GeomAbs_Shape VContinuity (const BRepAdaptor_Surface& S);
+ static GeomAbs_Shape VContinuity (const Handle(BRepAdaptor_Surface)& S);
- static Standard_Integer UDegree (const BRepAdaptor_Surface& S);
+ static Standard_Integer UDegree (const Handle(BRepAdaptor_Surface)& S);
- static Standard_Integer NbUPoles (const BRepAdaptor_Surface& S);
+ static Standard_Integer NbUPoles (const Handle(BRepAdaptor_Surface)& S);
- static Standard_Integer NbUKnots (const BRepAdaptor_Surface& S);
+ static Standard_Integer NbUKnots (const Handle(BRepAdaptor_Surface)& S);
- static Standard_Boolean IsURational (const BRepAdaptor_Surface& S);
+ static Standard_Boolean IsURational (const Handle(BRepAdaptor_Surface)& S);
- static Standard_Integer VDegree (const BRepAdaptor_Surface& S);
+ static Standard_Integer VDegree (const Handle(BRepAdaptor_Surface)& S);
- static Standard_Integer NbVPoles (const BRepAdaptor_Surface& S);
+ static Standard_Integer NbVPoles (const Handle(BRepAdaptor_Surface)& S);
- static Standard_Integer NbVKnots (const BRepAdaptor_Surface& S);
+ static Standard_Integer NbVKnots (const Handle(BRepAdaptor_Surface)& S);
- static Standard_Boolean IsVRational (const BRepAdaptor_Surface& S);
+ static Standard_Boolean IsVRational (const Handle(BRepAdaptor_Surface)& S);
- static Standard_Real UResolution (const BRepAdaptor_Surface& S, const Standard_Real R3d);
+ static Standard_Real UResolution (const Handle(BRepAdaptor_Surface)& S, const Standard_Real R3d);
- static Standard_Real VResolution (const BRepAdaptor_Surface& S, const Standard_Real R3d);
+ static Standard_Real VResolution (const Handle(BRepAdaptor_Surface)& S, const Standard_Real R3d);
- static GeomAbs_SurfaceType GetType (const BRepAdaptor_Surface& S);
+ static GeomAbs_SurfaceType GetType (const Handle(BRepAdaptor_Surface)& S);
- static gp_Pln Plane (const BRepAdaptor_Surface& S);
+ static gp_Pln Plane (const Handle(BRepAdaptor_Surface)& S);
- static gp_Cylinder Cylinder (const BRepAdaptor_Surface& S);
+ static gp_Cylinder Cylinder (const Handle(BRepAdaptor_Surface)& S);
- static gp_Cone Cone (const BRepAdaptor_Surface& S);
+ static gp_Cone Cone (const Handle(BRepAdaptor_Surface)& S);
- static gp_Torus Torus (const BRepAdaptor_Surface& S);
+ static gp_Torus Torus (const Handle(BRepAdaptor_Surface)& S);
- static gp_Sphere Sphere (const BRepAdaptor_Surface& S);
+ static gp_Sphere Sphere (const Handle(BRepAdaptor_Surface)& S);
- static Handle(Geom_BezierSurface) Bezier (const BRepAdaptor_Surface& S);
+ static Handle(Geom_BezierSurface) Bezier (const Handle(BRepAdaptor_Surface)& S);
- static Handle(Geom_BSplineSurface) BSpline (const BRepAdaptor_Surface& S);
+ static Handle(Geom_BSplineSurface) BSpline (const Handle(BRepAdaptor_Surface)& S);
- static gp_Ax1 AxeOfRevolution (const BRepAdaptor_Surface& S);
+ static gp_Ax1 AxeOfRevolution (const Handle(BRepAdaptor_Surface)& S);
- static gp_Dir Direction (const BRepAdaptor_Surface& S);
+ static gp_Dir Direction (const Handle(BRepAdaptor_Surface)& S);
- static Handle(Adaptor3d_Curve) BasisCurve (const BRepAdaptor_Surface& S);
+ static Handle(Adaptor3d_Curve) BasisCurve (const Handle(BRepAdaptor_Surface)& S);
- static gp_Ax1 Axis (const BRepAdaptor_Surface& S);
+ static gp_Ax1 Axis (const Handle(BRepAdaptor_Surface)& S);
- Standard_EXPORT static Standard_Integer NbSamplesU (const BRepAdaptor_Surface& S);
+ Standard_EXPORT static Standard_Integer NbSamplesU (const Handle(BRepAdaptor_Surface)& S);
- Standard_EXPORT static Standard_Integer NbSamplesV (const BRepAdaptor_Surface& S);
+ Standard_EXPORT static Standard_Integer NbSamplesV (const Handle(BRepAdaptor_Surface)& S);
- Standard_EXPORT static Standard_Integer NbSamplesU (const BRepAdaptor_Surface& S, const Standard_Real u1, const Standard_Real u2);
+ Standard_EXPORT static Standard_Integer NbSamplesU (const Handle(BRepAdaptor_Surface)& S, const Standard_Real u1, const Standard_Real u2);
- Standard_EXPORT static Standard_Integer NbSamplesV (const BRepAdaptor_Surface& S, const Standard_Real v1, const Standard_Real v2);
+ Standard_EXPORT static Standard_Integer NbSamplesV (const Handle(BRepAdaptor_Surface)& S, const Standard_Real v1, const Standard_Real v2);
//=======================================================================
inline Standard_Real
-HLRBRep_BSurfaceTool::FirstUParameter(const BRepAdaptor_Surface& Surf)
-{ return Surf.FirstUParameter(); }
+HLRBRep_BSurfaceTool::FirstUParameter(const Handle(BRepAdaptor_Surface)& Surf)
+{ return Surf->FirstUParameter(); }
//=======================================================================
//function : FirstVParameter
//=======================================================================
inline Standard_Real
-HLRBRep_BSurfaceTool::FirstVParameter(const BRepAdaptor_Surface& Surf)
-{ return Surf.FirstVParameter(); }
+HLRBRep_BSurfaceTool::FirstVParameter(const Handle(BRepAdaptor_Surface)& Surf)
+{ return Surf->FirstVParameter(); }
//=======================================================================
//function : LastUParameter
//=======================================================================
inline Standard_Real
-HLRBRep_BSurfaceTool::LastUParameter(const BRepAdaptor_Surface& Surf)
-{ return Surf.LastUParameter(); }
+HLRBRep_BSurfaceTool::LastUParameter(const Handle(BRepAdaptor_Surface)& Surf)
+{ return Surf->LastUParameter(); }
//=======================================================================
//function : LastVParameter
//=======================================================================
inline Standard_Real
-HLRBRep_BSurfaceTool::LastVParameter(const BRepAdaptor_Surface& Surf)
-{ return Surf.LastVParameter(); }
+HLRBRep_BSurfaceTool::LastVParameter(const Handle(BRepAdaptor_Surface)& Surf)
+{ return Surf->LastVParameter(); }
//=======================================================================
//function : NbUIntervals
//=======================================================================
inline Standard_Integer
-HLRBRep_BSurfaceTool::NbUIntervals(const BRepAdaptor_Surface& Surf,
+HLRBRep_BSurfaceTool::NbUIntervals(const Handle(BRepAdaptor_Surface)& Surf,
const GeomAbs_Shape S)
-{ return Surf.NbUIntervals(S); }
+{ return Surf->NbUIntervals(S); }
//=======================================================================
//function : NbVIntervals
//=======================================================================
inline Standard_Integer
-HLRBRep_BSurfaceTool::NbVIntervals(const BRepAdaptor_Surface& Surf,
+HLRBRep_BSurfaceTool::NbVIntervals(const Handle(BRepAdaptor_Surface)& Surf,
const GeomAbs_Shape S)
-{ return Surf.NbVIntervals(S); }
+{ return Surf->NbVIntervals(S); }
//=======================================================================
//function : UIntervals
//=======================================================================
inline void
-HLRBRep_BSurfaceTool::UIntervals(const BRepAdaptor_Surface& Surf,
+HLRBRep_BSurfaceTool::UIntervals(const Handle(BRepAdaptor_Surface)& Surf,
TColStd_Array1OfReal& Tab,
const GeomAbs_Shape S)
-{ Surf.UIntervals(Tab,S); }
+{ Surf->UIntervals(Tab,S); }
//=======================================================================
//function : VIntervals
//=======================================================================
inline void
-HLRBRep_BSurfaceTool::VIntervals(const BRepAdaptor_Surface& Surf,
+HLRBRep_BSurfaceTool::VIntervals(const Handle(BRepAdaptor_Surface)& Surf,
TColStd_Array1OfReal& Tab,
const GeomAbs_Shape S)
-{ Surf.VIntervals(Tab,S); }
+{ Surf->VIntervals(Tab,S); }
//=======================================================================
//=======================================================================
inline Handle(Adaptor3d_Surface)
-HLRBRep_BSurfaceTool::UTrim(const BRepAdaptor_Surface& Surf,
+HLRBRep_BSurfaceTool::UTrim(const Handle(BRepAdaptor_Surface)& Surf,
const Standard_Real F,
const Standard_Real L,
const Standard_Real Tol)
-{ return Surf.UTrim(F,L,Tol); }
+{ return Surf->UTrim(F,L,Tol); }
//=======================================================================
//function : VTrim
//=======================================================================
inline Handle(Adaptor3d_Surface)
-HLRBRep_BSurfaceTool::VTrim(const BRepAdaptor_Surface& Surf,
+HLRBRep_BSurfaceTool::VTrim(const Handle(BRepAdaptor_Surface)& Surf,
const Standard_Real F,
const Standard_Real L,
const Standard_Real Tol)
-{ return Surf.VTrim(F,L,Tol); }
+{ return Surf->VTrim(F,L,Tol); }
//=======================================================================
//function : IsUClosed
//=======================================================================
inline Standard_Boolean
-HLRBRep_BSurfaceTool::IsUClosed(const BRepAdaptor_Surface& S)
-{ return S.IsUClosed(); }
+HLRBRep_BSurfaceTool::IsUClosed(const Handle(BRepAdaptor_Surface)& S)
+{ return S->IsUClosed(); }
//=======================================================================
//function : IsVClosed
//=======================================================================
inline Standard_Boolean
-HLRBRep_BSurfaceTool::IsVClosed(const BRepAdaptor_Surface& S)
-{ return S.IsVClosed(); }
+HLRBRep_BSurfaceTool::IsVClosed(const Handle(BRepAdaptor_Surface)& S)
+{ return S->IsVClosed(); }
//=======================================================================
//function : IsUPeriodic
//=======================================================================
inline Standard_Boolean
-HLRBRep_BSurfaceTool::IsUPeriodic(const BRepAdaptor_Surface& S)
-{ return S.IsUPeriodic(); }
+HLRBRep_BSurfaceTool::IsUPeriodic(const Handle(BRepAdaptor_Surface)& S)
+{ return S->IsUPeriodic(); }
//=======================================================================
//function : UPeriod
//=======================================================================
inline Standard_Real
-HLRBRep_BSurfaceTool::UPeriod(const BRepAdaptor_Surface& S)
-{ return S.UPeriod(); }
+HLRBRep_BSurfaceTool::UPeriod(const Handle(BRepAdaptor_Surface)& S)
+{ return S->UPeriod(); }
//=======================================================================
//function : IsVPeriodic
//=======================================================================
inline Standard_Boolean
-HLRBRep_BSurfaceTool::IsVPeriodic(const BRepAdaptor_Surface& S)
-{ return S.IsVPeriodic(); }
+HLRBRep_BSurfaceTool::IsVPeriodic(const Handle(BRepAdaptor_Surface)& S)
+{ return S->IsVPeriodic(); }
//=======================================================================
//function : VPeriod
//=======================================================================
inline Standard_Real
-HLRBRep_BSurfaceTool::VPeriod(const BRepAdaptor_Surface& S)
-{ return S.VPeriod(); }
+HLRBRep_BSurfaceTool::VPeriod(const Handle(BRepAdaptor_Surface)& S)
+{ return S->VPeriod(); }
//=======================================================================
//function : Value
//=======================================================================
inline gp_Pnt
-HLRBRep_BSurfaceTool::Value(const BRepAdaptor_Surface& S,
+HLRBRep_BSurfaceTool::Value(const Handle(BRepAdaptor_Surface)& S,
const Standard_Real U,
const Standard_Real V )
-{ return S.Value(U,V); }
+{ return S->Value(U,V); }
//=======================================================================
//function : D0
//=======================================================================
inline void
-HLRBRep_BSurfaceTool::D0(const BRepAdaptor_Surface& S,
+HLRBRep_BSurfaceTool::D0(const Handle(BRepAdaptor_Surface)& S,
const Standard_Real U,
const Standard_Real V,
gp_Pnt& P)
-{ S.D0(U,V,P); }
+{ S->D0(U,V,P); }
//=======================================================================
//function : D1
//=======================================================================
inline void
-HLRBRep_BSurfaceTool::D1(const BRepAdaptor_Surface& S,
+HLRBRep_BSurfaceTool::D1(const Handle(BRepAdaptor_Surface)& S,
const Standard_Real U,
const Standard_Real V,
gp_Pnt& P,
gp_Vec& D1U,
gp_Vec& D1V)
-{ S.D1(U,V,P,D1U,D1V); }
+{ S->D1(U,V,P,D1U,D1V); }
//=======================================================================
//function : D2
//=======================================================================
inline void
-HLRBRep_BSurfaceTool::D2(const BRepAdaptor_Surface& S,
+HLRBRep_BSurfaceTool::D2(const Handle(BRepAdaptor_Surface)& S,
const Standard_Real U,
const Standard_Real V,
gp_Pnt& P,
gp_Vec& D2U,
gp_Vec& D2V,
gp_Vec& D2UV)
-{ S.D2(U,V,P,D1U,D1V,D2U,D2V,D2UV); }
+{ S->D2(U,V,P,D1U,D1V,D2U,D2V,D2UV); }
//=======================================================================
//function : D3
//=======================================================================
inline void
-HLRBRep_BSurfaceTool::D3(const BRepAdaptor_Surface& S,
+HLRBRep_BSurfaceTool::D3(const Handle(BRepAdaptor_Surface)& S,
const Standard_Real U,
const Standard_Real V,
gp_Pnt& P,
gp_Vec& D3V,
gp_Vec& D3UUV,
gp_Vec& D3UVV)
-{ S.D3(U,V,P,D1U,D1V,D2U,D2V,D2UV,D3U,D3V,D3UUV,D3UVV); }
+{ S->D3(U,V,P,D1U,D1V,D2U,D2V,D2UV,D3U,D3V,D3UUV,D3UVV); }
//=======================================================================
//function : DN
//=======================================================================
inline gp_Vec
-HLRBRep_BSurfaceTool::DN(const BRepAdaptor_Surface& S,
+HLRBRep_BSurfaceTool::DN(const Handle(BRepAdaptor_Surface)& S,
const Standard_Real U,
const Standard_Real V,
const Standard_Integer Nu,
const Standard_Integer Nv)
-{ return S.DN(U,V,Nu,Nv); }
+{ return S->DN(U,V,Nu,Nv); }
//=======================================================================
//function : UResolution
//=======================================================================
inline Standard_Real
-HLRBRep_BSurfaceTool::UResolution(const BRepAdaptor_Surface& S,
+HLRBRep_BSurfaceTool::UResolution(const Handle(BRepAdaptor_Surface)& S,
const Standard_Real R3d)
-{ return S.UResolution(R3d); }
+{ return S->UResolution(R3d); }
//=======================================================================
//function : VResolution
//=======================================================================
inline Standard_Real
-HLRBRep_BSurfaceTool::VResolution(const BRepAdaptor_Surface& S,
+HLRBRep_BSurfaceTool::VResolution(const Handle(BRepAdaptor_Surface)& S,
const Standard_Real R3d)
-{ return S.VResolution(R3d); }
+{ return S->VResolution(R3d); }
//=======================================================================
//function : GetType
//=======================================================================
inline GeomAbs_SurfaceType
-HLRBRep_BSurfaceTool::GetType(const BRepAdaptor_Surface& S )
-{ return S.GetType(); }
+HLRBRep_BSurfaceTool::GetType(const Handle(BRepAdaptor_Surface)& S )
+{ return S->GetType(); }
//=======================================================================
//function : Plane
//=======================================================================
inline gp_Pln
-HLRBRep_BSurfaceTool::Plane(const BRepAdaptor_Surface& S)
-{ return S.Plane(); }
+HLRBRep_BSurfaceTool::Plane(const Handle(BRepAdaptor_Surface)& S)
+{ return S->Plane(); }
//=======================================================================
//function : Cylinder
//=======================================================================
inline gp_Cylinder
-HLRBRep_BSurfaceTool::Cylinder(const BRepAdaptor_Surface& S)
-{ return S.Cylinder(); }
+HLRBRep_BSurfaceTool::Cylinder(const Handle(BRepAdaptor_Surface)& S)
+{ return S->Cylinder(); }
//=======================================================================
//function : Cone
//=======================================================================
inline gp_Cone
-HLRBRep_BSurfaceTool::Cone(const BRepAdaptor_Surface& S)
-{ return S.Cone(); }
+HLRBRep_BSurfaceTool::Cone(const Handle(BRepAdaptor_Surface)& S)
+{ return S->Cone(); }
//=======================================================================
//function : Sphere
//=======================================================================
inline gp_Sphere
-HLRBRep_BSurfaceTool::Sphere(const BRepAdaptor_Surface& S)
-{ return S.Sphere(); }
+HLRBRep_BSurfaceTool::Sphere(const Handle(BRepAdaptor_Surface)& S)
+{ return S->Sphere(); }
//=======================================================================
//function : Torus
//=======================================================================
inline gp_Torus
-HLRBRep_BSurfaceTool::Torus(const BRepAdaptor_Surface& S)
-{ return S.Torus(); }
+HLRBRep_BSurfaceTool::Torus(const Handle(BRepAdaptor_Surface)& S)
+{ return S->Torus(); }
//=======================================================================
//function : Bezier
//=======================================================================
inline Handle(Geom_BezierSurface)
- HLRBRep_BSurfaceTool::Bezier(const BRepAdaptor_Surface& S)
-{ return(S.Bezier()); }
+ HLRBRep_BSurfaceTool::Bezier(const Handle(BRepAdaptor_Surface)& S)
+{ return(S->Bezier()); }
//=======================================================================
//function : BSpline
//=======================================================================
inline Handle(Geom_BSplineSurface)
- HLRBRep_BSurfaceTool::BSpline(const BRepAdaptor_Surface& S)
-{ return(S.BSpline()); }
+ HLRBRep_BSurfaceTool::BSpline(const Handle(BRepAdaptor_Surface)& S)
+{ return(S->BSpline()); }
//=======================================================================
//function : AxeOfRevolution
//=======================================================================
inline gp_Ax1
-HLRBRep_BSurfaceTool::AxeOfRevolution(const BRepAdaptor_Surface& S)
-{ return(S.AxeOfRevolution()); }
+HLRBRep_BSurfaceTool::AxeOfRevolution(const Handle(BRepAdaptor_Surface)& S)
+{ return(S->AxeOfRevolution()); }
//=======================================================================
//function : Direction
//=======================================================================
inline gp_Dir
-HLRBRep_BSurfaceTool::Direction(const BRepAdaptor_Surface& S)
-{ return(S.Direction()); }
+HLRBRep_BSurfaceTool::Direction(const Handle(BRepAdaptor_Surface)& S)
+{ return(S->Direction()); }
//=======================================================================
//function : BasisCurve
//=======================================================================
inline Handle(Adaptor3d_Curve)
- HLRBRep_BSurfaceTool::BasisCurve(const BRepAdaptor_Surface& S)
-{ return(S.BasisCurve()); }
+ HLRBRep_BSurfaceTool::BasisCurve(const Handle(BRepAdaptor_Surface)& S)
+{ return(S->BasisCurve()); }
//=======================================================================
//function : UContinuity
//=======================================================================
inline GeomAbs_Shape
-HLRBRep_BSurfaceTool::UContinuity(const BRepAdaptor_Surface& S)
-{ return(S.UContinuity()); }
+HLRBRep_BSurfaceTool::UContinuity(const Handle(BRepAdaptor_Surface)& S)
+{ return(S->UContinuity()); }
//=======================================================================
//function : VContinuity
//=======================================================================
inline GeomAbs_Shape
-HLRBRep_BSurfaceTool::VContinuity(const BRepAdaptor_Surface& S)
-{ return(S.VContinuity()); }
+HLRBRep_BSurfaceTool::VContinuity(const Handle(BRepAdaptor_Surface)& S)
+{ return(S->VContinuity()); }
//=======================================================================
//function : UDegree
//=======================================================================
inline Standard_Integer
-HLRBRep_BSurfaceTool::UDegree(const BRepAdaptor_Surface& S)
-{ return(S.UDegree()); }
+HLRBRep_BSurfaceTool::UDegree(const Handle(BRepAdaptor_Surface)& S)
+{ return(S->UDegree()); }
//=======================================================================
//function : NbUPoles
//=======================================================================
inline Standard_Integer
-HLRBRep_BSurfaceTool::NbUPoles(const BRepAdaptor_Surface& S)
-{ return(S.NbUPoles()); }
+HLRBRep_BSurfaceTool::NbUPoles(const Handle(BRepAdaptor_Surface)& S)
+{ return(S->NbUPoles()); }
//=======================================================================
//function : NbUKnots
//=======================================================================
inline Standard_Integer
-HLRBRep_BSurfaceTool::NbUKnots(const BRepAdaptor_Surface& S)
-{ return(S.NbUKnots()); }
+HLRBRep_BSurfaceTool::NbUKnots(const Handle(BRepAdaptor_Surface)& S)
+{ return(S->NbUKnots()); }
//=======================================================================
//function : IsURational
//=======================================================================
inline Standard_Boolean
-HLRBRep_BSurfaceTool::IsURational(const BRepAdaptor_Surface& S)
-{ return(S.IsURational()); }
+HLRBRep_BSurfaceTool::IsURational(const Handle(BRepAdaptor_Surface)& S)
+{ return(S->IsURational()); }
//=======================================================================
//function : VDegree
//=======================================================================
inline Standard_Integer
-HLRBRep_BSurfaceTool::VDegree(const BRepAdaptor_Surface& S)
-{ return(S.VDegree()); }
+HLRBRep_BSurfaceTool::VDegree(const Handle(BRepAdaptor_Surface)& S)
+{ return(S->VDegree()); }
//=======================================================================
//function : NbVPoles
//=======================================================================
inline Standard_Integer
-HLRBRep_BSurfaceTool::NbVPoles(const BRepAdaptor_Surface& S)
-{ return(S.NbVPoles()); }
+HLRBRep_BSurfaceTool::NbVPoles(const Handle(BRepAdaptor_Surface)& S)
+{ return(S->NbVPoles()); }
//=======================================================================
//function : NbVKnots
//=======================================================================
inline Standard_Integer
-HLRBRep_BSurfaceTool::NbVKnots(const BRepAdaptor_Surface& S)
-{ return(S.NbVKnots()); }
+HLRBRep_BSurfaceTool::NbVKnots(const Handle(BRepAdaptor_Surface)& S)
+{ return(S->NbVKnots()); }
//=======================================================================
//function : IsVRational
//=======================================================================
inline Standard_Boolean
-HLRBRep_BSurfaceTool::IsVRational(const BRepAdaptor_Surface& S)
-{ return(S.IsVRational()); }
+HLRBRep_BSurfaceTool::IsVRational(const Handle(BRepAdaptor_Surface)& S)
+{ return(S->IsVRational()); }
//purpose :
//=======================================================================
HLRBRep_Curve::HLRBRep_Curve ()
-{}
+{
+ myCurve = new BRepAdaptor_Curve();
+}
//=======================================================================
//function : Curve
//=======================================================================
void HLRBRep_Curve::Curve (const TopoDS_Edge& E)
-{ myCurve.Initialize(E); }
+{ myCurve->Initialize(E); }
//=======================================================================
//function : Parameter2d
void Projector (const HLRAlgo_Projector* Proj)
{myProj = Proj;}
- //! Returns the 3D curve.
- BRepAdaptor_Curve& Curve();
-
//! Sets the 3D curve to be projected.
Standard_EXPORT void Curve (const TopoDS_Edge& E);
//! Returns the 3D curve.
- const BRepAdaptor_Curve& GetCurve() const;
+ const Handle(BRepAdaptor_Curve)& Curve() const;
//! Returns the parameter on the 2d curve from the
//! parameter on the 3d curve.
- BRepAdaptor_Curve myCurve;
+ Handle(BRepAdaptor_Curve) myCurve;
GeomAbs_CurveType myType;
const HLRAlgo_Projector* myProj;
Standard_Real myOX;
#include <gp_Parab2d.hxx>
#include <HLRBRep_BCurveTool.hxx>
-//=======================================================================
-//function : Curve
-//purpose :
-//=======================================================================
-
-inline BRepAdaptor_Curve& HLRBRep_Curve::Curve()
-{ return myCurve; }
-
//=======================================================================
//function : GetCurve
//purpose :
//=======================================================================
-inline const BRepAdaptor_Curve& HLRBRep_Curve::GetCurve() const
+inline const Handle(BRepAdaptor_Curve)& HLRBRep_Curve::Curve() const
{ return myCurve; }
//=======================================================================
else if(typC == GeomAbs_BezierCurve)
nbs = 3 + ((HLRBRep_Curve *)C)->NbPoles();
else if(typC == GeomAbs_BSplineCurve) {
- Handle(Geom_Curve) aCurve = ((HLRBRep_Curve *)C)->Curve().Curve().Curve();
+ Handle(Geom_Curve) aCurve = ((HLRBRep_Curve *)C)->Curve()->Curve()->Curve();
GeomAdaptor_Curve GAcurve(aCurve, u1, u2);
nbs = GAcurve.NbIntervals(GeomAbs_CN) + 1;
nbs*= ((HLRBRep_Curve *)C)->Degree();
HLRBRep_Surface *p1 = (HLRBRep_Surface*)iFaceGeom;
- const BRepAdaptor_Surface& bras=p1->Surface();
+ const Handle(BRepAdaptor_Surface)& bras=p1->Surface();
- const TopoDS_Face& topodsface=bras.Face();
+ const TopoDS_Face& topodsface=bras->Face();
CutAtSta(Cut1);
CutAtEnd(Cut2);
Status().Initialize
- (Start,(Standard_ShortReal)(ChangeGeometry().Curve().Resolution
+ (Start,(Standard_ShortReal)(ChangeGeometry().Curve()->Resolution
((Standard_Real)TolStart)),
- End ,(Standard_ShortReal)(ChangeGeometry().Curve().Resolution
+ End ,(Standard_ShortReal)(ChangeGeometry().Curve()->Resolution
((Standard_Real)TolEnd )));
}
{
Standard_Real pfbid,plbid;
if (BRep_Tool::CurveOnSurface
- (((HLRBRep_Curve *)E)->Curve().Edge(),
- ((HLRBRep_Surface*)F)->Surface().Face(),pfbid,plbid).IsNull())
+ (((HLRBRep_Curve *)E)->Curve()->Edge(),
+ ((HLRBRep_Surface*)F)->Surface()->Face(),pfbid,plbid).IsNull())
{
BRepExtrema_ExtPF proj
(BRepLib_MakeVertex(((HLRBRep_Curve*)E)->Value3D(Par)),
- ((HLRBRep_Surface*)F)->Surface().Face());
+ ((HLRBRep_Surface*)F)->Surface()->Face());
Standard_Integer i, index = 0;
Standard_Real dist2 = RealLast();
const Standard_Integer n = proj.NbExt();
}
else {
BRepAdaptor_Curve2d PC
- (((HLRBRep_Curve *)E)->Curve().Edge(),
- ((HLRBRep_Surface*)F)->Surface().Face());
+ (((HLRBRep_Curve *)E)->Curve()->Edge(),
+ ((HLRBRep_Surface*)F)->Surface()->Face());
gp_Pnt2d P2d;
PC.D0(Par,P2d);
U = P2d.X();
#include <HLRBRep_EdgeData.hxx>
#include <HLRBRep_Intersector.hxx>
#include <HLRBRep_SurfaceTool.hxx>
+#include <HLRBRep_Surface.hxx>
#include <HLRBRep_ThePolygonOfInterCSurf.hxx>
#include <HLRBRep_ThePolyhedronOfInterCSurf.hxx>
#include <IntCurveSurface_IntersectionPoint.hxx>
const Standard_Real P)
{
myTypePerform = 2;
- GeomAbs_SurfaceType typ = HLRBRep_SurfaceTool::GetType(mySurface);
+ HLRBRep_Surface* aHLRSur = (HLRBRep_Surface*)mySurface;
+ Standard_Address anAdaptorAddress = aHLRSur->Surface().get();
+ GeomAbs_SurfaceType typ = HLRBRep_SurfaceTool::GetType(anAdaptorAddress);
switch (typ) {
case GeomAbs_Plane :
case GeomAbs_Cylinder :
case GeomAbs_Cone :
case GeomAbs_Sphere :
case GeomAbs_Torus :
- myCSIntersector.Perform(L,mySurface);
+ myCSIntersector.Perform(L, anAdaptorAddress);
break;
default :
{
if (myPolyhedron == NULL) {
Standard_Integer nbsu,nbsv;
Standard_Real u1,v1,u2,v2;
- u1 = HLRBRep_SurfaceTool::FirstUParameter(mySurface);
- v1 = HLRBRep_SurfaceTool::FirstVParameter(mySurface);
- u2 = HLRBRep_SurfaceTool::LastUParameter(mySurface);
- v2 = HLRBRep_SurfaceTool::LastVParameter(mySurface);
- nbsu = HLRBRep_SurfaceTool::NbSamplesU(mySurface,u1,u2);
- nbsv = HLRBRep_SurfaceTool::NbSamplesV(mySurface,v1,v2);
+ u1 = HLRBRep_SurfaceTool::FirstUParameter(anAdaptorAddress);
+ v1 = HLRBRep_SurfaceTool::FirstVParameter(anAdaptorAddress);
+ u2 = HLRBRep_SurfaceTool::LastUParameter(anAdaptorAddress);
+ v2 = HLRBRep_SurfaceTool::LastVParameter(anAdaptorAddress);
+ nbsu = HLRBRep_SurfaceTool::NbSamplesU(anAdaptorAddress,u1,u2);
+ nbsv = HLRBRep_SurfaceTool::NbSamplesV(anAdaptorAddress,v1,v2);
myPolyhedron =
- new HLRBRep_ThePolyhedronOfInterCSurf(mySurface,nbsu,nbsv,u1,v1,u2,v2);
+ new HLRBRep_ThePolyhedronOfInterCSurf(anAdaptorAddress,nbsu,nbsv,u1,v1,u2,v2);
}
Standard_Real x0,y0,z0,x1,y1,z1,pmin,pmax;//,pp;
myPolyhedron->Bounding().Get(x0,y0,z0,x1,y1,z1);
if(pmax>P) pmax=P+0.0000001;
}
HLRBRep_ThePolygonOfInterCSurf Polygon(L,pmin,pmax,3);
- myCSIntersector.Perform(L,Polygon,mySurface,
+ myCSIntersector.Perform(L,Polygon, anAdaptorAddress,
*((HLRBRep_ThePolyhedronOfInterCSurf*)
myPolyhedron));
//purpose :
//=======================================================================
HLRBRep_Surface::HLRBRep_Surface ()
-: myType(GeomAbs_OtherSurface),
+: mySurf(new BRepAdaptor_Surface()),
+ myType(GeomAbs_OtherSurface),
myProj(NULL)
{
}
void HLRBRep_Surface::Surface (const TopoDS_Face& F)
{
//mySurf.Initialize(F,Standard_False);
- mySurf.Initialize(F,Standard_True);
+ mySurf->Initialize(F,Standard_True);
GeomAbs_SurfaceType typ = HLRBRep_BSurfaceTool::GetType(mySurf);
switch (typ) {
}
//! Returns the 3D Surface.
- BRepAdaptor_Surface& Surface();
+ const Handle(BRepAdaptor_Surface)& Surface();
//! Sets the 3D Surface to be projected.
Standard_EXPORT void Surface (const TopoDS_Face& F);
Standard_EXPORT Standard_Boolean SideRowsOfPoles (const Standard_Real tol, const Standard_Integer nbuPoles, const Standard_Integer nbvPoles, TColgp_Array2OfPnt& Pnt) const;
- BRepAdaptor_Surface mySurf;
+ Handle(BRepAdaptor_Surface) mySurf;
GeomAbs_SurfaceType myType;
const HLRAlgo_Projector* myProj;
//purpose :
//=======================================================================
-inline BRepAdaptor_Surface & HLRBRep_Surface::Surface()
+inline const Handle(BRepAdaptor_Surface)& HLRBRep_Surface::Surface()
{ return mySurf; }
//=======================================================================
else {
Handle (Geom2d_TrimmedCurve) TPC =
new Geom2d_TrimmedCurve (PC, U1, U2);
- Geom2dAdaptor_Curve aGAC (TPC);
+ Handle(Geom2dAdaptor_Curve) aGAC = new Geom2dAdaptor_Curve(TPC);
IndE = Hatcher.AddElement (aGAC, newE.Orientation());
}
SH(IndE) = newE;
else {
Handle (Geom2d_TrimmedCurve) TPC =
new Geom2d_TrimmedCurve (PC, U1, U2);
- Geom2dAdaptor_Curve aGAC (TPC);
+ Handle(Geom2dAdaptor_Curve) aGAC = new Geom2dAdaptor_Curve(TPC);
IndE = Hatcher.AddElement (aGAC, TopAbs_INTERNAL);
}
SH(IndE) = newE;
gp_Pnt2d Ori (UPrm, 0.);
Handle (Geom2d_Line) IsoLine = new Geom2d_Line (Ori, Dir);
- Geom2dAdaptor_Curve aGAC (IsoLine);
+ Handle(Geom2dAdaptor_Curve) aGAC = new Geom2dAdaptor_Curve(IsoLine);
Standard_Integer IndH = Hatcher.AddHatching (aGAC);
Hatcher.Trim (IndH);
if (Hatcher.TrimDone (IndH) && !Hatcher.TrimFailed (IndH))
gp_Pnt2d Ori (0., VPrm);
Handle (Geom2d_Line) IsoLine = new Geom2d_Line (Ori, Dir);
- Geom2dAdaptor_Curve aGAC (IsoLine);
+ Handle(Geom2dAdaptor_Curve) aGAC = new Geom2dAdaptor_Curve(IsoLine);
Standard_Integer IndH = Hatcher.AddHatching (aGAC);
Hatcher.Trim (IndH);
if (Hatcher.TrimDone (IndH) && !Hatcher.TrimFailed (IndH))
TopExp::Vertices(aE, aV1, aV2);
if((V1.IsSame(aV1) && V2.IsSame(aV2)) || (V1.IsSame(aV2) && V2.IsSame(aV1))) {
- BRepAdaptor_Curve aC(aE);
+ Handle(BRepAdaptor_Curve) aC = new BRepAdaptor_Curve(aE);
if((C.GetType() == GeomAbs_Line) &&
- (aC.GetType() == GeomAbs_Line)) {
+ (aC->GetType() == GeomAbs_Line)) {
SameEdge = Standard_True;
break;
}
if (!Curve.IsNull()) {
ent = GC.TransferCurve(Curve,Curve->FirstParameter(),Curve->LastParameter());
- BndLib_Add3dCurve::Add (GeomAdaptor_Curve (Curve), 0, box); }
+ BndLib_Add3dCurve::Add (new GeomAdaptor_Curve (Curve), 0, box); }
else if (!Surf.IsNull()) {
Standard_Real U1,U2,V1,V2;
Surf->Bounds(U1,U2,V1,V2);
ent = GS.TransferSurface(Surf,U1,U2,V1,V2);
- BndLib_AddSurface::Add (GeomAdaptor_Surface (Surf), 0, box);
+ BndLib_AddSurface::Add (new GeomAdaptor_Surface (Surf), 0, box);
}
Standard_Real aXmin, aYmin, aZmin, aXmax, aYmax, aZmax;
#define No_Standard_OutOfRange
#endif
-#define SURF (*((ThePSurface *)(surf)))
+#define SURF ((ThePSurface::element_type*)(surf))
#define FUNC (*((TheISurface *)(func)))
tgdv(0.0),
derived(Standard_False)
{
- surf = (Standard_Address)(&PS);
+ surf = (Standard_Address)(PS.get());
func = (Standard_Address)(&IS);
}
inline void IntImp_ZerImpFunc::Set (const ThePSurface& PS)
{
- surf = (Standard_Address)(&PS);
+ surf = (Standard_Address)(PS.get());
}
inline void IntImp_ZerImpFunc::SetImplicitSurface (const TheISurface& IS)
return d2d;
}
-inline const ThePSurface& IntImp_ZerImpFunc::PSurface() const
+inline const ThePSurface IntImp_ZerImpFunc::PSurface() const
{
- return (*((ThePSurface *)(surf)));
+ return (ThePSurface::element_type*)(surf);
}
inline const TheISurface& IntImp_ZerImpFunc::ISurface() const
#include <Standard_ConstructionError.hxx>
#include <Precision.hxx>
-#define SURF1 (*((ThePSurface *)(surf1)))
-#define SURF2 (*((ThePSurface *)(surf2)))
+#define SURF1 ((ThePSurface::element_type*)(surf1))
+#define SURF2 ((ThePSurface::element_type*)(surf2))
IntImp_ZerParFunc::IntImp_ZerParFunc(const ThePSurface& S1 ,
tangent(Standard_False),
paramConst(0.0)
{
- surf1 = (Standard_Address)(&S1);
- surf2 = (Standard_Address)(&S2);
+ surf1 = (Standard_Address)(S1.get());
+ surf2 = (Standard_Address)(S2.get());
ua0 = ThePSurfaceTool::FirstUParameter(SURF1); //-- ThePSurfaceTool::UIntervalFirst(surf1);
va0 = ThePSurfaceTool::FirstVParameter(SURF1); //-- ThePSurfaceTool::VIntervalFirst(surf1);
return gp_Dir2d(tgduv[2],tgduv[3]);
}
-inline const ThePSurface& IntImp_ZerParFunc::AuxillarSurface1() const {
- return *((const ThePSurface* )surf1);
+inline const ThePSurface IntImp_ZerParFunc::AuxillarSurface1() const {
+ return ((ThePSurface::element_type*)(surf1));
}
-inline const ThePSurface& IntImp_ZerParFunc::AuxillarSurface2() const {
- return *((const ThePSurface* )surf2);
+inline const ThePSurface IntImp_ZerParFunc::AuxillarSurface2() const {
+ return ((ThePSurface::element_type*)(surf2));
}
Standard_Real Tol = 1.e-5;
Standard_Real Dist2;
- Extrema_EPCOfExtPC2d extrema(P,*C,Nbu,epsX,Tol);
+ Extrema_EPCOfExtPC2d extrema(P,C,Nbu,epsX,Tol);
if (!extrema.IsDone()) {
return Standard_False;
}
return Standard_False;
Extrema_ExtPC anExtr;
- GeomAdaptor_Curve anAC;
+ Handle(GeomAdaptor_Curve) anAC = new GeomAdaptor_Curve();
Handle(Geom_Curve) aCurv;
if(aGType == IntPatch_Ellipse)
{
const Standard_Real anUinf = aCurv->FirstParameter(),
anUsup = aCurv->LastParameter();
- anAC.Load(aCurv, anUinf, anUsup);
+ anAC->Load(aCurv, anUinf, anUsup);
anExtr.Initialize(anAC, anUinf, anUsup);
}
ProjLib_ProjectedCurve aProjectedCurve(aGAHsurf, aProjCurve);
Handle(Geom2d_Curve) aPCurve;
ProjLib::MakePCurveOfType(aProjectedCurve, aPCurve);
- Geom2dAdaptor_Curve AC(aPCurve,
- aProjectedCurve.FirstParameter(),
- aProjectedCurve.LastParameter());
+ Handle(Geom2dAdaptor_Curve) AC = new Geom2dAdaptor_Curve(aPCurve,
+ aProjectedCurve.FirstParameter(),
+ aProjectedCurve.LastParameter());
Geom2dInt_GInter Intersector(AC,
Precision::Confusion(),
Precision::Confusion());
Handle(Adaptor3d_Surface)& TrimS)
{
Standard_Real TP = AlternativeTrimPrm;
- Extrema_ExtPS ext1(Pmin, *InfSurf, 1.e-7, 1.e-7);
- Extrema_ExtPS ext2(Pmax, *InfSurf, 1.e-7, 1.e-7);
+ Extrema_ExtPS ext1(Pmin, InfSurf, 1.e-7, 1.e-7);
+ Extrema_ExtPS ext2(Pmax, InfSurf, 1.e-7, 1.e-7);
if(ext1.IsDone() || ext2.IsDone())
{
Standard_Real Umax = -1.e+100, Umin = 1.e+100, Vmax = -1.e+100, Vmin = 1.e+100, cU, cV;
aPmid /= aNb;
aPP1.SetXYZ(aPmid);
Standard_Real aTolU = Precision::PConfusion(), aTolV = Precision::PConfusion();
- Extrema_ExtPS aProj(aPP1, *theS2.get(), aTolU, aTolV, Extrema_ExtFlag_MIN);
+ Extrema_ExtPS aProj(aPP1, theS2, aTolU, aTolV, Extrema_ExtFlag_MIN);
if (aProj.IsDone())
{
u = (u+u1)*0.5;
v = (v+v1)*0.5;
}
- const Adaptor2d_Curve2d& C2d = *arc;
gp_Pnt2d PObt,P2d(u,v);
- Standard_Real par= Geom2dInt_TheProjPCurOfGInter::FindParameter(C2d,P2d,1e-7);
- PObt=C2d.Value(par);
+ Standard_Real par= Geom2dInt_TheProjPCurOfGInter::FindParameter(arc,P2d,1e-7);
+ PObt=arc->Value(par);
if(PObt.Distance(P2d) < tol2d) {
return Standard_True;
}
gp_Vec ad1u, ad1v;
surf->D1(u,v,aPbid,ad1u,ad1v);
Standard_Real tol2d = ComputeParametricTolerance(TolArc,ad1u,ad1v);
- const Adaptor2d_Curve2d& C2d = *arc;
gp_Pnt2d aP(u,v),aPprj;
- par=Geom2dInt_TheProjPCurOfGInter::FindParameter(C2d,aP,1e-7);
- aPprj=C2d.Value(par);
+ par=Geom2dInt_TheProjPCurOfGInter::FindParameter(arc,aP,1e-7);
+ aPprj=arc->Value(par);
dist = aPprj.Distance(aP);
return dist <= tol2d;
}
case GeomAbs_SurfaceOfExtrusion:
case GeomAbs_SurfaceOfRevolution:
{
- Extrema_ExtPS anExtr(thePt, *theSurf, theSurf->UResolution(theTol),
+ Extrema_ExtPS anExtr(thePt, theSurf, theSurf->UResolution(theTol),
theSurf->VResolution(theTol), Extrema_ExtFlag_MIN);
if(!anExtr.IsDone() || (anExtr.NbExt() < 1))
{
break;
default:
{
- Extrema_GenLocateExtPS anExtr (*theSurf);
+ Extrema_GenLocateExtPS anExtr (theSurf);
anExtr.Perform(thePt, theUpar, theVpar);
if(!anExtr.IsDone() || (anExtr.SquareDistance() > theTol*theTol))
{
theQSurf->D0(aUquad, aVquad, aPQuad);
- Extrema_GenLocateExtPS anExtr (*thePSurf);
+ Extrema_GenLocateExtPS anExtr (thePSurf);
anExtr.Perform(aPQuad, aU0, aV0);
if(!anExtr.IsDone())
const gp_Dir2d& Direction2d();
- const Handle(Adaptor3d_Surface)& PSurface() const;
+ const Handle(Adaptor3d_Surface) PSurface() const;
const IntSurf_Quadric& ISurface() const;
U2f = aCEdge->FirstParameter();
U2l = aCEdge->LastParameter();
-
- GeomAdaptor_Curve C1, C2;
-
- C1.Load(aCAxis);
- C2.Load(aCEdge);
+ Handle(GeomAdaptor_Curve) C1 = new GeomAdaptor_Curve(aCAxis);
+ Handle(GeomAdaptor_Curve) C2 = new GeomAdaptor_Curve(aCEdge);
Tol = Precision::PConfusion();
//function : IntTools::GetRadius
//purpose :
//=======================================================================
- Standard_Integer IntTools::GetRadius(const BRepAdaptor_Curve& C,
+ Standard_Integer IntTools::GetRadius(const Handle(BRepAdaptor_Curve)& C,
const Standard_Real t1,
const Standard_Real t3,
Standard_Real& aR)
{
- GeomAbs_CurveType aType=C.GetType();
+ GeomAbs_CurveType aType=C->GetType();
if (aType==GeomAbs_Line) {
return 1;
}
if (aType==GeomAbs_Circle) {
- gp_Circ aCrc=C.Circle();
+ gp_Circ aCrc=C->Circle();
aR=aCrc.Radius();
return 0;
}
t2=0.5*(t1+t3);
- P1=C.Value(t1);
- P2=C.Value(t2);
- P3=C.Value(t3);
+ P1=C->Value(t1);
+ P2=C->Value(t2);
+ P3=C->Value(t3);
//
//
gce_MakeCirc aMakeCirc(P1, P2, P3);
//function : PrepareArgs
//purpose :
//=======================================================================
-Standard_Integer IntTools::PrepareArgs (BRepAdaptor_Curve& C,
+Standard_Integer IntTools::PrepareArgs (const Handle(BRepAdaptor_Curve)& C,
const Standard_Real Tmax,
const Standard_Real Tmin,
const Standard_Integer Discret,
Standard_Boolean aRFlag;
GeomAbs_CurveType aCurveType;
- aCurveType=C.GetType();
+ aCurveType=C->GetType();
dt=(Tmax-Tmin)/Discret;
aRFlag=(dt > 1.e-5);
Standard_EXPORT static Standard_Integer Parameter (const gp_Pnt& P, const Handle(Geom_Curve)& Curve, Standard_Real& aParm);
- Standard_EXPORT static Standard_Integer GetRadius (const BRepAdaptor_Curve& C, const Standard_Real t1, const Standard_Real t3, Standard_Real& R);
+ Standard_EXPORT static Standard_Integer GetRadius (const Handle(BRepAdaptor_Curve)& C, const Standard_Real t1, const Standard_Real t3, Standard_Real& R);
- Standard_EXPORT static Standard_Integer PrepareArgs (BRepAdaptor_Curve& C,
+ Standard_EXPORT static Standard_Integer PrepareArgs (const Handle(BRepAdaptor_Curve)& C,
const Standard_Real tMax, const Standard_Real tMin,
const Standard_Integer Discret, const Standard_Real Deflect,
TColStd_Array1OfReal& anArgs);
// function: IntTools_BeanFaceIntersector
// purpose:
// ==================================================================================
-IntTools_BeanFaceIntersector::IntTools_BeanFaceIntersector(const BRepAdaptor_Curve& theCurve,
- const BRepAdaptor_Surface& theSurface,
+IntTools_BeanFaceIntersector::IntTools_BeanFaceIntersector(const Handle(BRepAdaptor_Curve)& theCurve,
+ const Handle(BRepAdaptor_Surface)& theSurface,
const Standard_Real theBeanTolerance,
const Standard_Real theFaceTolerance) :
myFirstParameter(0.),
// function: IntTools_BeanFaceIntersector
// purpose:
// ==================================================================================
-IntTools_BeanFaceIntersector::IntTools_BeanFaceIntersector(const BRepAdaptor_Curve& theCurve,
- const BRepAdaptor_Surface& theSurface,
+IntTools_BeanFaceIntersector::IntTools_BeanFaceIntersector(const Handle(BRepAdaptor_Curve)& theCurve,
+ const Handle(BRepAdaptor_Surface)& theSurface,
const Standard_Real theFirstParOnCurve,
const Standard_Real theLastParOnCurve,
const Standard_Real theUMinParameter,
myCurve = theCurve;
myCriteria = myBeanTolerance + myFaceTolerance;
- myCurveResolution = myCurve.Resolution(myCriteria);
+ myCurveResolution = myCurve->Resolution(myCriteria);
mySurface = theSurface;
- myTrsfSurface = Handle(Geom_Surface)::DownCast(mySurface.Surface().Surface()->Transformed(mySurface.Trsf()));
+ myTrsfSurface = Handle(Geom_Surface)::DownCast(mySurface->Surface()->Surface()->Transformed(mySurface->Trsf()));
}
// ==================================================================================
if (myContext.IsNull()) {
myContext = new IntTools_Context;
}
+ if (myCurve.IsNull()) {
+ myCurve = new BRepAdaptor_Curve;
+ }
+ if (mySurface.IsNull()) {
+ mySurface = new BRepAdaptor_Surface;
+ }
+
//
- myCurve.Initialize(theEdge);
+ myCurve->Initialize(theEdge);
mySurface = myContext->SurfaceAdaptor(theFace);
- myTrsfSurface = Handle(Geom_Surface)::DownCast(mySurface.Surface().Surface()->Transformed(mySurface.Trsf()));
+ myTrsfSurface = Handle(Geom_Surface)::DownCast(mySurface->Surface()->Surface()->Transformed(mySurface->Trsf()));
myBeanTolerance = BRep_Tool::Tolerance(theEdge);
myFaceTolerance = BRep_Tool::Tolerance(theFace);
myCriteria = myBeanTolerance + myFaceTolerance + Precision::Confusion();
- myCurveResolution = myCurve.Resolution(myCriteria);
+ myCurveResolution = myCurve->Resolution(myCriteria);
- SetSurfaceParameters(mySurface.FirstUParameter(), mySurface.LastUParameter(),
- mySurface.FirstVParameter(), mySurface.LastVParameter());
+ SetSurfaceParameters(mySurface->FirstUParameter(), mySurface->LastUParameter(),
+ mySurface->FirstVParameter(), mySurface->LastVParameter());
myResults.Clear();
}
// function: Init
// purpose:
// ==================================================================================
-void IntTools_BeanFaceIntersector::Init(const BRepAdaptor_Curve& theCurve,
- const BRepAdaptor_Surface& theSurface,
+void IntTools_BeanFaceIntersector::Init(const Handle(BRepAdaptor_Curve)& theCurve,
+ const Handle(BRepAdaptor_Surface)& theSurface,
const Standard_Real theBeanTolerance,
const Standard_Real theFaceTolerance)
{
myCurve = theCurve;
mySurface = theSurface;
- myTrsfSurface = Handle(Geom_Surface)::DownCast(mySurface.Surface().Surface()->Transformed(mySurface.Trsf()));
+ myTrsfSurface = Handle(Geom_Surface)::DownCast(mySurface->Surface()->Surface()->Transformed(mySurface->Trsf()));
myBeanTolerance = theBeanTolerance;
myFaceTolerance = theFaceTolerance;
myCriteria = myBeanTolerance + myFaceTolerance;
- myCurveResolution = myCurve.Resolution(myCriteria);
+ myCurveResolution = myCurve->Resolution(myCriteria);
- SetSurfaceParameters(mySurface.FirstUParameter(), mySurface.LastUParameter(),
- mySurface.FirstVParameter(), mySurface.LastVParameter());
+ SetSurfaceParameters(mySurface->FirstUParameter(), mySurface->LastUParameter(),
+ mySurface->FirstVParameter(), mySurface->LastVParameter());
myResults.Clear();
}
// function: Init
// purpose:
// ==================================================================================
-void IntTools_BeanFaceIntersector::Init(const BRepAdaptor_Curve& theCurve,
- const BRepAdaptor_Surface& theSurface,
+void IntTools_BeanFaceIntersector::Init(const Handle(BRepAdaptor_Curve)& theCurve,
+ const Handle(BRepAdaptor_Surface)& theSurface,
const Standard_Real theFirstParOnCurve,
const Standard_Real theLastParOnCurve,
const Standard_Real theUMinParameter,
}
// Fast computation of Line/Plane case
- if (myCurve.GetType() == GeomAbs_Line &&
- mySurface.GetType() == GeomAbs_Plane)
+ if (myCurve->GetType() == GeomAbs_Line &&
+ mySurface->GetType() == GeomAbs_Plane)
{
ComputeLinePlane();
return;
!Precision::IsInfinite(myUMaxParameter) &&
!Precision::IsInfinite(myVMinParameter) &&
!Precision::IsInfinite(myVMaxParameter));
- bLocalize = bLocalize && (mySurface.GetType() == GeomAbs_BezierSurface ||
- mySurface.GetType() == GeomAbs_OtherSurface ||
- (mySurface.GetType() == GeomAbs_BSplineSurface &&
- (mySurface.UDegree() > 2 || mySurface.VDegree() > 2) &&
- (mySurface.NbUKnots() > 2 && mySurface.NbVKnots() > 2)));
+ bLocalize = bLocalize && (mySurface->GetType() == GeomAbs_BezierSurface ||
+ mySurface->GetType() == GeomAbs_OtherSurface ||
+ (mySurface->GetType() == GeomAbs_BSplineSurface &&
+ (mySurface->UDegree() > 2 || mySurface->VDegree() > 2) &&
+ (mySurface->NbUKnots() > 2 && mySurface->NbVKnots() > 2)));
Standard_Boolean isLocalized = bLocalize && ComputeLocalized();
// ==================================================================================
Standard_Real IntTools_BeanFaceIntersector::Distance(const Standard_Real theArg)
{
- gp_Pnt aPoint = myCurve.Value(theArg);
+ gp_Pnt aPoint = myCurve->Value(theArg);
- GeomAPI_ProjectPointOnSurf& aProjector = myContext->ProjPS(mySurface.Face());
+ GeomAPI_ProjectPointOnSurf& aProjector = myContext->ProjPS(mySurface->Face());
aProjector.Perform(aPoint);
if(aProjector.IsDone() && aProjector.NbPoints() > 0) {
Standard_Real aMinParameter = (i < 2) ? myVMinParameter : myUMinParameter;
Standard_Real aMaxParameter = (i < 2) ? myVMaxParameter : myUMaxParameter;
Standard_Real aMidParameter = (aMinParameter + aMaxParameter) * 0.5;
- gp_Pnt aPointMin = (i < 2) ? mySurface.Value(anIsoParameter, aMinParameter) : mySurface.Value(aMinParameter, anIsoParameter);
- gp_Pnt aPointMax = (i < 2) ? mySurface.Value(anIsoParameter, aMaxParameter) : mySurface.Value(aMaxParameter, anIsoParameter);
- gp_Pnt aPointMid = (i < 2) ? mySurface.Value(anIsoParameter, aMidParameter) : mySurface.Value(aMidParameter, anIsoParameter);
+ gp_Pnt aPointMin = (i < 2) ? mySurface->Value(anIsoParameter, aMinParameter) : mySurface->Value(aMinParameter, anIsoParameter);
+ gp_Pnt aPointMax = (i < 2) ? mySurface->Value(anIsoParameter, aMaxParameter) : mySurface->Value(aMaxParameter, anIsoParameter);
+ gp_Pnt aPointMid = (i < 2) ? mySurface->Value(anIsoParameter, aMidParameter) : mySurface->Value(aMidParameter, anIsoParameter);
Standard_Boolean useMinMaxPoints = Standard_True;
Standard_Boolean computeisoline = Standard_True;
Standard_Real& theUParameter,
Standard_Real& theVParameter)
{
- gp_Pnt aPoint = myCurve.Value(theArg);
+ gp_Pnt aPoint = myCurve->Value(theArg);
theUParameter = myUMinParameter;
theVParameter = myVMinParameter;
Standard_Real aDistance = RealLast();
Standard_Boolean projectionfound = Standard_False;
- GeomAPI_ProjectPointOnSurf& aProjector = myContext->ProjPS(mySurface.Face());
+ GeomAPI_ProjectPointOnSurf& aProjector = myContext->ProjPS(mySurface->Face());
aProjector.Perform(aPoint);
if(aProjector.IsDone() && aProjector.NbPoints() > 0) {
Standard_Real aMinParameter = (i < 2) ? myVMinParameter : myUMinParameter;
Standard_Real aMaxParameter = (i < 2) ? myVMaxParameter : myUMaxParameter;
Standard_Real aMidParameter = (aMinParameter + aMaxParameter) * 0.5;
- gp_Pnt aPointMin = (i < 2) ? mySurface.Value(anIsoParameter, aMinParameter) : mySurface.Value(aMinParameter, anIsoParameter);
- gp_Pnt aPointMax = (i < 2) ? mySurface.Value(anIsoParameter, aMaxParameter) : mySurface.Value(aMaxParameter, anIsoParameter);
- gp_Pnt aPointMid = (i < 2) ? mySurface.Value(anIsoParameter, aMidParameter) : mySurface.Value(aMidParameter, anIsoParameter);
+ gp_Pnt aPointMin = (i < 2) ? mySurface->Value(anIsoParameter, aMinParameter) : mySurface->Value(aMinParameter, anIsoParameter);
+ gp_Pnt aPointMax = (i < 2) ? mySurface->Value(anIsoParameter, aMaxParameter) : mySurface->Value(aMaxParameter, anIsoParameter);
+ gp_Pnt aPointMid = (i < 2) ? mySurface->Value(anIsoParameter, aMidParameter) : mySurface->Value(aMidParameter, anIsoParameter);
Standard_Boolean useMinMaxPoints = Standard_True;
Standard_Boolean computeisoline = Standard_True;
{
IntCurveSurface_HInter anExactIntersector;
- Handle(BRepAdaptor_Curve) aCurve = new BRepAdaptor_Curve(myCurve);
- Handle(BRepAdaptor_Surface) aSurface = new BRepAdaptor_Surface(mySurface);
-
- anExactIntersector.Perform(aCurve, aSurface);
+ anExactIntersector.Perform(myCurve, mySurface);
if (anExactIntersector.IsDone()) {
Standard_Integer i = 0;
// range, perform exact range search considering the lowest possible tolerance
// for edge and face.
myCriteria = 3 * Precision::Confusion();
- myCurveResolution = myCurve.Resolution (myCriteria);
+ myCurveResolution = myCurve->Resolution (myCriteria);
}
for(i = 1; i <= anExactIntersector.NbPoints(); i++) {
bUCorrected = Standard_False;
solutionIsValid = Standard_False;
//
- if(mySurface.IsUPeriodic()) {
+ if(mySurface->IsUPeriodic()) {
Standard_Real aNewU, aUPeriod, aEps, du;
//
- aUPeriod = mySurface.UPeriod();
+ aUPeriod = mySurface->UPeriod();
aEps = Epsilon(aUPeriod);
//
GeomInt::AdjustPeriodic(U, myUMinParameter, myUMaxParameter,
if(bUCorrected && VIsNotValid) {
solutionIsValid = Standard_False;
//
- if(mySurface.IsVPeriodic()) {
+ if(mySurface->IsVPeriodic()) {
Standard_Real aNewV, aVPeriod, aEps, dv;
//
- aVPeriod = mySurface.VPeriod();
+ aVPeriod = mySurface->VPeriod();
aEps = Epsilon(aVPeriod);
//
GeomInt::AdjustPeriodic(V, myVMinParameter, myVMaxParameter,
// ==================================================================================
Standard_Boolean IntTools_BeanFaceIntersector::FastComputeAnalytic()
{
- GeomAbs_CurveType aCT = myCurve.GetType();
+ GeomAbs_CurveType aCT = myCurve->GetType();
if (aCT == GeomAbs_BezierCurve ||
aCT == GeomAbs_BSplineCurve ||
aCT == GeomAbs_OffsetCurve ||
Standard_Boolean isCoincide = Standard_False;
Standard_Boolean hasIntersection = Standard_True;
- GeomAbs_SurfaceType aST = mySurface.GetType();
+ GeomAbs_SurfaceType aST = mySurface->GetType();
// Plane - Circle/Ellipse/Hyperbola/Parabola
if (aST == GeomAbs_Plane)
{
- gp_Pln surfPlane = mySurface.Plane();
+ gp_Pln surfPlane = mySurface->Plane();
gp_Dir aDir;
gp_Pnt aPLoc;
switch (aCT) {
case GeomAbs_Circle:
{
- aDir = myCurve.Circle().Axis().Direction();
- aPLoc = myCurve.Circle().Location();
+ aDir = myCurve->Circle().Axis().Direction();
+ aPLoc = myCurve->Circle().Location();
break;
}
case GeomAbs_Ellipse:
{
- aDir = myCurve.Ellipse().Axis().Direction();
- aPLoc = myCurve.Ellipse().Location();
+ aDir = myCurve->Ellipse().Axis().Direction();
+ aPLoc = myCurve->Ellipse().Location();
break;
}
case GeomAbs_Hyperbola:
{
- aDir = myCurve.Hyperbola().Axis().Direction();
- aPLoc = myCurve.Hyperbola().Location();
+ aDir = myCurve->Hyperbola().Axis().Direction();
+ aPLoc = myCurve->Hyperbola().Location();
break;
}
case GeomAbs_Parabola:
{
- aDir = myCurve.Parabola().Axis().Direction();
- aPLoc = myCurve.Parabola().Location();
+ aDir = myCurve->Parabola().Axis().Direction();
+ aPLoc = myCurve->Parabola().Location();
break;
}
default:
// Cylinder - Line/Circle
else if (aST == GeomAbs_Cylinder)
{
- gp_Cylinder aCylinder = mySurface.Cylinder();
+ gp_Cylinder aCylinder = mySurface->Cylinder();
const gp_Ax1& aCylAxis = aCylinder.Axis();
const gp_Dir& aCylDir = aCylAxis.Direction();
Standard_Real aCylRadius = aCylinder.Radius();
if (aCT == GeomAbs_Line)
{
- gp_Lin aLin = myCurve.Line();
+ gp_Lin aLin = myCurve->Line();
if (!aLin.Direction().IsParallel(aCylDir, Precision::Angular()))
return Standard_False;
else if (aCT == GeomAbs_Circle)
{
- gp_Circ aCircle = myCurve.Circle();
+ gp_Circ aCircle = myCurve->Circle();
Standard_Real anAngle = aCylDir.Angle(aCircle.Axis().Direction());
if (anAngle > Precision::Angular())
// Sphere - Line
else if (aST == GeomAbs_Sphere)
{
- gp_Sphere aSph = mySurface.Sphere();
+ gp_Sphere aSph = mySurface->Sphere();
gp_Pnt aSphLoc = aSph.Location();
if (aCT == GeomAbs_Line)
{
- gp_Lin aLin = myCurve.Line();
+ gp_Lin aLin = myCurve->Line();
Standard_Real aDist = aLin.Distance(aSphLoc) - aSph.Radius();
hasIntersection = aDist < myCriteria;
}
void IntTools_BeanFaceIntersector::ComputeLinePlane()
{
Standard_Real Tolang = 1.e-9;
- gp_Pln P = mySurface.Plane();
- gp_Lin L = myCurve.Line();
+ gp_Pln P = mySurface->Plane();
+ gp_Lin L = myCurve->Line();
myIsDone = Standard_True;
{
Standard_Real Tol, af, al;
Tol = Precision::PConfusion();
- Handle(Geom_Curve) aCurve = BRep_Tool::Curve (myCurve.Edge(), af, al);
- GeomAdaptor_Surface aGASurface (myTrsfSurface,
- myUMinParameter,
- myUMaxParameter,
- myVMinParameter,
- myVMaxParameter);
+ Handle(Geom_Curve) aCurve = BRep_Tool::Curve (myCurve->Edge(), af, al);
+ Handle(GeomAdaptor_Surface) aGASurface = new GeomAdaptor_Surface (myTrsfSurface,
+ myUMinParameter,
+ myUMaxParameter,
+ myVMinParameter,
+ myVMaxParameter);
for(Standard_Integer i = 1; i <= myRangeManager.Length(); i++) {
}
}
- GeomAdaptor_Curve aGACurve(aCurve, anarg1, anarg2);
+ Handle(GeomAdaptor_Curve) aGACurve = new GeomAdaptor_Curve(aCurve, anarg1, anarg2);
Extrema_ExtCS anExtCS;
anExtCS.Initialize(aGASurface, myUMinParameter, myUMaxParameter,
myVMinParameter, myVMaxParameter, Tol, Tol);
Standard_Boolean pointfound = Standard_False;
//
- gp_Pnt aPoint = myCurve.Value(aCurPar);
+ gp_Pnt aPoint = myCurve->Value(aCurPar);
Extrema_GenLocateExtPS anExtrema(mySurface, 1.e-10, 1.e-10);
anExtrema.Perform(aPoint, U, V);
// return close;
// }
-// Standard_Boolean TestCoinside(const BRepAdaptor_Curve& theCurve,
-// const BRepAdaptor_Surface& theSurface)
+// Standard_Boolean TestCoinside(const Handle(BRepAdaptor_Curve)& theCurve,
+// const Handle(BRepAdaptor_Surface)& theSurface)
// {
// Standard_Real cfp = theCurve.FirstParameter(), clp = theCurve.LastParameter();
// Standard_Real cdp = fabs(clp - cfp) / 23.;
if(!theSurfaceData.FindBox(aNewRangeS, aBoxS)) {
- if(mySurface.GetType() == GeomAbs_BSplineSurface) {
+ if(mySurface->GetType() == GeomAbs_BSplineSurface) {
// if(Standard_False ) {
Handle(Geom_BSplineSurface) aSurfBspl = Handle(Geom_BSplineSurface)::DownCast(myTrsfSurface);
aBoxS = GetSurfaceBox(aSurfBspl, aPrevParU, aCurParU, aPrevParV, aCurParV, myCriteria, theSurfaceData);
Standard_Real dMinU = 10. * Precision::PConfusion();
Standard_Real dMinV = dMinU;
IntTools_SurfaceRangeLocalizeData aSurfaceDataInit(3, 3, dMinU, dMinV);
- IntTools_SurfaceRangeLocalizeData& aSurfaceData = myContext->SurfaceData(mySurface.Face());
+ IntTools_SurfaceRangeLocalizeData& aSurfaceData = myContext->SurfaceData(mySurface->Face());
aSurfaceData.RemoveRangeOutAll();
aSurfaceData.ClearGrid();
Bnd_Box FBox;
Standard_Boolean bFBoxFound = aSurfaceData.FindBox(aSurfaceRange, FBox);
- if(mySurface.GetType() == GeomAbs_BSplineSurface) {
+ if(mySurface->GetType() == GeomAbs_BSplineSurface) {
Handle(Geom_BSplineSurface) aSurfBspl = Handle(Geom_BSplineSurface)::DownCast(myTrsfSurface);
ComputeGridPoints(aSurfBspl, myUMinParameter, myUMaxParameter,
Bnd_Box EBox;
- BndLib_Add3dCurve::Add (*myCurve.Trim(myFirstParameter, myLastParameter, Precision::PConfusion()), myBeanTolerance, EBox);
+ BndLib_Add3dCurve::Add (myCurve->Trim(myFirstParameter, myLastParameter, Precision::PConfusion()), myBeanTolerance, EBox);
if(EBox.IsOut(FBox)) {
for(Standard_Integer i = 1; i <= myRangeManager.Length(); i++) {
T = p1.Parameter();
p2.Parameter(U, V);
- if (myCurve.IsPeriodic())
- T = ElCLib::InPeriod(T, anarg1, anarg1 + myCurve.Period());
- if (mySurface.IsUPeriodic())
- U = ElCLib::InPeriod(U, parUF, parUF + mySurface.UPeriod());
- if (mySurface.IsVPeriodic())
- V = ElCLib::InPeriod(V, parVF, parVF + mySurface.VPeriod());
+ if (myCurve->IsPeriodic())
+ T = ElCLib::InPeriod(T, anarg1, anarg1 + myCurve->Period());
+ if (mySurface->IsUPeriodic())
+ U = ElCLib::InPeriod(U, parUF, parUF + mySurface->UPeriod());
+ if (mySurface->IsVPeriodic())
+ V = ElCLib::InPeriod(V, parVF, parVF + mySurface->VPeriod());
//To avoid occasional going out of boundaries because of numerical
//problem
//! Initializes the algorithm
- Standard_EXPORT IntTools_BeanFaceIntersector(const BRepAdaptor_Curve& theCurve, const BRepAdaptor_Surface& theSurface, const Standard_Real theBeanTolerance, const Standard_Real theFaceTolerance);
+ Standard_EXPORT IntTools_BeanFaceIntersector(const Handle(BRepAdaptor_Curve)& theCurve, const Handle(BRepAdaptor_Surface)& theSurface, const Standard_Real theBeanTolerance, const Standard_Real theFaceTolerance);
//! Initializes the algorithm
//! theUMinParameter, ... are used for
//! optimization purposes
- Standard_EXPORT IntTools_BeanFaceIntersector(const BRepAdaptor_Curve& theCurve, const BRepAdaptor_Surface& theSurface, const Standard_Real theFirstParOnCurve, const Standard_Real theLastParOnCurve, const Standard_Real theUMinParameter, const Standard_Real theUMaxParameter, const Standard_Real theVMinParameter, const Standard_Real theVMaxParameter, const Standard_Real theBeanTolerance, const Standard_Real theFaceTolerance);
+ Standard_EXPORT IntTools_BeanFaceIntersector(const Handle(BRepAdaptor_Curve)& theCurve, const Handle(BRepAdaptor_Surface)& theSurface, const Standard_Real theFirstParOnCurve, const Standard_Real theLastParOnCurve, const Standard_Real theUMinParameter, const Standard_Real theUMaxParameter, const Standard_Real theVMinParameter, const Standard_Real theVMaxParameter, const Standard_Real theBeanTolerance, const Standard_Real theFaceTolerance);
//! Initializes the algorithm
//! Initializes the algorithm
- Standard_EXPORT void Init (const BRepAdaptor_Curve& theCurve, const BRepAdaptor_Surface& theSurface, const Standard_Real theBeanTolerance, const Standard_Real theFaceTolerance);
+ Standard_EXPORT void Init (const Handle(BRepAdaptor_Curve)& theCurve, const Handle(BRepAdaptor_Surface)& theSurface, const Standard_Real theBeanTolerance, const Standard_Real theFaceTolerance);
//! Initializes the algorithm
//! theUMinParameter, ... are used for
//! optimization purposes
- Standard_EXPORT void Init (const BRepAdaptor_Curve& theCurve, const BRepAdaptor_Surface& theSurface, const Standard_Real theFirstParOnCurve, const Standard_Real theLastParOnCurve, const Standard_Real theUMinParameter, const Standard_Real theUMaxParameter, const Standard_Real theVMinParameter, const Standard_Real theVMaxParameter, const Standard_Real theBeanTolerance, const Standard_Real theFaceTolerance);
+ Standard_EXPORT void Init (const Handle(BRepAdaptor_Curve)& theCurve, const Handle(BRepAdaptor_Surface)& theSurface, const Standard_Real theFirstParOnCurve, const Standard_Real theLastParOnCurve, const Standard_Real theUMinParameter, const Standard_Real theUMaxParameter, const Standard_Real theVMinParameter, const Standard_Real theVMaxParameter, const Standard_Real theBeanTolerance, const Standard_Real theFaceTolerance);
//! Sets the intersection context
Standard_EXPORT Standard_Boolean TestComputeCoinside();
- BRepAdaptor_Curve myCurve;
- BRepAdaptor_Surface mySurface;
+ Handle(BRepAdaptor_Curve) myCurve;
+ Handle(BRepAdaptor_Surface) mySurface;
Handle(Geom_Surface) myTrsfSurface;
Standard_Real myFirstParameter;
Standard_Real myLastParameter;
}
myBndBoxDataMap.Clear();
- for (NCollection_DataMap<TopoDS_Shape, BRepAdaptor_Surface*, TopTools_ShapeMapHasher>::Iterator anIt (mySurfAdaptorMap);
- anIt.More(); anIt.Next())
- {
- BRepAdaptor_Surface* pSurfAdaptor = anIt.Value();
- (*pSurfAdaptor).~BRepAdaptor_Surface();
- myAllocator->Free (pSurfAdaptor);
- }
mySurfAdaptorMap.Clear();
for (NCollection_DataMap<TopoDS_Shape, Bnd_OBB*, TopTools_ShapeMapHasher>::Iterator anIt (myOBBMap);
//function : SurfaceAdaptor
//purpose :
//=======================================================================
-BRepAdaptor_Surface& IntTools_Context::SurfaceAdaptor
+Handle(BRepAdaptor_Surface) IntTools_Context::SurfaceAdaptor
(const TopoDS_Face& theFace)
{
- BRepAdaptor_Surface* pBAS = NULL;
+ Handle(BRepAdaptor_Surface) pBAS;
if (!mySurfAdaptorMap.Find (theFace, pBAS))
{
- //
- pBAS=(BRepAdaptor_Surface*)myAllocator->Allocate(sizeof(BRepAdaptor_Surface));
- new (pBAS) BRepAdaptor_Surface(theFace, Standard_True);
- //
+ pBAS = new BRepAdaptor_Surface(theFace, Standard_True);
mySurfAdaptorMap.Bind (theFace, pBAS);
}
- return *pBAS;
+ return pBAS;
}
//=======================================================================
}
//
aCT2D=new Geom2d_TrimmedCurve(aC2D, aU1, aU2);
- Geom2dAdaptor_Curve aGAC (aCT2D);
+ Handle(Geom2dAdaptor_Curve) aGAC = new Geom2dAdaptor_Curve(aCT2D);
pHatcher->AddElement(aGAC, aOrE);
}// for (; aExp.More() ; aExp.Next()) {
//
aTolSum=aTolV+aTolC;
//
- GeomAdaptor_Curve aGAC(aC3D);
- GeomAbs_CurveType aType=aGAC.GetType();
+ Handle(GeomAdaptor_Curve) aGAC = new GeomAdaptor_Curve(aC3D);
+ GeomAbs_CurveType aType=aGAC->GetType();
if (aType==GeomAbs_BSplineCurve ||
aType==GeomAbs_BezierCurve) {
aTolSum=2.*aTolSum;
Standard_Real& VMin,
Standard_Real& VMax)
{
- const BRepAdaptor_Surface& aBAS = SurfaceAdaptor(theFace);
- UMin = aBAS.FirstUParameter();
- UMax = aBAS.LastUParameter ();
- VMin = aBAS.FirstVParameter();
- VMax = aBAS.LastVParameter ();
+ const Handle(BRepAdaptor_Surface)& aBAS = SurfaceAdaptor(theFace);
+ UMin = aBAS->FirstUParameter();
+ UMax = aBAS->LastUParameter ();
+ VMin = aBAS->FirstVParameter();
+ VMax = aBAS->LastVParameter ();
}
Standard_EXPORT Geom2dHatch_Hatcher& Hatcher (const TopoDS_Face& aF);
//! Returns a reference to surface adaptor for given face
- Standard_EXPORT BRepAdaptor_Surface& SurfaceAdaptor (const TopoDS_Face& theFace);
+ Standard_EXPORT Handle(BRepAdaptor_Surface) SurfaceAdaptor (const TopoDS_Face& theFace);
//! Builds and stores an Oriented Bounding Box for the shape.
//! Returns a reference to OBB.
NCollection_DataMap<TopoDS_Shape, Geom2dHatch_Hatcher*, TopTools_ShapeMapHasher> myHatcherMap;
NCollection_DataMap<TopoDS_Shape, IntTools_SurfaceRangeLocalizeData*, TopTools_ShapeMapHasher> myProjSDataMap;
NCollection_DataMap<TopoDS_Shape, Bnd_Box*, TopTools_ShapeMapHasher> myBndBoxDataMap;
- NCollection_DataMap<TopoDS_Shape, BRepAdaptor_Surface*, TopTools_ShapeMapHasher> mySurfAdaptorMap;
+ NCollection_DataMap<TopoDS_Shape, Handle(BRepAdaptor_Surface), TopTools_ShapeMapHasher> mySurfAdaptorMap;
NCollection_DataMap<TopoDS_Shape, Bnd_OBB*, TopTools_ShapeMapHasher> myOBBMap; // Map of oriented bounding boxes
Standard_Integer myCreateFlag;
Standard_Real myPOnSTolerance;
#include <BRepExtrema_DistShapeShape.hxx>
static
- void BndBuildBox(const BRepAdaptor_Curve& theBAC,
+ void BndBuildBox(const Handle(BRepAdaptor_Curve)& theBAC,
const Standard_Real aT1,
const Standard_Real aT2,
const Standard_Real theTol,
Standard_Real& aT2max,
const Standard_Boolean bMaxDist = Standard_True);
static
- Standard_Real ResolutionCoeff(const BRepAdaptor_Curve& theBAC,
+ Standard_Real ResolutionCoeff(const Handle(BRepAdaptor_Curve)& theBAC,
const IntTools_Range& theRange);
static
Standard_Real Resolution(const Handle(Geom_Curve)& theCurve,
const Standard_Real theResCoeff,
const Standard_Real theR3D);
static
- Standard_Real CurveDeflection(const BRepAdaptor_Curve& theBAC,
+ Standard_Real CurveDeflection(const Handle(BRepAdaptor_Curve)& theBAC,
const IntTools_Range& theRange);
static
Standard_Boolean IsClosed(const Handle(Geom_Curve)& theCurve,
GeomAbs_CurveType aCT1, aCT2;
Standard_Integer iCT1, iCT2;
//
- myCurve1.Initialize(myEdge1);
- myCurve2.Initialize(myEdge2);
+ myCurve1->Initialize(myEdge1);
+ myCurve2->Initialize(myEdge2);
//
if (myRange1.First() == 0. && myRange1.Last() == 0.) {
- myRange1.SetFirst(myCurve1.FirstParameter());
- myRange1.SetLast (myCurve1.LastParameter());
+ myRange1.SetFirst(myCurve1->FirstParameter());
+ myRange1.SetLast (myCurve1->LastParameter());
}
//
if (myRange2.First() == 0. && myRange2.Last() == 0.) {
- myRange2.SetFirst(myCurve2.FirstParameter());
- myRange2.SetLast (myCurve2.LastParameter());
+ myRange2.SetFirst(myCurve2->FirstParameter());
+ myRange2.SetLast (myCurve2->LastParameter());
}
//
- aCT1 = myCurve1.GetType();
- aCT2 = myCurve2.GetType();
+ aCT1 = myCurve1->GetType();
+ aCT2 = myCurve2->GetType();
//
iCT1 = TypeToInteger(aCT1);
iCT2 = TypeToInteger(aCT2);
myEdge1 = myEdge2;
myEdge2 = tmpE;
//
- BRepAdaptor_Curve tmpC = myCurve1;
+ Handle(BRepAdaptor_Curve) tmpC = myCurve1;
myCurve1 = myCurve2;
myCurve2 = tmpC;
//
}
//
Standard_Real aTolAdd = myFuzzyValue / 2.;
- myTol1 = myCurve1.Tolerance() + aTolAdd;
- myTol2 = myCurve2.Tolerance() + aTolAdd;
+ myTol1 = myCurve1->Tolerance() + aTolAdd;
+ myTol2 = myCurve2->Tolerance() + aTolAdd;
myTol = myTol1 + myTol2;
//
if (iCT1 != 0 || iCT2 != 0) {
myResCoeff1 = ResolutionCoeff(myCurve1, myRange1);
myResCoeff2 = ResolutionCoeff(myCurve2, myRange2);
//
- myRes1 = Resolution(myCurve1.Curve().Curve(), myCurve1.GetType(), myResCoeff1, myTol1);
- myRes2 = Resolution(myCurve2.Curve().Curve(), myCurve2.GetType(), myResCoeff2, myTol2);
+ myRes1 = Resolution(myCurve1->Curve()->Curve(), myCurve1->GetType(), myResCoeff1, myTol1);
+ myRes2 = Resolution(myCurve2->Curve()->Curve(), myCurve2->GetType(), myResCoeff2, myTol2);
//
myPTol1 = 5.e-13;
aTM = Max(fabs(myRange1.First()), fabs(myRange1.Last()));
Prepare();
//
//3.1. Check Line/Line case
- if (myCurve1.GetType() == GeomAbs_Line &&
- myCurve2.GetType() == GeomAbs_Line) {
+ if (myCurve1->GetType() == GeomAbs_Line &&
+ myCurve2->GetType() == GeomAbs_Line) {
ComputeLineLine();
return;
}
}
}
//
- if ((myCurve1.GetType() <= GeomAbs_Parabola && myCurve2.GetType() <= GeomAbs_Parabola) &&
- (myCurve1.GetType() == GeomAbs_Line || myCurve2.GetType() == GeomAbs_Line))
+ if ((myCurve1->GetType() <= GeomAbs_Parabola && myCurve2->GetType() <= GeomAbs_Parabola) &&
+ (myCurve1->GetType() == GeomAbs_Line || myCurve2->GetType() == GeomAbs_Line))
{
//Improvement of performance for cases of searching common parts between line
//and analytical curve. This code allows to define that edges have no
//function : FindParameters
//purpose :
//=======================================================================
-Standard_Boolean IntTools_EdgeEdge::FindParameters(const BRepAdaptor_Curve& theBAC,
+Standard_Boolean IntTools_EdgeEdge::FindParameters(const Handle(BRepAdaptor_Curve)& theBAC,
const Standard_Real aT1,
const Standard_Real aT2,
const Standard_Real theTol,
aCBx = theCBox;
aCBx.SetGap(aCBx.GetGap() + theTol);
//
- const Handle(Geom_Curve)& aCurve = theBAC.Curve().Curve();
- const GeomAbs_CurveType aCurveType = theBAC.GetType();
+ const Handle(Geom_Curve)& aCurve = theBAC->Curve()->Curve();
+ const GeomAbs_CurveType aCurveType = theBAC->GetType();
Standard_Real aMaxDt = (aT2 - aT1) * 0.01;
//
for (i = 0; i < 2; ++i) {
Standard_Real k = 1;
//looking for the point on the edge which is in the box;
while (aC*(aT-aTB) >= 0) {
- theBAC.D0(aTB, aP);
+ theBAC->D0(aTB, aP);
aDist = PointBoxDistance(theCBox, aP);
if (aDist > theTol) {
if (aDistP > 0.) {
aDiff = aTIn - aTOut;
while (fabs(aDiff) > thePTol) {
aTB = aTOut + aDiff*aCf;
- theBAC.D0(aTB, aP);
+ theBAC->D0(aTB, aP);
if (aCBx.IsOut(aP)) {
aTOut = aTB;
} else {
Standard_Real aRes1, aRes2, dTR1, dTR2;
TColStd_MapOfInteger aMI;
//
- aRes1 = Resolution(myCurve1.Curve().Curve(),
- myCurve1.GetType(), myResCoeff1, myTol);
- aRes2 = Resolution(myCurve2.Curve().Curve(),
- myCurve2.GetType(), myResCoeff2, myTol);
+ aRes1 = Resolution(myCurve1->Curve()->Curve(),
+ myCurve1->GetType(), myResCoeff1, myTol);
+ aRes2 = Resolution(myCurve2->Curve()->Curve(),
+ myCurve2->GetType(), myResCoeff2, myTol);
//
myRange1.Range(aT11, aT12);
myRange2.Range(aT21, aT22);
Standard_Boolean bTouch = Standard_False;
Standard_Boolean bTouchConfirm = Standard_False;
//
- aRes1 = Resolution(myCurve1.Curve().Curve(),
- myCurve1.GetType(), myResCoeff1, myTol);
+ aRes1 = Resolution(myCurve1->Curve()->Curve(),
+ myCurve1->GetType(), myResCoeff1, myTol);
aNbS = 10;
aNbS = SplitRangeOnSegments(aT11, aT12, 3*aRes1, aNbS, aRanges);
//
{
Standard_Real aTol = myTol * myTol;
- gp_Lin aL1 = myCurve1.Line();
- gp_Lin aL2 = myCurve2.Line();
+ gp_Lin aL1 = myCurve1->Line();
+ gp_Lin aL2 = myCurve2->Line();
gp_Dir aD1 = aL1.Direction();
gp_Dir aD2 = aL2.Direction();
//function : BndBuildBox
//purpose :
//=======================================================================
-void BndBuildBox(const BRepAdaptor_Curve& theBAC,
+void BndBuildBox(const Handle(BRepAdaptor_Curve)& theBAC,
const Standard_Real aT1,
const Standard_Real aT2,
const Standard_Real theTol,
//function : ResolutionCoeff
//purpose :
//=======================================================================
-Standard_Real ResolutionCoeff(const BRepAdaptor_Curve& theBAC,
+Standard_Real ResolutionCoeff(const Handle(BRepAdaptor_Curve)& theBAC,
const IntTools_Range& theRange)
{
Standard_Real aResCoeff = 0.;
//
- const Handle(Geom_Curve)& aCurve = theBAC.Curve().Curve();
- const GeomAbs_CurveType aCurveType = theBAC.GetType();
+ const Handle(Geom_Curve)& aCurve = theBAC->Curve()->Curve();
+ const GeomAbs_CurveType aCurveType = theBAC->GetType();
//
switch (aCurveType) {
case GeomAbs_Circle :
aT = aT1;
kMin = 10.;
//
- theBAC.D0(aT1, aP1);
+ theBAC->D0(aT1, aP1);
for (i = 1; i <= aNbP; ++i) {
aT += aDt;
- theBAC.D0(aT, aP2);
+ theBAC->D0(aT, aP2);
aDist = aP1.Distance(aP2);
k = aDt / aDist;
if (k < kMin) {
//function : CurveDeflection
//purpose :
//=======================================================================
-Standard_Real CurveDeflection(const BRepAdaptor_Curve& theBAC,
+Standard_Real CurveDeflection(const Handle(BRepAdaptor_Curve)& theBAC,
const IntTools_Range& theRange)
{
Standard_Real aDt, aT, aT1, aT2, aDefl;
aDt = (aT2 - aT1) / aNbP;
aT = aT1;
//
- theBAC.D1(aT1, aP, aV1);
+ theBAC->D1(aT1, aP, aV1);
for (i = 1; i <= aNbP; ++i) {
aT += aDt;
- theBAC.D1(aT, aP, aV2);
+ theBAC->D1(aT, aP, aV2);
if (aV1.Magnitude() > gp::Resolution() &&
aV2.Magnitude() > gp::Resolution()) {
gp_Dir aD1(aV1), aD2(aV2);
//! Looking for the range of the edge which is in the box
- Standard_EXPORT static Standard_Boolean FindParameters(const BRepAdaptor_Curve& theBAC,
+ Standard_EXPORT static Standard_Boolean FindParameters(const Handle(BRepAdaptor_Curve)& theBAC,
const Standard_Real aT1, const Standard_Real aT2, const Standard_Real theTol,
const Standard_Real theRes, const Standard_Real thePTol,
const Standard_Real theResCoeff, const Bnd_Box& theCBox,
TopoDS_Edge myEdge2;
Handle(Geom_Curve) myGeom1;
Handle(Geom_Curve) myGeom2;
- BRepAdaptor_Curve myCurve1;
- BRepAdaptor_Curve myCurve2;
+ Handle(BRepAdaptor_Curve) myCurve1;
+ Handle(BRepAdaptor_Curve) myCurve2;
Standard_Real myTol1;
Standard_Real myTol2;
Standard_Real myTol;
//=======================================================================
inline IntTools_EdgeEdge::IntTools_EdgeEdge()
:
+ myCurve1(new BRepAdaptor_Curve()),
+ myCurve2(new BRepAdaptor_Curve()),
myTol1(0.),
myTol2(0.),
myTol(0.),
:
myEdge1(theEdge1),
myEdge2(theEdge2),
+ myCurve1(new BRepAdaptor_Curve()),
+ myCurve2(new BRepAdaptor_Curve()),
myTol1(0.),
myTol2(0.),
myTol(0.),
:
myEdge1(theEdge1),
myEdge2(theEdge2),
+ myCurve1(new BRepAdaptor_Curve()),
+ myCurve2(new BRepAdaptor_Curve()),
myTol1(0.),
myTol2(0.),
myTol(0.),
#include <algorithm>
static
- Standard_Boolean IsCoplanar (const BRepAdaptor_Curve& ,
- const BRepAdaptor_Surface& );
+ Standard_Boolean IsCoplanar (const Handle(BRepAdaptor_Curve)& ,
+ const Handle(BRepAdaptor_Surface)& );
static
- Standard_Boolean IsRadius (const BRepAdaptor_Curve& aCurve ,
- const BRepAdaptor_Surface& aSurface,
+ Standard_Boolean IsRadius (const Handle(BRepAdaptor_Curve)& aCurve ,
+ const Handle(BRepAdaptor_Surface)& aSurface,
const Standard_Real aCriteria);
//=======================================================================
IntTools_EdgeFace::IntTools_EdgeFace()
{
myFuzzyValue = Precision::Confusion();
+ myC = new BRepAdaptor_Curve();
+ myS = new BRepAdaptor_Surface();
myIsDone=Standard_False;
myErrorStatus=1;
myQuickCoincidenceCheck=Standard_False;
GeomAPI_ProjectPointOnSurf& aProjector=myContext->ProjPS(myFace);
Standard_Integer aNbSeg=23;
- if (myC.GetType() == GeomAbs_Line &&
- myS.GetType() == GeomAbs_Plane)
+ if (myC->GetType() == GeomAbs_Line &&
+ myS->GetType() == GeomAbs_Plane)
aNbSeg = 2; // Check only three points for Line/Plane intersection
const Standard_Real aTresh = 0.5;
iCnt=0;
for(i=0; i <= aNbSeg; ++i) {
aT = aT1+i*dT;
- aP=myC.Value(aT);
+ aP=myC->Value(aT);
//
aProjector.Perform(aP);
if (!aProjector.IsDone()) {
Standard_Boolean bFlag;
gp_Pnt aPC;
//
- myC.D0(aT, aPC);
+ myC->D0(aT, aPC);
bFlag=myContext->IsValidPointForFace(aPC, myFace, myCriteria);
//
return bFlag;
//
gp_Pnt P;
- myC.D0(t, P);
+ myC->D0(t, P);
//
Standard_Boolean bIsEqDistance;
//=======================================================================
Standard_Boolean IntTools_EdgeFace::IsEqDistance
(const gp_Pnt& aP,
- const BRepAdaptor_Surface& aBAS,
+ const Handle(BRepAdaptor_Surface)& aBAS,
const Standard_Real aTol,
Standard_Real& aD)
{
Standard_Boolean bRetFlag=Standard_True;
- GeomAbs_SurfaceType aSurfType=aBAS.GetType();
+ GeomAbs_SurfaceType aSurfType=aBAS->GetType();
if (aSurfType==GeomAbs_Cylinder) {
- gp_Cylinder aCyl=aBAS.Cylinder();
+ gp_Cylinder aCyl=aBAS->Cylinder();
const gp_Ax1& anAx1 =aCyl.Axis();
gp_Lin aLinAxis(anAx1);
Standard_Real aDC, aRadius=aCyl.Radius();
}
if (aSurfType==GeomAbs_Cone) {
- gp_Cone aCone=aBAS.Cone();
+ gp_Cone aCone=aBAS->Cone();
const gp_Ax1& anAx1 =aCone.Axis();
gp_Lin aLinAxis(anAx1);
Standard_Real aDC, aRadius, aDS, aSemiAngle;
if (aSurfType==GeomAbs_Torus) {
Standard_Real aMajorRadius, aMinorRadius, aDC;
- gp_Torus aTorus=aBAS.Torus();
+ gp_Torus aTorus=aBAS->Torus();
gp_Pnt aPLoc=aTorus.Location();
aMajorRadius=aTorus.MajorRadius();
{
gp_Pnt aPF, aPL;
- myC.D0(af1, aPF);
- myC.D0(al1, aPL);
+ myC->D0(af1, aPF);
+ myC->D0(al1, aPL);
df1=aPF.Distance(aPL);
Standard_Boolean isWholeRange = Standard_False;
- if((Abs(af1 - myRange.First()) < myC.Resolution(myCriteria)) &&
- (Abs(al1 - myRange.Last()) < myC.Resolution(myCriteria)))
+ if((Abs(af1 - myRange.First()) < myC->Resolution(myCriteria)) &&
+ (Abs(al1 - myRange.Last()) < myC->Resolution(myCriteria)))
isWholeRange = Standard_True;
if(isWholeRange) {
tm = (af1 + al1) * 0.5;
- if(aPF.Distance(myC.Value(tm)) > myCriteria * 2.) {
+ if(aPF.Distance(myC->Value(tm)) > myCriteria * 2.) {
aCommonPrt.SetType(TopAbs_EDGE);
return 0;
}
//
Standard_Real aCR;
- aCR=myC.Resolution(myCriteria);
+ aCR=myC->Resolution(myCriteria);
if((Abs(aTF - myRange.First()) < aCR) &&
(Abs(aTL - myRange.Last()) < aCR)) {
return theflag; // EDGE
Tol = Precision::PConfusion();
- const Handle(Geom_Curve)& Curve =BRep_Tool::Curve (myC.Edge(), af, al);
- const Handle(Geom_Surface)& Surface=BRep_Tool::Surface(myS.Face());
+ const Handle(Geom_Curve)& Curve =BRep_Tool::Curve (myC->Edge(), af, al);
+ const Handle(Geom_Surface)& Surface=BRep_Tool::Surface(myS->Face());
// Surface->Bounds(U1f,U1l,V1f,V1l);
- U1f = myS.FirstUParameter();
- U1l = myS.LastUParameter();
- V1f = myS.FirstVParameter();
- V1l = myS.LastVParameter();
+ U1f = myS->FirstUParameter();
+ U1l = myS->LastUParameter();
+ V1f = myS->FirstVParameter();
+ V1l = myS->LastVParameter();
- GeomAdaptor_Curve TheCurve (Curve,aTF, aTL);
- GeomAdaptor_Surface TheSurface (Surface, U1f, U1l, V1f, V1l);
+ Handle(GeomAdaptor_Curve) TheCurve = new GeomAdaptor_Curve(Curve,aTF, aTL);
+ Handle(GeomAdaptor_Surface) TheSurface = new GeomAdaptor_Surface(Surface, U1f, U1l, V1f, V1l);
Extrema_ExtCS anExtrema (TheCurve, TheSurface, Tol, Tol);
// modified by NIZHNY-MKK Thu Jul 21 11:35:32 2005.BEGIN
IntCurveSurface_HInter anExactIntersector;
- Handle(GeomAdaptor_Curve) aCurve = new GeomAdaptor_Curve(TheCurve);
- Handle(GeomAdaptor_Surface) aSurface = new GeomAdaptor_Surface(TheSurface);
-
- anExactIntersector.Perform(aCurve, aSurface);
+ anExactIntersector.Perform(TheCurve, TheSurface);
if(anExactIntersector.IsDone()) {
for(Standard_Integer i = 1; i <= anExactIntersector.NbPoints(); i++) {
}
//
myIsDone = Standard_False;
- myC.Initialize(myEdge);
+ myC->Initialize(myEdge);
GeomAbs_CurveType aCurveType;
- aCurveType=myC.GetType();
+ aCurveType=myC->GetType();
//
// Prepare myCriteria
Standard_Real aFuzz = myFuzzyValue / 2.;
gp_Pnt aPx1, aPx2;
//
aCP.Range1(aTx1, aTx2);
- myC.D0(aTx1, aPx1);
- myC.D0(aTx2, aPx2);
+ myC->D0(aTx1, aPx1);
+ myC->D0(aTx2, aPx2);
aCP.SetBoundingPoints(aPx1, aPx2);
//
MakeType (aCP);
Standard_Boolean bIsTouch;
Standard_Real aTx;
- aCType=myC.GetType();
- aSType=myS.GetType();
+ aCType=myC->GetType();
+ aSType=myS->GetType();
if (aCType==GeomAbs_Line && aSType==GeomAbs_Cylinder) {
for (i=1; i<=aNb; i++) {
GeomAbs_CurveType aType;
//
aCP.Range1(aTF, aTL);
- aType=myC.GetType();
+ aType=myC->GetType();
//
aEpsT=8.e-5;
if (aType==GeomAbs_Line) {
Tol = Precision::PConfusion();
- const Handle(Geom_Curve)& Curve =BRep_Tool::Curve (myC.Edge(), af, al);
- const Handle(Geom_Surface)& Surface=BRep_Tool::Surface(myS.Face());
+ const Handle(Geom_Curve)& Curve =BRep_Tool::Curve (myC->Edge(), af, al);
+ const Handle(Geom_Surface)& Surface=BRep_Tool::Surface(myS->Face());
Surface->Bounds(U1f,U1l,V1f,V1l);
- GeomAdaptor_Curve TheCurve (Curve,aTF, aTL);
- GeomAdaptor_Surface TheSurface (Surface, U1f, U1l, V1f, V1l);
+ Handle(GeomAdaptor_Curve) TheCurve = new GeomAdaptor_Curve(Curve,aTF, aTL);
+ Handle(GeomAdaptor_Surface) TheSurface = new GeomAdaptor_Surface(Surface, U1f, U1l, V1f, V1l);
Extrema_ExtCS anExtrema (TheCurve, TheSurface, Tol, Tol);
//function : IsCoplanar
//purpose :
//=======================================================================
-Standard_Boolean IsCoplanar (const BRepAdaptor_Curve& aCurve ,
- const BRepAdaptor_Surface& aSurface)
+Standard_Boolean IsCoplanar (const Handle(BRepAdaptor_Curve)& aCurve ,
+ const Handle(BRepAdaptor_Surface)& aSurface)
{
Standard_Boolean bFlag=Standard_False;
GeomAbs_CurveType aCType;
GeomAbs_SurfaceType aSType;
- aCType=aCurve.GetType();
- aSType=aSurface.GetType();
+ aCType=aCurve->GetType();
+ aSType=aSurface->GetType();
if (aCType==GeomAbs_Circle && aSType==GeomAbs_Plane) {
- gp_Circ aCirc=aCurve.Circle();
+ gp_Circ aCirc=aCurve->Circle();
const gp_Ax1& anAx1=aCirc.Axis();
const gp_Dir& aDirAx1=anAx1.Direction();
- gp_Pln aPln=aSurface.Plane();
+ gp_Pln aPln=aSurface->Plane();
const gp_Ax1& anAx=aPln.Axis();
const gp_Dir& aDirPln=anAx.Direction();
//function : IsRadius
//purpose :
//=======================================================================
-Standard_Boolean IsRadius (const BRepAdaptor_Curve& aCurve,
- const BRepAdaptor_Surface& aSurface,
+Standard_Boolean IsRadius (const Handle(BRepAdaptor_Curve)& aCurve,
+ const Handle(BRepAdaptor_Surface)& aSurface,
const Standard_Real aCriteria)
{
Standard_Boolean bFlag=Standard_False;
GeomAbs_CurveType aCType;
GeomAbs_SurfaceType aSType;
- aCType=aCurve.GetType();
- aSType=aSurface.GetType();
+ aCType=aCurve->GetType();
+ aSType=aSurface->GetType();
if (aCType==GeomAbs_Circle && aSType==GeomAbs_Plane) {
- gp_Circ aCirc=aCurve.Circle();
+ gp_Circ aCirc=aCurve->Circle();
const gp_Pnt aCenter=aCirc.Location();
Standard_Real aR=aCirc.Radius();
- gp_Pln aPln=aSurface.Plane();
+ gp_Pln aPln=aSurface->Plane();
Standard_Real aD=aPln.Distance(aCenter);
if (fabs (aD-aR) < aCriteria) {
return !bFlag;
//purpose :
//=======================================================================
Standard_Integer AdaptiveDiscret (const Standard_Integer iDiscret,
- const BRepAdaptor_Curve& aCurve ,
- const BRepAdaptor_Surface& aSurface)
+ const Handle(BRepAdaptor_Curve)& aCurve ,
+ const Handle(BRepAdaptor_Surface)& aSurface)
{
Standard_Integer iDiscretNew;
GeomAbs_SurfaceType aSType;
- aSType=aSurface.GetType();
+ aSType=aSurface->GetType();
if (aSType==GeomAbs_Cylinder) {
Standard_Real aELength, aRadius, dLR;
- aELength=IntTools::Length(aCurve.Edge());
+ aELength=IntTools::Length(aCurve->Edge());
- gp_Cylinder aCylinder=aSurface.Cylinder();
+ gp_Cylinder aCylinder=aSurface->Cylinder();
aRadius=aCylinder.Radius();
dLR=2*aRadius;
protected: //! @name Protected methods performing the intersection
- Standard_EXPORT static Standard_Boolean IsEqDistance (const gp_Pnt& aP, const BRepAdaptor_Surface& aS, const Standard_Real aT, Standard_Real& aD);
+ Standard_EXPORT static Standard_Boolean IsEqDistance (const gp_Pnt& aP, const Handle(BRepAdaptor_Surface)& aS, const Standard_Real aT, Standard_Real& aD);
Standard_EXPORT void CheckData();
Standard_EXPORT Standard_Boolean IsProjectable (const Standard_Real t) const;
TopoDS_Edge myEdge;
TopoDS_Face myFace;
Standard_Real myFuzzyValue;
- BRepAdaptor_Curve myC;
- BRepAdaptor_Surface myS;
+ Handle(BRepAdaptor_Curve) myC;
+ Handle(BRepAdaptor_Surface) myS;
Standard_Real myCriteria;
Standard_Boolean myIsDone;
Standard_Integer myErrorStatus;
return;
}
//
- BRepAdaptor_Curve2d C(edge,Face);
+ Handle(BRepAdaptor_Curve2d) C = new BRepAdaptor_Curve2d(edge,Face);
BRepAdaptor_Curve C3d;
//------------------------------------------
degenerated=Standard_False;
gp_Pnt P3d;
//
u=aPrms(iX);
- P2d = C.Value(u);
+ P2d = C->Value(u);
if(P2d.X()<Umin) Umin = P2d.X();
if(P2d.X()>Umax) Umax = P2d.X();
if(P2d.Y()<Vmin) Vmin = P2d.Y();
gp_Pnt2d aP;
gp_Vec2d aV;
- C.D1(aU, aP, aV);
+ C->D1(aU, aP, aV);
if(Or == TopAbs_REVERSED)
aV.Reverse();
// Append the derivative of the last parameter.
aU = aPrms(aNbs1);
- C.D1(aU, aP, aV);
+ C->D1(aU, aP, aV);
if(Or == TopAbs_REVERSED)
aV.Reverse();
{
BRep_Tool::Range(edge, Face, pfbid, plbid);
if (Abs(plbid - pfbid) < 1.e-9) continue;
- BRepAdaptor_Curve2d C(edge, Face);
+ Handle(BRepAdaptor_Curve2d) C = new BRepAdaptor_Curve2d(edge, Face);
GCPnts_QuasiUniformDeflection aDiscr(C, aDiscrDefl);
if (!aDiscr.IsDone())
break;
i += iStep;
for (; i != iEnd; i += iStep)
{
- gp_Pnt2d aP2d = C.Value(aDiscr.Parameter(i));
+ gp_Pnt2d aP2d = C->Value(aDiscr.Parameter(i));
SeqPnt2d.Append(aP2d);
}
if (nbp > 2)
}
-static Standard_Boolean isTreatAnalityc(const BRepAdaptor_Surface& theBAS1,
- const BRepAdaptor_Surface& theBAS2,
+static Standard_Boolean isTreatAnalityc(const Handle(BRepAdaptor_Surface)& theBAS1,
+ const Handle(BRepAdaptor_Surface)& theBAS2,
const Standard_Real theTol)
{
const Standard_Real Tolang = 1.e-8;
Standard_Real aHigh = 0.0;
- const GeomAbs_SurfaceType aType1=theBAS1.GetType();
- const GeomAbs_SurfaceType aType2=theBAS2.GetType();
+ const GeomAbs_SurfaceType aType1=theBAS1->GetType();
+ const GeomAbs_SurfaceType aType2=theBAS2->GetType();
gp_Pln aS1;
gp_Cylinder aS2;
if(aType1 == GeomAbs_Plane)
{
- aS1=theBAS1.Plane();
+ aS1=theBAS1->Plane();
}
else if(aType2 == GeomAbs_Plane)
{
- aS1=theBAS2.Plane();
+ aS1=theBAS2->Plane();
}
else
{
if(aType1 == GeomAbs_Cylinder)
{
- aS2=theBAS1.Cylinder();
- const Standard_Real VMin = theBAS1.FirstVParameter();
- const Standard_Real VMax = theBAS1.LastVParameter();
+ aS2=theBAS1->Cylinder();
+ const Standard_Real VMin = theBAS1->FirstVParameter();
+ const Standard_Real VMax = theBAS1->LastVParameter();
if( Precision::IsNegativeInfinite(VMin) ||
Precision::IsPositiveInfinite(VMax))
}
else if(aType2 == GeomAbs_Cylinder)
{
- aS2=theBAS2.Cylinder();
+ aS2=theBAS2->Cylinder();
- const Standard_Real VMin = theBAS2.FirstVParameter();
- const Standard_Real VMax = theBAS2.LastVParameter();
+ const Standard_Real VMin = theBAS2->FirstVParameter();
+ const Standard_Real VMax = theBAS2->LastVParameter();
if( Precision::IsNegativeInfinite(VMin) ||
Precision::IsPositiveInfinite(VMax))
myFace1=aF1;
myFace2=aF2;
- const BRepAdaptor_Surface& aBAS1 = myContext->SurfaceAdaptor(myFace1);
- const BRepAdaptor_Surface& aBAS2 = myContext->SurfaceAdaptor(myFace2);
- GeomAbs_SurfaceType aType1=aBAS1.GetType();
- GeomAbs_SurfaceType aType2=aBAS2.GetType();
+ const Handle(BRepAdaptor_Surface)& aBAS1 = myContext->SurfaceAdaptor(myFace1);
+ const Handle(BRepAdaptor_Surface)& aBAS2 = myContext->SurfaceAdaptor(myFace2);
+ GeomAbs_SurfaceType aType1=aBAS1->GetType();
+ GeomAbs_SurfaceType aType2=aBAS2->GetType();
const Standard_Boolean bReverse=SortTypes(aType1, aType2);
if (bReverse)
{
myFace1=aF2;
myFace2=aF1;
- aType1=aBAS2.GetType();
- aType2=aBAS1.GetType();
+ aType1=aBAS2->GetType();
+ aType2=aBAS1->GetType();
if (myListOfPnts.Extent())
{
return Standard_False;
Standard_Real tolint = 1.e-10;
- Geom2dAdaptor_Curve PCA;
+ Handle(Geom2dAdaptor_Curve) PCA = new Geom2dAdaptor_Curve();
IntRes2d_Domain PCD;
Geom2dInt_GInter PCI;
pl = thePCurve->LastParameter();
pntf = thePCurve->Value(pf);
pntl = thePCurve->Value(pl);
- PCA.Load(thePCurve);
- if(!PCA.IsPeriodic()) {
- if(PCA.FirstParameter() > pf) pf = PCA.FirstParameter();
- if(PCA.LastParameter() < pl) pl = PCA.LastParameter();
+ PCA->Load(thePCurve);
+ if(!PCA->IsPeriodic()) {
+ if(PCA->FirstParameter() > pf) pf = PCA->FirstParameter();
+ if(PCA->LastParameter() < pl) pl = PCA->LastParameter();
}
PCD.SetValues(pntf,pf,tolint,pntl,pl,tolint);
PCI.Perform(PCA,PCD,tolint,tolint);
myTS1=aT1;
myTS2=aT2;
//
- BRepAdaptor_Curve aBAC(myEdge);
+ Handle(BRepAdaptor_Curve) aBAC = new BRepAdaptor_Curve(myEdge);
BndLib_Add3dCurve::Add(aBAC, aT1, aT2, 0., myBndBox);
}
// compute the shrunk range - part of the edge not covered
// by the tolerance spheres of its vertices
- BRepAdaptor_Curve aBAC(myEdge);
+ Handle(BRepAdaptor_Curve) aBAC = new BRepAdaptor_Curve(myEdge);
if (!BRepLib::FindValidRange(aBAC, aTolE, myT1, aP1, aTolV1,
myT2, aP2, aTolV2, myTS1, myTS2)) {
// no valid range
//
// parametric tolerance for the edge
// to be used in AbscissaPoint computations
- Standard_Real aPTolE = aBAC.Resolution(aTolE);
+ Standard_Real aPTolE = aBAC->Resolution(aTolE);
// for the edges with big tolerance use
// min parametric tolerance - 1% of its range
Standard_Real aPTolEMin = (myT2 - myT1) / 100.;
}
//
// Build bounding box for the curve
- BndLib_Add3dCurve::Add(GeomAdaptor_Curve(aC3D),
+ BndLib_Add3dCurve::Add(new GeomAdaptor_Curve(aC3D),
Max(theCurve.Tolerance(), theCurve.TangentialTolerance()),
theBox);
//
// (theU0, theV0) is initial point for extrema
//=======================================================================
static Standard_Real SQDistPointSurface(const gp_Pnt &thePnt,
- const Adaptor3d_Surface& theSurf,
+ const Handle(Adaptor3d_Surface)& theSurf,
const Standard_Real theU0,
const Standard_Real theV0)
{
for(Standard_Integer i = 0; i < aNbItems; i++)
{
gp_Pnt aP(theSurf1->Value(aParUS1[i], aParVS1[i]));
- const Standard_Real aSqDist = SQDistPointSurface(aP, *theSurf2, theU20, theV20);
+ const Standard_Real aSqDist = SQDistPointSurface(aP, theSurf2, theU20, theV20);
if(aSqDist > aSQToler)
return Standard_False;
}
for(Standard_Integer i = 0; i < aNbItems; i++)
{
gp_Pnt aP(theSurf2->Value(aParUS2[i], aParVS2[i]));
- const Standard_Real aSqDist = SQDistPointSurface(aP, *theSurf1, theU10, theV10);
+ const Standard_Real aSqDist = SQDistPointSurface(aP, theSurf1, theU10, theV10);
if(aSqDist > aSQToler)
return Standard_False;
}
gp_Dir2d DirectionOnS2() const;
- const Handle(Adaptor3d_Surface)& AuxillarSurface1() const;
+ const Handle(Adaptor3d_Surface) AuxillarSurface1() const;
- const Handle(Adaptor3d_Surface)& AuxillarSurface2() const;
+ const Handle(Adaptor3d_Surface) AuxillarSurface2() const;
const Standard_Real V,
gp_Pnt& P)
{
+ Standard_ASSERT_RAISE(!S.IsNull(), "Surface Adaptor is not initialized");
P = S->Value(U, V);
}
gp_Vec& D1U,
gp_Vec& D1V)
{
+ Standard_ASSERT_RAISE(!S.IsNull(), "Surface Adaptor is not initialized");
S->D1(U, V, P, D1U, D1V);
}
gp_Vec& D2V,
gp_Vec& DUV)
{
+ Standard_ASSERT_RAISE(!S.IsNull(), "Surface Adaptor is not initialized");
S->D2(U, V, P, D1U, D1V, D2U, D2V, DUV);
}
const Standard_Integer IU,
const Standard_Integer IV)
{
+ Standard_ASSERT_RAISE(!S.IsNull(), "Surface Adaptor is not initialized");
return S->DN(U, V, IU, IV);
}
Standard_Integer LProp3d_SurfaceTool::Continuity
(const Handle(Adaptor3d_Surface)& S)
{
+ Standard_ASSERT_RAISE(!S.IsNull(), "Surface Adaptor is not initialized");
GeomAbs_Shape s = (GeomAbs_Shape) Min(S->UContinuity(),S->VContinuity());
switch (s) {
case GeomAbs_C0:
Standard_Real& U2,
Standard_Real& V2)
{
+ Standard_ASSERT_RAISE(!S.IsNull(), "Surface Adaptor is not initialized");
U1 = S->FirstUParameter();
V1 = S->FirstVParameter();
U2 = S->LastUParameter();
return res;
}
-Handle(Law_BSpline) Law::Reparametrize(const Adaptor3d_Curve& Curve,
+Handle(Law_BSpline) Law::Reparametrize(const Handle(Adaptor3d_Curve)& Curve,
const Standard_Real First,
const Standard_Real Last,
const Standard_Boolean HasDF,
TColStd_Array1OfReal cumdist(1,2*NbPoints);
TColStd_Array1OfReal ucourbe(1,2*NbPoints);
gp_Pnt P1,P2;
- Standard_Real U1 = Curve.FirstParameter();
- Standard_Real U2 = Curve.LastParameter();
+ Standard_Real U1 = Curve->FirstParameter();
+ Standard_Real U2 = Curve->LastParameter();
Standard_Real U, DU, Length = 0.;
if(!Rev){
- P1 = Curve.Value(U1);
+ P1 = Curve->Value(U1);
U = U1;
DU = (U2 - U1) / ( 2*NbPoints - 1);
}
else{
- P1 = Curve.Value(U2);
+ P1 = Curve->Value(U2);
U = U2;
DU = (U1 - U2) / ( 2*NbPoints - 1);
}
for ( i = 1; i <= 2*NbPoints ; i ++) {
- P2 = Curve.Value(U);
+ P2 = Curve->Value(U);
Length += P2.Distance(P1);
cumdist(i) = Length;
ucourbe(i) = U;
//! Computes a 1 d curve to reparametrize a curve. Its an
//! interpolation of NbPoints points calculated at quasi
//! constant abscissa.
- Standard_EXPORT static Handle(Law_BSpline) Reparametrize (const Adaptor3d_Curve& Curve, const Standard_Real First, const Standard_Real Last, const Standard_Boolean HasDF, const Standard_Boolean HasDL, const Standard_Real DFirst, const Standard_Real DLast, const Standard_Boolean Rev, const Standard_Integer NbPoints);
+ Standard_EXPORT static Handle(Law_BSpline) Reparametrize (const Handle(Adaptor3d_Curve)& Curve, const Standard_Real First, const Standard_Real Last, const Standard_Boolean HasDF, const Standard_Boolean HasDL, const Standard_Real DFirst, const Standard_Real DLast, const Standard_Boolean Rev, const Standard_Integer NbPoints);
//! Computes a 1 d curve to scale a field of tangency.
//! Value is 1. for t = (First+Last)/2 .
}
// Projection sur Sb
- GeomAdaptor_Surface GAS(Sb);
- Standard_Real TolU = GAS.UResolution(Precision::Confusion());
- Standard_Real TolV = GAS.VResolution(Precision::Confusion());
+ Handle(GeomAdaptor_Surface) GAS = new GeomAdaptor_Surface(Sb);
+ Standard_Real TolU = GAS->UResolution(Precision::Confusion());
+ Standard_Real TolV = GAS->VResolution(Precision::Confusion());
Extrema_ExtPS dist(pvt,GAS,TolU,TolV);
if (dist.IsDone()) {
Standard_Real dist2min = RealLast();
}
Standard_Real pmin=0, Dist2, Dist2Min, Glob2Min = RealLast();
- GeomAdaptor_Curve TheCurve;
+ Handle(GeomAdaptor_Curve) TheCurve = new GeomAdaptor_Curve();
Standard_Integer i,imin,k;
gp_Pnt pv = BRep_Tool::Pnt(vtx);
imin = 0;
for (i=1; i<= i2s.NbLines(); i++) {
- TheCurve.Load(i2s.Line(i));
+ TheCurve->Load(i2s.Line(i));
Extrema_ExtPC myExtPC(pv,TheCurve);
if (myExtPC.IsDone()) {
gp_Pnt p1b,p2b;
- Standard_Real thepmin = TheCurve.FirstParameter();
+ Standard_Real thepmin = TheCurve->FirstParameter();
myExtPC.TrimmedSquareDistances(Dist2Min,Dist2,p1b,p2b);
if (Dist2 < Dist2Min) {
- thepmin = TheCurve.LastParameter();
+ thepmin = TheCurve->LastParameter();
}
for (k=1; k<=myExtPC.NbExt(); k++) {
Dist2 = myExtPC.SquareDistance(k);
// Standard_Real pmin, Dist, DistMin;
Standard_Real Dist2, Dist2Min;
Standard_Real prmf=0,prml=0;
- GeomAdaptor_Curve TheCurve;
+ Handle(GeomAdaptor_Curve) TheCurve = new GeomAdaptor_Curve();
Standard_Integer i,k;
gp_Pnt pvf = BRep_Tool::Pnt(V1);
gp_Pnt pvl = BRep_Tool::Pnt(V2);
for (i=1; i<= i2s.NbLines(); i++) {
- TheCurve.Load(i2s.Line(i));
+ TheCurve->Load(i2s.Line(i));
Extrema_ExtPC myExtPC(pvf,TheCurve);
if (myExtPC.IsDone()) {
gp_Pnt p1b,p2b;
- Standard_Real thepmin = TheCurve.FirstParameter();
+ Standard_Real thepmin = TheCurve->FirstParameter();
myExtPC.TrimmedSquareDistances(Dist2Min,Dist2,p1b,p2b);
- if (Dist2 < Dist2Min && !TheCurve.IsPeriodic()) {
+ if (Dist2 < Dist2Min && !TheCurve->IsPeriodic()) {
Dist2Min = Dist2;
- thepmin = TheCurve.LastParameter();
+ thepmin = TheCurve->LastParameter();
}
for (k=1; k<=myExtPC.NbExt(); k++) {
Dist2 = myExtPC.SquareDistance(k);
prmf = thepmin;
myExtPC.Perform(pvl);
if (myExtPC.IsDone()) {
- thepmin = TheCurve.LastParameter();
+ thepmin = TheCurve->LastParameter();
myExtPC.TrimmedSquareDistances(Dist2,Dist2Min,p1b,p2b);
- if (Dist2 < Dist2Min && !TheCurve.IsClosed()) {
+ if (Dist2 < Dist2Min && !TheCurve->IsClosed()) {
Dist2Min = Dist2;
- thepmin = TheCurve.FirstParameter();
+ thepmin = TheCurve->FirstParameter();
}
for (k=1; k<=myExtPC.NbExt(); k++) {
Dist2 = myExtPC.SquareDistance(k);
const TopTools_ListOfShape&);
inline Standard_Boolean SameUV(const gp_Pnt2d& P1, const gp_Pnt2d& P2,
- const BRepAdaptor_Surface& theBAS)//const Standard_Real tol)
+ const Handle(BRepAdaptor_Surface)& theBAS)//const Standard_Real tol)
{
Standard_Boolean isSame = Standard_True;
- if(theBAS.IsUPeriodic())
- isSame = (fabs(P1.X() - P2.X()) < theBAS.UPeriod() *0.5);
- if(theBAS.IsVPeriodic())
- isSame = (isSame && (fabs(P1.Y() - P2.Y()) < theBAS.VPeriod() *0.5));
+ if(theBAS->IsUPeriodic())
+ isSame = (fabs(P1.X() - P2.X()) < theBAS->UPeriod() *0.5);
+ if(theBAS->IsVPeriodic())
+ isSame = (isSame && (fabs(P1.Y() - P2.Y()) < theBAS->VPeriod() *0.5));
return isSame;
//return P1.SquareDistance(P2) < tol * tol; //IFV
}
lf.Remove(itl);
BRep_Builder B;
- BRepAdaptor_Surface BAS(FaceRef, Standard_False);
+ Handle(BRepAdaptor_Surface) BAS = new BRepAdaptor_Surface(FaceRef, Standard_False);
- Standard_Boolean IsPeriodic = BAS.IsUPeriodic() || BAS.IsVPeriodic();
+ Standard_Boolean IsPeriodic = BAS->IsUPeriodic() || BAS->IsVPeriodic();
- tol1 = Max(BAS.UResolution(tol1), BAS.VResolution(tol1));
+ tol1 = Max(BAS->UResolution(tol1), BAS->VResolution(tol1));
if (wfirst.IsSame(wlast)) {
// on cree 2 faces en remplacement de itl.Value()
}
//fin MODIF.
- tol1 = Max(BAS.UResolution(tol1), BAS.VResolution(tol1));
+ tol1 = Max(BAS->UResolution(tol1), BAS->VResolution(tol1));
}
gp_Vec2d v2d;
gp_Pnt aPCur, aPlst;
- BRepAdaptor_Surface surf(F,Standard_False); // no restriction
- surf.D0 (plst.X(), plst.Y(), aPlst);
+ Handle(BRepAdaptor_Surface) surf = new BRepAdaptor_Surface(F,Standard_False); // no restriction
+ surf->D0 (plst.X(), plst.Y(), aPlst);
gp_Dir2d ref2d(dlst);
if(!SameUV(plst,p2d,surf))
continue;
- surf.D0 (p2d.X(), p2d.Y(), aPCur);
+ surf->D0 (p2d.X(), p2d.Y(), aPCur);
if (!Last.IsSame(anEdge)) {
ang = ref2d.Angle(gp_Dir2d(v2d));
// algorithms, for example, Boolean Operations.
Standard_Real aTolVExt[2] = { ext * aTolV[0] * aTolV[0], ext * aTolV[1] * aTolV[1] };
- BRepAdaptor_Curve2d thePCurve(theEdge, theFace);
+ Handle(BRepAdaptor_Curve2d) thePCurve = new BRepAdaptor_Curve2d(theEdge, theFace);
Bnd_Box2d theBox;
BndLib_Add2dCurve::Add(thePCurve, BRep_Tool::Tolerance(theEdge), theBox);
Standard_Real thePar [2];
Standard_Real aFpar, aLpar;
const Handle(Geom_Curve)& theCurve = BRep_Tool::Curve(theEdge, thePar[0], thePar[1]);
- GeomAdaptor_Curve theGAcurve(theCurve, thePar[0], thePar[1]);
- Standard_Real aTolV2d[2] = { theGAcurve.Resolution(aTolV[0]), theGAcurve.Resolution(aTolV[1]) };
+ Handle(GeomAdaptor_Curve) theGAcurve = new GeomAdaptor_Curve(theCurve, thePar[0], thePar[1]);
+ Standard_Real aTolV2d[2] = { theGAcurve->Resolution(aTolV[0]), theGAcurve->Resolution(aTolV[1]) };
aTolV2d[0] = Max(aTolV2d[0], Precision::PConfusion());
aTolV2d[1] = Max(aTolV2d[1], Precision::PConfusion());
Standard_Real aDistMax = Precision::Confusion() * Precision::Confusion();
for (; Explo.More(); Explo.Next())
{
const TopoDS_Edge& anEdge = TopoDS::Edge(Explo.Current());
- BRepAdaptor_Curve2d aPCurve(anEdge, theFace);
+ Handle(BRepAdaptor_Curve2d) aPCurve = new BRepAdaptor_Curve2d(anEdge, theFace);
Bnd_Box2d aBox;
BndLib_Add2dCurve::Add(aPCurve, BRep_Tool::Tolerance(anEdge), aBox);
if (theBox.IsOut(aBox))
continue;
const Handle(Geom_Curve)& aCurve = BRep_Tool::Curve(anEdge, aFpar, aLpar);
- GeomAdaptor_Curve aGAcurve(aCurve, aFpar, aLpar);
+ Handle(GeomAdaptor_Curve) aGAcurve = new GeomAdaptor_Curve(aCurve, aFpar, aLpar);
Extrema_ExtCC anExtrema(theGAcurve, aGAcurve, TolExt, TolExt);
if (!anExtrema.IsDone() || !anExtrema.NbExt())
BRepBndLib::Add(aCurF, aBoxF);
if (aBoxF.IsVoid())
continue;
- BRepAdaptor_Surface anAdF(aCurF, Standard_False);
+ Handle(BRepAdaptor_Surface) anAdF = new BRepAdaptor_Surface(aCurF, Standard_False);
NCollection_Handle<BRepTopAdaptor_FClass2d> aCheckStateTool;
i = 1;
Handle(Geom2dAdaptor_Curve) HC1 = new Geom2dAdaptor_Curve(C1);
Handle(Geom2dAdaptor_Curve) HC2 = new Geom2dAdaptor_Curve(C2);
- Adaptor2d_OffsetCurve OC1(HC1, D, MilC1, C1->LastParameter());
- Adaptor2d_OffsetCurve OC2(HC2, D, C2->FirstParameter(), MilC2);
+ Handle(Adaptor2d_OffsetCurve) OC1 = new Adaptor2d_OffsetCurve(HC1, D, MilC1, C1->LastParameter());
+ Handle(Adaptor2d_OffsetCurve) OC2 = new Adaptor2d_OffsetCurve(HC2, D, C2->FirstParameter(), MilC2);
Geom2dInt_GInter Intersect;
Intersect.Perform(OC1,OC2,Tol,Tol);
}
}
else if (Type1 == STANDARD_TYPE(Geom2d_CartesianPoint)) {
- Geom2dAdaptor_Curve C2(Item2);
+ Handle(Geom2dAdaptor_Curve) C2 = new Geom2dAdaptor_Curve(Item2);
Extrema_ExtPC2d Extremas(P1,C2);
if (Extremas.IsDone()){
for (i = 1; i <= Extremas.NbExt(); i++) {
}
}
else if (Type2 == STANDARD_TYPE(Geom2d_CartesianPoint)) {
- Geom2dAdaptor_Curve C1(Item1);
+ Handle(Geom2dAdaptor_Curve) C1 = new Geom2dAdaptor_Curve(Item1);
Extrema_ExtPC2d Extremas(P2,C1);
if (Extremas.IsDone()){
for (i=1;i<=Extremas.NbExt();i++) {
}
}
else {
- Geom2dAdaptor_Curve C1(Item1);
- Geom2dAdaptor_Curve C2(Item2);
+ Handle(Geom2dAdaptor_Curve) C1 = new Geom2dAdaptor_Curve(Item1);
+ Handle(Geom2dAdaptor_Curve) C2 = new Geom2dAdaptor_Curve(Item2);
Extrema_ExtCC2d Extremas(C1,C2);
if (!Extremas.IsParallel() && Extremas.IsDone()){
for ( i=1; i <= Extremas.NbExt(); i++) {
//---------------------------------------------------------------------
// Constuction de la courbe pour les extremas et ajustement des bornes.
//---------------------------------------------------------------------
- Geom2dAdaptor_Curve C1(Curve);
- GeomAbs_CurveType TypeC1 = C1.GetType();
+ Handle(Geom2dAdaptor_Curve) C1 = new Geom2dAdaptor_Curve(Curve);
+ GeomAbs_CurveType TypeC1 = C1->GetType();
if (TypeC1 == GeomAbs_Circle) {
- Standard_Real R = C1.Circle().Radius();
+ Standard_Real R = C1->Circle().Radius();
Standard_Real EpsCirc = 100.*Eps;
if ( R < 1.) EpsCirc = Eps/R;
if (((ParamMax - ParamMin + 2*EpsCirc) < 2*M_PI)) {
}
else {
if (TypeC1 == GeomAbs_Circle) {
- Distance = C1.Circle().Radius();
+ Distance = C1->Circle().Radius();
}
}
}
gp_Pnt2d FirstPointBisector = Bisector->Value(UB1);
Standard_Real UTrim = Precision::Infinite();
- Geom2dAdaptor_Curve AdapBisector(Bisector);
- Geom2dAdaptor_Curve AdapLine1 (Line1);
+ Handle(Geom2dAdaptor_Curve) AdapBisector = new Geom2dAdaptor_Curve(Bisector);
+ Handle(Geom2dAdaptor_Curve) AdapLine1 = new Geom2dAdaptor_Curve(Line1);
Intersect.Perform(AdapBisector, Domain1,
AdapLine1, Tolerance, Tolerance);
Standard_Real myPerMaxParam;
Standard_Integer myPeriodicDir;
- Adaptor3d_CurveOnSurface* myExtCCCurve1;
+ Handle(Adaptor3d_CurveOnSurface) myExtCCCurve1;
Standard_Real myExtCCLast2DParam;
Extrema_ExtPS *myExtPS;
gp_Pnt P;
P = Seq.Last ();
Seq.Remove (Seq.Length ());
- ProjLib_PrjResolve aPrjPS (*Curve, *Surface, Standard_Integer (P.Z ()));
+ ProjLib_PrjResolve aPrjPS (Curve, Surface, Standard_Integer (P.Z ()));
if (Standard_Integer (P.Z ()) == 2)
{
aPrjPS.Perform (t, P.X (), V0, gp_Pnt2d (Tol, TolV),
gp_Pnt2d POnS;
U0 = Sol.Y();
V0 = Sol.Z();
- ProjLib_PrjResolve aPrjPS (*Curve, *Surface, 1);
+ ProjLib_PrjResolve aPrjPS (Curve, Surface, 1);
Standard_Real aNotSol = NotSol;
while (fabs(Sol.X() - aNotSol) > Tol)
Standard_Real theMaxDist)
{
- ProjLib_PrjResolve aPrjPS (*C, *S, 1);
+ ProjLib_PrjResolve aPrjPS (C, S, 1);
Standard_Real ParU,ParV;
Extrema_ExtPS aExtPS;
- aExtPS.Initialize (*S, S->FirstUParameter(),
+ aExtPS.Initialize (S, S->FirstUParameter(),
S->LastUParameter(), S->FirstVParameter(),
S->LastVParameter(), TolU, TolV);
isSplitsComputed = Standard_False;
const Standard_Real aTolExt = Precision::PConfusion();
- Extrema_ExtCS CExt (*myCurve, *mySurface, aTolExt, aTolExt);
+ Extrema_ExtCS CExt (myCurve, mySurface, aTolExt, aTolExt);
if (CExt.IsDone() && CExt.NbExt())
{
// Search for the minimum solution.
gp_Pnt2d aLowBorder(mySurface->FirstUParameter(),mySurface->FirstVParameter());
gp_Pnt2d aUppBorder(mySurface->LastUParameter(), mySurface->LastVParameter());
gp_Pnt2d aTol(myTolU, myTolV);
- ProjLib_PrjResolve aPrjPS (*myCurve, *mySurface, 1);
+ ProjLib_PrjResolve aPrjPS (myCurve, mySurface, 1);
t = FirstU;
Standard_Boolean new_part;
}
//End of cubic interpolation
- ProjLib_PrjResolve aPrjPS (*myCurve, *mySurface, 1);
+ ProjLib_PrjResolve aPrjPS (myCurve, mySurface, 1);
aPrjPS.Perform(U, U0, V0, gp_Pnt2d(myTolU, myTolV),
gp_Pnt2d(mySurface->FirstUParameter(), mySurface->FirstVParameter()),
gp_Pnt2d(mySurface->LastUParameter(), mySurface->LastVParameter()), FuncTol);
else
{
gp_Pnt thePoint = myCurve->Value(U);
- Extrema_ExtPS aExtPS(thePoint, *mySurface, myTolU, myTolV);
+ Extrema_ExtPS aExtPS(thePoint, mySurface, myTolU, myTolV);
if (aExtPS.IsDone() && aExtPS.NbExt())
{
Standard_Integer k, Nend, imin = 1;
Standard_Real V;
V = (mySequence->Value(i)->Value(j).Z()
+ mySequence->Value(i)->Value(j +1).Z())/2;
- ProjLib_PrjResolve Solver (*myCurve, *mySurface, 2);
+ ProjLib_PrjResolve Solver (myCurve, mySurface, 2);
gp_Vec2d D;
gp_Pnt Triple;
Standard_Real U;
U = (mySequence->Value(i)->Value(j).Y()
+ mySequence->Value(i)->Value(j +1).Y())/2;
- ProjLib_PrjResolve Solver (*myCurve, *mySurface, 3);
+ ProjLib_PrjResolve Solver (myCurve, mySurface, 3);
gp_Vec2d D;
gp_Pnt Triple;
SplitDS aDS(theCurve, theSurface, theSplits);
Extrema_ExtPS anExtPS;
- anExtPS.Initialize(*theSurface,
+ anExtPS.Initialize(theSurface,
theSurface->FirstUParameter(), theSurface->LastUParameter(),
theSurface->FirstVParameter(), theSurface->LastVParameter(),
theTolU, theTolV);
// Create line which is represent periodic border.
Handle(Geom2d_Curve) aC2GC = new Geom2d_Line(aStartPnt, aDir);
Handle(Geom2dAdaptor_Curve) aC = new Geom2dAdaptor_Curve(aC2GC, 0, aLast2DParam);
- Adaptor3d_CurveOnSurface aCOnS(aC, theSplitDS.mySurface);
- theSplitDS.myExtCCCurve1 = &aCOnS;
+ Handle(Adaptor3d_CurveOnSurface) aCOnS = new Adaptor3d_CurveOnSurface(aC, theSplitDS.mySurface);
+ theSplitDS.myExtCCCurve1 = aCOnS;
theSplitDS.myExtCCLast2DParam = aLast2DParam;
FindSplitPoint(theSplitDS,
{
// Make extrema copy to avoid dependencies between different levels of the recursion.
Extrema_ExtCC anExtCC;
- anExtCC.SetCurve(1, *theSplitDS.myExtCCCurve1);
- anExtCC.SetCurve(2, *theSplitDS.myCurve);
+ anExtCC.SetCurve(1, theSplitDS.myExtCCCurve1);
+ anExtCC.SetCurve(2, theSplitDS.myCurve);
anExtCC.SetSingleSolutionFlag (Standard_True); // Search only one solution since multiple invocations are needed.
anExtCC.SetRange(1, 0, theSplitDS.myExtCCLast2DParam);
anExtCC.SetRange(2, theMinParam, theMaxParam);
Standard_Real W1, W2;
W1 = myCurve->FirstParameter();
W2 = myCurve->LastParameter();
- Standard_Real L = GCPnts_AbscissaPoint::Length (*myCurve);
+ Standard_Real L = GCPnts_AbscissaPoint::Length (myCurve);
Standard_Integer nbp = RealToInt(L / (R*M_PI_4)) + 1;
nbp = Max(nbp, 3);
Standard_Real Step = (W2 - W1) / (nbp - 1);
// Param space may be reduced in case of rectangular trimmed surface,
// in this case really trimmed bounds should be set as unperiodic.
Standard_Real aTrimF, aTrimL, aBaseF, aBaseL, aDummyF, aDummyL;
- Handle(Geom_Surface) aS = GeomAdaptor::MakeSurface (*theSurf, Standard_False); // Not trim.
+ Handle(Geom_Surface) aS = GeomAdaptor::MakeSurface (theSurf, Standard_False); // Not trim.
// U param space.
if (theSurf->IsUPeriodic())
{
if((Usup - U0) > uLittle) uSupLi = U0 + uLittle; else uSupLi = Usup;
if((Vsup - V0) > vLittle) vSupLi = V0 + vLittle; else vSupLi = Vsup;
- GeomAdaptor_Surface SurfLittle;
+ Handle(GeomAdaptor_Surface) SurfLittle = new GeomAdaptor_Surface;
if (Type == GeomAbs_BSplineSurface)
{
Handle(Geom_Surface) GBSS(theData.mySurf->BSpline());
- SurfLittle.Load(GBSS, uInfLi, uSupLi, vInfLi, vSupLi);
+ SurfLittle->Load(GBSS, uInfLi, uSupLi, vInfLi, vSupLi);
}
else if (Type == GeomAbs_BezierSurface)
{
Handle(Geom_Surface) GS(theData.mySurf->Bezier());
- SurfLittle.Load(GS, uInfLi, uSupLi, vInfLi, vSupLi);
+ SurfLittle->Load(GS, uInfLi, uSupLi, vInfLi, vSupLi);
}
else if (Type == GeomAbs_OffsetSurface)
{
- Handle(Geom_Surface) GS = GeomAdaptor::MakeSurface (*theData.mySurf);
- SurfLittle.Load(GS, uInfLi, uSupLi, vInfLi, vSupLi);
+ Handle(Geom_Surface) GS = GeomAdaptor::MakeSurface (theData.mySurf);
+ SurfLittle->Load(GS, uInfLi, uSupLi, vInfLi, vSupLi);
}
else
{
//Standard_Real Tol3d = 100*myTolerance; // At random Balthazar.
Standard_Integer NbOfPnts = 61;
- GCPnts_QuasiUniformAbscissa QUA (*Curve,NbOfPnts);
+ GCPnts_QuasiUniformAbscissa QUA (Curve, NbOfPnts);
NbOfPnts = QUA.NbPoints();
TColgp_Array1OfPnt Pts(1,NbOfPnts);
TColStd_Array1OfReal Param(1,NbOfPnts);
Standard_Boolean areManyZeros = Standard_False;
pntproj = Pts(1);
- Extrema_ExtPS aExtPS(pntproj, *Surf, TolU, TolV) ;
+ Extrema_ExtPS aExtPS(pntproj, Surf, TolU, TolV) ;
Standard_Real aMinSqDist = RealLast();
if (aExtPS.IsDone())
{
{
TolU = Min(TolU, Precision::PConfusion());
TolV = Min(TolV, Precision::PConfusion());
- aExtPS.Initialize(*Surf,
+ aExtPS.Initialize(Surf,
Surf->FirstUParameter(), Surf->LastUParameter(),
Surf->FirstVParameter(), Surf->LastVParameter(),
TolU, TolV);
Standard_Integer indExt = 0;
Standard_Integer iT = 1 + (NbOfPnts - 1)/5*i;
pntproj = Pts(iT);
- Extrema_ExtPS aTPS( pntproj, *Surf, TolU, TolV );
+ Extrema_ExtPS aTPS( pntproj, Surf, TolU, TolV );
Dist2Min = 1.e+200;
if( aTPS.IsDone() && aTPS.NbExt() >= 1 ) {
for( j = 1 ; j <= aTPS.NbExt() ; j++ ) {
for (j = tPp + 1; j <= NbOfPnts; ++j)
{
pntproj = Pts(j);
- Extrema_ExtPS aTPS( pntproj, *Surf, TolU, TolV );
+ Extrema_ExtPS aTPS( pntproj, Surf, TolU, TolV );
Dist2Min = RealLast();
if( aTPS.IsDone() && aTPS.NbExt() >= 1 ) {
Standard_Integer indExt = 0;
myProjIsDone = Standard_False;
Dist2Min = RealLast();
pntproj = Pts(i);
- Extrema_GenLocateExtPS aLocateExtPS (*Surf, TolU, TolV);
+ Extrema_GenLocateExtPS aLocateExtPS (Surf, TolU, TolV);
aLocateExtPS.Perform(pntproj, U0, V0);
if (aLocateExtPS.IsDone())
}
else
{
- Extrema_ExtPS aGlobalExtr(pntproj, *Surf, TolU, TolV);
+ Extrema_ExtPS aGlobalExtr(pntproj, Surf, TolU, TolV);
if (aGlobalExtr.IsDone())
{
Standard_Real LocalMinSqDist = RealLast();
else
Uaux = 2*aUsup - U0 - uperiod;
- Extrema_GenLocateExtPS locext (*Surf, TolU, TolV);
+ Extrema_GenLocateExtPS locext (Surf, TolU, TolV);
locext.Perform(pntproj, Uaux, V0);
if (locext.IsDone())
else
Vaux = 2*aVsup - V0 - vperiod;
- Extrema_GenLocateExtPS locext (*Surf, TolU, TolV);
+ Extrema_GenLocateExtPS locext (Surf, TolU, TolV);
locext.Perform(pntproj, U0, Vaux);
if (locext.IsDone())
else
Vaux = 2*Vsup - V0 - vperiod;
- Extrema_GenLocateExtPS locext (*Surf, TolU, TolV);
+ Extrema_GenLocateExtPS locext (Surf, TolU, TolV);
locext.Perform(pntproj, Uaux, Vaux);
if (locext.IsDone())
}
}
if(!myProjIsDone) {
- Extrema_ExtPS ext(pntproj, *Surf, TolU, TolV) ;
+ Extrema_ExtPS ext(pntproj, Surf, TolU, TolV) ;
if (ext.IsDone()) {
Dist2Min = ext.SquareDistance(1);
Standard_Integer aGoodValue = 1;
myProjIsDone = Standard_False;
Dist2Min = IntegerLast();
- Extrema_GenLocateExtPS extrloc (*Surf, TolU, TolV);
+ Extrema_GenLocateExtPS extrloc (Surf, TolU, TolV);
extrloc.Perform(BSC->Pole(i), (p11.X()+p22.X())/2, (p11.Y()+p22.Y())/2);
if (extrloc.IsDone()) {
for(i = 1;i <= Curve->NbPoles();i++) {
Dist2Min = IntegerLast();
- Extrema_GenLocateExtPS extrloc (*Surf, TolU, TolV);
+ Extrema_GenLocateExtPS extrloc (Surf, TolU, TolV);
extrloc.Perform(BC->Pole(i), 0.5, 0.5);
if (extrloc.IsDone()) {
myProjIsDone = Standard_False;
Dist2Min = IntegerLast();
- Extrema_GenLocateExtPS extrloc (*Surf, TolU, TolV);
+ Extrema_GenLocateExtPS extrloc (Surf, TolU, TolV);
extrloc.Perform(BSC->Pole(i), (p11.X()+p22.X())/2, (p11.Y()+p22.Y())/2);
if (extrloc.IsDone()) {
for(i = 1;i <= Curve->NbPoles();i++) {
Dist2Min = IntegerLast();
- Extrema_GenLocateExtPS extrloc (*Surf, TolU, TolV);
+ Extrema_GenLocateExtPS extrloc (Surf, TolU, TolV);
extrloc.Perform(BC->Pole(i), 0.5, 0.5);
if (extrloc.IsDone()) {
#include <ProjLib_PrjFunc.hxx>
#include <Standard_ConstructionError.hxx>
-ProjLib_PrjFunc::ProjLib_PrjFunc (const Adaptor3d_Curve* C, const Standard_Real FixVal, const Adaptor3d_Surface* S, const Standard_Integer Fix)
+ProjLib_PrjFunc::ProjLib_PrjFunc (const Handle(Adaptor3d_Curve) C, const Standard_Real FixVal, const Handle(Adaptor3d_Surface) S, const Standard_Integer Fix)
: myCurve(C), mySurface(S), myt(0), myU(0), myV(0), myFix(Fix)
{
myNorm=Min(1.,Min(mySurface->UResolution(1.),mySurface->VResolution(1.)));
DEFINE_STANDARD_ALLOC
- Standard_EXPORT ProjLib_PrjFunc(const Adaptor3d_Curve* C, const Standard_Real FixVal, const Adaptor3d_Surface* S, const Standard_Integer Fix);
+ Standard_EXPORT ProjLib_PrjFunc(const Handle(Adaptor3d_Curve) C, const Standard_Real FixVal, const Handle(Adaptor3d_Surface) S, const Standard_Integer Fix);
//! returns the number of variables of the function.
Standard_EXPORT Standard_Integer NbVariables() const;
private:
- const Adaptor3d_Curve* myCurve;
- const Adaptor3d_Surface* mySurface;
+ const Handle(Adaptor3d_Curve) myCurve;
+ const Handle(Adaptor3d_Surface) mySurface;
Standard_Real myt;
Standard_Real myU;
Standard_Real myV;
#include <Standard_ConstructionError.hxx>
#include <StdFail_NotDone.hxx>
-ProjLib_PrjResolve::ProjLib_PrjResolve(const Adaptor3d_Curve& C,const Adaptor3d_Surface& S,const Standard_Integer Fix)
-: myDone(Standard_False),
+ProjLib_PrjResolve::ProjLib_PrjResolve(const Handle(Adaptor3d_Curve)& C, const Handle(Adaptor3d_Surface)& S, const Standard_Integer Fix)
+: myCurve(C),
+ mySurface(S),
+ myDone(Standard_False),
myFix(Fix)
{
if (myFix > 3 || myFix < 1) throw Standard_ConstructionError();
mySolution = gp_Pnt2d(0.,0.);
- myCurve = &C;
- mySurface = &S;
}
// void ProjLib_PrjResolve::Perform(const Standard_Real t, const Standard_Real U, const Standard_Real V, const gp_Pnt2d& Tol2d, const gp_Pnt2d& Inf, const gp_Pnt2d& Sup, const Standard_Real FuncTol, const Standard_Boolean StrictInside)
DEFINE_STANDARD_ALLOC
- Standard_EXPORT ProjLib_PrjResolve(const Adaptor3d_Curve& C, const Adaptor3d_Surface& S, const Standard_Integer Fix);
+ Standard_EXPORT ProjLib_PrjResolve(const Handle(Adaptor3d_Curve)& C, const Handle(Adaptor3d_Surface)& S, const Standard_Integer Fix);
//! Calculates the ort from C(t) to S with a close point.
//! The close point is defined by the parameter values U0 and V0.
private:
- const Adaptor3d_Curve* myCurve;
- const Adaptor3d_Surface* mySurface;
+ const Handle(Adaptor3d_Curve) myCurve;
+ const Handle(Adaptor3d_Surface) mySurface;
Standard_Boolean myDone;
gp_Pnt2d mySolution;
Standard_Integer myFix;
{
public:
- ProjLib_OnSurface(const Handle(Adaptor3d_Curve) & C,
- const Handle(Adaptor3d_Surface) & S)
+ ProjLib_OnSurface(const Handle(Adaptor3d_Curve) &C,
+ const Handle(Adaptor3d_Surface) &S)
: myCurve(C)
{
myNbPnt = 1;
Standard_Real U = myCurve->FirstParameter();
gp_Pnt P = myCurve->Value(U);
Standard_Real Tol = Precision::PConfusion();
- myExtPS = new Extrema_ExtPS (P, *S, Tol, Tol);
+ myExtPS = new Extrema_ExtPS (P, S, Tol, Tol);
}
~ProjLib_OnSurface() { delete myExtPS; }
//purpose :
//=======================================================================
-static Standard_Boolean IsoIsDeg (const Adaptor3d_Surface& S,
+static Standard_Boolean IsoIsDeg (const Handle(Adaptor3d_Surface)& S,
const Standard_Real Param,
const GeomAbs_IsoType IT,
const Standard_Real TolMin,
{
Standard_Real U1=0.,U2=0.,V1=0.,V2=0.,T;
Standard_Boolean Along = Standard_True;
- U1 = S.FirstUParameter();
- U2 = S.LastUParameter();
- V1 = S.FirstVParameter();
- V2 = S.LastVParameter();
+ U1 = S->FirstUParameter();
+ U2 = S->LastUParameter();
+ V1 = S->FirstVParameter();
+ V2 = S->LastVParameter();
gp_Vec D1U,D1V;
gp_Pnt P;
Standard_Real Step,D1NormMax;
D1NormMax=0.;
for (T=U1;T<=U2;T=T+Step)
{
- S.D1(T,Param,P,D1U,D1V);
+ S->D1(T,Param,P,D1U,D1V);
D1NormMax=Max(D1NormMax,D1U.Magnitude());
}
D1NormMax=0.;
for (T=V1;T<=V2;T=T+Step)
{
- S.D1(Param,T,P,D1U,D1V);
+ S->D1(Param,T,P,D1U,D1V);
D1NormMax=Max(D1NormMax,D1V.Magnitude());
}
l = myCurve->LastParameter();
dt = (l - f) * eps;
- const Adaptor3d_Surface& S = *mySurface;
- U1 = S.FirstUParameter();
- U2 = S.LastUParameter();
- V1 = S.FirstVParameter();
- V2 = S.LastVParameter();
+ U1 = mySurface->FirstUParameter();
+ U2 = mySurface->LastUParameter();
+ V1 = mySurface->FirstVParameter();
+ V2 = mySurface->LastVParameter();
- if(IsoIsDeg(S, U1, GeomAbs_IsoU, 0., myTolerance))
+ if(IsoIsDeg(mySurface, U1, GeomAbs_IsoU, 0., myTolerance))
{
//Surface has pole at U = Umin
gp_Pnt Pole = mySurface->Value(U1, V1);
TrimC3d(myCurve, IsTrimmed, dt, Pole, SingularCase, 1, TolConf);
}
- if(IsoIsDeg(S, U2, GeomAbs_IsoU, 0., myTolerance))
+ if(IsoIsDeg(mySurface, U2, GeomAbs_IsoU, 0., myTolerance))
{
//Surface has pole at U = Umax
gp_Pnt Pole = mySurface->Value(U2, V1);
TrimC3d(myCurve, IsTrimmed, dt, Pole, SingularCase, 2, TolConf);
}
- if(IsoIsDeg(S, V1, GeomAbs_IsoV, 0., myTolerance))
+ if(IsoIsDeg(mySurface, V1, GeomAbs_IsoV, 0., myTolerance))
{
//Surface has pole at V = Vmin
gp_Pnt Pole = mySurface->Value(U1, V1);
TrimC3d(myCurve, IsTrimmed, dt, Pole, SingularCase, 3, TolConf);
}
- if(IsoIsDeg(S, V2, GeomAbs_IsoV, 0., myTolerance))
+ if(IsoIsDeg(mySurface, V2, GeomAbs_IsoV, 0., myTolerance))
{
//Surface has pole at V = Vmax
gp_Pnt Pole = mySurface->Value(U1, V2);
f = f + dt;
myCurve = myCurve->Trim(f, l, Precision::Confusion());
// Searching the parameter on the basis curve for surface of revolution
- Extrema_ExtPC anExtr(P, *mySurface->BasisCurve(), myTolerance);
+ Extrema_ExtPC anExtr(P, mySurface->BasisCurve(), myTolerance);
if (anExtr.IsDone())
{
Standard_Real aMinDist = RealLast();
l = l - dt;
myCurve = myCurve->Trim(f, l, Precision::Confusion());
// Searching the parameter on the basis curve for surface of revolution
- Extrema_ExtPC anExtr(P, *mySurface->BasisCurve(), myTolerance);
+ Extrema_ExtPC anExtr(P, mySurface->BasisCurve(), myTolerance);
if (anExtr.IsDone())
{
Standard_Real aMinDist = RealLast();
Standard_Boolean& theIsInfinite)
{
BRepAdaptor_Curve anAdaptor (theEdge);
- theCurve = Handle(Geom_Curve)::DownCast (anAdaptor.Curve().Curve()->Transformed (anAdaptor.Trsf()));
+ theCurve = Handle(Geom_Curve)::DownCast (anAdaptor.Curve()->Curve()->Transformed (anAdaptor.Trsf()));
if (theCurve.IsNull())
{
return Standard_False;
}
BRepAdaptor_Curve aCurveAdaptor (theEdge);
- theCurve = Handle(Geom_Curve)::DownCast (aCurveAdaptor.Curve().Curve()->Transformed (aCurveAdaptor.Trsf()));
+ theCurve = Handle(Geom_Curve)::DownCast (aCurveAdaptor.Curve()->Curve()->Transformed (aCurveAdaptor.Trsf()));
if (theCurve.IsNull())
{
return Standard_False;
BRepAdaptor_Curve aSecondAdaptor (theSecondEdge);
theFirstCurve = Handle(Geom_Curve)::DownCast
- (aFirstAdaptor.Curve().Curve()->Transformed (aFirstAdaptor.Trsf()));
+ (aFirstAdaptor.Curve()->Curve()->Transformed (aFirstAdaptor.Trsf()));
theSecondCurve = Handle(Geom_Curve)::DownCast
- (aSecondAdaptor.Curve().Curve()->Transformed (aSecondAdaptor.Trsf()));
+ (aSecondAdaptor.Curve()->Curve()->Transformed (aSecondAdaptor.Trsf()));
if (theFirstCurve->IsInstance (STANDARD_TYPE (Geom_TrimmedCurve)))
{
else
surf2 = new BRepAdaptor_Surface( surf1 );
- aSurf = surf1.Surface().Surface();
+ aSurf = surf1.Surface()->Surface();
// aSurf->Transform(surf1.Trsf()) ;
aSurf = Handle( Geom_Surface )::DownCast( aSurf->Transformed( surf1.Trsf() ) );
// generate points with specified deflection
const Handle(Geom_TrimmedCurve)& anArcCurve = aConstructArc.Value();
- GeomAdaptor_Curve anArcAdaptor (anArcCurve, anArcCurve->FirstParameter(), anArcCurve->LastParameter());
+ Handle(GeomAdaptor_Curve) anArcAdaptor = new GeomAdaptor_Curve(anArcCurve, anArcCurve->FirstParameter(), anArcCurve->LastParameter());
// compute number of discretization elements in old-fanshioned way
gp_Vec aCenterToFirstVec (theCenter, theFirstAttach);
// load data into arrays
for (Standard_Integer aPntIt = 1; aPntIt <= aMakePnts.NbPoints(); ++aPntIt)
{
- gp_Pnt aPnt = anArcAdaptor.Value (aMakePnts.Parameter (aPntIt));
+ gp_Pnt aPnt = anArcAdaptor->Value (aMakePnts.Parameter (aPntIt));
aPrimSegments->AddVertex (aPnt);
}
else if (aCurve.GetType() == GeomAbs_Circle)
{
- Handle(Geom_Circle) aCircle = Handle(Geom_Circle)::DownCast(aCurve.Curve().Curve());
+ Handle(Geom_Circle) aCircle = Handle(Geom_Circle)::DownCast(aCurve.Curve()->Curve());
Standard_Real FirstPar = ElCLib::Parameter(aCircle->Circ(), myAttachPoint1),
LastPar = ElCLib::Parameter(aCircle->Circ(), myPoint1);
if (LastPar < FirstPar ) LastPar += M_PI * 2;
}
else if (aCurve.GetType() == GeomAbs_Circle)
{
- Handle(Geom_Circle) aCircle = Handle(Geom_Circle)::DownCast(aCurve.Curve().Curve());
+ Handle(Geom_Circle) aCircle = Handle(Geom_Circle)::DownCast(aCurve.Curve()->Curve());
Standard_Real FirstPar = ElCLib::Parameter(aCircle->Circ(), myAttachPoint2),
LastPar = ElCLib::Parameter(aCircle->Circ(), myPoint2);
if (LastPar < FirstPar) LastPar += M_PI * 2;
}
else if (aCurve.GetType() == GeomAbs_Circle)
{
- Handle(Geom_Circle) aCircle = Handle(Geom_Circle)::DownCast(aCurve.Curve().Curve());
+ Handle(Geom_Circle) aCircle = Handle(Geom_Circle)::DownCast(aCurve.Curve()->Curve());
Standard_Real FirstPar = ElCLib::Parameter(aCircle->Circ(), myAttachPoint3),
LastPar = ElCLib::Parameter(aCircle->Circ(), myPoint3);
if (LastPar < FirstPar) LastPar += M_PI * 2;
}
else if (aCurve.GetType() == GeomAbs_Circle)
{
- Handle(Geom_Circle) aCircle = Handle(Geom_Circle)::DownCast(aCurve.Curve().Curve());
+ Handle(Geom_Circle) aCircle = Handle(Geom_Circle)::DownCast(aCurve.Curve()->Curve());
Standard_Real FirstPar = ElCLib::Parameter(aCircle->Circ(), myAttachPoint4),
LastPar = ElCLib::Parameter(aCircle->Circ(), myPoint4);
if (LastPar < FirstPar) LastPar += M_PI * 2;
Standard_Real FirstPar1 = FirstCurve.FirstParameter(), LastPar1 = FirstCurve.LastParameter(),
FirstPar2 = SecondCurve.FirstParameter(), LastPar2 = SecondCurve.LastParameter();
- Handle( Geom_Curve ) FirstProjCurve = FirstCurve.Curve().Curve(),
- SecondProjCurve = SecondCurve.Curve().Curve();
+ Handle( Geom_Curve ) FirstProjCurve = FirstCurve.Curve()->Curve(),
+ SecondProjCurve = SecondCurve.Curve()->Curve();
gp_Pnt FirstPoint1, LastPoint1, FirstPoint2, LastPoint2;
Standard_Boolean isFirstOnPlane, isSecondOnPlane;
Standard_Real uf, ul, vf, vl;
GS->Bounds(uf, ul, vf, vl);
- GeomAdaptor_Surface aSurf(GS);
+ Handle(GeomAdaptor_Surface) aSurf = new GeomAdaptor_Surface(GS);
myExtPS.Initialize (aSurf, uf-du, ul+du, vf-dv, vl+dv, Tol, Tol );
myExtPS.Perform ( P3D );
Standard_Integer nPSurf = ( myExtPS.IsDone() ? myExtPS.NbExt() : 0 );
distMin = sqrt(distMin);
Standard_Real S, T;
myExtPS.Point(indMin).Parameter ( S, T );
- gp_Pnt aCheckPnt = aSurf.Value( S, T );
+ gp_Pnt aCheckPnt = aSurf->Value( S, T );
Standard_Real aCheckDist = P3D.Distance(aCheckPnt);
di << "Solution is : U = "<< S << "\t V = "<< T << "\n";
di << "Solution is : X = "<< aCheckPnt.X() << "\t Y = "<< aCheckPnt.Y() << "\t Z = "<< aCheckPnt.Z() << "\n";
Standard_Integer i=0;
for( ; ex.More(); ex.Next()){
const TopoDS_Edge &E = TopoDS::Edge(ex.Current());
- BRepAdaptor_Curve aCurve(E);
+ Handle(BRepAdaptor_Curve) aCurve = new BRepAdaptor_Curve(E);
GCPnts_UniformDeflection plin(aCurve, 0.1);
di << "Num points = " << plin.NbPoints() << "\n";
if(argc > 2) {
vlast = ve1;
}
- GeomAdaptor_Curve curve;
+ Handle(GeomAdaptor_Curve) curve = new GeomAdaptor_Curve(acurve);
GCPnts_UniformAbscissa algo;
- curve.Load(acurve);
algo.Initialize( curve, l, newufirst, newulast );
if (!algo.IsDone())
di << "Not Done!!!" << "\n";
for (Standard_Integer Index = 1; Index<=algo.NbPoints();Index++) {
Standard_Real t = algo.Parameter(Index);
- gp_Pnt pt3 = curve.Value(t);
+ gp_Pnt pt3 = curve->Value(t);
di << "Parameter t = " << t << "\n";
di << "Value Pnt = " << pt3.X()<<" " <<pt3.Y()<<" " << pt3.Z() << "\n";
}
return 1;
}
const char *name = argv[1];
- Adaptor3d_Curve *adapCurve=NULL;
+ Handle(Adaptor3d_Curve) adapCurve;
Handle(Geom_Curve) curve = DrawTrSurf::GetCurve(argv[2]);
if (!curve.IsNull())
adapCurve = new GeomAdaptor_Curve(curve);
adapCurve = new BRepAdaptor_CompCurve(TopoDS::Wire(wire));
}
double step = Draw::Atof(argv[3]);
- GCPnts_UniformAbscissa aUni(*adapCurve, step);
+ GCPnts_UniformAbscissa aUni(adapCurve, step);
int res;
if (!aUni.IsDone())
{
}
res = 0;
}
- delete adapCurve;
return res;
}
gp_Pnt pnt;
curve.D0(need_length,pnt);
// create check_curve parameterised in a general way
- BRepAdaptor_CompCurve check_curve(wire);
+ Handle(BRepAdaptor_CompCurve) check_curve = new BRepAdaptor_CompCurve(wire);
Standard_Real check_par =
GCPnts_AbscissaPoint(check_curve, need_length, 0).Parameter();
gp_Pnt check_pnt;
- check_curve.D0(check_par,check_pnt);
+ check_curve->D0(check_par,check_pnt);
// check that points are coinciding
Standard_Real error_dist = pnt.Distance(check_pnt);
if (error_dist > Precision::Confusion()) {
//length!! 1.
Standard_Real l_abcissa,l_gprop;
- GeomAdaptor_Curve adaptor_spline(spline);
+ Handle(GeomAdaptor_Curve) adaptor_spline = new GeomAdaptor_Curve(spline);
GCPnts_AbscissaPoint temp;
l_abcissa=temp.Length(adaptor_spline);
std::cout<<"Length Spline(abcissa_Pnt): "<<l_abcissa<<std::endl;
Sprintf(abuf,"curve");
DrawTrSurf::Set (st, aCurve);
- Geom2dAdaptor_Curve aCLine(aLine);
- Geom2dAdaptor_Curve aCCurve(aCurve);
+ Handle(Geom2dAdaptor_Curve) aCLine = new Geom2dAdaptor_Curve(aLine);
+ Handle(Geom2dAdaptor_Curve) aCCurve = new Geom2dAdaptor_Curve(aCurve);
Geom2dGcc_QualifiedCurve aQualifCurve1(aCLine, GccEnt_outside);
Geom2dGcc_QualifiedCurve aQualifCurve2(aCCurve, GccEnt_outside);
Geom2dGcc_Circ2d2TanRad aGccCirc2d(aQualifCurve1, aQualifCurve2, 10, 1e-7);
aContext->Display (aisp, Standard_False);
}
- Geom2dAdaptor_Curve acur (curve2d), afromcur (fromcurve2d);
+ Handle(Geom2dAdaptor_Curve) acur = new Geom2dAdaptor_Curve(curve2d);
+ Handle(Geom2dAdaptor_Curve) afromcur = new Geom2dAdaptor_Curve(fromcurve2d);
Geom2dGcc_QualifiedCurve qcur (acur, GccEnt_outside);
Geom2dGcc_QualifiedCurve qfromcur (afromcur, GccEnt_outside);
Geom2dGcc_Lin2d2Tan lintan (qcur, qfromcur, 0.1, 0.0, 0.0);
if (argc == 6) tol = Draw::Atof(argv[5]);
}
if(c1IsCircle) {
- Geom2dAdaptor_Curve acur(aCur2d2);
+ Handle(Geom2dAdaptor_Curve) acur = new Geom2dAdaptor_Curve(aCur2d2);
Geom2dGcc_QCurve qcur(acur, GccEnt_unqualified);
GccEnt_QualifiedCirc qfromcur(aCir2d->Circ2d(), GccEnt_unqualified);
Geom2dGcc_Lin2d2TanIter lintan(qfromcur, qcur , par1, tol);
}
}
else {
- Geom2dAdaptor_Curve acur1(aCur2d1);
- Geom2dAdaptor_Curve acur2(aCur2d2);
+ Handle(Geom2dAdaptor_Curve) acur1 = new Geom2dAdaptor_Curve(aCur2d1);
+ Handle(Geom2dAdaptor_Curve) acur2 = new Geom2dAdaptor_Curve(aCur2d2);
Geom2dGcc_QCurve qcur1(acur1, GccEnt_unqualified);
Geom2dGcc_QCurve qcur2(acur2, GccEnt_unqualified);
Geom2dGcc_Lin2d2TanIter lintan(qcur1, qcur2 , par1, par2, tol);
{
int ret = 0;
Handle(Geom_Plane) gpln = new Geom_Plane(pln);
- GeomAdaptor_Surface adsur(gpln);
+ Handle(GeomAdaptor_Surface) adsur = new GeomAdaptor_Surface(gpln);
Extrema_ExtPS extps(pnt3d, adsur, 0.001, 0.001);
if( extps.IsDone() )
{
Handle(Geom2d_Curve) cir2d1 = GeomAPI::To2d(h_cir1, refpln);
Handle(Geom2d_Curve) cir2d2 = GeomAPI::To2d(h_cir2, refpln);
- Geom2dAdaptor_Curve adop1(cir2d1);
- Geom2dAdaptor_Curve adop2(cir2d2);
+ Handle(Geom2dAdaptor_Curve) adop1 = new Geom2dAdaptor_Curve(cir2d1);
+ Handle(Geom2dAdaptor_Curve) adop2 = new Geom2dAdaptor_Curve(cir2d2);
Geom2dGcc_QualifiedCurve qcur1(adop1, GccEnt_enclosing);
Geom2dGcc_QualifiedCurve qcur2(adop2, GccEnt_enclosing);
str = "OCC813_pnt"; DrawTrSurf::Set(str,pt2d);
Handle(Geom2d_Curve) curve2d = GeomAPI::To2d(ell,pln);
- Geom2dAdaptor_Curve acur(curve2d);
+ Handle(Geom2dAdaptor_Curve) acur = new Geom2dAdaptor_Curve(curve2d);
Geom2dGcc_QualifiedCurve qcur(acur, GccEnt_outside);
str = "OCC813_ell"; DrawTrSurf::Set(str,curve2d);
aContext->Display (aisp, Standard_False);
}
- Geom2dAdaptor_Curve acur(curve2d), afromcur(fromcurve2d);
+ Handle(Geom2dAdaptor_Curve) acur = new Geom2dAdaptor_Curve(curve2d);
+ Handle(Geom2dAdaptor_Curve) afromcur = new Geom2dAdaptor_Curve(fromcurve2d);
Geom2dGcc_QualifiedCurve qcur(acur, GccEnt_outside) ;
Geom2dGcc_QualifiedCurve qfromcur(afromcur, GccEnt_outside) ;
vlast = ve1;
}
- GeomAdaptor_Curve curve;
+ Handle(GeomAdaptor_Curve) curve = new GeomAdaptor_Curve(acurve);
GCPnts_UniformAbscissa algo;
- curve.Load(acurve);
algo.Initialize( curve, l, newufirst, newulast );
if (!algo.IsDone())
di << "Not Done!!!" << "\n";
Standard_Integer maxIndex =algo.NbPoints();
for (Standard_Integer Index = 1; Index<=maxIndex;Index++) {
Standard_Real t = algo.Parameter(Index);
- gp_Pnt pt3 = curve.Value(t);
+ gp_Pnt pt3 = curve->Value(t);
di << "Parameter t = " << t << "\n";
di << "Value Pnt = " << pt3.X()<<" " <<pt3.Y()<<" " << pt3.Z() << "\n";
if (EdgeIndex == 1 && Index == maxIndex) {
gp_Pnt aP3D( -1725.97, 843.257, -4.22741e-013 );
gp_Ax2 aAxis( gp_Pnt( 0, 843.257, 0 ), gp_Dir( 0, -1, 0 ), gp::DX() );
Handle(Geom_Circle) aCircle = new Geom_Circle( aAxis, 1725.9708621929999 );
- GeomAdaptor_Curve aC3D( aCircle );
+ Handle(GeomAdaptor_Curve) aC3D = new GeomAdaptor_Curve( aCircle );
Extrema_ExtPC aExtPC( aP3D, aC3D );
//Standard_Real aParam = (aExtPC.Point(1)).Parameter();
}
const TopoDS_Face aFace = TopoDS::Face (aShapeF);
const TopoDS_Vertex aVert = TopoDS::Vertex (aShapeV);
- GeomAdaptor_Surface aSurf (BRep_Tool::Surface (aFace));
+ Handle(GeomAdaptor_Surface) aSurf = new GeomAdaptor_Surface(BRep_Tool::Surface (aFace));
gp_Pnt aPnt = BRep_Tool::Pnt (aVert), aRes;
theDI << aRoot.Root()(1) << " " << aRoot.Root()(2) << "\n";
- aSurf.D0 (aRoot.Root()(1), aRoot.Root()(2), aRes);
+ aSurf->D0 (aRoot.Root()(1), aRoot.Root()(2), aRes);
DBRep::Set ("result", BRepBuilderAPI_MakeVertex (aRes));
return 0;
}
Handle(Geom_Circle) aCircle = new Geom_Circle(gp_Ax2(gp::Origin(), gp::DZ()), 10);
Handle(Geom_TrimmedCurve) aHalf = new Geom_TrimmedCurve(aCircle, aFirstP, aLastP);
TopoDS_Edge aEdge = BRepBuilderAPI_MakeEdge(aHalf);
- BRepAdaptor_Curve aAdaptor(aEdge);
+ Handle(BRepAdaptor_Curve) aAdaptor = new BRepAdaptor_Curve(aEdge);
BRepMesh_GeomTool aGeomTool(aAdaptor, aFirstP, aLastP, 0.1, 0.5);
if (aGeomTool.NbPoints() == 0)
gp_Pnt2d aUV;
if (!DrawTrSurf::GetPoint2d(theArgVal[3], aUV))
return 1;
- BRepAdaptor_Surface aSurf(aFace);
+ Handle(BRepAdaptor_Surface) aSurf = new BRepAdaptor_Surface(aFace);
Standard_Real aTolU = Precision::PConfusion();
Standard_Real aTolV = Precision::PConfusion();
aCurve1->D1(u,aP1,aTangent);
gp_Vec2d aNormal(-aTangent.Y(),aTangent.X());
Handle(Geom2d_Line) normalLine=new Geom2d_Line(aP1, gp_Dir2d(aNormal));
- Geom2dGcc_QualifiedCurve qualifiedC1(Geom2dAdaptor_Curve(aCurve1),GccEnt_unqualified);
- Geom2dGcc_QualifiedCurve qualifiedC2(Geom2dAdaptor_Curve(aCurve2),GccEnt_unqualified);
+ Geom2dGcc_QualifiedCurve qualifiedC1(new Geom2dAdaptor_Curve(aCurve1),GccEnt_unqualified);
+ Geom2dGcc_QualifiedCurve qualifiedC2(new Geom2dAdaptor_Curve(aCurve2),GccEnt_unqualified);
try
{
Geom2dAPI_ProjectPointOnCurve projPc3(aP1, normalLine);
double g3 = projPc3.LowerDistanceParameter();
Geom2dGcc_Circ2d2TanOn aCircleBuilder(qualifiedC1,qualifiedC2,
- Geom2dAdaptor_Curve(normalLine),1e-9,g1,g1,g3);
+ new Geom2dAdaptor_Curve(normalLine),1e-9,g1,g1,g3);
aDuumyList.Append(aCircleBuilder.NbSolutions());
}
catch(Standard_Failure const&)
{
Standard_Real firstParam = 0., lastParam = 0.;
Handle(Geom_Curve) pCurve = BRep_Tool::Curve(anEdge, firstParam, lastParam);
- GeomAdaptor_Curve curveAdaptor(pCurve, firstParam, lastParam);
+ Handle(GeomAdaptor_Curve) curveAdaptor = new GeomAdaptor_Curve(pCurve, firstParam, lastParam);
GCPnts_UniformDeflection uniformAbs(curveAdaptor, 0.001, firstParam, lastParam);
}
// local_get_2Dpointfrom3Dpoint(pt3d, pln->Pln(), thepoint);
thepoint = ProjLib::Project(pln->Pln(),pt3d);
Handle(Geom2d_CartesianPoint) ThePoint = new Geom2d_CartesianPoint(thepoint);
- Geom2dAdaptor_Curve acur1(gcir1) ;
+ Handle(Geom2dAdaptor_Curve) acur1 = new Geom2dAdaptor_Curve(gcir1) ;
Geom2dGcc_QualifiedCurve qcur1(acur1, GccEnt_outside) ;
Geom2dGcc_Circ2d2TanRad cirtanrad(qcur1, ThePoint, 200.0, 0.0001);
printf("\n No. of solutions = %d\n", cirtanrad.NbSolutions());
//Calculate the tangent with Geom2dGcc_Circ2dTanRan
- const Geom2dAdaptor_Curve AdaptedCurve1 ( curve1 );
- const Geom2dAdaptor_Curve AdaptedCurve2 ( curve2 );
+ const Handle(Geom2dAdaptor_Curve) AdaptedCurve1 = new Geom2dAdaptor_Curve( curve1 );
+ const Handle(Geom2dAdaptor_Curve) AdaptedCurve2 = new Geom2dAdaptor_Curve( curve2 );
GccEnt_Position curveQualif1 = GccEnt_unqualified;
GccEnt_Position curveQualif2 = GccEnt_unqualified;
TopLoc_Location aLoc;
if (!BRep_Tool::Surface (aFaceFwd, aLoc).IsNull())
{
- myFaceAdaptor.Initialize (aFaceFwd, false);
+ myFaceAdaptor = new BRepAdaptor_Surface(aFaceFwd, false);
mySLTool.SetSurface (myFaceAdaptor);
myHasNormals = true;
}
{
myPolyTriang.Nullify();
myFace.Nullify();
+ myFaceAdaptor.Nullify();
myHasNormals = false;
myHasFaceColor = false;
myFaceColor = Quantity_ColorRGBA();
Handle(Poly_Triangulation) myPolyTriang; //!< triangulation of current face
TopLoc_Location myFaceLocation; //!< current face location
mutable BRepLProp_SLProps mySLTool; //!< auxiliary tool for fetching normals from surface
- BRepAdaptor_Surface myFaceAdaptor; //!< surface adaptor for fetching normals from surface
+ Handle(BRepAdaptor_Surface) myFaceAdaptor; //!< surface adaptor for fetching normals from surface
Standard_Boolean myHasNormals; //!< flag indicating that current face has normals
gp_Trsf myTrsf; //!< current face transformation
Standard_Boolean myIsMirrored; //!< flag indicating that face triangles should be mirrored
IsStartPoint = Standard_True;
}
- Adaptor3d_CurveOnSurface aCOnS =
- Adaptor3d_CurveOnSurface(new BRepAdaptor_Curve2d(BRepAdaptor_Curve2d(aEdge, aFace)),
+ Handle(Adaptor3d_CurveOnSurface) aCOnS =
+ new Adaptor3d_CurveOnSurface(new BRepAdaptor_Curve2d(BRepAdaptor_Curve2d(aEdge, aFace)),
new BRepAdaptor_Surface(BRepAdaptor_Surface(aFace, Standard_False)));
gp_Pnt aPnt;
Handle(TColgp_HArray1OfXYZ)& thePoints)
{
NCollection_Vector<Standard_Real> aLengths;
- NCollection_Vector<BRepAdaptor_Curve> aCurves;
+ NCollection_Vector<Handle(BRepAdaptor_Curve)> aCurves;
NCollection_Vector<gp_XYZ> aPoints;
Standard_Real aTol = Max(1.e-3, theTol/10.);
Standard_Real aTotalLength = 0.;
const TopoDS_Edge& anE = TopoDS::Edge(anEIter.Value());
if (BRep_Tool::Degenerated(anE))
continue;
- BRepAdaptor_Curve aBAC(anE);
+ Handle(BRepAdaptor_Curve) aBAC = new BRepAdaptor_Curve(anE);
Standard_Real aClength = GCPnts_AbscissaPoint::Length(aBAC, aTol);
aTotalLength += aClength;
aCurves.Append(aBAC);
Standard_Integer i, aNb = aLengths.Length();
for (i = 0; i < aNb; ++i)
{
- const BRepAdaptor_Curve& aC = aCurves(i);
+ const Handle(BRepAdaptor_Curve)& aC = aCurves(i);
Standard_Real aClength = GCPnts_AbscissaPoint::Length(aC, aTol);
Standard_Integer aNbPoints = RealToInt(aClength / aTotalLength * theMaxNbInt + 1);
aNbPoints = Max(2, aNbPoints);
for (j = 1; j <= aNbPoints; ++j)
{
Standard_Real t = aPointGen.Parameter(j);
- gp_Pnt aP = aC.Value(t);
+ gp_Pnt aP = aC->Value(t);
aPoints.Append(aP.XYZ());
}
}
gp_Pnt p2, p1 = C1T->Value (u);
Standard_Real para;
//pdn Adaptor curve is used to avoid of enhancing of domain.
- GeomAdaptor_Curve GAC(C2T);
+ Handle(GeomAdaptor_Curve) GAC = new GeomAdaptor_Curve(C2T);
Standard_Real dist = SAC.Project (GAC,p1,toler,p2,para);
//pdn check if parameter of projection is in the domain of the edge.
if (para < f || para > l) return Standard_False;
//else proj = C2->Value(paramc2 -d2);
}
Standard_Real param;
- GeomAdaptor_Curve GAC(C3);
+ Handle(GeomAdaptor_Curve) GAC = new GeomAdaptor_Curve(C3);
Standard_Real f = C3->FirstParameter();
Standard_Real l = C3->LastParameter();
gp_Pnt result;
//function : ProjectOnSegments
//purpose :
//=======================================================================
-static void ProjectOnSegments (const Adaptor3d_Curve& AC, const gp_Pnt& P3D,
+static void ProjectOnSegments (const Handle(Adaptor3d_Curve)& AC, const gp_Pnt& P3D,
const Standard_Integer nbseg,
Standard_Real& uMin, Standard_Real& uMax,
Standard_Real& distmin, gp_Pnt& proj, Standard_Real& param)
Standard_Boolean aHasChanged = Standard_False;
for (Standard_Integer i = 0; i <= nbseg; i ++) {
u = uMin + (delta * i);
- gp_Pnt PU = AC.Value (u);
+ gp_Pnt PU = AC->Value (u);
dist2 = PU.SquareDistance (P3D);
if (dist2 < distmin2) { distmin2 = dist2; proj = PU; param = u; aHasChanged = Standard_True; }
}
Standard_Real uMin = (cf < cl ? cf : cl);
Standard_Real uMax = (cf < cl ? cl : cf);
- GeomAdaptor_Curve GAC(C3D, uMin, uMax);
+ Handle(GeomAdaptor_Curve) GAC = new GeomAdaptor_Curve(C3D, uMin, uMax);
if (C3D->IsKind(STANDARD_TYPE(Geom_BoundedCurve))) {
Standard_Real prec = ( AdjustToEnds ? preci : Precision::Confusion() ); //:j8 abv 10 Dec 98: tr10_r0501_db.stp #9423: protection against densing of points near one end
- gp_Pnt LowBound = GAC.Value(uMin);
- gp_Pnt HigBound = GAC.Value(uMax);
+ gp_Pnt LowBound = GAC->Value(uMin);
+ gp_Pnt HigBound = GAC->Value(uMax);
distmin = LowBound.Distance(P3D);
if (distmin <= prec) {
param = uMin;
//uMin = uMin - 0.1;
//uMax = uMax + 0.1;
// modified by pdn on 01.07.98 after BUC60195 entity 1952 (Min() added)
- Standard_Real delta = Min (GAC.Resolution (preci), (uMax - uMin) * 0.1);
+ Standard_Real delta = Min (GAC->Resolution (preci), (uMax - uMin) * 0.1);
uMin -= delta;
uMax += delta;
- GAC.Load(C3D, uMin, uMax);
+ GAC->Load(C3D, uMin, uMax);
}
return ProjectAct(GAC, P3D, preci, proj, param);
//purpose :
//=======================================================================
-Standard_Real ShapeAnalysis_Curve::Project(const Adaptor3d_Curve& C3D,
+Standard_Real ShapeAnalysis_Curve::Project(const Handle(Adaptor3d_Curve)& C3D,
const gp_Pnt& P3D,
const Standard_Real preci,
gp_Pnt& proj,
{
- Standard_Real uMin = C3D.FirstParameter();
- Standard_Real uMax = C3D.LastParameter();
+ Standard_Real uMin = C3D->FirstParameter();
+ Standard_Real uMax = C3D->LastParameter();
if (Precision::IsInfinite(uMin) && Precision::IsInfinite(uMax))
return ProjectAct(C3D, P3D, preci, proj, param);
Standard_Real distmin_L = Precision::Infinite(), distmin_H = Precision::Infinite();
Standard_Real prec = ( AdjustToEnds ? preci : Precision::Confusion() ); //:j8 abv 10 Dec 98: tr10_r0501_db.stp #9423: protection against densing of points near one end
- gp_Pnt LowBound = C3D.Value(uMin);
- gp_Pnt HigBound = C3D.Value(uMax);
+ gp_Pnt LowBound = C3D->Value(uMin);
+ gp_Pnt HigBound = C3D->Value(uMax);
distmin_L = LowBound.Distance(P3D);
distmin_H = HigBound.Distance(P3D);
//purpose :
//=======================================================================
-Standard_Real ShapeAnalysis_Curve::ProjectAct(const Adaptor3d_Curve& C3D,
+Standard_Real ShapeAnalysis_Curve::ProjectAct(const Handle(Adaptor3d_Curve)& C3D,
const gp_Pnt& P3D,
const Standard_Real preci,
gp_Pnt& proj,
}
//szv#4:S4163:12Mar99 moved
- Standard_Real uMin = C3D.FirstParameter(), uMax = C3D.LastParameter();
+ Standard_Real uMin = C3D->FirstParameter(), uMax = C3D->LastParameter();
Standard_Boolean closed = Standard_False; // si on franchit les bornes ...
Standard_Real distmin = Precision::Infinite(), valclosed = 0.;
Standard_Real aModParam = param;
if (distmin > preci) OK = Standard_False;
// Cas TrimmedCurve a cheval. Voir la courbe de base.
// Si fermee, passer une periode
- if (C3D.IsClosed()) {
+ if (C3D->IsClosed()) {
closed = Standard_True;
valclosed = uMax - uMin; //szv#4:S4163:12Mar99 optimized
}
// MEME PAS BIEN BON. L appelant pourra decider alors quoi faire
param = 0.;
- switch(C3D.GetType()) {
+ switch(C3D->GetType()) {
case GeomAbs_Circle:
{
- const gp_Circ& aCirc = C3D.Circle();
+ const gp_Circ& aCirc = C3D->Circle();
proj = aCirc.Position().Location();
if(aCirc.Radius() <= gp::Resolution() ||
P3D.SquareDistance(proj) <= gp::Resolution() ) {
- param = C3D.FirstParameter();
+ param = C3D->FirstParameter();
proj = proj.XYZ() + aCirc.XAxis().Direction().XYZ() * aCirc.Radius();
}
else {
break;
case GeomAbs_Hyperbola:
{
- param = ElCLib::Parameter(C3D.Hyperbola(), P3D);
- proj = ElCLib::Value(param, C3D.Hyperbola());
+ param = ElCLib::Parameter(C3D->Hyperbola(), P3D);
+ proj = ElCLib::Value(param, C3D->Hyperbola());
}
break;
case GeomAbs_Parabola:
{
- param = ElCLib::Parameter(C3D.Parabola(), P3D);
- proj = ElCLib::Value(param, C3D.Parabola());
+ param = ElCLib::Parameter(C3D->Parabola(), P3D);
+ proj = ElCLib::Value(param, C3D->Parabola());
}
break;
case GeomAbs_Line:
{
- param = ElCLib::Parameter(C3D.Line(), P3D);
- proj = ElCLib::Value(param, C3D.Line());
+ param = ElCLib::Parameter(C3D->Line(), P3D);
+ proj = ElCLib::Value(param, C3D->Line());
}
break;
case GeomAbs_Ellipse:
{
- param = ElCLib::Parameter(C3D.Ellipse(), P3D);
- proj = ElCLib::Value(param, C3D.Ellipse());
+ param = ElCLib::Parameter(C3D->Ellipse(), P3D);
+ proj = ElCLib::Value(param, C3D->Ellipse());
closed = Standard_True;
valclosed = 2.*M_PI;
Standard_Real uMin = (cf < cl ? cf : cl);
Standard_Real uMax = (cf < cl ? cl : cf);
Standard_Real distmin = Precision::Infinite();
- GeomAdaptor_Curve GAC(C3D, uMin, uMax);
+ Handle(GeomAdaptor_Curve) GAC = new GeomAdaptor_Curve(C3D, uMin, uMax);
if (C3D->IsKind(STANDARD_TYPE(Geom_BoundedCurve))) {
Standard_Real prec = ( AdjustToEnds ? preci : Precision::Confusion() ); //:j8 abv 10 Dec 98: tr10_r0501_db.stp #9423: protection against densing of points near one end
- gp_Pnt LowBound = GAC.Value(uMin);
- gp_Pnt HigBound = GAC.Value(uMax);
+ gp_Pnt LowBound = GAC->Value(uMin);
+ gp_Pnt HigBound = GAC->Value(uMax);
distmin = LowBound.Distance(P3D);
if (distmin <= prec) {
param = uMin;
//uMin = uMin - 0.1;
//uMax = uMax + 0.1;
// modified by pdn on 01.07.98 after BUC60195 entity 1952 (Min() added)
- Standard_Real delta = Min (GAC.Resolution (preci), (uMax - uMin) * 0.1);
+ Standard_Real delta = Min (GAC->Resolution (preci), (uMax - uMin) * 0.1);
uMin -= delta;
uMax += delta;
- GAC.Load(C3D, uMin, uMax);
+ GAC->Load(C3D, uMin, uMax);
}
return NextProject ( paramPrev, GAC, P3D, preci, proj, param );
}
//=======================================================================
Standard_Real ShapeAnalysis_Curve::NextProject(const Standard_Real paramPrev,
- const Adaptor3d_Curve& C3D,
+ const Handle(Adaptor3d_Curve)& C3D,
const gp_Pnt& P3D,
const Standard_Real preci,
gp_Pnt& proj,
Standard_Real& param) const
{
- Standard_Real uMin = C3D.FirstParameter();
- Standard_Real uMax = C3D.LastParameter();
+ Standard_Real uMin = C3D->FirstParameter();
+ Standard_Real uMax = C3D->LastParameter();
Extrema_LocateExtPC aProjector (P3D, C3D, paramPrev/*U0*/, uMin, uMax, preci/*TolU*/);
if (aProjector.IsDone()){
{
//:abv 05.06.02: TUBE.stp
// Use the same distribution of points as BRepTopAdaptor_FClass2d for consistency
- Geom2dAdaptor_Curve C ( curve, first, last );
+ Handle(Geom2dAdaptor_Curve) C = new Geom2dAdaptor_Curve( curve, first, last );
Standard_Integer nbs = Geom2dInt_Geom2dCurveTool::NbSamples(C);
//-- Attention aux bsplines rationnelles de degree 3. (bouts de cercles entre autres)
if (nbs > 2) nbs*=4;
Standard_Real step = ( last - first ) / (Standard_Real)( nbs - 1 );
for (Standard_Integer i = 0; i < nbs - 1; ++i)
- seq.Append(C.Value(first + step * i));
- seq.Append(C.Value(last));
+ seq.Append(C->Value(first + step * i));
+ seq.Append(C->Value(last));
return Standard_True;
/*
Standard_Integer i;
//!
//! Returned value is the distance between the given point and
//! computed one.
- Standard_EXPORT Standard_Real Project (const Adaptor3d_Curve& C3D, const gp_Pnt& P3D, const Standard_Real preci, gp_Pnt& proj, Standard_Real& param, const Standard_Boolean AdjustToEnds = Standard_True) const;
+ Standard_EXPORT Standard_Real Project (const Handle(Adaptor3d_Curve)& C3D, const gp_Pnt& P3D, const Standard_Real preci, gp_Pnt& proj, Standard_Real& param, const Standard_Boolean AdjustToEnds = Standard_True) const;
//! Projects a Point on a Curve, but parameters are limited
//! between <cf> and <cl>.
//! of the curve if distance is less than <preci>
Standard_EXPORT Standard_Real Project (const Handle(Geom_Curve)& C3D, const gp_Pnt& P3D, const Standard_Real preci, gp_Pnt& proj, Standard_Real& param, const Standard_Real cf, const Standard_Real cl, const Standard_Boolean AdjustToEnds = Standard_True) const;
- Standard_EXPORT Standard_Real ProjectAct (const Adaptor3d_Curve& C3D, const gp_Pnt& P3D, const Standard_Real preci, gp_Pnt& proj, Standard_Real& param) const;
+ Standard_EXPORT Standard_Real ProjectAct (const Handle(Adaptor3d_Curve)& C3D, const gp_Pnt& P3D, const Standard_Real preci, gp_Pnt& proj, Standard_Real& param) const;
//! Projects a Point on a Curve using Newton method.
//! <paramPrev> is taken as the first approximation of solution.
//! Projects a Point on a Curve using Newton method.
//! <paramPrev> is taken as the first approximation of solution.
//! If Newton algorithm fails the method Project() is used.
- Standard_EXPORT Standard_Real NextProject (const Standard_Real paramPrev, const Adaptor3d_Curve& C3D, const gp_Pnt& P3D, const Standard_Real preci, gp_Pnt& proj, Standard_Real& param) const;
+ Standard_EXPORT Standard_Real NextProject (const Standard_Real paramPrev, const Handle(Adaptor3d_Curve)& C3D, const gp_Pnt& P3D, const Standard_Real preci, gp_Pnt& proj, Standard_Real& param) const;
//! Validate parameters First and Last for the given curve
//! in order to make them valid for creation of edge.
const Standard_Real& theEndLength)
{
TColStd_SequenceOfInteger aSeqIntervals;
- BRepAdaptor_Curve aAdCurve1(theFirstEdge);
+ Handle(BRepAdaptor_Curve) aAdCurve1 = new BRepAdaptor_Curve(theFirstEdge);
BRepExtrema_DistShapeShape aMinDist;
aMinDist.LoadS1(theSecEdge);
aPoint = BRep_Tool::Pnt(V1);
}
else {
- GCPnts_AbscissaPoint aAbsPoint(Precision::Confusion(),aAdCurve1,aS,aAdCurve1.FirstParameter());
+ GCPnts_AbscissaPoint aAbsPoint(Precision::Confusion(),aAdCurve1,aS,aAdCurve1->FirstParameter());
if(aAbsPoint.IsDone())
- aAdCurve1.D0(aAbsPoint.Parameter(),aPoint);
+ aAdCurve1->D0(aAbsPoint.Parameter(),aPoint);
else continue;
}
BRep_Builder aB;
const Standard_Real theDomainDist)
{
Standard_Boolean isOverlap = Standard_False;
- BRepAdaptor_Curve aAdCurve1(theEdge1);
+ Handle(BRepAdaptor_Curve) aAdCurve1 = new BRepAdaptor_Curve(theEdge1);
Standard_Real aLength1 = GCPnts_AbscissaPoint::Length (aAdCurve1);
- BRepAdaptor_Curve aAdCurve2(theEdge2);
+ Handle(BRepAdaptor_Curve) aAdCurve2 = new BRepAdaptor_Curve(theEdge2);
Standard_Real aLength2 = GCPnts_AbscissaPoint::Length (aAdCurve2);
TopoDS_Edge aFirstEdge = (aLength1 >= aLength2 ? theEdge2: theEdge1);
TopoDS_Edge aSecEdge = (aLength1 >= aLength2 ? theEdge1: theEdge2);
Standard_Real aParam1, aFirst, aLast;
aMinDist.ParOnEdgeS1 ( i, aParam1 );
BRep_Tool::Range(aFirstEdge,aFirst,aLast);
- BRepAdaptor_Curve anAdaptor(aFirstEdge);
+ Handle(BRepAdaptor_Curve) anAdaptor = new BRepAdaptor_Curve(aFirstEdge);
aLengthP = GCPnts_AbscissaPoint::Length(anAdaptor,aFirst,aParam1);
}
else continue;
gp_Pnt2d ShapeAnalysis_Surface::ValueOfUV(const gp_Pnt& P3D, const Standard_Real preci)
{
- GeomAdaptor_Surface& SurfAdapt = *Adaptor3d();
+ Handle(GeomAdaptor_Surface) SurfAdapt = Adaptor3d();
Standard_Real S = 0., T = 0.;
myGap = -1.; // devra etre calcule
Standard_Boolean computed = Standard_True; // a priori
{ //:c9 abv 3 Mar 98: UKI60107-1 #350: to prevent 'catch' from catching exception raising below it
try { // ajout CKY 30-DEC-1997 (cf ProStep TR6 r_89-ug)
OCC_CATCH_SIGNALS
- GeomAbs_SurfaceType surftype = SurfAdapt.GetType();
+ GeomAbs_SurfaceType surftype = SurfAdapt->GetType();
switch (surftype) {
case GeomAbs_Plane:
{
- gp_Pln Plane = SurfAdapt.Plane();
+ gp_Pln Plane = SurfAdapt->Plane();
ElSLib::Parameters(Plane, P3D, S, T);
break;
}
case GeomAbs_Cylinder:
{
- gp_Cylinder Cylinder = SurfAdapt.Cylinder();
+ gp_Cylinder Cylinder = SurfAdapt->Cylinder();
ElSLib::Parameters(Cylinder, P3D, S, T);
S += ShapeAnalysis::AdjustByPeriod(S, 0.5*(uf + ul), 2 * M_PI);
break;
}
case GeomAbs_Cone:
{
- gp_Cone Cone = SurfAdapt.Cone();
+ gp_Cone Cone = SurfAdapt->Cone();
ElSLib::Parameters(Cone, P3D, S, T);
S += ShapeAnalysis::AdjustByPeriod(S, 0.5*(uf + ul), 2 * M_PI);
break;
}
case GeomAbs_Sphere:
{
- gp_Sphere Sphere = SurfAdapt.Sphere();
+ gp_Sphere Sphere = SurfAdapt->Sphere();
ElSLib::Parameters(Sphere, P3D, S, T);
S += ShapeAnalysis::AdjustByPeriod(S, 0.5*(uf + ul), 2 * M_PI);
break;
}
case GeomAbs_Torus:
{
- gp_Torus Torus = SurfAdapt.Torus();
+ gp_Torus Torus = SurfAdapt->Torus();
ElSLib::Parameters(Torus, P3D, S, T);
S += ShapeAnalysis::AdjustByPeriod(S, 0.5*(uf + ul), 2 * M_PI);
T += ShapeAnalysis::AdjustByPeriod(T, 0.5*(vf + vl), 2 * M_PI);
//can throw exception (e.g. Geom_UndefinedValue) when computing value - see id23943
if (!mySurf->IsKind(STANDARD_TYPE(Geom_OffsetSurface))) {
//modified by rln during fixing CSR # BUC60035 entity #D231
- du = Min(myUDelt, SurfAdapt.UResolution(preci));
- dv = Min(myVDelt, SurfAdapt.VResolution(preci));
+ du = Min(myUDelt, SurfAdapt->UResolution(preci));
+ dv = Min(myVDelt, SurfAdapt->VResolution(preci));
}
Standard_Real Tol = Precision::PConfusion();
myExtPS.SetFlag(Extrema_ExtFlag_MIN);
// file CEA_cuve-V5.igs Entityes 244, 259, 847, 925
// if project point3D on SurfaceOfRevolution Extreme recompute 2d point, but
// returns an old distance from 3d to solution :-(
- gp_Pnt aCheckPnt = SurfAdapt.Value(S, T);
+ gp_Pnt aCheckPnt = SurfAdapt->Value(S, T);
dist2Min = P3D.SquareDistance(aCheckPnt);
// end of WORKAROUND
Standard_Real disSurf = sqrt(dist2Min);//, disCurv =1.e10;
Standard_Real Tol = Precision::Confusion();
gp_Vec D1U, D1V;
gp_Pnt pnt;
- SurfAdapt.D1(UU, VV, pnt, D1U, D1V);
+ SurfAdapt->D1(UU, VV, pnt, D1U, D1V);
gp_Vec b = D1U.Crossed(D1V);
gp_Vec a(pnt, P3D);
Standard_Real ab = a.Dot(b);
} //:c9
//szv#4:S4163:12Mar99 waste raise
//if (!computed) throw Standard_NoSuchObject("PCurveLib_ProjectPointOnSurf::ValueOfUV untreated surface type");
- if (computed) { if (myGap <= 0) myGap = P3D.Distance(SurfAdapt.Value(S, T)); }
+ if (computed) { if (myGap <= 0) myGap = P3D.Distance(SurfAdapt->Value(S, T)); }
else { myGap = -1.; S = 0.; T = 0.; }
return gp_Pnt2d(S, T);
}
Standard_Boolean UV = Standard_True;
Standard_Real par = 0., other = 0., dist = 0.;
Handle(Geom_Curve) iso;
- Adaptor3d_IsoCurve anIsoCurve(Adaptor3d());
+ Handle(Adaptor3d_IsoCurve) anIsoCurve = new Adaptor3d_IsoCurve(Adaptor3d());
for (Standard_Integer num = 0; num < 6; num++) {
UV = (num < 3); // 0-1-2 : iso-U 3-4-5 : iso-V
}
else {
- Adaptor3d_Curve *anAdaptor = NULL;
- GeomAdaptor_Curve aGeomCurve;
+ Handle(Adaptor3d_Curve) anAdaptor;
+ Handle(GeomAdaptor_Curve) aGeomCurve = new GeomAdaptor_Curve();
const Bnd_Box *anIsoBox = 0;
switch (num) {
- case 0: par = myUF; aGeomCurve.Load(myIsoUF); anAdaptor = &aGeomCurve; anIsoBox = &myBndUF; break;
- case 1: par = myUL; aGeomCurve.Load(myIsoUL); anAdaptor = &aGeomCurve; anIsoBox = &myBndUL; break;
- case 2: par = U; anIsoCurve.Load(GeomAbs_IsoU, U); anAdaptor = &anIsoCurve; break;
- case 3: par = myVF; aGeomCurve.Load(myIsoVF); anAdaptor = &aGeomCurve; anIsoBox = &myBndVF; break;
- case 4: par = myVL; aGeomCurve.Load(myIsoVL); anAdaptor = &aGeomCurve; anIsoBox = &myBndVL; break;
- case 5: par = V; anIsoCurve.Load(GeomAbs_IsoV, V); anAdaptor = &anIsoCurve; break;
+ case 0: par = myUF; aGeomCurve->Load(myIsoUF); anAdaptor = aGeomCurve; anIsoBox = &myBndUF; break;
+ case 1: par = myUL; aGeomCurve->Load(myIsoUL); anAdaptor = aGeomCurve; anIsoBox = &myBndUL; break;
+ case 2: par = U; anIsoCurve->Load(GeomAbs_IsoU, U); anAdaptor = anIsoCurve; break;
+ case 3: par = myVF; aGeomCurve->Load(myIsoVF); anAdaptor = aGeomCurve; anIsoBox = &myBndVF; break;
+ case 4: par = myVL; aGeomCurve->Load(myIsoVL); anAdaptor = aGeomCurve; anIsoBox = &myBndVL; break;
+ case 5: par = V; anIsoCurve->Load(GeomAbs_IsoV, V); anAdaptor = anIsoCurve; break;
default: break;
}
if (anIsoBox && anIsoBox->Distance(aPBox) > theMin)
continue;
- dist = ShapeAnalysis_Curve().Project(*anAdaptor, P3d, preci, pntres, other);
+ dist = ShapeAnalysis_Curve().Project(anAdaptor, P3d, preci, pntres, other);
if (dist < theMin) {
theMin = dist;
UU = (UV ? par : other); VV = (UV ? other : par); //:q6: uncommented
PrevU = UU; PrevV = VV;
if (UV) {
par = UU;
- anIsoCurve.Load(GeomAbs_IsoU, UU);
+ anIsoCurve->Load(GeomAbs_IsoU, UU);
}
else {
par = VV;
- anIsoCurve.Load(GeomAbs_IsoV, VV);
+ anIsoCurve->Load(GeomAbs_IsoV, VV);
}
- Cf = anIsoCurve.FirstParameter();
- Cl = anIsoCurve.LastParameter();
+ Cf = anIsoCurve->FirstParameter();
+ Cl = anIsoCurve->LastParameter();
RestrictBounds (Cf, Cl);
dist = ShapeAnalysis_Curve().Project(anIsoCurve, P3d, preci, pntres, other);
if (dist < theMin) {
UV = !UV;
if (UV) {
par = UU;
- anIsoCurve.Load(GeomAbs_IsoU, UU);
+ anIsoCurve->Load(GeomAbs_IsoU, UU);
}
else {
par = VV;
- anIsoCurve.Load(GeomAbs_IsoV, VV);
+ anIsoCurve->Load(GeomAbs_IsoV, VV);
}
- Cf = anIsoCurve.FirstParameter();
- Cl = anIsoCurve.LastParameter();
+ Cf = anIsoCurve->FirstParameter();
+ Cl = anIsoCurve->LastParameter();
RestrictBounds (Cf, Cl);
dist = ShapeAnalysis_Curve().ProjectAct(anIsoCurve, P3d, preci, pntres, other);
if (dist < theMin) {
myIsoBoxes = Standard_True;
ComputeBoundIsos();
if (!myIsoUF.IsNull())
- BndLib_Add3dCurve::Add(GeomAdaptor_Curve(myIsoUF), Precision::Confusion(), myBndUF);
+ BndLib_Add3dCurve::Add(new GeomAdaptor_Curve(myIsoUF), Precision::Confusion(), myBndUF);
if (!myIsoUL.IsNull())
- BndLib_Add3dCurve::Add(GeomAdaptor_Curve(myIsoUL), Precision::Confusion(), myBndUL);
+ BndLib_Add3dCurve::Add(new GeomAdaptor_Curve(myIsoUL), Precision::Confusion(), myBndUL);
if (!myIsoVF.IsNull())
- BndLib_Add3dCurve::Add(GeomAdaptor_Curve(myIsoVF), Precision::Confusion(), myBndVF);
+ BndLib_Add3dCurve::Add(new GeomAdaptor_Curve(myIsoVF), Precision::Confusion(), myBndVF);
if (!myIsoVL.IsNull())
- BndLib_Add3dCurve::Add(GeomAdaptor_Curve(myIsoVL), Precision::Confusion(), myBndVL);
+ BndLib_Add3dCurve::Add(new GeomAdaptor_Curve(myIsoVL), Precision::Confusion(), myBndVL);
}
const Bnd_Box& ShapeAnalysis_Surface::GetBoxUF()
gp_Pnt p1 = myCurve->Value(Param).Transformed(myLocation.Inverted());
Handle(Adaptor3d_Surface) AdS = myAC3d.GetSurface();
Handle(Geom2dAdaptor_Curve) AC2d = new Geom2dAdaptor_Curve(myCurve2d,First,Last);
- Adaptor3d_CurveOnSurface Ad1(AC2d,AdS);
+ Handle(Adaptor3d_CurveOnSurface) Ad1 = new Adaptor3d_CurveOnSurface(AC2d,AdS);
projDev = sac.Project(Ad1,p1,myPrecision,pproj,ppar);//pdn
- linDev = p1.Distance(Ad1.Value(linPar));
+ linDev = p1.Distance(Ad1->Value(linPar));
}
else {
gp_Pnt p1 = myAC3d.Value(Param).Transformed(myLocation);
Standard_Real len = last -first;
gp_Pnt ploc1 = p1.Transformed(loc);
gp_Pnt ploc2 = p2.Transformed(loc);
- GeomAdaptor_Curve GAC(C3d,first,last);
+ Handle(GeomAdaptor_Curve) GAC = new GeomAdaptor_Curve(C3d,first,last);
// CATIA bplseitli.model FAC1155 - Copy: protection for degenerated edges(3d case for symmetry)
Standard_Real linFirst = first+alpha*len;
Standard_Real linLast = first+beta*len;
Standard_Real len = last -first;
Handle(Geom2dAdaptor_Curve) AC2d = new Geom2dAdaptor_Curve(toGC->PCurve(),first,last);
Handle(GeomAdaptor_Surface) AdS = new GeomAdaptor_Surface( toGC->Surface());
- Adaptor3d_CurveOnSurface Ad1(AC2d,AdS);
+ Handle(Adaptor3d_CurveOnSurface) Ad1 = new Adaptor3d_CurveOnSurface(AC2d,AdS);
ShapeAnalysis_Curve sac1;
//gp_Pnt p1 = Ad1.Value(prevPar);
if(isLastOnEnd && ! localLinearLast)
localLinearLast = Standard_True;
- gp_Pnt pos1 = Ad1.Value ( linFirst );
- gp_Pnt pos2 = Ad1.Value ( linLast );
+ gp_Pnt pos1 = Ad1->Value ( linFirst );
+ gp_Pnt pos2 = Ad1->Value ( linLast );
Standard_Real d01 = pos1.Distance ( ploc1 );
Standard_Real d02 = pos2.Distance ( ploc2 );
if ( localLinearFirst || useLinear || d01 <= dist1 || ( d01 < myPrecision && d01 <= 2 * dist1 ) )
TopoDS_Edge E = sbwd->Edge (i);
if(sae.PCurve (E,S,L,c2d,cf,cl,Standard_False)) {
Bnd_Box2d box;
- Geom2dAdaptor_Curve gac(c2d,cf,cl);
+ Handle(Geom2dAdaptor_Curve) gac = new Geom2dAdaptor_Curve(c2d,cf,cl);
BndLib_Add2dCurve::Add(gac,::Precision::Confusion(),box);
boxes(i) = box;
}
// from 3d curve (but only if edge is SameParameter)
static gp_Pnt GetPointOnEdge ( const TopoDS_Edge &edge,
const Handle(ShapeAnalysis_Surface) &surf,
- const Geom2dAdaptor_Curve &Crv2d,
+ const Handle(Geom2dAdaptor_Curve) &Crv2d,
const Standard_Real param )
{
if ( BRep_Tool::SameParameter ( edge ) ) {
if ( ! ConS.IsNull() )
return ConS->Value ( param ).Transformed ( L.Transformation() );
}
- gp_Pnt2d aP2d = Crv2d.Value(param);
+ gp_Pnt2d aP2d = Crv2d->Value(param);
return surf->Adaptor3d()->Value(aP2d.X(), aP2d.Y());
}
Standard_Real tolint = 1.0e-10;
//szv#4:S4163:12Mar99 warning
IntRes2d_Domain domain ( Crv->Value ( a ), a, tolint, Crv->Value ( b ), b, tolint );
- Geom2dAdaptor_Curve AC ( Crv );
+ Handle(Geom2dAdaptor_Curve) AC = new Geom2dAdaptor_Curve( Crv );
Geom2dInt_GInter Inter ( AC, domain, tolint, tolint );
if ( ! Inter.IsDone() ) return Standard_False;
Standard_Real tolint = 1.0e-10;
//szv#4:S4163:12Mar99 warning
- Geom2dAdaptor_Curve C1 ( Crv1 ), C2 ( Crv2 );
- IntRes2d_Domain d1 ( C1.Value ( a1 ), a1, tolint,
- C1.Value ( b1 ), b1, tolint );
- IntRes2d_Domain d2 ( C2.Value ( a2 ), a2, tolint,
- C2.Value ( b2 ), b2, tolint );
+ Handle(Geom2dAdaptor_Curve) C1 = new Geom2dAdaptor_Curve(Crv1);
+ Handle(Geom2dAdaptor_Curve) C2 = new Geom2dAdaptor_Curve(Crv2);
+ IntRes2d_Domain d1 ( C1->Value ( a1 ), a1, tolint,
+ C1->Value ( b1 ), b1, tolint );
+ IntRes2d_Domain d2 ( C2->Value ( a2 ), a2, tolint,
+ C2->Value ( b2 ), b2, tolint );
//:64 abv 25 Dec 97: Attention!
// Since Intersection algorithm is not symmetrical, for consistency with BRepCheck
Crv1->Value ( b1 ), b1, tolint );
IntRes2d_Domain d2 ( Crv2->Value ( a2 ), a2, tolint,
Crv2->Value ( b2 ), b2, tolint );
- Geom2dAdaptor_Curve C1 ( Crv1 ), C2 ( Crv2 );
+ Handle(Geom2dAdaptor_Curve) C1 = new Geom2dAdaptor_Curve(Crv1);
+ Handle(Geom2dAdaptor_Curve) C2 = new Geom2dAdaptor_Curve(Crv2);
Geom2dInt_GInter Inter;
Inter.Perform ( C1, d1, C2, d2, tolint, tolint );
//purpose :
//=======================================================================
-static Standard_Real ProjectInside(const Adaptor3d_CurveOnSurface& AD,
+static Standard_Real ProjectInside(const Handle(Adaptor3d_CurveOnSurface)& AD,
const gp_Pnt& pnt,
const Standard_Real preci,
gp_Pnt& proj,
{
ShapeAnalysis_Curve sac;
Standard_Real dist = sac.Project(AD,pnt,preci,proj,param,adjustToEnds);
- Standard_Real uFirst = AD.FirstParameter();
- Standard_Real uLast = AD.LastParameter();
+ Standard_Real uFirst = AD->FirstParameter();
+ Standard_Real uLast = AD->LastParameter();
if(param<uFirst) {
param = uFirst;
- proj = AD.Value(uFirst);
+ proj = AD->Value(uFirst);
return proj.Distance(pnt);
}
if(param>uLast) {
param = uLast;
- proj = AD.Value(uLast);
+ proj = AD->Value(uLast);
return proj.Distance(pnt);
}
return dist;
Handle(Geom2dAdaptor_Curve) AC2d1 = new Geom2dAdaptor_Curve(c2d1,a1,b1);
Handle(GeomAdaptor_Surface) AdS1 = new GeomAdaptor_Surface(new Geom_Plane(gp_Pln()));
- Adaptor3d_CurveOnSurface Ad1(AC2d1,AdS1);
+ Handle(Adaptor3d_CurveOnSurface) Ad1 = new Adaptor3d_CurveOnSurface(AC2d1,AdS1);
Handle(Geom2dAdaptor_Curve) AC2d2 = new Geom2dAdaptor_Curve(c2d2,a2,b2);
Handle(GeomAdaptor_Surface) AdS2 = new GeomAdaptor_Surface(new Geom_Plane(gp_Pln()));
- Adaptor3d_CurveOnSurface Ad2(AC2d2,AdS2);
+ Handle(Adaptor3d_CurveOnSurface) Ad2 = new Adaptor3d_CurveOnSurface(AC2d2,AdS2);
- Adaptor3d_CurveOnSurface longAD, shortAD;
+ Handle(Adaptor3d_CurveOnSurface) longAD, shortAD;
Standard_Real lenP, firstP;
ShapeAnalysis_Curve sac;
Standard_Real step = lenP/23;
for (Standard_Integer i = 1; i < 23; i++,firstP+=step) {
- Standard_Real d1 = sac.Project(longAD,shortAD.Value(firstP),Tolerance,Proj1,param1);
+ Standard_Real d1 = sac.Project(longAD,shortAD->Value(firstP),Tolerance,Proj1,param1);
if (d1 > Tolerance) {
return Standard_False;
}
Standard_Integer aReverse = 0;
for (Standard_Integer aEI = 0; aEI < 2; ++aEI)
{
- GeomAdaptor_Curve aCA(aCs[aEI]);
+ Handle(GeomAdaptor_Curve) aCA = new GeomAdaptor_Curve(aCs[aEI]);
if (GCPnts_AbscissaPoint::Length(aCA, aLs[aEI][0], aLs[aEI][1],
0.25 * Precision::Confusion()) < 0.5 * Precision::Confusion())
{
GeomProjLib::ProjectOnPlane (c3d, Plane,
Plane->Position().Direction(), Standard_True);
Handle(GeomAdaptor_Curve) HC = new GeomAdaptor_Curve ( ProjOnPlane );
- ProjLib_ProjectedCurve Proj ( mySurf->Adaptor3d(), HC );
+ Handle(ProjLib_ProjectedCurve) Proj = new ProjLib_ProjectedCurve( mySurf->Adaptor3d(), HC );
result = Geom2dAdaptor::MakeCurve(Proj);
if ( result.IsNull() ) return result;
Standard_Integer nbNMVert = aNMVertices.Length();
TColStd_SequenceOfReal aNMVertParams;
if( nbNMVert) {
- Geom2dAdaptor_Curve adc(C2d);
+ Handle(Geom2dAdaptor_Curve) adc = new Geom2dAdaptor_Curve(C2d);
Standard_Integer n =1;
for( ; n<= nbNMVert; n++) {
gp_Pnt apV = BRep_Tool::Pnt(TopoDS::Vertex(aNMVertices.Value(n)));
ShapeAnalysis_Edge sae;
// prepare data on cutting line
Handle(Geom2d_Line) jC2d = new Geom2d_Line ( line );
- Geom2dAdaptor_Curve jGAC(jC2d);
+ Handle(Geom2dAdaptor_Curve) jGAC = new Geom2dAdaptor_Curve(jC2d);
TColStd_SequenceOfInteger IntEdgeInd; // index of intersecting edge
TColStd_SequenceOfReal IntEdgePar; // parameter of intersection point on edge
for ( Standard_Integer iter=1; iter <= nbIter; iter++ ) {
// data for intersection
IntRes2d_Domain iDom ( pppf, f, TOLINT, pppl, l, TOLINT );
- Geom2dAdaptor_Curve iGAC(c2d);
+ Handle(Geom2dAdaptor_Curve) iGAC = new Geom2dAdaptor_Curve(c2d);
// intersection
Geom2dInt_GInter Inter;
// ----------------------------------------------------------------------------
static Standard_Boolean FindParameterWithExt (const gp_Pnt& Pt1,
- const Adaptor3d_CurveOnSurface& COnS,
+ const Handle(Adaptor3d_CurveOnSurface)& COnS,
const Standard_Real Uinf,
const Standard_Real Usup,
const Standard_Real preci,
Geom2dAdaptor_Curve CA = Geom2dAdaptor_Curve(theCurve2d,cf,cl);
Handle(Geom2dAdaptor_Curve) myHCur = new Geom2dAdaptor_Curve(CA);
- Adaptor3d_CurveOnSurface COnS = Adaptor3d_CurveOnSurface(myHCur, myHSur);
+ Handle(Adaptor3d_CurveOnSurface) COnS = new Adaptor3d_CurveOnSurface(myHCur, myHSur);
// ----------------------------------------------
// --- topological limit == geometric limit ? ---
// ----------------------------------------------
- Standard_Real Uinf = COnS.FirstParameter();
- Standard_Real Usup = COnS.LastParameter();
+ Standard_Real Uinf = COnS->FirstParameter();
+ Standard_Real Usup = COnS->LastParameter();
Standard_Real w1 = 0., w2 = 0.;
ShapeAnalysis_Curve sac;
return;
}
//:abv 29.08.01: SAT: fix for closed case
- if ( COnS.Value(Uinf).Distance ( COnS.Value(Usup) ) < Precision::Confusion() ) {
+ if ( COnS->Value(Uinf).Distance ( COnS->Value(Usup) ) < Precision::Confusion() ) {
// 18.11.2002 SKL OCC630 compare values with tolerance Precision::PConfusion() instead of "=="
if ( Abs(myFirstParam-Uinf) < ::Precision::PConfusion() &&
Abs(myLastParam-Uinf) < ::Precision::PConfusion() )
Geom2dAdaptor_Curve CA = Geom2dAdaptor_Curve(theCurve2d);
Handle(Geom2dAdaptor_Curve) myHCur = new Geom2dAdaptor_Curve(CA);
- Adaptor3d_CurveOnSurface COnS = Adaptor3d_CurveOnSurface(myHCur, myHSur);
+ Handle(Adaptor3d_CurveOnSurface) COnS = new Adaptor3d_CurveOnSurface(myHCur, myHSur);
//:S4136 Standard_Real preci = BRepAPI::Precision();
Standard_Real Uinf = theCurve2d->FirstParameter();
if (theCurve2d->IsKind(STANDARD_TYPE(Geom2d_BoundedCurve))) {
- gp_Pnt Pdeb = COnS.Value(Uinf);
- gp_Pnt Pfin = COnS.Value(Usup);
+ gp_Pnt Pdeb = COnS->Value(Uinf);
+ gp_Pnt Pfin = COnS->Value(Usup);
//szv#4:S4163:12Mar99 optimized
if ( Pdeb.IsEqual(Pt1, preci) && Pfin.IsEqual(Pt2, preci) ) {
// --- Try with Extrema ---
// ------------------------------------------
- Standard_Real w1 = COnS.FirstParameter();
- Standard_Real w2 = COnS.LastParameter();
+ Standard_Real w1 = COnS->FirstParameter();
+ Standard_Real w2 = COnS->LastParameter();
if ((!Precision::IsInfinite(w1) &&
!Precision::IsInfinite(w2) &&
{
continue;
}
- Geom2dAdaptor_Curve gac;
+ Handle(Geom2dAdaptor_Curve) gac;
Standard_Real aFirst = cw->FirstParameter();
Standard_Real aLast = cw->LastParameter();
if(cw->IsKind(STANDARD_TYPE(Geom2d_BSplineCurve)) && (cf < aFirst || cl > aLast)) {
//avoiding problems with segment in Bnd_Box
- gac.Load(cw);
+ gac = new Geom2dAdaptor_Curve(cw);
}
- else
- gac.Load(cw,cf,cl);
+ else
+ gac = new Geom2dAdaptor_Curve(cw,cf,cl);
BndLib_Add2dCurve::Add(gac,::Precision::Confusion(),aBox);
}
ShapeAnalysis_Edge sae;
if(sae.PCurve(newE1,S,L,c2d,cf,cl,Standard_False)) {
Bnd_Box2d box;
- Geom2dAdaptor_Curve gac;
+ Handle(Geom2dAdaptor_Curve) gac;
Standard_Real aFirst = c2d->FirstParameter();
Standard_Real aLast = c2d->LastParameter();
if(c2d->IsKind(STANDARD_TYPE(Geom2d_BSplineCurve))
&& (cf < aFirst || cl > aLast)) {
//pdn avoiding problems with segment in Bnd_Box
- gac.Load(c2d);
+ gac = new Geom2dAdaptor_Curve(c2d);
}
else
- gac.Load(c2d,cf,cl);
+ gac = new Geom2dAdaptor_Curve(c2d,cf,cl);
BndLib_Add2dCurve::Add(gac,::Precision::Confusion(),box);
boxes.Bind(newE1,box);
}
if(sae.PCurve(newE2,S,L,c2d,cf,cl,Standard_False)) {
Bnd_Box2d box;
- Geom2dAdaptor_Curve gac;
+ Handle(Geom2dAdaptor_Curve) gac;
Standard_Real aFirst = c2d->FirstParameter();
Standard_Real aLast = c2d->LastParameter();
if(c2d->IsKind(STANDARD_TYPE(Geom2d_BSplineCurve))
&& (cf < aFirst || cl > aLast)) {
//pdn avoiding problems with segment in Bnd_Box
- gac.Load(c2d);
+ gac = new Geom2dAdaptor_Curve(c2d);
}
else
- gac.Load(c2d,cf,cl);
+ gac = new Geom2dAdaptor_Curve(c2d,cf,cl);
BndLib_Add2dCurve::Add(gac,::Precision::Confusion(),box);
boxes.Bind(newE2,box);
}
ShapeAnalysis_Edge sae;
if(sae.PCurve(newE1,S,L,c2d,cf,cl,Standard_False)) {
Bnd_Box2d box;
- Geom2dAdaptor_Curve gac;
+ Handle(Geom2dAdaptor_Curve) gac;
Standard_Real aFirst = c2d->FirstParameter();
Standard_Real aLast = c2d->LastParameter();
if(c2d->IsKind(STANDARD_TYPE(Geom2d_BSplineCurve))
&& (cf < aFirst || cl > aLast)) {
//pdn avoiding problems with segment in Bnd_Box
- gac.Load(c2d);
+ gac = new Geom2dAdaptor_Curve(c2d);
}
else
- gac.Load(c2d,cf,cl);
+ gac = new Geom2dAdaptor_Curve(c2d,cf,cl);
BndLib_Add2dCurve::Add(gac,::Precision::Confusion(),box);
boxes.Bind(newE1,box);
}
if(sae.PCurve(newE2,S,L,c2d,cf,cl,Standard_False)) {
Bnd_Box2d box;
- Geom2dAdaptor_Curve gac;
+ Handle(Geom2dAdaptor_Curve) gac;
Standard_Real aFirst = c2d->FirstParameter();
Standard_Real aLast = c2d->LastParameter();
if(c2d->IsKind(STANDARD_TYPE(Geom2d_BSplineCurve))
&& (cf < aFirst || cl > aLast)) {
//pdn avoiding problems with segment in Bnd_Box
- gac.Load(c2d);
+ gac = new Geom2dAdaptor_Curve(c2d);
}
else
- gac.Load(c2d,cf,cl);
+ gac = new Geom2dAdaptor_Curve(c2d,cf,cl);
BndLib_Add2dCurve::Add(gac,::Precision::Confusion(),box);
boxes.Bind(newE2,box);
}
//=======================================================================
static gp_Pnt GetPointOnEdge(const TopoDS_Edge &edge,
const Handle(ShapeAnalysis_Surface) &surf,
- const Geom2dAdaptor_Curve &Crv2d,
+ const Handle(Geom2dAdaptor_Curve) &Crv2d,
const Standard_Real param )
{
if( BRep_Tool::SameParameter(edge) ) {
if( !ConS.IsNull() )
return ConS->Value(param).Transformed(L.Transformation());
}
- gp_Pnt2d aP2d = Crv2d.Value(param);
+ gp_Pnt2d aP2d = Crv2d->Value(param);
return surf->Adaptor3d()->Value(aP2d.X(), aP2d.Y());
}
ShapeAnalysis_Edge sae;
if(sae.PCurve(newE1,S,L,c2d,cf,cl,Standard_False)) {
Bnd_Box2d box;
- Geom2dAdaptor_Curve gac;
+ Handle(Geom2dAdaptor_Curve) gac;
Standard_Real aFirst = c2d->FirstParameter();
Standard_Real aLast = c2d->LastParameter();
if(c2d->IsKind(STANDARD_TYPE(Geom2d_BSplineCurve))
&& (cf < aFirst || cl > aLast)) {
//pdn avoiding problems with segment in Bnd_Box
- gac.Load(c2d);
+ gac = new Geom2dAdaptor_Curve(c2d);
}
else
- gac.Load(c2d,cf,cl);
+ gac = new Geom2dAdaptor_Curve(c2d,cf,cl);
BndLib_Add2dCurve::Add(gac,::Precision::Confusion(),box);
boxes.Bind(newE1,box);
}
if(sae.PCurve(newE2,S,L,c2d,cf,cl,Standard_False)) {
Bnd_Box2d box;
- Geom2dAdaptor_Curve gac;
+ Handle(Geom2dAdaptor_Curve) gac;
Standard_Real aFirst = c2d->FirstParameter();
Standard_Real aLast = c2d->LastParameter();
if(c2d->IsKind(STANDARD_TYPE(Geom2d_BSplineCurve))
&& (cf < aFirst || cl > aLast)) {
//pdn avoiding problems with segment in Bnd_Box
- gac.Load(c2d);
+ gac = new Geom2dAdaptor_Curve(c2d);
}
else
- gac.Load(c2d,cf,cl);
+ gac = new Geom2dAdaptor_Curve(c2d,cf,cl);
BndLib_Add2dCurve::Add(gac,::Precision::Confusion(),box);
boxes.Bind(newE2,box);
}
Standard_Real cf,cl;
if(sae.PCurve(newE1,S,L,c2d,cf,cl,Standard_False)) {
Bnd_Box2d box;
- Geom2dAdaptor_Curve gac;
+ Handle(Geom2dAdaptor_Curve) gac;
Standard_Real aFirst = c2d->FirstParameter();
Standard_Real aLast = c2d->LastParameter();
if(c2d->IsKind(STANDARD_TYPE(Geom2d_BSplineCurve))
&& (cf < aFirst || cl > aLast)) {
//pdn avoiding problems with segment in Bnd_Box
- gac.Load(c2d);
+ gac = new Geom2dAdaptor_Curve(c2d);
}
else
- gac.Load(c2d,cf,cl);
+ gac = new Geom2dAdaptor_Curve(c2d,cf,cl);
BndLib_Add2dCurve::Add(gac,::Precision::Confusion(),box);
boxes.Bind(newE1,box);
}
if(sae.PCurve(newE2,S,L,c2d,cf,cl,Standard_False)) {
Bnd_Box2d box;
- Geom2dAdaptor_Curve gac;
+ Handle(Geom2dAdaptor_Curve) gac;
Standard_Real aFirst = c2d->FirstParameter();
Standard_Real aLast = c2d->LastParameter();
if(c2d->IsKind(STANDARD_TYPE(Geom2d_BSplineCurve))
&& (cf < aFirst || cl > aLast)) {
//pdn avoiding problems with segment in Bnd_Box
- gac.Load(c2d);
+ gac = new Geom2dAdaptor_Curve(c2d);
}
else
- gac.Load(c2d,cf,cl);
+ gac = new Geom2dAdaptor_Curve(c2d,cf,cl);
BndLib_Add2dCurve::Add(gac,::Precision::Confusion(),box);
boxes.Bind(newE2,box);
}
TopoDS_Edge E = sewd->Edge(i);
if(sae.PCurve(E,S,L,c2d,cf,cl,Standard_False)) {
Bnd_Box2d box;
- Geom2dAdaptor_Curve gac;
+ Handle(Geom2dAdaptor_Curve) gac;
Standard_Real aFirst = c2d->FirstParameter();
Standard_Real aLast = c2d->LastParameter();
if(c2d->IsKind(STANDARD_TYPE(Geom2d_BSplineCurve))
&& (cf < aFirst || cl > aLast)) {
//pdn avoiding problems with segment in Bnd_Box
- gac.Load(c2d);
+ gac = new Geom2dAdaptor_Curve(c2d);
}
else
- gac.Load(c2d,cf,cl);
+ gac = new Geom2dAdaptor_Curve(c2d,cf,cl);
BndLib_Add2dCurve::Add(gac,::Precision::Confusion(),box);
boxes.Bind(E,box);
aTotalBox.Add (box);
// find needed vertex from edge2 and split edge1 using it
ShapeAnalysis_Edge sae;
Handle(ShapeAnalysis_Surface) sas = new ShapeAnalysis_Surface(BRep_Tool::Surface(face));
- gp_Pnt pi1 = GetPointOnEdge(edge1,sas,Crv1,param1);
+ Handle(Geom2dAdaptor_Curve) gac = new Geom2dAdaptor_Curve(Crv1);
+ gp_Pnt pi1 = GetPointOnEdge(edge1,sas,gac,param1);
BRep_Builder B;
TopoDS_Vertex V;
Standard_Real tolV;
if( !sae.PCurve(edge1, face, Crv1, a1, b1, Standard_False) ) return Standard_False;
if( !sae.PCurve(edge2, face, Crv2, a2, b2, Standard_False) ) return Standard_False;
Standard_Real tolint = 1.0e-10;
- Geom2dAdaptor_Curve C1(Crv1), C2(Crv2);
- IntRes2d_Domain d1(C1.Value(a1),a1,tolint,C1.Value(b1),b1,tolint);
- IntRes2d_Domain d2(C2.Value(a2),a2,tolint,C2.Value(b2),b2,tolint);
+ Handle(Geom2dAdaptor_Curve) C1 = new Geom2dAdaptor_Curve(Crv1);
+ Handle(Geom2dAdaptor_Curve) C2 = new Geom2dAdaptor_Curve(Crv2);
+ IntRes2d_Domain d1(C1->Value(a1),a1,tolint,C1->Value(b1),b1,tolint);
+ IntRes2d_Domain d2(C2->Value(a2),a2,tolint,C2->Value(b2),b2,tolint);
Geom2dInt_GInter Inter;
Inter.Perform( C1, d1, C2, d2, tolint, tolint );
if(!Inter.IsDone()) continue;
if( !sae.PCurve(edge2, face, Crv2, a2, b2, Standard_False) )
continue; //return Standard_False;gka 06.09.04
Standard_Real tolint = 1.0e-10;
- Geom2dAdaptor_Curve C1(Crv1), C2(Crv2);
- IntRes2d_Domain d1(C1.Value(a1),a1,tolint,C1.Value(b1),b1,tolint);
- IntRes2d_Domain d2(C2.Value(a2),a2,tolint,C2.Value(b2),b2,tolint);
+ Handle(Geom2dAdaptor_Curve) C1 = new Geom2dAdaptor_Curve(Crv1);
+ Handle(Geom2dAdaptor_Curve) C2 = new Geom2dAdaptor_Curve(Crv2);
+ IntRes2d_Domain d1(C1->Value(a1),a1,tolint,C1->Value(b1),b1,tolint);
+ IntRes2d_Domain d2(C2->Value(a2),a2,tolint,C2->Value(b2),b2,tolint);
Geom2dInt_GInter Inter;
Inter.Perform( C1, d1, C2, d2, tolint, tolint );
if(!Inter.IsDone()) continue;
Handle(Geom_Curve) C = BRep_Tool::Curve ( E, a, b );
Handle(ShapeAnalysis_Surface) S = myAnalyzer->Surface();
Standard_Integer nbs = S->NbSingularities(MinTolerance());
- GeomAdaptor_Curve GAC ( C, a, b );
+ Handle(GeomAdaptor_Curve) GAC = new GeomAdaptor_Curve( C, a, b );
TColStd_SequenceOfReal seq;
for (Standard_Integer j=1; j <= nbs; j++) {
Standard_Real Preci;
Geom2dInt_GInter Inter;
Standard_Real tolint = ::Precision::PConfusion();
- Geom2dAdaptor_Curve AC1(pc1), AC2(pc2);
+ Handle(Geom2dAdaptor_Curve) AC1 = new Geom2dAdaptor_Curve(pc1);
+ Handle(Geom2dAdaptor_Curve) AC2 = new Geom2dAdaptor_Curve(pc2);
// Try to find intersection points
IntRes2d_Domain dom1(pc1->Value(domfirst1),domfirst1,tolint,
{
// Intersect pcurve with bounding line
Handle(Geom2d_Line) lin = new Geom2d_Line(P1,gp_Dir2d(gp_Vec2d(P1,P2)));
- Geom2dAdaptor_Curve ACL(lin);
+ Handle(Geom2dAdaptor_Curve) ACL = new Geom2dAdaptor_Curve(lin);
IntRes2d_Domain dlin(P1,0.,tolint,P2,P1.Distance(P2),tolint);
Handle(Geom2d_Curve) pc;
}
pc = pc2;
}
- Geom2dAdaptor_Curve ACC(pc);
+ Handle(Geom2dAdaptor_Curve) ACC = new Geom2dAdaptor_Curve(pc);
IntRes2d_Domain domc(pc->Value(fpar),fpar,tolint,
pc->Value(lpar),lpar,tolint);
Standard_Real af = 0.,al = 0.;
Handle(Geom_Curve) c3d;
- Adaptor3d_CurveOnSurface AdCS;
+ Handle(Adaptor3d_CurveOnSurface) AdCS = new Adaptor3d_CurveOnSurface();
if(myEdgeDivide->HasCurve3d())
sae.Curve3d(E,c3d,af,al,Standard_False);
else if(myEdgeDivide->HasCurve2d() && !Surf.IsNull()) {
sae.PCurve ( E, myFace, c2d, af, al, Standard_False);
Handle(Adaptor3d_Surface) AdS = new GeomAdaptor_Surface(Surf);
Handle(Adaptor2d_Curve2d) AC2d = new Geom2dAdaptor_Curve(c2d,af,al);
- AdCS.Load(AC2d);
- AdCS.Load(AdS);
+ AdCS->Load(AC2d);
+ AdCS->Load(AdS);
}
TopTools_SequenceOfShape aSeqNMVertices;
TColStd_SequenceOfReal aSeqParNM;
my4Poles (1, 4)
{
myFTFont = new Font_FTFont();
+ myCurvOnSurf = new Adaptor3d_CurveOnSurface();
init();
}
mySurface = new Geom_Plane (gp_Pln (gp::XOY()));
myCurve2dAdaptor = new Geom2dAdaptor_Curve();
Handle(Adaptor3d_Surface) aSurfAdaptor = new GeomAdaptor_Surface (mySurface);
- myCurvOnSurf.Load (aSurfAdaptor);
+ myCurvOnSurf->Load (aSurfAdaptor);
}
// =======================================================================
my3Poles (1, 3),
my4Poles (1, 4)
{
+ myCurvOnSurf = new Adaptor3d_CurveOnSurface();
init();
if (theSize <= myPrecision * 100.0)
{
my3Poles (1, 3),
my4Poles (1, 4)
{
+ myCurvOnSurf = new Adaptor3d_CurveOnSurface();
init();
if (theSize <= myPrecision * 100.0)
{
Standard_Real anAverDeviation = 0.0;
myCurve2dAdaptor->Load (theCurve2d);
const Handle(Adaptor2d_Curve2d)& aCurve = myCurve2dAdaptor; // to avoid ambiguity
- myCurvOnSurf.Load (aCurve);
+ myCurvOnSurf->Load (aCurve);
GeomLib::BuildCurve3d (myPrecision, myCurvOnSurf,
myCurve2dAdaptor->FirstParameter(), myCurve2dAdaptor->LastParameter(),
theCurve3d, aMaxDeviation, anAverDeviation, theContinuity);
protected: //! @name Shared temporary variables for glyph construction
- Adaptor3d_CurveOnSurface myCurvOnSurf;
+ Handle(Adaptor3d_CurveOnSurface) myCurvOnSurf;
Handle(Geom2dAdaptor_Curve) myCurve2dAdaptor;
Geom2dConvert_CompCurveToBSplineCurve myConcatMaker;
TColgp_Array1OfPnt2d my3Poles;
// function: FindLimits
// purpose:
//==================================================================
-static void FindLimits(const Adaptor3d_Curve& aCurve,
+static void FindLimits(const Handle(Adaptor3d_Curve)& aCurve,
const Standard_Real aLimit,
Standard_Real& First,
Standard_Real& Last)
{
- First = aCurve.FirstParameter();
- Last = aCurve.LastParameter();
+ First = aCurve->FirstParameter();
+ Last = aCurve->LastParameter();
Standard_Boolean firstInf = Precision::IsNegativeInfinite(First);
Standard_Boolean lastInf = Precision::IsPositiveInfinite(Last);
delta *= 2;
First = - delta;
Last = delta;
- aCurve.D0(First,P1);
- aCurve.D0(Last,P2);
+ aCurve->D0(First,P1);
+ aCurve->D0(Last,P2);
} while (P1.Distance(P2) < aLimit);
}
else if (firstInf) {
- aCurve.D0(Last,P2);
+ aCurve->D0(Last,P2);
do {
delta *= 2;
First = Last - delta;
- aCurve.D0(First,P1);
+ aCurve->D0(First,P1);
} while (P1.Distance(P2) < aLimit);
}
else if (lastInf) {
- aCurve.D0(First,P1);
+ aCurve->D0(First,P1);
do {
delta *= 2;
Last = First + delta;
- aCurve.D0(Last,P2);
+ aCurve->D0(Last,P2);
} while (P1.Distance(P2) < aLimit);
}
}
// function: DrawCurve
// purpose:
//==================================================================
-static void DrawCurve (const Adaptor3d_Curve& aCurve,
+static void DrawCurve (const Handle(Adaptor3d_Curve)& aCurve,
const Handle(Graphic3d_Group) aGroup,
const Standard_Integer NbP,
const Standard_Real U1,
{
Standard_Integer nbintervals = 1;
- if (aCurve.GetType() == GeomAbs_BSplineCurve) {
- nbintervals = aCurve.NbKnots() - 1;
+ if (aCurve->GetType() == GeomAbs_BSplineCurve) {
+ nbintervals = aCurve->NbKnots() - 1;
nbintervals = Max(1, nbintervals/3);
}
- switch (aCurve.GetType())
+ switch (aCurve->GetType())
{
case GeomAbs_Line:
{
- gp_Pnt p1 = aCurve.Value(U1);
- gp_Pnt p2 = aCurve.Value(U2);
+ gp_Pnt p1 = aCurve->Value(U1);
+ gp_Pnt p2 = aCurve->Value(U2);
Points.Append(p1);
Points.Append(p2);
if(drawCurve)
aPrims = new Graphic3d_ArrayOfPolylines(N);
for (Standard_Integer i = 1; i <= N;i++) {
- p = aCurve.Value(U1 + (i-1)*DU);
+ p = aCurve->Value(U1 + (i-1)*DU);
Points.Append(p);
if(drawCurve)
aPrims->AddVertex(p);
const Standard_Real Y,
const Standard_Real Z,
const Standard_Real aDistance,
- const Adaptor3d_Curve& aCurve,
+ const Handle(Adaptor3d_Curve)& aCurve,
const Standard_Real TheDeflection,
const Standard_Integer NbP,
const Standard_Real U1,
const Standard_Real U2)
{
Standard_Real retdist;
- switch (aCurve.GetType())
+ switch (aCurve->GetType())
{
case GeomAbs_Line:
{
- gp_Pnt p1 = aCurve.Value(U1);
+ gp_Pnt p1 = aCurve->Value(U1);
if ( Abs(X-p1.X()) + Abs(Y-p1.Y()) + Abs(Z-p1.Z()) <= aDistance)
return Standard_True;
- gp_Pnt p2 = aCurve.Value(U2);
+ gp_Pnt p2 = aCurve->Value(U2);
if ( Abs(X-p2.X()) + Abs(Y-p2.Y()) + Abs(Z-p2.Z()) <= aDistance)
return Standard_True;
return Prs3d::MatchSegment(X,Y,Z,aDistance,p1,p2,retdist);
}
case GeomAbs_Circle:
{
- const Standard_Real Radius = aCurve.Circle().Radius();
+ const Standard_Real Radius = aCurve->Circle().Radius();
const Standard_Real DU = Sqrt(8.0 * TheDeflection / Radius);
const Standard_Real Er = Abs( U2 - U1) / DU;
const Standard_Integer N = Max(2, (Standard_Integer)IntegerPart(Er));
if ( N > 0) {
gp_Pnt p1,p2;
for (Standard_Integer Index = 1; Index <= N+1; Index++) {
- p2 = aCurve.Value(U1 + (Index - 1) * DU);
+ p2 = aCurve->Value(U1 + (Index - 1) * DU);
if ( Abs(X-p2.X()) + Abs(Y-p2.Y()) + Abs(Z-p2.Z()) <= aDistance)
return Standard_True;
const Standard_Real DU = (U2-U1) / (NbP-1);
gp_Pnt p1,p2;
for (Standard_Integer i=1;i<=NbP;i++) {
- p2 = aCurve.Value(U1 + (i-1)*DU);
+ p2 = aCurve->Value(U1 + (i-1)*DU);
if ( Abs(X-p2.X()) + Abs(Y-p2.Y()) + Abs(Z-p2.Z()) <= aDistance)
return Standard_True;
if (i>1) {
// purpose:
//==================================================================
void StdPrs_Curve::Add (const Handle (Prs3d_Presentation)& aPresentation,
- const Adaptor3d_Curve& aCurve,
+ const Handle(Adaptor3d_Curve)& aCurve,
const Handle (Prs3d_Drawer)& aDrawer,
const Standard_Boolean drawCurve)
{
if (aDrawer->LineArrowDraw()) {
gp_Pnt Location;
gp_Vec Direction;
- aCurve.D1(aCurve.LastParameter(),Location,Direction);
+ aCurve->D1(aCurve->LastParameter(),Location,Direction);
Prs3d_Arrow::Draw (aPresentation->CurrentGroup(), Location, gp_Dir(Direction),
aDrawer->ArrowAspect()->Angle(),
aDrawer->ArrowAspect()->Length());
// purpose:
//==================================================================
void StdPrs_Curve::Add (const Handle (Prs3d_Presentation)& aPresentation,
- const Adaptor3d_Curve& aCurve,
+ const Handle(Adaptor3d_Curve)& aCurve,
const Handle(Prs3d_Drawer)& aDrawer,
TColgp_SequenceOfPnt& Points,
const Standard_Boolean drawCurve)
// purpose:
//==================================================================
void StdPrs_Curve::Add (const Handle (Prs3d_Presentation)& aPresentation,
- const Adaptor3d_Curve& aCurve,
+ const Handle(Adaptor3d_Curve)& aCurve,
const Standard_Real U1,
const Standard_Real U2,
TColgp_SequenceOfPnt& Points,
// purpose:
//==================================================================
void StdPrs_Curve::Add (const Handle (Prs3d_Presentation)& aPresentation,
- const Adaptor3d_Curve& aCurve,
+ const Handle(Adaptor3d_Curve)& aCurve,
const Standard_Real U1,
const Standard_Real U2,
const Handle (Prs3d_Drawer)& aDrawer,
if (aDrawer->LineArrowDraw()) {
gp_Pnt Location;
gp_Vec Direction;
- aCurve.D1(aCurve.LastParameter(),Location,Direction);
+ aCurve->D1(aCurve->LastParameter(),Location,Direction);
Prs3d_Arrow::Draw (aPresentation->CurrentGroup(), Location, gp_Dir(Direction),
aDrawer->ArrowAspect()->Angle(),
aDrawer->ArrowAspect()->Length());
const Standard_Real Y,
const Standard_Real Z,
const Standard_Real aDistance,
- const Adaptor3d_Curve& aCurve,
+ const Handle(Adaptor3d_Curve)& aCurve,
const Handle (Prs3d_Drawer)& aDrawer)
{
Standard_Real V1, V2;
const Standard_Real Y,
const Standard_Real Z,
const Standard_Real aDistance,
- const Adaptor3d_Curve& aCurve,
+ const Handle(Adaptor3d_Curve)& aCurve,
const Standard_Real aDeflection,
const Standard_Real aLimit,
const Standard_Integer NbPoints)
const Standard_Real Y,
const Standard_Real Z,
const Standard_Real aDistance,
- const Adaptor3d_Curve& aCurve,
+ const Handle(Adaptor3d_Curve)& aCurve,
const Standard_Real U1,
const Standard_Real U2,
const Handle (Prs3d_Drawer)& aDrawer)
const Standard_Real Y,
const Standard_Real Z,
const Standard_Real aDistance,
- const Adaptor3d_Curve& aCurve,
+ const Handle(Adaptor3d_Curve)& aCurve,
const Standard_Real U1,
const Standard_Real U2,
const Standard_Real aDeflection,
//! If drawCurve equals Standard_False the curve will not be displayed,
//! it is used if the curve is a part of some shape and PrimitiveArray
//! visualization approach is activated (it is activated by default).
- Standard_EXPORT static void Add (const Handle(Prs3d_Presentation)& aPresentation, const Adaptor3d_Curve& aCurve, const Handle(Prs3d_Drawer)& aDrawer, const Standard_Boolean drawCurve = Standard_True);
+ Standard_EXPORT static void Add (const Handle(Prs3d_Presentation)& aPresentation, const Handle(Adaptor3d_Curve)& aCurve, const Handle(Prs3d_Drawer)& aDrawer, const Standard_Boolean drawCurve = Standard_True);
//! Adds to the presentation aPresentation the drawing of the curve aCurve.
//! The aspect is defined by LineAspect in aDrawer.
//! If drawCurve equals Standard_False the curve will not be displayed,
//! it is used if the curve is a part of some shape and PrimitiveArray
//! visualization approach is activated (it is activated by default).
- Standard_EXPORT static void Add (const Handle(Prs3d_Presentation)& aPresentation, const Adaptor3d_Curve& aCurve, const Standard_Real U1, const Standard_Real U2, const Handle(Prs3d_Drawer)& aDrawer, const Standard_Boolean drawCurve = Standard_True);
+ Standard_EXPORT static void Add (const Handle(Prs3d_Presentation)& aPresentation, const Handle(Adaptor3d_Curve)& aCurve, const Standard_Real U1, const Standard_Real U2, const Handle(Prs3d_Drawer)& aDrawer, const Standard_Boolean drawCurve = Standard_True);
//! adds to the presentation aPresentation the drawing of the curve aCurve.
//! The aspect is the current aspect.
//! If drawCurve equals Standard_False the curve will not be displayed,
//! it is used if the curve is a part of some shape and PrimitiveArray
//! visualization approach is activated (it is activated by default).
- Standard_EXPORT static void Add (const Handle(Prs3d_Presentation)& aPresentation, const Adaptor3d_Curve& aCurve, const Handle(Prs3d_Drawer)& aDrawer, TColgp_SequenceOfPnt& Points, const Standard_Boolean drawCurve = Standard_True);
+ Standard_EXPORT static void Add (const Handle(Prs3d_Presentation)& aPresentation, const Handle(Adaptor3d_Curve)& aCurve, const Handle(Prs3d_Drawer)& aDrawer, TColgp_SequenceOfPnt& Points, const Standard_Boolean drawCurve = Standard_True);
//! adds to the presentation aPresentation the drawing of the curve
//! aCurve.
//! If drawCurve equals Standard_False the curve will not be displayed,
//! it is used if the curve is a part of some shape and PrimitiveArray
//! visualization approach is activated (it is activated by default).
- Standard_EXPORT static void Add (const Handle(Prs3d_Presentation)& aPresentation, const Adaptor3d_Curve& aCurve, const Standard_Real U1, const Standard_Real U2, TColgp_SequenceOfPnt& Points, const Standard_Integer aNbPoints = 30, const Standard_Boolean drawCurve = Standard_True);
+ Standard_EXPORT static void Add (const Handle(Prs3d_Presentation)& aPresentation, const Handle(Adaptor3d_Curve)& aCurve, const Standard_Real U1, const Standard_Real U2, TColgp_SequenceOfPnt& Points, const Standard_Integer aNbPoints = 30, const Standard_Boolean drawCurve = Standard_True);
//! returns true if the distance between the point (X,Y,Z) and the
//! drawing of the curve is less than aDistance.
- Standard_EXPORT static Standard_Boolean Match (const Standard_Real X, const Standard_Real Y, const Standard_Real Z, const Standard_Real aDistance, const Adaptor3d_Curve& aCurve, const Handle(Prs3d_Drawer)& aDrawer);
+ Standard_EXPORT static Standard_Boolean Match (const Standard_Real X, const Standard_Real Y, const Standard_Real Z, const Standard_Real aDistance, const Handle(Adaptor3d_Curve)& aCurve, const Handle(Prs3d_Drawer)& aDrawer);
//! returns true if the distance between the point (X,Y,Z) and the
//! drawing of the curve is less than aDistance.
- Standard_EXPORT static Standard_Boolean Match (const Standard_Real X, const Standard_Real Y, const Standard_Real Z, const Standard_Real aDistance, const Adaptor3d_Curve& aCurve, const Standard_Real aDeflection, const Standard_Real aLimit, const Standard_Integer aNbPoints);
+ Standard_EXPORT static Standard_Boolean Match (const Standard_Real X, const Standard_Real Y, const Standard_Real Z, const Standard_Real aDistance, const Handle(Adaptor3d_Curve)& aCurve, const Standard_Real aDeflection, const Standard_Real aLimit, const Standard_Integer aNbPoints);
//! returns true if the distance between the point (X,Y,Z) and the
//! drawing of the curve aCurve is less than aDistance.
//! The drawing is considered between the points
//! of parameter U1 and U2;
- Standard_EXPORT static Standard_Boolean Match (const Standard_Real X, const Standard_Real Y, const Standard_Real Z, const Standard_Real aDistance, const Adaptor3d_Curve& aCurve, const Standard_Real U1, const Standard_Real U2, const Handle(Prs3d_Drawer)& aDrawer);
+ Standard_EXPORT static Standard_Boolean Match (const Standard_Real X, const Standard_Real Y, const Standard_Real Z, const Standard_Real aDistance, const Handle(Adaptor3d_Curve)& aCurve, const Standard_Real U1, const Standard_Real U2, const Handle(Prs3d_Drawer)& aDrawer);
//! returns true if the distance between the point (X,Y,Z) and the
//! drawing of the curve aCurve is less than aDistance.
//! The drawing is considered between the points
//! of parameter U1 and U2;
- Standard_EXPORT static Standard_Boolean Match (const Standard_Real X, const Standard_Real Y, const Standard_Real Z, const Standard_Real aDistance, const Adaptor3d_Curve& aCurve, const Standard_Real U1, const Standard_Real U2, const Standard_Real aDeflection, const Standard_Integer aNbPoints);
+ Standard_EXPORT static Standard_Boolean Match (const Standard_Real X, const Standard_Real Y, const Standard_Real Z, const Standard_Real aDistance, const Handle(Adaptor3d_Curve)& aCurve, const Standard_Real U1, const Standard_Real U2, const Standard_Real aDeflection, const Standard_Integer aNbPoints);
};
// function: GetDeflection
// purpose:
//==================================================================
-static Standard_Real GetDeflection(const Adaptor3d_Curve& aCurve,
+static Standard_Real GetDeflection(const Handle(Adaptor3d_Curve)& aCurve,
const Standard_Real U1,
const Standard_Real U2,
const Handle(Prs3d_Drawer)& aDrawer)
// function: FindLimits
// purpose:
//==================================================================
-static Standard_Boolean FindLimits(const Adaptor3d_Curve& aCurve,
+static Standard_Boolean FindLimits(const Handle(Adaptor3d_Curve)& aCurve,
const Standard_Real aLimit,
Standard_Real& First,
Standard_Real& Last)
{
- First = aCurve.FirstParameter();
- Last = aCurve.LastParameter();
+ First = aCurve->FirstParameter();
+ Last = aCurve->LastParameter();
Standard_Boolean firstInf = Precision::IsNegativeInfinite(First);
Standard_Boolean lastInf = Precision::IsPositiveInfinite(Last);
delta *= 2;
First = - delta;
Last = delta;
- aCurve.D0(First,P1);
- aCurve.D0(Last,P2);
+ aCurve->D0(First,P1);
+ aCurve->D0(Last,P2);
} while (P1.Distance(P2) < aLimit);
}
else if (firstInf) {
- aCurve.D0(Last,P2);
+ aCurve->D0(Last,P2);
do {
if (count++ == 100000) return Standard_False;
delta *= 2;
First = Last - delta;
- aCurve.D0(First,P1);
+ aCurve->D0(First,P1);
} while (P1.Distance(P2) < aLimit);
}
else if (lastInf) {
- aCurve.D0(First,P1);
+ aCurve->D0(First,P1);
do {
if (count++ == 100000) return Standard_False;
delta *= 2;
Last = First + delta;
- aCurve.D0(Last,P2);
+ aCurve->D0(Last,P2);
} while (P1.Distance(P2) < aLimit);
}
}
// function: drawCurve
// purpose:
//==================================================================
-static void drawCurve (Adaptor3d_Curve& aCurve,
+static void drawCurve (const Handle(Adaptor3d_Curve)& aCurve,
const Handle(Graphic3d_Group)& aGroup,
const Standard_Real TheDeflection,
const Standard_Real anAngle,
const Standard_Real U2,
TColgp_SequenceOfPnt& Points)
{
- switch (aCurve.GetType())
+ switch (aCurve->GetType())
{
case GeomAbs_Line:
{
- gp_Pnt p1 = aCurve.Value(U1);
- gp_Pnt p2 = aCurve.Value(U2);
+ gp_Pnt p1 = aCurve->Value(U1);
+ gp_Pnt p2 = aCurve->Value(U2);
Points.Append(p1);
Points.Append(p2);
if (!aGroup.IsNull())
}
default:
{
- const Standard_Integer nbinter = aCurve.NbIntervals(GeomAbs_C1);
+ const Standard_Integer nbinter = aCurve->NbIntervals(GeomAbs_C1);
TColStd_Array1OfReal T(1, nbinter+1);
- aCurve.Intervals(T, GeomAbs_C1);
+ aCurve->Intervals(T, GeomAbs_C1);
Standard_Real theU1, theU2;
Standard_Integer NumberOfPoints, i, j;
const Standard_Real Y,
const Standard_Real Z,
const Standard_Real aDistance,
- const Adaptor3d_Curve& aCurve,
+ const Handle(Adaptor3d_Curve)& aCurve,
const Standard_Real TheDeflection,
const Standard_Real anAngle,
const Standard_Real U1,
const Standard_Real U2)
{
Standard_Real retdist;
- switch (aCurve.GetType())
+ switch (aCurve->GetType())
{
case GeomAbs_Line:
{
- gp_Pnt p1 = aCurve.Value(U1);
+ gp_Pnt p1 = aCurve->Value(U1);
if ( Abs(X-p1.X()) + Abs(Y-p1.Y()) + Abs(Z-p1.Z()) <= aDistance)
return Standard_True;
- gp_Pnt p2 = aCurve.Value(U2);
+ gp_Pnt p2 = aCurve->Value(U2);
if ( Abs(X-p2.X()) + Abs(Y-p2.Y()) + Abs(Z-p2.Z()) <= aDistance)
return Standard_True;
return Prs3d::MatchSegment(X,Y,Z,aDistance,p1,p2,retdist);
}
case GeomAbs_Circle:
{
- const Standard_Real Radius = aCurve.Circle().Radius();
+ const Standard_Real Radius = aCurve->Circle().Radius();
if (!Precision::IsInfinite(Radius)) {
const Standard_Real DU = Sqrt(8.0 * TheDeflection / Radius);
const Standard_Real Er = Abs( U2 - U1) / DU;
if ( N > 0) {
gp_Pnt p1,p2;
for (Standard_Integer Index = 1; Index <= N+1; Index++) {
- p2 = aCurve.Value(U1 + (Index - 1) * DU);
+ p2 = aCurve->Value(U1 + (Index - 1) * DU);
if ( Abs(X-p2.X()) + Abs(Y-p2.Y()) + Abs(Z-p2.Z()) <= aDistance)
return Standard_True;
// purpose:
//==================================================================
void StdPrs_DeflectionCurve::Add (const Handle (Prs3d_Presentation)& aPresentation,
- Adaptor3d_Curve& aCurve,
+ const Handle(Adaptor3d_Curve)& aCurve,
const Handle (Prs3d_Drawer)& aDrawer,
const Standard_Boolean theToDrawCurve)
{
{
gp_Pnt Location;
gp_Vec Direction;
- aCurve.D1(V2, Location,Direction);
+ aCurve->D1(V2, Location,Direction);
Prs3d_Arrow::Draw (aGroup,
Location,
gp_Dir(Direction),
// purpose:
//==================================================================
void StdPrs_DeflectionCurve::Add (const Handle (Prs3d_Presentation)& aPresentation,
- Adaptor3d_Curve& aCurve,
+ const Handle(Adaptor3d_Curve)& aCurve,
const Standard_Real U1,
const Standard_Real U2,
const Handle (Prs3d_Drawer)& aDrawer,
{
gp_Pnt Location;
gp_Vec Direction;
- aCurve.D1(V2, Location,Direction);
+ aCurve->D1(V2, Location,Direction);
Prs3d_Arrow::Draw (aGroup,
Location,
gp_Dir(Direction),
// purpose:
//==================================================================
void StdPrs_DeflectionCurve::Add (const Handle (Prs3d_Presentation)& aPresentation,
- Adaptor3d_Curve& aCurve,
+ const Handle(Adaptor3d_Curve)& aCurve,
const Standard_Real U1,
const Standard_Real U2,
const Standard_Real aDeflection,
// purpose:
//==================================================================
void StdPrs_DeflectionCurve::Add (const Handle (Prs3d_Presentation)& aPresentation,
- Adaptor3d_Curve& aCurve,
+ const Handle(Adaptor3d_Curve)& aCurve,
const Standard_Real aDeflection,
const Standard_Real aLimit,
const Standard_Real anAngle,
// purpose:
//================================================================================
void StdPrs_DeflectionCurve::Add (const Handle (Prs3d_Presentation)& aPresentation,
- Adaptor3d_Curve& aCurve,
+ const Handle(Adaptor3d_Curve)& aCurve,
const Standard_Real aDeflection,
const Handle(Prs3d_Drawer)& aDrawer,
TColgp_SequenceOfPnt& Points,
const Standard_Real Y,
const Standard_Real Z,
const Standard_Real aDistance,
- const Adaptor3d_Curve& aCurve,
+ const Handle(Adaptor3d_Curve)& aCurve,
const Handle (Prs3d_Drawer)& aDrawer)
{
Standard_Real V1, V2;
const Standard_Real Y,
const Standard_Real Z,
const Standard_Real aDistance,
- const Adaptor3d_Curve& aCurve,
+ const Handle(Adaptor3d_Curve)& aCurve,
const Standard_Real U1,
const Standard_Real U2,
const Handle (Prs3d_Drawer)& aDrawer)
const Standard_Real Y,
const Standard_Real Z,
const Standard_Real aDistance,
- const Adaptor3d_Curve& aCurve,
+ const Handle(Adaptor3d_Curve)& aCurve,
const Standard_Real U1,
const Standard_Real U2,
const Standard_Real aDeflection,
const Standard_Real Y,
const Standard_Real Z,
const Standard_Real aDistance,
- const Adaptor3d_Curve& aCurve,
+ const Handle(Adaptor3d_Curve)& aCurve,
const Standard_Real aDeflection,
const Standard_Real aLimit,
const Standard_Real anAngle)
//! If drawCurve equals Standard_False the curve will not be displayed,
//! it is used if the curve is a part of some shape and PrimitiveArray
//! visualization approach is activated (it is activated by default).
- Standard_EXPORT static void Add (const Handle(Prs3d_Presentation)& aPresentation, Adaptor3d_Curve& aCurve, const Handle(Prs3d_Drawer)& aDrawer, const Standard_Boolean drawCurve = Standard_True);
+ Standard_EXPORT static void Add (const Handle(Prs3d_Presentation)& aPresentation, const Handle(Adaptor3d_Curve)& aCurve, const Handle(Prs3d_Drawer)& aDrawer, const Standard_Boolean drawCurve = Standard_True);
//! adds to the presentation aPresentation the drawing of the curve
//! aCurve with respect to the maximal chordial deviation defined
//! If drawCurve equals Standard_False the curve will not be displayed,
//! it is used if the curve is a part of some shape and PrimitiveArray
//! visualization approach is activated (it is activated by default).
- Standard_EXPORT static void Add (const Handle(Prs3d_Presentation)& aPresentation, Adaptor3d_Curve& aCurve, const Standard_Real U1, const Standard_Real U2, const Handle(Prs3d_Drawer)& aDrawer, const Standard_Boolean drawCurve = Standard_True);
+ Standard_EXPORT static void Add (const Handle(Prs3d_Presentation)& aPresentation, const Handle(Adaptor3d_Curve)& aCurve, const Standard_Real U1, const Standard_Real U2, const Handle(Prs3d_Drawer)& aDrawer, const Standard_Boolean drawCurve = Standard_True);
//! adds to the presentation aPresentation the drawing of the curve
//! aCurve with respect to the maximal chordial deviation aDeflection.
//! If drawCurve equals Standard_False the curve will not be displayed,
//! it is used if the curve is a part of some shape and PrimitiveArray
//! visualization approach is activated (it is activated by default).
- Standard_EXPORT static void Add (const Handle(Prs3d_Presentation)& aPresentation, Adaptor3d_Curve& aCurve, const Standard_Real aDeflection, const Standard_Real aLimit, const Standard_Real anAngle = 0.2, const Standard_Boolean drawCurve = Standard_True);
+ Standard_EXPORT static void Add (const Handle(Prs3d_Presentation)& aPresentation, const Handle(Adaptor3d_Curve)& aCurve, const Standard_Real aDeflection, const Standard_Real aLimit, const Standard_Real anAngle = 0.2, const Standard_Boolean drawCurve = Standard_True);
//! adds to the presentation aPresentation the drawing of the curve
//! aCurve with respect to the maximal chordial deviation aDeflection.
//! If drawCurve equals Standard_False the curve will not be displayed,
//! it is used if the curve is a part of some shape and PrimitiveArray
//! visualization approach is activated (it is activated by default).
- Standard_EXPORT static void Add (const Handle(Prs3d_Presentation)& aPresentation, Adaptor3d_Curve& aCurve, const Standard_Real aDeflection, const Handle(Prs3d_Drawer)& aDrawer, TColgp_SequenceOfPnt& Points, const Standard_Boolean drawCurve = Standard_True);
+ Standard_EXPORT static void Add (const Handle(Prs3d_Presentation)& aPresentation, const Handle(Adaptor3d_Curve)& aCurve, const Standard_Real aDeflection, const Handle(Prs3d_Drawer)& aDrawer, TColgp_SequenceOfPnt& Points, const Standard_Boolean drawCurve = Standard_True);
//! adds to the presentation aPresentation the drawing of the curve
//! aCurve with respect to the maximal chordial deviation aDeflection.
//! If drawCurve equals Standard_False the curve will not be displayed,
//! it is used if the curve is a part of some shape and PrimitiveArray
//! visualization approach is activated (it is activated by default).
- Standard_EXPORT static void Add (const Handle(Prs3d_Presentation)& aPresentation, Adaptor3d_Curve& aCurve, const Standard_Real U1, const Standard_Real U2, const Standard_Real aDeflection, TColgp_SequenceOfPnt& Points, const Standard_Real anAngle = 0.2, const Standard_Boolean drawCurve = Standard_True);
+ Standard_EXPORT static void Add (const Handle(Prs3d_Presentation)& aPresentation, const Handle(Adaptor3d_Curve)& aCurve, const Standard_Real U1, const Standard_Real U2, const Standard_Real aDeflection, TColgp_SequenceOfPnt& Points, const Standard_Real anAngle = 0.2, const Standard_Boolean drawCurve = Standard_True);
//! returns true if the distance between the point (X,Y,Z) and the
//! drawing of the curve aCurve with respect of the maximal
//! chordial deviation defined by the drawer aDrawer is less then aDistance.
- Standard_EXPORT static Standard_Boolean Match (const Standard_Real X, const Standard_Real Y, const Standard_Real Z, const Standard_Real aDistance, const Adaptor3d_Curve& aCurve, const Handle(Prs3d_Drawer)& aDrawer);
+ Standard_EXPORT static Standard_Boolean Match (const Standard_Real X, const Standard_Real Y, const Standard_Real Z, const Standard_Real aDistance, const Handle(Adaptor3d_Curve)& aCurve, const Handle(Prs3d_Drawer)& aDrawer);
//! returns true if the distance between the point (X,Y,Z) and the
//! drawing of the curve aCurve with respect of the maximal
//! chordial deviation defined by the drawer aDrawer is less
//! then aDistance. The drawing is considered between the points
//! of parameter U1 and U2;
- Standard_EXPORT static Standard_Boolean Match (const Standard_Real X, const Standard_Real Y, const Standard_Real Z, const Standard_Real aDistance, const Adaptor3d_Curve& aCurve, const Standard_Real U1, const Standard_Real U2, const Handle(Prs3d_Drawer)& aDrawer);
+ Standard_EXPORT static Standard_Boolean Match (const Standard_Real X, const Standard_Real Y, const Standard_Real Z, const Standard_Real aDistance, const Handle(Adaptor3d_Curve)& aCurve, const Standard_Real U1, const Standard_Real U2, const Handle(Prs3d_Drawer)& aDrawer);
//! Returns true if the distance between the point (theX, theY, theZ)
//! and the drawing with respect of the maximal chordial deviation theDeflection is less then theDistance.
Standard_EXPORT static Standard_Boolean Match (const Standard_Real theX, const Standard_Real theY, const Standard_Real theZ, const Standard_Real theDistance,
- const Adaptor3d_Curve& theCurve,
+ const Handle(Adaptor3d_Curve)& theCurve,
const Standard_Real theDeflection, const Standard_Real theLimit, const Standard_Real theAngle);
//! Returns true if the distance between the point (theX, theY, theZ)
//! and the drawing with respect of the maximal chordial deviation theDeflection is less then theDistance.
//! The drawing is considered between the points of parameter theU1 and theU2.
Standard_EXPORT static Standard_Boolean Match (const Standard_Real theX, const Standard_Real theY, const Standard_Real theZ, const Standard_Real theDistance,
- const Adaptor3d_Curve& theCurve, const Standard_Real theU1, const Standard_Real theU2,
+ const Handle(Adaptor3d_Curve)& theCurve, const Standard_Real theU1, const Standard_Real theU2,
const Standard_Real theDeflection, const Standard_Real theAngle);
};
Standard_Integer aNbEdges = aTool.NbEdges();
Standard_Integer anI;
Standard_Real anU1, anU2;
- BRepAdaptor_Curve aCurve;
+ Handle(BRepAdaptor_Curve) aCurve = new BRepAdaptor_Curve();
Standard_Real aDeviation = theDrawer->MaximalChordialDeviation();
Handle(Graphic3d_Group) aGroup = thePresentation->CurrentGroup();
void StdPrs_HLRToolShape::NextVisible() {
myEdgeIterator.NextVisible();
}
-void StdPrs_HLRToolShape::Visible(BRepAdaptor_Curve& TheEdge,
+void StdPrs_HLRToolShape::Visible(Handle(BRepAdaptor_Curve)& TheEdge,
Standard_Real& U1,
Standard_Real& U2) {
void StdPrs_HLRToolShape::NextHidden() {
myEdgeIterator.NextHidden();
}
-void StdPrs_HLRToolShape::Hidden (BRepAdaptor_Curve& TheEdge,
+void StdPrs_HLRToolShape::Hidden (Handle(BRepAdaptor_Curve)& TheEdge,
Standard_Real& U1,
Standard_Real& U2) {
Standard_EXPORT void NextVisible();
- Standard_EXPORT void Visible (BRepAdaptor_Curve& TheEdge, Standard_Real& U1, Standard_Real& U2);
+ Standard_EXPORT void Visible (Handle(BRepAdaptor_Curve)& TheEdge, Standard_Real& U1, Standard_Real& U2);
Standard_EXPORT void InitHidden (const Standard_Integer EdgeNumber);
Standard_EXPORT void NextHidden();
- Standard_EXPORT void Hidden (BRepAdaptor_Curve& TheEdge, Standard_Real& U1, Standard_Real& U2);
+ Standard_EXPORT void Hidden (Handle(BRepAdaptor_Curve)& TheEdge, Standard_Real& U1, Standard_Real& U2);
//! @param theLimit [in] the parameter limit value.
//! @param theFirst [in/out] the first parameter value.
//! @param theLast [in/out] the last parameter value.
- static void findLimits (const Adaptor3d_Curve& theCurve,
+ static void findLimits (const Handle(Adaptor3d_Curve)& theCurve,
const Standard_Real theLimit,
Standard_Real& theFirst,
Standard_Real& theLast)
{
- theFirst = Max (theCurve.FirstParameter(), theFirst);
- theLast = Min (theCurve.LastParameter(), theLast);
+ theFirst = Max (theCurve->FirstParameter(), theFirst);
+ theLast = Min (theCurve->LastParameter(), theLast);
Standard_Boolean isFirstInf = Precision::IsNegativeInfinite (theFirst);
Standard_Boolean isLastInf = Precision::IsPositiveInfinite (theLast);
aDelta *= 2.0;
theFirst = -aDelta;
theLast = aDelta;
- theCurve.D0 (theFirst, aP1);
- theCurve.D0 (theLast, aP2);
+ theCurve->D0 (theFirst, aP1);
+ theCurve->D0 (theLast, aP2);
}
while (aP1.Distance (aP2) < theLimit);
}
else if (isFirstInf)
{
- theCurve.D0 (theLast, aP2);
+ theCurve->D0 (theLast, aP2);
do
{
aDelta *= 2.0;
theFirst = theLast - aDelta;
- theCurve.D0 (theFirst, aP1);
+ theCurve->D0 (theFirst, aP1);
}
while (aP1.Distance (aP2) < theLimit);
}
else if (isLastInf)
{
- theCurve.D0 (theFirst, aP1);
+ theCurve->D0 (theFirst, aP1);
do
{
aDelta *= 2.0;
theLast = theFirst + aDelta;
- theCurve.D0 (theLast, aP2);
+ theCurve->D0 (theLast, aP2);
}
while (aP1.Distance (aP2) < theLimit);
}
for (anEdgeTool.Init(); anEdgeTool.More(); anEdgeTool.Next())
{
TopAbs_Orientation anOrientation = anEdgeTool.Orientation();
- const Adaptor2d_Curve2d* anEdgeCurve = &anEdgeTool.Value();
+ const Handle(Adaptor2d_Curve2d) anEdgeCurve = anEdgeTool.Value();
if (anEdgeCurve->GetType() != GeomAbs_Line)
{
- GCPnts_QuasiUniformDeflection aSampler (*anEdgeCurve, aSamplerDeflection);
+ GCPnts_QuasiUniformDeflection aSampler (anEdgeCurve, aSamplerDeflection);
if (!aSampler.IsDone())
{
#ifdef OCCT_DEBUG
// Use isoline adapter for other types of surfaces.
GeomAbs_SurfaceType aSurfType = theSurface->GetType();
Handle(Geom_Surface) aBSurface;
- GeomAdaptor_Curve aBSurfaceCurve;
- Adaptor3d_IsoCurve aCanonicalCurve;
+ Handle(GeomAdaptor_Curve) aBSurfaceCurve = new GeomAdaptor_Curve();
+ Handle(Adaptor3d_IsoCurve) aCanonicalCurve = new Adaptor3d_IsoCurve();
if (aSurfType == GeomAbs_BezierSurface)
{
aBSurface = theSurface->Bezier();
}
else
{
- aCanonicalCurve.Load (theSurface);
+ aCanonicalCurve->Load (theSurface);
}
// For each isoline: compute its segments.
if (!aBSurface.IsNull())
{
- aBSurfaceCurve.Load (isIsoU ? aBSurface->UIso (anIsoParam) : aBSurface->VIso (anIsoParam));
+ aBSurfaceCurve->Load (isIsoU ? aBSurface->UIso (anIsoParam) : aBSurface->VIso (anIsoParam));
findLimits (aBSurfaceCurve, aUVLimit, aSegmentP1, aSegmentP2);
}
else
{
- aCanonicalCurve.Load (isIsoU ? GeomAbs_IsoU : GeomAbs_IsoV, anIsoParam, aSegmentP1, aSegmentP2);
+ aCanonicalCurve->Load (isIsoU ? GeomAbs_IsoU : GeomAbs_IsoV, anIsoParam, aSegmentP1, aSegmentP2);
findLimits (aCanonicalCurve, aUVLimit, aSegmentP1, aSegmentP2);
continue;
}
}
- Adaptor3d_Curve* aCurve = aBSurface.IsNull() ? (Adaptor3d_Curve*) &aCanonicalCurve
- : (Adaptor3d_Curve*) &aBSurfaceCurve;
+
+ Handle(Adaptor3d_Curve) aCurve;
+ if (aBSurface.IsNull())
+ aCurve = aCanonicalCurve;
+ else
+ aCurve = aBSurfaceCurve;
Handle(TColgp_HSequenceOfPnt) aPoints = new TColgp_HSequenceOfPnt();
StdPrs_DeflectionCurve::Add (Handle(Prs3d_Presentation)(),
- *aCurve,
+ aCurve,
aSegmentP1,
aSegmentP2,
theDeflection,
anIso2 = theSurface->UIso (aNodeUV2.X());
}
- GeomAdaptor_Curve aCurveAdaptor1 (anIso1);
- GeomAdaptor_Curve aCurveAdaptor2 (anIso2);
+ Handle(GeomAdaptor_Curve) aCurveAdaptor1 = new GeomAdaptor_Curve(anIso1);
+ Handle(GeomAdaptor_Curve) aCurveAdaptor2 = new GeomAdaptor_Curve(anIso2);
Standard_Real aLength1 = GCPnts_AbscissaPoint::Length (aCurveAdaptor1, aPntOnNode1Iso, aPntOnNode3Iso, 1e-2);
Standard_Real aLength2 = GCPnts_AbscissaPoint::Length (aCurveAdaptor2, aPntOnNode2Iso, aPntOnNode3Iso, 1e-2);
if (Abs (aLength1) < Precision::Confusion() || Abs (aLength2) < Precision::Confusion())
#include <StdPrs_Plane.hxx>
void StdPrs_Plane::Add (const Handle (Prs3d_Presentation)& aPresentation,
- const Adaptor3d_Surface& aPlane,
+ const Handle(Adaptor3d_Surface)& aPlane,
const Handle (Prs3d_Drawer)& aDrawer)
{
// aPresentation->NewGroup();
Handle(Graphic3d_Group) TheGroup = aPresentation->CurrentGroup();
- if (aPlane.GetType() != GeomAbs_Plane) return;
- Handle(Geom_Plane) thegeom = new Geom_Plane(aPlane.Plane());
+ if (aPlane->GetType() != GeomAbs_Plane) return;
+ Handle(Geom_Plane) thegeom = new Geom_Plane(aPlane->Plane());
Handle(Prs3d_PlaneAspect) theaspect = aDrawer->PlaneAspect();
const Standard_Real Y,
const Standard_Real Z,
const Standard_Real aDistance,
- const Adaptor3d_Surface& aPlane,
+ const Handle(Adaptor3d_Surface)& aPlane,
const Handle (Prs3d_Drawer)&)
{
- if (aPlane.GetType() == GeomAbs_Plane) {
- gp_Pln theplane = aPlane.Plane();
+ if (aPlane->GetType() == GeomAbs_Plane) {
+ gp_Pln theplane = aPlane->Plane();
gp_Pnt thepoint (X,Y,Z);
return (Abs(theplane.Distance(thepoint)) <= aDistance);
//! The infinite plane aPlane is added to the display
//! aPresentation, and the attributes of the display are
//! defined by the attribute manager aDrawer.
- Standard_EXPORT static void Add (const Handle(Prs3d_Presentation)& aPresentation, const Adaptor3d_Surface& aPlane, const Handle(Prs3d_Drawer)& aDrawer);
+ Standard_EXPORT static void Add (const Handle(Prs3d_Presentation)& aPresentation, const Handle(Adaptor3d_Surface)& aPlane, const Handle(Prs3d_Drawer)& aDrawer);
//! returns true if the distance between the point (X,Y,Z) and the
//! plane is less than aDistance.
- Standard_EXPORT static Standard_Boolean Match (const Standard_Real X, const Standard_Real Y, const Standard_Real Z, const Standard_Real aDistance, const Adaptor3d_Surface& aPlane, const Handle(Prs3d_Drawer)& aDrawer);
+ Standard_EXPORT static Standard_Boolean Match (const Standard_Real X, const Standard_Real Y, const Standard_Real Z, const Standard_Real aDistance, const Handle(Adaptor3d_Surface)& aPlane, const Handle(Prs3d_Drawer)& aDrawer);
};
//purpose :
//=======================================================================
void StdPrs_PoleCurve::Add (const Handle (Prs3d_Presentation)& aPresentation,
- const Adaptor3d_Curve& aCurve,
+ const Handle(Adaptor3d_Curve)& aCurve,
const Handle (Prs3d_Drawer)& aDrawer)
{
aPresentation->CurrentGroup()->SetPrimitivesAspect(aDrawer->LineAspect()->Aspect());
- GeomAbs_CurveType CType = aCurve.GetType();
+ GeomAbs_CurveType CType = aCurve->GetType();
if (CType == GeomAbs_BezierCurve || CType == GeomAbs_BSplineCurve) {
Standard_Integer i, Nb;
if (CType == GeomAbs_BezierCurve) {
- Handle(Geom_BezierCurve) Bz = aCurve.Bezier();
+ Handle(Geom_BezierCurve) Bz = aCurve->Bezier();
Nb = Bz->NbPoles();
Handle(Graphic3d_ArrayOfPolylines) aPrims = new Graphic3d_ArrayOfPolylines(Nb);
for (i = 1; i <= Nb; i++)
aPresentation->CurrentGroup()->AddPrimitiveArray(aPrims);
}
else if (CType == GeomAbs_BSplineCurve) {
- Handle(Geom_BSplineCurve) Bs = aCurve.BSpline();
+ Handle(Geom_BSplineCurve) Bs = aCurve->BSpline();
Nb = Bs->NbPoles();
Handle(Graphic3d_ArrayOfPolylines) aPrims = new Graphic3d_ArrayOfPolylines(Nb);
for (i = 1; i <= Nb; i++)
if (aDrawer->LineArrowDraw()) {
gp_Pnt Location;
gp_Vec Direction;
- aCurve.D1(aCurve.LastParameter(),Location,Direction);
+ aCurve->D1(aCurve->LastParameter(),Location,Direction);
Prs3d_Arrow::Draw (aPresentation->CurrentGroup(),
Location,
gp_Dir(Direction),
const Standard_Real Y,
const Standard_Real Z,
const Standard_Real aDistance,
- const Adaptor3d_Curve& aCurve,
+ const Handle(Adaptor3d_Curve)& aCurve,
const Handle (Prs3d_Drawer)& /*aDrawer*/)
{
- GeomAbs_CurveType CType = aCurve.GetType();
+ GeomAbs_CurveType CType = aCurve->GetType();
Standard_Integer i, Nb = 0;
Standard_Real x,y,z;
if (CType == GeomAbs_BezierCurve) {
- Handle(Geom_BezierCurve) Bz = aCurve.Bezier();
+ Handle(Geom_BezierCurve) Bz = aCurve->Bezier();
Nb = Bz->NbPoles();
for (i = 1; i <= Nb; i++) {
Bz->Pole(i).Coord(x,y,z);
return Standard_False;
}
else if (CType == GeomAbs_BSplineCurve) {
- Handle(Geom_BSplineCurve) Bs = aCurve.BSpline();
+ Handle(Geom_BSplineCurve) Bs = aCurve->BSpline();
Nb = Bs->NbPoles();
for (i = 1; i <= Nb; i++) {
Bs->Pole(i).Coord(x,y,z);
const Standard_Real Y,
const Standard_Real Z,
const Standard_Real aDistance,
- const Adaptor3d_Curve& aCurve,
+ const Handle(Adaptor3d_Curve)& aCurve,
const Handle(Prs3d_Drawer)& /*aDrawer*/)
{
Standard_Real x, y, z, DistMin = RealLast();
Standard_Integer num = 0, i, Nb = 0;
Standard_Real dist;
- GeomAbs_CurveType CType = aCurve.GetType();
+ GeomAbs_CurveType CType = aCurve->GetType();
if (CType == GeomAbs_BezierCurve) {
- Handle(Geom_BezierCurve) Bz = aCurve.Bezier();
+ Handle(Geom_BezierCurve) Bz = aCurve->Bezier();
Nb = Bz->NbPoles();
for (i = 1; i <= Nb; i++) {
Bz->Pole(i).Coord(x,y,z);
}
}
else if (CType == GeomAbs_BSplineCurve) {
- Handle(Geom_BSplineCurve) Bs = aCurve.BSpline();
+ Handle(Geom_BSplineCurve) Bs = aCurve->BSpline();
Nb = Bs->NbPoles();
for (i = 1; i <= Nb; i++) {
Bs->Pole(i).Coord(x,y,z);
//! The curve object from Adaptor3d provides data from
//! a Geom curve. This makes it possible to use the
//! surface in a geometric algorithm.
- Standard_EXPORT static void Add (const Handle(Prs3d_Presentation)& aPresentation, const Adaptor3d_Curve& aCurve, const Handle(Prs3d_Drawer)& aDrawer);
+ Standard_EXPORT static void Add (const Handle(Prs3d_Presentation)& aPresentation, const Handle(Adaptor3d_Curve)& aCurve, const Handle(Prs3d_Drawer)& aDrawer);
//! returns true if the distance between the point (X,Y,Z) and the
//! broken line made of the poles is less then aDistance.
- Standard_EXPORT static Standard_Boolean Match (const Standard_Real X, const Standard_Real Y, const Standard_Real Z, const Standard_Real aDistance, const Adaptor3d_Curve& aCurve, const Handle(Prs3d_Drawer)& aDrawer);
+ Standard_EXPORT static Standard_Boolean Match (const Standard_Real X, const Standard_Real Y, const Standard_Real Z, const Standard_Real aDistance, const Handle(Adaptor3d_Curve)& aCurve, const Handle(Prs3d_Drawer)& aDrawer);
//! returns the pole the most near of the point (X,Y,Z) and
//! returns its range. The distance between the pole and
//! (X,Y,Z) must be less then aDistance. If no pole corresponds, 0 is returned.
- Standard_EXPORT static Standard_Integer Pick (const Standard_Real X, const Standard_Real Y, const Standard_Real Z, const Standard_Real aDistance, const Adaptor3d_Curve& aCurve, const Handle(Prs3d_Drawer)& aDrawer);
+ Standard_EXPORT static Standard_Integer Pick (const Standard_Real X, const Standard_Real Y, const Standard_Real Z, const Standard_Real aDistance, const Handle(Adaptor3d_Curve)& aCurve, const Handle(Prs3d_Drawer)& aDrawer);
};
//purpose :
//=======================================================================
void StdPrs_ShadedSurface::Add (const Handle(Prs3d_Presentation)& thePrs,
- const Adaptor3d_Surface& theSurface,
+ const Handle(Adaptor3d_Surface)& theSurface,
const Handle(Prs3d_Drawer)& theDrawer)
{
Standard_Integer N1 = theDrawer->UIsoAspect()->Number();
// If the surface is closed, the faces from back-side are not traced:
Handle(Graphic3d_Group) aGroup = thePrs->CurrentGroup();
aGroup->SetGroupPrimitivesAspect (theDrawer->ShadingAspect()->Aspect());
- aGroup->SetClosed (theSurface.IsUClosed() && theSurface.IsVClosed());
+ aGroup->SetClosed (theSurface->IsUClosed() && theSurface->IsVClosed());
- Standard_Integer aNBUintv = theSurface.NbUIntervals (GeomAbs_C1);
- Standard_Integer aNBVintv = theSurface.NbVIntervals (GeomAbs_C1);
+ Standard_Integer aNBUintv = theSurface->NbUIntervals (GeomAbs_C1);
+ Standard_Integer aNBVintv = theSurface->NbVIntervals (GeomAbs_C1);
TColStd_Array1OfReal anInterU (1, aNBUintv + 1);
TColStd_Array1OfReal anInterV (1, aNBVintv + 1);
- theSurface.UIntervals (anInterU, GeomAbs_C1);
- theSurface.VIntervals (anInterV, GeomAbs_C1);
+ theSurface->UIntervals (anInterU, GeomAbs_C1);
+ theSurface->VIntervals (anInterV, GeomAbs_C1);
Standard_Real U1, U2, V1, V2, DU, DV;
aPArray->AddBound (N2 + 1);
for (Standard_Integer j = 1; j <= N2 + 1; ++j)
{
- theSurface.D1 (U1 + DU * (i - 1), V1 + DV * (j - 1), P2, D1U, D1V);
+ theSurface->D1 (U1 + DU * (i - 1), V1 + DV * (j - 1), P2, D1U, D1V);
D1 = D1U ^ D1V;
D1.Normalize();
- theSurface.D1 (U1 + DU * i, V1 + DV * (j - 1), P2, D1U, D1V);
+ theSurface->D1 (U1 + DU * i, V1 + DV * (j - 1), P2, D1U, D1V);
D2 = D1U ^ D1V;
D2.Normalize();
aPArray->AddVertex (P1, D1);
//! The surface's display attributes are set in the attribute manager aDrawer.
//! The surface object from Adaptor3d provides data
//! from a Geom surface in order to use the surface in an algorithm.
- Standard_EXPORT static void Add (const Handle(Prs3d_Presentation)& aPresentation, const Adaptor3d_Surface& aSurface, const Handle(Prs3d_Drawer)& aDrawer);
+ Standard_EXPORT static void Add (const Handle(Prs3d_Presentation)& aPresentation, const Handle(Adaptor3d_Surface)& aSurface, const Handle(Prs3d_Drawer)& aDrawer);
//purpose :
//=======================================================================
StdPrs_ToolRFace::StdPrs_ToolRFace()
-: myHasNullCurves (Standard_False)
+: myCurve(new Geom2dAdaptor_Curve()),
+ myHasNullCurves (Standard_False)
{
}
//=======================================================================
StdPrs_ToolRFace::StdPrs_ToolRFace (const Handle(BRepAdaptor_Surface)& theSurface)
: myFace (theSurface->Face()),
+ myCurve(new Geom2dAdaptor_Curve()),
myHasNullCurves (Standard_False)
{
myFace.Orientation(TopAbs_FORWARD);
if (Handle(Geom2d_Curve) aCurve = BRep_Tool::CurveOnSurface (TopoDS::Edge (myExplorer.Current()), myFace, aParamU1, aParamU2))
{
- myCurve.Load (aCurve, aParamU1, aParamU2);
+ myCurve->Load (aCurve, aParamU1, aParamU2);
return;
}
else
}
}
- myCurve.Reset();
+ myCurve->Reset();
}
}
//! Return current curve.
- const Adaptor2d_Curve2d& Value() const { return myCurve; }
+ const Handle(Adaptor2d_Curve2d)& Value() const { return myCurve; }
//! Return current edge.
Standard_EXPORT const TopoDS_Edge& Edge() const;
TopoDS_Face myFace;
TopExp_Explorer myExplorer;
- Geom2dAdaptor_Curve myCurve;
+ Handle(Geom2dAdaptor_Curve) myCurve;
Standard_Boolean myHasNullCurves;
};
// function: FindLimits
// purpose:
//==================================================================
-static void FindLimits(const Adaptor3d_Curve& aCurve,
+static void FindLimits(const Handle(Adaptor3d_Curve)& aCurve,
const Standard_Real aLimit,
Standard_Real& First,
Standard_Real& Last)
{
- First = Max(aCurve.FirstParameter(), First);
- Last = Min(aCurve.LastParameter(), Last);
+ First = Max(aCurve->FirstParameter(), First);
+ Last = Min(aCurve->LastParameter(), Last);
Standard_Boolean firstInf = Precision::IsNegativeInfinite(First);
Standard_Boolean lastInf = Precision::IsPositiveInfinite(Last);
delta *= 2;
First = - delta;
Last = delta;
- aCurve.D0(First,P1);
- aCurve.D0(Last,P2);
+ aCurve->D0(First,P1);
+ aCurve->D0(Last,P2);
} while (P1.Distance(P2) < aLimit);
}
else if (firstInf) {
- aCurve.D0(Last,P2);
+ aCurve->D0(Last,P2);
do {
delta *= 2;
First = Last - delta;
- aCurve.D0(First,P1);
+ aCurve->D0(First,P1);
} while (P1.Distance(P2) < aLimit);
}
else if (lastInf) {
- aCurve.D0(First,P1);
+ aCurve->D0(First,P1);
do {
delta *= 2;
Last = First + delta;
- aCurve.D0(Last,P2);
+ aCurve->D0(Last,P2);
} while (P1.Distance(P2) < aLimit);
}
}
for (ToolRst.Init(); ToolRst.More(); ToolRst.Next())
{
const TopAbs_Orientation anOrient = ToolRst.Orientation();
- const Adaptor2d_Curve2d* TheRCurve = &ToolRst.Value();
+ const Handle(Adaptor2d_Curve2d) TheRCurve = ToolRst.Value();
if (TheRCurve->GetType() != GeomAbs_Line)
{
- GCPnts_QuasiUniformDeflection UDP (*TheRCurve, ddefle);
+ GCPnts_QuasiUniformDeflection UDP (TheRCurve, ddefle);
if (UDP.IsDone())
{
const Standard_Integer aNumberOfPoints = UDP.NbPoints();
// draw the isos
- Adaptor3d_IsoCurve anIso;
- anIso.Load(aFace);
+ Handle(Adaptor3d_IsoCurve) anIso = new Adaptor3d_IsoCurve(aFace);
Handle(Geom_Curve) BC;
- const BRepAdaptor_Surface& BS = *aFace;
GeomAbs_SurfaceType thetype = aFace->GetType();
Handle(Geom_Surface) GB;
if (thetype == GeomAbs_BezierSurface)
{
- GB = BS.Bezier();
+ GB = aFace->Bezier();
}
else if (thetype == GeomAbs_BSplineSurface)
{
- GB = BS.BSpline();
+ GB = aFace->BSpline();
}
const Standard_Real anAngle = aDrawer->DeviationAngle();
BC = GB->VIso (Coord);
}
- GeomAdaptor_Curve GC (BC);
+ Handle(GeomAdaptor_Curve) GC = new GeomAdaptor_Curve(BC);
FindLimits (GC, aLimit,b1, b2);
if (b2 - b1 > Precision::Confusion())
{
{
if (isobuild.IsXLine (i))
{
- anIso.Load (GeomAbs_IsoU,Coord,b1,b2);
+ anIso->Load (GeomAbs_IsoU,Coord,b1,b2);
}
else
{
- anIso.Load (GeomAbs_IsoV,Coord,b1,b2);
+ anIso->Load (GeomAbs_IsoV,Coord,b1,b2);
}
FindLimits (anIso, aLimit, b1, b2);
UMax = VMax = RealFirst();
for (ToolRst.Init(); ToolRst.More(); ToolRst.Next()) {
- const Adaptor2d_Curve2d* TheRCurve = &ToolRst.Value();
+ const Handle(Adaptor2d_Curve2d) TheRCurve = ToolRst.Value();
u = TheRCurve->FirstParameter();
v = TheRCurve->LastParameter();
step = ( v - u) / nbPoints;
gp_Pnt dummypnt;
for (ToolRst.Init(); ToolRst.More(); ToolRst.Next()) {
TopAbs_Orientation Orient = ToolRst.Orientation();
- const Adaptor2d_Curve2d* TheRCurve = &ToolRst.Value();
+ const Handle(Adaptor2d_Curve2d)* TheRCurve = &ToolRst.Value();
GCPnts_QuasiUniformDeflection UDP(*TheRCurve, Deflection);
if (UDP.IsDone()) {
Standard_Integer NumberOfPoints = UDP.NbPoints();
// draw the isos
- Adaptor3d_IsoCurve anIso;
- anIso.Load(aFace);
+ Handle(Adaptor3d_IsoCurve) anIso = new Adaptor3d_IsoCurve(aFace);
Standard_Integer NumberOfLines = isobuild.NbLines();
Standard_Real anAngle = aDrawer->DeviationAngle();
b2 = b2 == RealLast() ? aLimit : b2;
if (isobuild.IsXLine(i))
- anIso.Load(GeomAbs_IsoU,Coord,b1,b2);
+ anIso->Load(GeomAbs_IsoU,Coord,b1,b2);
else
- anIso.Load(GeomAbs_IsoV,Coord,b1,b2);
+ anIso->Load(GeomAbs_IsoV,Coord,b1,b2);
if (StdPrs_DeflectionCurve::Match(X,Y,Z,aDistance,anIso, b1, b2, Deflection, anAngle))
return Standard_True;
if (TOD == Aspect_TOD_RELATIVE) {
// On calcule la fleche en fonction des min max globaux de la piece:
Bnd_Box Total;
- BndLib_AddSurface::Add (*aSurface, U1, U2, V1, V2, 0., Total);
+ BndLib_AddSurface::Add (aSurface, U1, U2, V1, V2, 0., Total);
Standard_Real m = aDrawer->MaximalChordialDeviation()/
aDrawer->DeviationCoefficient();
Standard_Real aXmin, aYmin, aZmin, aXmax, aYmax, aZmax;
else
TheDeflection = aDrawer->MaximalChordialDeviation();
- Adaptor3d_IsoCurve anIso;
- anIso.Load(aSurface);
+ Handle(Adaptor3d_IsoCurve) anIso = new Adaptor3d_IsoCurve(aSurface);
// Trace des frontieres.
// *********************
aPresentation->CurrentGroup()->SetPrimitivesAspect (aDrawer->FreeBoundaryAspect()->Aspect());
if ( !UClosed )
{
- anIso.Load(GeomAbs_IsoU,U1,V1,V2);
+ anIso->Load(GeomAbs_IsoU,U1,V1,V2);
StdPrs_DeflectionCurve::Add(aPresentation,anIso,TheDeflection, MaxP);
- anIso.Load(GeomAbs_IsoU,U2,V1,V2);
+ anIso->Load(GeomAbs_IsoU,U2,V1,V2);
StdPrs_DeflectionCurve::Add(aPresentation,anIso,TheDeflection, MaxP);
}
if ( !VClosed )
{
- anIso.Load(GeomAbs_IsoV,V1,U1,U2);
+ anIso->Load(GeomAbs_IsoV,V1,U1,U2);
StdPrs_DeflectionCurve::Add(aPresentation,anIso,TheDeflection, MaxP);
- anIso.Load(GeomAbs_IsoV,V2,U1,U2);
+ anIso->Load(GeomAbs_IsoV,V2,U1,U2);
StdPrs_DeflectionCurve::Add(aPresentation,anIso,TheDeflection, MaxP);
}
}
Standard_Real du= UClosed ? (U2-U1)/fin : (U2-U1)/(1+fin);
for (Standard_Integer i=1; i<=fin;i++){
- anIso.Load(GeomAbs_IsoU,U1+du*i,V1,V2);
+ anIso->Load(GeomAbs_IsoU,U1+du*i,V1,V2);
StdPrs_DeflectionCurve::Add(aPresentation,anIso,TheDeflection, MaxP);
}
}
Standard_Real dv= VClosed ?(V2-V1)/fin : (V2-V1)/(1+fin);
for (Standard_Integer i=1; i<=fin;i++){
- anIso.Load(GeomAbs_IsoV,V1+dv*i,U1,U2);
+ anIso->Load(GeomAbs_IsoV,V1+dv*i,U1,U2);
StdPrs_DeflectionCurve::Add(aPresentation,anIso,TheDeflection, MaxP);
}
}
//=======================================================================
void StdPrs_WFPoleSurface::Add (const Handle (Prs3d_Presentation)& aPresentation,
- const Adaptor3d_Surface& aSurface,
+ const Handle(Adaptor3d_Surface)& aSurface,
const Handle (Prs3d_Drawer)& aDrawer)
{
- GeomAbs_SurfaceType SType = aSurface.GetType();
+ GeomAbs_SurfaceType SType = aSurface->GetType();
if (SType == GeomAbs_BezierSurface || SType == GeomAbs_BSplineSurface) {
Standard_Integer n , m;
if (SType == GeomAbs_BezierSurface) {
- Handle(Geom_BezierSurface) B = aSurface.Bezier();
- n = aSurface.NbUPoles();
- m = aSurface.NbVPoles();
+ Handle(Geom_BezierSurface) B = aSurface->Bezier();
+ n = aSurface->NbUPoles();
+ m = aSurface->NbVPoles();
TColgp_Array2OfPnt A(1,n,1,m);
- (aSurface.Bezier())->Poles(A);
+ (aSurface->Bezier())->Poles(A);
AddPoles(aPresentation, A, aDrawer);
}
else if (SType == GeomAbs_BSplineSurface) {
- Handle(Geom_BSplineSurface) B = aSurface.BSpline();
- n = (aSurface.BSpline())->NbUPoles();
- m = (aSurface.BSpline())->NbVPoles();
+ Handle(Geom_BSplineSurface) B = aSurface->BSpline();
+ n = (aSurface->BSpline())->NbUPoles();
+ m = (aSurface->BSpline())->NbVPoles();
TColgp_Array2OfPnt A(1,n,1,m);
- (aSurface.BSpline())->Poles(A);
+ (aSurface->BSpline())->Poles(A);
AddPoles(aPresentation, A, aDrawer);
}
//! The surface aSurface is a surface object from
//! Adaptor3d, and provides data from a Geom surface.
//! This makes it possible to use the surface in a geometric algorithm.
- Standard_EXPORT static void Add (const Handle(Prs3d_Presentation)& aPresentation, const Adaptor3d_Surface& aSurface, const Handle(Prs3d_Drawer)& aDrawer);
+ Standard_EXPORT static void Add (const Handle(Prs3d_Presentation)& aPresentation, const Handle(Adaptor3d_Surface)& aSurface, const Handle(Prs3d_Drawer)& aDrawer);
for (aToolRst.Init(); aToolRst.More(); aToolRst.Next())
{
- const Adaptor2d_Curve2d& aRCurve = aToolRst.Value();
+ const Handle(Adaptor2d_Curve2d)& aRCurve = aToolRst.Value();
BndLib_Add2dCurve::Add(aRCurve, Precision::PConfusion(), aBndBox);
}
if (!aBndBox.IsVoid())
aBndBox.Get(aUMin, aVMin, aUMax, aVMax);
else
{ // No pcurves -- take natural bounds
- aUMin = theFace->Surface().FirstUParameter();
- aVMin = theFace->Surface().FirstVParameter();
- aUMax = theFace->Surface().LastUParameter();
- aVMax = theFace->Surface().LastVParameter();
+ aUMin = theFace->Surface()->FirstUParameter();
+ aVMin = theFace->Surface()->FirstVParameter();
+ aUMax = theFace->Surface()->LastUParameter();
+ aVMax = theFace->Surface()->LastVParameter();
}
// Load the isos
for (aToolRst.Init(); aToolRst.More(); aToolRst.Next())
{
TopAbs_Orientation anOrientation = aToolRst.Orientation();
- const Adaptor2d_Curve2d* aRCurve = &aToolRst.Value();
+ const Handle(Adaptor2d_Curve2d) aRCurve = aToolRst.Value();
anU1 = aRCurve->FirstParameter();
anU2 = aRCurve->LastParameter();
if (aRCurve->GetType() != GeomAbs_Line)
}
// Draw the isos
- Adaptor3d_IsoCurve anIsoCurve;
- anIsoCurve.Load(theFace);
+ Handle(Adaptor3d_IsoCurve) anIsoCurve = new Adaptor3d_IsoCurve(theFace);
Handle(Geom_Curve) aBCurve;
- const BRepAdaptor_Surface& aBSurface = *theFace;
GeomAbs_SurfaceType aFaceType = theFace->GetType();
Standard_Integer aNbLines = anIsoBuild.NbLines();
Handle(Geom_Surface) aGeomBSurface;
if (aFaceType == GeomAbs_BezierSurface)
{
- aGeomBSurface = aBSurface.Bezier();
+ aGeomBSurface = theFace->Bezier();
}
else if (aFaceType == GeomAbs_BSplineSurface)
{
- aGeomBSurface = aBSurface.BSpline();
+ aGeomBSurface = theFace->BSpline();
}
for (anI = 1; anI <= aNbLines; ++anI)
//Note that the isos are the part of the shape, it will be displayed after a computation the whole shape
//NbPoints = 30 - default parameter for computation of such curves
- StdPrs_Curve::Add (thePresentation, GeomAdaptor_Curve (aBCurve), b1, b2, aPoints->ChangeSequence(), 30, Standard_False);
+ StdPrs_Curve::Add (thePresentation, new GeomAdaptor_Curve (aBCurve), b1, b2, aPoints->ChangeSequence(), 30, Standard_False);
theCurves.Append (aPoints);
}
else
{
if (anIsoBuild.IsXLine (anI))
{
- anIsoCurve.Load (GeomAbs_IsoU, anIsoCoord, b1, b2);
+ anIsoCurve->Load (GeomAbs_IsoU, anIsoCoord, b1, b2);
}
else
{
- anIsoCurve.Load(GeomAbs_IsoV, anIsoCoord, b1, b2);
+ anIsoCurve->Load(GeomAbs_IsoV, anIsoCoord, b1, b2);
}
StdPrs_Curve::Add (thePresentation, anIsoCurve, theDrawer, aPoints->ChangeSequence(), Standard_False);
theCurves.Append (aPoints);
for (aToolRst.Init(); aToolRst.More(); aToolRst.Next())
{
- const Adaptor2d_Curve2d* aRCurve = &aToolRst.Value();
+ const Handle(Adaptor2d_Curve2d) aRCurve = aToolRst.Value();
anU = aRCurve->FirstParameter();
aV = aRCurve->LastParameter();
if (aRCurve->GetType() != GeomAbs_Line)
for (aToolRst.Init(); aToolRst.More(); aToolRst.Next())
{
TopAbs_Orientation Orient = aToolRst.Orientation();
- const Adaptor2d_Curve2d* aRCurve = &aToolRst.Value();
+ const Handle(Adaptor2d_Curve2d) aRCurve = aToolRst.Value();
anU1 = aRCurve->FirstParameter();
anU2 = aRCurve->LastParameter();
if (aRCurve->GetType() != GeomAbs_Line) {
// Draw the isos
- Adaptor3d_IsoCurve anIso;
- anIso.Load(theFace);
+ Handle(Adaptor3d_IsoCurve) anIso = new Adaptor3d_IsoCurve(theFace);
Standard_Integer aNbLines = anIsoBuild.NbLines();
for (anI = 1; anI <= aNbLines; anI++)
if (anIsoBuild.IsXLine(anI))
- anIso.Load(GeomAbs_IsoU,aCoord,anIsoStart,anIsoEnd);
+ anIso->Load(GeomAbs_IsoU,aCoord,anIsoStart,anIsoEnd);
else
- anIso.Load(GeomAbs_IsoV,aCoord,anIsoStart,anIsoEnd);
+ anIso->Load(GeomAbs_IsoV,aCoord,anIsoStart,anIsoEnd);
if (StdPrs_Curve::Match(theX,theY,theZ,theDistance,anIso,
theDeflection, aLimit, aNbPoints))
else if (BRep_Tool::IsGeometric (anEdge))
{
// Default presentation for edges without triangulation.
- BRepAdaptor_Curve aCurve (anEdge);
+ Handle(BRepAdaptor_Curve) aCurve = new BRepAdaptor_Curve(anEdge);
StdPrs_DeflectionCurve::Add (Handle(Prs3d_Presentation)(),
aCurve,
theShapeDeflection,
Standard_Boolean UClosed = aSurface->IsUClosed();
Standard_Boolean VClosed = aSurface->IsVClosed();
- Adaptor3d_IsoCurve anIso;
- anIso.Load(aSurface);
+ Handle(Adaptor3d_IsoCurve) anIso = new Adaptor3d_IsoCurve(aSurface);
// Trace des frontieres.
// *********************
aPresentation->CurrentGroup()->SetPrimitivesAspect (aDrawer->FreeBoundaryAspect()->Aspect());
if (!UClosed)
{
- anIso.Load (GeomAbs_IsoU, U1, V1, V2);
+ anIso->Load (GeomAbs_IsoU, U1, V1, V2);
Handle(TColgp_HSequenceOfPnt) aPntsU1 = new TColgp_HSequenceOfPnt;
StdPrs_Curve::Add (aPresentation, anIso, aDrawer, aPntsU1->ChangeSequence(), Standard_False);
freeCurves.Append (aPntsU1);
- anIso.Load (GeomAbs_IsoU,U2,V1,V2);
+ anIso->Load (GeomAbs_IsoU,U2,V1,V2);
Handle(TColgp_HSequenceOfPnt) aPntsU2 = new TColgp_HSequenceOfPnt;
StdPrs_Curve::Add (aPresentation, anIso, aDrawer, aPntsU2->ChangeSequence(), Standard_False);
freeCurves.Append(aPntsU2);
}
if (!VClosed)
{
- anIso.Load (GeomAbs_IsoV, V1, U1, U2);
+ anIso->Load (GeomAbs_IsoV, V1, U1, U2);
Handle(TColgp_HSequenceOfPnt) aPntsV1 = new TColgp_HSequenceOfPnt;
StdPrs_Curve::Add (aPresentation, anIso, aDrawer, aPntsV1->ChangeSequence(), Standard_False);
freeCurves.Append (aPntsV1);
- anIso.Load (GeomAbs_IsoV, V2, U1, U2);
+ anIso->Load (GeomAbs_IsoV, V2, U1, U2);
Handle(TColgp_HSequenceOfPnt) aPntsV2 = new TColgp_HSequenceOfPnt;
StdPrs_Curve::Add (aPresentation, anIso, aDrawer, aPntsV2->ChangeSequence(), Standard_False);
freeCurves.Append(aPntsV2);
Standard_Real du= UClosed ? (U2-U1) / fin : (U2-U1) / (1 + fin);
for (Standard_Integer i = 1; i <= fin; i++)
{
- anIso.Load (GeomAbs_IsoU, U1 + du * i, V1, V2);
+ anIso->Load (GeomAbs_IsoU, U1 + du * i, V1, V2);
Handle(TColgp_HSequenceOfPnt) Pnts = new TColgp_HSequenceOfPnt;
StdPrs_Curve::Add (aPresentation, anIso, aDrawer, Pnts->ChangeSequence(), Standard_False);
UIsoCurves.Append (Pnts);
Standard_Real dv = VClosed ? (V2 - V1) / fin : (V2 - V1) / (1 + fin);
for (Standard_Integer i = 1; i <= fin; i++)
{
- anIso.Load (GeomAbs_IsoV, V1 + dv * i, U1, U2);
+ anIso->Load (GeomAbs_IsoV, V1 + dv * i, U1, U2);
Handle(TColgp_HSequenceOfPnt) Pnts = new TColgp_HSequenceOfPnt;
StdPrs_Curve::Add (aPresentation, anIso, aDrawer, Pnts->ChangeSequence(), Standard_False);
VIsoCurves.Append (Pnts);
// Function: FindLimits
// Purpose :
//==================================================
-static Standard_Boolean FindLimits (const Adaptor3d_Curve& theCurve,
+static Standard_Boolean FindLimits (const Handle(Adaptor3d_Curve)& theCurve,
const Standard_Real theLimit,
Standard_Real& theFirst,
Standard_Real& theLast)
{
- theFirst = theCurve.FirstParameter();
- theLast = theCurve.LastParameter();
+ theFirst = theCurve->FirstParameter();
+ theLast = theCurve->LastParameter();
Standard_Boolean isFirstInf = Precision::IsNegativeInfinite (theFirst);
Standard_Boolean isLastInf = Precision::IsPositiveInfinite (theLast);
if (isFirstInf || isLastInf)
aDelta *= 2.0;
theFirst = - aDelta;
theLast = aDelta;
- theCurve.D0 (theFirst, aPnt1);
- theCurve.D0 (theLast, aPnt2);
+ theCurve->D0 (theFirst, aPnt1);
+ theCurve->D0 (theLast, aPnt2);
} while (aPnt1.Distance (aPnt2) < theLimit);
}
else if (isFirstInf)
{
- theCurve.D0 (theLast, aPnt2);
+ theCurve->D0 (theLast, aPnt2);
do {
if (anIterCount++ >= 100000) return Standard_False;
aDelta *= 2.0;
theFirst = theLast - aDelta;
- theCurve.D0 (theFirst, aPnt1);
+ theCurve->D0 (theFirst, aPnt1);
} while (aPnt1.Distance (aPnt2) < theLimit);
}
else if (isLastInf)
{
- theCurve.D0 (theFirst, aPnt1);
+ theCurve->D0 (theFirst, aPnt1);
do {
if (anIterCount++ >= 100000) return Standard_False;
aDelta *= 2.0;
theLast = theFirst + aDelta;
- theCurve.D0 (theLast, aPnt2);
+ theCurve->D0 (theLast, aPnt2);
} while (aPnt1.Distance (aPnt2) < theLimit);
}
}
return;
}
- BRepAdaptor_Curve cu3d;
+ Handle(BRepAdaptor_Curve) cu3d = new BRepAdaptor_Curve();
try {
OCC_CATCH_SIGNALS
- cu3d.Initialize (anEdge);
+ cu3d->Initialize (anEdge);
} catch (Standard_NullObject const&) {
return;
}
- Standard_Real aParamFirst = cu3d.FirstParameter();
- Standard_Real aParamLast = cu3d.LastParameter();
- switch (cu3d.GetType())
+ Standard_Real aParamFirst = cu3d->FirstParameter();
+ Standard_Real aParamLast = cu3d->LastParameter();
+ switch (cu3d->GetType())
{
case GeomAbs_Line:
{
BRep_Tool::Range (anEdge, aParamFirst, aParamLast);
theSensitive = new Select3D_SensitiveSegment (theOwner,
- cu3d.Value (aParamFirst),
- cu3d.Value (aParamLast));
+ cu3d->Value (aParamFirst),
+ cu3d->Value (aParamLast));
break;
}
case GeomAbs_Circle:
{
- const gp_Circ aCircle = cu3d.Circle();
+ const gp_Circ aCircle = cu3d->Circle();
if (aCircle.Radius() <= Precision::Confusion())
{
theSelection->Add (new Select3D_SensitivePoint (theOwner, aCircle.Location()));
// TODO: remove copy-paste from StdPrs_Curve and some others...
if (FindLimits (cu3d, theMaxParam, aParamFirst, aParamLast))
{
- Standard_Integer aNbIntervals = cu3d.NbIntervals (GeomAbs_C1);
+ Standard_Integer aNbIntervals = cu3d->NbIntervals (GeomAbs_C1);
TColStd_Array1OfReal anIntervals (1, aNbIntervals + 1);
- cu3d.Intervals (anIntervals, GeomAbs_C1);
+ cu3d->Intervals (anIntervals, GeomAbs_C1);
Standard_Real aV1, aV2;
Standard_Integer aNumberOfPoints;
TColgp_SequenceOfPnt aPointsSeq;
// simple subdivisions
Standard_Integer nbintervals = 1;
- if (cu3d.GetType() == GeomAbs_BSplineCurve)
+ if (cu3d->GetType() == GeomAbs_BSplineCurve)
{
- nbintervals = cu3d.NbKnots() - 1;
+ nbintervals = cu3d->NbKnots() - 1;
nbintervals = Max (1, nbintervals / 3);
}
for (Standard_Integer aPntId = 1; aPntId <= aPntNb; ++aPntId)
{
aParam = aParamFirst + aParamDelta * (aPntId - 1);
- aPointArray->SetValue (aPntId, cu3d.Value (aParam));
+ aPointArray->SetValue (aPntId, cu3d->Value (aParam));
}
theSensitive = new Select3D_SensitiveCurve (theOwner, aPointArray);
}
if (!IsPlanar || aplane.IsNull()) {
// check are the planes of edge1 and edge2 coincident
BRepAdaptor_Curve aCurve( edge1 );
- Handle( Geom_Curve ) aProjCurve = aCurve.Curve().Curve();
+ Handle( Geom_Curve ) aProjCurve = aCurve.Curve()->Curve();
gp_Circ aCircle = (Handle( Geom_Circle )::DownCast( aProjCurve ))->Circ();
gp_Ax3 anAx31(aCircle.Position()); //get the circle axis
// get the circle plane
Handle(Geom_Plane) aPlane1 = new Geom_Plane (anAx31);
aCurve.Initialize(edge2);
- aProjCurve = aCurve.Curve().Curve();
+ aProjCurve = aCurve.Curve()->Curve();
aCircle = (Handle( Geom_Circle )::DownCast( aProjCurve ))->Circ();
gp_Ax3 anAx32(aCircle.Position()); //get the circle axis
// get the circle plane
BRepAdaptor_Curve CURVE(OE);
if (CURVE.GetType() == GeomAbs_Line) {
// Works only with line !!
- Handle(Geom_Geometry) aGeomGeometry = CURVE.Curve().Curve()->Transformed(CURVE.Trsf()) ;
+ Handle(Geom_Geometry) aGeomGeometry = CURVE.Curve()->Curve()->Transformed(CURVE.Trsf()) ;
gp_Lin OLin = Handle(Geom_Line)::DownCast (aGeomGeometry)->Lin();
TopoDS_Edge NE = TopoDS::Edge(S2);
CURVE.Initialize (NE);
- aGeomGeometry = CURVE.Curve().Curve()->Transformed(CURVE.Trsf()) ;
+ aGeomGeometry = CURVE.Curve()->Curve()->Transformed(CURVE.Trsf()) ;
gp_Lin NLin = Handle(Geom_Line)::DownCast (aGeomGeometry)->Lin();
gp_Dir TDir (NLin.Location().XYZ() - OLin.Location().XYZ());
aplane = new Geom_Plane (NLin.Location(),NLin.Direction()^TDir);
}
else
if (CURVE.GetType() == GeomAbs_Circle) {
- Handle(Geom_Geometry) aGeomGeometry = CURVE.Curve().Curve()->Transformed(CURVE.Trsf()) ;
+ Handle(Geom_Geometry) aGeomGeometry = CURVE.Curve()->Curve()->Transformed(CURVE.Trsf()) ;
gp_Ax1 ax = Handle(Geom_Circle)::DownCast (aGeomGeometry)->Circ().Axis();
aplane = new Geom_Plane (ax.Location(),ax.Direction());
is_planar = Standard_True;
mySurface2 = new BRepAdaptor_Surface();
mySurfacesSameOriented = Standard_False;
myFacesSameOriented = Standard_False;
+ myCurve1 = new Geom2dAdaptor_Curve();
+ myCurve2 = new Geom2dAdaptor_Curve();
myTol1 = 0.; // Precision::PConfusion();
myTol2 = 0.; // Precision::PIntersection();
myDimension = 2;
myFacesSameOriented = Standard_True;
myFace1 = TopoDS::Face(F1);
- BRepAdaptor_Surface& S1 = *mySurface1; S1.Initialize(myFace1,computerestriction);
- mySurfaceType1 = S1.GetType();
+ mySurface1->Initialize(myFace1,computerestriction);
+ mySurfaceType1 = mySurface1->GetType();
myFace2 = TopoDS::Face(F2);
- BRepAdaptor_Surface& S2 = *mySurface2; S2.Initialize(myFace2,computerestriction);
- mySurfaceType2 = S2.GetType();
+ mySurface2->Initialize(myFace2,computerestriction);
+ mySurfaceType2 = mySurface2->GetType();
TopoDS_Face face1forward = myFace1;
face1forward.Orientation(TopAbs_FORWARD);
so21 = TopOpeBRepTool_ShapeTool::FacesSameOriented(face1forward,myFace2);
myf2surf1F_sameoriented = so21;
- mySurfacesSameOriented = TopOpeBRepTool_ShapeTool::SurfacesSameOriented(S1,S2);
+ mySurfacesSameOriented = TopOpeBRepTool_ShapeTool::SurfacesSameOriented(mySurface1, mySurface2);
myFacesSameOriented = TopOpeBRepTool_ShapeTool::FacesSameOriented(myFace1,myFace2);
if ( !myTolForced ) {
- FTOL_FaceTolerances2d(B1,B2,myFace1,myFace2,S1,S2,myTol1,myTol2);
+ FTOL_FaceTolerances2d(B1,B2,myFace1,myFace2, mySurface1, mySurface2,myTol1,myTol2);
myTol1 = (myTol1 > 1.e-4)? 1.e-4: myTol1;
myTol2 = (myTol2 > 1.e-4)? 1.e-4: myTol2;
}
// Modified by Sergey KHROMOV - Fri Jan 11 14:49:48 2002 Begin
static Standard_Boolean IsTangentSegment(const IntRes2d_IntersectionPoint &P1,
const IntRes2d_IntersectionPoint &P2,
- const Geom2dAdaptor_Curve &aC1,
- const Geom2dAdaptor_Curve &aC2,
+ const Handle(Geom2dAdaptor_Curve) &aC1,
+ const Handle(Geom2dAdaptor_Curve) &aC2,
const Standard_Real aTolConf) {
const gp_Pnt2d &aP2d1 = P1.Value();
const gp_Pnt2d &aP2d2 = P2.Value();
if (aSqrDistPP <= aTolConf) {
Standard_Real aParDist1 = Abs(P1.ParamOnFirst() - P2.ParamOnFirst());
Standard_Real aParDist2 = Abs(P1.ParamOnSecond() - P2.ParamOnSecond());
- Standard_Real aResol1 = aC1.Resolution(aTolConf);
- Standard_Real aResol2 = aC2.Resolution(aTolConf);
+ Standard_Real aResol1 = aC1->Resolution(aTolConf);
+ Standard_Real aResol2 = aC2->Resolution(aTolConf);
if (aParDist1*aParDist1 <= aResol1 &&
aParDist2*aParDist2 <= aResol2)
if (PC1.IsNull())
throw Standard_Failure("EdgesIntersector::Perform : no 2d curve");
- myCurve1.Load(PC1);
+ myCurve1->Load(PC1);
BRep_Tool::UVPoints(myEdge1,myFace1,pfirst,plast);
tole = BRep_Tool::Tolerance(myEdge1);
myDomain1.SetValues(pfirst,first,tole,plast,last,tole);
if ( mySurfaceType1 == GeomAbs_Plane || memesfaces || memesupport) {
Handle(Geom2d_Curve) PC2 = FC2D_CurveOnSurface(myEdge2,myFace1,first,last,tolpc);
- myCurve2.Load(PC2);
+ myCurve2->Load(PC2);
BRep_Tool::UVPoints(myEdge2,myFace1,pfirst,plast);
tole = BRep_Tool::Tolerance(myEdge2);
myDomain2.SetValues(pfirst,first,tole,plast,last,tole);
}
if (!PC2on1.IsNull()) {
- myCurve2.Load(PC2on1);
+ myCurve2->Load(PC2on1);
tole = BRep_Tool::Tolerance(myEdge2);
PC2on1->D0(first,pfirst);
PC2on1->D0(last,plast);
//=======================================================================
Standard_Boolean TopOpeBRep_EdgesIntersector::ComputeSameDomain()
{
- const Geom2dAdaptor_Curve& C1 = Curve(1);
- const Geom2dAdaptor_Curve& C2 = Curve(2);
- GeomAbs_CurveType t1 = C1.GetType();
- GeomAbs_CurveType t2 = C2.GetType();
+ const Handle(Geom2dAdaptor_Curve)& C1 = Curve(1);
+ const Handle(Geom2dAdaptor_Curve)& C2 = Curve(2);
+ GeomAbs_CurveType t1 = C1->GetType();
+ GeomAbs_CurveType t2 = C2->GetType();
if (!myHasSegment)
return SetSameDomain(Standard_False);
return SetSameDomain(Standard_False);
}
- gp_Circ2d c1 = C1.Circle();
- gp_Circ2d c2 = C2.Circle();
+ gp_Circ2d c1 = C1->Circle();
+ gp_Circ2d c2 = C2->Circle();
Standard_Real r1 = c1.Radius();
Standard_Real r2 = c2.Radius();
// Standard_Boolean rr = (r1 == r2);
const gp_Pnt2d& p1 = c1.Location();
const gp_Pnt2d& p2 = c2.Location();
- const BRepAdaptor_Surface& BAS1 = Surface(1);
- Standard_Real u1,v1; p1.Coord(u1,v1); gp_Pnt P1 = BAS1.Value(u1,v1);
- Standard_Real u2,v2; p2.Coord(u2,v2); gp_Pnt P2 = BAS1.Value(u2,v2);// recall myCurve2=C2d(myEdge2,myFace1);
+ const Handle(BRepAdaptor_Surface)& BAS1 = Surface(1);
+ Standard_Real u1,v1; p1.Coord(u1,v1); gp_Pnt P1 = BAS1->Value(u1,v1);
+ Standard_Real u2,v2; p2.Coord(u2,v2); gp_Pnt P2 = BAS1->Value(u2,v2);// recall myCurve2=C2d(myEdge2,myFace1);
Standard_Real dpp = P1.Distance(P2);
Standard_Real tol1 = BRep_Tool::Tolerance(TopoDS::Edge(Edge(1)));
Standard_Real tol2 = BRep_Tool::Tolerance(TopoDS::Edge(Edge(2)));
//function : Curve
//purpose :
//=======================================================================
-const Geom2dAdaptor_Curve& TopOpeBRep_EdgesIntersector::Curve(const Standard_Integer Index) const
+const Handle(Geom2dAdaptor_Curve)& TopOpeBRep_EdgesIntersector::Curve(const Standard_Integer Index) const
{
if ( Index == 1 ) return myCurve1;
else if ( Index == 2 ) return myCurve2;
//function : Surface
//purpose :
//=======================================================================
-const BRepAdaptor_Surface& TopOpeBRep_EdgesIntersector::Surface(const Standard_Integer Index) const
+const Handle(BRepAdaptor_Surface)& TopOpeBRep_EdgesIntersector::Surface(const Standard_Integer Index) const
{
- if ( Index == 1 ) return *mySurface1;
- else if ( Index == 2 ) return *mySurface2;
+ if ( Index == 1 ) return mySurface1;
+ else if ( Index == 2 ) return mySurface2;
else throw Standard_Failure("TopOpeBRep_EdgesIntersector::Surface");
}
Standard_EXPORT const TopoDS_Shape& Edge (const Standard_Integer Index) const;
- Standard_EXPORT const Geom2dAdaptor_Curve& Curve (const Standard_Integer Index) const;
+ Standard_EXPORT const Handle(Geom2dAdaptor_Curve)& Curve (const Standard_Integer Index) const;
Standard_EXPORT const TopoDS_Shape& Face (const Standard_Integer Index) const;
- Standard_EXPORT const BRepAdaptor_Surface& Surface (const Standard_Integer Index) const;
+ Standard_EXPORT const Handle(BRepAdaptor_Surface)& Surface (const Standard_Integer Index) const;
Standard_EXPORT Standard_Boolean SurfacesSameOriented() const;
IntRes2d_Domain myDomain2;
TopoDS_Edge myEdge1;
TopoDS_Edge myEdge2;
- Geom2dAdaptor_Curve myCurve1;
- Geom2dAdaptor_Curve myCurve2;
+ Handle(Geom2dAdaptor_Curve) myCurve1;
+ Handle(Geom2dAdaptor_Curve) myCurve2;
Standard_Real myTol1;
Standard_Real myTol2;
Standard_Boolean myTolForced;
p.SetCoord (inf, inf, inf);
}
else
- mySurface1->Surface().D0(p2.X(),p2.Y(), p);
+ mySurface1->Surface()->D0(p2.X(),p2.Y(), p);
return p;
}
Standard_Boolean hasC3D = FC2D_HasC3D(E);
Standard_Real dist;
if (hasC3D) {
- BRepAdaptor_Curve BAC(E);
+ Handle(BRepAdaptor_Curve) BAC = new BRepAdaptor_Curve(E);
paramLdef = FUN_tool_projPonC(P,BAC,paramL,dist);
}
else {
- BRepAdaptor_Curve2d BAC2D;
- if (Esi == 1) BAC2D.Initialize(E,FF.Face(1));
- else if (Esi == 2) BAC2D.Initialize(E,FF.Face(2));
+ Handle(BRepAdaptor_Curve2d) BAC2D = new BRepAdaptor_Curve2d();
+ if (Esi == 1) BAC2D->Initialize(E,FF.Face(1));
+ else if (Esi == 2) BAC2D->Initialize(E,FF.Face(2));
paramLdef = FUN_tool_projPonC2D(P,BAC2D,paramL,dist);
}
return paramLdef;
//Patch: avoid making too small edges. Made for the bug buc60926 by jgv, 14.06.01.
Standard_Real fpar, lpar;
DSC.Range(fpar, lpar);
- GeomAdaptor_Curve theCurve( DSC.Curve(), fpar, lpar );
+ Handle(GeomAdaptor_Curve) theCurve = new GeomAdaptor_Curve( DSC.Curve(), fpar, lpar );
Bnd_Box theBox;
BndLib_Add3dCurve::Add( theCurve, 0., theBox );
Standard_Real Xmin, Ymin, Zmin, Xmax, Ymax, Zmax, MaxSide;
Standard_Real& theLast);
//------------------------------------------------------------------------------------------------
static Standard_Boolean IsPointOK(const gp_Pnt& theTestPnt,
- const Adaptor3d_Surface& theTestSurface,
+ const Handle(Adaptor3d_Surface)& theTestSurface,
const Standard_Real& theTol);
//-------------------------------------------------------------------------------------------------
static Standard_Boolean GetPointOn2S(const gp_Pnt& theTestPnt,
- const Adaptor3d_Surface& theTestSurface,
+ const Handle(Adaptor3d_Surface)& theTestSurface,
const Standard_Real& theTol,
Extrema_POnSurf& theResultPoint);
//-------------------------------------------------------------------------------------------------------------------------
myFace1 = TopoDS::Face(F1); myFace1.Orientation(TopAbs_FORWARD);
myFace2 = TopoDS::Face(F2); myFace2.Orientation(TopAbs_FORWARD);
- BRepAdaptor_Surface& S1 = *mySurface1; S1.Initialize(myFace1);
- BRepAdaptor_Surface& S2 = *mySurface2; S2.Initialize(myFace2);
- mySurfaceType1 = S1.GetType();
- mySurfaceType2 = S2.GetType();
+ mySurface1->Initialize(myFace1);
+ mySurface2->Initialize(myFace2);
+ mySurfaceType1 = mySurface1->GetType();
+ mySurfaceType2 = mySurface2->GetType();
const Handle(Adaptor3d_Surface)& aSurf1 = mySurface1; // to avoid ambiguity
myDomain1->Initialize(aSurf1);
const Handle(Adaptor3d_Surface)& aSurf2 = mySurface2; // to avoid ambiguity
Standard_Real Deflection=0.01,MaxUV=0.01;
if (!myForceTolerances) {
- FTOL_FaceTolerances3d(B1,B2,myFace1,myFace2,S1,S2,
+ FTOL_FaceTolerances3d(B1,B2,myFace1,myFace2, mySurface1, mySurface2,
myTol1,myTol2,Deflection,MaxUV);
myTol1 = (myTol1 > 1.e-4)? 1.e-4: myTol1;
myTol2 = (myTol2 > 1.e-4)? 1.e-4: myTol2;
// mySurfacesSameOriented : a mettre dans IntPatch NYI
if ( SameDomain() ) {
- mySurfacesSameOriented = TopOpeBRepTool_ShapeTool::SurfacesSameOriented(S1,S2);
+ mySurfacesSameOriented = TopOpeBRepTool_ShapeTool::SurfacesSameOriented(mySurface1, mySurface2);
}
// build the map of edges found as RESTRICTION
myLineNb = 0;
Standard_Integer n = myIntersector.NbLines();
myHAL = new TopOpeBRep_HArray1OfLineInter(0,n);
- BRepAdaptor_Surface& S1 = *mySurface1;
- BRepAdaptor_Surface& S2 = *mySurface2;
// modified by NIZHNY-MKK Mon Apr 2 12:14:58 2001.BEGIN
if(n==0)
for(Standard_Integer index = 1; index <= myLineNb; index++) {
TopOpeBRep_LineInter& LI = myHAL->ChangeValue(index);
const Handle(IntPatch_Line)& L = aSeqOfResultLines.Value(index);
- LI.SetLine(L,S1,S2);
+ LI.SetLine(L, mySurface1, mySurface2);
LI.Index(index);
}
}
}
aPOnLine = gp_Pnt2d(u, v);
- Standard_Real par1 = Geom2dInt_TheProjPCurOfGInter::FindParameter (*theArc, aPOnLine, 1.e-7);
+ Standard_Real par1 = Geom2dInt_TheProjPCurOfGInter::FindParameter (theArc, aPOnLine, 1.e-7);
if(theRank == 1) {
Vtx2.ParametersOnS1(u, v);
Vtx2.ParametersOnS2(u, v);
}
aPOnLine = gp_Pnt2d(u, v);
- Standard_Real par2 = Geom2dInt_TheProjPCurOfGInter::FindParameter (*theArc, aPOnLine, 1.e-7);
+ Standard_Real par2 = Geom2dInt_TheProjPCurOfGInter::FindParameter (theArc, aPOnLine, 1.e-7);
Standard_Real tol = (Vtx1.Tolerance() > Vtx2.Tolerance()) ? Vtx1.Tolerance() : Vtx2.Tolerance();
Vtx.ParametersOnS2(u, v);
}
gp_Pnt2d atmpPoint(u, v);
- Standard_Real apar = Geom2dInt_TheProjPCurOfGInter::FindParameter (*theArc, atmpPoint, 1.e-7);
+ Standard_Real apar = Geom2dInt_TheProjPCurOfGInter::FindParameter (theArc, atmpPoint, 1.e-7);
Vtx.SetParameter(apar);
anRLine->AddVertex(Vtx);
}
Vtx.ParametersOnS2(u, v);
}
gp_Pnt2d atmpPoint(u, v);
- Standard_Real apar = Geom2dInt_TheProjPCurOfGInter::FindParameter (*theArc, atmpPoint, 1.e-7);
+ Standard_Real apar = Geom2dInt_TheProjPCurOfGInter::FindParameter (theArc, atmpPoint, 1.e-7);
Vtx.SetParameter(apar);
anRLine->AddVertex(Vtx);
}
POn2S.ParametersOnS2(u, v);
}
gp_Pnt2d aPOnArc, aPOnLine(u, v);
- Standard_Real par = Geom2dInt_TheProjPCurOfGInter::FindParameter (*theDomain->Value(), aPOnLine, 1e-7);
+ Standard_Real par = Geom2dInt_TheProjPCurOfGInter::FindParameter (theDomain->Value(), aPOnLine, 1e-7);
aPOnArc = theDomain->Value()->Value(par);
gp_Pnt ap;
gp_Vec ad1u, ad1v;
Handle(Geom_Curve) aCEdge=BRep_Tool::Curve(*anE, firstES1, lastES1);
if ( aCEdge.IsNull() ) // e.g. degenerated edge, see OCC21770
continue;
- GeomAdaptor_Curve CE;
- CE.Load(aCEdge);
+ Handle(GeomAdaptor_Curve) CE = new GeomAdaptor_Curve(aCEdge);
Extrema_ExtPC epc(theTestPoint, CE, 1.e-7);
if( epc.IsDone() )
gp_Pnt2d aPOnLine_F(Upf, Vpf);
gp_Pnt2d aPOnLine_L(Upl, Vpl);
- Standard_Real par_F = Geom2dInt_TheProjPCurOfGInter::FindParameter (*arc, aPOnLine_F, tol);
- Standard_Real par_L = Geom2dInt_TheProjPCurOfGInter::FindParameter (*arc, aPOnLine_L, tol);
+ Standard_Real par_F = Geom2dInt_TheProjPCurOfGInter::FindParameter (arc, aPOnLine_F, tol);
+ Standard_Real par_L = Geom2dInt_TheProjPCurOfGInter::FindParameter (arc, aPOnLine_L, tol);
WLVertexParameters.Append(par_F);
WLVertexParameters.Append(par_L);
Standard_Real param = (firstES1 + WLVertexParameters.Value(1)) / 2.;
gp_Pnt point;
aCEdge->D0(param, point);
- if( !IsPointOK(point, *theSurfaceTool, CheckTol) )
+ if( !IsPointOK(point, theSurfaceTool, CheckTol) )
{
classifyOK = Standard_False;
break;
Standard_Real param = (lastES1 + WLVertexParameters.Value(WLVertexParameters.Length())) / 2.;
gp_Pnt point;
aCEdge->D0(param, point);
- if( !IsPointOK(point, *theSurfaceTool, CheckTol) )
+ if( !IsPointOK(point, theSurfaceTool, CheckTol) )
{
classifyOK = Standard_False;
break;
Standard_Real param = (WLVertexParameters.Value(i*2) + WLVertexParameters.Value(i*2+1)) / 2.;
gp_Pnt point;
aCEdge->D0(param, point);
- if( !IsPointOK(point, *theSurfaceTool, CheckTol) )
+ if( !IsPointOK(point, theSurfaceTool, CheckTol) )
{
classifyOK = Standard_False;
break;
Extrema_POnSurf pOnS1;
Extrema_POnSurf pOnS2;
gp_Pnt arcpoint = PointsFromArc.Value( i );
- Standard_Boolean isOnS1 = GetPointOn2S( arcpoint, *theSurfaceObj, CheckTol, pOnS1 );
- Standard_Boolean isOnS2 = GetPointOn2S( arcpoint, *theSurfaceTool, CheckTol, pOnS2 );
+ Standard_Boolean isOnS1 = GetPointOn2S( arcpoint, theSurfaceObj, CheckTol, pOnS1 );
+ Standard_Boolean isOnS2 = GetPointOn2S( arcpoint, theSurfaceTool, CheckTol, pOnS2 );
if( isOnS1 && isOnS2 )
{
Standard_Real u1 = 0., v1 = 0., u2 = 0., v2 = 0.;
// purpose: returns the state of testPoint on OTHER face.
//========================================================================================
static Standard_Boolean IsPointOK(const gp_Pnt& theTestPnt,
- const Adaptor3d_Surface& theTestSurface,
+ const Handle(Adaptor3d_Surface)& theTestSurface,
const Standard_Real& theTol)
{
Standard_Boolean result = Standard_False;
// purpose: check state of testPoint and returns result point if state is OK.
//========================================================================================
static Standard_Boolean GetPointOn2S(const gp_Pnt& theTestPnt,
- const Adaptor3d_Surface& theTestSurface,
+ const Handle(Adaptor3d_Surface)& theTestSurface,
const Standard_Real& theTol,
Extrema_POnSurf& theResultPoint)
{
//purpose :
//=======================================================================
void TopOpeBRep_Hctxee2d::SetEdges(const TopoDS_Edge& E1,const TopoDS_Edge& E2,
- const BRepAdaptor_Surface& BAS1,
- const BRepAdaptor_Surface& BAS2)
+ const Handle(BRepAdaptor_Surface)& BAS1,
+ const Handle(BRepAdaptor_Surface)& BAS2)
{
- const TopoDS_Face& F1 = BAS1.Face();
- GeomAbs_SurfaceType ST1 = BAS1.GetType();
- const TopoDS_Face& F2 = BAS2.Face();
+ const TopoDS_Face& F1 = BAS1->Face();
+ GeomAbs_SurfaceType ST1 = BAS1->GetType();
+ const TopoDS_Face& F2 = BAS2->Face();
myEdge1 = TopoDS::Edge(E1);
myEdge2 = TopoDS::Edge(E2);
Handle(Geom2d_Curve) PC1;
PC1 = FC2D_CurveOnSurface(myEdge1,F1,first,last,tolpc);
if (PC1.IsNull()) throw Standard_Failure("TopOpeBRep_Hctxee2d::SetEdges : no 2d curve");
- myCurve1.Load(PC1);
+ myCurve1 = new Geom2dAdaptor_Curve(PC1);
BRep_Tool::UVPoints(myEdge1,F1,pfirst,plast);
tole = BRep_Tool::Tolerance(myEdge1);
myDomain1.SetValues(pfirst,first,tole,plast,last,tole);
if ( ST1 == GeomAbs_Plane || memesfaces || memesupport) {
Handle(Geom2d_Curve) PC2 = FC2D_CurveOnSurface(myEdge2,F1,first,last,tolpc);
- myCurve2.Load(PC2);
+ myCurve2 = new Geom2dAdaptor_Curve(PC2);
BRep_Tool::UVPoints(myEdge2,F1,pfirst,plast);
tole = BRep_Tool::Tolerance(myEdge2);
myDomain2.SetValues(pfirst,first,tole,plast,last,tole);
}
if (!PC2on1.IsNull()) {
- myCurve2.Load(PC2on1);
+ myCurve2 = new Geom2dAdaptor_Curve(PC2on1);
tole = BRep_Tool::Tolerance(myEdge2);
PC2on1->D0(first,pfirst);
PC2on1->D0(last,plast);
//function : Curve
//purpose :
//=======================================================================
-const Geom2dAdaptor_Curve& TopOpeBRep_Hctxee2d::Curve(const Standard_Integer Index) const
+const Handle(Geom2dAdaptor_Curve)& TopOpeBRep_Hctxee2d::Curve(const Standard_Integer Index) const
{
if ( Index == 1 ) return myCurve1;
else if ( Index == 2 ) return myCurve2;
Standard_EXPORT TopOpeBRep_Hctxee2d();
- Standard_EXPORT void SetEdges (const TopoDS_Edge& E1, const TopoDS_Edge& E2, const BRepAdaptor_Surface& BAS1, const BRepAdaptor_Surface& BAS2);
+ Standard_EXPORT void SetEdges (const TopoDS_Edge& E1, const TopoDS_Edge& E2, const Handle(BRepAdaptor_Surface)& BAS1, const Handle(BRepAdaptor_Surface)& BAS2);
Standard_EXPORT const TopoDS_Shape& Edge (const Standard_Integer I) const;
- Standard_EXPORT const Geom2dAdaptor_Curve& Curve (const Standard_Integer I) const;
+ Standard_EXPORT const Handle(Geom2dAdaptor_Curve)& Curve (const Standard_Integer I) const;
Standard_EXPORT const IntRes2d_Domain& Domain (const Standard_Integer I) const;
TopoDS_Edge myEdge1;
- Geom2dAdaptor_Curve myCurve1;
+ Handle(Geom2dAdaptor_Curve) myCurve1;
IntRes2d_Domain myDomain1;
TopoDS_Edge myEdge2;
- Geom2dAdaptor_Curve myCurve2;
+ Handle(Geom2dAdaptor_Curve) myCurve2;
IntRes2d_Domain myDomain2;
//=======================================================================
void TopOpeBRep_Hctxff2d::SetHSurfacesPrivate()
{
- BRepAdaptor_Surface& S1 = *mySurface1;
- myFace1 = S1.Face();
- mySurfaceType1 = S1.GetType();
+ myFace1 = mySurface1->Face();
+ mySurfaceType1 = mySurface1->GetType();
- BRepAdaptor_Surface& S2 = *mySurface2;
- myFace2 = S2.Face();
- mySurfaceType2 = S2.GetType();
+ myFace2 = mySurface2->Face();
+ mySurfaceType2 = mySurface2->GetType();
mySurfacesSameOriented = Standard_True;
myFacesSameOriented = Standard_True;
so21 = TopOpeBRepTool_ShapeTool::FacesSameOriented(face1forward,myFace2);
myf2surf1F_sameoriented = so21;
- mySurfacesSameOriented = TopOpeBRepTool_ShapeTool::SurfacesSameOriented(S1,S2);
+ mySurfacesSameOriented = TopOpeBRepTool_ShapeTool::SurfacesSameOriented(mySurface1, mySurface2);
myFacesSameOriented = TopOpeBRepTool_ShapeTool::FacesSameOriented(myFace1,myFace2);
#ifdef OCCT_DEBUG
//=======================================================================
void TopOpeBRep_LineInter::SetLine(const Handle(IntPatch_Line)& L,
- const BRepAdaptor_Surface& S1,
- const BRepAdaptor_Surface& S2)
+ const Handle(BRepAdaptor_Surface)& S1,
+ const Handle(BRepAdaptor_Surface)& S2)
{
// load line according to its type
myIL = L;
// transform an analytic line to a walking line
if (myTypeLineCurve == TopOpeBRep_ANALYTIC) {
IntPatch_SequenceOfLine aSLin;
- FUN_ALINETOWLINE(myILA,new BRepAdaptor_Surface(S1),
- new BRepAdaptor_Surface(S2), aSLin);
+ FUN_ALINETOWLINE(myILA, S1, S2, aSLin);
if(aSLin.Length() > 0)
myILW = Handle(IntPatch_WLine)::DownCast(aSLin.Value(1));
TopOpeBRep_LineInter();
- Standard_EXPORT void SetLine (const Handle(IntPatch_Line)& L, const BRepAdaptor_Surface& S1, const BRepAdaptor_Surface& S2);
+ Standard_EXPORT void SetLine (const Handle(IntPatch_Line)& L, const Handle(BRepAdaptor_Surface)& S1, const Handle(BRepAdaptor_Surface)& S2);
void SetFaces (const TopoDS_Face& F1, const TopoDS_Face& F2);
const TopoDS_Edge& E = TopoDS::Edge(it.Value());
Standard_Real tolE = BRep_Tool::Tolerance(E);
Standard_Real maxtol = Max(tolE,GLOBAL_tolFF);
- BRepAdaptor_Curve BAC(E);
- f = BAC.FirstParameter(); l = BAC.LastParameter();
+ Handle(BRepAdaptor_Curve) BAC = new BRepAdaptor_Curve(E);
+ f = BAC->FirstParameter(); l = BAC->LastParameter();
Standard_Boolean pinc = FUN_tool_PinC(Pm,BAC,f,l,maxtol);
if (pinc) {isone = Standard_True; break;}
}
{ // prequesitory : E1, E2 are restriction edges of opposite rank
// found in the same FacesFiller
Standard_Boolean ok = Standard_False;
- BRepAdaptor_Curve BAC;
+ Handle(BRepAdaptor_Curve) BAC = new BRepAdaptor_Curve();
TopoDS_Vertex v1,v2;TopExp::Vertices(E1,v1,v2);
TopoDS_Vertex v3,v4;TopExp::Vertices(E2,v3,v4);
if (!ok) {
- BAC.Initialize(E1);
+ BAC->Initialize(E1);
Standard_Real tol1 = BRep_Tool::Tolerance(E1);
Standard_Real tol2 = BRep_Tool::Tolerance(v3);
Standard_Real tol3 = BRep_Tool::Tolerance(v4);
}
}
if (!ok) {
- BAC.Initialize(E2);
+ BAC->Initialize(E2);
Standard_Real tol1 = BRep_Tool::Tolerance(E2);
Standard_Real tol2 = BRep_Tool::Tolerance(v1);
Standard_Real tol3 = BRep_Tool::Tolerance(v2);
const gp_Dir& aSecDir,
Standard_Real& aCrvt)
{
- BRepAdaptor_Surface aSurf(aFace);
+ Handle(BRepAdaptor_Surface) aSurf = new BRepAdaptor_Surface(aFace);
Standard_Integer cn = BRepLProp_SurfaceTool::Continuity(aSurf);
if (cn < 2) return Standard_False;
BRepLProp_SLProps aProp(aSurf, aP2d.X(), aP2d.Y(), 2, Precision::Confusion());
for (; aWEx.More(); aWEx.Next()) {
const TopoDS_Edge& anEdge = TopoDS::Edge(aWEx.Current());
Standard_Real aTolE = BRep_Tool::Tolerance(anEdge);
- BRepAdaptor_Curve2d aBAC2d (anEdge,myCorrectedFace);
+ Handle(BRepAdaptor_Curve2d) aBAC2d = new BRepAdaptor_Curve2d(anEdge, myCorrectedFace);
BndLib_Add2dCurve::Add(aBAC2d, aTolE, aB2d);
}
B2d=aB2d;
gp_Pnt aPOri;
gp_Vec aTgOri;
/////
- Handle (Geom_Curve) GCOri=aCAOri.Curve().Curve();
+ Handle (Geom_Curve) GCOri=aCAOri.Curve()->Curve();
Handle (Geom_Curve) aCopyCurve = Handle(Geom_Curve)::DownCast(GCOri -> Copy());
const TopLoc_Location& aLoc = aEOri.Location();
const TopoDS_Face& S,
const Standard_Real aMaxTol);
static
- Standard_Boolean Validate(const Adaptor3d_Curve& CRef,
- const Adaptor3d_Curve& Other,
+ Standard_Boolean Validate(const Handle(Adaptor3d_Curve)& CRef,
+ const Handle(Adaptor3d_Curve)& Other,
const Standard_Real Tol,
const Standard_Boolean SameParameter,
Standard_Real& aNewTolerance);
Handle(Geom2d_Curve) PC = cr->PCurve();
Handle(GeomAdaptor_Surface) GAHS = new GeomAdaptor_Surface(Sb);
Handle(Geom2dAdaptor_Curve) GHPC = new Geom2dAdaptor_Curve(PC,f,l);
- Adaptor3d_CurveOnSurface ACS(GHPC,GAHS);
- ok = Validate (*myHCurve, ACS, Tol, SameParameter, aNewTol);
+ Handle(Adaptor3d_CurveOnSurface) ACS = new Adaptor3d_CurveOnSurface(GHPC,GAHS);
+ ok = Validate (myHCurve, ACS, Tol, SameParameter, aNewTol);
if (ok) {
// printf("(Edge,1) Tolerance=%15.10lg\n", aNewTol);
if (aNewTol<aMaxTol)
if (cr->IsCurveOnClosedSurface()) {
// checkclosed = Standard_True;
GHPC->Load(cr->PCurve2(),f,l); // same bounds
- ACS.Load(GHPC, GAHS); // sans doute inutile
- ok = Validate (*myHCurve, ACS, Tol, SameParameter, aNewTol);
+ ACS->Load(GHPC, GAHS); // sans doute inutile
+ ok = Validate (myHCurve, ACS, Tol, SameParameter, aNewTol);
if (ok) {
if (aNewTol<aMaxTol)
TE->UpdateTolerance(aNewTol);
Handle(GeomAdaptor_Curve) aHCurve = new GeomAdaptor_Curve(ProjOnPlane);
- ProjLib_ProjectedCurve proj(GAHS,aHCurve);
+ Handle(ProjLib_ProjectedCurve) proj = new ProjLib_ProjectedCurve(GAHS,aHCurve);
Handle(Geom2d_Curve) PC = Geom2dAdaptor::MakeCurve(proj);
Handle(Geom2dAdaptor_Curve) GHPC =
new Geom2dAdaptor_Curve(PC, myHCurve->FirstParameter(), myHCurve->LastParameter());
- Adaptor3d_CurveOnSurface ACS(GHPC,GAHS);
+ Handle(Adaptor3d_CurveOnSurface) ACS = new Adaptor3d_CurveOnSurface(GHPC,GAHS);
- ok = Validate (*myHCurve, ACS,
+ ok = Validate (myHCurve, ACS,
Tol,Standard_True, aNewTol); // voir dub...
if (ok)
{
//function : Validate
//purpose :
//=======================================================================
-Standard_Boolean Validate(const Adaptor3d_Curve& CRef,
- const Adaptor3d_Curve& Other,
+Standard_Boolean Validate(const Handle(Adaptor3d_Curve)& CRef,
+ const Handle(Adaptor3d_Curve)& Other,
const Standard_Real Tol,
const Standard_Boolean SameParameter,
Standard_Real& aNewTolerance)
{
Standard_Real First, Last, MaxDistance, aD;
- First = CRef.FirstParameter();
- Last = CRef.LastParameter();
+ First = CRef->FirstParameter();
+ Last = CRef->LastParameter();
MaxDistance = Tol*Tol;
Standard_Integer i, aNC1=NCONTROL-1;
Standard_Boolean aFlag=Standard_False;
Standard_Boolean proj = (!SameParameter ||
- First != Other.FirstParameter() ||
- Last != Other.LastParameter());
+ First != Other->FirstParameter() ||
+ Last != Other->LastParameter());
//
// 1.
if (!proj) {
for (i = 0; i < NCONTROL; i++) {
Standard_Real prm = ((aNC1-i)*First + i*Last)/aNC1;
- gp_Pnt pref = CRef.Value(prm);
- gp_Pnt pother = Other.Value(prm);
+ gp_Pnt pref = CRef->Value(prm);
+ gp_Pnt pother = Other->Value(prm);
aD=pref.SquareDistance(pother);
else {
Extrema_LocateExtPC refd,otherd;
Standard_Real OFirst, OLast;
- OFirst = Other.FirstParameter();
- OLast = Other.LastParameter();
+ OFirst = Other->FirstParameter();
+ OLast = Other->LastParameter();
- gp_Pnt pd = CRef.Value(First);
- gp_Pnt pdo = Other.Value(OFirst);
+ gp_Pnt pd = CRef->Value(First);
+ gp_Pnt pdo = Other->Value(OFirst);
aD = pd.SquareDistance(pdo);
if (aD > MaxDistance) {
aFlag=Standard_True;
}
- pd = CRef.Value(Last);
- pdo = Other.Value(OLast);
+ pd = CRef->Value(Last);
+ pdo = Other->Value(OLast);
aD = pd.SquareDistance(pdo);
if (aD > MaxDistance) {
MaxDistance=aD;
aFlag=Standard_True;
}
- refd.Initialize(CRef, First, Last, CRef.Resolution(Tol));
- otherd.Initialize(Other, OFirst, OLast, Other.Resolution(Tol));
+ refd.Initialize(CRef, First, Last, CRef->Resolution(Tol));
+ otherd.Initialize(Other, OFirst, OLast, Other->Resolution(Tol));
for (i = 2; i< aNC1; i++) {
Standard_Real rprm = ((aNC1-i)*First + i*Last)/aNC1;
- gp_Pnt pref = CRef.Value(rprm);
+ gp_Pnt pref = CRef->Value(rprm);
Standard_Real oprm = ((aNC1-i)*OFirst + i*OLast)/aNC1;
- gp_Pnt pother = Other.Value(oprm);
+ gp_Pnt pother = Other->Value(oprm);
refd.Perform(pother,rprm);
if (!refd.IsDone() || refd.SquareDistance() > Tol * Tol) {
{
gp_Pnt P = BRep_Tool::Pnt(V);
Standard_Real tol = BRep_Tool::Tolerance(V);
- GeomAdaptor_Curve GAC(C);
+ Handle(GeomAdaptor_Curve) GAC = new GeomAdaptor_Curve(C);
Extrema_ExtPC extrema(P,GAC);
if (extrema.IsDone()) {
Standard_Integer i,n = extrema.NbExt();
Standard_Boolean FUN_findPonF(const TopoDS_Edge& E,const TopOpeBRepDS_DataStructure& BDS, const TopOpeBRepDS_ListOfInterference& LIF,gp_Pnt& P,Standard_Real& par)
{
Standard_Boolean Pok = Standard_False;
- BRepAdaptor_Curve BAC(E);
+ Handle(BRepAdaptor_Curve) BAC = new BRepAdaptor_Curve(E);
const TopOpeBRepDS_ListOfInterference& LIE = BDS.ShapeInterferences(E);
TopOpeBRepDS_ListIteratorOfListOfInterference itI; itI.Initialize(LIE);
continue;
}
- BAC.D0(par,P);
+ BAC->D0(par,P);
Pok = FUN_isPonF(LIF,P,BDS,E);
// P est OK pour toutes les faces de LIF : on arrete de chercher
if (Pok) {
Standard_EXPORT Standard_Boolean FUN_Parameters
(const gp_Pnt& Pnt,const TopoDS_Shape& F,Standard_Real& u,Standard_Real& v)
{
- BRepAdaptor_Surface Surf(TopoDS::Face(F));
+ Handle(BRepAdaptor_Surface) Surf = new BRepAdaptor_Surface(TopoDS::Face(F));
// Get 2d coord of the projection of <Pnt> on surface of <F>.
- Standard_Real uvtol = Surf.Tolerance();
- Standard_Real fu=Surf.FirstUParameter(),lu=Surf.LastUParameter();
- Standard_Real fv=Surf.FirstVParameter(),lv=Surf.LastVParameter();
+ Standard_Real uvtol = Surf->Tolerance();
+ Standard_Real fu=Surf->FirstUParameter(),lu=Surf->LastUParameter();
+ Standard_Real fv=Surf->FirstVParameter(),lv=Surf->LastVParameter();
Extrema_ExtPS extps(Pnt,Surf,fu,lu,fv,lv,uvtol,uvtol);
if (!extps.IsDone()) {
return Standard_False;
(const TopoDS_Shape& F,const gp_Pnt2d& uv,
gp_Dir& Norm,gp_Dir& D1,gp_Dir& D2,Standard_Real& Cur1,Standard_Real& Cur2)
{
- BRepAdaptor_Surface surf(TopoDS::Face(F));
+ Handle(BRepAdaptor_Surface) surf = new BRepAdaptor_Surface(TopoDS::Face(F));
Standard_Real uu = uv.X(),vv = uv.Y();
Standard_Boolean sphere = FUN_sphere(F);
if (plane)
Norm = FUN_tool_nggeomF(uv, TopoDS::Face(F));
else if (sphere) {
- gp_Pnt center = surf.Sphere().Location();
- gp_Pnt value = surf.Value(uu,vv);
+ gp_Pnt center = surf->Sphere().Location();
+ gp_Pnt value = surf->Value(uu,vv);
Norm = gp_Dir(gp_Vec(center,value)); // recall : input data for TopTrans_SurfaceTransition
// describes "direct" geometry
}
Standard_Boolean haspc = FC2D_HasCurveOnSurface(E,myFref);
if (!haspc) return Standard_False;
- BRepAdaptor_Curve2d BC2d(E,myFref);
- Standard_Real tol2d = BC2d.Resolution(tolE);
+ Handle(BRepAdaptor_Curve2d) BC2d = new BRepAdaptor_Curve2d(E,myFref);
+ Standard_Real tol2d = BC2d->Resolution(tolE);
BndLib_Add2dCurve::Add(BC2d,tol2d,B2d);
}
mymapsbox2d.Add(S,B2d);
else { // 2drep(E, myFref) is NOT an iso
// ------------------------------
Bnd_Box2d Bn2d;
- Geom2dAdaptor_Curve GC2d(PC,f,l);
+ Handle(Geom2dAdaptor_Curve) GC2d = new Geom2dAdaptor_Curve(PC,f,l);
Standard_Real tolE = BRep_Tool::Tolerance(E);
Standard_Real toladd = Max(tolE,tol);
BndLib_Add2dCurve::Add(GC2d,toladd,Bn2d);
Standard_Boolean withtangency = Standard_True;
Standard_Boolean compminmaxUV = Standard_True;
- BRepAdaptor_Surface BAS1(TopoDS::Face(S1),compminmaxUV);
- BRepAdaptor_Surface BAS2(TopoDS::Face(S2),compminmaxUV);
+ Handle(BRepAdaptor_Surface) BAS1 = new BRepAdaptor_Surface(TopoDS::Face(S1), compminmaxUV);
+ Handle(BRepAdaptor_Surface) BAS2 = new BRepAdaptor_Surface(TopoDS::Face(S2), compminmaxUV);
Handle(BRepApprox_ApproxLine) AL;
Approx.SetParameters(tol3d,tol2d,degmin,degmax,nitmax,NbPntMax,withtangency,
parametrization);
- if (CompC3D && CompPC1 && BAS1.GetType() == GeomAbs_Plane) {
+ if (CompC3D && CompPC1 && BAS1->GetType() == GeomAbs_Plane) {
//-- The curve X,Y,Z and U2,V2 is approximated
Approx.Perform(BAS1,BAS2,AL,CompC3D,Standard_False,CompPC2,iparmin,iparmax);
}
- else if(CompC3D && CompPC2 && BAS2.GetType() == GeomAbs_Plane) {
+ else if(CompC3D && CompPC2 && BAS2->GetType() == GeomAbs_Plane) {
//-- The curve X,Y,Z and U1,V1 is approximated
Approx.Perform(BAS1,BAS2,AL,CompC3D,CompPC1,Standard_False,iparmin,iparmax);
}
done = done && CheckApproxResults(Approx);
if (done) {
- if (CompC3D && CompPC1 && BAS1.GetType() == GeomAbs_Plane) {
+ if (CompC3D && CompPC1 && BAS1->GetType() == GeomAbs_Plane) {
C3Dnew = ::MakeCurve3DfromWLineApprox(Approx,1);
- PC1new = ::MakeCurve2DfromWLineApproxAndPlane(Approx,BAS1.Plane());
+ PC1new = ::MakeCurve2DfromWLineApproxAndPlane(Approx,BAS1->Plane());
if (CompPC2) PC2new = ::MakeCurve2DfromWLineApprox(Approx,2);
}
- else if(CompC3D && CompPC2 && BAS2.GetType() == GeomAbs_Plane) {
+ else if(CompC3D && CompPC2 && BAS2->GetType() == GeomAbs_Plane) {
C3Dnew = ::MakeCurve3DfromWLineApprox(Approx,1);
if (CompPC1) PC1new = ::MakeCurve2DfromWLineApprox(Approx,2);
- PC2new = ::MakeCurve2DfromWLineApproxAndPlane(Approx,BAS2.Plane());
+ PC2new = ::MakeCurve2DfromWLineApproxAndPlane(Approx,BAS2->Plane());
}
else {
if (CompC3D) C3Dnew = ::MakeCurve3DfromWLineApprox(Approx,1);
// ----------------------------------------------------------------------
Standard_EXPORT Standard_Boolean FUN_tool_projPonC(const gp_Pnt& P,
- const Standard_Real tole,const BRepAdaptor_Curve& BAC,
+ const Standard_Real tole,const Handle(BRepAdaptor_Curve)& BAC,
const Standard_Real pmin,const Standard_Real pmax,
Standard_Real& param,Standard_Real& dist)
{
if (!ok) {
for (Standard_Integer i = 1; i <= 2; i++) {
Standard_Real par = (i == 1) ? pmin : pmax;
- gp_Pnt pt = BAC.Value(par);
+ gp_Pnt pt = BAC->Value(par);
Standard_Real d2 = pt.SquareDistance(P);
Standard_Boolean onpt = (d2 < tole * tole);
if (onpt) {
// ----------------------------------------------------------------------
Standard_EXPORT Standard_Boolean FUN_tool_projPonC(const gp_Pnt& P,
- const BRepAdaptor_Curve& BAC,
+ const Handle(BRepAdaptor_Curve)& BAC,
const Standard_Real pmin,const Standard_Real pmax,
Standard_Real& param,Standard_Real& dist)
{
// <True> if projection succeeds,and sets <param> to parameter of <P> on <C>.
- Standard_Real tole = BAC.Tolerance();
+ Standard_Real tole = BAC->Tolerance();
Standard_Boolean ok = FUN_tool_projPonC(P,tole,BAC,pmin,pmax,param,dist);
return ok;
}
// ----------------------------------------------------------------------
Standard_EXPORT Standard_Boolean FUN_tool_projPonC(const gp_Pnt& P,
- const BRepAdaptor_Curve& BAC,
+ const Handle(BRepAdaptor_Curve)& BAC,
Standard_Real& param,Standard_Real& dist)
{
// <True> if projection succeeds,and sets <param> to parameter of <P> on <C>.
- Standard_Real tole = BAC.Tolerance();
- Standard_Real pmin = BAC.FirstParameter();
- Standard_Real pmax = BAC.LastParameter();
+ Standard_Real tole = BAC->Tolerance();
+ Standard_Real pmin = BAC->FirstParameter();
+ Standard_Real pmax = BAC->LastParameter();
Standard_Boolean ok = FUN_tool_projPonC(P,tole,BAC,pmin,pmax,param,dist);
return ok;
}
// ----------------------------------------------------------------------
Standard_EXPORT Standard_Boolean FUN_tool_projPonC2D(const gp_Pnt& P,
- const Standard_Real tole,const BRepAdaptor_Curve2d& BAC2D,
+ const Standard_Real tole,const Handle(BRepAdaptor_Curve2d)& BAC2D,
const Standard_Real pmin,const Standard_Real pmax,
Standard_Real& param,Standard_Real& dist)
{
Standard_Boolean ok = Standard_False;
gp_Pnt2d P2D;
- const TopoDS_Face& F = BAC2D.Face();
+ const TopoDS_Face& F = BAC2D->Face();
ok = FUN_tool_projPonF(P,F,P2D,dist);
if (!ok) return Standard_False;
if (!ok) {
for (Standard_Integer i = 1; i <= 2; i++) {
Standard_Real par = (i == 1) ? pmin : pmax;
- gp_Pnt2d pt2d = BAC2D.Value(par);
+ gp_Pnt2d pt2d = BAC2D->Value(par);
Standard_Real d2 = pt2d.SquareDistance(P2D);
Standard_Boolean onpt = (d2 < tole * tole);
if (onpt) {
// ----------------------------------------------------------------------
Standard_EXPORT Standard_Boolean FUN_tool_projPonC2D(const gp_Pnt& P,
- const BRepAdaptor_Curve2d& BAC2D,
+ const Handle(BRepAdaptor_Curve2d)& BAC2D,
const Standard_Real pmin,const Standard_Real pmax,
Standard_Real& param,Standard_Real& dist)
{
// <True> if projection succeeds,and sets <param> to parameter of <P> on <C>.
- Standard_Real tole = BRep_Tool::Tolerance(BAC2D.Edge());
+ Standard_Real tole = BRep_Tool::Tolerance(BAC2D->Edge());
Standard_Boolean ok = FUN_tool_projPonC2D(P,tole,BAC2D,pmin,pmax,param,dist);
return ok;
}
// ----------------------------------------------------------------------
Standard_EXPORT Standard_Boolean FUN_tool_projPonC2D(const gp_Pnt& P,
- const BRepAdaptor_Curve2d& BAC2D,
+ const Handle(BRepAdaptor_Curve2d)& BAC2D,
Standard_Real& param,Standard_Real& dist)
{
// <True> if projection succeeds,and sets <param> to parameter of <P> on <C>.
- Standard_Real tole = BRep_Tool::Tolerance(BAC2D.Edge());
- Standard_Real pmin = BAC2D.FirstParameter();
- Standard_Real pmax = BAC2D.LastParameter();
+ Standard_Real tole = BRep_Tool::Tolerance(BAC2D->Edge());
+ Standard_Real pmin = BAC2D->FirstParameter();
+ Standard_Real pmax = BAC2D->LastParameter();
Standard_Boolean ok = FUN_tool_projPonC2D(P,tole,BAC2D,pmin,pmax,param,dist);
return ok;
}
Standard_Real& param,Standard_Real& dist)
{
dist = 1.;
- BRepAdaptor_Curve BAC(E);
- Standard_Real first = BAC.FirstParameter();
- Standard_Real last = BAC.LastParameter();
+ Handle(BRepAdaptor_Curve) BAC = new BRepAdaptor_Curve(E);
+ Standard_Real first = BAC->FirstParameter();
+ Standard_Real last = BAC->LastParameter();
Standard_Boolean ok = FUN_tool_projPonC(P,tole,BAC,first,last,param,dist);
if (!ok) return Standard_False;
Standard_EXPORT void FUN_tool_bounds(const TopoDS_Edge& E,Standard_Real& f,Standard_Real& l);
Standard_EXPORT Standard_Integer FUN_tool_getindex(const Extrema_ExtPC& ponc);
Standard_EXPORT Standard_Integer FUN_tool_getindex(const Extrema_ExtPC2d& ponc);
-Standard_EXPORT Standard_Boolean FUN_tool_projPonC(const gp_Pnt& P,const Standard_Real tole,const BRepAdaptor_Curve& BAC,const Standard_Real pmin,const Standard_Real pmax,Standard_Real& param,Standard_Real& dist);
-Standard_EXPORT Standard_Boolean FUN_tool_projPonC(const gp_Pnt& P,const BRepAdaptor_Curve& BAC,const Standard_Real pmin,const Standard_Real pmax,Standard_Real& param,Standard_Real& dist);
-Standard_EXPORT Standard_Boolean FUN_tool_projPonC(const gp_Pnt& P,const BRepAdaptor_Curve& BAC,Standard_Real& param,Standard_Real& dist);
-Standard_EXPORT Standard_Boolean FUN_tool_projPonC2D(const gp_Pnt& P,const Standard_Real tole,const BRepAdaptor_Curve2d& BAC2D,const Standard_Real pmin,const Standard_Real pmax,Standard_Real& param,Standard_Real& dist);
-Standard_EXPORT Standard_Boolean FUN_tool_projPonC2D(const gp_Pnt& P,const BRepAdaptor_Curve2d& BAC2D,const Standard_Real pmin,const Standard_Real pmax,Standard_Real& param,Standard_Real& dist);
-Standard_EXPORT Standard_Boolean FUN_tool_projPonC2D(const gp_Pnt& P,const BRepAdaptor_Curve2d& BAC2D,Standard_Real& param,Standard_Real& dist);
+Standard_EXPORT Standard_Boolean FUN_tool_projPonC(const gp_Pnt& P,const Standard_Real tole,const Handle(BRepAdaptor_Curve)& BAC,const Standard_Real pmin,const Standard_Real pmax,Standard_Real& param,Standard_Real& dist);
+Standard_EXPORT Standard_Boolean FUN_tool_projPonC(const gp_Pnt& P,const Handle(BRepAdaptor_Curve)& BAC,const Standard_Real pmin,const Standard_Real pmax,Standard_Real& param,Standard_Real& dist);
+Standard_EXPORT Standard_Boolean FUN_tool_projPonC(const gp_Pnt& P,const Handle(BRepAdaptor_Curve)& BAC,Standard_Real& param,Standard_Real& dist);
+Standard_EXPORT Standard_Boolean FUN_tool_projPonC2D(const gp_Pnt& P,const Standard_Real tole,const Handle(BRepAdaptor_Curve2d)& BAC2D,const Standard_Real pmin,const Standard_Real pmax,Standard_Real& param,Standard_Real& dist);
+Standard_EXPORT Standard_Boolean FUN_tool_projPonC2D(const gp_Pnt& P,const Handle(BRepAdaptor_Curve2d)& BAC2D,const Standard_Real pmin,const Standard_Real pmax,Standard_Real& param,Standard_Real& dist);
+Standard_EXPORT Standard_Boolean FUN_tool_projPonC2D(const gp_Pnt& P,const Handle(BRepAdaptor_Curve2d)& BAC2D,Standard_Real& param,Standard_Real& dist);
Standard_EXPORT Standard_Boolean FUN_tool_projPonS(const gp_Pnt& P,const Handle(Geom_Surface)& S,gp_Pnt2d& UV,Standard_Real& dist,
const Extrema_ExtFlag anExtFlag=Extrema_ExtFlag_MINMAX,
const Extrema_ExtAlgo anExtAlgo=Extrema_ExtAlgo_Grad);
//=======================================================================
Standard_Boolean TopOpeBRepTool_ShapeTool::SurfacesSameOriented
-(const BRepAdaptor_Surface& S1,const BRepAdaptor_Surface& Sref)
+(const Handle(BRepAdaptor_Surface)& S1,const Handle(BRepAdaptor_Surface)& S2)
{
- const BRepAdaptor_Surface& S2 = Sref;
- GeomAbs_SurfaceType ST1 = S1.GetType();
- GeomAbs_SurfaceType ST2 = S2.GetType();
+ GeomAbs_SurfaceType ST1 = S1->GetType();
+ GeomAbs_SurfaceType ST2 = S2->GetType();
Standard_Boolean so = Standard_True;
if (ST1 == GeomAbs_Plane && ST2 == GeomAbs_Plane) {
- Standard_Real u1 = S1.FirstUParameter();
- Standard_Real v1 = S1.FirstVParameter();
- gp_Pnt p1; gp_Vec d1u,d1v; S1.D1(u1,v1,p1,d1u,d1v);
+ Standard_Real u1 = S1->FirstUParameter();
+ Standard_Real v1 = S1->FirstVParameter();
+ gp_Pnt p1; gp_Vec d1u,d1v; S1->D1(u1,v1,p1,d1u,d1v);
gp_Vec n1 = d1u.Crossed(d1v);
- Standard_Real u2 = S2.FirstUParameter();
- Standard_Real v2 = S2.FirstVParameter();
- gp_Pnt p2; gp_Vec d2u,d2v; S2.D1(u2,v2,p2,d2u,d2v);
+ Standard_Real u2 = S2->FirstUParameter();
+ Standard_Real v2 = S2->FirstVParameter();
+ gp_Pnt p2; gp_Vec d2u,d2v; S2->D1(u2,v2,p2,d2u,d2v);
gp_Vec n2 = d2u.Crossed(d2v);
Standard_Real d = n1.Dot(n2);
// prenons donc l'origine
Standard_Real u1 = 0.;
Standard_Real v1 = 0.;
- gp_Pnt p1; gp_Vec d1u,d1v; S1.D1(u1,v1,p1,d1u,d1v);
+ gp_Pnt p1; gp_Vec d1u,d1v; S1->D1(u1,v1,p1,d1u,d1v);
gp_Vec n1 = d1u.Crossed(d1v);
- Handle(Geom_Surface) HS2 = S2.Surface().Surface();
- HS2 = Handle(Geom_Surface)::DownCast(HS2->Transformed(S2.Trsf()));
+ Handle(Geom_Surface) HS2 = S2->Surface()->Surface();
+ HS2 = Handle(Geom_Surface)::DownCast(HS2->Transformed(S2->Trsf()));
gp_Pnt2d p22d; Standard_Real dp2;
Standard_Boolean ok = FUN_tool_projPonS(p1,HS2,p22d,dp2);
if ( !ok ) return so; // NYI : raise
Standard_Real u2 = p22d.X();
Standard_Real v2 = p22d.Y();
- gp_Pnt p2; gp_Vec d2u,d2v; S2.D1(u2,v2,p2,d2u,d2v);
+ gp_Pnt p2; gp_Vec d2u,d2v; S2->D1(u2,v2,p2,d2u,d2v);
gp_Vec n2 = d2u.Crossed(d2v);
Standard_Real d = n1.Dot(n2);
}
Standard_Boolean computerestriction = Standard_False;
- BRepAdaptor_Surface BAS1(F1,computerestriction);
- BRepAdaptor_Surface BAS2(F2,computerestriction);
+ Handle(BRepAdaptor_Surface) BAS1 = new BRepAdaptor_Surface(F1,computerestriction);
+ Handle(BRepAdaptor_Surface) BAS2 = new BRepAdaptor_Surface(F2,computerestriction);
Standard_Boolean so = F1.IsSame(F2) || SurfacesSameOriented(BAS1,BAS2);
Standard_Boolean b = so;
if ( o1 != o2 ) b = !so;
//=======================================================================
Standard_Boolean TopOpeBRepTool_ShapeTool::CurvesSameOriented
-(const BRepAdaptor_Curve& C1, const BRepAdaptor_Curve& Cref)
+(const Handle(BRepAdaptor_Curve)& C1, const Handle(BRepAdaptor_Curve)& C2)
{
- const BRepAdaptor_Curve& C2 = Cref;
- GeomAbs_CurveType CT1 = C1.GetType();
- GeomAbs_CurveType CT2 = C2.GetType();
+ GeomAbs_CurveType CT1 = C1->GetType();
+ GeomAbs_CurveType CT2 = C2->GetType();
Standard_Boolean so = Standard_True;
if (CT1 == GeomAbs_Line && CT2 == GeomAbs_Line) {
- Standard_Real p1 = C1.FirstParameter();
+ Standard_Real p1 = C1->FirstParameter();
gp_Dir t1,n1; Standard_Real c1; EdgeData(C1,p1,t1,n1,c1);
- Standard_Real p2 = C2.FirstParameter();
+ Standard_Real p2 = C2->FirstParameter();
gp_Dir t2,n2; Standard_Real c2; EdgeData(C2,p2,t2,n2,c2);
Standard_Real d = t1.Dot(t2);
so = (d > 0.);
o2 == TopAbs_EXTERNAL || o2 == TopAbs_INTERNAL ) {
return Standard_True;
}
- BRepAdaptor_Curve BAC1(E1);
- BRepAdaptor_Curve BAC2(E2);
+ Handle(BRepAdaptor_Curve) BAC1 = new BRepAdaptor_Curve(E1);
+ Handle(BRepAdaptor_Curve) BAC2 = new BRepAdaptor_Curve(E2);
Standard_Boolean so = CurvesSameOriented(BAC1,BAC2);
Standard_Boolean b = so;
if ( o1 != o2 ) b = !so;
//=======================================================================
Standard_Real TopOpeBRepTool_ShapeTool::EdgeData
-(const BRepAdaptor_Curve& BAC, const Standard_Real P,
+(const Handle(BRepAdaptor_Curve)& BAC, const Standard_Real P,
gp_Dir& T, gp_Dir& N, Standard_Real& C)
{
(const TopoDS_Shape& E, const Standard_Real P,
gp_Dir& T, gp_Dir& N, Standard_Real& C)
{
- BRepAdaptor_Curve BAC(TopoDS::Edge(E));
+ Handle(BRepAdaptor_Curve) BAC = new BRepAdaptor_Curve(TopoDS::Edge(E));
Standard_Real d = EdgeData(BAC,P,T,N,C);
return d;
}
Standard_EXPORT static Standard_Boolean ShapesSameOriented (const TopoDS_Shape& S1, const TopoDS_Shape& S2);
- Standard_EXPORT static Standard_Boolean SurfacesSameOriented (const BRepAdaptor_Surface& S1, const BRepAdaptor_Surface& S2);
+ Standard_EXPORT static Standard_Boolean SurfacesSameOriented (const Handle(BRepAdaptor_Surface)& S1, const Handle(BRepAdaptor_Surface)& S2);
Standard_EXPORT static Standard_Boolean FacesSameOriented (const TopoDS_Shape& F1, const TopoDS_Shape& F2);
- Standard_EXPORT static Standard_Boolean CurvesSameOriented (const BRepAdaptor_Curve& C1, const BRepAdaptor_Curve& C2);
+ Standard_EXPORT static Standard_Boolean CurvesSameOriented (const Handle(BRepAdaptor_Curve)& C1, const Handle(BRepAdaptor_Curve)& C2);
Standard_EXPORT static Standard_Boolean EdgesSameOriented (const TopoDS_Shape& E1, const TopoDS_Shape& E2);
//! Compute tangent T, normal N, curvature C at point of parameter
//! P on curve BRAC. Returns the tolerance indicating if T,N are null.
- Standard_EXPORT static Standard_Real EdgeData (const BRepAdaptor_Curve& BRAC, const Standard_Real P, gp_Dir& T, gp_Dir& N, Standard_Real& C);
+ Standard_EXPORT static Standard_Real EdgeData (const Handle(BRepAdaptor_Curve)& BRAC, const Standard_Real P, gp_Dir& T, gp_Dir& N, Standard_Real& C);
//! Same as previous on edge E.
Standard_EXPORT static Standard_Real EdgeData (const TopoDS_Shape& E, const Standard_Real P, gp_Dir& T, gp_Dir& N, Standard_Real& C);
//purpose :
//=======================================================================
-Standard_Boolean TopOpeBRepTool_TOOL::TggeomE(const Standard_Real par, const BRepAdaptor_Curve& BC,
+Standard_Boolean TopOpeBRepTool_TOOL::TggeomE(const Standard_Real par, const Handle(BRepAdaptor_Curve)& BC,
gp_Vec& Tg)
{
//#ifdef OCCT_DEBUG
// Standard_Boolean apoles = (ct == GeomAbs_BezierCurve)||(ct == GeomAbs_BSplineCurve);
//#endif
- Standard_Real f = BC.FirstParameter(), l = BC.LastParameter();
- Standard_Real tolE = BC.Tolerance(); Standard_Real tolp = BC.Resolution(tolE);
+ Standard_Real f = BC->FirstParameter(), l = BC->LastParameter();
+ Standard_Real tolE = BC->Tolerance(); Standard_Real tolp = BC->Resolution(tolE);
Standard_Boolean onf = Abs(f-par)<tolp; Standard_Boolean onl = Abs(l-par)<tolp;
Standard_Boolean inbounds = (f<par)&&(par<l);
if ((!inbounds) && (!onf) && (!onl)) return Standard_False;
Standard_Real thepar = par;
- gp_Pnt thepnt; BC.D1(thepar, thepnt, Tg);
+ gp_Pnt thepnt; BC->D1(thepar, thepnt, Tg);
Tg.Normalize();
return Standard_True;
Standard_Boolean isdgE = BRep_Tool::Degenerated(E);
if (isdgE) return Standard_False;
- BRepAdaptor_Curve BC(E);
+ Handle(BRepAdaptor_Curve) BC = new BRepAdaptor_Curve(E);
//modified by NIZNHY-PKV Fri Aug 4 09:49:31 2000 f
if (!CheckEdgeLength(E)) {
return Standard_False;
Standard_Real& curv)
{
curv = 0.;
- BRepAdaptor_Curve BAC(E);
- GeomAbs_CurveType CT = BAC.GetType();
+ Handle(BRepAdaptor_Curve) BAC = new BRepAdaptor_Curve(E);
+ GeomAbs_CurveType CT = BAC->GetType();
Standard_Boolean line = (CT == GeomAbs_Line);
Standard_Real tola = Precision::Angular()*1.e3;//NYITOLXPU
if (line) {
- gp_Dir dir = BAC.Line().Direction();
+ gp_Dir dir = BAC->Line().Direction();
Standard_Real dot = dir.Dot(tg0);
if (Abs(1-dot) < tola) return Standard_False;
return Standard_True;
Standard_EXPORT static void stuvF (const gp_Pnt2d& uv, const TopoDS_Face& F, Standard_Integer& onU, Standard_Integer& onV);
- Standard_EXPORT static Standard_Boolean TggeomE (const Standard_Real par, const BRepAdaptor_Curve& BC, gp_Vec& Tg);
+ Standard_EXPORT static Standard_Boolean TggeomE (const Standard_Real par, const Handle(BRepAdaptor_Curve)& BC, gp_Vec& Tg);
Standard_EXPORT static Standard_Boolean TggeomE (const Standard_Real par, const TopoDS_Edge& E, gp_Vec& Tg);
// ----------------------------------------------------------------------
Standard_EXPORT Standard_Boolean FUN_tool_PinC(const gp_Pnt& P,
- const BRepAdaptor_Curve& BAC,
+ const Handle(BRepAdaptor_Curve)& BAC,
const Standard_Real pmin,const Standard_Real pmax,
const Standard_Real tol)
{
// ----------------------------------------------------------------------
Standard_EXPORT Standard_Boolean FUN_tool_PinC(const gp_Pnt& P,
- const BRepAdaptor_Curve& BAC,
+ const Handle(BRepAdaptor_Curve)& BAC,
const Standard_Real tol)
{
// returns true if <P> is on <C> under a given tolerance <tol>
Standard_Boolean PinC = Standard_False;
- Standard_Real pmin = BAC.FirstParameter();
- Standard_Real pmax = BAC.LastParameter();
+ Standard_Real pmin = BAC->FirstParameter();
+ Standard_Real pmax = BAC->LastParameter();
PinC = FUN_tool_PinC(P,BAC,pmin,pmax,tol);
return PinC;
}
// => returns IN
// else,returns OUT.
TopAbs_State sta = TopAbs_UNKNOWN;
- BRepAdaptor_Curve BAC(E);
+ Handle(BRepAdaptor_Curve) BAC = new BRepAdaptor_Curve(E);
Extrema_ExtPC ProjonBAC(P,BAC);
if (ProjonBAC.IsDone() && ProjonBAC.NbExt()>0) {
Standard_Integer i = FUN_tool_getindex(ProjonBAC);
Standard_Real newtol = Max(tolE,tolpc);
BRep_Builder BB; BB.UpdateEdge(E,pc,F,newtol);
}
- BRepAdaptor_Curve2d BC2d(E,F);
+ Handle(BRepAdaptor_Curve2d) BC2d = new BRepAdaptor_Curve2d(E,F);
BndLib_Add2dCurve::Add(BC2d,tol,newB2d);
} //ex(W,EDGE)
}
// Standard_Real f,l;
- BRepAdaptor_Curve BAC(E);
+ Handle(BRepAdaptor_Curve) BAC = new BRepAdaptor_Curve(E);
Extrema_ExtPC pro(pt,BAC);
Standard_Boolean done = pro.IsDone() && (pro.NbExt() >0);
if (!done) return Standard_False;
}
// ----------------------------------------------------------------------
-Standard_EXPORT gp_Dir FUN_tool_dirC(const Standard_Real par,const BRepAdaptor_Curve& BAC)
+Standard_EXPORT gp_Dir FUN_tool_dirC(const Standard_Real par,const Handle(BRepAdaptor_Curve)& BAC)
{
- gp_Pnt p; gp_Vec tgE; BAC.D1(par,p,tgE);
+ gp_Pnt p; gp_Vec tgE; BAC->D1(par,p,tgE);
gp_Dir dirC(tgE);
return dirC;
}
{
Standard_Boolean isdgE = BRep_Tool::Degenerated(E);
if (isdgE) return gp_Vec(0,0,0);
- gp_Vec dirE(FUN_tool_dirC(paronE,E));
+ gp_Vec dirE(FUN_tool_dirC(paronE, new BRepAdaptor_Curve(E)));
return dirE;
}
// ----------------------------------------------------------------------
-Standard_EXPORT Standard_Boolean FUN_tool_line(const BRepAdaptor_Curve& BAC)
+Standard_EXPORT Standard_Boolean FUN_tool_line(const Handle(BRepAdaptor_Curve)& BAC)
{
- Standard_Boolean line = (BAC.GetType() == GeomAbs_Line);
+ Standard_Boolean line = (BAC->GetType() == GeomAbs_Line);
return line;
}
}
// ----------------------------------------------------------------------
-Standard_EXPORT Standard_Boolean FUN_tool_quad(const BRepAdaptor_Curve& BAC)
+Standard_EXPORT Standard_Boolean FUN_tool_quad(const Handle(BRepAdaptor_Curve)& BAC)
{
- GeomAbs_CurveType CT = BAC.GetType();
+ GeomAbs_CurveType CT = BAC->GetType();
Standard_Boolean isquad = Standard_False;
if (CT == GeomAbs_Line) isquad = Standard_True;
if (CT == GeomAbs_Circle) isquad = Standard_True;
}
// ----------------------------------------------------------------------
-Standard_EXPORT Standard_Boolean FUN_tool_findPinBAC(const BRepAdaptor_Curve& BAC,gp_Pnt& P,Standard_Real& par)
+Standard_EXPORT Standard_Boolean FUN_tool_findPinBAC(const Handle(BRepAdaptor_Curve)& BAC,gp_Pnt& P,Standard_Real& par)
{
FUN_tool_findparinBAC(BAC,par);
- BAC.D0(par,P);
+ BAC->D0(par,P);
return Standard_True;
}
// ----------------------------------------------------------------------
-Standard_EXPORT Standard_Boolean FUN_tool_findparinBAC(const BRepAdaptor_Curve& BAC,Standard_Real& par)
+Standard_EXPORT Standard_Boolean FUN_tool_findparinBAC(const Handle(BRepAdaptor_Curve)& BAC,Standard_Real& par)
{
- Standard_Real fE = BAC.FirstParameter(),lE = BAC.LastParameter();
+ Standard_Real fE = BAC->FirstParameter(),lE = BAC->LastParameter();
Standard_Real t = 0.34567237; par = (1-t)*fE + t*lE;
return Standard_True;
}
// ----------------------------------------------------------------------
Standard_EXPORT Standard_Boolean FUN_tool_findparinE(const TopoDS_Shape& E,Standard_Real& par)
{
- BRepAdaptor_Curve BAC(TopoDS::Edge(E));
+ Handle(BRepAdaptor_Curve) BAC = new BRepAdaptor_Curve(TopoDS::Edge(E));
Standard_Boolean r = FUN_tool_findparinBAC(BAC,par);
return r;
}
// ----------------------------------------------------------------------
Standard_EXPORT Standard_Boolean FUN_tool_findPinE(const TopoDS_Shape& E,gp_Pnt& P,Standard_Real& par)
{
- BRepAdaptor_Curve BAC(TopoDS::Edge(E));
+ Handle(BRepAdaptor_Curve) BAC = new BRepAdaptor_Curve(TopoDS::Edge(E));
Standard_Boolean r = FUN_tool_findPinBAC(BAC,P,par);
return r;
}
// ----------------------------------------------------------------------
// project point <P> on geometries (curve <C>,surface <S>)
// ----------------------------------------------------------------------
-Standard_EXPORT Standard_Boolean FUN_tool_PinC(const gp_Pnt& P,const BRepAdaptor_Curve& BAC,const Standard_Real pmin,const Standard_Real pmax,const Standard_Real tol);
-Standard_EXPORT Standard_Boolean FUN_tool_PinC(const gp_Pnt& P,const BRepAdaptor_Curve& BAC,const Standard_Real tol);
+Standard_EXPORT Standard_Boolean FUN_tool_PinC(const gp_Pnt& P,const Handle(BRepAdaptor_Curve)& BAC,const Standard_Real pmin,const Standard_Real pmax,const Standard_Real tol);
+Standard_EXPORT Standard_Boolean FUN_tool_PinC(const gp_Pnt& P,const Handle(BRepAdaptor_Curve)& BAC,const Standard_Real tol);
// ----------------------------------------------------------------------
Standard_EXPORT Standard_Boolean FUN_tool_value(const Standard_Real par,const TopoDS_Edge& E,gp_Pnt& P);
Standard_EXPORT Standard_Boolean FUN_tool_paronEF(const TopoDS_Edge& E,const Standard_Real& par,const TopoDS_Face& F,gp_Pnt2d& UV);
Standard_EXPORT Standard_Boolean FUN_tool_parF(const TopoDS_Edge& E,const Standard_Real& par,const TopoDS_Face& F,gp_Pnt2d& UV,const Standard_Real tol);
Standard_EXPORT Standard_Boolean FUN_tool_parF(const TopoDS_Edge& E,const Standard_Real& par,const TopoDS_Face& F,gp_Pnt2d& UV);
-Standard_EXPORT gp_Dir FUN_tool_dirC(const Standard_Real par,const BRepAdaptor_Curve& BAC);
+Standard_EXPORT gp_Dir FUN_tool_dirC(const Standard_Real par,const Handle(BRepAdaptor_Curve)& BAC);
Standard_EXPORT gp_Vec FUN_tool_tggeomE(const Standard_Real paronE,const TopoDS_Edge& E);
-Standard_EXPORT Standard_Boolean FUN_tool_line(const BRepAdaptor_Curve& BAC);
+Standard_EXPORT Standard_Boolean FUN_tool_line(const Handle(BRepAdaptor_Curve)& BAC);
Standard_EXPORT Standard_Boolean FUN_tool_quad(const TopoDS_Edge& E);
-Standard_EXPORT Standard_Boolean FUN_tool_quad(const BRepAdaptor_Curve& BAC);
+Standard_EXPORT Standard_Boolean FUN_tool_quad(const Handle(BRepAdaptor_Curve)& BAC);
Standard_EXPORT Standard_Boolean FUN_tool_quad(const TopoDS_Face& F);
-Standard_EXPORT Standard_Boolean FUN_tool_findPinBAC(const BRepAdaptor_Curve& BAC,gp_Pnt& P,Standard_Real& par);
-Standard_EXPORT Standard_Boolean FUN_tool_findparinBAC(const BRepAdaptor_Curve& BAC,Standard_Real& par);
+Standard_EXPORT Standard_Boolean FUN_tool_findPinBAC(const Handle(BRepAdaptor_Curve)& BAC,gp_Pnt& P,Standard_Real& par);
+Standard_EXPORT Standard_Boolean FUN_tool_findparinBAC(const Handle(BRepAdaptor_Curve)& BAC,Standard_Real& par);
Standard_EXPORT Standard_Boolean FUN_tool_findparinE(const TopoDS_Shape& E,Standard_Real& par);
Standard_EXPORT Standard_Boolean FUN_tool_findPinE(const TopoDS_Shape& E,gp_Pnt& P,Standard_Real& par);
Standard_EXPORT Standard_Boolean FUN_tool_maxtol(const TopoDS_Shape& S,const TopAbs_ShapeEnum& typ,Standard_Real& tol);
Standard_EXPORT void FTOL_FaceTolerances
(const Bnd_Box& B1, const Bnd_Box& B2,
const TopoDS_Face& myFace1, const TopoDS_Face& myFace2,
- const BRepAdaptor_Surface& mySurface1, const BRepAdaptor_Surface& mySurface2,
+ const Handle(BRepAdaptor_Surface)& mySurface1, const Handle(BRepAdaptor_Surface)& mySurface2,
Standard_Real& myTol1, Standard_Real& myTol2,
Standard_Real& Deflection, Standard_Real& MaxUV)
{
Standard_Real MMAXUV=0.01;
Standard_Real MU0,MU1,MV0,MV1,DP1,DP2,DP;
- MU0=mySurface1.FirstUParameter();
- MU1=mySurface1.LastUParameter();
- MV0=mySurface1.FirstVParameter();
- MV1=mySurface1.LastVParameter();
+ MU0=mySurface1->FirstUParameter();
+ MU1=mySurface1->LastUParameter();
+ MV0=mySurface1->FirstVParameter();
+ MV1=mySurface1->LastVParameter();
DP1 = MU1-MU0;
DP2 = MV1-MV0;
if(DP2<DP1) DP=DP2; else DP=DP1; //-- DP + petit
- MU0=mySurface2.FirstUParameter();
- MU1=mySurface2.LastUParameter();
- MV0=mySurface2.FirstVParameter();
- MV1=mySurface2.LastVParameter();
+ MU0=mySurface2->FirstUParameter();
+ MU1=mySurface2->LastUParameter();
+ MV0=mySurface2->FirstVParameter();
+ MV1=mySurface2->LastVParameter();
DP1 = MU1-MU0;
DP2 = MV1-MV0;
if(DP2>DP1) DP1=DP2; //-- DP1 + petit
else {
B2.Update(0., 0., 0., 1., 1., 1.);
}
- BRepAdaptor_Surface mySurface1;
- BRepAdaptor_Surface mySurface2;
- mySurface1.Initialize(myFace1);
- mySurface2.Initialize(myFace2);
+ Handle(BRepAdaptor_Surface) mySurface1 = new BRepAdaptor_Surface(myFace1);
+ Handle(BRepAdaptor_Surface) mySurface2 = new BRepAdaptor_Surface(myFace2);
Standard_Real Deflection=0.01,MaxUV=0.01;
Standard_Real myTol1,myTol2;
FTOL_FaceTolerances(B1,B2,
Standard_EXPORT void FTOL_FaceTolerances3d
(const Bnd_Box& B1, const Bnd_Box& B2,
const TopoDS_Face& myFace1, const TopoDS_Face& myFace2,
- const BRepAdaptor_Surface& mySurface1, const BRepAdaptor_Surface& mySurface2,
+ const Handle(BRepAdaptor_Surface)& mySurface1, const Handle(BRepAdaptor_Surface)& mySurface2,
Standard_Real& myTol1, Standard_Real& myTol2,
Standard_Real& Deflection, Standard_Real& MaxUV)
{
const Bnd_Box& B2,
const TopoDS_Face& myFace1,
const TopoDS_Face& myFace2,
- const BRepAdaptor_Surface& mySurface1,
- const BRepAdaptor_Surface& mySurface2,
+ const Handle(BRepAdaptor_Surface)& mySurface1,
+ const Handle(BRepAdaptor_Surface)& mySurface2,
Standard_Real& myTol1, Standard_Real& myTol2)
{
Standard_Real BIDDeflection,BIDMaxUV;
Standard_EXPORT void FTOL_FaceTolerances
(const Bnd_Box& B1,const Bnd_Box& B2,
const TopoDS_Face& myFace1,const TopoDS_Face& myFace2,
- const BRepAdaptor_Surface& mySurface1,const BRepAdaptor_Surface& mySurface2,
+ const Handle(BRepAdaptor_Surface)& mySurface1,const Handle(BRepAdaptor_Surface)& mySurface2,
Standard_Real& myTol1,Standard_Real& myTol2,
Standard_Real& Deflection,Standard_Real& MaxUV);
Standard_EXPORT void FTOL_FaceTolerances3d
(const Bnd_Box& B1,const Bnd_Box& B2,
const TopoDS_Face& myFace1,const TopoDS_Face& myFace2,
- const BRepAdaptor_Surface& mySurface1,const BRepAdaptor_Surface& mySurface2,
+ const Handle(BRepAdaptor_Surface)& mySurface1,const Handle(BRepAdaptor_Surface)& mySurface2,
Standard_Real& myTol1,Standard_Real& myTol2,
Standard_Real& Deflection,Standard_Real& MaxUV);
Standard_EXPORT void FTOL_FaceTolerances2d
(const Bnd_Box& B1,const Bnd_Box& B2,
const TopoDS_Face& myFace1,const TopoDS_Face& myFace2,
- const BRepAdaptor_Surface& mySurface1,const BRepAdaptor_Surface& mySurface2,
+ const Handle(BRepAdaptor_Surface)& mySurface1,const Handle(BRepAdaptor_Surface)& mySurface2,
Standard_Real& myTol1,Standard_Real& myTol2);
#endif
// ---------------------------------------
Handle(StepGeom_Curve) Gpms;
- Handle(Geom_Curve) C = CA.Curve().Curve();
+ Handle(Geom_Curve) C = CA.Curve()->Curve();
if (!C.IsNull()) {
C = Handle(Geom_Curve)::DownCast(C->Copy());
// function: FindLimits
// purpose:
//==================================================================
-static void FindLimits(const Adaptor3d_Curve& aCurve,
+static void FindLimits(const Handle(Adaptor3d_Curve)& aCurve,
const Standard_Real aLimit,
Standard_Real& First,
Standard_Real& Last)
{
- First = aCurve.FirstParameter();
- Last = aCurve.LastParameter();
+ First = aCurve->FirstParameter();
+ Last = aCurve->LastParameter();
Standard_Boolean firstInf = Precision::IsNegativeInfinite(First);
Standard_Boolean lastInf = Precision::IsPositiveInfinite(Last);
delta *= 2;
First = - delta;
Last = delta;
- aCurve.D0(First,P1);
- aCurve.D0(Last,P2);
+ aCurve->D0(First,P1);
+ aCurve->D0(Last,P2);
} while (P1.Distance(P2) < aLimit);
}
else if (firstInf) {
- aCurve.D0(Last,P2);
+ aCurve->D0(Last,P2);
do {
delta *= 2;
First = Last - delta;
- aCurve.D0(First,P1);
+ aCurve->D0(First,P1);
} while (P1.Distance(P2) < aLimit);
}
else if (lastInf) {
- aCurve.D0(First,P1);
+ aCurve->D0(First,P1);
do {
delta *= 2;
Last = First + delta;
- aCurve.D0(Last,P2);
+ aCurve->D0(Last,P2);
} while (P1.Distance(P2) < aLimit);
}
}
// function: DrawCurve
// purpose:
//==================================================================
-static void DrawCurve (const Adaptor3d_Curve& aCurve,
+static void DrawCurve (const Handle(Adaptor3d_Curve)& aCurve,
const Standard_Integer NbP,
const Standard_Real U1,
const Standard_Real U2,
Handle(TColgp_HArray1OfVec) HAV1;
Handle(TColStd_HArray1OfInteger) HAI1;
- if (aCurve.GetType() == GeomAbs_BSplineCurve) {
- nbintervals = aCurve.NbKnots() - 1;
-// std::cout << "NbKnots "<<aCurve.NbKnots() << std::endl;
+ if (aCurve->GetType() == GeomAbs_BSplineCurve) {
+ nbintervals = aCurve->NbKnots() - 1;
+// std::cout << "NbKnots "<<aCurve->NbKnots() << std::endl;
nbintervals = Max(1, nbintervals/3);
}
- switch (aCurve.GetType()) {
+ switch (aCurve->GetType()) {
case GeomAbs_Line:
{
gp_Vec V;
HAV1 = new TColgp_HArray1OfVec(1, 2);
// array of coordinates of line
- gp_Pnt p = aCurve.Value(U1);
+ gp_Pnt p = aCurve->Value(U1);
V.SetX(p.X()); V.SetY(p.Y()); V.SetZ(p.Z());
HAV1->SetValue(1,V);
- p = aCurve.Value(U2);
+ p = aCurve->Value(U2);
V.SetX(p.X()); V.SetY(p.Y()); V.SetZ(p.Z());
HAV1->SetValue(2,V);
for (i = 1; i <= N;i++) {
U = U1 + (i-1)*DU;
- p = aCurve.Value(U);
+ p = aCurve->Value(U);
V.SetX(p.X()); V.SetY(p.Y()); V.SetZ(p.Z());
HAV1->SetValue(i,V);
// function: Add 1
// purpose:
//==================================================================
-void VrmlConverter_Curve::Add(const Adaptor3d_Curve& aCurve,
+void VrmlConverter_Curve::Add(const Handle(Adaptor3d_Curve)& aCurve,
const Handle(VrmlConverter_Drawer)& aDrawer,
Standard_OStream& anOStream)
{
// function: Add 2
// purpose:
//==================================================================
-void VrmlConverter_Curve::Add(const Adaptor3d_Curve& aCurve,
+void VrmlConverter_Curve::Add(const Handle(Adaptor3d_Curve)& aCurve,
const Standard_Real U1,
const Standard_Real U2,
const Handle(VrmlConverter_Drawer)& aDrawer,
// function: Add 3
// purpose:
//==================================================================
-void VrmlConverter_Curve::Add(const Adaptor3d_Curve& aCurve,
+void VrmlConverter_Curve::Add(const Handle(Adaptor3d_Curve)& aCurve,
const Standard_Real U1,
const Standard_Real U2,
Standard_OStream& anOStream,
//! adds to the OStream the drawing of the curve aCurve.
//! The aspect is defined by LineAspect in aDrawer.
- Standard_EXPORT static void Add (const Adaptor3d_Curve& aCurve, const Handle(VrmlConverter_Drawer)& aDrawer, Standard_OStream& anOStream);
+ Standard_EXPORT static void Add (const Handle(Adaptor3d_Curve)& aCurve, const Handle(VrmlConverter_Drawer)& aDrawer, Standard_OStream& anOStream);
//! adds to the OStream the drawing of the curve aCurve.
//! The aspect is defined by LineAspect in aDrawer.
//! The drawing will be limited between the points of parameter
//! U1 and U2.
- Standard_EXPORT static void Add (const Adaptor3d_Curve& aCurve, const Standard_Real U1, const Standard_Real U2, const Handle(VrmlConverter_Drawer)& aDrawer, Standard_OStream& anOStream);
+ Standard_EXPORT static void Add (const Handle(Adaptor3d_Curve)& aCurve, const Standard_Real U1, const Standard_Real U2, const Handle(VrmlConverter_Drawer)& aDrawer, Standard_OStream& anOStream);
//! adds to the OStream the drawing of the curve aCurve.
//! The aspect is the current aspect.
//! The drawing will be limited between the points of parameter
//! U1 and U2. aNbPoints defines number of points on one interval.
- Standard_EXPORT static void Add (const Adaptor3d_Curve& aCurve, const Standard_Real U1, const Standard_Real U2, Standard_OStream& anOStream, const Standard_Integer aNbPoints);
+ Standard_EXPORT static void Add (const Handle(Adaptor3d_Curve)& aCurve, const Standard_Real U1, const Standard_Real U2, Standard_OStream& anOStream, const Standard_Integer aNbPoints);
// function: FindLimits
// purpose:
//==================================================================
-static void FindLimits(const Adaptor3d_Curve& aCurve,
+static void FindLimits(const Handle(Adaptor3d_Curve)& aCurve,
const Standard_Real aLimit,
Standard_Real& First,
Standard_Real& Last)
{
- First = aCurve.FirstParameter();
- Last = aCurve.LastParameter();
+ First = aCurve->FirstParameter();
+ Last = aCurve->LastParameter();
Standard_Boolean firstInf = Precision::IsNegativeInfinite(First);
Standard_Boolean lastInf = Precision::IsPositiveInfinite(Last);
delta *= 2;
First = - delta;
Last = delta;
- aCurve.D0(First,P1);
- aCurve.D0(Last,P2);
+ aCurve->D0(First,P1);
+ aCurve->D0(Last,P2);
} while (P1.Distance(P2) < aLimit);
}
else if (firstInf) {
- aCurve.D0(Last,P2);
+ aCurve->D0(Last,P2);
do {
delta *= 2;
First = Last - delta;
- aCurve.D0(First,P1);
+ aCurve->D0(First,P1);
} while (P1.Distance(P2) < aLimit);
}
else if (lastInf) {
- aCurve.D0(First,P1);
+ aCurve->D0(First,P1);
do {
delta *= 2;
Last = First + delta;
- aCurve.D0(Last,P2);
+ aCurve->D0(Last,P2);
} while (P1.Distance(P2) < aLimit);
}
}
// function: DrawCurve
// purpose:
//==================================================================
-static void DrawCurve (Adaptor3d_Curve& aCurve,
+static void DrawCurve (const Handle(Adaptor3d_Curve)& aCurve,
const Standard_Real TheDeflection,
const Standard_Real U1,
const Standard_Real U2,
Handle(TColgp_HArray1OfVec) HAV1;
Handle(TColStd_HArray1OfInteger) HAI1;
- switch (aCurve.GetType()) {
+ switch (aCurve->GetType()) {
case GeomAbs_Line:
{
gp_Vec V;
HAI1 = new TColStd_HArray1OfInteger(1,3);
// array of coordinates of line
- gp_Pnt p = aCurve.Value(U1);
+ gp_Pnt p = aCurve->Value(U1);
V.SetX(p.X()); V.SetY(p.Y()); V.SetZ(p.Z());
HAV1->SetValue(1,V);
- p = aCurve.Value(U2);
+ p = aCurve->Value(U2);
V.SetX(p.X()); V.SetY(p.Y()); V.SetZ(p.Z());
HAV1->SetValue(2,V);
break;
case GeomAbs_Circle:
{
- Standard_Real Radius = aCurve.Circle().Radius();
+ Standard_Real Radius = aCurve->Circle().Radius();
if (!Precision::IsInfinite(Radius)) {
Standard_Real DU = Sqrt(8.0 * TheDeflection / Radius);
Standard_Integer N = Standard_Integer(Abs( U2 - U1) / DU);
for (Standard_Integer Index = 1; Index <= N+1; Index++) {
U = U1 + (Index - 1) * DU;
- p = aCurve.Value(U);
+ p = aCurve->Value(U);
V.SetX(p.X()); V.SetY(p.Y()); V.SetZ(p.Z());
HAV1->SetValue(Index,V);
// function: GetDeflection
// purpose:
//==================================================================
-static Standard_Real GetDeflection(const Adaptor3d_Curve& aCurve,
+static Standard_Real GetDeflection(const Handle(Adaptor3d_Curve)& aCurve,
const Standard_Real U1,
const Standard_Real U2,
const Handle(VrmlConverter_Drawer)& aDrawer) {
// purpose: 1
//==================================================================
void VrmlConverter_DeflectionCurve::Add(Standard_OStream& anOStream,
- Adaptor3d_Curve& aCurve,
+ const Handle(Adaptor3d_Curve)& aCurve,
const Handle(VrmlConverter_Drawer)& aDrawer)
{
// purpose: 2
//==================================================================
void VrmlConverter_DeflectionCurve::Add(Standard_OStream& anOStream,
- Adaptor3d_Curve& aCurve,
+ const Handle(Adaptor3d_Curve)& aCurve,
const Standard_Real U1,
const Standard_Real U2,
const Handle(VrmlConverter_Drawer)& aDrawer)
//==================================================================
void VrmlConverter_DeflectionCurve::Add(Standard_OStream& anOStream,
- Adaptor3d_Curve& aCurve,
+ const Handle(Adaptor3d_Curve)& aCurve,
const Standard_Real aDeflection,
const Standard_Real aLimit)
{
//==================================================================
void VrmlConverter_DeflectionCurve::Add(Standard_OStream& anOStream,
- Adaptor3d_Curve& aCurve,
+ const Handle(Adaptor3d_Curve)& aCurve,
const Standard_Real aDeflection,
const Handle(VrmlConverter_Drawer)& aDrawer)
{
//==================================================================
void VrmlConverter_DeflectionCurve::Add(Standard_OStream& anOStream,
- Adaptor3d_Curve& aCurve,
+ const Handle(Adaptor3d_Curve)& aCurve,
const Standard_Real U1,
const Standard_Real U2,
const Standard_Real aDeflection)
//==================================================================
void VrmlConverter_DeflectionCurve::Add(Standard_OStream& anOStream,
- const Adaptor3d_Curve& aCurve,
+ const Handle(Adaptor3d_Curve)& aCurve,
const Handle(TColStd_HArray1OfReal)& aParams,
const Standard_Integer aNbNodes,
const Handle(VrmlConverter_Drawer)& aDrawer)
for (i = 1; i<=aNbNodes; i++)
{
Standard_Real aParam = aParams->Value(aParams->Lower() + i - 1);
- aPoint = aCurve.Value(aParam);
+ aPoint = aCurve->Value(aParam);
aVec.SetX(aPoint.X());
aVec.SetY(aPoint.Y());
aVec.SetZ(aPoint.Z());
//! respect to the maximal chordial deviation defined
//! by the drawer aDrawer.
//! The aspect is defined by LineAspect in aDrawer.
- Standard_EXPORT static void Add (Standard_OStream& anOStream, Adaptor3d_Curve& aCurve, const Handle(VrmlConverter_Drawer)& aDrawer);
+ Standard_EXPORT static void Add (Standard_OStream& anOStream, const Handle(Adaptor3d_Curve)& aCurve, const Handle(VrmlConverter_Drawer)& aDrawer);
//! adds to the OStream the drawing of the curve aCurve with
//! respect to the maximal chordial deviation defined
//! The aspect is defined by LineAspect in aDrawer.
//! The drawing will be limited between the points of parameter
//! U1 and U2.
- Standard_EXPORT static void Add (Standard_OStream& anOStream, Adaptor3d_Curve& aCurve, const Standard_Real U1, const Standard_Real U2, const Handle(VrmlConverter_Drawer)& aDrawer);
+ Standard_EXPORT static void Add (Standard_OStream& anOStream, const Handle(Adaptor3d_Curve)& aCurve, const Standard_Real U1, const Standard_Real U2, const Handle(VrmlConverter_Drawer)& aDrawer);
//! adds to the OStream the drawing of the curve aCurve with
//! respect to the maximal chordial deviation aDeflection.
//! The aspect is the current aspect
- Standard_EXPORT static void Add (Standard_OStream& anOStream, Adaptor3d_Curve& aCurve, const Standard_Real aDeflection, const Standard_Real aLimit);
+ Standard_EXPORT static void Add (Standard_OStream& anOStream, const Handle(Adaptor3d_Curve)& aCurve, const Standard_Real aDeflection, const Standard_Real aLimit);
//! adds to the OStream the drawing of the curve aCurve with
//! respect to the maximal chordial deviation aDeflection.
//! The aspect is the current aspect
- Standard_EXPORT static void Add (Standard_OStream& anOStream, Adaptor3d_Curve& aCurve, const Standard_Real aDeflection, const Handle(VrmlConverter_Drawer)& aDrawer);
+ Standard_EXPORT static void Add (Standard_OStream& anOStream, const Handle(Adaptor3d_Curve)& aCurve, const Standard_Real aDeflection, const Handle(VrmlConverter_Drawer)& aDrawer);
//! adds to the OStream the drawing of the curve aCurve with
//! respect to the maximal chordial deviation aDeflection.
//! The aspect is the current aspect
//! The drawing will be limited between the points of parameter
//! U1 and U2.
- Standard_EXPORT static void Add (Standard_OStream& anOStream, Adaptor3d_Curve& aCurve, const Standard_Real U1, const Standard_Real U2, const Standard_Real aDeflection);
+ Standard_EXPORT static void Add (Standard_OStream& anOStream, const Handle(Adaptor3d_Curve)& aCurve, const Standard_Real U1, const Standard_Real U2, const Standard_Real aDeflection);
//! adds to the OStream the drawing of the curve aCurve with
//! the array of parameters to retrieve points on curve.
- Standard_EXPORT static void Add (Standard_OStream& anOStream, const Adaptor3d_Curve& aCurve, const Handle(TColStd_HArray1OfReal)& aParams, const Standard_Integer aNbNodes, const Handle(VrmlConverter_Drawer)& aDrawer);
+ Standard_EXPORT static void Add (Standard_OStream& anOStream, const Handle(Adaptor3d_Curve)& aCurve, const Handle(TColStd_HArray1OfReal)& aParams, const Standard_Integer aNbNodes, const Handle(VrmlConverter_Drawer)& aDrawer);
Standard_Integer NbEdge = Tool.NbEdges();
Standard_Integer i;
Standard_Real U1,U2;
- BRepAdaptor_Curve TheCurve;
+ Handle(BRepAdaptor_Curve) TheCurve;
Standard_Real theRequestedDeflection;
if(aDrawer->TypeOfDeflection() == Aspect_TOD_RELATIVE) // TOD_RELATIVE, TOD_ABSOLUTE
gp_Pnt dummypnt;
for (ToolRst.Init(); ToolRst.More(); ToolRst.Next()) {
TopAbs_Orientation Orient = ToolRst.Orientation();
- const Adaptor2d_Curve2d* TheRCurve = &ToolRst.Value();
+ const Handle(Adaptor2d_Curve2d) TheRCurve = ToolRst.Value();
if (TheRCurve->GetType() != GeomAbs_Line) {
- GCPnts_QuasiUniformDeflection UDP(*TheRCurve, Deflection);
+ GCPnts_QuasiUniformDeflection UDP(TheRCurve, Deflection);
if (UDP.IsDone()) {
Standard_Integer NumberOfPoints = UDP.NbPoints();
if ( NumberOfPoints >= 2 ) {
// draw the isos
- Adaptor3d_IsoCurve anIso;
- anIso.Load(aFace);
+ Handle(Adaptor3d_IsoCurve) anIso = new Adaptor3d_IsoCurve(aFace);
Standard_Integer NumberOfLines = isobuild.NbLines();
Handle(VrmlConverter_LineAspect) latmp = new VrmlConverter_LineAspect;
b1 = b1 == RealFirst() ? - aLimit : b1;
b2 = b2 == RealLast() ? aLimit : b2;
- anIso.Load(GeomAbs_IsoU,Coord,b1,b2);
+ anIso->Load(GeomAbs_IsoU,Coord,b1,b2);
VrmlConverter_DeflectionCurve::Add(anOStream, anIso, Deflection, aDrawer);
}
b1 = b1 == RealFirst() ? - aLimit : b1;
b2 = b2 == RealLast() ? aLimit : b2;
- anIso.Load(GeomAbs_IsoV,Coord,b1,b2);
+ anIso->Load(GeomAbs_IsoV,Coord,b1,b2);
VrmlConverter_DeflectionCurve::Add(anOStream, anIso, Deflection, aDrawer);
}
for(Tool.InitCurve();Tool.MoreCurve();Tool.NextCurve()){
if (Tool.Neighbours() == 0) {
if (Tool.HasCurve()) {
- BRepAdaptor_Curve C(Tool.GetCurve());
+ Handle(BRepAdaptor_Curve) C = new BRepAdaptor_Curve(Tool.GetCurve());
BRep_Tool::PolygonOnTriangulation(Tool.GetCurve(), aPT, aT, aL);
if (!aPT.IsNull() && !aT.IsNull() && aPT->HasParameters())
VrmlConverter_DeflectionCurve::Add(anOStream, C, aPT->Parameters(), aPT->NbNodes(), aDrawer);
for(Tool.InitCurve();Tool.MoreCurve();Tool.NextCurve()){
if (Tool.Neighbours() == 1) {
if (Tool.HasCurve()) {
- BRepAdaptor_Curve C(Tool.GetCurve());
+ Handle(BRepAdaptor_Curve) C = new BRepAdaptor_Curve(Tool.GetCurve());
BRep_Tool::PolygonOnTriangulation(Tool.GetCurve(), aPT, aT, aL);
if (!aPT.IsNull() && !aT.IsNull() && aPT->HasParameters())
VrmlConverter_DeflectionCurve::Add(anOStream, C, aPT->Parameters(), aPT->NbNodes(), aDrawer);
for(Tool.InitCurve();Tool.MoreCurve();Tool.NextCurve()){
if (Tool.Neighbours() >= 2) {
if (Tool.HasCurve()) {
- BRepAdaptor_Curve C(Tool.GetCurve());
+ Handle(BRepAdaptor_Curve) C = new BRepAdaptor_Curve(Tool.GetCurve());
BRep_Tool::PolygonOnTriangulation(Tool.GetCurve(), aPT, aT, aL);
if (!aPT.IsNull() && !aT.IsNull() && aPT->HasParameters())
VrmlConverter_DeflectionCurve::Add(anOStream, C, aPT->Parameters(), aPT->NbNodes(), aDrawer);
Bnd_Box2d B;
for (ToolRst.Init(); ToolRst.More(); ToolRst.Next()) {
- const Adaptor2d_Curve2d& TheRCurve = ToolRst.Value();
+ const Handle(Adaptor2d_Curve2d)& TheRCurve = ToolRst.Value();
BndLib_Add2dCurve::Add(TheRCurve, Precision::PConfusion(), B);
}
for (ToolRst.Init(); ToolRst.More(); ToolRst.Next()) {
TopAbs_Orientation Orient = ToolRst.Orientation();
- const Adaptor2d_Curve2d* TheRCurve = &ToolRst.Value();
+ const Handle(Adaptor2d_Curve2d) TheRCurve = ToolRst.Value();
U1 = TheRCurve->FirstParameter();
U2 = TheRCurve->LastParameter();
if (TheRCurve->GetType() != GeomAbs_Line) {
// draw the isos
- Adaptor3d_IsoCurve anIso;
- anIso.Load(aFace);
+ Handle(Adaptor3d_IsoCurve) anIso = new Adaptor3d_IsoCurve(aFace);
Standard_Integer NumberOfLines = isobuild.NbLines();
Handle(VrmlConverter_LineAspect) latmp = new VrmlConverter_LineAspect;
b1 = b1 == RealFirst() ? - aLimit : b1;
b2 = b2 == RealLast() ? aLimit : b2;
- anIso.Load(GeomAbs_IsoU,Coord,b1,b2);
+ anIso->Load(GeomAbs_IsoU,Coord,b1,b2);
VrmlConverter_Curve::Add(anIso, aDrawer, anOStream);
}
b1 = b1 == RealFirst() ? - aLimit : b1;
b2 = b2 == RealLast() ? aLimit : b2;
- anIso.Load(GeomAbs_IsoV,Coord,b1,b2);
+ anIso->Load(GeomAbs_IsoV,Coord,b1,b2);
VrmlConverter_Curve::Add(anIso, aDrawer, anOStream);
}
for(Tool.InitCurve();Tool.MoreCurve();Tool.NextCurve()){
if (Tool.Neighbours() == 0) {
if (Tool.HasCurve()) {
- BRepAdaptor_Curve C(Tool.GetCurve());
+ Handle(BRepAdaptor_Curve) C = new BRepAdaptor_Curve(Tool.GetCurve());
VrmlConverter_Curve::Add(C, aDrawer, anOStream);
}
}
for(Tool.InitCurve();Tool.MoreCurve();Tool.NextCurve()){
if (Tool.Neighbours() == 1) {
if (Tool.HasCurve()) {
- BRepAdaptor_Curve C(Tool.GetCurve());
+ Handle(BRepAdaptor_Curve) C = new BRepAdaptor_Curve(Tool.GetCurve());
VrmlConverter_Curve::Add(C, aDrawer, anOStream);
}
}
for(Tool.InitCurve();Tool.MoreCurve();Tool.NextCurve()){
if (Tool.Neighbours() >= 2) {
if (Tool.HasCurve()) {
- BRepAdaptor_Curve C(Tool.GetCurve());
+ Handle(BRepAdaptor_Curve) C = new BRepAdaptor_Curve(Tool.GetCurve());
VrmlConverter_Curve::Add(C, aDrawer, anOStream);
}
}
// If polygon was not found -> generate it
if (aPol.IsNull()) {
- BRepAdaptor_Curve aCurve(aEdge);
- const Standard_Real aFirst = aCurve.FirstParameter();
- const Standard_Real aLast = aCurve.LastParameter();
+ Handle(BRepAdaptor_Curve) aCurve = new BRepAdaptor_Curve(aEdge);
+ const Standard_Real aFirst = aCurve->FirstParameter();
+ const Standard_Real aLast = aCurve->LastParameter();
GCPnts_TangentialDeflection TD(aCurve, aFirst, aLast,
myDeflAngle, myDeflection, 2);
projects / occt.git / commitdiff