// 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());
}