#include <Adaptor2d_OffsetCurve.hxx>
#include <Geom2d_BezierCurve.hxx>
#include <Geom2d_BSplineCurve.hxx>
+#include <Geom2dEvaluator.hxx>
#include <GeomAbs_SurfaceType.hxx>
#include <gp.hxx>
#include <gp_Ax22d.hxx>
#include <Standard_DomainError.hxx>
#include <Standard_NoSuchObject.hxx>
#include <Standard_NotImplemented.hxx>
-#include <Standard_OutOfRange.hxx>
#include <Standard_TypeMismatch.hxx>
//=======================================================================
myOffset = Offset;
myFirst = myCurve->FirstParameter();
myLast = myCurve->LastParameter();
-
}
//=======================================================================
gp_Pnt2d Adaptor2d_OffsetCurve::Value(const Standard_Real U) const
{
if ( myOffset != 0.) {
- gp_Pnt2d P;
- gp_Vec2d V;
- Standard_Real Norme;
- myCurve->D1(U, P, V);
- Norme = V.Magnitude();
- V.SetCoord(-V.Y(),V.X());
- if (Norme >= gp::Resolution()) {
- return gp_Pnt2d(P.XY()+myOffset*V.XY()/Norme);
- }
- else {
- throw gp_VectorWithNullMagnitude("Adaptor2d_OffsetCurve::Value");
- }
+ gp_Pnt2d aP;
+ gp_Vec2d aV;
+ myCurve->D1(U, aP, aV);
+ Geom2dEvaluator::CalculateD0(aP, aV, myOffset);
+ return aP;
}
else {
return myCurve->Value(U);
//=======================================================================
void Adaptor2d_OffsetCurve::D1
- (const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& V) const
-{
- gp_Vec2d V1,V2,V3;
- gp_Pnt2d PP;
- Standard_Real Norme;
- if ( myOffset != 0. ) {
- myCurve->D2(U,PP,V1,V2);
- Norme = V1.Magnitude();
- V3.SetCoord( -V1.Y(),V1.X());
- V2.SetCoord( -V2.Y(),V2.X());
- if ( Norme >= gp::Resolution()) {
- P = gp_Pnt2d( PP.XY()+myOffset*V3.XY()/Norme);
- V = gp_Vec2d( V1.XY()+
- (myOffset/Norme)*(V2.XY()-V3.XY()*
- (V2.XY()*V3.XY())/(Norme*Norme)));
- }
- else {
- throw gp_VectorWithNullMagnitude("Adaptor2d_OffsetCurve::D1");
- }
+(const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& V) const
+{
+ if (myOffset != 0.) {
+ gp_Vec2d aV2;
+ myCurve->D2(U, P, V, aV2);
+ Geom2dEvaluator::CalculateD1( P, V, aV2, myOffset);
}
else {
- myCurve->D1(U,P,V);
+ myCurve->D1(U, P, V);
}
}
//=======================================================================
void Adaptor2d_OffsetCurve::D2
- (const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& V1, gp_Vec2d& V2) const
+(const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& V1, gp_Vec2d& V2) const
{
- if ( myOffset != 0.) {
- gp_Vec2d T1,T2,T3;
- gp_Pnt2d PP;
- Standard_Real Norme;
- myCurve->D3(U,PP,T1,T2,T3);
-
- Norme = T1.Magnitude();
- if ( Norme >= gp::Resolution()) {
- gp_Vec2d N1,N2,N3; // Ni = Z ^ Ti
- N1.SetCoord( -T1.Y(), T1.X());
- N2.SetCoord( -T2.Y(), T2.X());
- N3.SetCoord( -T3.Y(), T3.X());
- Standard_Real d12,d13,d22,Nor3,Nor11;
- d12 = T1*T2;
- d22 = T2*T2;
- d13 = T1*T3;
- Nor3 = Norme*Norme*Norme;
- Nor11 = Nor3*Nor3*Nor3*Norme*Norme;
- V2 = gp_Vec2d( -1 * ( (d22+d13)/Nor3 + 3*d12*d12/Nor11) * N1.XY());
- V2 = gp_Vec2d( V2.XY() - (2*d12/Nor3)*N2.XY() + N3.XY()/Norme);
- V2 = gp_Vec2d( myOffset*V2.XY() + T2.XY());
-
- D1( U,P,V1);
- }
- else {
- throw gp_VectorWithNullMagnitude("Adaptor2d_OffsetCurve::D2");
- }
+ if (myOffset != 0.) {
+ gp_Vec2d aV3;
+ myCurve->D3(U, P, V1, V2, aV3);
+ Geom2dEvaluator::CalculateD2(P, V1, V2, aV3, Standard_False, myOffset);
}
else {
- myCurve->D2(U,P,V1,V2);
+ myCurve->D2(U, P, V1, V2);
}
}
//purpose :
//=======================================================================
-//void Adaptor2d_OffsetCurve::D3
-// (const Standard_Real T,
-// gp_Pnt2d& P, gp_Vec2d& V1, gp_Vec2d& V2, gp_Vec2d& V3) const
void Adaptor2d_OffsetCurve::D3
- (const Standard_Real ,
- gp_Pnt2d& , gp_Vec2d& , gp_Vec2d& , gp_Vec2d& ) const
+ (const Standard_Real U,
+ gp_Pnt2d& P, gp_Vec2d& V1, gp_Vec2d& V2, gp_Vec2d& V3) const
{
- throw Standard_NotImplemented("Adaptor2d_OffsetCurve::D3");
+ if (myOffset != 0.) {
+ gp_Vec2d aV4 = myCurve->DN(U, 4);
+ myCurve->D3(U, P, V1, V2, V3);
+ Geom2dEvaluator::CalculateD3(P, V1, V2, V3, aV4, Standard_False, myOffset);
+ }
+ else {
+ myCurve->D3(U, P, V1, V2, V3);
+ }
}
//=======================================================================
//=======================================================================
gp_Vec2d Adaptor2d_OffsetCurve::DN
-// (const Standard_Real T, const Standard_Integer N) const
(const Standard_Real , const Standard_Integer ) const
{
throw Standard_NotImplemented("Adaptor2d_OffsetCurve::DN");
Standard_Integer nbs = 20;
- if (theCurve->GetType() == GeomAbs_Line)
- nbs = 2;
- else if (theCurve->GetType() == GeomAbs_BezierCurve)
+ if (theCurve->GetType() == GeomAbs_BezierCurve)
{
- nbs = 3 + theCurve->NbPoles();
+ nbs = Max(nbs, 3 + theCurve->NbPoles());
}
else if (theCurve->GetType() == GeomAbs_BSplineCurve) {
- nbs = theCurve->NbKnots();
- nbs *= theCurve->Degree();
+ nbs = Max(nbs, theCurve->NbKnots() * theCurve->Degree());
}
- if (nbs > 200)
- nbs = 200;
+ if (nbs > 300)
+ nbs = 300;
return nbs;
}