// Created by: Laurent BUCHARD
// Copyright (c) 1993-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.

#include <gp_Pnt.hxx>
#include <gp_Vec.hxx>
#include <gp_Pln.hxx>
#include <gp_Cylinder.hxx>
#include <gp_Cone.hxx>
#include <gp_Torus.hxx>
#include <gp_Sphere.hxx>
#include <gp_Ax1.hxx>
#include <gp_Dir.hxx>
#include <Geom_BezierSurface.hxx>
#include <Geom_BSplineSurface.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor3d_Curve.hxx>
#include <BRepAdaptor_Surface.hxx>

//=======================================================================
//function : FirstUParameter
//purpose  : 
//=======================================================================

inline Standard_Real
HLRBRep_BSurfaceTool::FirstUParameter(const BRepAdaptor_Surface& Surf)
{ return Surf.FirstUParameter(); }

//=======================================================================
//function : FirstVParameter
//purpose  : 
//=======================================================================

inline Standard_Real
HLRBRep_BSurfaceTool::FirstVParameter(const BRepAdaptor_Surface& Surf)
{ return Surf.FirstVParameter(); }

//=======================================================================
//function : LastUParameter
//purpose  :
//=======================================================================

inline Standard_Real
HLRBRep_BSurfaceTool::LastUParameter(const BRepAdaptor_Surface& Surf)
{ return Surf.LastUParameter(); }

//=======================================================================
//function : LastVParameter
//purpose  : 
//=======================================================================

inline Standard_Real
HLRBRep_BSurfaceTool::LastVParameter(const BRepAdaptor_Surface& Surf)
{ return Surf.LastVParameter(); }

//=======================================================================
//function : NbUIntervals
//purpose  : 
//=======================================================================

inline Standard_Integer
HLRBRep_BSurfaceTool::NbUIntervals(const BRepAdaptor_Surface& Surf,
				   const GeomAbs_Shape S)
{ return Surf.NbUIntervals(S); }

//=======================================================================
//function : NbVIntervals
//purpose  : 
//=======================================================================

inline Standard_Integer
HLRBRep_BSurfaceTool::NbVIntervals(const BRepAdaptor_Surface& Surf,
				   const GeomAbs_Shape S)
{ return Surf.NbVIntervals(S); }

//=======================================================================
//function : UIntervals
//purpose  : 
//=======================================================================

inline void
HLRBRep_BSurfaceTool::UIntervals(const BRepAdaptor_Surface& Surf,
				 TColStd_Array1OfReal& Tab,
				 const GeomAbs_Shape S)
{ Surf.UIntervals(Tab,S); }

//=======================================================================
//function : VIntervals
//purpose  : 
//=======================================================================

inline void
HLRBRep_BSurfaceTool::VIntervals(const BRepAdaptor_Surface& Surf,
				 TColStd_Array1OfReal& Tab,
				 const GeomAbs_Shape S)
{ Surf.VIntervals(Tab,S); }


//=======================================================================
//function : UTrim
//purpose  : 
//=======================================================================

inline Handle(Adaptor3d_Surface)
HLRBRep_BSurfaceTool::UTrim(const BRepAdaptor_Surface& Surf,
			    const Standard_Real F,
			    const Standard_Real L,
			    const Standard_Real Tol)
{ return Surf.UTrim(F,L,Tol); }

//=======================================================================
//function : VTrim
//purpose  : 
//=======================================================================

inline Handle(Adaptor3d_Surface)
HLRBRep_BSurfaceTool::VTrim(const BRepAdaptor_Surface& Surf,
			    const Standard_Real F,
			    const Standard_Real L,
			    const Standard_Real Tol)
{ return Surf.VTrim(F,L,Tol); }

//=======================================================================
//function : IsUClosed
//purpose  : 
//=======================================================================

inline Standard_Boolean
HLRBRep_BSurfaceTool::IsUClosed(const BRepAdaptor_Surface& S)
{ return S.IsUClosed(); }

//=======================================================================
//function : IsVClosed
//purpose  : 
//=======================================================================

