// Created by: Laurent BUCHARD
// Copyright (c) 1993-1999 Matra Datavision
// Copyright (c) 1999-2012 OPEN CASCADE SAS
//
// The content of this file is subject to the Open CASCADE Technology Public
// License Version 6.5 (the "License"). You may not use the content of this file
// except in compliance with the License. Please obtain a copy of the License
// at http://www.opencascade.org and read it completely before using this file.
//
// The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
// main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
//
// The Original Code and all software distributed under the License is
// distributed on an "AS IS" basis, without warranty of any kind, and the
// Initial Developer hereby disclaims all such warranties, including without
// limitation, any warranties of merchantability, fitness for a particular
// purpose or non-infringement. Please see the License for the specific terms
// and conditions governing the rights and limitations under the License.


#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 <Handle_Geom_BezierSurface.hxx>
#include <Handle_Geom_BSplineSurface.hxx>
#include <Handle_Adaptor3d_HSurface.hxx>
#include <Handle_Adaptor3d_HCurve.hxx>


inline Standard_Real Adaptor3d_HSurfaceTool::FirstUParameter(const Handle(Adaptor3d_HSurface)& Surf)
{
  return Surf->FirstUParameter();
}

inline Standard_Real Adaptor3d_HSurfaceTool::FirstVParameter(const Handle(Adaptor3d_HSurface)& Surf)
{
  return Surf->FirstVParameter();
}

inline Standard_Real Adaptor3d_HSurfaceTool::LastUParameter(const Handle(Adaptor3d_HSurface)& Surf)
{
  return Surf->LastUParameter();
}

inline Standard_Real Adaptor3d_HSurfaceTool::LastVParameter(const Handle(Adaptor3d_HSurface)& Surf)
{
  return Surf->LastVParameter();
}

inline Standard_Integer Adaptor3d_HSurfaceTool::NbUIntervals(const Handle(Adaptor3d_HSurface)& Surf, const GeomAbs_Shape S)
{
  return Surf->NbUIntervals(S);
}

inline Standard_Integer Adaptor3d_HSurfaceTool::NbVIntervals(const Handle(Adaptor3d_HSurface)& Surf, const GeomAbs_Shape S)
{
  return Surf->NbVIntervals(S);
}

inline void Adaptor3d_HSurfaceTool::UIntervals(const Handle(Adaptor3d_HSurface)& Surf,
                                               TColStd_Array1OfReal& Tab,
                                               const GeomAbs_Shape S)
{
  Surf->UIntervals(Tab,S);
}

inline void Adaptor3d_HSurfaceTool::VIntervals(const Handle(Adaptor3d_HSurface)& Surf,
                                               TColStd_Array1OfReal& Tab,
                                               const GeomAbs_Shape S)
{
  Surf->VIntervals(Tab,S);
}

inline Handle_Adaptor3d_HSurface Adaptor3d_HSurfaceTool::UTrim(const Handle(Adaptor3d_HSurface)& Surf,
                                                               const Standard_Real F,
                                                               const Standard_Real L,
                                                               const Standard_Real Tol)
{
  return Surf->UTrim(F,L,Tol);
}

inline Handle_Adaptor3d_HSurface Adaptor3d_HSurfaceTool::VTrim(const Handle(Adaptor3d_HSurface)& Surf,
                                                               const Standard_Real F,
                                                               const Standard_Real L,
                                                               const Standard_Real Tol)
{
  return Surf->VTrim(F,L,Tol);
}

inline Standard_Boolean Adaptor3d_HSurfaceTool::IsUClosed(const Handle(Adaptor3d_HSurface)& S)
{
  return S->IsUClosed();
}

inline Standard_Boolean Adaptor3d_HSurfaceTool::IsVClosed(const Handle(Adaptor3d_HSurface)& S)
{
  return S->IsVClosed();
}

inline Standard_Boolean Adaptor3d_HSurfaceTool::IsUPeriodic(const Handle(Adaptor3d_HSurface)& S)
{
  return S->IsUPeriodic();
}

inline Standard_Real Adaptor3d_HSurfaceTool::UPeriod(const Handle(Adaptor3d_HSurface)& S)
{
  return S->UPeriod();
}

