[occt.git] / 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 <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());
}
Commit	Line	Data
	1	// Created by: Laurent BUCHARD
	2	// Copyright (c) 1993-1999 Matra Datavision
	3	// Copyright (c) 1999-2014 OPEN CASCADE SAS
	4	//
	5	// This file is part of Open CASCADE Technology software library.
	6	//
	7	// This library is free software; you can redistribute it and/or modify it under
	8	// the terms of the GNU Lesser General Public License version 2.1 as published
	9	// by the Free Software Foundation, with special exception defined in the file
	10	// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
	11	// distribution for complete text of the license and disclaimer of any warranty.
	12	//
	13	// Alternatively, this file may be used under the terms of Open CASCADE
	14	// commercial license or contractual agreement.
	15
	16	#include <gp_Pnt.hxx>
	17	#include <gp_Vec.hxx>
	18	#include <gp_Pln.hxx>
	19	#include <gp_Cylinder.hxx>
	20	#include <gp_Cone.hxx>
	21	#include <gp_Torus.hxx>
	22	#include <gp_Sphere.hxx>
	23	#include <gp_Ax1.hxx>
	24	#include <gp_Dir.hxx>
	25	#include <Handle_Geom_BezierSurface.hxx>
	26	#include <Handle_Geom_BSplineSurface.hxx>
	27	#include <Handle_Adaptor3d_HSurface.hxx>
	28	#include <Handle_Adaptor3d_HCurve.hxx>
	29
	30
	31	inline Standard_Real Adaptor3d_HSurfaceTool::FirstUParameter(const Handle(Adaptor3d_HSurface)& Surf)
	32	{
	33	return Surf->FirstUParameter();
	34	}
	35
	36	inline Standard_Real Adaptor3d_HSurfaceTool::FirstVParameter(const Handle(Adaptor3d_HSurface)& Surf)
	37	{
	38	return Surf->FirstVParameter();
	39	}
	40
	41	inline Standard_Real Adaptor3d_HSurfaceTool::LastUParameter(const Handle(Adaptor3d_HSurface)& Surf)
	42	{
	43	return Surf->LastUParameter();
	44	}
	45
	46	inline Standard_Real Adaptor3d_HSurfaceTool::LastVParameter(const Handle(Adaptor3d_HSurface)& Surf)
	47	{
	48	return Surf->LastVParameter();
	49	}
	50
	51	inline Standard_Integer Adaptor3d_HSurfaceTool::NbUIntervals(const Handle(Adaptor3d_HSurface)& Surf, const GeomAbs_Shape S)
	52	{
	53	return Surf->NbUIntervals(S);
	54	}
	55
	56	inline Standard_Integer Adaptor3d_HSurfaceTool::NbVIntervals(const Handle(Adaptor3d_HSurface)& Surf, const GeomAbs_Shape S)
	57	{
	58	return Surf->NbVIntervals(S);
	59	}
	60
	61	inline void Adaptor3d_HSurfaceTool::UIntervals(const Handle(Adaptor3d_HSurface)& Surf,
	62	TColStd_Array1OfReal& Tab,
	63	const GeomAbs_Shape S)
	64	{
	65	Surf->UIntervals(Tab,S);
	66	}
	67
	68	inline void Adaptor3d_HSurfaceTool::VIntervals(const Handle(Adaptor3d_HSurface)& Surf,
	69	TColStd_Array1OfReal& Tab,
	70	const GeomAbs_Shape S)
	71	{
	72	Surf->VIntervals(Tab,S);
	73	}
	74
	75	inline Handle_Adaptor3d_HSurface Adaptor3d_HSurfaceTool::UTrim(const Handle(Adaptor3d_HSurface)& Surf,
	76	const Standard_Real F,
	77	const Standard_Real L,
	78	const Standard_Real Tol)
	79	{
	80	return Surf->UTrim(F,L,Tol);
	81	}
	82
	83	inline Handle_Adaptor3d_HSurface Adaptor3d_HSurfaceTool::VTrim(const Handle(Adaptor3d_HSurface)& Surf,
	84	const Standard_Real F,
	85	const Standard_Real L,
	86	const Standard_Real Tol)
	87	{
	88	return Surf->VTrim(F,L,Tol);
	89	}
	90
	91	inline Standard_Boolean Adaptor3d_HSurfaceTool::IsUClosed(const Handle(Adaptor3d_HSurface)& S)
	92	{
	93	return S->IsUClosed();
	94	}
	95
	96	inline Standard_Boolean Adaptor3d_HSurfaceTool::IsVClosed(const Handle(Adaptor3d_HSurface)& S)
	97	{
	98	return S->IsVClosed();
	99	}
	100
	101	inline Standard_Boolean Adaptor3d_HSurfaceTool::IsUPeriodic(const Handle(Adaptor3d_HSurface)& S)
	102	{
	103	return S->IsUPeriodic();
	104	}
	105
	106	inline Standard_Real Adaptor3d_HSurfaceTool::UPeriod(const Handle(Adaptor3d_HSurface)& S)
	107	{
	108	return S->UPeriod();
	109	}
	110
	111	inline Standard_Boolean Adaptor3d_HSurfaceTool::IsVPeriodic(const Handle(Adaptor3d_HSurface)& S)
	112	{
	113	return S->IsVPeriodic();
	114	}
	115
	116	inline Standard_Real Adaptor3d_HSurfaceTool::VPeriod(const Handle(Adaptor3d_HSurface)& S)
	117	{
	118	return S->VPeriod();
	119	}
	120
	121	inline gp_Pnt Adaptor3d_HSurfaceTool::Value(const Handle(Adaptor3d_HSurface)& S,
	122	const Standard_Real U,
	123	const Standard_Real V )
	124	{
	125	return S->Value(U,V);
	126	}
	127
	128	inline void Adaptor3d_HSurfaceTool::D0(const Handle(Adaptor3d_HSurface)& S,
	129	const Standard_Real U,
	130	const Standard_Real V,
	131	gp_Pnt& P)
	132	{
	133	S->D0(U,V,P);
	134	}
	135
	136	inline void Adaptor3d_HSurfaceTool::D1(const Handle(Adaptor3d_HSurface)& S,
	137	const Standard_Real U,
	138	const Standard_Real V,
	139	gp_Pnt& P,
	140	gp_Vec& D1U,
	141	gp_Vec& D1V)
	142	{
	143	S->D1(U,V,P,D1U,D1V);
	144	}
	145
	146	inline void Adaptor3d_HSurfaceTool::D2(const Handle(Adaptor3d_HSurface)& S,
	147	const Standard_Real U,
	148	const Standard_Real V,
	149	gp_Pnt& P,
	150	gp_Vec& D1U,
	151	gp_Vec& D1V,
	152	gp_Vec& D2U,
	153	gp_Vec& D2V,
	154	gp_Vec& D2UV)
	155	{
	156	S->D2(U,V,P,D1U,D1V,D2U,D2V,D2UV);
	157	}
	158
	159	inline void Adaptor3d_HSurfaceTool::D3(const Handle(Adaptor3d_HSurface)& S,
	160	const Standard_Real U,
	161	const Standard_Real V,
	162	gp_Pnt& P,
	163	gp_Vec& D1U,
	164	gp_Vec& D1V,
	165	gp_Vec& D2U,
	166	gp_Vec& D2V,
	167	gp_Vec& D2UV,
	168	gp_Vec& D3U,
	169	gp_Vec& D3V,
	170	gp_Vec& D3UUV,
	171	gp_Vec& D3UVV)
	172	{
	173	S->D3(U,V,P,D1U,D1V,D2U,D2V,D2UV,D3U,D3V,D3UUV,D3UVV);
	174	}
	175
	176	inline gp_Vec Adaptor3d_HSurfaceTool::DN(const Handle(Adaptor3d_HSurface)& S,
	177	const Standard_Real U,
	178	const Standard_Real V,
	179	const Standard_Integer Nu,
	180	const Standard_Integer Nv)
	181	{
	182	return S->DN(U,V,Nu,Nv);
	183	}
	184
	185	inline Standard_Real Adaptor3d_HSurfaceTool::UResolution(const Handle(Adaptor3d_HSurface)& S,
	186	const Standard_Real R3d)
	187	{
	188	return S->UResolution(R3d);
	189	}
	190
	191	inline Standard_Real Adaptor3d_HSurfaceTool::VResolution(const Handle(Adaptor3d_HSurface)& S,
	192	const Standard_Real R3d)
	193	{
	194	return S->VResolution(R3d);
	195	}
	196
	197	inline GeomAbs_SurfaceType Adaptor3d_HSurfaceTool::GetType(const Handle(Adaptor3d_HSurface)& S )
	198	{
	199	return S->GetType();
	200	}
	201
	202	inline gp_Pln Adaptor3d_HSurfaceTool::Plane(const Handle(Adaptor3d_HSurface)& S)
	203	{
	204	return S->Plane();
	205	}
	206
	207	inline gp_Cylinder Adaptor3d_HSurfaceTool::Cylinder(const Handle(Adaptor3d_HSurface)& S)
	208	{
	209	return S->Cylinder();
	210	}
	211
	212	inline gp_Cone Adaptor3d_HSurfaceTool::Cone(const Handle(Adaptor3d_HSurface)& S)
	213	{
	214	return S->Cone();
	215	}
	216
	217	inline gp_Sphere Adaptor3d_HSurfaceTool::Sphere(const Handle(Adaptor3d_HSurface)& S)
	218	{
	219	return S->Sphere();
	220	}
	221
	222	inline gp_Torus Adaptor3d_HSurfaceTool::Torus(const Handle(Adaptor3d_HSurface)& S)
	223	{
	224	return S->Torus();
	225	}
	226
	227	inline Handle(Geom_BezierSurface) Adaptor3d_HSurfaceTool::Bezier(const Handle(Adaptor3d_HSurface)& S)
	228	{
	229	return(S->Bezier());
	230	}
	231
	232	inline Handle(Geom_BSplineSurface) Adaptor3d_HSurfaceTool::BSpline(const Handle(Adaptor3d_HSurface)& S)
	233	{
	234	return(S->BSpline());
	235	}
	236
	237	inline gp_Ax1 Adaptor3d_HSurfaceTool::AxeOfRevolution(const Handle(Adaptor3d_HSurface)& S)
	238	{
	239	return(S->AxeOfRevolution());
	240	}
	241
	242	inline gp_Dir Adaptor3d_HSurfaceTool::Direction(const Handle(Adaptor3d_HSurface)& S)
	243	{
	244	return(S->Direction());
	245	}
	246
	247	inline Handle(Adaptor3d_HCurve) Adaptor3d_HSurfaceTool::BasisCurve(const Handle(Adaptor3d_HSurface)& S)
	248	{
	249	return(S->BasisCurve());
	250	}
	251
	252	inline Handle(Adaptor3d_HSurface) Adaptor3d_HSurfaceTool::BasisSurface(const Handle(Adaptor3d_HSurface)& S)
	253	{
	254	return(S->BasisSurface());
	255	}
	256
	257	inline Standard_Real Adaptor3d_HSurfaceTool::OffsetValue(const Handle(Adaptor3d_HSurface)& S)
	258	{
	259	return(S->OffsetValue());
	260	}