OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-08-14 13:30:48 +03:00
Code Activity

0024002: Overall code and build procedure refactoring -- automatic

Browse Source 
Automatic upgrade of OCCT code by command "occt_upgrade . -nocdl":
- WOK-generated header files from inc and sources from drv are moved to src
- CDL files removed
- All packages are converted to nocdlpack
This commit is contained in:
abv
2015-07-12 07:42:38 +03:00
parent 543a996496
commit 42cf5bc1ca
15354 changed files with 623957 additions and 509844 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
src/GeomAdaptor/FILES Normal file
View File

@@ -0,0 +1,18 @@
GeomAdaptor.cxx
GeomAdaptor.hxx
GeomAdaptor_Curve.cxx
GeomAdaptor_Curve.hxx
GeomAdaptor_Curve.lxx
GeomAdaptor_GHCurve.hxx
GeomAdaptor_GHCurve_0.cxx
GeomAdaptor_GHSurface.hxx
GeomAdaptor_GHSurface_0.cxx
GeomAdaptor_HCurve.cxx
GeomAdaptor_HCurve.hxx
GeomAdaptor_HCurve.lxx
GeomAdaptor_HSurface.cxx
GeomAdaptor_HSurface.hxx
GeomAdaptor_HSurface.lxx
GeomAdaptor_Surface.cxx
GeomAdaptor_Surface.hxx
GeomAdaptor_Surface.lxx

63
src/GeomAdaptor/GeomAdaptor.cdl
View File

@@ -1,63 +0,0 @@
-- Created on: 1992-10-08
-- Created by: Isabelle GRIGNON
-- Copyright (c) 1992-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.
package GeomAdaptor
---Purpose: this package contains the geometric definition of
-- curve and surface necessary to use algorithmes.
uses
Geom,
GeomAbs,
Adaptor3d,
gp,
Standard,
TColStd,
Geom2dAdaptor,
TColgp,
Precision,
BSplCLib,
BSplSLib
is
class Curve;
class Surface;
private class GHSurface instantiates GenHSurface from Adaptor3d
(Surface from GeomAdaptor);
class HSurface;
private class GHCurve instantiates GenHCurve from Adaptor3d
(Curve from GeomAdaptor);
class HCurve;
---Purpose: Inherited from GHCurve. Provides a curve
-- handled by reference.
MakeCurve( C : Curve from Adaptor3d)
---Purpose: Build a Geom_Curve using the informations from the
-- Curve from Adaptor3d
returns Curve from Geom;
MakeSurface( S : Surface from Adaptor3d)
---Purpose: Build a Geom_Surface using the informations from the
-- Surface from Adaptor3d
returns Surface from Geom;
end GeomAdaptor;

47
src/GeomAdaptor/GeomAdaptor.cxx
View File