inline Standard_Boolean
HLRBRep_BSurfaceTool::IsVClosed(const BRepAdaptor_Surface& S)
{ return S.IsVClosed(); }

//=======================================================================
//function : IsUPeriodic
//purpose  : 
//=======================================================================

inline Standard_Boolean
HLRBRep_BSurfaceTool::IsUPeriodic(const BRepAdaptor_Surface& S)
{ return S.IsUPeriodic(); }

//=======================================================================
//function : UPeriod
//purpose  : 
//=======================================================================

inline Standard_Real
HLRBRep_BSurfaceTool::UPeriod(const BRepAdaptor_Surface& S)
{ return S.UPeriod(); }

//=======================================================================
//function : IsVPeriodic
//purpose  : 
//=======================================================================

inline Standard_Boolean
HLRBRep_BSurfaceTool::IsVPeriodic(const BRepAdaptor_Surface& S)
{ return S.IsVPeriodic(); }

//=======================================================================
//function : VPeriod
//purpose  : 
//=======================================================================

inline Standard_Real
HLRBRep_BSurfaceTool::VPeriod(const BRepAdaptor_Surface& S)
{ return S.VPeriod(); }

//=======================================================================
//function : Value
//purpose  : 
//=======================================================================

inline gp_Pnt
HLRBRep_BSurfaceTool::Value(const BRepAdaptor_Surface& S,
			    const Standard_Real U,
			    const Standard_Real V )
{ return S.Value(U,V); }

//=======================================================================
//function : D0
//purpose  : 
//=======================================================================

inline void
HLRBRep_BSurfaceTool::D0(const BRepAdaptor_Surface& S,
			 const Standard_Real U,
			 const Standard_Real V,
			 gp_Pnt& P)
{ S.D0(U,V,P); }

//=======================================================================
//function : D1
//purpose  : 
//=======================================================================

inline void
HLRBRep_BSurfaceTool::D1(const 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); }

//=======================================================================
//function : D2
//purpose  : 
//=======================================================================

inline void
HLRBRep_BSurfaceTool::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)
{ S.D2(U,V,P,D1U,D1V,D2U,D2V,D2UV); }

//=======================================================================
//function : D3
//purpose  : 
//=======================================================================

inline void
HLRBRep_BSurfaceTool::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)
{ S.D3(U,V,P,D1U,D1V,D2U,D2V,D2UV,D3U,D3V,D3UUV,D3UVV); }

//=======================================================================
//function : DN
//purpose  : 
//=======================================================================

inline gp_Vec
HLRBRep_BSurfaceTool::DN(const 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); }

//=======================================================================
//function : UResolution
//purpose  : 
//=======================================================================

inline Standard_Real
HLRBRep_BSurfaceTool::UResolution(const BRepAdaptor_Surface& S,
				  const Standard_Real R3d)
{ return S.UResolution(R3d); }

//=======================================================================
//function : VResolution
//purpose  : 
//=======================================================================

inline Standard_Real
HLRBRep_BSurfaceTool::VResolution(const BRepAdaptor_Surface& S,
				  const Standard_Real R3d)
{ return S.VResolution(R3d); }

//=======================================================================
//function : GetType
//purpose  : 
//=======================================================================

inline GeomAbs_SurfaceType
HLRBRep_BSurfaceTool::GetType(const BRepAdaptor_Surface& S )
{ return S.GetType(); }

//=======================================================================
//function : Plane
//purpose  : 
//=======================================================================

inline gp_Pln
HLRBRep_BSurfaceTool::Plane(const BRepAdaptor_Surface& S)
{ return S.Plane(); }

//=======================================================================
//function : Cylinder
//purpose  : 
//=======================================================================

inline gp_Cylinder
HLRBRep_BSurfaceTool::Cylinder(const BRepAdaptor_Surface& S) 
{ return S.Cylinder(); }

//=======================================================================
//function : Cone
//purpose  : 
//=======================================================================

inline gp_Cone
HLRBRep_BSurfaceTool::Cone(const BRepAdaptor_Surface& S) 
{ return S.Cone(); }

//=======================================================================
//function : Sphere
//purpose  : 
//=======================================================================

