include/opencascade/HLRBRep_SurfaceTool.lxx

0001 // Created by: Laurent BUCHARD
0002 // Copyright (c) 1993-1999 Matra Datavision
0003 // Copyright (c) 1999-2014 OPEN CASCADE SAS
0004 //
0005 // This file is part of Open CASCADE Technology software library.
0006 //
0007 // This library is free software; you can redistribute it and/or modify it under
0008 // the terms of the GNU Lesser General Public License version 2.1 as published
0009 // by the Free Software Foundation, with special exception defined in the file
0010 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
0011 // distribution for complete text of the license and disclaimer of any warranty.
0012 //
0013 // Alternatively, this file may be used under the terms of Open CASCADE
0014 // commercial license or contractual agreement.
0015
0016 #include <gp_Pnt.hxx>
0017 #include <gp_Vec.hxx>
0018 #include <gp_Pln.hxx>
0019 #include <gp_Cylinder.hxx>
0020 #include <gp_Cone.hxx>
0021 #include <gp_Torus.hxx>
0022 #include <gp_Sphere.hxx>
0023 #include <gp_Ax1.hxx>
0024 #include <gp_Dir.hxx>
0025 #include <Geom_BezierSurface.hxx>
0026 #include <Geom_BSplineSurface.hxx>
0027 #include <Adaptor3d_Surface.hxx>
0028 #include <Adaptor3d_Curve.hxx>
0029 #include <BRepAdaptor_Surface.hxx>
0030
0031 inline Standard_Real HLRBRep_SurfaceTool::FirstUParameter(const Standard_Address Surf){  return ((BRepAdaptor_Surface *)Surf)->FirstUParameter(); }
0032 inline Standard_Real HLRBRep_SurfaceTool::FirstVParameter(const Standard_Address Surf){  return ((BRepAdaptor_Surface *)Surf)->FirstVParameter();}
0033 inline Standard_Real HLRBRep_SurfaceTool::LastUParameter(const Standard_Address Surf){  return ((BRepAdaptor_Surface *)Surf)->LastUParameter();}
0034 inline Standard_Real HLRBRep_SurfaceTool::LastVParameter(const Standard_Address Surf){  return ((BRepAdaptor_Surface *)Surf)->LastVParameter();}
0035
0036 inline Standard_Integer HLRBRep_SurfaceTool::NbUIntervals(const Standard_Address Surf,
0037                                                           const GeomAbs_Shape S){
0038   return ((BRepAdaptor_Surface *)Surf)->NbUIntervals(S);
0039 }
0040
0041 inline Standard_Integer HLRBRep_SurfaceTool::NbVIntervals(const Standard_Address Surf,
0042                                                           const GeomAbs_Shape S){
0043   return ((BRepAdaptor_Surface *)Surf)->NbVIntervals(S);
0044 }
0045
0046 inline void HLRBRep_SurfaceTool::UIntervals(const Standard_Address Surf,
0047                                                         TColStd_Array1OfReal& Tab,
0048                                                         const GeomAbs_Shape S){
0049   ((BRepAdaptor_Surface *)Surf)->UIntervals(Tab,S);
0050 }
0051
0052 inline void HLRBRep_SurfaceTool::VIntervals(const Standard_Address Surf,
0053                                                      TColStd_Array1OfReal& Tab,
0054                                                      const GeomAbs_Shape S){
0055   ((BRepAdaptor_Surface *)Surf)->VIntervals(Tab,S);
0056 }
0057
0058
0059 inline Handle(Adaptor3d_Surface) HLRBRep_SurfaceTool::UTrim(const Standard_Address Surf,
0060                                                                    const Standard_Real F,
0061                                                                    const Standard_Real L,
0062                                                                    const Standard_Real Tol) {
0063   return ((BRepAdaptor_Surface *)Surf)->UTrim(F,L,Tol);
0064 }
0065
0066 inline Handle(Adaptor3d_Surface) HLRBRep_SurfaceTool::VTrim(const Standard_Address Surf,
0067                                                                    const Standard_Real F,
0068                                                                    const Standard_Real L,
0069                                                                    const Standard_Real Tol) {
0070   return ((BRepAdaptor_Surface *)Surf)->VTrim(F,L,Tol);
0071 }
0072
0073
0074
0075
0076 inline Standard_Boolean HLRBRep_SurfaceTool::IsUClosed(const Standard_Address S)
0077 {
0078   return ((BRepAdaptor_Surface *)S)->IsUClosed();
0079 }
0080
0081 inline Standard_Boolean HLRBRep_SurfaceTool::IsVClosed(const Standard_Address S)
0082 {
0083   return ((BRepAdaptor_Surface *)S)->IsVClosed();
0084 }
0085
0086 inline Standard_Boolean HLRBRep_SurfaceTool::IsUPeriodic(const Standard_Address S)
0087 {
0088   return ((BRepAdaptor_Surface *)S)->IsUPeriodic();
0089 }
0090
0091 inline Standard_Real HLRBRep_SurfaceTool::UPeriod(const Standard_Address S)
0092 {
0093   return ((BRepAdaptor_Surface *)S)->UPeriod();
0094 }
0095
0096 inline Standard_Boolean HLRBRep_SurfaceTool::IsVPeriodic(const Standard_Address S)
0097 {
0098   return ((BRepAdaptor_Surface *)S)->IsVPeriodic();
0099 }
0100
0101 inline Standard_Real HLRBRep_SurfaceTool::VPeriod(const Standard_Address S)
0102 {
0103   return ((BRepAdaptor_Surface *)S)->VPeriod();
0104 }
0105
0106 inline gp_Pnt HLRBRep_SurfaceTool::Value(const Standard_Address S,
0107                                          const Standard_Real U,
0108                                          const Standard_Real V )
0109 {
0110   return ((BRepAdaptor_Surface *)S)->Value(U,V);
0111 }
0112
0113 inline void HLRBRep_SurfaceTool::D0(const Standard_Address S,
0114                                     const Standard_Real U,
0115                                     const Standard_Real V,
0116                                     gp_Pnt& P)
0117 {
0118   ((BRepAdaptor_Surface *)S)->D0(U,V,P);
0119 }
0120
0121 inline void HLRBRep_SurfaceTool::D1(const Standard_Address S,
0122                                     const Standard_Real U,
0123                                     const Standard_Real V,
0124                                     gp_Pnt& P,
0125                                     gp_Vec& D1U,
0126                                     gp_Vec& D1V)
0127 {
0128   ((BRepAdaptor_Surface *)S)->D1(U,V,P,D1U,D1V);
0129 }
0130
0131 inline void HLRBRep_SurfaceTool::D2(const Standard_Address S,
0132                                     const Standard_Real U,
0133                                     const Standard_Real V,
0134                                     gp_Pnt& P,
0135                                     gp_Vec& D1U,
0136                                     gp_Vec& D1V,
0137                                     gp_Vec& D2U,
0138                                     gp_Vec& D2V,
0139                                     gp_Vec& D2UV)
0140 {
0141   ((BRepAdaptor_Surface *)S)->D2(U,V,P,D1U,D1V,D2U,D2V,D2UV);
0142 }
0143
0144 inline void HLRBRep_SurfaceTool::D3(const Standard_Address S,
0145                                     const Standard_Real U,
0146                                     const Standard_Real V,
0147                                     gp_Pnt& P,
0148                                     gp_Vec& D1U,
0149                                     gp_Vec& D1V,
0150                                     gp_Vec& D2U,
0151                                     gp_Vec& D2V,
0152                                     gp_Vec& D2UV,
0153                                     gp_Vec& D3U,
0154                                     gp_Vec& D3V,
0155                                     gp_Vec& D3UUV,
0156                                     gp_Vec& D3UVV)
0157 {
0158   ((BRepAdaptor_Surface *)S)->D3(U,V,P,D1U,D1V,D2U,D2V,D2UV,D3U,D3V,D3UUV,D3UVV);
0159 }
0160
0161 inline gp_Vec HLRBRep_SurfaceTool::DN(const Standard_Address S,
0162                                       const Standard_Real U,
0163                                       const Standard_Real V,
0164                                       const Standard_Integer Nu,
0165                                       const Standard_Integer Nv)
0166 {
0167   return ((BRepAdaptor_Surface *)S)->DN(U,V,Nu,Nv);
0168 }
0169
0170 inline Standard_Real HLRBRep_SurfaceTool::UResolution(const Standard_Address S,
0171                                                       const Standard_Real R3d)
0172 {
0173   return ((BRepAdaptor_Surface *)S)->UResolution(R3d);
0174 }
0175
0176 inline Standard_Real HLRBRep_SurfaceTool::VResolution(const Standard_Address S,
0177                                                       const Standard_Real R3d)
0178 {
0179   return ((BRepAdaptor_Surface *)S)->VResolution(R3d);
0180 }
0181
0182 inline GeomAbs_SurfaceType HLRBRep_SurfaceTool::GetType(const Standard_Address S )
0183 {
0184   return ((BRepAdaptor_Surface *)S)->GetType();
0185 }
0186
0187 inline gp_Pln HLRBRep_SurfaceTool::Plane(const Standard_Address S)
0188 {
0189   return ((BRepAdaptor_Surface *)S)->Plane();
0190 }
0191
0192 inline gp_Cylinder HLRBRep_SurfaceTool::Cylinder(const Standard_Address S)
0193 {
0194   return ((BRepAdaptor_Surface *)S)->Cylinder();
0195 }
0196
0197 inline gp_Cone HLRBRep_SurfaceTool::Cone(const Standard_Address S)
0198 {
0199   return ((BRepAdaptor_Surface *)S)->Cone();
0200 }
0201
0202 inline gp_Sphere HLRBRep_SurfaceTool::Sphere(const Standard_Address S)
0203 {
0204   return ((BRepAdaptor_Surface *)S)->Sphere();
0205 }
0206
0207 inline gp_Torus HLRBRep_SurfaceTool::Torus(const Standard_Address S)
0208 {
0209   return ((BRepAdaptor_Surface *)S)->Torus();
0210 }
0211
0212
0213 inline Handle(Geom_BezierSurface) HLRBRep_SurfaceTool::Bezier(const Standard_Address S) {
0214   return(((BRepAdaptor_Surface *)S)->Bezier());
0215 }
0216
0217 inline Handle(Geom_BSplineSurface) HLRBRep_SurfaceTool::BSpline(const Standard_Address S) {
0218   return(((BRepAdaptor_Surface *)S)->BSpline());
0219 }
0220
0221
0222 inline gp_Ax1  HLRBRep_SurfaceTool::AxeOfRevolution(const Standard_Address S) {
0223   return(((BRepAdaptor_Surface *)S)->AxeOfRevolution());
0224 }
0225
0226 inline gp_Dir  HLRBRep_SurfaceTool::Direction(const Standard_Address S) {
0227   return(((BRepAdaptor_Surface *)S)->Direction());
0228 }
0229
0230 inline Handle(Adaptor3d_Curve)  HLRBRep_SurfaceTool::BasisCurve(const Standard_Address S) {
0231   return(((BRepAdaptor_Surface *)S)->BasisCurve());
0232 }
0233
0234 inline Handle(Adaptor3d_Surface) HLRBRep_SurfaceTool::BasisSurface(const Standard_Address S) {
0235   return(((BRepAdaptor_Surface *)S)->BasisSurface());
0236 }
0237
0238 inline Standard_Real HLRBRep_SurfaceTool::OffsetValue(const Standard_Address S) {
0239   return(((BRepAdaptor_Surface *)S)->OffsetValue());
0240 }