@@ -14,37 +14,38 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <GeomAdaptor.ixx>
#include <Geom_Line.hxx>
#include <Geom_Circle.hxx>
#include <Geom_Ellipse.hxx>
#include <Geom_Parabola.hxx>
#include <Geom_Hyperbola.hxx>
#include <Geom_BezierCurve.hxx>
#include <Geom_BSplineCurve.hxx>
#include <Geom_TrimmedCurve.hxx>
#include <Geom_Plane.hxx>
#include <Geom_CylindricalSurface.hxx>
#include <Geom_ConicalSurface.hxx>
#include <Geom_SphericalSurface.hxx>
#include <Geom_ToroidalSurface.hxx>
#include <Geom_BezierSurface.hxx>
#include <Geom_BSplineSurface.hxx>
#include <Geom_SurfaceOfRevolution.hxx>
#include <Geom_SurfaceOfLinearExtrusion.hxx>
#include <Geom_RectangularTrimmedSurface.hxx>
#include <Geom_OffsetSurface.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_HCurve.hxx>
#include <Adaptor3d_HSurface.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Geom_BezierCurve.hxx>
#include <Geom_BezierSurface.hxx>
#include <Geom_BSplineCurve.hxx>
#include <Geom_BSplineSurface.hxx>
#include <Geom_Circle.hxx>
#include <Geom_ConicalSurface.hxx>
#include <Geom_Curve.hxx>
#include <Geom_CylindricalSurface.hxx>
#include <Geom_Ellipse.hxx>
#include <Geom_Hyperbola.hxx>
#include <Geom_Line.hxx>
#include <Geom_OffsetSurface.hxx>
#include <Geom_Parabola.hxx>
#include <Geom_Plane.hxx>
#include <Geom_RectangularTrimmedSurface.hxx>
#include <Geom_SphericalSurface.hxx>
#include <Geom_Surface.hxx>
#include <Geom_SurfaceOfLinearExtrusion.hxx>
#include <Geom_SurfaceOfRevolution.hxx>
#include <Geom_ToroidalSurface.hxx>
#include <Geom_TrimmedCurve.hxx>
#include <GeomAdaptor.hxx>
//=======================================================================
//function : MakeCurve
//purpose :
//=======================================================================
Handle(Geom_Curve) GeomAdaptor::MakeCurve (const Adaptor3d_Curve& HC)
{
Handle(Geom_Curve) C;

84
src/GeomAdaptor/GeomAdaptor.hxx Normal file
View File

@@ -0,0 +1,84 @@
// Created on: 1992-10-08
// Created by: Isabelle GRIGNON
// Copyright (c) 1992-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.
#ifndef _GeomAdaptor_HeaderFile
#define _GeomAdaptor_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
class Geom_Curve;
class Adaptor3d_Curve;
class Geom_Surface;
class Adaptor3d_Surface;
class GeomAdaptor_Curve;
class GeomAdaptor_Surface;
class GeomAdaptor_GHSurface;
class GeomAdaptor_HSurface;
class GeomAdaptor_GHCurve;
class GeomAdaptor_HCurve;
//! this package contains the geometric definition of
//! curve and surface necessary to use algorithmes.
class GeomAdaptor
{
public:
DEFINE_STANDARD_ALLOC
//! Inherited from GHCurve. Provides a curve
//! handled by reference.
//! Build a Geom_Curve using the informations from the
//! Curve from Adaptor3d
Standard_EXPORT static Handle(Geom_Curve) MakeCurve (const Adaptor3d_Curve& C);
//! Build a Geom_Surface using the informations from the
//! Surface from Adaptor3d
Standard_EXPORT static Handle(Geom_Surface) MakeSurface (const Adaptor3d_Surface& S);
protected:
private:
friend class GeomAdaptor_Curve;
friend class GeomAdaptor_Surface;
friend class GeomAdaptor_GHSurface;
friend class GeomAdaptor_HSurface;
friend class GeomAdaptor_GHCurve;
friend class GeomAdaptor_HCurve;
};
#endif // _GeomAdaptor_HeaderFile

361
src/GeomAdaptor/GeomAdaptor_Curve.cdl
View File

@@ -1,361 +0,0 @@
-- Created on: 1992-09-01
-- Created by: Modelistation
-- Copyright (c) 1992-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.
class Curve from GeomAdaptor inherits Curve from Adaptor3d
---Purpose: This class provides an interface between the services provided by any
-- curve from the package Geom and those required of the curve by algorithms which use it.
-- Creation of the loaded curve the curve is C1 by piece.
uses Vec from gp,
Pnt from gp,
Circ from gp,
Elips from gp,
Hypr from gp,
Parab from gp,
Lin from gp,
Array1OfReal from TColStd,
Curve from Geom,
BezierCurve from Geom,
BSplineCurve from Geom,
CurveType from GeomAbs,
Shape from GeomAbs,
HCurve from Adaptor3d,
Cache from BSplCLib
raises NoSuchObject from Standard,
ConstructionError from Standard,
OutOfRange from Standard,
DomainError from Standard
is
Create
returns Curve from GeomAdaptor;
---C++: inline
Create(C : Curve from Geom)
returns Curve from GeomAdaptor;
---C++: inline
Create(C : Curve from Geom; UFirst,ULast : Real)
returns Curve from GeomAdaptor
raises
ConstructionError from Standard;
---Purpose: ConstructionError is raised if Ufirst>Ulast
---C++: inline
Load(me : in out; C : Curve from Geom);
---C++: inline
Load(me : in out; C : Curve from Geom; UFirst,ULast : Real)
raises
ConstructionError from Standard;
---C++: inline
---Purpose: ConstructionError is raised if Ufirst>Ulast
Curve(me) returns Curve from Geom
---Purpose:
-- Provides a curve inherited from Hcurve from Adaptor.
-- This is inherited to provide easy to use constructors.
---C++: return const&
---C++: inline
is static;
FirstParameter(me) returns Real
---C++: inline
is redefined static;
LastParameter(me) returns Real
---C++: inline
is redefined static;
Continuity(me) returns Shape from GeomAbs
is redefined static;
NbIntervals(me; S : Shape from GeomAbs) returns Integer
---Purpose: Returns the number of intervals for continuity
-- <S>. May be one if Continuity(me) >= <S>
is redefined static;
Intervals(me; T : in out Array1OfReal from TColStd;
S : Shape from GeomAbs)
---Purpose: Stores in <T> the parameters bounding the intervals
-- of continuity <S>.
--
-- The array must provide enough room to accomodate
-- for the parameters. i.e. T.Length() > NbIntervals()
raises
OutOfRange from Standard
is redefined static;
Trim(me; First, Last, Tol : Real) returns HCurve from Adaptor3d
---Purpose: Returns a curve equivalent of <me> between
-- parameters <First> and <Last>. <Tol> is used to
-- test for 3d points confusion.
raises
OutOfRange from Standard
---Purpose: If <First> >= <Last>
is redefined static;
IsClosed(me) returns Boolean
is redefined static;
IsPeriodic(me) returns Boolean
is redefined static;
Period(me) returns Real
raises
DomainError from Standard -- if the curve is not periodic
is redefined static;
Value(me; U : Real) returns Pnt from gp
--- Purpose : Computes the point of parameter U on the curve
is redefined static;
ValueBSpline(me; U: Real) returns Pnt from gp
--- Purpose : Computes the point of parameter U on the B-spline curve
is private;
ValueOffset(me; U: Real) returns Pnt from gp
--- Purpose : Computes the point of parameter U on the offset curve
is private;
D0 (me; U : Real; P : out Pnt from gp)
--- Purpose : Computes the point of parameter U.
is redefined static;
D0BSpline(me; theU : Real; theP : out Pnt from gp)
--- Purpose : Computes the point of parameter U on the B-spline curve
is private;
D0Offset(me; theU : Real; theP : out Pnt from gp)
--- Purpose : Computes the point of parameter U on the offset curve
is private;
D1 (me; U : Real; P : out Pnt from gp ; V : out Vec from gp)
--- Purpose : Computes the point of parameter U on the curve
-- with its first derivative.
--
-- Warning : On the specific case of BSplineCurve:
-- if the curve is cut in interval of continuity at least C1, the
-- derivatives are computed on the current interval.
-- else the derivatives are computed on the basis curve.
is redefined static;
D1BSpline(me; theU : Real; theP : out Pnt from gp ; theV : out Vec from gp)
--- Purpose : Computes the point of parameter U on the B-spline curve
-- and its derivative
is private;
D1Offset(me; theU : Real; theP : out Pnt from gp ; theV : out Vec from gp)
--- Purpose : Computes the point of parameter U on the offset curve
-- and its derivative
is private;
D2 (me; U : Real; P : out Pnt from gp; V1, V2 : out Vec from gp)
--- Purpose :
-- Returns the point P of parameter U, the first and second
-- derivatives V1 and V2.
--
-- Warning : On the specific case of BSplineCurve:
-- if the curve is cut in interval of continuity at least C2, the
-- derivatives are computed on the current interval.
-- else the derivatives are computed on the basis curve.
is redefined static;
D2BSpline(me; theU : Real; theP : out Pnt from gp; theV1, theV2 : out Vec from gp)
--- Purpose : Computes the point of parameter U on the B-spline curve
-- and its first and second derivatives
is private;
D2Offset(me; theU : Real; theP : out Pnt from gp; theV1, theV2 : out Vec from gp)
--- Purpose : Computes the point of parameter U on the offset curve
-- and its first and second derivatives
is private;
D3 (me; U : Real; P : out Pnt from gp; V1, V2, V3 : out Vec from gp)
--- Purpose :
-- Returns the point P of parameter U, the first, the second
-- and the third derivative.
--
-- Warning : On the specific case of BSplineCurve:
-- if the curve is cut in interval of continuity at least C3, the
-- derivatives are computed on the current interval.
-- else the derivatives are computed on the basis curve.
is redefined static;
D3BSpline(me; theU : Real; theP : out Pnt from gp; theV1, theV2, theV3 : out Vec from gp)
--- Purpose : Computes the point of parameter U on the B-spline curve
-- and its first, second and third derivatives
is private;
D3Offset(me; theU : Real; theP : out Pnt from gp; theV1, theV2, theV3 : out Vec from gp)
--- Purpose : Computes the point of parameter U on the offset curve
-- and its first, second and third derivatives
is private;
DN (me; U : Real; N : Integer) returns Vec from gp
--- Purpose :
-- The returned vector gives the value of the derivative for the
-- order of derivation N.
-- Warning : On the specific case of BSplineCurve:
-- if the curve is cut in interval of continuity CN, the
-- derivatives are computed on the current interval.
-- else the derivatives are computed on the basis curve.
raises
OutOfRange from Standard
--- Purpose : Raised if N < 1.
is redefined static;
DNBSpline(me; theU : Real; N : Integer) returns Vec from gp
--- Purpose :
-- The returned vector gives the value of the derivative for the
-- order of derivation N.
is private;
DNOffset(me; theU : Real; N : Integer) returns Vec from gp
--- Purpose :
-- The returned vector gives the value of the derivative for the
-- order of derivation N.
is private;
Resolution(me; R3d :Real) returns Real
---Purpose : returns the parametric resolution
is redefined static;
GetType(me) returns CurveType from GeomAbs
---C++: inline
is redefined static;
Line(me) returns Lin from gp
raises
NoSuchObject from Standard
is redefined static;
Circle(me) returns Circ from gp
raises
NoSuchObject from Standard
is redefined static;
Ellipse(me) returns Elips from gp
raises
NoSuchObject from Standard
is redefined static;
Hyperbola(me) returns Hypr from gp
raises
NoSuchObject from Standard
is redefined static;
Parabola(me) returns Parab from gp
raises
NoSuchObject from Standard
is redefined static;
Degree(me) returns Integer
raises
NoSuchObject from Standard
is redefined static;
---Purpose:
-- this should NEVER make a copy
-- of the underlying curve to read
-- the relevant information
--
IsRational(me) returns Boolean
raises
NoSuchObject from Standard
is redefined static;
---Purpose:
-- this should NEVER make a copy
-- of the underlying curve to read
-- the relevant information
--
NbPoles(me) returns Integer
raises
NoSuchObject from Standard
is redefined static;
---Purpose:
-- this should NEVER make a copy
-- of the underlying curve to read
-- the relevant information
--
NbKnots(me) returns Integer
raises
NoSuchObject from Standard
is redefined static;
---Purpose:
-- this should NEVER make a copy
-- of the underlying curve to read
-- the relevant information
--
Bezier(me) returns BezierCurve from Geom
raises
NoSuchObject from Standard
is redefined static;
---Purpose : this will NOT make a copy of the
-- Bezier Curve : If you want to modify
-- the Curve please make a copy yourself
-- Also it will NOT trim the surface to
-- myFirst/Last.
BSpline(me) returns BSplineCurve from Geom
raises
NoSuchObject from Standard
is redefined static;
---Purpose : this will NOT make a copy of the
-- BSpline Curve : If you want to modify
-- the Curve please make a copy yourself
-- Also it will NOT trim the surface to
-- myFirst/Last.
LocalContinuity(me; U1, U2 : Real) returns Shape from GeomAbs
is static private;
load(me : in out; C : Curve from Geom; UFirst,ULast : Real)
is private;
RebuildCache(me; theParameter : Real)
---Purpose: Rebuilds B-spline cache
-- \param theParameter the value on the knot axis which identifies the caching span
is static private;
fields
myCurve : Curve from Geom ;
myTypeCurve : CurveType from GeomAbs ;
myFirst : Real from Standard ;
myLast : Real from Standard;
myCurveCache : Cache from BSplCLib;
myOffsetBaseCurveAdaptor : HCurve from Adaptor3d;
friends
class Surface from GeomAdaptor
end Curve;

49
src/GeomAdaptor/GeomAdaptor_Curve.cxx
View File

@@ -21,36 +21,45 @@
#define No_Standard_RangeError
#define No_Standard_OutOfRange
#include <GeomAdaptor_Curve.ixx>
#include <GeomAdaptor_HCurve.hxx>
#include <Adaptor3d_HCurve.hxx>
#include <BSplCLib.hxx>
#include <BSplCLib_Cache.hxx>
#include <GeomAbs_Shape.hxx>
#include <TColgp_Array1OfPnt.hxx>
#include <TColStd_Array1OfReal.hxx>
#include <TColStd_Array1OfInteger.hxx>
#include <TColStd_HArray1OfInteger.hxx>
#include <Precision.hxx>
#include <Geom_TrimmedCurve.hxx>
#include <Geom_Circle.hxx>
#include <Geom_Line.hxx>
#include <Geom_TrimmedCurve.hxx>
#include <CSLib_Offset.hxx>
#include <Geom_BezierCurve.hxx>
#include <Geom_BSplineCurve.hxx>
#include <Geom_Circle.hxx>
#include <Geom_Curve.hxx>
#include <Geom_Ellipse.hxx>
#include <Geom_Parabola.hxx>
#include <Geom_Hyperbola.hxx>
//#include <GeomConvert_BSplineCurveKnotSplitting.hxx>
#include <Standard_OutOfRange.hxx>
#include <Standard_NoSuchObject.hxx>
#include <Standard_NullObject.hxx>
#include <Standard_NotImplemented.hxx>
#include <Geom_Line.hxx>
#include <Geom_OffsetCurve.hxx>
#include <CSLib_Offset.hxx>
#include <Geom_Parabola.hxx>
#include <Geom_TrimmedCurve.hxx>
#include <GeomAbs_Shape.hxx>
#include <GeomAdaptor_Curve.hxx>
#include <GeomAdaptor_HCurve.hxx>
#include <GeomAdaptor_Surface.hxx>
#include <gp_Circ.hxx>
#include <gp_Elips.hxx>
#include <gp_Hypr.hxx>
#include <gp_Lin.hxx>
#include <gp_Parab.hxx>
#include <gp_Pnt.hxx>
#include <gp_Vec.hxx>
#include <Precision.hxx>
#include <Standard_ConstructionError.hxx>
#include <Standard_DomainError.hxx>
#include <Standard_NoSuchObject.hxx>
#include <Standard_NotImplemented.hxx>
#include <Standard_NullObject.hxx>
#include <Standard_OutOfRange.hxx>
#include <TColgp_Array1OfPnt.hxx>
#include <TColStd_Array1OfInteger.hxx>
#include <TColStd_Array1OfReal.hxx>
#include <TColStd_HArray1OfInteger.hxx>
//#include <GeomConvert_BSplineCurveKnotSplitting.hxx>
#define myBspl Handle(Geom_BSplineCurve)::DownCast (myCurve)
#define PosTol Precision::PConfusion()/2

289
src/GeomAdaptor/GeomAdaptor_Curve.hxx Normal file
View File

@@ -0,0 +1,289 @@
// Created on: 1992-09-01
// Created by: Modelistation
// Copyright (c) 1992-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.
#ifndef _GeomAdaptor_Curve_HeaderFile
#define _GeomAdaptor_Curve_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <GeomAbs_CurveType.hxx>
#include <Standard_Real.hxx>
#include <BSplCLib_Cache.hxx>
#include <Adaptor3d_Curve.hxx>
#include <GeomAbs_Shape.hxx>
#include <Standard_Integer.hxx>
#include <TColStd_Array1OfReal.hxx>
#include <Standard_Boolean.hxx>
class Geom_Curve;
class Adaptor3d_HCurve;
class Standard_NoSuchObject;
class Standard_ConstructionError;
class Standard_OutOfRange;
class Standard_DomainError;
class GeomAdaptor_Surface;
class gp_Pnt;
class gp_Vec;
class gp_Lin;
class gp_Circ;
class gp_Elips;
class gp_Hypr;
class gp_Parab;
class Geom_BezierCurve;
class Geom_BSplineCurve;
//! This class provides an interface between the services provided by any
//! curve from the package Geom and those required of the curve by algorithms which use it.
//! Creation of the loaded curve the curve is C1 by piece.
class GeomAdaptor_Curve : public Adaptor3d_Curve
{
public:
DEFINE_STANDARD_ALLOC
GeomAdaptor_Curve();
GeomAdaptor_Curve(const Handle(Geom_Curve)& C);
//! ConstructionError is raised if Ufirst>Ulast
GeomAdaptor_Curve(const Handle(Geom_Curve)& C, const Standard_Real UFirst, const Standard_Real ULast);
void Load (const Handle(Geom_Curve)& C);
//! ConstructionError is raised if Ufirst>Ulast
void Load (const Handle(Geom_Curve)& C, const Standard_Real UFirst, const Standard_Real ULast);
//! Provides a curve inherited from Hcurve from Adaptor.
//! This is inherited to provide easy to use constructors.
const Handle(Geom_Curve)& Curve() const;
Standard_Real FirstParameter() const Standard_OVERRIDE;
Standard_Real LastParameter() const Standard_OVERRIDE;
Standard_EXPORT GeomAbs_Shape Continuity() const Standard_OVERRIDE;
//! Returns the number of intervals for continuity
//! <S>. May be one if Continuity(me) >= <S>
Standard_EXPORT Standard_Integer NbIntervals (const GeomAbs_Shape S) const Standard_OVERRIDE;
//! Stores in <T> the parameters bounding the intervals
//! of continuity <S>.
//!
//! The array must provide enough room to accomodate
//! for the parameters. i.e. T.Length() > NbIntervals()
Standard_EXPORT void Intervals (TColStd_Array1OfReal& T, const GeomAbs_Shape S) const Standard_OVERRIDE;
//! Returns a curve equivalent of <me> between
//! parameters <First> and <Last>. <Tol> is used to
//! test for 3d points confusion.
//! If <First> >= <Last>
Standard_EXPORT Handle(Adaptor3d_HCurve) Trim (const Standard_Real First, const Standard_Real Last, const Standard_Real Tol) const Standard_OVERRIDE;
Standard_EXPORT Standard_Boolean IsClosed() const Standard_OVERRIDE;
Standard_EXPORT Standard_Boolean IsPeriodic() const Standard_OVERRIDE;
Standard_EXPORT Standard_Real Period() const Standard_OVERRIDE;
//! Computes the point of parameter U on the curve
Standard_EXPORT gp_Pnt Value (const Standard_Real U) const Standard_OVERRIDE;
//! Computes the point of parameter U.
Standard_EXPORT void D0 (const Standard_Real U, gp_Pnt& P) const Standard_OVERRIDE;
//! Computes the point of parameter U on the curve
//! with its first derivative.
//!
//! Warning : On the specific case of BSplineCurve:
//! if the curve is cut in interval of continuity at least C1, the
//! derivatives are computed on the current interval.
//! else the derivatives are computed on the basis curve.
Standard_EXPORT void D1 (const Standard_Real U, gp_Pnt& P, gp_Vec& V) const Standard_OVERRIDE;
//! Returns the point P of parameter U, the first and second
//! derivatives V1 and V2.
//!
//! Warning : On the specific case of BSplineCurve:
//! if the curve is cut in interval of continuity at least C2, the
//! derivatives are computed on the current interval.
//! else the derivatives are computed on the basis curve.
Standard_EXPORT void D2 (const Standard_Real U, gp_Pnt& P, gp_Vec& V1, gp_Vec& V2) const Standard_OVERRIDE;
//! Returns the point P of parameter U, the first, the second
//! and the third derivative.
//!
//! Warning : On the specific case of BSplineCurve:
//! if the curve is cut in interval of continuity at least C3, the
//! derivatives are computed on the current interval.
//! else the derivatives are computed on the basis curve.
Standard_EXPORT void D3 (const Standard_Real U, gp_Pnt& P, gp_Vec& V1, gp_Vec& V2, gp_Vec& V3) const Standard_OVERRIDE;
//! The returned vector gives the value of the derivative for the
//! order of derivation N.
//! Warning : On the specific case of BSplineCurve:
//! if the curve is cut in interval of continuity CN, the
//! derivatives are computed on the current interval.
//! else the derivatives are computed on the basis curve.
//! Raised if N < 1.
Standard_EXPORT gp_Vec DN (const Standard_Real U, const Standard_Integer N) const Standard_OVERRIDE;
//! returns the parametric resolution
Standard_EXPORT Standard_Real Resolution (const Standard_Real R3d) const Standard_OVERRIDE;
GeomAbs_CurveType GetType() const Standard_OVERRIDE;
Standard_EXPORT gp_Lin Line() const Standard_OVERRIDE;
Standard_EXPORT gp_Circ Circle() const Standard_OVERRIDE;
Standard_EXPORT gp_Elips Ellipse() const Standard_OVERRIDE;
Standard_EXPORT gp_Hypr Hyperbola() const Standard_OVERRIDE;
Standard_EXPORT gp_Parab Parabola() const Standard_OVERRIDE;
//! this should NEVER make a copy
//! of the underlying curve to read
//! the relevant information
Standard_EXPORT Standard_Integer Degree() const Standard_OVERRIDE;
//! this should NEVER make a copy
//! of the underlying curve to read
//! the relevant information
Standard_EXPORT Standard_Boolean IsRational() const Standard_OVERRIDE;
//! this should NEVER make a copy
//! of the underlying curve to read
//! the relevant information
Standard_EXPORT Standard_Integer NbPoles() const Standard_OVERRIDE;
//! this should NEVER make a copy
//! of the underlying curve to read
//! the relevant information
Standard_EXPORT Standard_Integer NbKnots() const Standard_OVERRIDE;
//! this will NOT make a copy of the
//! Bezier Curve : If you want to modify
//! the Curve please make a copy yourself
//! Also it will NOT trim the surface to
//! myFirst/Last.
Standard_EXPORT Handle(Geom_BezierCurve) Bezier() const Standard_OVERRIDE;
//! this will NOT make a copy of the
//! BSpline Curve : If you want to modify
//! the Curve please make a copy yourself
//! Also it will NOT trim the surface to
//! myFirst/Last.
Standard_EXPORT Handle(Geom_BSplineCurve) BSpline() const Standard_OVERRIDE;
friend class GeomAdaptor_Surface;
protected:
private:
//! Computes the point of parameter U on the B-spline curve
Standard_EXPORT gp_Pnt ValueBSpline (const Standard_Real U) const;
//! Computes the point of parameter U on the offset curve
Standard_EXPORT gp_Pnt ValueOffset (const Standard_Real U) const;
//! Computes the point of parameter U on the B-spline curve
Standard_EXPORT void D0BSpline (const Standard_Real theU, gp_Pnt& theP) const;
//! Computes the point of parameter U on the offset curve
Standard_EXPORT void D0Offset (const Standard_Real theU, gp_Pnt& theP) const;
//! Computes the point of parameter U on the B-spline curve
//! and its derivative
Standard_EXPORT void D1BSpline (const Standard_Real theU, gp_Pnt& theP, gp_Vec& theV) const;
//! Computes the point of parameter U on the offset curve
//! and its derivative
Standard_EXPORT void D1Offset (const Standard_Real theU, gp_Pnt& theP, gp_Vec& theV) const;
//! Computes the point of parameter U on the B-spline curve
//! and its first and second derivatives
Standard_EXPORT void D2BSpline (const Standard_Real theU, gp_Pnt& theP, gp_Vec& theV1, gp_Vec& theV2) const;
//! Computes the point of parameter U on the offset curve
//! and its first and second derivatives
Standard_EXPORT void D2Offset (const Standard_Real theU, gp_Pnt& theP, gp_Vec& theV1, gp_Vec& theV2) const;
//! Computes the point of parameter U on the B-spline curve
//! and its first, second and third derivatives
Standard_EXPORT void D3BSpline (const Standard_Real theU, gp_Pnt& theP, gp_Vec& theV1, gp_Vec& theV2, gp_Vec& theV3) const;
//! Computes the point of parameter U on the offset curve
//! and its first, second and third derivatives
Standard_EXPORT void D3Offset (const Standard_Real theU, gp_Pnt& theP, gp_Vec& theV1, gp_Vec& theV2, gp_Vec& theV3) const;
//! The returned vector gives the value of the derivative for the
//! order of derivation N.
Standard_EXPORT gp_Vec DNBSpline (const Standard_Real theU, const Standard_Integer N) const;
//! The returned vector gives the value of the derivative for the
//! order of derivation N.
Standard_EXPORT gp_Vec DNOffset (const Standard_Real theU, const Standard_Integer N) const;
Standard_EXPORT GeomAbs_Shape LocalContinuity (const Standard_Real U1, const Standard_Real U2) const;
Standard_EXPORT void load (const Handle(Geom_Curve)& C, const Standard_Real UFirst, const Standard_Real ULast);
//! Rebuilds B-spline cache
//! \param theParameter the value on the knot axis which identifies the caching span
Standard_EXPORT void RebuildCache (const Standard_Real theParameter) const;
Handle(Geom_Curve) myCurve;
GeomAbs_CurveType myTypeCurve;
Standard_Real myFirst;
Standard_Real myLast;
Handle(BSplCLib_Cache) myCurveCache;
Handle(Adaptor3d_HCurve) myOffsetBaseCurveAdaptor;
};
#include <GeomAdaptor_Curve.lxx>
#endif // _GeomAdaptor_Curve_HeaderFile

89
src/GeomAdaptor/GeomAdaptor_GHCurve.hxx Normal file
View File

@@ -0,0 +1,89 @@
// Created on: 1992-10-08
// Created by: Isabelle GRIGNON
// Copyright (c) 1992-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.
#ifndef _GeomAdaptor_GHCurve_HeaderFile
#define _GeomAdaptor_GHCurve_HeaderFile
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <GeomAdaptor_Curve.hxx>
#include <Adaptor3d_HCurve.hxx>
class Standard_OutOfRange;
class Standard_NoSuchObject;
class Standard_DomainError;
class GeomAdaptor_Curve;
class Adaptor3d_Curve;
class GeomAdaptor_GHCurve;
DEFINE_STANDARD_HANDLE(GeomAdaptor_GHCurve, Adaptor3d_HCurve)
class GeomAdaptor_GHCurve : public Adaptor3d_HCurve
{
public:
Standard_EXPORT GeomAdaptor_GHCurve();
Standard_EXPORT GeomAdaptor_GHCurve(const GeomAdaptor_Curve& C);
Standard_EXPORT void Set (const GeomAdaptor_Curve& C);
Standard_EXPORT const Adaptor3d_Curve& Curve() const;
Standard_EXPORT Adaptor3d_Curve& GetCurve();
GeomAdaptor_Curve& ChangeCurve();
DEFINE_STANDARD_RTTI(GeomAdaptor_GHCurve,Adaptor3d_HCurve)
protected:
GeomAdaptor_Curve myCurve;
private:
};
#define TheCurve GeomAdaptor_Curve
#define TheCurve_hxx <GeomAdaptor_Curve.hxx>
#define Adaptor3d_GenHCurve GeomAdaptor_GHCurve
#define Adaptor3d_GenHCurve_hxx <GeomAdaptor_GHCurve.hxx>
#define Handle_Adaptor3d_GenHCurve Handle(GeomAdaptor_GHCurve)
#include <Adaptor3d_GenHCurve.lxx>
#undef TheCurve
#undef TheCurve_hxx
#undef Adaptor3d_GenHCurve
#undef Adaptor3d_GenHCurve_hxx
#undef Handle_Adaptor3d_GenHCurve
#endif // _GeomAdaptor_GHCurve_HeaderFile

42
src/GeomAdaptor/GeomAdaptor_GHCurve_0.cxx Normal file
View File

@@ -0,0 +1,42 @@
// Created on: 1992-10-08
// Created by: Isabelle GRIGNON
// Copyright (c) 1992-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 <GeomAdaptor_GHCurve.hxx>
#include <Standard_Type.hxx>
#include <Standard_OutOfRange.hxx>
#include <Standard_NoSuchObject.hxx>
#include <Standard_DomainError.hxx>
#include <GeomAdaptor_Curve.hxx>
#include <Adaptor3d_Curve.hxx>
#define TheCurve GeomAdaptor_Curve
#define TheCurve_hxx <GeomAdaptor_Curve.hxx>
#define Adaptor3d_GenHCurve GeomAdaptor_GHCurve
#define Adaptor3d_GenHCurve_hxx <GeomAdaptor_GHCurve.hxx>
#define Handle_Adaptor3d_GenHCurve Handle(GeomAdaptor_GHCurve)
#include <Adaptor3d_GenHCurve.gxx>

87
src/GeomAdaptor/GeomAdaptor_GHSurface.hxx Normal file
View File

@@ -0,0 +1,87 @@
// Created on: 1992-10-08
// Created by: Isabelle GRIGNON
// Copyright (c) 1992-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.
#ifndef _GeomAdaptor_GHSurface_HeaderFile
#define _GeomAdaptor_GHSurface_HeaderFile
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <GeomAdaptor_Surface.hxx>
#include <Adaptor3d_HSurface.hxx>
class Standard_OutOfRange;
class Standard_NoSuchObject;
class Standard_DomainError;
class GeomAdaptor_Surface;
class Adaptor3d_Surface;
class GeomAdaptor_GHSurface;
DEFINE_STANDARD_HANDLE(GeomAdaptor_GHSurface, Adaptor3d_HSurface)
class GeomAdaptor_GHSurface : public Adaptor3d_HSurface
{
public:
Standard_EXPORT GeomAdaptor_GHSurface();
Standard_EXPORT GeomAdaptor_GHSurface(const GeomAdaptor_Surface& S);
Standard_EXPORT void Set (const GeomAdaptor_Surface& S);
Standard_EXPORT const Adaptor3d_Surface& Surface() const;
GeomAdaptor_Surface& ChangeSurface();
DEFINE_STANDARD_RTTI(GeomAdaptor_GHSurface,Adaptor3d_HSurface)
protected:
GeomAdaptor_Surface mySurf;
private:
};
#define TheSurface GeomAdaptor_Surface
#define TheSurface_hxx <GeomAdaptor_Surface.hxx>
#define Adaptor3d_GenHSurface GeomAdaptor_GHSurface
#define Adaptor3d_GenHSurface_hxx <GeomAdaptor_GHSurface.hxx>
#define Handle_Adaptor3d_GenHSurface Handle(GeomAdaptor_GHSurface)
#include <Adaptor3d_GenHSurface.lxx>
#undef TheSurface
#undef TheSurface_hxx
#undef Adaptor3d_GenHSurface
#undef Adaptor3d_GenHSurface_hxx
#undef Handle_Adaptor3d_GenHSurface
#endif // _GeomAdaptor_GHSurface_HeaderFile

42
src/GeomAdaptor/GeomAdaptor_GHSurface_0.cxx Normal file
View File

@@ -0,0 +1,42 @@
// Created on: 1992-10-08
// Created by: Isabelle GRIGNON
// Copyright (c) 1992-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 <GeomAdaptor_GHSurface.hxx>
#include <Standard_Type.hxx>
#include <Standard_OutOfRange.hxx>
#include <Standard_NoSuchObject.hxx>
#include <Standard_DomainError.hxx>
#include <GeomAdaptor_Surface.hxx>
#include <Adaptor3d_Surface.hxx>
#define TheSurface GeomAdaptor_Surface
#define TheSurface_hxx <GeomAdaptor_Surface.hxx>
#define Adaptor3d_GenHSurface GeomAdaptor_GHSurface
#define Adaptor3d_GenHSurface_hxx <GeomAdaptor_GHSurface.hxx>
#define Handle_Adaptor3d_GenHSurface Handle(GeomAdaptor_GHSurface)
#include <Adaptor3d_GenHSurface.gxx>

47
src/GeomAdaptor/GeomAdaptor_HCurve.cdl
View File

@@ -1,47 +0,0 @@
-- Created on: 1995-08-25
-- Created by: Remi LEQUETTE
-- Copyright (c) 1995-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.
class HCurve from GeomAdaptor inherits GHCurve from GeomAdaptor
---Purpose: An interface between the services provided by any
-- curve from the package Geom and those required of
-- the curve by algorithms which use it.
uses
Curve from Geom,
Curve from GeomAdaptor
raises
ConstructionError from Standard
is
Create returns HCurve from GeomAdaptor;
---C++: inline
Create( AS : Curve from GeomAdaptor) returns HCurve from GeomAdaptor;
---C++: inline
Create( S : Curve from Geom) returns HCurve from GeomAdaptor;
---C++: inline
Create( S : Curve from Geom; UFirst,ULast : Real)
returns HCurve from GeomAdaptor
---Purpose: ConstructionError is raised if UFirst>ULast or VFirst>VLast
---C++: inline
raises ConstructionError from Standard;
end HCurve;

7
src/GeomAdaptor/GeomAdaptor_HCurve.cxx
View File

@@ -14,4 +14,9 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <GeomAdaptor_HCurve.ixx>
#include <Geom_Curve.hxx>
#include <GeomAdaptor_Curve.hxx>
#include <GeomAdaptor_HCurve.hxx>
#include <Standard_ConstructionError.hxx>
#include <Standard_Type.hxx>

75
src/GeomAdaptor/GeomAdaptor_HCurve.hxx Normal file
View File

@@ -0,0 +1,75 @@
// Created on: 1995-08-25
// Created by: Remi LEQUETTE
// Copyright (c) 1995-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.
#ifndef _GeomAdaptor_HCurve_HeaderFile
#define _GeomAdaptor_HCurve_HeaderFile
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <GeomAdaptor_GHCurve.hxx>
#include <Standard_Real.hxx>
class Standard_ConstructionError;
class GeomAdaptor_Curve;
class Geom_Curve;
class GeomAdaptor_HCurve;
DEFINE_STANDARD_HANDLE(GeomAdaptor_HCurve, GeomAdaptor_GHCurve)
//! An interface between the services provided by any
//! curve from the package Geom and those required of
//! the curve by algorithms which use it.
class GeomAdaptor_HCurve : public GeomAdaptor_GHCurve
{
public:
GeomAdaptor_HCurve();
GeomAdaptor_HCurve(const GeomAdaptor_Curve& AS);
GeomAdaptor_HCurve(const Handle(Geom_Curve)& S);
//! ConstructionError is raised if UFirst>ULast or VFirst>VLast
GeomAdaptor_HCurve(const Handle(Geom_Curve)& S, const Standard_Real UFirst, const Standard_Real ULast);
DEFINE_STANDARD_RTTI(GeomAdaptor_HCurve,GeomAdaptor_GHCurve)
protected:
private:
};
#include <GeomAdaptor_HCurve.lxx>
#endif // _GeomAdaptor_HCurve_HeaderFile

50
src/GeomAdaptor/GeomAdaptor_HSurface.cdl
View File

@@ -1,50 +0,0 @@
-- Created on: 1995-08-25
-- Created by: Remi LEQUETTE
-- Copyright (c) 1995-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.
class HSurface from GeomAdaptor inherits GHSurface from GeomAdaptor
---Purpose: An interface between the services provided by any
-- surface from the package Geom and those required
-- of the surface by algorithms which use it.
-- Provides a surface handled by reference.
uses
Surface from Geom,
Surface from GeomAdaptor
raises
ConstructionError from Standard
is
Create returns HSurface from GeomAdaptor;
---C++: inline
Create( AS : Surface from GeomAdaptor) returns HSurface from GeomAdaptor;
---C++: inline
Create( S : Surface from Geom) returns HSurface from GeomAdaptor;
---C++: inline
Create( S : Surface from Geom; UFirst,ULast,VFirst,VLast : Real;
TolU : Real = 0.0;
TolV : Real = 0.0)
returns HSurface from GeomAdaptor
raises ConstructionError from Standard;
---Purpose: ConstructionError is raised if UFirst>ULast or VFirst>VLast
---C++: inline
end HSurface;

7
src/GeomAdaptor/GeomAdaptor_HSurface.cxx
View File

@@ -14,4 +14,9 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <GeomAdaptor_HSurface.ixx>
#include <Geom_Surface.hxx>
#include <GeomAdaptor_HSurface.hxx>
#include <GeomAdaptor_Surface.hxx>
#include <Standard_ConstructionError.hxx>
#include <Standard_Type.hxx>

76
src/GeomAdaptor/GeomAdaptor_HSurface.hxx Normal file
View File

@@ -0,0 +1,76 @@
// Created on: 1995-08-25
// Created by: Remi LEQUETTE
// Copyright (c) 1995-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.
#ifndef _GeomAdaptor_HSurface_HeaderFile
#define _GeomAdaptor_HSurface_HeaderFile
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <GeomAdaptor_GHSurface.hxx>
#include <Standard_Real.hxx>
class Standard_ConstructionError;
class GeomAdaptor_Surface;
class Geom_Surface;
class GeomAdaptor_HSurface;
DEFINE_STANDARD_HANDLE(GeomAdaptor_HSurface, GeomAdaptor_GHSurface)
//! An interface between the services provided by any
//! surface from the package Geom and those required
//! of the surface by algorithms which use it.
//! Provides a surface handled by reference.
class GeomAdaptor_HSurface : public GeomAdaptor_GHSurface
{
public:
GeomAdaptor_HSurface();
GeomAdaptor_HSurface(const GeomAdaptor_Surface& AS);
GeomAdaptor_HSurface(const Handle(Geom_Surface)& S);
//! ConstructionError is raised if UFirst>ULast or VFirst>VLast
GeomAdaptor_HSurface(const Handle(Geom_Surface)& S, const Standard_Real UFirst, const Standard_Real ULast, const Standard_Real VFirst, const Standard_Real VLast, const Standard_Real TolU = 0.0, const Standard_Real TolV = 0.0);
DEFINE_STANDARD_RTTI(GeomAdaptor_HSurface,GeomAdaptor_GHSurface)
protected:
private:
};
#include <GeomAdaptor_HSurface.lxx>
#endif // _GeomAdaptor_HSurface_HeaderFile

407
src/GeomAdaptor/GeomAdaptor_Surface.cdl
View File

@@ -1,407 +0,0 @@
-- Created on: 1993-05-14
-- Created by: Bruno DUMORTIER
-- 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.
class Surface from GeomAdaptor inherits Surface from Adaptor3d
---Purpose: An interface between the services provided by any
-- surface from the package Geom and those required
-- of the surface by algorithms which use it.
-- Creation of the loaded surface the surface is C1 by piece
uses
Pnt from gp,
Vec from gp,
Dir from gp,
Pln from gp,
Cone from gp,
Cylinder from gp,
Sphere from gp,
Torus from gp,
Ax1 from gp,
Array1OfReal from TColStd,
Surface from Geom,
BezierSurface from Geom,
BSplineSurface from Geom,
SurfaceType from GeomAbs,
Shape from GeomAbs,
Curve from GeomAdaptor,
HCurve from Adaptor3d,
HSurface from Adaptor3d,
Cache from BSplSLib
raises
NoSuchObject from Standard,
OutOfRange from Standard,
ConstructionError from Standard,
DomainError from Standard
is
Create returns Surface from GeomAdaptor;
---C++: inline
Create( S : Surface from Geom) returns Surface from GeomAdaptor;
---C++: inline
Create( S : Surface from Geom; UFirst,ULast,VFirst,VLast : Real;
TolU : Real = 0.0;
TolV : Real = 0.0)
returns Surface from GeomAdaptor
raises ConstructionError from Standard;
---Purpose: ConstructionError is raised if UFirst>ULast or VFirst>VLast
---C++: inline
Load(me : in out; S : Surface from Geom);
---C++: inline
Load(me : in out; S : Surface from Geom;
UFirst,ULast,VFirst,VLast : Real;
TolU : Real = 0.0;
TolV : Real = 0.0)
raises ConstructionError from Standard;
---C++: inline
---Purpose: ConstructionError is raised if UFirst>ULast or VFirst>VLast
Surface(me) returns Surface from Geom
---C++: return const&
---C++: inline
is static;
--
-- Global methods - Apply to the whole surface.
--
FirstUParameter(me) returns Real
---C++:inline
is redefined static;
LastUParameter(me) returns Real
---C++:inline
is redefined static;
FirstVParameter(me) returns Real
---C++:inline
is redefined static;
LastVParameter(me) returns Real
---C++:inline
is redefined static;
UContinuity(me) returns Shape from GeomAbs
is redefined static;
VContinuity(me) returns Shape from GeomAbs
is redefined static;
NbUIntervals(me; S : Shape from GeomAbs) returns Integer
---Purpose: Returns the number of U intervals for continuity
-- <S>. May be one if UContinuity(me) >= <S>
is redefined static;
NbVIntervals(me; S : Shape from GeomAbs) returns Integer
---Purpose: Returns the number of V intervals for continuity
-- <S>. May be one if VContinuity(me) >= <S>
is redefined static;
UIntervals(me; T : in out Array1OfReal from TColStd;
S : Shape from GeomAbs )
---Purpose: Returns the intervals with the requested continuity
-- in the U direction.
raises
OutOfRange from Standard -- if the Length of the array does
-- have enought slots to accomodate
-- the result.
is redefined static;
VIntervals(me; T : in out Array1OfReal from TColStd;
S : Shape from GeomAbs )
---Purpose: Returns the intervals with the requested continuity
-- in the V direction.
raises
OutOfRange from Standard -- if the Length of the array does
-- have enought slots to accomodate
-- the result.
is redefined static;
UTrim(me; First, Last, Tol : Real) returns HSurface from Adaptor3d
---Purpose: Returns a surface trimmed in the U direction
-- equivalent of <me> between
-- parameters <First> and <Last>. <Tol> is used to
-- test for 3d points confusion.
raises
OutOfRange from Standard
---Purpose: If <First> >= <Last>
is redefined static ;
VTrim(me; First, Last, Tol : Real) returns HSurface from Adaptor3d
---Purpose: Returns a surface trimmed in the V direction between
-- parameters <First> and <Last>. <Tol> is used to
-- test for 3d points confusion.
raises
OutOfRange from Standard
---Purpose: If <First> >= <Last>
is redefined static ;
IsUClosed(me) returns Boolean
is redefined static;
IsVClosed(me) returns Boolean
is redefined static;
IsUPeriodic(me) returns Boolean
is redefined static;
UPeriod(me) returns Real
raises
DomainError from Standard -- if the curve is not periodic
is redefined static;
IsVPeriodic(me) returns Boolean
is redefined static;
VPeriod(me) returns Real
raises
DomainError from Standard -- if the curve is not periodic
is redefined static;
Value (me; U, V : Real) returns Pnt from gp
--- Purpose : Computes the point of parameters U,V on the surface.
is redefined static;
D0 (me; U, V : Real;
P : out Pnt from gp)
--- Purpose : Computes the point of parameters U,V on the surface.
is redefined static;
D1 (me; U, V : Real;
P : out Pnt from gp;
D1U, D1V : out Vec from gp)
--- Purpose : Computes the point and the first derivatives on
-- the surface.
--
-- Warning : On the specific case of BSplineSurface:
-- if the surface is cut in interval of continuity at least C1,
-- the derivatives are computed on the current interval.
-- else the derivatives are computed on the basis surface.
is redefined static;
D2 (me; U, V : Real;
P : out Pnt from gp;
D1U, D1V : out Vec from gp;
D2U, D2V : out Vec from gp;
D2UV : out Vec from gp)
--- Purpose : Computes the point, the first and second
-- derivatives on the surface.
--
-- Warning : On the specific case of BSplineSurface:
-- if the surface is cut in interval of continuity at least C2,
-- the derivatives are computed on the current interval.
-- else the derivatives are computed on the basis surface.
is redefined static;
D3 (me; U, V : Real;
P : out Pnt from gp;
D1U, D1V : out Vec from gp;
D2U, D2V : out Vec from gp;
D2UV : out Vec from gp;
D3U, D3V : out Vec from gp;
D3UUV, D3UVV : out Vec from gp)
--- Purpose : Computes the point, the first, second and third
-- derivatives on the surface.
--
-- Warning : On the specific case of BSplineSurface:
-- if the surface is cut in interval of continuity at least C3,
-- the derivatives are computed on the current interval.
-- else the derivatives are computed on the basis surface.
is redefined static;
DN (me; U, V : Real; Nu, Nv : Integer)
returns Vec from gp
--- Purpose : Computes the derivative of order Nu in the
-- direction U and Nv in the direction V at the point P(U, V).
--
-- Warning : On the specific case of BSplineSurface:
-- if the surface is cut in interval of continuity CN,
-- the derivatives are computed on the current interval.
-- else the derivatives are computed on the basis surface.
raises
OutOfRange from Standard
--- Purpose : Raised if Nu + Nv < 1 or Nu < 0 or Nv < 0.
is redefined static;
UResolution(me; R3d : Real ) returns Real
---Purpose : Returns the parametric U resolution corresponding
-- to the real space resolution <R3d>.
is redefined static;
VResolution(me; R3d : Real ) returns Real
---Purpose : Returns the parametric V resolution corresponding
-- to the real space resolution <R3d>.
is redefined static;
GetType(me) returns SurfaceType from GeomAbs
---Purpose: Returns the type of the surface : Plane, Cylinder,
-- Cone, Sphere, Torus, BezierSurface,
-- BSplineSurface, SurfaceOfRevolution,
-- SurfaceOfExtrusion, OtherSurface
---C++:inline
is redefined static;
--
-- The following methods must be called when GetType returned
-- the corresponding type.
--
Plane(me) returns Pln from gp
raises NoSuchObject from Standard
is redefined static;
Cylinder(me) returns Cylinder from gp
raises NoSuchObject from Standard
is redefined static;
Cone(me) returns Cone from gp
raises NoSuchObject from Standard
is redefined static;
Sphere(me) returns Sphere from gp
raises NoSuchObject from Standard
is redefined static;
Torus(me) returns Torus from gp
raises NoSuchObject from Standard
is redefined static;
UDegree(me) returns Integer
raises NoSuchObject from Standard
is redefined static;
NbUPoles(me) returns Integer
raises NoSuchObject from Standard
is redefined static;
VDegree(me) returns Integer
raises NoSuchObject from Standard
is redefined static;
NbVPoles(me) returns Integer
raises NoSuchObject from Standard
is redefined static;
NbUKnots(me) returns Integer
raises
NoSuchObject from Standard
is redefined static;
NbVKnots(me) returns Integer
raises
NoSuchObject from Standard
is redefined static;
IsURational(me) returns Boolean
raises
NoSuchObject from Standard
is redefined static;
IsVRational(me) returns Boolean
raises
NoSuchObject from Standard
is redefined static;
Bezier(me) returns BezierSurface from Geom
---Purpose: This will NOT make a copy of the
-- Bezier Surface : If you want to modify
-- the Surface please make a copy yourself
-- Also it will NOT trim the surface to
-- myU/VFirst/Last.
raises
NoSuchObject from Standard
is redefined static;
BSpline(me) returns BSplineSurface from Geom
---Purpose: This will NOT make a copy of the
-- BSpline Surface : If you want to modify
-- the Surface please make a copy yourself
-- Also it will NOT trim the surface to
-- myU/VFirst/Last.
raises
NoSuchObject from Standard
is redefined static;
AxeOfRevolution(me) returns Ax1 from gp
raises
NoSuchObject from Standard -- only for SurfaceOfRevolution
is redefined static;
Direction(me) returns Dir from gp
raises
NoSuchObject from Standard -- only for SurfaceOfExtrusion
is redefined static;
BasisCurve(me) returns HCurve from Adaptor3d
raises
NoSuchObject from Standard -- only for SurfaceOfExtrusion
is redefined static;
BasisSurface(me) returns HSurface from Adaptor3d
raises
NoSuchObject from Standard -- only for Offset Surface
is redefined static;
OffsetValue(me) returns Real from Standard
raises
NoSuchObject from Standard -- only for Offset Surface
is redefined static;
Span (me;Side :Integer; Ideb,Ifin:Integer;
OutIdeb,OutIfin:out Integer;
FKIndx, LKIndx : Integer )
is private;
IfUVBound (me;U,V :Real;Ideb,Ifin,IVdeb,IVfin :out Integer;
USide,VSide: Integer)
returns Boolean from Standard
is private;
load (me : in out; S : Surface from Geom;
UFirst,ULast,VFirst,VLast : Real;
TolU : Real = 0.0;
TolV : Real = 0.0)
is private;
RebuildCache(me; theU, theV : Real)
---Purpose: Rebuilds B-spline cache
-- \param theU first parameter to identify the span for caching
-- \param theV second parameter to identify the span for caching
is static private;
fields
mySurface : Surface from Geom;
mySurfaceType : SurfaceType from GeomAbs;
myUFirst : Real from Standard;
myULast : Real from Standard;
myVFirst : Real from Standard;
myVLast : Real from Standard;
myTolU, myTolV : Real from Standard;
mySurfaceCache : Cache from BSplSLib;
end Surface;

64
src/GeomAdaptor/GeomAdaptor_Surface.cxx
View File

@@ -22,40 +22,52 @@
#define No_Standard_OutOfRange
#define PosTol (Precision::PConfusion()*0.5)
#include <GeomAdaptor_Surface.ixx>
#include <GeomAdaptor_HSurface.hxx>
#include <GeomAdaptor_HCurve.hxx>
#include <GeomAdaptor_Curve.hxx>
#include <Adaptor3d_HCurve.hxx>
#include <Adaptor3d_HSurface.hxx>
#include <Standard_OutOfRange.hxx>
#include <Geom_RectangularTrimmedSurface.hxx>
#include <Geom_BSplineSurface.hxx>
#include <Geom_BezierSurface.hxx>
#include <Geom_OffsetSurface.hxx>
//#include <GeomConvert_BSplineSurfaceKnotSplitting.hxx>
#include <Standard_OutOfRange.hxx>
#include <TColStd_HArray1OfInteger.hxx>
#include <TColStd_Array1OfReal.hxx>
#include <TColStd_Array1OfInteger.hxx>
#include <Geom_Plane.hxx>
#include <Geom_CylindricalSurface.hxx>
#include <Geom_SphericalSurface.hxx>
#include <Geom_ToroidalSurface.hxx>
#include <Geom_ConicalSurface.hxx>
#include <Geom_SurfaceOfRevolution.hxx>
#include <Geom_SurfaceOfLinearExtrusion.hxx>
#include <Geom_Curve.hxx>
#include <Geom_Circle.hxx>
#include <gp_Circ.hxx>
#include <gp_Lin.hxx>
#include <gp_Trsf.hxx>
#include <BSplCLib.hxx>
#include <BSplSLib_Cache.hxx>
#include <Geom_BezierSurface.hxx>
#include <Geom_BSplineSurface.hxx>
#include <Geom_Circle.hxx>
#include <Geom_ConicalSurface.hxx>
#include <Geom_Curve.hxx>
#include <Geom_CylindricalSurface.hxx>
#include <Geom_OffsetSurface.hxx>
#include <Geom_Plane.hxx>
#include <Geom_RectangularTrimmedSurface.hxx>
#include <Geom_SphericalSurface.hxx>
#include <Geom_Surface.hxx>
#include <Geom_SurfaceOfLinearExtrusion.hxx>
#include <Geom_SurfaceOfRevolution.hxx>
#include <Geom_ToroidalSurface.hxx>
#include <GeomAdaptor_Curve.hxx>
#include <GeomAdaptor_HCurve.hxx>
#include <GeomAdaptor_HSurface.hxx>
#include <GeomAdaptor_Surface.hxx>
#include <gp_Ax1.hxx>
#include <gp_Circ.hxx>
#include <gp_Cone.hxx>
#include <gp_Cylinder.hxx>
#include <gp_Dir.hxx>
#include <gp_Lin.hxx>
#include <gp_Pln.hxx>
#include <gp_Pnt.hxx>
#include <gp_Sphere.hxx>
#include <gp_Torus.hxx>
#include <gp_Trsf.hxx>
#include <gp_Vec.hxx>
#include <Precision.hxx>
#include <Standard_ConstructionError.hxx>
#include <Standard_DomainError.hxx>
#include <Standard_NoSuchObject.hxx>
#include <Standard_NullObject.hxx>
#include <Standard_OutOfRange.hxx>
#include <TColStd_Array1OfInteger.hxx>
#include <TColStd_Array1OfReal.hxx>
#include <TColStd_HArray1OfInteger.hxx>
//#include <GeomConvert_BSplineSurfaceKnotSplitting.hxx>
#define myBspl Handle(Geom_BSplineSurface)::DownCast (mySurface)
#define myExtSurf Handle(Geom_SurfaceOfLinearExtrusion)::DownCast (mySurface)
#define myRevSurf Handle(Geom_SurfaceOfRevolution)::DownCast (mySurface)

281
src/GeomAdaptor/GeomAdaptor_Surface.hxx Normal file
View File

@@ -0,0 +1,281 @@
// Created on: 1993-05-14
// Created by: Bruno DUMORTIER
// 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.
#ifndef _GeomAdaptor_Surface_HeaderFile
#define _GeomAdaptor_Surface_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <GeomAbs_SurfaceType.hxx>
#include <Standard_Real.hxx>
#include <BSplSLib_Cache.hxx>
#include <Adaptor3d_Surface.hxx>
#include <GeomAbs_Shape.hxx>
#include <Standard_Integer.hxx>
#include <TColStd_Array1OfReal.hxx>
#include <Standard_Boolean.hxx>
class Geom_Surface;
class Standard_NoSuchObject;
class Standard_OutOfRange;
class Standard_ConstructionError;
class Standard_DomainError;
class Adaptor3d_HSurface;
class gp_Pnt;
class gp_Vec;
class gp_Pln;
class gp_Cylinder;
class gp_Cone;
class gp_Sphere;
class gp_Torus;
class Geom_BezierSurface;
class Geom_BSplineSurface;
class gp_Ax1;
class gp_Dir;
class Adaptor3d_HCurve;
//! An interface between the services provided by any
//! surface from the package Geom and those required
//! of the surface by algorithms which use it.
//! Creation of the loaded surface the surface is C1 by piece
class GeomAdaptor_Surface : public Adaptor3d_Surface
{
public:
DEFINE_STANDARD_ALLOC
GeomAdaptor_Surface();
GeomAdaptor_Surface(const Handle(Geom_Surface)& S);
//! ConstructionError is raised if UFirst>ULast or VFirst>VLast
GeomAdaptor_Surface(const Handle(Geom_Surface)& S, const Standard_Real UFirst, const Standard_Real ULast, const Standard_Real VFirst, const Standard_Real VLast, const Standard_Real TolU = 0.0, const Standard_Real TolV = 0.0);
void Load (const Handle(Geom_Surface)& S);
//! ConstructionError is raised if UFirst>ULast or VFirst>VLast
void Load (const Handle(Geom_Surface)& S, const Standard_Real UFirst, const Standard_Real ULast, const Standard_Real VFirst, const Standard_Real VLast, const Standard_Real TolU = 0.0, const Standard_Real TolV = 0.0);
const Handle(Geom_Surface)& Surface() const;
Standard_Real FirstUParameter() const Standard_OVERRIDE;
Standard_Real LastUParameter() const Standard_OVERRIDE;
Standard_Real FirstVParameter() const Standard_OVERRIDE;
Standard_Real LastVParameter() const Standard_OVERRIDE;
Standard_EXPORT GeomAbs_Shape UContinuity() const Standard_OVERRIDE;
Standard_EXPORT GeomAbs_Shape VContinuity() const Standard_OVERRIDE;
//! Returns the number of U intervals for continuity
//! <S>. May be one if UContinuity(me) >= <S>
Standard_EXPORT Standard_Integer NbUIntervals (const GeomAbs_Shape S) const Standard_OVERRIDE;
//! Returns the number of V intervals for continuity
//! <S>. May be one if VContinuity(me) >= <S>
Standard_EXPORT Standard_Integer NbVIntervals (const GeomAbs_Shape S) const Standard_OVERRIDE;
//! Returns the intervals with the requested continuity
//! in the U direction.
Standard_EXPORT void UIntervals (TColStd_Array1OfReal& T, const GeomAbs_Shape S) const Standard_OVERRIDE;
//! Returns the intervals with the requested continuity
//! in the V direction.
Standard_EXPORT void VIntervals (TColStd_Array1OfReal& T, const GeomAbs_Shape S) const Standard_OVERRIDE;
//! Returns a surface trimmed in the U direction
//! equivalent of <me> between
//! parameters <First> and <Last>. <Tol> is used to
//! test for 3d points confusion.
//! If <First> >= <Last>
Standard_EXPORT Handle(Adaptor3d_HSurface) UTrim (const Standard_Real First, const Standard_Real Last, const Standard_Real Tol) const Standard_OVERRIDE;
//! Returns a surface trimmed in the V direction between
//! parameters <First> and <Last>. <Tol> is used to
//! test for 3d points confusion.
//! If <First> >= <Last>
Standard_EXPORT Handle(Adaptor3d_HSurface) VTrim (const Standard_Real First, const Standard_Real Last, const Standard_Real Tol) const Standard_OVERRIDE;
Standard_EXPORT Standard_Boolean IsUClosed() const Standard_OVERRIDE;
Standard_EXPORT Standard_Boolean IsVClosed() const Standard_OVERRIDE;
Standard_EXPORT Standard_Boolean IsUPeriodic() const Standard_OVERRIDE;
Standard_EXPORT Standard_Real UPeriod() const Standard_OVERRIDE;
Standard_EXPORT Standard_Boolean IsVPeriodic() const Standard_OVERRIDE;
Standard_EXPORT Standard_Real VPeriod() const Standard_OVERRIDE;
//! Computes the point of parameters U,V on the surface.
Standard_EXPORT gp_Pnt Value (const Standard_Real U, const Standard_Real V) const Standard_OVERRIDE;
//! Computes the point of parameters U,V on the surface.
Standard_EXPORT void D0 (const Standard_Real U, const Standard_Real V, gp_Pnt& P) const Standard_OVERRIDE;
//! Computes the point and the first derivatives on
//! the surface.
//!
//! Warning : On the specific case of BSplineSurface:
//! if the surface is cut in interval of continuity at least C1,
//! the derivatives are computed on the current interval.
//! else the derivatives are computed on the basis surface.
Standard_EXPORT void D1 (const Standard_Real U, const Standard_Real V, gp_Pnt& P, gp_Vec& D1U, gp_Vec& D1V) const Standard_OVERRIDE;
//! Computes the point, the first and second
//! derivatives on the surface.
//!
//! Warning : On the specific case of BSplineSurface:
//! if the surface is cut in interval of continuity at least C2,
//! the derivatives are computed on the current interval.
//! else the derivatives are computed on the basis surface.
Standard_EXPORT void D2 (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) const Standard_OVERRIDE;
//! Computes the point, the first, second and third
//! derivatives on the surface.
//!
//! Warning : On the specific case of BSplineSurface:
//! if the surface is cut in interval of continuity at least C3,
//! the derivatives are computed on the current interval.
//! else the derivatives are computed on the basis surface.
Standard_EXPORT void D3 (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) const Standard_OVERRIDE;
//! Computes the derivative of order Nu in the
//! direction U and Nv in the direction V at the point P(U, V).
//!
//! Warning : On the specific case of BSplineSurface:
//! if the surface is cut in interval of continuity CN,
//! the derivatives are computed on the current interval.
//! else the derivatives are computed on the basis surface.
//! Raised if Nu + Nv < 1 or Nu < 0 or Nv < 0.
Standard_EXPORT gp_Vec DN (const Standard_Real U, const Standard_Real V, const Standard_Integer Nu, const Standard_Integer Nv) const Standard_OVERRIDE;
//! Returns the parametric U resolution corresponding
//! to the real space resolution <R3d>.
Standard_EXPORT Standard_Real UResolution (const Standard_Real R3d) const Standard_OVERRIDE;
//! Returns the parametric V resolution corresponding
//! to the real space resolution <R3d>.
Standard_EXPORT Standard_Real VResolution (const Standard_Real R3d) const Standard_OVERRIDE;
//! Returns the type of the surface : Plane, Cylinder,
//! Cone, Sphere, Torus, BezierSurface,
//! BSplineSurface, SurfaceOfRevolution,
//! SurfaceOfExtrusion, OtherSurface
GeomAbs_SurfaceType GetType() const Standard_OVERRIDE;
Standard_EXPORT gp_Pln Plane() const Standard_OVERRIDE;
Standard_EXPORT gp_Cylinder Cylinder() const Standard_OVERRIDE;
Standard_EXPORT gp_Cone Cone() const Standard_OVERRIDE;
Standard_EXPORT gp_Sphere Sphere() const Standard_OVERRIDE;
Standard_EXPORT gp_Torus Torus() const Standard_OVERRIDE;
Standard_EXPORT Standard_Integer UDegree() const Standard_OVERRIDE;
Standard_EXPORT Standard_Integer NbUPoles() const Standard_OVERRIDE;
Standard_EXPORT Standard_Integer VDegree() const Standard_OVERRIDE;
Standard_EXPORT Standard_Integer NbVPoles() const Standard_OVERRIDE;
Standard_EXPORT Standard_Integer NbUKnots() const Standard_OVERRIDE;
Standard_EXPORT Standard_Integer NbVKnots() const Standard_OVERRIDE;
Standard_EXPORT Standard_Boolean IsURational() const Standard_OVERRIDE;
Standard_EXPORT Standard_Boolean IsVRational() const Standard_OVERRIDE;
//! This will NOT make a copy of the
//! Bezier Surface : If you want to modify
//! the Surface please make a copy yourself
//! Also it will NOT trim the surface to
//! myU/VFirst/Last.
Standard_EXPORT Handle(Geom_BezierSurface) Bezier() const Standard_OVERRIDE;
//! This will NOT make a copy of the
//! BSpline Surface : If you want to modify
//! the Surface please make a copy yourself
//! Also it will NOT trim the surface to
//! myU/VFirst/Last.
Standard_EXPORT Handle(Geom_BSplineSurface) BSpline() const Standard_OVERRIDE;
Standard_EXPORT gp_Ax1 AxeOfRevolution() const Standard_OVERRIDE;
Standard_EXPORT gp_Dir Direction() const Standard_OVERRIDE;
Standard_EXPORT Handle(Adaptor3d_HCurve) BasisCurve() const Standard_OVERRIDE;
Standard_EXPORT Handle(Adaptor3d_HSurface) BasisSurface() const Standard_OVERRIDE;
Standard_EXPORT Standard_Real OffsetValue() const Standard_OVERRIDE;
protected:
private:
Standard_EXPORT void Span (const Standard_Integer Side, const Standard_Integer Ideb, const Standard_Integer Ifin, Standard_Integer& OutIdeb, Standard_Integer& OutIfin, const Standard_Integer FKIndx, const Standard_Integer LKIndx) const;
Standard_EXPORT Standard_Boolean IfUVBound (const Standard_Real U, const Standard_Real V, Standard_Integer& Ideb, Standard_Integer& Ifin, Standard_Integer& IVdeb, Standard_Integer& IVfin, const Standard_Integer USide, const Standard_Integer VSide) const;
Standard_EXPORT void load (const Handle(Geom_Surface)& S, const Standard_Real UFirst, const Standard_Real ULast, const Standard_Real VFirst, const Standard_Real VLast, const Standard_Real TolU = 0.0, const Standard_Real TolV = 0.0);
//! Rebuilds B-spline cache
//! \param theU first parameter to identify the span for caching
//! \param theV second parameter to identify the span for caching
Standard_EXPORT void RebuildCache (const Standard_Real theU, const Standard_Real theV) const;
Handle(Geom_Surface) mySurface;
GeomAbs_SurfaceType mySurfaceType;
Standard_Real myUFirst;
Standard_Real myULast;
Standard_Real myVFirst;
Standard_Real myVLast;
Standard_Real myTolU;
Standard_Real myTolV;
Handle(BSplSLib_Cache) mySurfaceCache;
};
#include <GeomAdaptor_Surface.lxx>
#endif // _GeomAdaptor_Surface_HeaderFile