inline Standard_Boolean Adaptor3d_HSurfaceTool::IsVPeriodic(const Handle(Adaptor3d_HSurface)& S)
{
  return S->IsVPeriodic();
}

inline Standard_Real Adaptor3d_HSurfaceTool::VPeriod(const Handle(Adaptor3d_HSurface)& S)
{
  return S->VPeriod();
}

inline gp_Pnt Adaptor3d_HSurfaceTool::Value(const Handle(Adaptor3d_HSurface)& S,
                                            const Standard_Real U,
                                            const Standard_Real V )
{
  return S->Value(U,V);
}

inline void Adaptor3d_HSurfaceTool::D0(const Handle(Adaptor3d_HSurface)& S,
                                       const Standard_Real U,
                                       const Standard_Real V,
                                       gp_Pnt& P)
{
  S->D0(U,V,P);
}

inline void Adaptor3d_HSurfaceTool::D1(const Handle(Adaptor3d_HSurface)& 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);
}

inline void Adaptor3d_HSurfaceTool::D2(const Handle(Adaptor3d_HSurface)& 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);
}

inline void Adaptor3d_HSurfaceTool::D3(const Handle(Adaptor3d_HSurface)& 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);
}

inline gp_Vec Adaptor3d_HSurfaceTool::DN(const Handle(Adaptor3d_HSurface)& S,
                                         const Standard_Real U,
                                         const Standard_Real V,
                                         const Standard_Integer Nu,
                                         const Standard_Integer Nv)
{
  return S->DN(U,V,Nu,Nv);
}

inline Standard_Real Adaptor3d_HSurfaceTool::UResolution(const Handle(Adaptor3d_HSurface)& S,
                                                         const Standard_Real R3d)
{
  return S->UResolution(R3d);
}

inline Standard_Real Adaptor3d_HSurfaceTool::VResolution(const Handle(Adaptor3d_HSurface)& S,
                                                         const Standard_Real R3d)
{
  return S->VResolution(R3d);
}

inline GeomAbs_SurfaceType Adaptor3d_HSurfaceTool::GetType(const Handle(Adaptor3d_HSurface)& S )
{
  return S->GetType();
}

inline gp_Pln Adaptor3d_HSurfaceTool::Plane(const Handle(Adaptor3d_HSurface)& S)
{
  return S->Plane();
}

inline gp_Cylinder Adaptor3d_HSurfaceTool::Cylinder(const Handle(Adaptor3d_HSurface)& S) 
{
  return S->Cylinder();
}

inline gp_Cone Adaptor3d_HSurfaceTool::Cone(const Handle(Adaptor3d_HSurface)& S) 
{
  return S->Cone();
}

inline gp_Sphere Adaptor3d_HSurfaceTool::Sphere(const Handle(Adaptor3d_HSurface)& S) 
{
  return S->Sphere();
}

inline gp_Torus Adaptor3d_HSurfaceTool::Torus(const Handle(Adaptor3d_HSurface)& S) 
{
  return S->Torus();
}

inline Handle(Geom_BezierSurface) Adaptor3d_HSurfaceTool::Bezier(const Handle(Adaptor3d_HSurface)& S)
{ 
  return(S->Bezier());
}

inline Handle(Geom_BSplineSurface) Adaptor3d_HSurfaceTool::BSpline(const Handle(Adaptor3d_HSurface)& S)
{ 
  return(S->BSpline());
}

inline gp_Ax1  Adaptor3d_HSurfaceTool::AxeOfRevolution(const Handle(Adaptor3d_HSurface)& S)
{ 
  return(S->AxeOfRevolution());
}

inline gp_Dir  Adaptor3d_HSurfaceTool::Direction(const Handle(Adaptor3d_HSurface)& S)
{
  return(S->Direction());
}

inline Handle(Adaptor3d_HCurve)  Adaptor3d_HSurfaceTool::BasisCurve(const Handle(Adaptor3d_HSurface)& S)
{
  return(S->BasisCurve());
}

inline Handle(Adaptor3d_HSurface) Adaptor3d_HSurfaceTool::BasisSurface(const Handle(Adaptor3d_HSurface)& S)
{
  return(S->BasisSurface());
}

inline Standard_Real Adaptor3d_HSurfaceTool::OffsetValue(const Handle(Adaptor3d_HSurface)& S)
{
  return(S->OffsetValue());
}