#include <Geom_BSplineCurve.hxx>
#include <Geom_Geometry.hxx>
#include <Geom_Surface.hxx>
+#include <Geom_RectangularTrimmedSurface.hxx>
#include <Geom_Plane.hxx>
#include <Geom_ElementarySurface.hxx>
#include <Geom_CylindricalSurface.hxx>
#include <Geom_SurfaceOfLinearExtrusion.hxx>
#include <Geom_RectangularTrimmedSurface.hxx>
#include <Geom_Curve.hxx>
+#include <Geom_TrimmedCurve.hxx>
#include <Geom_Circle.hxx>
#include <Geom_Ellipse.hxx>
typedef gp_Pnt Pnt;
typedef gp_Trsf Trsf;
typedef gp_XYZ XYZ;
+
+static const Standard_Real MyAngularToleranceForG1 = Precision::Angular();
//=======================================================================
//function : derivatives
//purpose :
//=======================================================================
static void derivatives(Standard_Integer MaxOrder,
- Standard_Integer MinOrder,
- const Standard_Real U,
- const Standard_Real V,
- const Handle(Geom_Surface)& basisSurf,
- const Standard_Integer Nu,
- const Standard_Integer Nv,
- const Standard_Boolean AlongU,
- const Standard_Boolean AlongV,
- const Handle(Geom_BSplineSurface)& L,
- TColgp_Array2OfVec& DerNUV,
- TColgp_Array2OfVec& DerSurf)
+ Standard_Integer MinOrder,
+ const Standard_Real U,
+ const Standard_Real V,
+ const Handle(Geom_Surface)& basisSurf,
+ const Standard_Integer Nu,
+ const Standard_Integer Nv,
+ const Standard_Boolean AlongU,
+ const Standard_Boolean AlongV,
+ const Handle(Geom_BSplineSurface)& L,
+ TColgp_Array2OfVec& DerNUV,
+ TColgp_Array2OfVec& DerSurf)
{
- Standard_Integer i,j;
- gp_Pnt P;
- gp_Vec DL1U, DL1V, DL2U , DL2V , DL2UV ,DL3U, DL3UUV, DL3UVV, DL3V;
-
- if (AlongU || AlongV)
- {
- MaxOrder=0;
- TColgp_Array2OfVec DerSurfL(0,MaxOrder+Nu+1,0,MaxOrder+Nv+1);
- switch (MinOrder)
- {
- case 1 :
- L->D1(U, V, P, DL1U, DL1V);
- DerSurfL.SetValue(1, 0, DL1U);
- DerSurfL.SetValue(0, 1, DL1V);
- break;
- case 2 :
- L->D2(U, V, P, DL1U, DL1V, DL2U , DL2V , DL2UV);
- DerSurfL.SetValue(1, 0, DL1U);
- DerSurfL.SetValue(0, 1, DL1V);
- DerSurfL.SetValue(1, 1, DL2UV);
- DerSurfL.SetValue(2, 0, DL2U);
- DerSurfL.SetValue(0, 2, DL2V);
- break;
- case 3 :
- L->D3(U, V, P, DL1U, DL1V, DL2U , DL2V , DL2UV ,DL3U, DL3V ,DL3UUV, DL3UVV);
- DerSurfL.SetValue(1, 0, DL1U);
- DerSurfL.SetValue(0, 1, DL1V);
- DerSurfL.SetValue(1, 1, DL2UV);
- DerSurfL.SetValue(2, 0, DL2U);
- DerSurfL.SetValue(0, 2, DL2V);
- DerSurfL.SetValue(3, 0, DL3U);
- DerSurfL.SetValue(2, 1, DL3UUV);
- DerSurfL.SetValue(1, 2, DL3UVV);
- DerSurfL.SetValue(0, 3, DL3V);
- break;
- default:
- break;
- }
-
- if(Nu <= Nv)
- {
- for(i=0;i<=MaxOrder+1+Nu;i++)
- for(j=i;j<=MaxOrder+Nv+1;j++)
- if(i+j> MinOrder)
- {
- DerSurfL.SetValue(i,j,L->DN(U,V,i,j));
- DerSurf.SetValue(i,j,basisSurf->DN(U,V,i,j));
- if (i!=j && j <= Nu+1)
- {
- DerSurf.SetValue(j,i,basisSurf->DN(U,V,j,i));
- DerSurfL.SetValue(j,i,L->DN(U,V,j,i));
- }
- }
- }
- else
- {
- for(j=0;j<=MaxOrder+1+Nv;j++)
- for(i=j;i<=MaxOrder+Nu+1;i++)
- if(i+j> MinOrder)
- {
- DerSurfL.SetValue(i,j,L->DN(U,V,i,j));
- DerSurf.SetValue(i,j,basisSurf->DN(U,V,i,j));
- if (i!=j && i <= Nv+1)
- {
- DerSurf.SetValue(j,i,basisSurf->DN(U,V,j,i));
- DerSurfL.SetValue(j,i,L->DN(U,V,j,i));
- }
- }
- }
- for(i=0;i<=MaxOrder+Nu;i++)
- for(j=0;j<=MaxOrder+Nv;j++)
- {
- if (AlongU)
- DerNUV.SetValue(i,j,CSLib::DNNUV(i,j,DerSurfL,DerSurf));
- if (AlongV)
- DerNUV.SetValue(i,j,CSLib::DNNUV(i,j,DerSurf,DerSurfL));
- }
+ Standard_Integer i,j;
+ gp_Pnt P;
+ gp_Vec DL1U, DL1V, DL2U , DL2V , DL2UV ,DL3U, DL3UUV, DL3UVV, DL3V;
- }
- else
- {
+ if (AlongU || AlongV)
+ {
+ MaxOrder=0;
+ TColgp_Array2OfVec DerSurfL(0,MaxOrder+Nu+1,0,MaxOrder+Nv+1);
+ switch (MinOrder)
+ {
+ case 1 :
+ L->D1(U, V, P, DL1U, DL1V);
+ DerSurfL.SetValue(1, 0, DL1U);
+ DerSurfL.SetValue(0, 1, DL1V);
+ break;
+ case 2 :
+ L->D2(U, V, P, DL1U, DL1V, DL2U , DL2V , DL2UV);
+ DerSurfL.SetValue(1, 0, DL1U);
+ DerSurfL.SetValue(0, 1, DL1V);
+ DerSurfL.SetValue(1, 1, DL2UV);
+ DerSurfL.SetValue(2, 0, DL2U);
+ DerSurfL.SetValue(0, 2, DL2V);
+ break;
+ case 3 :
+ L->D3(U, V, P, DL1U, DL1V, DL2U , DL2V , DL2UV ,DL3U, DL3V ,DL3UUV, DL3UVV);
+ DerSurfL.SetValue(1, 0, DL1U);
+ DerSurfL.SetValue(0, 1, DL1V);
+ DerSurfL.SetValue(1, 1, DL2UV);
+ DerSurfL.SetValue(2, 0, DL2U);
+ DerSurfL.SetValue(0, 2, DL2V);
+ DerSurfL.SetValue(3, 0, DL3U);
+ DerSurfL.SetValue(2, 1, DL3UUV);
+ DerSurfL.SetValue(1, 2, DL3UVV);
+ DerSurfL.SetValue(0, 3, DL3V);
+ break;
+ default:
+ break;
+ }
- for(i=0;i<=MaxOrder+Nu+1;i++)
- for(j=i;j<=MaxOrder+Nv+1;j++)
- if(i+j>MinOrder)
- {
-
- DerSurf.SetValue(i,j,basisSurf->DN(U,V,i,j));
- if (i!=j) DerSurf.SetValue(j,i,basisSurf->DN(U,V,j,i));
- }
- for(i=0;i<=MaxOrder+Nu;i++)
- for(j=0;j<=MaxOrder+Nv;j++)
+ if(Nu <= Nv)
+ {
+ for(i=0;i<=MaxOrder+1+Nu;i++)
+ for(j=i;j<=MaxOrder+Nv+1;j++)
+ if(i+j> MinOrder)
+ {
+ DerSurfL.SetValue(i,j,L->DN(U,V,i,j));
+ DerSurf.SetValue(i,j,basisSurf->DN(U,V,i,j));
+ if (i!=j && j <= Nu+1)
+ {
+ DerSurf.SetValue(j,i,basisSurf->DN(U,V,j,i));
+ DerSurfL.SetValue(j,i,L->DN(U,V,j,i));
+ }
+ }
+ }
+ else
+ {
+ for(j=0;j<=MaxOrder+1+Nv;j++)
+ for(i=j;i<=MaxOrder+Nu+1;i++)
+ if(i+j> MinOrder)
+ {
+ DerSurfL.SetValue(i,j,L->DN(U,V,i,j));
+ DerSurf.SetValue(i,j,basisSurf->DN(U,V,i,j));
+ if (i!=j && i <= Nv+1)
{
- DerNUV.SetValue(i,j,CSLib::DNNUV(i,j,DerSurf));
- }
+ DerSurf.SetValue(j,i,basisSurf->DN(U,V,j,i));
+ DerSurfL.SetValue(j,i,L->DN(U,V,j,i));
+ }
+ }
+ }
+ for(i=0;i<=MaxOrder+Nu;i++)
+ for(j=0;j<=MaxOrder+Nv;j++)
+ {
+ if (AlongU)
+ DerNUV.SetValue(i,j,CSLib::DNNUV(i,j,DerSurfL,DerSurf));
+ if (AlongV)
+ DerNUV.SetValue(i,j,CSLib::DNNUV(i,j,DerSurf,DerSurfL));
}
-
+
+ }
+ else
+ {
+
+ for(i=0;i<=MaxOrder+Nu+1;i++)
+ for(j=i;j<=MaxOrder+Nv+1;j++)
+ if(i+j>MinOrder)
+ {
+
+ DerSurf.SetValue(i,j,basisSurf->DN(U,V,i,j));
+ if (i!=j) DerSurf.SetValue(j,i,basisSurf->DN(U,V,j,i));
+ }
+ for(i=0;i<=MaxOrder+Nu;i++)
+ for(j=0;j<=MaxOrder+Nv;j++)
+ {
+ DerNUV.SetValue(i,j,CSLib::DNNUV(i,j,DerSurf));
+ }
+ }
+
}
-
+
//=======================================================================
//function : Copy
Handle(Geom_Geometry) Geom_OffsetSurface::Copy () const {
- Handle(OffsetSurface) S;
- S = new OffsetSurface (basisSurf, offsetValue);
- return S;
+ Handle(OffsetSurface) S;
+ S = new OffsetSurface (basisSurf, offsetValue);
+ return S;
}
//=======================================================================
//function : Geom_OffsetSurface
-//purpose :
+//purpose : Basis surface cannot be an Offset surface or trimmed from
+// offset surface.
//=======================================================================
-Geom_OffsetSurface::Geom_OffsetSurface ( const Handle(Surface)& S,
- const Standard_Real Offset )
- : offsetValue (Offset)
+Geom_OffsetSurface::Geom_OffsetSurface (const Handle(Geom_Surface)& theSurf,
+ const Standard_Real theOffset,
+ const Standard_Boolean isTheNotCheckC0)
+ : offsetValue (theOffset)
{
- Handle(Geom_OffsetSurface) Off_S;
- Off_S = Handle(Geom_OffsetSurface)::DownCast(S);
- if (!Off_S.IsNull()) {
- offsetValue += Off_S->Offset();
- SetBasisSurface (Off_S->BasisSurface());
- }
- else {
- SetBasisSurface(S);
- }
-
-//
-// Tolerance en dur pour l'instant ,mais on devrait la proposer dans le constructeur
-// et la mettre en champ, on pourrait utiliser par exemple pour l'extraction d'iso
-// et aussi pour les singularite. Pour les surfaces osculatrices, on l'utilise pour
-// detecter si une iso est degeneree.
- Standard_Real Tol = Precision::Confusion(); //0.0001;
- myOscSurf.Init(basisSurf,Tol);
-}
+ SetBasisSurface(theSurf, isTheNotCheckC0);
+}
//=======================================================================
//function : SetBasisSurface
//purpose :
//=======================================================================
-void Geom_OffsetSurface::SetBasisSurface (const Handle(Surface)& S)
+void Geom_OffsetSurface::SetBasisSurface (const Handle(Surface)& S,
+ const Standard_Boolean isNotCheckC0)
{
- Handle(Surface) aBasisSurf = Handle(Surface)::DownCast(S->Copy());
+ Standard_Real aUf, aUl, aVf, aVl;
+ S->Bounds(aUf, aUl, aVf, aVl);
+
+ Handle(Surface) aCheckingSurf = Handle(Surface)::DownCast(S->Copy());
+ Standard_Boolean isTrimmed = Standard_False;
+
+ while(aCheckingSurf->IsKind(STANDARD_TYPE(Geom_RectangularTrimmedSurface)) ||
+ aCheckingSurf->IsKind(STANDARD_TYPE(Geom_OffsetSurface)))
+ {
+ if (aCheckingSurf->IsKind(STANDARD_TYPE(Geom_RectangularTrimmedSurface)))
+ {
+ Handle(Geom_RectangularTrimmedSurface) aTrimS =
+ Handle(Geom_RectangularTrimmedSurface)::DownCast(aCheckingSurf);
+ aCheckingSurf = aTrimS->BasisSurface();
+ isTrimmed = Standard_True;
+ }
+
+ if (aCheckingSurf->IsKind(STANDARD_TYPE(Geom_OffsetSurface)))
+ {
+ Handle(Geom_OffsetSurface) aOS =
+ Handle(Geom_OffsetSurface)::DownCast(aCheckingSurf);
+ aCheckingSurf = aOS->BasisSurface();
+ offsetValue += aOS->Offset();
+ }
+ }
+
+
+ myBasisSurfContinuity = aCheckingSurf->Continuity();
+
+ Standard_Boolean isC0 = !isNotCheckC0 &&
+ (myBasisSurfContinuity == GeomAbs_C0);
// Basis surface must be at least C1
- if (aBasisSurf->Continuity() == GeomAbs_C0)
+ if (isC0)
{
- // For B-splines it is sometimes possible to increase continuity by removing
- // unnecessarily duplicated knots
- if (aBasisSurf->IsKind(STANDARD_TYPE(Geom_BSplineSurface)))
+ Handle(Geom_Curve) aCurve;
+
+ if (aCheckingSurf->IsKind(STANDARD_TYPE(Geom_SurfaceOfRevolution)))
{
- Handle(Geom_BSplineSurface) aBSurf = Handle(Geom_BSplineSurface)::DownCast(aBasisSurf);
- Standard_Integer uDegree = aBSurf->UDegree(), vDegree = aBSurf->VDegree();
- Standard_Real Toler = Precision::Confusion();
- Standard_Integer start = aBSurf->IsUPeriodic() ? 1 : aBSurf->FirstUKnotIndex(),
- finish = aBSurf->IsUPeriodic() ? aBSurf->NbUKnots() : aBSurf->LastUKnotIndex();
- for (Standard_Integer i = start; i <= finish; i++)
- {
- Standard_Integer mult = aBSurf->UMultiplicity(i);
- if ( mult == uDegree )
- aBSurf->RemoveUKnot(i,uDegree - 1, Toler);
- }
- start = aBSurf->IsVPeriodic() ? 1 : aBSurf->FirstVKnotIndex();
- finish = aBSurf->IsVPeriodic() ? aBSurf->NbVKnots() : aBSurf->LastVKnotIndex();
- for (Standard_Integer i = start; i <= finish; i++)
+ Handle(Geom_SurfaceOfRevolution) aRevSurf = Handle(Geom_SurfaceOfRevolution)::DownCast(aCheckingSurf);
+ aCurve = aRevSurf->BasisCurve();
+ }
+ else if (aCheckingSurf->IsKind(STANDARD_TYPE(Geom_SurfaceOfLinearExtrusion)))
+ {
+ Handle(Geom_SurfaceOfLinearExtrusion) aLESurf = Handle(Geom_SurfaceOfLinearExtrusion)::DownCast(aCheckingSurf);
+ aCurve = aLESurf->BasisCurve();
+ }
+
+ if(!aCurve.IsNull())
+ {
+ while(aCurve->IsKind(STANDARD_TYPE(Geom_TrimmedCurve)) ||
+ aCurve->IsKind(STANDARD_TYPE(Geom_OffsetCurve)))
{
- Standard_Integer mult = aBSurf->VMultiplicity(i);
- if ( mult == vDegree )
- aBSurf->RemoveVKnot(i,vDegree - 1, Toler);
+ if (aCurve->IsKind(STANDARD_TYPE(Geom_TrimmedCurve)))
+ {
+ Handle(Geom_TrimmedCurve) aTrimC =
+ Handle(Geom_TrimmedCurve)::DownCast(aCurve);
+ aCurve = aTrimC->BasisCurve();
+ }
+
+ if (aCurve->IsKind(STANDARD_TYPE(Geom_OffsetCurve)))
+ {
+ Handle(Geom_OffsetCurve) aOC =
+ Handle(Geom_OffsetCurve)::DownCast(aCurve);
+ aCurve = aOC->BasisCurve();
+ }
}
}
+ Standard_Real aUIsoPar = (aUf + aUl)/2.0, aVIsoPar = (aVf + aVl)/2.0;
+ Standard_Boolean isUG1 = Standard_False, isVG1 = Standard_False;
+
+ const Handle(Geom_Curve) aCurv1 = aCurve.IsNull() ? aCheckingSurf->UIso(aUIsoPar) : aCurve;
+ const Handle(Geom_Curve) aCurv2 = aCheckingSurf->VIso(aVIsoPar);
+ isUG1 = !aCurv1->IsKind(STANDARD_TYPE(Geom_BSplineCurve));
+ isVG1 = !aCurv2->IsKind(STANDARD_TYPE(Geom_BSplineCurve));
+
+ if(!isUG1)
+ {
+ Handle(Geom_BSplineCurve) aBC = Handle(Geom_BSplineCurve)::DownCast(aCurv1);
+ isUG1 = aBC->IsG1(aVf, aVl, MyAngularToleranceForG1);
+ }
+ //
+ if(!isVG1)
+ {
+ Handle(Geom_BSplineCurve) aBC = Handle(Geom_BSplineCurve)::DownCast(aCurv2);
+ isVG1 = aBC->IsG1(aUf, aUl, MyAngularToleranceForG1);
+ }
+ //
+ if(isUG1 && isVG1)
+ {
+ myBasisSurfContinuity = GeomAbs_G1;
+ isC0 = Standard_False;
+ }
+
// Raise exception if still C0
- if (aBasisSurf->Continuity() == GeomAbs_C0)
+ if (isC0)
Standard_ConstructionError::Raise("Offset with no C1 Surface");
}
- basisSurf = aBasisSurf;
+ if(isTrimmed)
+ {
+ basisSurf =
+ new Geom_RectangularTrimmedSurface(aCheckingSurf, aUf, aUl, aVf, aVl);
+ }
+ else
+ {
+ basisSurf = aCheckingSurf;
+ }
+
equivSurf = Surface();
+ //
+ // Tolerance en dur pour l'instant ,mais on devrait la proposer dans le constructeur
+ // et la mettre en champ, on pourrait utiliser par exemple pour l'extraction d'iso
+ // et aussi pour les singularite. Pour les surfaces osculatrices, on l'utilise pour
+ // detecter si une iso est degeneree.
+ Standard_Real Tol = Precision::Confusion(); //0.0001;
+ myOscSurf.Init(basisSurf,Tol);
+
}
//=======================================================================
void Geom_OffsetSurface::Bounds (Standard_Real& U1,
- Standard_Real& U2,
- Standard_Real& V1,
- Standard_Real& V2) const {
-
- basisSurf->Bounds (U1, U2 ,V1, V2);
+ Standard_Real& U2,
+ Standard_Real& V1,
+ Standard_Real& V2) const {
+
+ basisSurf->Bounds (U1, U2 ,V1, V2);
}
GeomAbs_Shape Geom_OffsetSurface::Continuity () const {
GeomAbs_Shape OffsetShape=GeomAbs_C0;
- switch (basisSurf->Continuity()) {
- case GeomAbs_C0 : OffsetShape = GeomAbs_C0; break;
- case GeomAbs_G1 : OffsetShape = GeomAbs_C0; break;
- case GeomAbs_C1 : OffsetShape = GeomAbs_C0; break;
- case GeomAbs_G2 : OffsetShape = GeomAbs_C0; break;
- case GeomAbs_C2 : OffsetShape = GeomAbs_C1; break;
- case GeomAbs_C3 : OffsetShape = GeomAbs_C2; break;
- case GeomAbs_CN : OffsetShape = GeomAbs_CN; break;
+ switch (myBasisSurfContinuity) {
+ case GeomAbs_C0 : OffsetShape = GeomAbs_C0; break;
+ case GeomAbs_G1 : OffsetShape = GeomAbs_C0; break;
+ case GeomAbs_C1 : OffsetShape = GeomAbs_C0; break;
+ case GeomAbs_G2 : OffsetShape = GeomAbs_C0; break;
+ case GeomAbs_C2 : OffsetShape = GeomAbs_C1; break;
+ case GeomAbs_C3 : OffsetShape = GeomAbs_C2; break;
+ case GeomAbs_CN : OffsetShape = GeomAbs_CN; break;
}
return OffsetShape;
}
Vec D1U, D1V;
#ifdef CHECK
- if (basisSurf->Continuity() == GeomAbs_C0) Geom_UndefinedValue::Raise();
+ if (myBasisSurfContinuity == GeomAbs_C0) Geom_UndefinedValue::Raise();
#endif
if (equivSurf.IsNull()){
basisSurf->D1(U, V, P, D1U, D1V);
//=======================================================================
void Geom_OffsetSurface::D1 (const Standard_Real U, const Standard_Real V,
- Pnt& P,
- Vec& D1U, Vec& D1V) const
+ Pnt& P,
+ Vec& D1U, Vec& D1V) const
{
#ifdef CHECK
- if (basisSurf->Continuity()==GeomAbs_C0 ||
- basisSurf->Continuity()==GeomAbs_C1) {
- Geom_UndefinedDerivative::Raise();
+ if (myBasisSurfContinuity==GeomAbs_C0 ||
+ myBasisSurfContinuity==GeomAbs_C1) {
+ Geom_UndefinedDerivative::Raise();
}
#endif
if (equivSurf.IsNull())
//=======================================================================
void Geom_OffsetSurface::D2 (const Standard_Real U, const Standard_Real V,
- Pnt& P,
- Vec& D1U, Vec& D1V,
- Vec& D2U, Vec& D2V, Vec& D2UV) const {
-
+ Pnt& P,
+ Vec& D1U, Vec& D1V,
+ Vec& D2U, Vec& D2V, Vec& D2UV) const {
+
#ifdef CHECK
- GeomAbs_Shape Continuity = basisSurf->Continuity();
- if (Continuity == GeomAbs_C0 || Continuity == GeomAbs_C1 ||
- Continuity == GeomAbs_C2) { Geom_UndefinedDerivative::Raise(); }
+ if (myBasisSurfContinuity == GeomAbs_C0 ||
+ myBasisSurfContinuity == GeomAbs_C1 ||
+ myBasisSurfContinuity == GeomAbs_C2)
+ {
+ Geom_UndefinedDerivative::Raise();
+ }
#endif
- if (equivSurf.IsNull())
+ if (equivSurf.IsNull())
{
gp_Vec d3u, d3uuv, d3uvv, d3v;
basisSurf->D3(U, V, P, D1U, D1V, D2U, D2V, D2UV,
- d3u,d3v, d3uuv, d3uvv);
-
+ d3u,d3v, d3uuv, d3uvv);
+
SetD2(U,V,P,D1U,D1V,D2U,D2V,D2UV,d3u,d3v, d3uuv, d3uvv);
}
- else equivSurf->D2(U,V,P,D1U,D1V,D2U,D2V,D2UV);
+ else equivSurf->D2(U,V,P,D1U,D1V,D2U,D2V,D2UV);
}
//=======================================================================
void Geom_OffsetSurface::D3 (const Standard_Real U, const Standard_Real V,
- Pnt& P,
- Vec& D1U, Vec& D1V,
- Vec& D2U, Vec& D2V, Vec& D2UV,
- Vec& D3U, Vec& D3V, Vec& D3UUV, Vec& D3UVV) const {
+ Pnt& P,
+ Vec& D1U, Vec& D1V,
+ Vec& D2U, Vec& D2V, Vec& D2UV,
+ Vec& D3U, Vec& D3V, Vec& D3UUV, Vec& D3UVV) const {
#ifdef CHECK
- if (!(basisSurf->IsCNu (4) && basisSurf->IsCNv (4))) {
- Geom_UndefinedDerivative::Raise();
+ if (!(basisSurf->IsCNu (4) && basisSurf->IsCNv (4))) {
+ Geom_UndefinedDerivative::Raise();
}
#endif
- if (equivSurf.IsNull())
+ if (equivSurf.IsNull())
{
-
+
basisSurf->D3(U, V, P, D1U, D1V, D2U, D2V, D2UV,
- D3U, D3V, D3UUV, D3UVV);
+ D3U, D3V, D3UUV, D3UVV);
SetD3(U, V, P, D1U, D1V, D2U, D2V, D2UV,
- D3U, D3V, D3UUV, D3UVV);
+ D3U, D3V, D3UUV, D3UVV);
}
- else equivSurf->D3(U,V,P,D1U,D1V,D2U,D2V,D2UV,D3U,D3V,D3UUV,D3UVV);
+ else equivSurf->D3(U,V,P,D1U,D1V,D2U,D2V,D2UV,D3U,D3V,D3UUV,D3UVV);
}
-
+
//=======================================================================
Vec Geom_OffsetSurface::DN ( const Standard_Real U , const Standard_Real V,
- const Standard_Integer Nu, const Standard_Integer Nv) const
+ const Standard_Integer Nu, const Standard_Integer Nv) const
{
-
+
Standard_RangeError_Raise_if (Nu < 0 || Nv < 0 || Nu + Nv < 1, " ");
#ifdef CHECK
if (!(basisSurf->IsCNu (Nu) && basisSurf->IsCNv (Nv))) {
if (equivSurf.IsNull())
{
- Pnt P;
- Vec D1U,D1V;
- basisSurf->D1 (U, V, P, D1U, D1V);
+ Pnt P;
+ Vec D1U,D1V;
+ basisSurf->D1 (U, V, P, D1U, D1V);
- D = SetDN(U,V,Nu,Nv,D1U,D1V);
- }
+ D = SetDN(U,V,Nu,Nv,D1U,D1V);
+ }
else D=equivSurf->DN(U,V,Nu,Nv);
return D;
}
void Geom_OffsetSurface::D1
(const Standard_Real U, const Standard_Real V,
- Pnt& P, Pnt& Pbasis,
- Vec& D1U, Vec& D1V, Vec& D1Ubasis , Vec& D1Vbasis,
- Vec& D2Ubasis, Vec& D2Vbasis, Vec& D2UVbasis) const {
-
- if (basisSurf->Continuity() == GeomAbs_C0 ||
- basisSurf->Continuity() == GeomAbs_C1) {
- Geom_UndefinedDerivative::Raise();
- }
- basisSurf->D2 (U, V, Pbasis, D1Ubasis, D1Vbasis, D2Ubasis, D2Vbasis,
- D2UVbasis);
- Vec Ndir = D1Ubasis.Crossed (D1Vbasis);
- Standard_Real R2 = Ndir.SquareMagnitude();
- Standard_Real R = Sqrt (R2);
- Standard_Real R3 = R * R2;
- Vec DUNdir = D2Ubasis.Crossed (D1Vbasis);
- DUNdir.Add (D1Ubasis.Crossed (D2UVbasis));
- Vec DVNdir = D2UVbasis.Crossed (D1Vbasis);
- DVNdir.Add (D1Ubasis.Crossed (D2Vbasis));
- Standard_Real DRu = Ndir.Dot (DUNdir);
- Standard_Real DRv = Ndir.Dot (DVNdir);
- if (R3 <= gp::Resolution()) {
- if (R2 <= gp::Resolution()) Geom_UndefinedDerivative::Raise();
- DUNdir.Multiply(R);
- DUNdir.Subtract (Ndir.Multiplied (DRu/R));
- DUNdir.Multiply (offsetValue/R2);
- D1U = D1Ubasis.Added (DUNdir);
- DVNdir.Multiply(R);
- DVNdir.Subtract (Ndir.Multiplied (DRv/R));
- DVNdir.Multiply (offsetValue/R2);
- D1V = D1Vbasis.Added (DVNdir);
- }
- else {
- DUNdir.Multiply (offsetValue / R);
- DUNdir.Subtract (Ndir.Multiplied (offsetValue*DRu/R3));
- D1U = D1Ubasis.Added (DUNdir);
- DVNdir.Multiply (offsetValue / R);
- DVNdir.Subtract (Ndir.Multiplied (offsetValue*DRv/R3));
- D1V = D1Vbasis.Added (DVNdir);
- }
- Ndir.Multiply (offsetValue/R);
- P.SetXYZ ((Ndir.XYZ()).Added (Pbasis.XYZ()));
+ Pnt& P, Pnt& Pbasis,
+ Vec& D1U, Vec& D1V, Vec& D1Ubasis , Vec& D1Vbasis,
+ Vec& D2Ubasis, Vec& D2Vbasis, Vec& D2UVbasis) const {
+
+ if (basisSurf->Continuity() == GeomAbs_C0 ||
+ basisSurf->Continuity() == GeomAbs_C1) {
+ Geom_UndefinedDerivative::Raise();
+ }
+ basisSurf->D2 (U, V, Pbasis, D1Ubasis, D1Vbasis, D2Ubasis, D2Vbasis,
+ D2UVbasis);
+ Vec Ndir = D1Ubasis.Crossed (D1Vbasis);
+ Standard_Real R2 = Ndir.SquareMagnitude();
+ Standard_Real R = Sqrt (R2);
+ Standard_Real R3 = R * R2;
+ Vec DUNdir = D2Ubasis.Crossed (D1Vbasis);
+ DUNdir.Add (D1Ubasis.Crossed (D2UVbasis));
+ Vec DVNdir = D2UVbasis.Crossed (D1Vbasis);
+ DVNdir.Add (D1Ubasis.Crossed (D2Vbasis));
+ Standard_Real DRu = Ndir.Dot (DUNdir);
+ Standard_Real DRv = Ndir.Dot (DVNdir);
+ if (R3 <= gp::Resolution()) {
+ if (R2 <= gp::Resolution()) Geom_UndefinedDerivative::Raise();
+ DUNdir.Multiply(R);
+ DUNdir.Subtract (Ndir.Multiplied (DRu/R));
+ DUNdir.Multiply (offsetValue/R2);
+ D1U = D1Ubasis.Added (DUNdir);
+ DVNdir.Multiply(R);
+ DVNdir.Subtract (Ndir.Multiplied (DRv/R));
+ DVNdir.Multiply (offsetValue/R2);
+ D1V = D1Vbasis.Added (DVNdir);
+ }
+ else {
+ DUNdir.Multiply (offsetValue / R);
+ DUNdir.Subtract (Ndir.Multiplied (offsetValue*DRu/R3));
+ D1U = D1Ubasis.Added (DUNdir);
+ DVNdir.Multiply (offsetValue / R);
+ DVNdir.Subtract (Ndir.Multiplied (offsetValue*DRv/R3));
+ D1V = D1Vbasis.Added (DVNdir);
+ }
+ Ndir.Multiply (offsetValue/R);
+ P.SetXYZ ((Ndir.XYZ()).Added (Pbasis.XYZ()));
}
void Geom_OffsetSurface::D2
(const Standard_Real U, const Standard_Real V,
- Pnt& P, Pnt& Pbasis,
- Vec& D1U, Vec& D1V, Vec& D2U, Vec& D2V, Vec& D2UV,
- Vec& D1Ubasis, Vec& D1Vbasis,
- Vec& D2Ubasis, Vec& D2Vbasis, Vec& D2UVbasis,
- Vec& D3Ubasis, Vec& D3Vbasis, Vec& D3UUVbasis, Vec& D3UVVbasis) const {
-
-
- GeomAbs_Shape Continuity = basisSurf->Continuity();
- if (Continuity == GeomAbs_C0 || Continuity == GeomAbs_C1 ||
- Continuity == GeomAbs_C2) { Geom_UndefinedDerivative::Raise(); }
-// Vec D3U, D3V, D3UVV, D3UUV;
- basisSurf->D3 (U, V, P, D1Ubasis, D1Vbasis, D2Ubasis, D2Vbasis, D2UVbasis,
- D3Ubasis, D3Vbasis, D3UUVbasis, D3UVVbasis);
- Vec Ndir = D1Ubasis.Crossed (D1Vbasis);
- Standard_Real R2 = Ndir.SquareMagnitude();
- Standard_Real R = Sqrt (R2);
- Standard_Real R3 = R2 * R;
- Standard_Real R4 = R2 * R2;
- Standard_Real R5 = R3 * R2;
- Vec DUNdir = D2Ubasis.Crossed (D1Vbasis);
- DUNdir.Add (D1Ubasis.Crossed (D2UVbasis));
- Vec DVNdir = D2UVbasis.Crossed (D1Vbasis);
- DVNdir.Add (D1Ubasis.Crossed (D2Vbasis));
- Standard_Real DRu = Ndir.Dot (DUNdir);
- Standard_Real DRv = Ndir.Dot (DVNdir);
- Vec D2UNdir = D3Ubasis.Crossed (D1Vbasis);
- D2UNdir.Add (D1Ubasis.Crossed (D3UUVbasis));
- D2UNdir.Add (2.0 * (D2Ubasis.Crossed (D2UVbasis)));
- Vec D2VNdir = D3UVVbasis.Crossed (D1Vbasis);
- D2VNdir.Add (D1Ubasis.Crossed (D3Vbasis));
- D2VNdir.Add (2.0 * (D2UVbasis.Crossed (D2Vbasis)));
- Vec D2UVNdir = D2UVbasis.Crossed (D1Vbasis);
- D2UVNdir.Add (D1Ubasis.Crossed (D3UVVbasis));
- D2UVNdir.Add (D2Ubasis.Crossed (D2Vbasis));
- Standard_Real D2Ru = Ndir.Dot (D2UNdir) + DUNdir.Dot (DUNdir);
- Standard_Real D2Rv = Ndir.Dot (D2VNdir) + DVNdir.Dot (DVNdir);
- Standard_Real D2Ruv = DVNdir.Dot (DUNdir) + Ndir.Dot (D2UVNdir);
-
- if (R5 <= gp::Resolution()) {
- //We try another computation but the stability is not very good
- //dixit ISG.
- if (R4 <= gp::Resolution()) Geom_UndefinedDerivative::Raise();
- // V2 = P" (U) :
- // Standard_Real R4 = R2 * R2;
- D2UNdir.Subtract (DUNdir.Multiplied (2.0 * DRu / R2));
- D2UNdir.Subtract (Ndir.Multiplied (D2Ru/R2));
- D2UNdir.Add (Ndir.Multiplied (3.0 * DRu * DRu / R4));
- D2UNdir.Multiply (offsetValue / R);
- D2U = D2Ubasis.Added (D2UNdir);
- D2VNdir.Subtract (DVNdir.Multiplied (2.0 * DRv / R2));
- D2VNdir.Subtract (Ndir.Multiplied (D2Rv/R2));
- D2VNdir.Add (Ndir.Multiplied (3.0 * DRv * DRv / R4));
- D2VNdir.Multiply (offsetValue / R);
- D2V = D2Vbasis.Added (D2VNdir);
-
- D2UVNdir.Subtract (DUNdir.Multiplied (DRv / R2));
- D2UVNdir.Subtract (DVNdir.Multiplied (DRu / R2));
- D2UVNdir.Subtract (Ndir.Multiplied (D2Ruv / R2));
- D2UVNdir.Add (Ndir.Multiplied (3.0 * DRu * DRv / R4));
- D2UVNdir.Multiply (offsetValue / R);
- D2UV = D2UVbasis.Added (D2UVNdir);
-
- DUNdir.Multiply(R);
- DUNdir.Subtract (Ndir.Multiplied (DRu/R));
- DUNdir.Multiply (offsetValue/R2);
- D1U = D1Ubasis.Added (DUNdir);
- DVNdir.Multiply(R);
- DVNdir.Subtract (Ndir.Multiplied (DRv/R));
- DVNdir.Multiply (offsetValue/R2);
- D1V = D1Vbasis.Added (DVNdir);
- }
- else {
- D2UNdir.Multiply (offsetValue/R);
- D2UNdir.Subtract (DUNdir.Multiplied (2.0 * offsetValue * DRu / R3));
- D2UNdir.Subtract (Ndir.Multiplied (offsetValue * D2Ru / R3));
- D2UNdir.Add (Ndir.Multiplied (offsetValue * 3.0 * DRu * DRu / R5));
- D2U = D2Ubasis.Added (D2UNdir);
-
- D2VNdir.Multiply (offsetValue/R);
- D2VNdir.Subtract (DVNdir.Multiplied (2.0 * offsetValue * DRv / R3));
- D2VNdir.Subtract (Ndir.Multiplied (offsetValue * D2Rv / R3));
- D2VNdir.Add (Ndir.Multiplied (offsetValue * 3.0 * DRv * DRv / R5));
- D2V = D2Vbasis.Added (D2VNdir);
-
- D2UVNdir.Multiply (offsetValue/R);
- D2UVNdir.Subtract (DUNdir.Multiplied (offsetValue * DRv / R3));
- D2UVNdir.Subtract (DVNdir.Multiplied (offsetValue * DRu / R3));
- D2UVNdir.Subtract (Ndir.Multiplied (offsetValue * D2Ruv / R3));
- D2UVNdir.Add (Ndir.Multiplied (3.0 * offsetValue * DRu * DRv / R5));
- D2UV = D2UVbasis.Added (D2UVNdir);
-
- DUNdir.Multiply (offsetValue / R);
- DUNdir.Subtract (Ndir.Multiplied (offsetValue*DRu/R3));
- D1U = D1Ubasis.Added (DUNdir);
- DVNdir.Multiply (offsetValue / R);
- DVNdir.Subtract (Ndir.Multiplied (offsetValue*DRv/R3));
- D1V = D1Vbasis.Added (DVNdir);
- }
- Ndir.Multiply (offsetValue/R);
- P.SetXYZ ((Ndir.XYZ()).Added (Pbasis.XYZ()));
+ Pnt& P, Pnt& Pbasis,
+ Vec& D1U, Vec& D1V, Vec& D2U, Vec& D2V, Vec& D2UV,
+ Vec& D1Ubasis, Vec& D1Vbasis,
+ Vec& D2Ubasis, Vec& D2Vbasis, Vec& D2UVbasis,
+ Vec& D3Ubasis, Vec& D3Vbasis, Vec& D3UUVbasis, Vec& D3UVVbasis) const {
+
+
+ GeomAbs_Shape Continuity = basisSurf->Continuity();
+ if (Continuity == GeomAbs_C0 || Continuity == GeomAbs_C1 ||
+ Continuity == GeomAbs_C2) { Geom_UndefinedDerivative::Raise(); }
+ // Vec D3U, D3V, D3UVV, D3UUV;
+ basisSurf->D3 (U, V, P, D1Ubasis, D1Vbasis, D2Ubasis, D2Vbasis, D2UVbasis,
+ D3Ubasis, D3Vbasis, D3UUVbasis, D3UVVbasis);
+ Vec Ndir = D1Ubasis.Crossed (D1Vbasis);
+ Standard_Real R2 = Ndir.SquareMagnitude();
+ Standard_Real R = Sqrt (R2);
+ Standard_Real R3 = R2 * R;
+ Standard_Real R4 = R2 * R2;
+ Standard_Real R5 = R3 * R2;
+ Vec DUNdir = D2Ubasis.Crossed (D1Vbasis);
+ DUNdir.Add (D1Ubasis.Crossed (D2UVbasis));
+ Vec DVNdir = D2UVbasis.Crossed (D1Vbasis);
+ DVNdir.Add (D1Ubasis.Crossed (D2Vbasis));
+ Standard_Real DRu = Ndir.Dot (DUNdir);
+ Standard_Real DRv = Ndir.Dot (DVNdir);
+ Vec D2UNdir = D3Ubasis.Crossed (D1Vbasis);
+ D2UNdir.Add (D1Ubasis.Crossed (D3UUVbasis));
+ D2UNdir.Add (2.0 * (D2Ubasis.Crossed (D2UVbasis)));
+ Vec D2VNdir = D3UVVbasis.Crossed (D1Vbasis);
+ D2VNdir.Add (D1Ubasis.Crossed (D3Vbasis));
+ D2VNdir.Add (2.0 * (D2UVbasis.Crossed (D2Vbasis)));
+ Vec D2UVNdir = D2UVbasis.Crossed (D1Vbasis);
+ D2UVNdir.Add (D1Ubasis.Crossed (D3UVVbasis));
+ D2UVNdir.Add (D2Ubasis.Crossed (D2Vbasis));
+ Standard_Real D2Ru = Ndir.Dot (D2UNdir) + DUNdir.Dot (DUNdir);
+ Standard_Real D2Rv = Ndir.Dot (D2VNdir) + DVNdir.Dot (DVNdir);
+ Standard_Real D2Ruv = DVNdir.Dot (DUNdir) + Ndir.Dot (D2UVNdir);
+
+ if (R5 <= gp::Resolution()) {
+ //We try another computation but the stability is not very good
+ //dixit ISG.
+ if (R4 <= gp::Resolution()) Geom_UndefinedDerivative::Raise();
+ // V2 = P" (U) :
+ // Standard_Real R4 = R2 * R2;
+ D2UNdir.Subtract (DUNdir.Multiplied (2.0 * DRu / R2));
+ D2UNdir.Subtract (Ndir.Multiplied (D2Ru/R2));
+ D2UNdir.Add (Ndir.Multiplied (3.0 * DRu * DRu / R4));
+ D2UNdir.Multiply (offsetValue / R);
+ D2U = D2Ubasis.Added (D2UNdir);
+ D2VNdir.Subtract (DVNdir.Multiplied (2.0 * DRv / R2));
+ D2VNdir.Subtract (Ndir.Multiplied (D2Rv/R2));
+ D2VNdir.Add (Ndir.Multiplied (3.0 * DRv * DRv / R4));
+ D2VNdir.Multiply (offsetValue / R);
+ D2V = D2Vbasis.Added (D2VNdir);
+
+ D2UVNdir.Subtract (DUNdir.Multiplied (DRv / R2));
+ D2UVNdir.Subtract (DVNdir.Multiplied (DRu / R2));
+ D2UVNdir.Subtract (Ndir.Multiplied (D2Ruv / R2));
+ D2UVNdir.Add (Ndir.Multiplied (3.0 * DRu * DRv / R4));
+ D2UVNdir.Multiply (offsetValue / R);
+ D2UV = D2UVbasis.Added (D2UVNdir);
+
+ DUNdir.Multiply(R);
+ DUNdir.Subtract (Ndir.Multiplied (DRu/R));
+ DUNdir.Multiply (offsetValue/R2);
+ D1U = D1Ubasis.Added (DUNdir);
+ DVNdir.Multiply(R);
+ DVNdir.Subtract (Ndir.Multiplied (DRv/R));
+ DVNdir.Multiply (offsetValue/R2);
+ D1V = D1Vbasis.Added (DVNdir);
+ }
+ else {
+ D2UNdir.Multiply (offsetValue/R);
+ D2UNdir.Subtract (DUNdir.Multiplied (2.0 * offsetValue * DRu / R3));
+ D2UNdir.Subtract (Ndir.Multiplied (offsetValue * D2Ru / R3));
+ D2UNdir.Add (Ndir.Multiplied (offsetValue * 3.0 * DRu * DRu / R5));
+ D2U = D2Ubasis.Added (D2UNdir);
+
+ D2VNdir.Multiply (offsetValue/R);
+ D2VNdir.Subtract (DVNdir.Multiplied (2.0 * offsetValue * DRv / R3));
+ D2VNdir.Subtract (Ndir.Multiplied (offsetValue * D2Rv / R3));
+ D2VNdir.Add (Ndir.Multiplied (offsetValue * 3.0 * DRv * DRv / R5));
+ D2V = D2Vbasis.Added (D2VNdir);
+
+ D2UVNdir.Multiply (offsetValue/R);
+ D2UVNdir.Subtract (DUNdir.Multiplied (offsetValue * DRv / R3));
+ D2UVNdir.Subtract (DVNdir.Multiplied (offsetValue * DRu / R3));
+ D2UVNdir.Subtract (Ndir.Multiplied (offsetValue * D2Ruv / R3));
+ D2UVNdir.Add (Ndir.Multiplied (3.0 * offsetValue * DRu * DRv / R5));
+ D2UV = D2UVbasis.Added (D2UVNdir);
+
+ DUNdir.Multiply (offsetValue / R);
+ DUNdir.Subtract (Ndir.Multiplied (offsetValue*DRu/R3));
+ D1U = D1Ubasis.Added (DUNdir);
+ DVNdir.Multiply (offsetValue / R);
+ DVNdir.Subtract (Ndir.Multiplied (offsetValue*DRv/R3));
+ D1V = D1Vbasis.Added (DVNdir);
+ }
+ Ndir.Multiply (offsetValue/R);
+ P.SetXYZ ((Ndir.XYZ()).Added (Pbasis.XYZ()));
}
//=======================================================================
void Geom_OffsetSurface::LocalD0 (const Standard_Real U,
- const Standard_Real V,
- const Standard_Integer USide,
- const Standard_Integer VSide,
- gp_Pnt& P ) const
+ const Standard_Real V,
+ const Standard_Integer USide,
+ const Standard_Integer VSide,
+ gp_Pnt& P ) const
{
if (equivSurf.IsNull()) {
Vec D1U, D1V;
if (!RTS.IsNull()) {
Basis = RTS->BasisSurface();
}
-
+
// BSpline case
Handle(Geom_BSplineSurface) BSplS;
BSplS = Handle(Geom_BSplineSurface)::DownCast(Basis);
if (!BSplS.IsNull()) {
Vec D2U,D2V,D2UV, D3U,D3V,D3UUV,D3UVV;
LocateSides(U,V,USide,VSide,BSplS,1,P,D1U,D1V,D2U,D2V,D2UV,
- D3U,D3V,D3UUV,D3UVV);
+ D3U,D3V,D3UUV,D3UVV);
SetD0(U,V,P,D1U,D1V);
return;
}
SetD0(U,V, P, D1U,D1V);
return;
}
-
+
// General cases
basisSurf->D1(U, V, P, D1U, D1V);
SetD0(U,V, P, D1U,D1V);
//=======================================================================
void Geom_OffsetSurface::LocalD1 (const Standard_Real U,
- const Standard_Real V,
- const Standard_Integer USide,
- const Standard_Integer VSide,
- gp_Pnt& P,
- gp_Vec& D1U,
- gp_Vec& D1V) const
+ const Standard_Real V,
+ const Standard_Integer USide,
+ const Standard_Integer VSide,
+ gp_Pnt& P,
+ gp_Vec& D1U,
+ gp_Vec& D1V) const
{
if (equivSurf.IsNull()) {
Vec D2U,D2V,D2UV ;
if (!RTS.IsNull()) {
Basis = RTS->BasisSurface();
}
-
+
// BSpline case
Handle(Geom_BSplineSurface) BSplS;
BSplS = Handle(Geom_BSplineSurface)::DownCast(Basis);
if (!BSplS.IsNull()) {
Vec D3U,D3V,D3UUV,D3UVV;
LocateSides(U,V,USide,VSide,BSplS,2,P,D1U,D1V,D2U,D2V,D2UV,
- D3U,D3V,D3UUV,D3UVV);
+ D3U,D3V,D3UUV,D3UVV);
SetD1(U,V,P,D1U,D1V,D2U,D2V,D2UV);
return;
}
SetD1(U,V, P, D1U,D1V,D2U,D2V,D2UV);
return;
}
-
+
// General cases
basisSurf->D2(U, V, P, D1U, D1V,D2U,D2V,D2UV);
SetD1(U,V, P, D1U,D1V,D2U,D2V,D2UV);
//=======================================================================
void Geom_OffsetSurface::LocalD2 (const Standard_Real U,
- const Standard_Real V,
- const Standard_Integer USide,
- const Standard_Integer VSide,
- gp_Pnt& P,
- gp_Vec& D1U,
- gp_Vec& D1V,
- gp_Vec& D2U,
- gp_Vec& D2V,
- gp_Vec& D2UV) const
+ const Standard_Real V,
+ const Standard_Integer USide,
+ const Standard_Integer VSide,
+ gp_Pnt& P,
+ gp_Vec& D1U,
+ gp_Vec& D1V,
+ gp_Vec& D2U,
+ gp_Vec& D2V,
+ gp_Vec& D2UV) const
{
if (equivSurf.IsNull()) {
Handle(Geom_Surface) Basis = basisSurf;
if (!RTS.IsNull()) {
Basis = RTS->BasisSurface();
}
-
+
// BSpline case
Handle(Geom_BSplineSurface) BSplS;
BSplS = Handle(Geom_BSplineSurface)::DownCast(Basis);
if (!BSplS.IsNull()) {
LocateSides(U,V,USide,VSide,BSplS,3,P,D1U,D1V,D2U,D2V,D2UV,
- D3U,D3V,D3UUV,D3UVV);
+ D3U,D3V,D3UUV,D3UVV);
SetD2(U,V,P,D1U,D1V,D2U,D2V,D2UV,D3U,D3V,D3UUV,D3UVV);
return;
}
if (!SE.IsNull()) {
SE->LocalD3(U,V,USide,P,D1U,D1V,
- D2U,D2V,D2UV,
- D3U,D3V,D3UUV,D3UVV);
+ D2U,D2V,D2UV,
+ D3U,D3V,D3UUV,D3UVV);
SetD2(U,V,P,D1U,D1V,D2U,D2V,D2UV,D3U,D3V,D3UUV,D3UVV);
return;
}
SetD2(U,V, P, D1U,D1V, D2U,D2V,D2UV, D3U,D3V,D3UUV,D3UVV);
return;
}
-
+
// General cases
basisSurf->D3(U, V, P, D1U, D1V, D2U, D2V, D2UV,D3U, D3V, D3UUV, D3UVV);
SetD2(U,V, P, D1U,D1V, D2U,D2V,D2UV, D3U,D3V,D3UUV,D3UVV);
//=======================================================================
void Geom_OffsetSurface::LocalD3 (const Standard_Real U,
- const Standard_Real V,
- const Standard_Integer USide,
- const Standard_Integer VSide,
- 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) const
+ const Standard_Real V,
+ const Standard_Integer USide,
+ const Standard_Integer VSide,
+ 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) const
{
if (equivSurf.IsNull()) {
Handle(Geom_Surface) Basis = basisSurf;
if (!RTS.IsNull()) {
Basis = RTS->BasisSurface();
}
-
+
// BSpline case
Handle(Geom_BSplineSurface) BSplS;
BSplS = Handle(Geom_BSplineSurface)::DownCast(Basis);
if (!BSplS.IsNull()) {
LocateSides(U,V,USide,VSide,BSplS,3,P,D1U,D1V,D2U,D2V,D2UV,
- D3U,D3V,D3UUV,D3UVV);
+ D3U,D3V,D3UUV,D3UVV);
SetD3(U,V,P,D1U,D1V,D2U,D2V,D2UV,D3U,D3V,D3UUV,D3UVV);
return;
}
if (!SE.IsNull()) {
SE->LocalD3(U,V,USide,P,D1U,D1V,
- D2U,D2V,D2UV,
- D3U,D3V,D3UUV,D3UVV);
+ D2U,D2V,D2UV,
+ D3U,D3V,D3UUV,D3UVV);
SetD3(U,V,P,D1U,D1V,D2U,D2V,D2UV,D3U,D3V,D3UUV,D3UVV);
return;
}
SetD3(U,V, P, D1U,D1V, D2U,D2V,D2UV, D3U,D3V,D3UUV,D3UVV);
return;
}
-
+
// General cases
basisSurf->D3(U, V, P, D1U, D1V, D2U, D2V, D2UV,D3U, D3V, D3UUV, D3UVV);
SetD3(U,V, P, D1U,D1V, D2U,D2V,D2UV, D3U,D3V,D3UUV,D3UVV);
//=======================================================================
gp_Vec Geom_OffsetSurface::LocalDN (const Standard_Real U,
- const Standard_Real V,
- const Standard_Integer USide,
- const Standard_Integer VSide,
- const Standard_Integer Nu,
- const Standard_Integer Nv) const
+ const Standard_Real V,
+ const Standard_Integer USide,
+ const Standard_Integer VSide,
+ const Standard_Integer Nu,
+ const Standard_Integer Nv) const
{
gp_Vec D(0,0,0);
-
+
if(equivSurf.IsNull()) {
Vec D1U,D1V,D2U,D2V,D2UV,D3U,D3V,D3UUV,D3UVV;
Pnt P;
Handle(Geom_Surface) Basis = basisSurf;
-
+
// if Basis is Trimmed we make the basis`s basis
Handle(Geom_RectangularTrimmedSurface) RTS;
RTS = Handle(Geom_RectangularTrimmedSurface)::DownCast(Basis);
-
+
if (!RTS.IsNull()) {
Basis = RTS -> BasisSurface();
}
-
+
//BSpline case
Handle(Geom_BSplineSurface) BSplS;
BSplS = Handle(Geom_BSplineSurface)::DownCast(Basis);
-
+
if(!BSplS.IsNull()) {
LocateSides(U,V,USide,VSide,BSplS,1,P,D1U,D1V,D2U,D2V,D2UV,D3U,D3V,D3UUV,D3UVV);
return D = SetDN(U,V,Nu,Nv,D1U,D1V);
}
-
+
//Extrusion case
Handle( Geom_SurfaceOfLinearExtrusion) SE;
SE = Handle(Geom_SurfaceOfLinearExtrusion)::DownCast(Basis);
-
+
if(!SE.IsNull()) {
-
+
SE->LocalD1(U,V,USide,P,D1U,D1V);
D = SetDN(U,V,Nu,Nv,D1U,D1V);
return D;
}
-
+
//Revolution case
Handle(Geom_SurfaceOfRevolution) SR;
SR = Handle(Geom_SurfaceOfRevolution)::DownCast(Basis);
-
+
if(!SR.IsNull()) {
D = SR->LocalDN(U,V,VSide,Nu,Nv);
return D = SetDN(U,V,Nu,Nv,D1U,D1V);
}
-
+
//General cases
D = basisSurf->DN(U,V,Nu,Nv);
return D = SetDN(U,V,Nu,Nv,D1U,D1V);
//purpose :
//=======================================================================
void Geom_OffsetSurface::LocateSides(const Standard_Real U,
- const Standard_Real V,
- const Standard_Integer USide,
- const Standard_Integer VSide,
- const Handle(Geom_BSplineSurface)& BSplS,
- const Standard_Integer NDir,
- 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 ) const
+ const Standard_Real V,
+ const Standard_Integer USide,
+ const Standard_Integer VSide,
+ const Handle(Geom_BSplineSurface)& BSplS,
+ const Standard_Integer NDir,
+ 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 ) const
{
Standard_Boolean UIsKnot=Standard_False, VIsKnot=Standard_False ;
Standard_Integer Ideb, Ifin, IVdeb, IVfin;
Standard_Real ParTol=Precision::PConfusion()/10.;
BSplS->Geom_BSplineSurface::LocateU(U,ParTol,Ideb, Ifin, Standard_False);
BSplS->Geom_BSplineSurface::LocateV(V,ParTol,IVdeb,IVfin,Standard_False);
-
+
if(Ideb == Ifin ) { //knot
if(USide == 1) {Ifin++; UIsKnot=Standard_True;}
if(IVfin > BSplS->LastVKnotIndex()) {IVfin = BSplS->LastVKnotIndex(); IVdeb = IVfin - 1;}
-
+
if((UIsKnot)||(VIsKnot))
switch(NDir)
- {
- case 0 : BSplS->Geom_BSplineSurface::LocalD0(U,V,Ideb,Ifin,IVdeb,IVfin,P); break;
- case 1 : BSplS->Geom_BSplineSurface::LocalD1(U,V,Ideb,Ifin,IVdeb,IVfin,P,D1U,D1V); break;
- case 2 : BSplS->Geom_BSplineSurface::LocalD2(U,V,Ideb,Ifin,IVdeb,IVfin,P,D1U,D1V,D2U,D2V,D2UV); break;
- case 3 : BSplS->Geom_BSplineSurface::LocalD3(U,V,Ideb,Ifin,IVdeb,IVfin,P,D1U,D1V,D2U,D2V,D2UV,D3U,D3V,D3UUV,D3UVV); break;
- }else switch(NDir)
- {
- case 0 : basisSurf->D0(U,V,P); break;
- case 1 : basisSurf->D1(U,V,P,D1U,D1V); break;
- case 2 : basisSurf->D2(U,V,P,D1U,D1V,D2U,D2V,D2UV); break;
- case 3 : basisSurf->D3(U,V,P,D1U,D1V,D2U,D2V,D2UV,D3U,D3V,D3UUV,D3UVV); break;
- }
+ {
+ case 0 : BSplS->Geom_BSplineSurface::LocalD0(U,V,Ideb,Ifin,IVdeb,IVfin,P); break;
+ case 1 : BSplS->Geom_BSplineSurface::LocalD1(U,V,Ideb,Ifin,IVdeb,IVfin,P,D1U,D1V); break;
+ case 2 : BSplS->Geom_BSplineSurface::LocalD2(U,V,Ideb,Ifin,IVdeb,IVfin,P,D1U,D1V,D2U,D2V,D2UV); break;
+ case 3 : BSplS->Geom_BSplineSurface::LocalD3(U,V,Ideb,Ifin,IVdeb,IVfin,P,D1U,D1V,D2U,D2V,D2UV,D3U,D3V,D3UUV,D3UVV); break;
+ }else switch(NDir)
+ {
+ case 0 : basisSurf->D0(U,V,P); break;
+ case 1 : basisSurf->D1(U,V,P,D1U,D1V); break;
+ case 2 : basisSurf->D2(U,V,P,D1U,D1V,D2U,D2V,D2UV); break;
+ case 3 : basisSurf->D3(U,V,P,D1U,D1V,D2U,D2V,D2UV,D3U,D3V,D3UUV,D3UVV); break;
+ }
}
class Geom_OffsetSurface_UIsoEvaluator : public AdvApprox_EvaluatorFunction
{
- public:
+public:
Geom_OffsetSurface_UIsoEvaluator (const Handle(Geom_Surface)& theSurface,
- Standard_Real theU)
- : CurrentSurface(theSurface), IsoPar(theU) {}
-
+ Standard_Real theU)
+ : CurrentSurface(theSurface), IsoPar(theU) {}
+
virtual void Evaluate (Standard_Integer *Dimension,
- Standard_Real StartEnd[2],
- Standard_Real *Parameter,
- Standard_Integer *DerivativeRequest,
- Standard_Real *Result, // [Dimension]
- Standard_Integer *ErrorCode);
-
- private:
+ Standard_Real StartEnd[2],
+ Standard_Real *Parameter,
+ Standard_Integer *DerivativeRequest,
+ Standard_Real *Result, // [Dimension]
+ Standard_Integer *ErrorCode);
+
+private:
Handle(Geom_Surface) CurrentSurface;
Standard_Real IsoPar;
};
void Geom_OffsetSurface_UIsoEvaluator::Evaluate(Standard_Integer *,/*Dimension*/
- Standard_Real /*StartEnd*/[2],
- Standard_Real *Parameter,
- Standard_Integer *DerivativeRequest,
- Standard_Real *Result,
- Standard_Integer *ReturnCode)
+ Standard_Real /*StartEnd*/[2],
+ Standard_Real *Parameter,
+ Standard_Integer *DerivativeRequest,
+ Standard_Real *Result,
+ Standard_Integer *ReturnCode)
{
gp_Pnt P;
if (*DerivativeRequest == 0) {
class Geom_OffsetSurface_VIsoEvaluator : public AdvApprox_EvaluatorFunction
{
- public:
+public:
Geom_OffsetSurface_VIsoEvaluator (const Handle(Geom_Surface)& theSurface,
- Standard_Real theV)
- : CurrentSurface(theSurface), IsoPar(theV) {}
-
+ Standard_Real theV)
+ : CurrentSurface(theSurface), IsoPar(theV) {}
+
virtual void Evaluate (Standard_Integer *Dimension,
- Standard_Real StartEnd[2],
- Standard_Real *Parameter,
- Standard_Integer *DerivativeRequest,
- Standard_Real *Result, // [Dimension]
- Standard_Integer *ErrorCode);
-
- private:
+ Standard_Real StartEnd[2],
+ Standard_Real *Parameter,
+ Standard_Integer *DerivativeRequest,
+ Standard_Real *Result, // [Dimension]
+ Standard_Integer *ErrorCode);
+
+private:
Handle(Geom_Surface) CurrentSurface;
Standard_Real IsoPar;
};
void Geom_OffsetSurface_VIsoEvaluator::Evaluate(Standard_Integer *,/*Dimension*/
- Standard_Real /*StartEnd*/[2],
- Standard_Real *Parameter,
- Standard_Integer *DerivativeRequest,
- Standard_Real *Result,
- Standard_Integer *ReturnCode)
+ Standard_Real /*StartEnd*/[2],
+ Standard_Real *Parameter,
+ Standard_Integer *DerivativeRequest,
+ Standard_Real *Result,
+ Standard_Integer *ReturnCode)
{
gp_Pnt P;
if (*DerivativeRequest == 0) {
Geom_OffsetSurface_UIsoEvaluator ev (this, UU);
AdvApprox_ApproxAFunction Approx(Num1, Num2, Num3, T1, T2, T3,
- V1, V2, Cont,
- MaxDeg,MaxSeg, ev);
+ V1, V2, Cont,
+ MaxDeg,MaxSeg, ev);
Standard_ConstructionError_Raise_if (!Approx.IsDone(),
- " Geom_OffsetSurface : UIso");
+ " Geom_OffsetSurface : UIso");
Standard_Integer NbPoles = Approx.NbPoles();
void Geom_OffsetSurface::Value
( const Standard_Real U, const Standard_Real V,
-// Pnt& P, Pnt& Pbasis,
- Pnt& P, Pnt& ,
- Vec& D1Ubasis, Vec& D1Vbasis) const {
+ // Pnt& P, Pnt& Pbasis,
+ Pnt& P, Pnt& ,
+ Vec& D1Ubasis, Vec& D1Vbasis) const {
- if (basisSurf->Continuity() == GeomAbs_C0)
- Geom_UndefinedValue::Raise();
-
- SetD0(U,V,P,D1Ubasis,D1Vbasis);
+ if (myBasisSurfContinuity == GeomAbs_C0)
+ Geom_UndefinedValue::Raise();
+
+ SetD0(U,V,P,D1Ubasis,D1Vbasis);
}
Geom_OffsetSurface_VIsoEvaluator ev (this, VV);
AdvApprox_ApproxAFunction Approx (Num1, Num2, Num3, T1, T2, T3,
- U1, U2, Cont, MaxDeg, MaxSeg, ev);
+ U1, U2, Cont, MaxDeg, MaxSeg, ev);
Standard_ConstructionError_Raise_if (!Approx.IsDone(),
- " Geom_OffsetSurface : VIso");
+ " Geom_OffsetSurface : VIso");
TColgp_Array1OfPnt Poles( 1, Approx.NbPoles());
TColStd_Array1OfReal Knots( 1, Approx.NbKnots());
Standard_Boolean Geom_OffsetSurface::IsCNu (const Standard_Integer N) const {
- Standard_RangeError_Raise_if (N < 0, " ");
- return basisSurf->IsCNu (N+1);
+ Standard_RangeError_Raise_if (N < 0, " ");
+ return basisSurf->IsCNu (N+1);
}
}
else if (S->IsKind (STANDARD_TYPE(Geom_SurfaceOfLinearExtrusion))) {
Handle(Geom_SurfaceOfLinearExtrusion) Extru =
- Handle(Geom_SurfaceOfLinearExtrusion)::DownCast(S);
+ Handle(Geom_SurfaceOfLinearExtrusion)::DownCast(S);
Handle(Curve) C = Extru->BasisCurve();
if (C->IsKind (STANDARD_TYPE(Geom_Circle)) || C->IsKind (STANDARD_TYPE(Geom_Ellipse))) {
}
else if (SBasis->IsKind (STANDARD_TYPE(Geom_SurfaceOfLinearExtrusion))) {
Handle(Geom_SurfaceOfLinearExtrusion) Extru =
- Handle(Geom_SurfaceOfLinearExtrusion)::DownCast(SBasis);
+ Handle(Geom_SurfaceOfLinearExtrusion)::DownCast(SBasis);
Handle(Curve) C = Extru->BasisCurve();
UClosed = (C->IsKind(STANDARD_TYPE(Geom_Circle)) || C->IsKind(STANDARD_TYPE(Geom_Ellipse)));
void Geom_OffsetSurface::Transform (const Trsf& T)
{
- basisSurf->Transform (T);
- offsetValue *= T.ScaleFactor();
- equivSurf.Nullify();
+ basisSurf->Transform (T);
+ offsetValue *= T.ScaleFactor();
+ equivSurf.Nullify();
}
//=======================================================================
//=======================================================================
void Geom_OffsetSurface::TransformParameters(Standard_Real& U,
- Standard_Real& V,
- const gp_Trsf& T)
-const
+ Standard_Real& V,
+ const gp_Trsf& T)
+ const
{
basisSurf->TransformParameters(U,V,T);
if(!equivSurf.IsNull()) equivSurf->TransformParameters(U,V,T);
//=======================================================================
gp_GTrsf2d Geom_OffsetSurface::ParametricTransformation
-(const gp_Trsf& T) const
+ (const gp_Trsf& T) const
{
return basisSurf->ParametricTransformation(T);
}
S->Bounds(U1,U2,V1,V2);
IsTrimmed = Standard_True;
}
- else {
- IsTrimmed = Standard_False;
- Base = basisSurf;
- }
+ else {
+ IsTrimmed = Standard_False;
+ Base = basisSurf;
+ }
// Traite les surfaces cannonique
- if (TheType == STANDARD_TYPE(Geom_Plane))
+ if (TheType == STANDARD_TYPE(Geom_Plane))
{
Handle(Geom_Plane) P =
Handle(Geom_Plane)::DownCast(Base);
}
else
{
-// surface degeneree
+ // surface degeneree
}
}
else if (TheType == STANDARD_TYPE(Geom_ConicalSurface))
}
else
{
-// surface degeneree
+ // surface degeneree
}
}
else if (TheType == STANDARD_TYPE(Geom_SphericalSurface)) {
Result->UReverse();
}
else {
-// surface degeneree
+ // surface degeneree
}
}
else if (TheType == STANDARD_TYPE(Geom_ToroidalSurface))
if (MinorRadius <= MajorRadius)
{
if (Axis.Direct())
- MinorRadius += offsetValue;
+ MinorRadius += offsetValue;
else
- MinorRadius -= offsetValue;
+ MinorRadius -= offsetValue;
if (MinorRadius >= Tol)
- Result = new Geom_ToroidalSurface(Axis,MajorRadius,MinorRadius);
-// else if (MinorRadius <= -Tol)
-// Result->UReverse();
+ Result = new Geom_ToroidalSurface(Axis,MajorRadius,MinorRadius);
+ // else if (MinorRadius <= -Tol)
+ // Result->UReverse();
else
{
-// surface degeneree
+ // surface degeneree
}
}
}
}
Standard_Boolean Geom_OffsetSurface::UOsculatingSurface(const Standard_Real U,
- const Standard_Real V,
- Standard_Boolean& t,
- Handle(Geom_BSplineSurface)& L) const
+ const Standard_Real V,
+ Standard_Boolean& t,
+ Handle(Geom_BSplineSurface)& L) const
{
return myOscSurf.UOscSurf(U,V,t,L);
}
Standard_Boolean Geom_OffsetSurface::VOsculatingSurface(const Standard_Real U,
- const Standard_Real V,
- Standard_Boolean& t,
- Handle(Geom_BSplineSurface)& L) const
+ const Standard_Real V,
+ Standard_Boolean& t,
+ Handle(Geom_BSplineSurface)& L) const
{
return myOscSurf.VOscSurf(U,V,t,L);
}
//purpose : private
//=======================================================================
void Geom_OffsetSurface::SetD0(const Standard_Real U, const Standard_Real V,
- Pnt& P,
- const Vec& D1U, const Vec& D1V)const
+ Pnt& P,
+ const Vec& D1U, const Vec& D1V)const
{
Standard_Boolean AlongU = Standard_False,
- AlongV = Standard_False;
+ AlongV = Standard_False;
Handle(Geom_BSplineSurface) L;
Standard_Boolean IsOpposite=Standard_False;
Standard_Real signe = 1.;
CSLib::Normal (D1U, D1V, MagTol, NStatus, Normal);
if (NStatus == CSLib_Defined) // akm - only in singularities && !AlongU && !AlongV)
- {
- P.SetXYZ(P.XYZ() + offsetValue * Normal.XYZ());
- }
+ {
+ P.SetXYZ(P.XYZ() + offsetValue * Normal.XYZ());
+ }
else
- {
- Standard_Integer MaxOrder=3;
- TColgp_Array2OfVec DerNUV(0,MaxOrder,0,MaxOrder);
- TColgp_Array2OfVec DerSurf(0,MaxOrder+1,0,MaxOrder+1);
- Standard_Integer OrderU,OrderV;
- Standard_Real Umin,Umax,Vmin,Vmax;
- Bounds(Umin,Umax,Vmin,Vmax);
- DerSurf.SetValue(1, 0, D1U);
- DerSurf.SetValue(0, 1, D1V);
- derivatives(MaxOrder,1,U,V,basisSurf,0,0,AlongU,AlongV,L,DerNUV,DerSurf);
-
- CSLib::Normal(MaxOrder,DerNUV,MagTol,U,V,Umin,Umax,Vmin,Vmax,NStatus,Normal,OrderU,OrderV);
- if (NStatus == CSLib_Defined)
- P.SetXYZ(P.XYZ() + offsetValue * signe * Normal.XYZ());
- else
- Geom_UndefinedValue::Raise();
-
- }
+ {
+ Standard_Integer MaxOrder=3;
+ TColgp_Array2OfVec DerNUV(0,MaxOrder,0,MaxOrder);
+ TColgp_Array2OfVec DerSurf(0,MaxOrder+1,0,MaxOrder+1);
+ Standard_Integer OrderU,OrderV;
+ Standard_Real Umin,Umax,Vmin,Vmax;
+ Bounds(Umin,Umax,Vmin,Vmax);
+ DerSurf.SetValue(1, 0, D1U);
+ DerSurf.SetValue(0, 1, D1V);
+ derivatives(MaxOrder,1,U,V,basisSurf,0,0,AlongU,AlongV,L,DerNUV,DerSurf);
+
+ CSLib::Normal(MaxOrder,DerNUV,MagTol,U,V,Umin,Umax,Vmin,Vmax,NStatus,Normal,OrderU,OrderV);
+ if (NStatus == CSLib_Defined)
+ P.SetXYZ(P.XYZ() + offsetValue * signe * Normal.XYZ());
+ else
+ Geom_UndefinedValue::Raise();
+
+ }
}
//=======================================================================
//purpose : private
//=======================================================================/
void Geom_OffsetSurface::SetD1(const Standard_Real U, const Standard_Real V,
- Pnt& P,
- Vec& D1U, Vec& D1V,
- const Vec& d2u, const Vec& d2v, const Vec& d2uv ) const
+ Pnt& P,
+ Vec& D1U, Vec& D1V,
+ const Vec& d2u, const Vec& d2v, const Vec& d2uv ) const
{
-
+
Standard_Real MagTol=0.000000001;
Dir Normal;
CSLib_NormalStatus NStatus;
DerSurf.SetValue(0, 2, d2v);
Handle(Geom_BSplineSurface) L;
Standard_Boolean AlongU = Standard_False,
- AlongV = Standard_False;
+ AlongV = Standard_False;
Standard_Boolean IsOpposite=Standard_False;
Standard_Real signe = 1.;
AlongU = UOsculatingSurface(U,V,IsOpposite,L);
AlongV = VOsculatingSurface(U,V,IsOpposite,L);
if ((AlongV || AlongU) && IsOpposite) signe = -1;
derivatives(MaxOrder,2,U,V,basisSurf,1,1,AlongU,AlongV,L,DerNUV,DerSurf);
-
+
CSLib::Normal(MaxOrder,DerNUV,MagTol,U,V,Umin,Umax,Vmin,Vmax,NStatus,Normal,OrderU,OrderV);
if (NStatus != CSLib_Defined) Geom_UndefinedValue::Raise();
-
+
P.SetXYZ(P.XYZ() + offsetValue * signe * Normal.XYZ());
-
+
D1U = DerSurf(1,0)
+ offsetValue * signe * CSLib::DNNormal(1,0,DerNUV,OrderU,OrderV);
D1V = DerSurf(0,1)
+ offsetValue * signe * CSLib::DNNormal(0,1,DerNUV,OrderU,OrderV);
-
+
}
//=======================================================================
//purpose : private
//=======================================================================/
void Geom_OffsetSurface::SetD2(const Standard_Real U, const Standard_Real V,
- Pnt& P,
- Vec& D1U, Vec& D1V,
- Vec& D2U, Vec& D2V, Vec& D2UV,
- const Vec& d3u, const Vec& d3v,
- const Vec& d3uuv, const Vec& d3uvv ) const
+ Pnt& P,
+ Vec& D1U, Vec& D1V,
+ Vec& D2U, Vec& D2V, Vec& D2UV,
+ const Vec& d3u, const Vec& d3v,
+ const Vec& d3uuv, const Vec& d3uvv ) const
{
Standard_Real MagTol=0.000000001;
Dir Normal;
DerSurf.SetValue(1, 2, d3uvv);
DerSurf.SetValue(0, 3, d3v);
//*********************
-
+
Handle(Geom_BSplineSurface) L;
Standard_Boolean AlongU = Standard_False,
- AlongV = Standard_False;
+ AlongV = Standard_False;
Standard_Boolean IsOpposite=Standard_False;
Standard_Real signe = 1.;
AlongU = UOsculatingSurface(U,V,IsOpposite,L);
AlongV = VOsculatingSurface(U,V,IsOpposite,L);
if ((AlongV || AlongU) && IsOpposite) signe = -1;
derivatives(MaxOrder,3,U,V,basisSurf,2,2,AlongU,AlongV,L,DerNUV,DerSurf);
-
+
CSLib::Normal(MaxOrder,DerNUV,MagTol,U,V,Umin,Umax,Vmin,Vmax,NStatus,Normal,OrderU,OrderV);
if (NStatus != CSLib_Defined) Geom_UndefinedValue::Raise();
-
-
+
+
P.SetXYZ(P.XYZ() + offsetValue * signe * Normal.XYZ());
-
+
D1U = DerSurf(1,0)
+ offsetValue * signe * CSLib::DNNormal(1,0,DerNUV,OrderU,OrderV);
D1V = DerSurf(0,1)
+ offsetValue * signe * CSLib::DNNormal(0,1,DerNUV,OrderU,OrderV);
-
+
D2U = basisSurf->DN(U,V,2,0)
+ signe * offsetValue * CSLib::DNNormal(2,0,DerNUV,OrderU,OrderV);
D2V = basisSurf->DN(U,V,0,2)
//purpose : private
//=======================================================================/
void Geom_OffsetSurface::SetD3(const Standard_Real U, const Standard_Real V,
- Pnt& P,
- Vec& D1U, Vec& D1V,
- Vec& D2U, Vec& D2V, Vec& D2UV,
- Vec& D3U, Vec& D3V, Vec& D3UUV, Vec& D3UVV ) const
+ Pnt& P,
+ Vec& D1U, Vec& D1V,
+ Vec& D2U, Vec& D2V, Vec& D2UV,
+ Vec& D3U, Vec& D3V, Vec& D3UUV, Vec& D3UVV ) const
{
Standard_Real MagTol=0.000000001;
Dir Normal;
TColgp_Array2OfVec DerSurf(0,MaxOrder+4,0,MaxOrder+4);
Standard_Real Umin,Umax,Vmin,Vmax;
Bounds(Umin,Umax,Vmin,Vmax);
-
+
DerSurf.SetValue(1, 0, D1U);
DerSurf.SetValue(0, 1, D1V);
DerSurf.SetValue(1, 1, D2UV);
DerSurf.SetValue(2, 1, D3UUV);
DerSurf.SetValue(1, 2, D3UVV);
DerSurf.SetValue(0, 3, D3V);
-
-
+
+
//*********************
Handle(Geom_BSplineSurface) L;
Standard_Boolean AlongU = Standard_False,
- AlongV = Standard_False;
+ AlongV = Standard_False;
Standard_Boolean IsOpposite=Standard_False;
Standard_Real signe = 1.;
AlongU = UOsculatingSurface(U,V,IsOpposite,L);
AlongV = VOsculatingSurface(U,V,IsOpposite,L);
if ((AlongV || AlongU) && IsOpposite) signe = -1;
derivatives(MaxOrder,3,U,V,basisSurf,3,3,AlongU,AlongV,L,DerNUV,DerSurf);
-
+
CSLib::Normal(MaxOrder,DerNUV,MagTol,U,V,Umin,Umax,Vmin,Vmax,NStatus,Normal,OrderU,OrderV);
if (NStatus != CSLib_Defined) Geom_UndefinedValue::Raise();
-
-
+
+
P.SetXYZ(P.XYZ() + offsetValue * signe * Normal.XYZ());
-
+
D1U = DerSurf(1,0)
+ offsetValue * signe * CSLib::DNNormal(1,0,DerNUV,OrderU,OrderV);
D1V = DerSurf(0,1)
+ offsetValue * signe * CSLib::DNNormal(0,1,DerNUV,OrderU,OrderV);
-
+
D2U = basisSurf->DN(U,V,2,0)
+ signe * offsetValue * CSLib::DNNormal(2,0,DerNUV,OrderU,OrderV);
D2V = basisSurf->DN(U,V,0,2)
//=======================================================================
Vec Geom_OffsetSurface::SetDN ( const Standard_Real U , const Standard_Real V,
- const Standard_Integer Nu, const Standard_Integer Nv,
- const Vec& D1U, const Vec& D1V) const
+ const Standard_Integer Nu, const Standard_Integer Nv,
+ const Vec& D1U, const Vec& D1V) const
{
gp_Vec D(0,0,0);
Standard_Real MagTol=0.000000001;
TColgp_Array2OfVec DerSurf(0,MaxOrder+Nu+1,0,MaxOrder+Nv+1);
Standard_Real Umin,Umax,Vmin,Vmax;
Bounds(Umin,Umax,Vmin,Vmax);
-
+
DerSurf.SetValue(1, 0, D1U);
DerSurf.SetValue(0, 1, D1V);
//*********************
Standard_Real signe = 1.;
AlongU = UOsculatingSurface(U,V,IsOpposite,L);
AlongV = VOsculatingSurface(U,V,IsOpposite,L);
- if ((AlongV || AlongU) && IsOpposite) signe = -1;
+ if ((AlongV || AlongU) && IsOpposite) signe = -1;
derivatives(MaxOrder,1,U,V,basisSurf,Nu,Nv,AlongU,AlongV,L,DerNUV,DerSurf);
-
+
CSLib::Normal(MaxOrder,DerNUV,MagTol,U,V,Umin,Umax,Vmin,Vmax,NStatus,Normal,OrderU,OrderV);
if (NStatus != CSLib_Defined) Geom_UndefinedValue::Raise();
-
+
D = basisSurf->DN(U,V,Nu,Nv)
+ signe * offsetValue * CSLib::DNNormal(Nu,Nv,DerNUV,OrderU,OrderV);
-
+
return D;
}
+//=======================================================================
+//function : GetBasisCurveContinuity
+//purpose :
+//=======================================================================
+GeomAbs_Shape Geom_OffsetSurface::GetBasisSurfContinuity() const
+{
+ return myBasisSurfContinuity;
+}
//=======================================================================
Geom_OsculatingSurface::Geom_OsculatingSurface()
-: myAlong(1,4)
+ : myAlong(1,4)
{
}
//=======================================================================
//=======================================================================
Geom_OsculatingSurface::Geom_OsculatingSurface(const Handle(Geom_Surface)& BS,
- const Standard_Real Tol)
-: myAlong(1,4)
+ const Standard_Real Tol)
+ : myAlong(1,4)
{
Init(BS,Tol);
}
//=======================================================================
void Geom_OsculatingSurface::Init(const Handle(Geom_Surface)& BS,
- const Standard_Real Tol)
+ const Standard_Real Tol)
{
ClearOsculFlags();
myTol=Tol;
myOsculSurf1 = new Geom_HSequenceOfBSplineSurface();
myOsculSurf2 = new Geom_HSequenceOfBSplineSurface();
if ((BS->IsKind(STANDARD_TYPE(Geom_BSplineSurface))) ||
- (BS->IsKind(STANDARD_TYPE(Geom_BezierSurface))))
- {
- Standard_Real U1=0,U2=0,V1=0,V2=0;
-
- Standard_Integer i = 1;
- BS->Bounds(U1,U2,V1,V2);
- myAlong.SetValue(1,IsQPunctual(BS,V1,GeomAbs_IsoV,TolMin,Tol));
- myAlong.SetValue(2,IsQPunctual(BS,V2,GeomAbs_IsoV,TolMin,Tol));
- myAlong.SetValue(3,IsQPunctual(BS,U1,GeomAbs_IsoU,TolMin,Tol));
- myAlong.SetValue(4,IsQPunctual(BS,U2,GeomAbs_IsoU,TolMin,Tol));
+ (BS->IsKind(STANDARD_TYPE(Geom_BezierSurface))))
+ {
+ Standard_Real U1=0,U2=0,V1=0,V2=0;
+
+ Standard_Integer i = 1;
+ BS->Bounds(U1,U2,V1,V2);
+ myAlong.SetValue(1,IsQPunctual(BS,V1,GeomAbs_IsoV,TolMin,Tol));
+ myAlong.SetValue(2,IsQPunctual(BS,V2,GeomAbs_IsoV,TolMin,Tol));
+ myAlong.SetValue(3,IsQPunctual(BS,U1,GeomAbs_IsoU,TolMin,Tol));
+ myAlong.SetValue(4,IsQPunctual(BS,U2,GeomAbs_IsoU,TolMin,Tol));
#ifdef OCCT_DEBUG
- cout<<myAlong(1)<<endl<<myAlong(2)<<endl<<myAlong(3)<<endl<<myAlong(4)<<endl;
+ cout<<myAlong(1)<<endl<<myAlong(2)<<endl<<myAlong(3)<<endl<<myAlong(4)<<endl;
#endif
- if (myAlong(1) || myAlong(2) || myAlong(3) || myAlong(4))
- {
- Handle(Geom_BSplineSurface) InitSurf, L,S;
- if (BS->IsKind(STANDARD_TYPE(Geom_BezierSurface)))
- {
- Handle(Geom_BezierSurface) BzS = Handle(Geom_BezierSurface)::DownCast(BS);
- TColgp_Array2OfPnt P(1,BzS->NbUPoles(),1,BzS->NbVPoles());
- TColStd_Array1OfReal UKnots(1,2);
- TColStd_Array1OfReal VKnots(1,2);
- TColStd_Array1OfInteger UMults(1,2);
- TColStd_Array1OfInteger VMults(1,2);
- for (i=1;i<=2;i++)
- {
- UKnots.SetValue(i,(i-1));
- VKnots.SetValue(i,(i-1));
- UMults.SetValue(i,BzS->UDegree()+1);
- VMults.SetValue(i,BzS->VDegree()+1);
- }
- BzS->Poles(P);
- InitSurf = new Geom_BSplineSurface(P,UKnots,VKnots,
- UMults,VMults,
- BzS->UDegree(),
- BzS->VDegree(),
- BzS->IsUPeriodic(),
- BzS->IsVPeriodic());
- }
- else
- {
- InitSurf = Handle(Geom_BSplineSurface)::DownCast(myBasisSurf);
- }
+ if (myAlong(1) || myAlong(2) || myAlong(3) || myAlong(4))
+ {
+ Handle(Geom_BSplineSurface) InitSurf, L,S;
+ if (BS->IsKind(STANDARD_TYPE(Geom_BezierSurface)))
+ {
+ Handle(Geom_BezierSurface) BzS = Handle(Geom_BezierSurface)::DownCast(BS);
+ TColgp_Array2OfPnt P(1,BzS->NbUPoles(),1,BzS->NbVPoles());
+ TColStd_Array1OfReal UKnots(1,2);
+ TColStd_Array1OfReal VKnots(1,2);
+ TColStd_Array1OfInteger UMults(1,2);
+ TColStd_Array1OfInteger VMults(1,2);
+ for (i=1;i<=2;i++)
+ {
+ UKnots.SetValue(i,(i-1));
+ VKnots.SetValue(i,(i-1));
+ UMults.SetValue(i,BzS->UDegree()+1);
+ VMults.SetValue(i,BzS->VDegree()+1);
+ }
+ BzS->Poles(P);
+ InitSurf = new Geom_BSplineSurface(P,UKnots,VKnots,
+ UMults,VMults,
+ BzS->UDegree(),
+ BzS->VDegree(),
+ BzS->IsUPeriodic(),
+ BzS->IsVPeriodic());
+ }
+ else
+ {
+ InitSurf = Handle(Geom_BSplineSurface)::DownCast(myBasisSurf);
+ }
#ifdef OCCT_DEBUG
- cout<<"UDEG: "<<InitSurf->UDegree()<<endl;
- cout<<"VDEG: "<<InitSurf->VDegree()<<endl;
+ cout<<"UDEG: "<<InitSurf->UDegree()<<endl;
+ cout<<"VDEG: "<<InitSurf->VDegree()<<endl;
#endif
-
- if(IsAlongU() && IsAlongV()) ClearOsculFlags();
- // Standard_ConstructionError_Raise_if((IsAlongU() && IsAlongV()),"Geom_OsculatingSurface");
- if ((IsAlongU() && InitSurf->VDegree()>1) ||
- (IsAlongV() && InitSurf->UDegree()>1))
- {
- myKdeg = new TColStd_HSequenceOfInteger();
- Standard_Integer k=0;
- Standard_Boolean IsQPunc;
- Standard_Integer UKnot,VKnot;
- if (myAlong(1) || myAlong(2))
- {
- for (i=1;i<InitSurf->NbUKnots();i++)
- {
- if (myAlong(1))
- {
- S = InitSurf; k=0; IsQPunc=Standard_True;
- UKnot=i;
- VKnot=1;
- while(IsQPunc)
- {
- OsculSurf = BuildOsculatingSurface(V1,UKnot,VKnot,S,L);
- if(!OsculSurf) break;
- k++;
+
+ if(IsAlongU() && IsAlongV()) ClearOsculFlags();
+ // Standard_ConstructionError_Raise_if((IsAlongU() && IsAlongV()),"Geom_OsculatingSurface");
+ if ((IsAlongU() && InitSurf->VDegree()>1) ||
+ (IsAlongV() && InitSurf->UDegree()>1))
+ {
+ myKdeg = new TColStd_HSequenceOfInteger();
+ Standard_Integer k=0;
+ Standard_Boolean IsQPunc;
+ Standard_Integer UKnot,VKnot;
+ if (myAlong(1) || myAlong(2))
+ {
+ for (i=1;i<InitSurf->NbUKnots();i++)
+ {
+ if (myAlong(1))
+ {
+ S = InitSurf; k=0; IsQPunc=Standard_True;
+ UKnot=i;
+ VKnot=1;
+ while(IsQPunc)
+ {
+ OsculSurf = BuildOsculatingSurface(V1,UKnot,VKnot,S,L);
+ if(!OsculSurf) break;
+ k++;
#ifdef OCCT_DEBUG
- cout<<"1.k = "<<k<<endl;
+ cout<<"1.k = "<<k<<endl;
#endif
- IsQPunc=IsQPunctual(L,V1,GeomAbs_IsoV,0.,Tol);
- UKnot=1;
- VKnot=1;
- S=L;
-
- }
- if (OsculSurf)
- myOsculSurf1->Append(L);
- else
- ClearOsculFlags(); //myAlong.SetValue(1,Standard_False);
- if (myAlong(2) && OsculSurf)
- {
- S = InitSurf; k=0; IsQPunc=Standard_True;
- UKnot=i;
- VKnot=InitSurf->NbVKnots()-1;
-
- while(IsQPunc)
- {
- OsculSurf = BuildOsculatingSurface(V2,UKnot,VKnot,S,L);
- if(!OsculSurf) break;
- k++;
+ IsQPunc=IsQPunctual(L,V1,GeomAbs_IsoV,0.,Tol);
+ UKnot=1;
+ VKnot=1;
+ S=L;
+
+ }
+ if (OsculSurf)
+ myOsculSurf1->Append(L);
+ else
+ ClearOsculFlags(); //myAlong.SetValue(1,Standard_False);
+ if (myAlong(2) && OsculSurf)
+ {
+ S = InitSurf; k=0; IsQPunc=Standard_True;
+ UKnot=i;
+ VKnot=InitSurf->NbVKnots()-1;
+
+ while(IsQPunc)
+ {
+ OsculSurf = BuildOsculatingSurface(V2,UKnot,VKnot,S,L);
+ if(!OsculSurf) break;
+ k++;
#ifdef OCCT_DEBUG
- cout<<"2.k = "<<k<<endl;
+ cout<<"2.k = "<<k<<endl;
#endif
- IsQPunc=IsQPunctual(L,V2,GeomAbs_IsoV,0.,Tol);
- UKnot=1;
- VKnot=1;
- S=L;
- }
- if(OsculSurf)
- {
- myOsculSurf2->Append(L);
- myKdeg->Append(k);
- }
- }
- }
- else
- //if (myAlong(2))
- {
- S = InitSurf; k=0; IsQPunc=Standard_True;
- UKnot=i;
- VKnot=InitSurf->NbVKnots()-1;
- while(IsQPunc)
- {
- OsculSurf = BuildOsculatingSurface(V2,UKnot,VKnot,S,L);
- if(!OsculSurf) break;
- k++;
+ IsQPunc=IsQPunctual(L,V2,GeomAbs_IsoV,0.,Tol);
+ UKnot=1;
+ VKnot=1;
+ S=L;
+ }
+ if(OsculSurf)
+ {
+ myOsculSurf2->Append(L);
+ myKdeg->Append(k);
+ }
+ }
+ }
+ else
+ //if (myAlong(2))
+ {
+ S = InitSurf; k=0; IsQPunc=Standard_True;
+ UKnot=i;
+ VKnot=InitSurf->NbVKnots()-1;
+ while(IsQPunc)
+ {
+ OsculSurf = BuildOsculatingSurface(V2,UKnot,VKnot,S,L);
+ if(!OsculSurf) break;
+ k++;
#ifdef OCCT_DEBUG
- cout<<"2.k = "<<k<<endl;
+ cout<<"2.k = "<<k<<endl;
#endif
- IsQPunc=IsQPunctual(L,V2,GeomAbs_IsoV,0.,Tol);
- UKnot=1;
- VKnot=1;
- S=L;
-
- }
- if(OsculSurf)
- {
- myOsculSurf2->Append(L);
- myKdeg->Append(k);
- }
- else
- ClearOsculFlags(); //myAlong.SetValue(2,Standard_False);
- }
- }
- }
- if (myAlong(3) || myAlong(4))
- {
- for (i=1;i<InitSurf->NbVKnots();i++)
- {
- if (myAlong(3))
- {
- S = InitSurf; k=0; IsQPunc=Standard_True;
- UKnot=1;
- VKnot=i;
- while(IsQPunc)
- {
- OsculSurf = BuildOsculatingSurface(U1,UKnot,VKnot,S,L);
- if(!OsculSurf) break;
- k++;
+ IsQPunc=IsQPunctual(L,V2,GeomAbs_IsoV,0.,Tol);
+ UKnot=1;
+ VKnot=1;
+ S=L;
+
+ }
+ if(OsculSurf)
+ {
+ myOsculSurf2->Append(L);
+ myKdeg->Append(k);
+ }
+ else
+ ClearOsculFlags(); //myAlong.SetValue(2,Standard_False);
+ }
+ }
+ }
+ if (myAlong(3) || myAlong(4))
+ {
+ for (i=1;i<InitSurf->NbVKnots();i++)
+ {
+ if (myAlong(3))
+ {
+ S = InitSurf; k=0; IsQPunc=Standard_True;
+ UKnot=1;
+ VKnot=i;
+ while(IsQPunc)
+ {
+ OsculSurf = BuildOsculatingSurface(U1,UKnot,VKnot,S,L);
+ if(!OsculSurf) break;
+ k++;
#ifdef OCCT_DEBUG
- cout<<"1.k = "<<k<<endl;
+ cout<<"1.k = "<<k<<endl;
#endif
- IsQPunc=IsQPunctual(L,U1,GeomAbs_IsoU,0.,Tol);
- UKnot=1;
- VKnot=1;
- S=L;
- }
- if(OsculSurf)
- myOsculSurf1->Append(L);
- else
- ClearOsculFlags(); //myAlong.SetValue(3,Standard_False);
- if (myAlong(4) && OsculSurf )
- {
- S = InitSurf; k=0; IsQPunc=Standard_True;
- UKnot=InitSurf->NbUKnots()-1;
- VKnot=i;
- while(IsQPunc)
- {
- OsculSurf = BuildOsculatingSurface(U2,UKnot,VKnot,S,L);
- if(!OsculSurf) break;
- k++;
+ IsQPunc=IsQPunctual(L,U1,GeomAbs_IsoU,0.,Tol);
+ UKnot=1;
+ VKnot=1;
+ S=L;
+ }
+ if(OsculSurf)
+ myOsculSurf1->Append(L);
+ else
+ ClearOsculFlags(); //myAlong.SetValue(3,Standard_False);
+ if (myAlong(4) && OsculSurf )
+ {
+ S = InitSurf; k=0; IsQPunc=Standard_True;
+ UKnot=InitSurf->NbUKnots()-1;
+ VKnot=i;
+ while(IsQPunc)
+ {
+ OsculSurf = BuildOsculatingSurface(U2,UKnot,VKnot,S,L);
+ if(!OsculSurf) break;
+ k++;
#ifdef OCCT_DEBUG
- cout<<"2.k = "<<k<<endl;
+ cout<<"2.k = "<<k<<endl;
#endif
- IsQPunc=IsQPunctual(L,U2,GeomAbs_IsoU,0.,Tol);
- UKnot=1;
- VKnot=1;
- S=L;
- }
- if(OsculSurf)
- {
- myOsculSurf2->Append(L);
- myKdeg->Append(k);
- }
- }
- }
- else
- {
- S = InitSurf; k=0; IsQPunc=Standard_True;
- UKnot=InitSurf->NbUKnots()-1;
- VKnot=i;
- while(IsQPunc)
- {
- OsculSurf = BuildOsculatingSurface(U2,UKnot,VKnot,S,L);
- if(!OsculSurf) break;
- k++;
+ IsQPunc=IsQPunctual(L,U2,GeomAbs_IsoU,0.,Tol);
+ UKnot=1;
+ VKnot=1;
+ S=L;
+ }
+ if(OsculSurf)
+ {
+ myOsculSurf2->Append(L);
+ myKdeg->Append(k);
+ }
+ }
+ }
+ else
+ {
+ S = InitSurf; k=0; IsQPunc=Standard_True;
+ UKnot=InitSurf->NbUKnots()-1;
+ VKnot=i;
+ while(IsQPunc)
+ {
+ OsculSurf = BuildOsculatingSurface(U2,UKnot,VKnot,S,L);
+ if(!OsculSurf) break;
+ k++;
#ifdef OCCT_DEBUG
- cout<<"2.k = "<<k<<endl;
+ cout<<"2.k = "<<k<<endl;
#endif
- IsQPunc=IsQPunctual(L,U2,GeomAbs_IsoU,0.,Tol);
- UKnot=1;
- VKnot=1;
- S=L;
- }
- if(OsculSurf)
- {
- myOsculSurf2->Append(L);
- myKdeg->Append(k);
- }
- else
- ClearOsculFlags(); //myAlong.SetValue(4,Standard_False);
- }
- }
- }
- }
- else
- {
- ClearOsculFlags();
- }
- }
+ IsQPunc=IsQPunctual(L,U2,GeomAbs_IsoU,0.,Tol);
+ UKnot=1;
+ VKnot=1;
+ S=L;
+ }
+ if(OsculSurf)
+ {
+ myOsculSurf2->Append(L);
+ myKdeg->Append(k);
+ }
+ else
+ ClearOsculFlags(); //myAlong.SetValue(4,Standard_False);
+ }
+ }
+ }
+ }
+ else
+ {
+ ClearOsculFlags();
+ }
}
+ }
else
ClearOsculFlags();
}
//purpose :
//=======================================================================
- Handle(Geom_Surface) Geom_OsculatingSurface::BasisSurface() const
+Handle(Geom_Surface) Geom_OsculatingSurface::BasisSurface() const
{
return myBasisSurf;
}
//=======================================================================
Standard_Boolean Geom_OsculatingSurface::UOscSurf
- (const Standard_Real U,
- const Standard_Real V,
- Standard_Boolean& t,
- Handle(Geom_BSplineSurface)& L) const
+ (const Standard_Real U,
+ const Standard_Real V,
+ Standard_Boolean& t,
+ Handle(Geom_BSplineSurface)& L) const
{
Standard_Boolean along = Standard_False;
if (myAlong(1) || myAlong(2))
if (myBasisSurf->IsKind(STANDARD_TYPE(Geom_BSplineSurface)))
{
Handle(Geom_BSplineSurface) BSur =
- *((Handle(Geom_BSplineSurface)*)& myBasisSurf);
+ *((Handle(Geom_BSplineSurface)*)& myBasisSurf);
NbUK = BSur->NbUKnots();
NbVK = BSur->NbVKnots();
TColStd_Array1OfReal UKnots(1,NbUK);
if (NU < 1) NU=1;
if (NU >= NbUK) NU=NbUK-1;
if (NbVK==2 && NV==1)
- // Need to find the closest end
- if (VKnots(NbVK)-V > V-VKnots(1))
- isToSkipSecond = Standard_True;
+ // Need to find the closest end
+ if (VKnots(NbVK)-V > V-VKnots(1))
+ isToSkipSecond = Standard_True;
}
else {NU = 1; NV = 1 ; NbVK = 2 ;}
//=======================================================================
Standard_Boolean Geom_OsculatingSurface::VOscSurf
- (const Standard_Real U,
- const Standard_Real V,
- Standard_Boolean& t,
- Handle(Geom_BSplineSurface)& L) const
+ (const Standard_Real U,
+ const Standard_Real V,
+ Standard_Boolean& t,
+ Handle(Geom_BSplineSurface)& L) const
{
Standard_Boolean along = Standard_False;
if (myAlong(3) || myAlong(4))
if (myBasisSurf->IsKind(STANDARD_TYPE(Geom_BSplineSurface)))
{
Handle(Geom_BSplineSurface) BSur =
- *((Handle(Geom_BSplineSurface)*)& myBasisSurf);
+ *((Handle(Geom_BSplineSurface)*)& myBasisSurf);
NbUK = BSur->NbUKnots();
NbVK = BSur->NbVKnots();
TColStd_Array1OfReal UKnots(1,NbUK);
if (NV < 1) NV=1;
if (NV >= NbVK) NV=NbVK-1;
if (NbUK==2 && NU==1)
- // Need to find the closest end
- if (UKnots(NbUK)-U > U-UKnots(1))
- isToSkipSecond = Standard_True;
+ // Need to find the closest end
+ if (UKnots(NbUK)-U > U-UKnots(1))
+ isToSkipSecond = Standard_True;
}
else {NU = 1; NV = 1 ; NbUK = 2;}
//=======================================================================
Standard_Boolean Geom_OsculatingSurface::BuildOsculatingSurface
- (const Standard_Real Param,
- const Standard_Integer SUKnot,
- const Standard_Integer SVKnot,
- const Handle(Geom_BSplineSurface)& BS,
- Handle(Geom_BSplineSurface)& BSpl) const
+ (const Standard_Real Param,
+ const Standard_Integer SUKnot,
+ const Standard_Integer SVKnot,
+ const Handle(Geom_BSplineSurface)& BS,
+ Handle(Geom_BSplineSurface)& BSpl) const
{
Standard_Integer i, j;
Standard_Boolean OsculSurf=Standard_True;
cout<<"======================================"<<endl<<endl;
#endif
-// for cache
+ // for cache
Standard_Integer MinDegree,
- MaxDegree ;
+ MaxDegree ;
Standard_Real udeg, vdeg;
udeg = BS->UDegree();
vdeg = BS->VDegree();
if( (IsAlongU() && vdeg <=1) || (IsAlongV() && udeg <=1))
{
#ifdef OCCT_DEBUG
- cout<<" surface osculatrice nulle "<<endl;
+ cout<<" surface osculatrice nulle "<<endl;
#endif
- //Standard_ConstructionError::Raise("Geom_OsculatingSurface");
- OsculSurf=Standard_False;
+ //Standard_ConstructionError::Raise("Geom_OsculatingSurface");
+ OsculSurf=Standard_False;
}
else
{
- MinDegree = (Standard_Integer ) Min(udeg,vdeg) ;
- MaxDegree = (Standard_Integer ) Max(udeg,vdeg) ;
-
- TColgp_Array2OfPnt cachepoles(1, MaxDegree + 1, 1, MinDegree + 1);
-// end for cache
-
-// for polynomial grid
- Standard_Integer MaxUDegree, MaxVDegree;
- Standard_Integer UContinuity, VContinuity;
-
- Handle(TColStd_HArray2OfInteger) NumCoeffPerSurface =
- new TColStd_HArray2OfInteger(1, 1, 1, 2);
- Handle(TColStd_HArray1OfReal) PolynomialUIntervals =
- new TColStd_HArray1OfReal(1, 2);
- Handle(TColStd_HArray1OfReal) PolynomialVIntervals =
- new TColStd_HArray1OfReal(1, 2);
- Handle(TColStd_HArray1OfReal) TrueUIntervals =
- new TColStd_HArray1OfReal(1, 2);
- Handle(TColStd_HArray1OfReal) TrueVIntervals =
- new TColStd_HArray1OfReal(1, 2);
- MaxUDegree = (Standard_Integer ) udeg;
- MaxVDegree = (Standard_Integer ) vdeg;
-
- for (i=1;i<=2;i++)
- {
- PolynomialUIntervals->ChangeValue(i) = i-1;
- PolynomialVIntervals->ChangeValue(i) = i-1;
- TrueUIntervals->ChangeValue(i) = BS->UKnot(SUKnot+i-1);
- TrueVIntervals->ChangeValue(i) = BS->VKnot(SVKnot+i-1);
- }
+ MinDegree = (Standard_Integer ) Min(udeg,vdeg) ;
+ MaxDegree = (Standard_Integer ) Max(udeg,vdeg) ;
+
+ TColgp_Array2OfPnt cachepoles(1, MaxDegree + 1, 1, MinDegree + 1);
+ // end for cache
+
+ // for polynomial grid
+ Standard_Integer MaxUDegree, MaxVDegree;
+ Standard_Integer UContinuity, VContinuity;
+
+ Handle(TColStd_HArray2OfInteger) NumCoeffPerSurface =
+ new TColStd_HArray2OfInteger(1, 1, 1, 2);
+ Handle(TColStd_HArray1OfReal) PolynomialUIntervals =
+ new TColStd_HArray1OfReal(1, 2);
+ Handle(TColStd_HArray1OfReal) PolynomialVIntervals =
+ new TColStd_HArray1OfReal(1, 2);
+ Handle(TColStd_HArray1OfReal) TrueUIntervals =
+ new TColStd_HArray1OfReal(1, 2);
+ Handle(TColStd_HArray1OfReal) TrueVIntervals =
+ new TColStd_HArray1OfReal(1, 2);
+ MaxUDegree = (Standard_Integer ) udeg;
+ MaxVDegree = (Standard_Integer ) vdeg;
+
+ for (i=1;i<=2;i++)
+ {
+ PolynomialUIntervals->ChangeValue(i) = i-1;
+ PolynomialVIntervals->ChangeValue(i) = i-1;
+ TrueUIntervals->ChangeValue(i) = BS->UKnot(SUKnot+i-1);
+ TrueVIntervals->ChangeValue(i) = BS->VKnot(SVKnot+i-1);
+ }
- Standard_Integer OscUNumCoeff=0, OscVNumCoeff=0;
- if (IsAlongU())
- {
+ Standard_Integer OscUNumCoeff=0, OscVNumCoeff=0;
+ if (IsAlongU())
+ {
#ifdef OCCT_DEBUG
- cout<<">>>>>>>>>>> AlongU"<<endl;
+ cout<<">>>>>>>>>>> AlongU"<<endl;
#endif
- OscUNumCoeff = (Standard_Integer ) udeg + 1;
- OscVNumCoeff = (Standard_Integer ) vdeg;
- }
- if (IsAlongV())
- {
+ OscUNumCoeff = (Standard_Integer ) udeg + 1;
+ OscVNumCoeff = (Standard_Integer ) vdeg;
+ }
+ if (IsAlongV())
+ {
#ifdef OCCT_DEBUG
- cout<<">>>>>>>>>>> AlongV"<<endl;
+ cout<<">>>>>>>>>>> AlongV"<<endl;
#endif
- OscUNumCoeff = (Standard_Integer ) udeg;
- OscVNumCoeff = (Standard_Integer ) vdeg + 1;
+ OscUNumCoeff = (Standard_Integer ) udeg;
+ OscVNumCoeff = (Standard_Integer ) vdeg + 1;
+ }
+ NumCoeffPerSurface->ChangeValue(1,1) = OscUNumCoeff;
+ NumCoeffPerSurface->ChangeValue(1,2) = OscVNumCoeff;
+ Standard_Integer nbc = NumCoeffPerSurface->Value(1,1)*NumCoeffPerSurface->Value(1,2)*3;
+ //
+ if(nbc == 0)
+ {
+ return Standard_False;
+ }
+ //
+ Handle(TColStd_HArray1OfReal) Coefficients = new TColStd_HArray1OfReal(1, nbc);
+ // end for polynomial grid
+
+ // building the cache
+ Standard_Integer ULocalIndex, VLocalIndex;
+ Standard_Real ucacheparameter, vcacheparameter,uspanlength, vspanlength;
+ TColgp_Array2OfPnt NewPoles(1, BS->NbUPoles(), 1, BS->NbVPoles());
+
+ Standard_Integer aUfKnotsLength = BS->NbUPoles() + BS->UDegree() + 1;
+ Standard_Integer aVfKnotsLength = BS->NbVPoles() + BS->VDegree() + 1;
+
+ if(BS->IsUPeriodic())
+ {
+ TColStd_Array1OfInteger aMults(1, BS->NbUKnots());
+ BS->UMultiplicities(aMults);
+ aUfKnotsLength = BSplCLib::KnotSequenceLength(aMults, BS->UDegree(), Standard_True);
+ }
+
+ if(BS->IsVPeriodic())
+ {
+ TColStd_Array1OfInteger aMults(1, BS->NbVKnots());
+ BS->VMultiplicities(aMults);
+ aVfKnotsLength = BSplCLib::KnotSequenceLength(aMults, BS->VDegree(), Standard_True);
+ }
+
+ TColStd_Array1OfReal UFlatKnots(1, aUfKnotsLength);
+ TColStd_Array1OfReal VFlatKnots(1, aVfKnotsLength);
+ BS->Poles(NewPoles);
+ BS->UKnotSequence(UFlatKnots);
+ BS->VKnotSequence(VFlatKnots);
+
+ VLocalIndex = 0;
+ ULocalIndex = 0;
+ for(j = 1; j <= SVKnot; j++) VLocalIndex += BS->VMultiplicity(j);
+ for(i = 1; i <= SUKnot; i++) ULocalIndex += BS->UMultiplicity(i);
+ ucacheparameter = BS->UKnot(SUKnot);
+ vcacheparameter = BS->VKnot(SVKnot);
+ vspanlength = BS->VKnot(SVKnot + 1) - BS->VKnot(SVKnot);
+ uspanlength = BS->UKnot(SUKnot + 1) - BS->UKnot(SUKnot);
+
+ // On se ramene toujours a un parametrage tel que localement ce soit l'iso
+ // u=0 ou v=0 qui soit degeneree
+
+ Standard_Boolean IsVNegative = Param > vcacheparameter + vspanlength/2;
+ Standard_Boolean IsUNegative = Param > ucacheparameter + uspanlength/2;
+
+ if (IsAlongU() && (Param > vcacheparameter + vspanlength/2))
+ vcacheparameter = vcacheparameter + vspanlength;
+ if (IsAlongV() && (Param > ucacheparameter + uspanlength/2))
+ ucacheparameter = ucacheparameter + uspanlength;
+
+ BSplSLib::BuildCache(ucacheparameter,
+ vcacheparameter,
+ uspanlength,
+ vspanlength,
+ BS->IsUPeriodic(),
+ BS->IsVPeriodic(),
+ BS->UDegree(),
+ BS->VDegree(),
+ ULocalIndex,
+ VLocalIndex,
+ UFlatKnots,
+ VFlatKnots,
+ NewPoles,
+ BSplSLib::NoWeights(),
+ cachepoles,
+ BSplSLib::NoWeights());
+ Standard_Integer m, n, index;
+ TColgp_Array2OfPnt OscCoeff(1,OscUNumCoeff , 1, OscVNumCoeff);
+
+ if (IsAlongU())
+ {
+ if (udeg > vdeg)
+ {
+ for(n = 1; n <= udeg + 1; n++)
+ for(m = 1; m <= vdeg; m++)
+ OscCoeff(n,m) = cachepoles(n,m+1) ;
+ }
+ else
+ {
+ for(n = 1; n <= udeg + 1; n++)
+ for(m = 1; m <= vdeg; m++)
+ OscCoeff(n,m) = cachepoles(m+1,n) ;
}
- NumCoeffPerSurface->ChangeValue(1,1) = OscUNumCoeff;
- NumCoeffPerSurface->ChangeValue(1,2) = OscVNumCoeff;
-
- Handle(TColStd_HArray1OfReal) Coefficients = new TColStd_HArray1OfReal(1,
- NumCoeffPerSurface->Value(1,1)*NumCoeffPerSurface->Value(1,2)*3);
-// end for polynomial grid
-
-// building the cache
- Standard_Integer ULocalIndex, VLocalIndex;
- Standard_Real ucacheparameter, vcacheparameter,uspanlength, vspanlength;
- TColgp_Array2OfPnt NewPoles(1, BS->NbUPoles(), 1, BS->NbVPoles());
- TColStd_Array1OfReal UFlatKnots(1, BS->NbUPoles() + BS->UDegree() + 1);
- TColStd_Array1OfReal VFlatKnots(1, BS->NbVPoles() + BS->VDegree() + 1);
- BS->Poles(NewPoles);
- BS->UKnotSequence(UFlatKnots);
- BS->VKnotSequence(VFlatKnots);
-
- VLocalIndex = 0;
- ULocalIndex = 0;
- for(j = 1; j <= SVKnot; j++) VLocalIndex += BS->VMultiplicity(j);
- for(i = 1; i <= SUKnot; i++) ULocalIndex += BS->UMultiplicity(i);
- ucacheparameter = BS->UKnot(SUKnot);
- vcacheparameter = BS->VKnot(SVKnot);
- vspanlength = BS->VKnot(SVKnot + 1) - BS->VKnot(SVKnot);
- uspanlength = BS->UKnot(SUKnot + 1) - BS->UKnot(SUKnot);
-
- // On se ramene toujours a un parametrage tel que localement ce soit l'iso
- // u=0 ou v=0 qui soit degeneree
-
- Standard_Boolean IsVNegative = Param > vcacheparameter + vspanlength/2;
- Standard_Boolean IsUNegative = Param > ucacheparameter + uspanlength/2;
-
- if (IsAlongU() && (Param > vcacheparameter + vspanlength/2))
- vcacheparameter = vcacheparameter + vspanlength;
- if (IsAlongV() && (Param > ucacheparameter + uspanlength/2))
- ucacheparameter = ucacheparameter + uspanlength;
-
- BSplSLib::BuildCache(ucacheparameter,
- vcacheparameter,
- uspanlength,
- vspanlength,
- BS->IsUPeriodic(),
- BS->IsVPeriodic(),
- BS->UDegree(),
- BS->VDegree(),
- ULocalIndex,
- VLocalIndex,
- UFlatKnots,
- VFlatKnots,
- NewPoles,
- BSplSLib::NoWeights(),
- cachepoles,
- BSplSLib::NoWeights());
- Standard_Integer m, n, index;
- TColgp_Array2OfPnt OscCoeff(1,OscUNumCoeff , 1, OscVNumCoeff);
-
- if (IsAlongU())
- {
- if (udeg > vdeg)
- {
- for(n = 1; n <= udeg + 1; n++)
- for(m = 1; m <= vdeg; m++)
- OscCoeff(n,m) = cachepoles(n,m+1) ;
- }
- else
- {
- for(n = 1; n <= udeg + 1; n++)
- for(m = 1; m <= vdeg; m++)
- OscCoeff(n,m) = cachepoles(m+1,n) ;
- }
- if (IsVNegative) PLib::VTrimming(-1,0,OscCoeff,PLib::NoWeights2());
-
- index=1;
- for(n = 1; n <= udeg + 1; n++)
- for(m = 1; m <= vdeg; m++)
- {
- Coefficients->ChangeValue(index++) = OscCoeff(n,m).X();
- Coefficients->ChangeValue(index++) = OscCoeff(n,m).Y();
- Coefficients->ChangeValue(index++) = OscCoeff(n,m).Z();
- }
- }
-
- if (IsAlongV())
- {
- if (udeg > vdeg)
- {
- for(n = 1; n <= udeg; n++)
- for(m = 1; m <= vdeg + 1; m++)
- OscCoeff(n,m) = cachepoles(n+1,m);
- }
- else
- {
- for(n = 1; n <= udeg; n++)
- for(m = 1; m <= vdeg + 1; m++)
- OscCoeff(n,m) = cachepoles(m,n+1);
- }
- if (IsUNegative) PLib::UTrimming(-1,0,OscCoeff,PLib::NoWeights2());
- index=1;
- for(n = 1; n <= udeg; n++)
- for(m = 1; m <= vdeg + 1; m++)
- {
- Coefficients->ChangeValue(index++) = OscCoeff(n,m).X();
- Coefficients->ChangeValue(index++) = OscCoeff(n,m).Y();
- Coefficients->ChangeValue(index++) = OscCoeff(n,m).Z();
- }
- }
-
- if (IsAlongU()) MaxVDegree--;
- if (IsAlongV()) MaxUDegree--;
- UContinuity = - 1;
- VContinuity = - 1;
-
- Convert_GridPolynomialToPoles Data(1,1,
- UContinuity,
- VContinuity,
- MaxUDegree,
- MaxVDegree,
- NumCoeffPerSurface,
- Coefficients,
- PolynomialUIntervals,
- PolynomialVIntervals,
- TrueUIntervals,
- TrueVIntervals);
-
-// Handle(Geom_BSplineSurface) BSpl =
- BSpl =new Geom_BSplineSurface(Data.Poles()->Array2(),
- Data.UKnots()->Array1(),
- Data.VKnots()->Array1(),
- Data.UMultiplicities()->Array1(),
- Data.VMultiplicities()->Array1(),
- Data.UDegree(),
- Data.VDegree(),
- 0, 0);
+ if (IsVNegative) PLib::VTrimming(-1,0,OscCoeff,PLib::NoWeights2());
+
+ index=1;
+ for(n = 1; n <= udeg + 1; n++)
+ for(m = 1; m <= vdeg; m++)
+ {
+ Coefficients->ChangeValue(index++) = OscCoeff(n,m).X();
+ Coefficients->ChangeValue(index++) = OscCoeff(n,m).Y();
+ Coefficients->ChangeValue(index++) = OscCoeff(n,m).Z();
+ }
+ }
+
+ if (IsAlongV())
+ {
+ if (udeg > vdeg)
+ {
+ for(n = 1; n <= udeg; n++)
+ for(m = 1; m <= vdeg + 1; m++)
+ OscCoeff(n,m) = cachepoles(n+1,m);
+ }
+ else
+ {
+ for(n = 1; n <= udeg; n++)
+ for(m = 1; m <= vdeg + 1; m++)
+ OscCoeff(n,m) = cachepoles(m,n+1);
+ }
+ if (IsUNegative) PLib::UTrimming(-1,0,OscCoeff,PLib::NoWeights2());
+ index=1;
+ for(n = 1; n <= udeg; n++)
+ for(m = 1; m <= vdeg + 1; m++)
+ {
+ Coefficients->ChangeValue(index++) = OscCoeff(n,m).X();
+ Coefficients->ChangeValue(index++) = OscCoeff(n,m).Y();
+ Coefficients->ChangeValue(index++) = OscCoeff(n,m).Z();
+ }
+ }
+
+ if (IsAlongU()) MaxVDegree--;
+ if (IsAlongV()) MaxUDegree--;
+ UContinuity = - 1;
+ VContinuity = - 1;
+
+ Convert_GridPolynomialToPoles Data(1,1,
+ UContinuity,
+ VContinuity,
+ MaxUDegree,
+ MaxVDegree,
+ NumCoeffPerSurface,
+ Coefficients,
+ PolynomialUIntervals,
+ PolynomialVIntervals,
+ TrueUIntervals,
+ TrueVIntervals);
+
+ // Handle(Geom_BSplineSurface) BSpl =
+ BSpl =new Geom_BSplineSurface(Data.Poles()->Array2(),
+ Data.UKnots()->Array1(),
+ Data.VKnots()->Array1(),
+ Data.UMultiplicities()->Array1(),
+ Data.VMultiplicities()->Array1(),
+ Data.UDegree(),
+ Data.VDegree(),
+ 0, 0);
#ifdef OCCT_DEBUG
- cout<<"^====================================^"<<endl<<endl;
+ cout<<"^====================================^"<<endl<<endl;
#endif
-// L=BSpl;
- }
+ // L=BSpl;
+ }
return OsculSurf;
}
//=======================================================================
Standard_Boolean Geom_OsculatingSurface::IsQPunctual
- (const Handle(Geom_Surface)& S,
- const Standard_Real Param,
- const GeomAbs_IsoType IT,
- const Standard_Real TolMin,
- const Standard_Real TolMax) const
+ (const Handle(Geom_Surface)& S,
+ const Standard_Real Param,
+ const GeomAbs_IsoType IT,
+ const Standard_Real TolMin,
+ const Standard_Real TolMax) const
{
- Standard_Real U1=0,U2=0,V1=0,V2=0,T;
- Standard_Boolean Along = Standard_True;
- S->Bounds(U1,U2,V1,V2);
- gp_Vec D1U,D1V;
- gp_Pnt P;
- Standard_Real Step,D1NormMax;
- if (IT == GeomAbs_IsoV)
+ Standard_Real U1=0,U2=0,V1=0,V2=0,T;
+ Standard_Boolean Along = Standard_True;
+ S->Bounds(U1,U2,V1,V2);
+ gp_Vec D1U,D1V;
+ gp_Pnt P;
+ Standard_Real Step,D1NormMax;
+ if (IT == GeomAbs_IsoV)
+ {
+ Step = (U2 - U1)/10;
+ D1NormMax=0.;
+ for (T=U1;T<=U2;T=T+Step)
{
- Step = (U2 - U1)/10;
- D1NormMax=0.;
- for (T=U1;T<=U2;T=T+Step)
- {
- S->D1(T,Param,P,D1U,D1V);
- D1NormMax=Max(D1NormMax,D1U.Magnitude());
- }
+ S->D1(T,Param,P,D1U,D1V);
+ D1NormMax=Max(D1NormMax,D1U.Magnitude());
+ }
#ifdef OCCT_DEBUG
- cout << " D1NormMax = " << D1NormMax << endl;
+ cout << " D1NormMax = " << D1NormMax << endl;
#endif
- if (D1NormMax >TolMax || D1NormMax < TolMin )
- Along = Standard_False;
- }
- else
+ if (D1NormMax >TolMax || D1NormMax < TolMin )
+ Along = Standard_False;
+ }
+ else
+ {
+ Step = (V2 - V1)/10;
+ D1NormMax=0.;
+ for (T=V1;T<=V2;T=T+Step)
{
- Step = (V2 - V1)/10;
- D1NormMax=0.;
- for (T=V1;T<=V2;T=T+Step)
- {
- S->D1(Param,T,P,D1U,D1V);
- D1NormMax=Max(D1NormMax,D1V.Magnitude());
- }
+ S->D1(Param,T,P,D1U,D1V);
+ D1NormMax=Max(D1NormMax,D1V.Magnitude());
+ }
#ifdef OCCT_DEBUG
- cout << " D1NormMax = " << D1NormMax << endl;
+ cout << " D1NormMax = " << D1NormMax << endl;
#endif
- if (D1NormMax >TolMax || D1NormMax < TolMin )
- Along = Standard_False;
+ if (D1NormMax >TolMax || D1NormMax < TolMin )
+ Along = Standard_False;
- }
- return Along;
+ }
+ return Along;
}
//=======================================================================
//purpose :
//=======================================================================
- Standard_Boolean Geom_OsculatingSurface::HasOscSurf() const
+Standard_Boolean Geom_OsculatingSurface::HasOscSurf() const
{
return (myAlong(1) || myAlong(2) || myAlong(3) || myAlong(4));
}
void Geom_OsculatingSurface::ClearOsculFlags()
{
- myAlong.SetValue(1,Standard_False);
- myAlong.SetValue(2,Standard_False);
- myAlong.SetValue(3,Standard_False);
- myAlong.SetValue(4,Standard_False);
+ myAlong.SetValue(1,Standard_False);
+ myAlong.SetValue(2,Standard_False);
+ myAlong.SetValue(3,Standard_False);
+ myAlong.SetValue(4,Standard_False);
}
projects / occt-copy.git / commitdiff