src/Adaptor3d/Adaptor3d_HSurfaceTool.lxx

   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
   8 // under the terms of the GNU Lesser General Public 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 }