occt/src/Adaptor3d/Adaptor3d_HSurfaceTool.lxx

// 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_HSurface.hxx>
#include <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());
}