inline gp_Sphere
HLRBRep_BSurfaceTool::Sphere(const BRepAdaptor_Surface& S) 
{ return S.Sphere(); }

//=======================================================================
//function : Torus
//purpose  : 
//=======================================================================

inline gp_Torus
HLRBRep_BSurfaceTool::Torus(const BRepAdaptor_Surface& S) 
{ return S.Torus(); }

//=======================================================================
//function : Bezier
//purpose  : 
//=======================================================================

inline Handle(Geom_BezierSurface)
     HLRBRep_BSurfaceTool::Bezier(const BRepAdaptor_Surface& S)
{ return(S.Bezier()); }

//=======================================================================
//function : BSpline
//purpose  : 
//=======================================================================

inline Handle(Geom_BSplineSurface)
     HLRBRep_BSurfaceTool::BSpline(const BRepAdaptor_Surface& S)
{ return(S.BSpline()); }

//=======================================================================
//function : AxeOfRevolution
//purpose  : 
//=======================================================================

inline gp_Ax1
HLRBRep_BSurfaceTool::AxeOfRevolution(const BRepAdaptor_Surface& S)
{ return(S.AxeOfRevolution()); }

//=======================================================================
//function : Direction
//purpose  : 
//=======================================================================

inline gp_Dir
HLRBRep_BSurfaceTool::Direction(const BRepAdaptor_Surface& S)
{ return(S.Direction()); }

//=======================================================================
//function : BasisCurve
//purpose  : 
//=======================================================================

inline Handle(Adaptor3d_Curve)
     HLRBRep_BSurfaceTool::BasisCurve(const BRepAdaptor_Surface& S)
{ return(S.BasisCurve()); }

//=======================================================================
//function : UContinuity
//purpose  : 
//=======================================================================

inline GeomAbs_Shape
HLRBRep_BSurfaceTool::UContinuity(const BRepAdaptor_Surface& S)
{ return(S.UContinuity()); }

//=======================================================================
//function : VContinuity
//purpose  : 
//=======================================================================

inline GeomAbs_Shape
HLRBRep_BSurfaceTool::VContinuity(const BRepAdaptor_Surface& S)
{ return(S.VContinuity()); }

//=======================================================================
//function : UDegree
//purpose  : 
//=======================================================================

inline Standard_Integer
HLRBRep_BSurfaceTool::UDegree(const BRepAdaptor_Surface& S)
{ return(S.UDegree()); }

//=======================================================================
//function : NbUPoles
//purpose  :
//=======================================================================

inline Standard_Integer
HLRBRep_BSurfaceTool::NbUPoles(const BRepAdaptor_Surface& S)
{ return(S.NbUPoles()); }

//=======================================================================
//function : NbUKnots
//purpose  : 
//=======================================================================

inline Standard_Integer
HLRBRep_BSurfaceTool::NbUKnots(const BRepAdaptor_Surface& S)
{ return(S.NbUKnots()); }

//=======================================================================
//function : IsURational
//purpose  : 
//=======================================================================

inline Standard_Boolean
HLRBRep_BSurfaceTool::IsURational(const BRepAdaptor_Surface& S)
{ return(S.IsURational()); }

//=======================================================================
//function : VDegree
//purpose  : 
//=======================================================================

inline Standard_Integer
HLRBRep_BSurfaceTool::VDegree(const BRepAdaptor_Surface& S)
{ return(S.VDegree()); }

//=======================================================================
//function : NbVPoles
//purpose  : 
//=======================================================================

inline Standard_Integer
HLRBRep_BSurfaceTool::NbVPoles(const BRepAdaptor_Surface& S)
{ return(S.NbVPoles()); }

//=======================================================================
//function : NbVKnots
//purpose  : 
//=======================================================================

inline Standard_Integer
HLRBRep_BSurfaceTool::NbVKnots(const BRepAdaptor_Surface& S)
{ return(S.NbVKnots()); }

//=======================================================================
//function : IsVRational
//purpose  : 
//=======================================================================

inline Standard_Boolean
HLRBRep_BSurfaceTool::IsVRational(const BRepAdaptor_Surface& S)
{ return(S.IsVRational()); }
