OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-04-03 17:56:21 +03:00
Code Packages Releases Activity

0024023: Revamp the OCCT Handle -- general

Browse Source 
Missing headers added; includes of headers "Handle_...hxx" removed.

Misuses of macro Handle() and its use in typedefs corrected.

Alias classes Profile and Option are removed from IFSelect; ones defined in MoniTool are used directly.

Removed header files defining only Handle classes (except Image_PixMap_Handle.hxx)

Classes SelectMgr_BaseFrustum and now inherit Standard_Transient and can be manipulated by Handle (not NCollection_Handle)

Fixed reference-type local variable pointing to temporary object

Use of handle in conditional expressions and comparisons to NULL are replaced by call to method IsNull()
This commit is contained in:
abv 2015-06-30 10:25:12 +03:00
parent 35c0599a42
commit c04c30b3ee
311 changed files with 725 additions and 1175 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/AIS/AIS_AngleDimension.hxx
View File

@ -34,6 +34,7 @@
#include <TopoDS_Face.hxx>
#include <TopoDS_Vertex.hxx>
class AIS_AngleDimension;
DEFINE_STANDARD_HANDLE (AIS_AngleDimension, AIS_Dimension)
//! Angle dimension. Can be constructed:

1
src/AIS/AIS_DiameterDimension.hxx
View File

@ -24,6 +24,7 @@
#include <Standard_Macro.hxx>
#include <Standard_Type.hxx>
class AIS_DiameterDimension;
DEFINE_STANDARD_HANDLE (AIS_DiameterDimension, AIS_Dimension)
//! Diameter dimension. Can be constructued:

1
src/AIS/AIS_Dimension.hxx
View File

@ -42,6 +42,7 @@
#include <NCollection_Sequence.hxx>
#include <NCollection_Handle.hxx>
class AIS_Dimension;
DEFINE_STANDARD_HANDLE(AIS_Dimension, AIS_InteractiveObject)
//! AIS_Dimension is a base class for 2D presentations of linear (length, diameter, radius)

2
src/AIS/AIS_GraphicTool.cxx
View File

@ -28,7 +28,7 @@
#include <Aspect_InteriorStyle.hxx>
#include <Prs3d_ShadingAspect.hxx>
#include <Prs3d_IsoAspect.hxx>
static Handle(Prs3d_LineAspect) GetLineAspect(const Handle(Prs3d_Drawer)& Dr,
const AIS_TypeOfAttribute Att)

8
src/AIS/AIS_InteractiveContext.cxx
View File

@ -395,11 +395,11 @@ void AIS_InteractiveContext::SetViewAffinity (const Handle(AIS_InteractiveObject
anAffinity->SetVisible (aCView->ViewId, theIsVisible == Standard_True);
if (theIsVisible)
{
theView->View()->ChangeHiddenObjects()->Remove (theIObj);
theView->View()->ChangeHiddenObjects()->Remove (theIObj.get());
}
else
{
theView->View()->ChangeHiddenObjects()->Add (theIObj);
theView->View()->ChangeHiddenObjects()->Add (theIObj.get());
}
}
@ -2435,7 +2435,7 @@ void AIS_InteractiveContext::ClearGlobal (const Handle(AIS_InteractiveObject)& t
myMainVwr->Viewer()->UnregisterObject (theIObj);
for (myMainVwr->InitDefinedViews(); myMainVwr->MoreDefinedViews(); myMainVwr->NextDefinedViews())
{
myMainVwr->DefinedView()->View()->ChangeHiddenObjects()->Remove (theIObj);
myMainVwr->DefinedView()->View()->ChangeHiddenObjects()->Remove (theIObj.get());
}
if (theToUpdateviewer
@ -2826,7 +2826,7 @@ void AIS_InteractiveContext::Disconnect (const Handle(AIS_InteractiveObject)& th
theObj->Disconnect (theObjToDisconnect);
mgrSelector->Remove (theObjToDisconnect);
}
else if (theAssembly->IsInstance ("AIS_ConnectedInteractive") && theObjToDisconnect == NULL)
else if (theAssembly->IsInstance ("AIS_ConnectedInteractive") && theObjToDisconnect.IsNull())
{
const Handle(AIS_ConnectedInteractive)& theObj =
Handle(AIS_ConnectedInteractive)::DownCast (theAssembly);

2
src/AIS/AIS_InteractiveContext_2.cxx
View File

@ -674,7 +674,7 @@ Standard_Integer AIS_InteractiveContext::PurgeDisplay()
//=======================================================================
Standard_Integer AIS_InteractiveContext::PurgeViewer(const Handle(V3d_Viewer)& Vwr)
{
const Handle(Graphic3d_StructureManager)& GSM = Vwr->Viewer();
Handle(Graphic3d_StructureManager) GSM = Vwr->Viewer();
Standard_Integer NbCleared(0);
Graphic3d_MapOfStructure SOS;
GSM->DisplayedStructures(SOS);

3
src/AIS/AIS_MaxRadiusDimension.cxx
View File

@ -41,6 +41,7 @@
#include <BRepAdaptor_Curve.hxx>
#include <Geom_Ellipse.hxx>
#include <Geom_OffsetCurve.hxx>
#include <Geom_TrimmedCurve.hxx>
#include <Geom_Plane.hxx>
#include <Geom_Surface.hxx>
@ -323,7 +324,7 @@ void AIS_MaxRadiusDimension::ComputeSelection(const Handle(SelectMgr_Selection)&
else
parStart = par;
Handle(Geom_TrimmedCurve)TrimCurve;
Handle(Geom_Curve)TrimCurve;
if(myIsOffset)
{
Handle(Geom_Curve) aCurve = myOffsetCurve;

3
src/AIS/AIS_MinRadiusDimension.cxx
View File

@ -42,6 +42,7 @@
#include <BRepAdaptor_Curve.hxx>
#include <Geom_Ellipse.hxx>
#include <Geom_OffsetCurve.hxx>
#include <Geom_TrimmedCurve.hxx>
#include <Geom_Plane.hxx>
#include <Geom_Surface.hxx>
@ -325,7 +326,7 @@ void AIS_MinRadiusDimension::ComputeSelection(const Handle(SelectMgr_Selection)&
}
else
parStart = par;
Handle(Geom_TrimmedCurve)TrimCurve;
Handle(Geom_Curve)TrimCurve;
if(myIsOffset)
{
Handle(Geom_Curve) aCurve = myOffsetCurve;

1
src/AIS/AIS_PointCloud.hxx
View File

@ -27,6 +27,7 @@
#include <TColgp_HArray1OfDir.hxx>
#include <TColgp_HArray1OfPnt.hxx>
class AIS_PointCloud;
DEFINE_STANDARD_HANDLE(AIS_PointCloud, AIS_InteractiveObject)
//! Interactive object for set of points.

1
src/AIS/AIS_RadiusDimension.hxx
View File

@ -22,6 +22,7 @@
#include <Standard.hxx>
#include <Standard_Macro.hxx>
class AIS_RadiusDimension;
DEFINE_STANDARD_HANDLE (AIS_RadiusDimension,AIS_Dimension)
//! Radius dimension. Can be constructued:

2
src/BOPAlgo/BOPAlgo_PaveFiller_6.cxx
View File

@ -1131,7 +1131,7 @@ void BOPAlgo_PaveFiller::UpdateFaceInfo
const BOPDS_Curve& theNC,
const Standard_Real theTolR3D,
const BOPDS_IndexedMapOfPaveBlock& theMPBOnIn,
Handle(BOPDS_PaveBlock&) aPBOut)
Handle(BOPDS_PaveBlock)& aPBOut)
{
Standard_Boolean bRet;
Standard_Real aT1, aT2, aTm, aTx;

2
src/BOPAlgo/BOPAlgo_PaveFiller_7.cxx
View File

@ -516,7 +516,7 @@ void BOPAlgo_PaveFiller::MakePCurves()
}
//
Handle(BOPDS_CommonBlock) aCB=myDS->CommonBlock(aPB);
if (!aCB) {
if (aCB.IsNull()) {
continue;
}
//

1
src/BOPDS/BOPDS_ListOfPaveBlock.hxx
View File

@ -17,6 +17,7 @@
#include <NCollection_List.hxx>
class BOPDS_PaveBlock;
typedef NCollection_List<Handle(BOPDS_PaveBlock)> BOPDS_ListOfPaveBlock;
typedef BOPDS_ListOfPaveBlock::Iterator BOPDS_ListIteratorOfListOfPaveBlock;

1
src/BOPTools/BOPTools_AlgoTools2D.cxx
View File

@ -31,6 +31,7 @@
#include <Geom2d_Parabola.hxx>
#include <Geom2d_Hyperbola.hxx>
#include <Geom2d_TrimmedCurve.hxx>
#include <Geom2d_BSplineCurve.hxx>
#include <Geom2dAdaptor.hxx>

2
src/BRepCheck/BRepCheck_Solid.cxx
View File

@ -41,7 +41,7 @@
#include <BRepCheck.hxx>
#include <BRepCheck_ListOfStatus.hxx>
class BRepCheck_HSC;
DEFINE_STANDARD_HANDLE(BRepCheck_HSC, MMgt_TShared);
//=======================================================================
//class : BRepCheck_HSC

2
src/BRepFill/BRepFill_Filling.cxx
View File

@ -60,7 +60,7 @@
#include <Geom2d_BezierCurve.hxx>
#include <Geom2d_TrimmedCurve.hxx>
#include <Geom_Surface.hxx>
#include <Geom_BSplineSurface.hxx>
#include <TColgp_SequenceOfXY.hxx>
#include <GeomPlate_PlateG0Criterion.hxx>

2
src/BRepFill/BRepFill_Sweep.cxx
View File

@ -45,7 +45,7 @@
#include <Geom_BezierCurve.hxx>
#include <Geom_BSplineCurve.hxx>
#include <Geom2d_Line.hxx>
#include <Geom2d_Curve.hxx>
#include <Geom2d_BSplineCurve.hxx>
#include <Geom2d_TrimmedCurve.hxx>
#include <GeomLib.hxx>
#include <GeomLib_IsPlanarSurface.hxx>

34
src/BRepGProp/BRepGProp_Gauss.cxx
View File

@ -176,7 +176,7 @@ Standard_Integer BRepGProp_Gauss::MaxSubs(const Standard_Integer theN,
//function : Init
//purpose :
//=======================================================================
void BRepGProp_Gauss::Init(Handle(Vector)& theOutVec,
void BRepGProp_Gauss::Init(NCollection_Handle<math_Vector>& theOutVec,
const Standard_Real theValue,
const Standard_Integer theFirst,
const Standard_Integer theLast)
@ -227,10 +227,10 @@ Standard_Integer BRepGProp_Gauss::FillIntervalBounds(
const TColStd_Array1OfReal& theKnots,
const Standard_Integer theNumSubs,
InertiaArray& theInerts,
Handle(Vector)& theParam1,
Handle(Vector)& theParam2,
Handle(Vector)& theError,
Handle(Vector)& theCommonError)
NCollection_Handle<math_Vector>& theParam1,
NCollection_Handle<math_Vector>& theParam2,
NCollection_Handle<math_Vector>& theError,
NCollection_Handle<math_Vector>& theCommonError)
{
const Standard_Integer aSize =
Max(theKnots.Upper(), MaxSubs(theKnots.Upper() - 1, theNumSubs));
@ -550,10 +550,10 @@ Standard_Real BRepGProp_Gauss::Compute(
InertiaArray anInertiaU = new NCollection_Array1<Inertia>(1, SM);
// Prepare Gauss points and weights
Handle(Vector) LGaussP[2];
Handle(Vector) LGaussW[2];
Handle(Vector) UGaussP[2];
Handle(Vector) UGaussW[2];
NCollection_Handle<math_Vector> LGaussP[2];
NCollection_Handle<math_Vector> LGaussW[2];
NCollection_Handle<math_Vector> UGaussP[2];
NCollection_Handle<math_Vector> UGaussW[2];
const Standard_Integer aNbGaussPoint =
RealToInt(Ceiling(ERROR_ALGEBR_RATIO * GPM));
@ -568,14 +568,14 @@ Standard_Real BRepGProp_Gauss::Compute(
UGaussW[0] = new math_Vector(1, GPM);
UGaussW[1] = new math_Vector(1, aNbGaussPoint);
Handle(Vector) L1 = new math_Vector(1, SM);
Handle(Vector) L2 = new math_Vector(1, SM);
Handle(Vector) U1 = new math_Vector(1, SM);
Handle(Vector) U2 = new math_Vector(1, SM);
NCollection_Handle<math_Vector> L1 = new math_Vector(1, SM);
NCollection_Handle<math_Vector> L2 = new math_Vector(1, SM);
NCollection_Handle<math_Vector> U1 = new math_Vector(1, SM);
NCollection_Handle<math_Vector> U2 = new math_Vector(1, SM);
Handle(Vector) ErrL = new math_Vector(1, SM, 0.0);
Handle(Vector) ErrU = new math_Vector(1, SM, 0.0);
Handle(Vector) ErrUL = new math_Vector(1, SM, 0.0);
NCollection_Handle<math_Vector> ErrL = new math_Vector(1, SM, 0.0);
NCollection_Handle<math_Vector> ErrU = new math_Vector(1, SM, 0.0);
NCollection_Handle<math_Vector> ErrUL = new math_Vector(1, SM, 0.0);
// Face parametrization in U and V direction
Standard_Real BV1, BV2, BU1, BU2;
@ -746,7 +746,7 @@ Standard_Real BRepGProp_Gauss::Compute(
if (Abs(u2 - u1) < EPS_PARAM)
continue;
Handle(Vector) aDummy;
NCollection_Handle<math_Vector> aDummy;
iUSubEnd = FillIntervalBounds(u1, u2, UKnots, NumSubs, anInertiaU, U1, U2, ErrU, aDummy);
UMaxSubs = BRepGProp_Gauss::MaxSubs(iUSubEnd);

10
src/BRepGProp/BRepGProp_Gauss.hxx
View File

@ -251,7 +251,7 @@ private: //! @name private methods
const Standard_Integer theCoeff = 32);
static void Init(
Handle(Vector)& theOutVec,
NCollection_Handle<math_Vector>& theOutVec,
const Standard_Real theValue,
const Standard_Integer theFirst = 0,
const Standard_Integer theLast = 0);
@ -268,10 +268,10 @@ private: //! @name private methods
const TColStd_Array1OfReal& theKnots,
const Standard_Integer theNumSubs,
InertiaArray& theInerts,
Handle(Vector)& theParam1,
Handle(Vector)& theParam2,
Handle(Vector)& theError,
Handle(Vector)& theCommonError);
NCollection_Handle<math_Vector>& theParam1,
NCollection_Handle<math_Vector>& theParam2,
NCollection_Handle<math_Vector>& theError,
NCollection_Handle<math_Vector>& theCommonError);
private: //! @name private fields

2
src/BRepMAT2d/BRepMAT2d_BisectingLocus.cxx
View File

@ -30,7 +30,7 @@
# include <MAT_ListOfBisector.hxx>
# include <MAT_DataMapOfIntegerBasicElt.hxx>
# include <MAT_DataMapIteratorOfDataMapOfIntegerBasicElt.hxx>
# include <Geom2d_Curve.hxx>
# include <Geom2d_TrimmedCurve.hxx>
# include <gp_Pnt2d.hxx>
# include <TColGeom2d_SequenceOfGeometry.hxx>
# include <Precision.hxx>

4
src/BRepMAT2d/BRepMAT2d_Explorer.cxx
View File

@ -613,12 +613,12 @@ void AdjustCurveEnd(Handle(Geom2d_BoundedCurve)& theC2d, const gp_Pnt2d theP,
if(isFirst)
{
gp_Pnt2d aP = theC2d->Value(theC2d->LastParameter());
theC2d = GCE2d_MakeSegment(theP, aP);
theC2d = GCE2d_MakeSegment(theP, aP).Value();
}
else
{
gp_Pnt2d aP = theC2d->Value(theC2d->FirstParameter());
theC2d = GCE2d_MakeSegment(aP, theP);
theC2d = GCE2d_MakeSegment(aP, theP).Value();
}
}
else

1
src/BRepMesh/BRepMesh.hxx
View File

@ -47,6 +47,7 @@
class BRepMesh_Vertex;
class TopoDS_Edge;
class TopoDS_Vertex;
class BRepMesh_FaceAttribute;
class BRepMesh_VertexInspector;
class BRepMesh_CircleInspector;
class BRepMesh_Classifier;

1
src/BRepMesh/BRepMesh_EdgeTessellationExtractor.hxx
View File

@ -28,6 +28,7 @@ class Poly_Triangulation;
class Poly_PolygonOnTriangulation;
class TopoDS_Edge;
class TopoDS_Face;
class Geom2d_Curve;
//! Auxiliary class implements functionality retrieving tessellated
//! representation of an edge stored in polygon.

1
src/BRepMesh/BRepMesh_FastDiscretFace.cxx
View File

@ -32,6 +32,7 @@
#include <GeomLib.hxx>
#include <Geom_Surface.hxx>
#include <Geom_BSplineSurface.hxx>
#include <Geom_BezierSurface.hxx>
#include <GCPnts_TangentialDeflection.hxx>
#include <GCPnts_AbscissaPoint.hxx>

2
src/BRepMesh/BRepMesh_ShapeTool.hxx
View File

@ -18,9 +18,11 @@
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Macro.hxx>
#include <BRepAdaptor_HSurface.hxx>
#include <BRepMesh_FaceAttribute.hxx>
#include <BRepMesh.hxx>
class Poly_Triangulation;
class TopoDS_Face;
class TopoDS_Edge;
class Bnd_Box;

1
src/BRepOffset/BRepOffset_Inter2d.cxx
View File

@ -49,6 +49,7 @@
#include <Geom_Line.hxx>
#include <Geom_Plane.hxx>
#include <Geom_TrimmedCurve.hxx>
#include <Geom_BSplineCurve.hxx>
#include <GeomConvert_CompCurveToBSplineCurve.hxx>
#include <Precision.hxx>
#include <Geom2d_TrimmedCurve.hxx>

1
src/BRepOffset/BRepOffset_MakeOffset.cxx
View File

@ -92,6 +92,7 @@
#include <BRepAdaptor_Curve2d.hxx>
#include <TopTools_DataMapIteratorOfDataMapOfShapeListOfShape.hxx>
#include <Geom_SphericalSurface.hxx>
#include <Geom_CylindricalSurface.hxx>
#include <TopoDS_Wire.hxx>
#include <BRepTools_Substitution.hxx>
#include <Geom_TrimmedCurve.hxx>

4
src/BRepOffset/BRepOffset_Offset.cxx
View File

@ -186,8 +186,8 @@ static void UpdateEdge (const TopoDS_Edge& E,
//=======================================================================
static void ComputeCurve3d(TopoDS_Edge Edge,
Handle(Geom2d_Curve) Curve,
Handle(Geom_Surface) Surf,
const Handle(Geom2d_Curve)& Curve,
const Handle(Geom_Surface)& Surf,
const TopLoc_Location Loc,
Standard_Real Tol)
{

1
src/BRepOffsetAPI/BRepOffsetAPI_ThruSections.cxx
View File

@ -55,6 +55,7 @@
#include <GeomAbs_Shape.hxx>
#include <Geom_Curve.hxx>
#include <Geom_Plane.hxx>
#include <Geom_BSplineSurface.hxx>
#include <Geom_TrimmedCurve.hxx>
#include <Geom_BezierCurve.hxx>

1
src/BRepTest/BRepTest_BasicCommands.cxx
View File

@ -48,6 +48,7 @@
#include <ProjLib_ComputeApproxOnPolarSurface.hxx>
#include <DrawTrSurf.hxx>
#include <Geom_Plane.hxx>
#include <Draw_Segment3D.hxx>
#include <Draw_Marker3D.hxx>

2
src/BRepTest/BRepTest_FilletCommands.cxx
View File

@ -634,7 +634,7 @@ static Standard_Integer blend1(Draw_Interpretor& di, Standard_Integer narg, cons
for (i=1;i<=nb;i++)
{Standard_Integer s=aRakk.NbSection(i);
for (j=1;j<=s;j++)
{Handle(Geom_TrimmedCurve Sec);
{Handle(Geom_TrimmedCurve) Sec;
aRakk.Section(i,j,Sec);
Sprintf(localname, "%s%d%d" ,"sec",i,j);
temp =localname;

2
src/BRepTools/BRepTools_Modifier.cxx
View File

@ -52,7 +52,7 @@
#include <gp_Trsf.hxx>
#include <BRepTools_TrsfModification.hxx>
#include <Message_ProgressSentry.hxx>
#include <Geom_Surface.hxx>
//=======================================================================

1
src/BRepTools/BRepTools_ShapeSet.cxx
View File

@ -52,6 +52,7 @@
#include <TColStd_HArray1OfReal.hxx>
#include <Poly_Triangulation.hxx>
#include <Poly_PolygonOnTriangulation.hxx>
#include <Poly_Polygon2D.hxx>
#include <Message_ProgressIndicator.hxx>
#include <Message_ProgressSentry.hxx>

2
src/BVH/BVH.cxx
View File

@ -21,6 +21,8 @@
#include <BVH_SweepPlaneBuilder.hxx>
#include <BVH_SpatialMedianBuilder.hxx>
#include <Standard_Real.hxx>
// Specific instantiations of struct templates to avoid compilation warnings
template class BVH_Box<Standard_Real, 2>;

5
src/BinTObjDrivers/BinTObjDrivers_DocumentRetrievalDriver.cxx
View File

@ -19,11 +19,6 @@
#include <BinLDrivers.hxx>
#include <BinTObjDrivers.hxx>
IMPLEMENT_STANDARD_HANDLE (BinTObjDrivers_DocumentRetrievalDriver,
BinLDrivers_DocumentRetrievalDriver)
IMPLEMENT_STANDARD_RTTIEXT(BinTObjDrivers_DocumentRetrievalDriver,
BinLDrivers_DocumentRetrievalDriver)
//=======================================================================
//function : BinTObjDrivers_DocumentRetrievalDriver
//purpose :

5
src/BinTObjDrivers/BinTObjDrivers_DocumentStorageDriver.cxx
View File

@ -19,11 +19,6 @@
#include <BinLDrivers.hxx>
#include <BinTObjDrivers.hxx>
IMPLEMENT_STANDARD_HANDLE (BinTObjDrivers_DocumentStorageDriver,
BinLDrivers_DocumentStorageDriver)
IMPLEMENT_STANDARD_RTTIEXT(BinTObjDrivers_DocumentStorageDriver,
BinLDrivers_DocumentStorageDriver)
//=======================================================================
//function : BinTObjDrivers_DocumentStorageDriver
//purpose :

1
src/BinTools/BinTools_ShapeSet.cxx
View File

@ -23,6 +23,7 @@
#include <Poly_PolygonOnTriangulation.hxx>
#include <Poly_Polygon3D.hxx>
#include <Poly_Triangulation.hxx>
#include <Poly_Polygon2D.hxx>
#include <BRepTools.hxx>
#include <BRep_Tool.hxx>
#include <BRep_TVertex.hxx>

1
src/ChFi2d/ChFi2d_ChamferAPI.cxx
View File

@ -16,6 +16,7 @@
#include <Precision.hxx>
#include <gp_Pnt.hxx>
#include <GC_MakeLine.hxx>
#include <Geom_Line.hxx>
#include <BRep_Tool.hxx>
#include <BRepBuilderAPI_MakeEdge.hxx>
#include <TopoDS_Iterator.hxx>

1
src/ChFi3d/ChFi3d_Builder_2.cxx
View File

@ -34,6 +34,7 @@
#include <ElCLib.hxx>
#include <Geom_BSplineCurve.hxx>
#include <Geom_BSplineSurface.hxx>
#include <Geom_Line.hxx>
#include <Geom_Plane.hxx>
#include <Geom2d_Curve.hxx>

2
src/ChFi3d/ChFi3d_Builder_C2.cxx
View File

@ -93,7 +93,7 @@ static void Reduce(const Standard_Real& p1,
{
GeomAdaptor_Surface& s1 = hs1->ChangeSurface();
GeomAdaptor_Surface& s2 = hs2->ChangeSurface();
const Handle(Geom_Surface&) surf = s1.Surface();
const Handle(Geom_Surface)& surf = s1.Surface();
Standard_Real ud,uf,vd,vf;
surf->Bounds(ud,uf,vd,vf);
Standard_Real milmoins = 0.51*vd+0.49*vf, milplus = 0.49*vd+0.51*vf;

1
src/ChFi3d/ChFi3d_Builder_CnCrn.cxx
View File

@ -64,6 +64,7 @@
#include <Geom2d_Line.hxx>
#include <Geom_Line.hxx>
#include <Geom_Curve.hxx>
#include <Geom_BSplineSurface.hxx>
#include <Geom2d_TrimmedCurve.hxx>
#include <GeomInt_IntSS.hxx>
#include <GeomLib.hxx>

2
src/ChFi3d/ChFi3d_Builder_SpKP.cxx
View File

@ -580,7 +580,7 @@ static void FillSD (TopOpeBRepDS_DataStructure& DStr,
for(;trouve;) {
const HatchGen_PointOnElement& PEtemp = pPH->Point(LeType);
IE = PEtemp.Index();
Handle(BRepAdaptor_HCurve2d) HE = Handle(BRepAdaptor_HCurve2d::DownCast(M(IE)));
Handle(BRepAdaptor_HCurve2d) HE = Handle(BRepAdaptor_HCurve2d)::DownCast(M(IE));
if(!HE.IsNull()) {
const TopoDS_Edge& Etemp = HE->ChangeCurve2d().Edge();
TopExp::Vertices(Etemp,V1,V2);

1
src/ChFi3d/ChFi3d_ChBuilder_C3.cxx
View File

@ -48,6 +48,7 @@
#include <Geom_Plane.hxx>
#include <Geom2d_Line.hxx>
#include <Geom_Line.hxx>
#include <Geom_BSplineSurface.hxx>
#include <GeomAdaptor_HSurface.hxx>
#include <BRepAdaptor_Surface.hxx>

1
src/ChFi3d/ChFi3d_FilBuilder_C2.cxx
View File

@ -38,6 +38,7 @@
#include <Geom_BSplineCurve.hxx>
#include <Geom2d_TrimmedCurve.hxx>
#include <Geom2d_BSplineCurve.hxx>
#include <Geom_BSplineSurface.hxx>
#include <Law_Linear.hxx>
#include <BRepBlend_CSCircular.hxx>
#include <BRepBlend_Line.hxx>

1
src/ChFi3d/ChFi3d_FilBuilder_C3.cxx
View File

@ -45,6 +45,7 @@
#include <Geom2d_Curve.hxx>
#include <Geom2d_TrimmedCurve.hxx>
#include <Geom2d_Line.hxx>
#include <Geom_BSplineSurface.hxx>
#include <IntAna_QuadQuadGeo.hxx>
#include <IntCurveSurface_IntersectionPoint.hxx>

3
src/DBRep/DBRep_IsoBuilder.cxx
View File

@ -188,7 +188,8 @@ Geom2dHatch_Hatcher (Geom2dHatch_Intersector (IntersectorConfusion,
// if U1 and U2 coincide-->do nothing
if (Abs (U1 - U2) <= Precision::PConfusion()) continue;
Handle (Geom2d_TrimmedCurve) TrimPCurve = new Geom2d_TrimmedCurve (PCurve, U1, U2);
AddElement (TrimPCurve, TopologicalEdge.Orientation());
Geom2dAdaptor_Curve aGAC (TrimPCurve);
AddElement (aGAC, TopologicalEdge.Orientation());
}
}

2
src/Draw/Draw_VariableCommands.cxx
View File

@ -527,7 +527,7 @@ static Standard_Integer copy(Draw_Interpretor& , Standard_Integer n, const char*
D = D->Copy();
else
// clear old name
Draw::Set(a[i],Handle(Draw_Drawable3D()));
Draw::Set(a[i],Handle(Draw_Drawable3D)());
Draw::Set(a[i+1],D);
}

1
src/DrawFairCurve/DrawFairCurve_Batten.cxx
View File

@ -19,6 +19,7 @@
#include <FairCurve_Batten.hxx>
#include <FairCurve_AnalysisCode.hxx>
#include <GeomTools_Curve2dSet.hxx>
#include <Geom2d_BSplineCurve.hxx>
DrawFairCurve_Batten::DrawFairCurve_Batten(const Standard_Address TheBatten)
: DrawTrSurf_BSplineCurve2d( ((FairCurve_Batten*)TheBatten)->Curve()),

1
src/Expr/Expr_Array1OfNamedUnknown.hxx
View File

@ -19,6 +19,7 @@
#include <NCollection_Array1.hxx>
class Expr_NamedUnknown;
typedef NCollection_Array1<Handle(Expr_NamedUnknown)> Expr_Array1OfNamedUnknown;

1
src/Font/Font_BRepFont.cxx
View File

@ -22,6 +22,7 @@
#include <GC_MakeSegment.hxx>
#include <Geom_BezierCurve.hxx>
#include <Geom_BSplineCurve.hxx>
#include <Geom2d_TrimmedCurve.hxx>
#include <Geom_Plane.hxx>
#include <Geom2d_BezierCurve.hxx>
#include <Geom2d_BSplineCurve.hxx>

5
src/Geom/Geom_Axis1Placement.cxx
View File

@ -17,7 +17,6 @@
#include <Geom_Axis1Placement.ixx>
typedef Geom_Axis1Placement Axis1Placement;
typedef Handle(Geom_Axis1Placement) Handle(Axis1Placement);
typedef gp_Ax2 Ax2;
typedef gp_Dir Dir;
typedef gp_Pnt Pnt;
@ -31,7 +30,7 @@ typedef gp_Vec Vec;
Handle(Geom_Geometry) Geom_Axis1Placement::Copy() const {
Handle(Axis1Placement) A1;
Handle(Geom_Axis1Placement) A1;
A1 = new Axis1Placement (axis);
return A1;
}
@ -66,7 +65,7 @@ void Geom_Axis1Placement::Reverse() { axis.Reverse(); }
void Geom_Axis1Placement::Transform (const Trsf& T) { axis.Transform (T); }
Handle(Axis1Placement) Geom_Axis1Placement::Reversed() const {
Handle(Geom_Axis1Placement) Geom_Axis1Placement::Reversed() const {
gp_Ax1 A1 = axis;
A1.Reverse();

3
src/Geom/Geom_Axis2Placement.cxx
View File

@ -16,7 +16,6 @@
#include <Geom_Axis2Placement.ixx>
typedef Handle(Geom_Axis2Placement) Handle(Axis2Placement);
typedef Geom_Axis2Placement Axis2Placement;
typedef gp_Ax1 Ax1;
typedef gp_Dir Dir;
@ -32,7 +31,7 @@ typedef gp_Vec Vec;
Handle(Geom_Geometry) Geom_Axis2Placement::Copy() const {
Handle(Axis2Placement) A2;
Handle(Geom_Axis2Placement) A2;
A2 = new Axis2Placement (axis.Location(), axis.Direction(), vxdir, vydir);
return A2;
}

3
src/Geom/Geom_AxisPlacement.cxx
View File

@ -16,7 +16,6 @@
#include <Geom_AxisPlacement.ixx>
typedef Handle(Geom_AxisPlacement) Handle(AxisPlacement);
typedef gp_Ax1 Ax1;
typedef gp_Dir Dir;
typedef gp_Pnt Pnt;
@ -34,7 +33,7 @@ void Geom_AxisPlacement::SetAxis (const Ax1& A1) { axis = A1; }
void Geom_AxisPlacement::SetLocation (const Pnt& P) {axis.SetLocation (P);}
Standard_Real Geom_AxisPlacement::Angle (const Handle(AxisPlacement)& Other) const {
Standard_Real Geom_AxisPlacement::Angle (const Handle(Geom_AxisPlacement)& Other) const {
return axis.Angle (Other->Axis());
}

5
src/Geom/Geom_CartesianPoint.cxx
View File

@ -17,14 +17,11 @@
#include <Geom_CartesianPoint.ixx>
typedef Geom_CartesianPoint CartesianPoint;
typedef Handle(Geom_CartesianPoint) Handle(CartesianPoint);
typedef gp_Ax1 Ax1;
typedef gp_Ax2 Ax2;
typedef gp_Vec Vec;
typedef gp_Trsf Trsf;
//=======================================================================
//function : Geom_CartesianPoint
//purpose :
@ -49,7 +46,7 @@ const Standard_Real X, const Standard_Real Y, const Standard_Real Z) : gpPnt (X,
Handle(Geom_Geometry) Geom_CartesianPoint::Copy() const {
Handle(CartesianPoint) P;
Handle(Geom_CartesianPoint) P;
P = new CartesianPoint (gpPnt);
return P;
}

3
src/Geom/Geom_Circle.cxx
View File

@ -21,7 +21,6 @@
#include <Standard_ConstructionError.hxx>
typedef Geom_Circle Circle;
typedef Handle(Geom_Circle) Handle(Circle);
typedef gp_Ax2 Ax2;
typedef gp_Pnt Pnt;
typedef gp_Trsf Trsf;
@ -38,7 +37,7 @@ typedef gp_XYZ XYZ;
Handle(Geom_Geometry) Geom_Circle::Copy() const {
Handle(Circle) C;
Handle(Geom_Circle) C;
C = new Circle (pos, radius);
return C;
}

6
src/Geom/Geom_ConicalSurface.cxx
View File

@ -32,7 +32,6 @@
#include <Geom_Circle.hxx>
typedef Geom_ConicalSurface ConicalSurface;
typedef Handle(Geom_ConicalSurface) Handle(ConicalSurface);
typedef gp_Ax1 Ax1;
typedef gp_Ax2 Ax2;
typedef gp_Ax3 Ax3;
@ -44,9 +43,6 @@ typedef gp_Trsf Trsf;
typedef gp_Vec Vec;
typedef gp_XYZ XYZ;
//=======================================================================
//function : Copy
//purpose :
@ -54,7 +50,7 @@ typedef gp_XYZ XYZ;
Handle(Geom_Geometry) Geom_ConicalSurface::Copy () const {
Handle(ConicalSurface) Cs;
Handle(Geom_ConicalSurface) Cs;
Cs = new ConicalSurface (pos, semiAngle, radius);
return Cs;
}

6
src/Geom/Geom_Curve.cxx
View File

@ -17,17 +17,15 @@
#include <Geom_Curve.ixx>
typedef Geom_Curve Curve;
typedef Handle(Geom_Curve) Handle(Curve);
//=======================================================================
//function : Reversed
//purpose :
//=======================================================================
Handle(Curve) Geom_Curve::Reversed () const
Handle(Geom_Curve) Geom_Curve::Reversed () const
{
Handle(Curve) C = Handle(Curve)::DownCast(Copy());
Handle(Geom_Curve) C = Handle(Geom_Curve)::DownCast(Copy());
C->Reverse();
return C;
}

3
src/Geom/Geom_CylindricalSurface.cxx
View File

@ -31,7 +31,6 @@
#include <ElSLib.hxx>
typedef Geom_CylindricalSurface CylindricalSurface;
typedef Handle(Geom_CylindricalSurface) Handle(CylindricalSurface);
typedef gp_Ax1 Ax1;
typedef gp_Ax2 Ax2;
@ -53,7 +52,7 @@ typedef gp_XYZ XYZ;
Handle(Geom_Geometry) Geom_CylindricalSurface::Copy () const {
Handle(CylindricalSurface) Cs;
Handle(Geom_CylindricalSurface) Cs;
Cs = new CylindricalSurface (pos, radius);
return Cs;
}

14
src/Geom/Geom_Direction.cxx
View File

@ -19,9 +19,7 @@
#include <Standard_ConstructionError.hxx>
typedef Geom_Direction Direction;
typedef Handle(Geom_Direction) Handle(Direction);
typedef Geom_Vector Vector;
typedef Handle(Geom_Vector) Handle(Vector);
typedef gp_Ax1 Ax1;
typedef gp_Ax2 Ax2;
typedef gp_Pnt Pnt;
@ -36,7 +34,7 @@ typedef gp_Trsf Trsf;
Handle(Geom_Geometry) Geom_Direction::Copy() const {
Handle(Direction) D;
Handle(Geom_Direction) D;
D = new Direction (gpVec);
return D;
}
@ -95,7 +93,7 @@ void Geom_Direction::SetZ (const Standard_Real Z) {
}
void Geom_Direction::Cross (const Handle(Vector)& Other) {
void Geom_Direction::Cross (const Handle(Geom_Vector)& Other) {
gp_Dir V (gpVec.Crossed(Other->Vec()));
gpVec = V;
@ -103,14 +101,14 @@ void Geom_Direction::Cross (const Handle(Vector)& Other) {
void Geom_Direction::CrossCross (
const Handle(Vector)& V1, const Handle(Vector)& V2) {
const Handle(Geom_Vector)& V1, const Handle(Geom_Vector)& V2) {
gp_Dir V (gpVec.CrossCrossed (V1->Vec(), V2->Vec()));
gpVec = V;
}
Handle(Vector) Geom_Direction::Crossed (const Handle(Vector)& Other)
Handle(Geom_Vector) Geom_Direction::Crossed (const Handle(Geom_Vector)& Other)
const {
gp_Dir V (gpVec.Crossed (Other->Vec()));
@ -118,8 +116,8 @@ const {
}
Handle(Vector) Geom_Direction::CrossCrossed (
const Handle(Vector)& V1, const Handle(Vector)& V2) const {
Handle(Geom_Vector) Geom_Direction::CrossCrossed (
const Handle(Geom_Vector)& V1, const Handle(Geom_Vector)& V2) const {
gp_Dir V (gpVec.CrossCrossed (V1->Vec(), V2->Vec()));
return new Direction (V);

8
src/Geom/Geom_ElementarySurface.cxx
View File

@ -16,12 +16,7 @@
#include <Geom_ElementarySurface.ixx>
typedef Geom_ElementarySurface ElementarySurface;
typedef Handle(Geom_ElementarySurface) Handle(ElementarySurface);
typedef Handle(Geom_Surface) Handle(Surface);
typedef gp_Ax1 Ax1;
typedef gp_Ax2 Ax2;
typedef gp_Ax3 Ax3;
@ -29,9 +24,6 @@ typedef gp_Dir Dir;
typedef gp_Pnt Pnt;
typedef gp_Vec Vec;
//=======================================================================
//function : Continuity
//purpose :

7
src/Geom/Geom_Ellipse.cxx
View File

@ -21,7 +21,6 @@
#include <Standard_RangeError.hxx>
typedef Geom_Ellipse Ellipse;
typedef Handle(Geom_Ellipse) Handle(Ellipse);
typedef gp_Ax1 Ax1;
typedef gp_Ax2 Ax2;
typedef gp_Pnt Pnt;
@ -29,10 +28,6 @@ typedef gp_Vec Vec;
typedef gp_Trsf Trsf;
typedef gp_XYZ XYZ;
//=======================================================================
//function : Copy
//purpose :
@ -40,7 +35,7 @@ typedef gp_XYZ XYZ;
Handle(Geom_Geometry) Geom_Ellipse::Copy() const
{
Handle(Ellipse) E;
Handle(Geom_Ellipse) E;
E = new Ellipse (pos, majorRadius, minorRadius);
return E;
}

67
src/Geom/Geom_Geometry.cxx
View File

@ -20,7 +20,6 @@
#include <Geom_Geometry.ixx>
#include <Standard_ConstructionError.hxx>
typedef Handle(Geom_Geometry) Handle(Geometry);
typedef Geom_Geometry Geometry;
typedef gp_Pnt Pnt;
typedef gp_Vec Vec;
@ -28,8 +27,6 @@ typedef gp_Ax1 Ax1;
typedef gp_Ax2 Ax2;
typedef gp_Trsf Trsf;
Handle(Geom_Geometry) Geom_Geometry::Copy() const {
Handle(Geom_Geometry) G;
@ -94,85 +91,69 @@ void Geom_Geometry::Translate (const gp_Pnt& P1, const gp_Pnt& P2) {
}
Handle(Geometry) Geom_Geometry::Mirrored (const gp_Pnt& P) const {
Handle(Geometry) me = this;
Handle(Geometry) G = me->Copy();
Handle(Geom_Geometry) Geom_Geometry::Mirrored (const gp_Pnt& P) const
{
Handle(Geom_Geometry) G = Copy();
G->Mirror (P);
return G;
}
Handle(Geometry) Geom_Geometry::Mirrored (const gp_Ax1& A1) const {
Handle(Geometry) me = this;
Handle(Geometry) G = me->Copy();
Handle(Geom_Geometry) Geom_Geometry::Mirrored (const gp_Ax1& A1) const
{
Handle(Geom_Geometry) G = Copy();
G->Mirror (A1);
return G;
}
Handle(Geometry) Geom_Geometry::Mirrored (const gp_Ax2& A2) const {
Handle(Geometry) me = this;
Handle(Geometry) G = me->Copy();
Handle(Geom_Geometry) Geom_Geometry::Mirrored (const gp_Ax2& A2) const
{
Handle(Geom_Geometry) G = Copy();
G->Mirror (A2);
return G;
}
Handle(Geometry) Geom_Geometry::Rotated (
const gp_Ax1& A1,
const Standard_Real Ang
) const {
Handle(Geometry) me = this;
Handle(Geometry) G = me->Copy();
Handle(Geom_Geometry) Geom_Geometry::Rotated (const gp_Ax1& A1, const Standard_Real Ang) const
{
Handle(Geom_Geometry) G = Copy();
G->Rotate (A1, Ang);
return G;
}
Handle(Geometry) Geom_Geometry::Scaled (const gp_Pnt& P, const Standard_Real S) const {
Handle(Geometry) me = this;
Handle(Geometry) G = me->Copy();
Handle(Geom_Geometry) Geom_Geometry::Scaled (const gp_Pnt& P, const Standard_Real S) const
{
Handle(Geom_Geometry) G = Copy();
G->Scale (P, S);
return G;
}
Handle(Geometry) Geom_Geometry::Transformed (const gp_Trsf& T) const {
Handle(Geometry) me = this;
Handle(Geometry) G = me->Copy();
Handle(Geom_Geometry) Geom_Geometry::Transformed (const gp_Trsf& T) const
{
Handle(Geom_Geometry) G = Copy();
G->Transform (T);
return G;
}
Handle(Geometry) Geom_Geometry::Translated (const gp_Vec& V) const {
Handle(Geometry) me = this;
Handle(Geometry) G = me->Copy();
Handle(Geom_Geometry) Geom_Geometry::Translated (const gp_Vec& V) const
{
Handle(Geom_Geometry) G = Copy();
G->Translate (V);
return G;
}
Handle(Geometry) Geom_Geometry::Translated (
const gp_Pnt& P1,
const gp_Pnt& P2
) const {
Handle(Geometry) me = this;
Handle(Geometry) G = me->Copy();
Handle(Geom_Geometry) Geom_Geometry::Translated (const gp_Pnt& P1, const gp_Pnt& P2) const
{
Handle(Geom_Geometry) G = Copy();
G->Translate (P1, P2);
return G;
}

7
src/Geom/Geom_Hyperbola.cxx
View File

@ -24,7 +24,6 @@
typedef Geom_Hyperbola Hyperbola;
typedef Handle(Geom_Hyperbola) Handle(Hyperbola);
typedef gp_Ax1 Ax1;
typedef gp_Ax2 Ax2;
typedef gp_Pnt Pnt;
@ -32,10 +31,6 @@ typedef gp_Vec Vec;
typedef gp_Trsf Trsf;
typedef gp_XYZ XYZ;
//=======================================================================
//function : Copy
//purpose :
@ -43,7 +38,7 @@ typedef gp_XYZ XYZ;
Handle(Geom_Geometry) Geom_Hyperbola::Copy() const {
Handle(Hyperbola) H;
Handle(Geom_Hyperbola) H;
H = new Hyperbola (pos, majorRadius, minorRadius);
return H;
}

15
src/Geom/Geom_OffsetCurve.cxx
View File

@ -42,20 +42,13 @@
#include <CSLib_Offset.hxx>
typedef Geom_OffsetCurve OffsetCurve;
typedef Handle(Geom_OffsetCurve) Handle(OffsetCurve);
typedef Geom_Curve Curve;
typedef Handle(Geom_Curve) Handle(Curve);
typedef Handle(Geom_Geometry) Handle(Geometry);
typedef gp_Dir Dir;
typedef gp_Pnt Pnt;
typedef gp_Trsf Trsf;
typedef gp_Vec Vec;
typedef gp_XYZ XYZ;
//ordre de derivation maximum pour la recherche de la premiere
//derivee non nulle
static const int maxDerivOrder = 3;
@ -79,7 +72,7 @@ static Standard_Boolean AdjustDerivative(
Handle(Geom_Geometry) Geom_OffsetCurve::Copy () const {
Handle(OffsetCurve) C;
Handle(Geom_OffsetCurve) C;
C = new OffsetCurve (basisCurve, offsetValue, direction);
return C;
}
@ -174,12 +167,12 @@ Standard_Real Geom_OffsetCurve::Period () const
//purpose :
//=======================================================================
void Geom_OffsetCurve::SetBasisCurve (const Handle(Curve)& C,
void Geom_OffsetCurve::SetBasisCurve (const Handle(Geom_Curve)& C,
const Standard_Boolean isNotCheckC0)
{
const Standard_Real aUf = C->FirstParameter(),
aUl = C->LastParameter();
Handle(Curve) aCheckingCurve = Handle(Curve)::DownCast(C->Copy());
Handle(Geom_Curve) aCheckingCurve = Handle(Geom_Curve)::DownCast(C->Copy());
Standard_Boolean isTrimmed = Standard_False;
while(aCheckingCurve->IsKind(STANDARD_TYPE(Geom_TrimmedCurve)) ||
@ -255,7 +248,7 @@ void Geom_OffsetCurve::SetBasisCurve (const Handle(Curve)& C,
//purpose :
//=======================================================================
Handle(Curve) Geom_OffsetCurve::BasisCurve () const
Handle(Geom_Curve) Geom_OffsetCurve::BasisCurve () const
{
return basisCurve;
}

31
src/Geom/Geom_OffsetSurface.cxx
View File

@ -71,13 +71,8 @@
#include <GeomAbs_Shape.hxx>
#include <GeomAbs_CurveType.hxx>
typedef Handle(Geom_OffsetCurve) Handle(OffsetCurve);
typedef Geom_OffsetCurve OffsetCurve;
typedef Handle(Geom_Curve) Handle(Curve);
typedef Handle(Geom_Surface) Handle(Surface);
typedef Handle(Geom_OffsetSurface) Handle(OffsetSurface);
typedef Geom_OffsetSurface OffsetSurface;
typedef Handle(Geom_Geometry) Handle(Geometry);
typedef gp_Dir Dir;
typedef gp_Vec Vec;
typedef gp_Pnt Pnt;
@ -210,7 +205,7 @@ static void derivatives(Standard_Integer MaxOrder,
Handle(Geom_Geometry) Geom_OffsetSurface::Copy () const {
Handle(OffsetSurface) S;
Handle(Geom_OffsetSurface) S;
S = new OffsetSurface (basisSurf, offsetValue);
return S;
}
@ -240,13 +235,13 @@ Geom_OffsetSurface::Geom_OffsetSurface (const Handle(Geom_Surface)& theSurf,
//purpose :
//=======================================================================
void Geom_OffsetSurface::SetBasisSurface (const Handle(Surface)& S,
void Geom_OffsetSurface::SetBasisSurface (const Handle(Geom_Surface)& S,
const Standard_Boolean isNotCheckC0)
{
Standard_Real aUf, aUl, aVf, aVl;
S->Bounds(aUf, aUl, aVf, aVl);
Handle(Surface) aCheckingSurf = Handle(Surface)::DownCast(S->Copy());
Handle(Geom_Surface) aCheckingSurf = Handle(Geom_Surface)::DownCast(S->Copy());
Standard_Boolean isTrimmed = Standard_False;
while(aCheckingSurf->IsKind(STANDARD_TYPE(Geom_RectangularTrimmedSurface)) ||
@ -429,7 +424,7 @@ Standard_Real Geom_OffsetSurface::VReversedParameter( const Standard_Real V) con
//purpose :
//=======================================================================
Handle(Surface) Geom_OffsetSurface::BasisSurface () const
Handle(Geom_Surface) Geom_OffsetSurface::BasisSurface () const
{
return basisSurf;
}
@ -1280,7 +1275,8 @@ Handle(Geom_Curve) Geom_OffsetSurface::UIso (const Standard_Real UU) const
GeomAbs_Shape Cont = GeomAbs_C1;
Standard_Integer MaxSeg = 100, MaxDeg =14;
Geom_OffsetSurface_UIsoEvaluator ev (this, UU);
Handle(Geom_OffsetSurface) me (this);
Geom_OffsetSurface_UIsoEvaluator ev (me, UU);
AdvApprox_ApproxAFunction Approx(Num1, Num2, Num3, T1, T2, T3,
V1, V2, Cont,
MaxDeg,MaxSeg, ev);
@ -1347,7 +1343,8 @@ Handle(Geom_Curve) Geom_OffsetSurface::VIso (const Standard_Real VV) const
GeomAbs_Shape Cont = GeomAbs_C1;
Standard_Integer MaxSeg = 100, MaxDeg =14;
Geom_OffsetSurface_VIsoEvaluator ev (this, VV);
Handle(Geom_OffsetSurface) me (this);
Geom_OffsetSurface_VIsoEvaluator ev (me, VV);
AdvApprox_ApproxAFunction Approx (Num1, Num2, Num3, T1, T2, T3,
U1, U2, Cont, MaxDeg, MaxSeg, ev);
@ -1447,13 +1444,13 @@ Standard_Real Geom_OffsetSurface::VPeriod() const
Standard_Boolean Geom_OffsetSurface::IsUClosed () const {
Standard_Boolean UClosed;
Handle(Surface) SBasis = BasisSurface();
Handle(Geom_Surface) SBasis = BasisSurface();
if (SBasis->IsKind (STANDARD_TYPE(Geom_RectangularTrimmedSurface))) {
Handle(Geom_RectangularTrimmedSurface) St =
Handle(Geom_RectangularTrimmedSurface)::DownCast(SBasis);
Handle(Surface) S = Handle(Surface)::DownCast(St->BasisSurface());
Handle(Geom_Surface) S = Handle(Geom_Surface)::DownCast(St->BasisSurface());
if (S->IsKind (STANDARD_TYPE(Geom_ElementarySurface))) {
UClosed = SBasis->IsUClosed();
}
@ -1461,7 +1458,7 @@ Standard_Boolean Geom_OffsetSurface::IsUClosed () const {
Handle(Geom_SurfaceOfLinearExtrusion) Extru =
Handle(Geom_SurfaceOfLinearExtrusion)::DownCast(S);
Handle(Curve) C = Extru->BasisCurve();
Handle(Geom_Curve) C = Extru->BasisCurve();
if (C->IsKind (STANDARD_TYPE(Geom_Circle)) || C->IsKind (STANDARD_TYPE(Geom_Ellipse))) {
UClosed = SBasis->IsUClosed();
}
@ -1480,7 +1477,7 @@ Standard_Boolean Geom_OffsetSurface::IsUClosed () const {
Handle(Geom_SurfaceOfLinearExtrusion) Extru =
Handle(Geom_SurfaceOfLinearExtrusion)::DownCast(SBasis);
Handle(Curve) C = Extru->BasisCurve();
Handle(Geom_Curve) C = Extru->BasisCurve();
UClosed = (C->IsKind(STANDARD_TYPE(Geom_Circle)) || C->IsKind(STANDARD_TYPE(Geom_Ellipse)));
}
else if (SBasis->IsKind (STANDARD_TYPE(Geom_SurfaceOfRevolution))) {
@ -1500,13 +1497,13 @@ Standard_Boolean Geom_OffsetSurface::IsUClosed () const {
Standard_Boolean Geom_OffsetSurface::IsVClosed () const {
Standard_Boolean VClosed;
Handle(Surface) SBasis = BasisSurface();
Handle(Geom_Surface) SBasis = BasisSurface();
if (SBasis->IsKind (STANDARD_TYPE(Geom_RectangularTrimmedSurface))) {
Handle(Geom_RectangularTrimmedSurface) St =
Handle(Geom_RectangularTrimmedSurface)::DownCast(SBasis);
Handle(Surface) S = Handle(Surface)::DownCast(St->BasisSurface());
Handle(Geom_Surface) S = Handle(Geom_Surface)::DownCast(St->BasisSurface());
if (S->IsKind (STANDARD_TYPE(Geom_ElementarySurface))) {
VClosed = SBasis->IsVClosed();
}

8
src/Geom/Geom_Parabola.cxx
View File

@ -23,7 +23,6 @@
#include <Standard_RangeError.hxx>
typedef Geom_Parabola Parabola;
typedef Handle(Geom_Parabola) Handle(Parabola);
typedef gp_Ax1 Ax1;
typedef gp_Ax2 Ax2;
typedef gp_Pnt Pnt;
@ -31,11 +30,6 @@ typedef gp_Trsf Trsf;
typedef gp_Vec Vec;
typedef gp_XYZ XYZ;
//=======================================================================
//function : Copy
//purpose :
@ -43,7 +37,7 @@ typedef gp_XYZ XYZ;
Handle(Geom_Geometry) Geom_Parabola::Copy() const {
Handle(Parabola) Prb;
Handle(Geom_Parabola) Prb;
Prb = new Parabola (pos, focalLength);
return Prb;
}

7
src/Geom/Geom_Plane.cxx
View File

@ -28,9 +28,6 @@
#include <GeomAbs_UVSense.hxx>
typedef Geom_Plane Plane;
typedef Handle(Geom_Plane) Handle(Plane);
typedef Handle(Geom_Line) Handle(Line);
typedef gp_Ax1 Ax1;
typedef gp_Ax2 Ax2;
typedef gp_Ax3 Ax3;
@ -42,8 +39,6 @@ typedef gp_Trsf Trsf;
typedef gp_Vec Vec;
typedef gp_XYZ XYZ;
//=======================================================================
//function : Copy
//purpose :
@ -51,7 +46,7 @@ typedef gp_XYZ XYZ;
Handle(Geom_Geometry) Geom_Plane::Copy () const {
Handle(Plane) Pl = new Plane ( pos);
Handle(Geom_Plane) Pl = new Plane ( pos);
return Pl;
}

7
src/Geom/Geom_Point.cxx
View File

@ -16,12 +16,9 @@
#include <Geom_Point.ixx>
typedef Handle(Geom_Point) Handle(Point);
typedef Geom_Point Point;
Standard_Real Geom_Point::Distance (const Handle(Point)& Other) const {
Standard_Real Geom_Point::Distance (const Handle(Geom_Point)& Other) const {
gp_Pnt P1 = this->Pnt ();
gp_Pnt P2 = Other->Pnt ();
@ -29,7 +26,7 @@ Standard_Real Geom_Point::Distance (const Handle(Point)& Other) const {
}
Standard_Real Geom_Point::SquareDistance (const Handle(Point)& Other) const {
Standard_Real Geom_Point::SquareDistance (const Handle(Geom_Point)& Other) const {
gp_Pnt P1 = this->Pnt ();
gp_Pnt P2 = Other->Pnt ();

26
src/Geom/Geom_RectangularTrimmedSurface.cxx
View File

@ -42,21 +42,13 @@
#include <Precision.hxx>
#include <ElCLib.hxx>
typedef Handle(Geom_Surface) Handle(Surface);
typedef Handle(Geom_Geometry) Handle(Geometry);
typedef Geom_RectangularTrimmedSurface RectangularTrimmedSurface;
typedef Handle(Geom_RectangularTrimmedSurface) Handle(RectangularTrimmedSurface);
typedef gp_Ax1 Ax1;
typedef gp_Ax2 Ax2;
typedef gp_Pnt Pnt;
typedef gp_Trsf Trsf;
typedef gp_Vec Vec;
//=======================================================================
//function : Copy
//purpose :
@ -64,7 +56,7 @@ typedef gp_Vec Vec;
Handle(Geom_Geometry) Geom_RectangularTrimmedSurface::Copy () const {
Handle(RectangularTrimmedSurface) S;
Handle(Geom_RectangularTrimmedSurface) S;
if ( isutrimmed && isvtrimmed )
S = new RectangularTrimmedSurface (basisSurf,
@ -91,7 +83,7 @@ Handle(Geom_Geometry) Geom_RectangularTrimmedSurface::Copy () const {
Geom_RectangularTrimmedSurface::Geom_RectangularTrimmedSurface (
const Handle(Surface)& S,
const Handle(Geom_Surface)& S,
const Standard_Real U1,
const Standard_Real U2,
const Standard_Real V1,
@ -111,9 +103,9 @@ const Standard_Boolean VSense)
Handle(Geom_RectangularTrimmedSurface) T =
Handle(Geom_RectangularTrimmedSurface)::DownCast(S);
if (!T.IsNull())
basisSurf = Handle(Surface)::DownCast(T->BasisSurface()->Copy());
basisSurf = Handle(Geom_Surface)::DownCast(T->BasisSurface()->Copy());
else
basisSurf = Handle(Surface)::DownCast(S->Copy());
basisSurf = Handle(Geom_Surface)::DownCast(S->Copy());
Handle(Geom_OffsetSurface) O =
Handle(Geom_OffsetSurface)::DownCast(basisSurf);
@ -122,7 +114,7 @@ const Standard_Boolean VSense)
Handle(Geom_RectangularTrimmedSurface) S2 =
new Geom_RectangularTrimmedSurface( O->BasisSurface(),U1,U2, V1, V2, USense, VSense);
Handle(Geom_OffsetSurface) OS = new Geom_OffsetSurface(S2, O->Offset());
basisSurf = Handle(Surface)::DownCast(OS);
basisSurf = Handle(Geom_Surface)::DownCast(OS);
}
SetTrim( U1, U2, V1, V2, USense, VSense);
@ -147,9 +139,9 @@ Geom_RectangularTrimmedSurface::Geom_RectangularTrimmedSurface (
Handle(Geom_RectangularTrimmedSurface) T =
Handle(Geom_RectangularTrimmedSurface)::DownCast(S);
if (!T.IsNull())
basisSurf = Handle(Surface)::DownCast(T->BasisSurface()->Copy());
basisSurf = Handle(Geom_Surface)::DownCast(T->BasisSurface()->Copy());
else
basisSurf = Handle(Surface)::DownCast(S->Copy());
basisSurf = Handle(Geom_Surface)::DownCast(S->Copy());
Handle(Geom_OffsetSurface) O =
Handle(Geom_OffsetSurface)::DownCast(basisSurf);
@ -158,7 +150,7 @@ Geom_RectangularTrimmedSurface::Geom_RectangularTrimmedSurface (
Handle(Geom_RectangularTrimmedSurface) S2 =
new Geom_RectangularTrimmedSurface( O->BasisSurface(),Param1,Param2, UTrim, Sense);
Handle(Geom_OffsetSurface) OS = new Geom_OffsetSurface(S2, O->Offset());
basisSurf = Handle(Surface)::DownCast(OS);
basisSurf = Handle(Geom_Surface)::DownCast(OS);
}
SetTrim(Param1, Param2, UTrim, Sense);
@ -380,7 +372,7 @@ Standard_Real Geom_RectangularTrimmedSurface::VReversedParameter( const Standard
//purpose :
//=======================================================================
Handle(Surface) Geom_RectangularTrimmedSurface::BasisSurface () const
Handle(Geom_Surface) Geom_RectangularTrimmedSurface::BasisSurface () const
{
return basisSurf;
}

12
src/Geom/Geom_SphericalSurface.cxx
View File

@ -26,9 +26,6 @@
typedef Geom_Circle Circle;
typedef Geom_SphericalSurface SphericalSurface;
typedef Handle(Geom_SphericalSurface) Handle(SphericalSurface);
typedef Handle(Geom_Curve) Handle(Curve);
typedef Handle(Geom_Circle) Handle(Circle);
typedef gp_Ax2 Ax2;
typedef gp_Ax3 Ax3;
typedef gp_Circ Circ;
@ -38,9 +35,6 @@ typedef gp_Trsf Trsf;
typedef gp_XYZ XYZ;
typedef gp_Vec Vec;
//=======================================================================
//function : Copy
//purpose :
@ -48,7 +42,7 @@ typedef gp_Vec Vec;
Handle(Geom_Geometry) Geom_SphericalSurface::Copy () const {
Handle(SphericalSurface) Cs;
Handle(Geom_SphericalSurface) Cs;
Cs = new SphericalSurface (pos, radius);
return Cs;
}
@ -313,7 +307,7 @@ gp_Sphere Geom_SphericalSurface::Sphere () const {
//purpose :
//=======================================================================
Handle(Curve) Geom_SphericalSurface::UIso (const Standard_Real U) const
Handle(Geom_Curve) Geom_SphericalSurface::UIso (const Standard_Real U) const
{
Handle(Geom_Circle) GC = new Geom_Circle(ElSLib::SphereUIso(pos,radius,U));
Handle(Geom_TrimmedCurve) iso = new Geom_TrimmedCurve(GC,-M_PI/2.,M_PI/2);
@ -326,7 +320,7 @@ Handle(Curve) Geom_SphericalSurface::UIso (const Standard_Real U) const
//purpose :
//=======================================================================
Handle(Curve) Geom_SphericalSurface::VIso (const Standard_Real V) const
Handle(Geom_Curve) Geom_SphericalSurface::VIso (const Standard_Real V) const
{
Handle(Geom_Circle)
GC = new Geom_Circle(ElSLib::SphereVIso(pos,radius,V));

10
src/Geom/Geom_Surface.cxx
View File

@ -17,17 +17,15 @@
#include <Geom_Surface.ixx>
typedef Geom_Surface Surface;
typedef Handle(Geom_Surface) Handle(Surface);
//=======================================================================
//function : UReversed
//purpose :
//=======================================================================
Handle(Surface) Geom_Surface::UReversed () const
Handle(Geom_Surface) Geom_Surface::UReversed () const
{
Handle(Surface) S = Handle(Surface)::DownCast(Copy());
Handle(Geom_Surface) S = Handle(Geom_Surface)::DownCast(Copy());
S->UReverse();
return S;
}
@ -38,9 +36,9 @@ Handle(Surface) Geom_Surface::UReversed () const
//purpose :
//=======================================================================
Handle(Surface) Geom_Surface::VReversed () const
Handle(Geom_Surface) Geom_Surface::VReversed () const
{
Handle(Surface) S = Handle(Surface)::DownCast(Copy());
Handle(Geom_Surface) S = Handle(Geom_Surface)::DownCast(Copy());
S->VReverse();
return S;
}

14
src/Geom/Geom_SurfaceOfLinearExtrusion.cxx
View File

@ -44,9 +44,7 @@
#define FMULTS (BSplCLib::NoMults())
typedef Geom_SurfaceOfLinearExtrusion SurfaceOfLinearExtrusion;
typedef Handle(Geom_SurfaceOfLinearExtrusion) Handle(SurfaceOfLinearExtrusion);
typedef Geom_Curve Curve;
typedef Handle(Geom_Curve) Handle(Curve);
typedef gp_Dir Dir;
typedef gp_Pnt Pnt;
typedef gp_Trsf Trsf;
@ -131,10 +129,10 @@ Handle(Geom_Geometry) Geom_SurfaceOfLinearExtrusion::Copy () const
//=======================================================================
Geom_SurfaceOfLinearExtrusion::Geom_SurfaceOfLinearExtrusion
( const Handle(Curve)& C,
( const Handle(Geom_Curve)& C,
const Dir& V) {
basisCurve = Handle(Curve)::DownCast(C->Copy()); // Copy 10-03-93
basisCurve = Handle(Geom_Curve)::DownCast(C->Copy()); // Copy 10-03-93
direction = V;
smooth = C->Continuity();
}
@ -202,10 +200,10 @@ void Geom_SurfaceOfLinearExtrusion::SetDirection (const Dir& V) {
//purpose :
//=======================================================================
void Geom_SurfaceOfLinearExtrusion::SetBasisCurve (const Handle(Curve)& C) {
void Geom_SurfaceOfLinearExtrusion::SetBasisCurve (const Handle(Geom_Curve)& C) {
smooth = C->Continuity();
basisCurve = Handle(Curve)::DownCast(C->Copy()); // Copy 10-03-93
basisCurve = Handle(Geom_Curve)::DownCast(C->Copy()); // Copy 10-03-93
}
@ -491,11 +489,11 @@ Handle(Geom_Curve) Geom_SurfaceOfLinearExtrusion::UIso (const Standard_Real U) c
//purpose :
//=======================================================================
Handle(Curve) Geom_SurfaceOfLinearExtrusion::VIso (const Standard_Real V) const {
Handle(Geom_Curve) Geom_SurfaceOfLinearExtrusion::VIso (const Standard_Real V) const {
Vec Vdir (direction);
Vdir.Multiply (V);
Handle(Curve) C;
Handle(Geom_Curve) C;
C = Handle(Geom_Curve)::DownCast(basisCurve->Translated(Vdir));
return C;
}

16
src/Geom/Geom_SurfaceOfRevolution.cxx
View File

@ -38,10 +38,7 @@
#define FMULTS (BSplCLib::NoMults())
typedef Geom_SurfaceOfRevolution SurfaceOfRevolution;
typedef Handle(Geom_SurfaceOfRevolution) Handle(SurfaceOfRevolution);
typedef Handle(Geom_Geometry) Handle(Geometry);
typedef Geom_Curve Curve;
typedef Handle(Geom_Curve) Handle(Curve);
typedef gp_Ax1 Ax1;
typedef gp_Ax2 Ax2;
typedef gp_Dir Dir;
@ -50,6 +47,7 @@ typedef gp_Pnt Pnt;
typedef gp_Trsf Trsf;
typedef gp_Vec Vec;
typedef gp_XYZ XYZ;
//=======================================================================
//function : LocateSide
//purpose : This method locates U parameter on basis BSpline curve
@ -135,10 +133,10 @@ Handle(Geom_Geometry) Geom_SurfaceOfRevolution::Copy () const {
//=======================================================================
Geom_SurfaceOfRevolution::Geom_SurfaceOfRevolution
(const Handle(Curve)& C ,
(const Handle(Geom_Curve)& C ,
const Ax1& A1 ) : loc (A1.Location()) {
basisCurve = Handle(Curve)::DownCast(C->Copy());
basisCurve = Handle(Geom_Curve)::DownCast(C->Copy());
direction = A1.Direction();
smooth = C->Continuity();
}
@ -300,9 +298,9 @@ void Geom_SurfaceOfRevolution::SetDirection (const Dir& V) {
//purpose :
//=======================================================================
void Geom_SurfaceOfRevolution::SetBasisCurve (const Handle(Curve)& C) {
void Geom_SurfaceOfRevolution::SetBasisCurve (const Handle(Geom_Curve)& C) {
basisCurve = Handle(Curve)::DownCast(C->Copy());
basisCurve = Handle(Geom_Curve)::DownCast(C->Copy());
smooth = C->Continuity();
}
@ -1111,9 +1109,9 @@ Ax2 Geom_SurfaceOfRevolution::ReferencePlane() const {
//purpose :
//=======================================================================
Handle(Curve) Geom_SurfaceOfRevolution::UIso (const Standard_Real U) const {
Handle(Geom_Curve) Geom_SurfaceOfRevolution::UIso (const Standard_Real U) const {
Handle(Curve) C = Handle(Curve)::DownCast(basisCurve->Copy());
Handle(Geom_Curve) C = Handle(Geom_Curve)::DownCast(basisCurve->Copy());
Ax1 RotAxis = Ax1 (loc, direction);
C->Rotate (RotAxis, U);
return C;

3
src/Geom/Geom_ToroidalSurface.cxx
View File

@ -28,7 +28,6 @@
#include <Standard_RangeError.hxx>
typedef Geom_ToroidalSurface ToroidalSurface;
typedef Handle(Geom_ToroidalSurface) Handle(ToroidalSurface);
typedef TColStd_Array1OfReal Array1OfReal;
typedef gp_Ax1 Ax1;
typedef gp_Ax2 Ax2;
@ -49,7 +48,7 @@ typedef gp_XYZ XYZ;
Handle(Geom_Geometry) Geom_ToroidalSurface::Copy () const {
Handle(ToroidalSurface) Cs;
Handle(Geom_ToroidalSurface) Cs;
Cs = new ToroidalSurface (pos, majorRadius, minorRadius);
return Cs;
}

12
src/Geom/Geom_Transformation.cxx
View File

@ -16,7 +16,6 @@
#include <Geom_Transformation.ixx>
typedef Handle(Geom_Transformation) Handle(Transformation);
typedef Geom_Transformation Transformation;
typedef gp_Ax1 Ax1;
typedef gp_Ax2 Ax2;
@ -25,9 +24,6 @@ typedef gp_Pnt Pnt;
typedef gp_TrsfForm TrsfForm;
typedef gp_Vec Vec;
Geom_Transformation::Geom_Transformation () { }
@ -37,7 +33,7 @@ Geom_Transformation::Geom_Transformation (const gp_Trsf& T)
Handle(Geom_Transformation) Geom_Transformation::Copy() const {
Handle(Transformation) T;
Handle(Geom_Transformation) T;
T = new Transformation (gpTrsf);
return T;
}
@ -104,13 +100,13 @@ Standard_Real Geom_Transformation::Value (const Standard_Integer Row, const Stan
void Geom_Transformation::Invert () { gpTrsf.Invert(); }
Handle(Transformation) Geom_Transformation::Inverted () const {
Handle(Geom_Transformation) Geom_Transformation::Inverted () const {
return new Transformation (gpTrsf.Inverted());
}
Handle(Transformation) Geom_Transformation::Multiplied (
Handle(Geom_Transformation) Geom_Transformation::Multiplied (
const Handle(Geom_Transformation)& Other) const {
return new Transformation (gpTrsf.Multiplied (Other->Trsf()));
@ -126,7 +122,7 @@ void Geom_Transformation::Multiply (const Handle(Geom_Transformation)& Other) {
void Geom_Transformation::Power (const Standard_Integer N) { gpTrsf.Power (N); }
Handle(Transformation) Geom_Transformation::Powered (const Standard_Integer N) const {
Handle(Geom_Transformation) Geom_Transformation::Powered (const Standard_Integer N) const {
gp_Trsf T = gpTrsf;
T.Power (N);

12
src/Geom/Geom_TrimmedCurve.cxx
View File

@ -31,11 +31,7 @@
#include <Precision.hxx>
#include <ElCLib.hxx>
typedef Handle(Geom_TrimmedCurve) Handle(TrimmedCurve);
typedef Geom_TrimmedCurve TrimmedCurve;
typedef Handle(Geom_Curve) Handle(Curve);
typedef Handle(Geom_Geometry) Handle(Geometry);
typedef gp_Ax1 Ax1;
typedef gp_Ax2 Ax2;
typedef gp_Pnt Pnt;
@ -49,7 +45,7 @@ typedef gp_Vec Vec;
Handle(Geom_Geometry) Geom_TrimmedCurve::Copy () const {
Handle(TrimmedCurve) Tc = new TrimmedCurve (basisCurve, uTrim1, uTrim2);
Handle(Geom_TrimmedCurve) Tc = new TrimmedCurve (basisCurve, uTrim1, uTrim2);
return Tc;
}
@ -70,9 +66,9 @@ Geom_TrimmedCurve::Geom_TrimmedCurve (const Handle(Geom_Curve)& C,
// kill trimmed basis curves
Handle(Geom_TrimmedCurve) T = Handle(Geom_TrimmedCurve)::DownCast(C);
if (!T.IsNull())
basisCurve = Handle(Curve)::DownCast(T->BasisCurve()->Copy());
basisCurve = Handle(Geom_Curve)::DownCast(T->BasisCurve()->Copy());
else
basisCurve = Handle(Curve)::DownCast(C->Copy());
basisCurve = Handle(Geom_Curve)::DownCast(C->Copy());
SetTrim(U1, U2, Sense, theAdjustPeriodic);
}
@ -207,7 +203,7 @@ GeomAbs_Shape Geom_TrimmedCurve::Continuity () const {
//purpose :
//=======================================================================
Handle(Curve) Geom_TrimmedCurve::BasisCurve () const {
Handle(Geom_Curve) Geom_TrimmedCurve::BasisCurve () const {
return basisCurve;
}

16
src/Geom/Geom_Vector.cxx
View File

@ -17,15 +17,11 @@
#include <Geom_Vector.ixx>
typedef Geom_Vector Vector;
typedef Handle(Geom_Vector) Handle(Vector);
typedef gp_Ax1 Ax1;
typedef gp_Ax2 Ax2;
typedef gp_Pnt Pnt;
typedef gp_Trsf Trsf;
void Geom_Vector::Reverse () { gpVec.Reverse(); }
Standard_Real Geom_Vector::X () const { return gpVec.X(); }
@ -36,22 +32,22 @@ Standard_Real Geom_Vector::Z () const { return gpVec.Z(); }
const gp_Vec& Geom_Vector::Vec () const { return gpVec; }
Handle(Vector) Geom_Vector::Reversed () const
Handle(Geom_Vector) Geom_Vector::Reversed () const
{
Handle(Vector) V = Handle(Vector)::DownCast(Copy());
Handle(Geom_Vector) V = Handle(Geom_Vector)::DownCast(Copy());
V->Reverse();
return V;
}
Standard_Real Geom_Vector::Angle (const Handle(Vector)& Other) const {
Standard_Real Geom_Vector::Angle (const Handle(Geom_Vector)& Other) const {
return gpVec.Angle (Other->Vec());
}
Standard_Real Geom_Vector::AngleWithRef (
const Handle(Vector)& Other, const Handle(Vector)& VRef) const {
const Handle(Geom_Vector)& Other, const Handle(Geom_Vector)& VRef) const {
return gpVec.AngleWithRef (Other->Vec(), VRef->Vec());
}
@ -63,14 +59,14 @@ void Geom_Vector::Coord (Standard_Real& X, Standard_Real& Y, Standard_Real& Z) c
}
Standard_Real Geom_Vector::Dot (const Handle(Vector)& Other) const {
Standard_Real Geom_Vector::Dot (const Handle(Geom_Vector)& Other) const {
return gpVec.Dot (Other->Vec());
}
Standard_Real Geom_Vector::DotCross (
const Handle(Vector)& V1, const Handle(Vector)& V2) const {
const Handle(Geom_Vector)& V1, const Handle(Geom_Vector)& V2) const {
return gpVec.DotCross (V1->Vec(), V2->Vec());
}

38
src/Geom/Geom_VectorWithMagnitude.cxx
View File

@ -17,18 +17,12 @@
#include <Geom_VectorWithMagnitude.ixx>
typedef Geom_VectorWithMagnitude VectorWithMagnitude;
typedef Handle(Geom_VectorWithMagnitude) Handle(VectorWithMagnitude);
typedef Geom_Vector Vector;
typedef Handle(Geom_Vector) Handle(Vector);
typedef Handle(Geom_Geometry) Handle(Geometry);
typedef gp_Ax1 Ax1;
typedef gp_Ax2 Ax2;
typedef gp_Pnt Pnt;
typedef gp_Trsf Trsf;
//=======================================================================
//function : Geom_VectorWithMagnitude
//purpose :
@ -63,7 +57,7 @@ const Pnt& P1, const Pnt& P2) { gpVec = gp_Vec (P1, P2); }
Handle(Geom_Geometry) Geom_VectorWithMagnitude::Copy() const {
Handle(VectorWithMagnitude) V;
Handle(Geom_VectorWithMagnitude) V;
V = new VectorWithMagnitude (gpVec);
return V;
}
@ -128,7 +122,7 @@ Standard_Real Geom_VectorWithMagnitude::SquareMagnitude () const {
//purpose :
//=======================================================================
void Geom_VectorWithMagnitude::Add (const Handle(Vector)& Other) {
void Geom_VectorWithMagnitude::Add (const Handle(Geom_Vector)& Other) {
gpVec.Add (Other->Vec());
}
@ -139,8 +133,8 @@ void Geom_VectorWithMagnitude::Add (const Handle(Vector)& Other) {
//purpose :
//=======================================================================
Handle(VectorWithMagnitude) Geom_VectorWithMagnitude::Added (
const Handle(Vector)& Other) const {
Handle(Geom_VectorWithMagnitude) Geom_VectorWithMagnitude::Added (
const Handle(Geom_Vector)& Other) const {
gp_Vec V1 = gpVec;
V1.Add (Other->Vec());
@ -153,7 +147,7 @@ const Handle(Vector)& Other) const {
//purpose :
//=======================================================================
void Geom_VectorWithMagnitude::Cross (const Handle(Vector)& Other) {
void Geom_VectorWithMagnitude::Cross (const Handle(Geom_Vector)& Other) {
gpVec.Cross (Other->Vec());
}
@ -165,8 +159,8 @@ void Geom_VectorWithMagnitude::Cross (const Handle(Vector)& Other) {
//purpose :
//=======================================================================
Handle(Vector) Geom_VectorWithMagnitude::Crossed (
const Handle(Vector)& Other) const {
Handle(Geom_Vector) Geom_VectorWithMagnitude::Crossed (
const Handle(Geom_Vector)& Other) const {
gp_Vec V (gpVec);
V.Cross (Other->Vec());
@ -180,7 +174,7 @@ const Handle(Vector)& Other) const {
//=======================================================================
void Geom_VectorWithMagnitude::CrossCross (
const Handle(Vector)& V1, const Handle(Vector)& V2) {
const Handle(Geom_Vector)& V1, const Handle(Geom_Vector)& V2) {
gpVec.CrossCross (V1->Vec(), V2->Vec());
}
@ -191,8 +185,8 @@ const Handle(Vector)& V1, const Handle(Vector)& V2) {
//purpose :
//=======================================================================
Handle(Vector) Geom_VectorWithMagnitude::CrossCrossed (
const Handle(Vector)& V1, const Handle(Vector)& V2) const {
Handle(Geom_Vector) Geom_VectorWithMagnitude::CrossCrossed (
const Handle(Geom_Vector)& V1, const Handle(Geom_Vector)& V2) const {
gp_Vec V (gpVec);
V.CrossCross (V1->Vec(), V2->Vec());
@ -216,7 +210,7 @@ void Geom_VectorWithMagnitude::Divide (const Standard_Real Scalar) {
//purpose :
//=======================================================================
Handle(VectorWithMagnitude) Geom_VectorWithMagnitude::Divided (
Handle(Geom_VectorWithMagnitude) Geom_VectorWithMagnitude::Divided (
const Standard_Real Scalar) const {
gp_Vec V (gpVec);
@ -230,7 +224,7 @@ const Standard_Real Scalar) const {
//purpose :
//=======================================================================
Handle(VectorWithMagnitude) Geom_VectorWithMagnitude::Multiplied (
Handle(Geom_VectorWithMagnitude) Geom_VectorWithMagnitude::Multiplied (
const Standard_Real Scalar) const {
gp_Vec V (gpVec);
@ -263,7 +257,7 @@ void Geom_VectorWithMagnitude::Normalize () { gpVec.Normalize (); }
//purpose :
//=======================================================================
Handle(VectorWithMagnitude) Geom_VectorWithMagnitude::Normalized () const {
Handle(Geom_VectorWithMagnitude) Geom_VectorWithMagnitude::Normalized () const {
gp_Vec V (gpVec);
V.Normalize ();
@ -276,7 +270,7 @@ Handle(VectorWithMagnitude) Geom_VectorWithMagnitude::Normalized () const {
//purpose :
//=======================================================================
void Geom_VectorWithMagnitude::Subtract (const Handle(Vector)& Other) {
void Geom_VectorWithMagnitude::Subtract (const Handle(Geom_Vector)& Other) {
gpVec.Subtract (Other->Vec());
}
@ -287,8 +281,8 @@ void Geom_VectorWithMagnitude::Subtract (const Handle(Vector)& Other) {
//purpose :
//=======================================================================
Handle(VectorWithMagnitude) Geom_VectorWithMagnitude::Subtracted (
const Handle(Vector)& Other) const {
Handle(Geom_VectorWithMagnitude) Geom_VectorWithMagnitude::Subtracted (
const Handle(Geom_Vector)& Other) const {
gp_Vec V (gpVec);
V.Subtract (Other->Vec());

9
src/Geom2d/Geom2d_AxisPlacement.cxx
View File

@ -19,7 +19,6 @@
typedef Geom2d_AxisPlacement AxisPlacement;
typedef Handle(Geom2d_AxisPlacement) Handle(AxisPlacement);
typedef gp_Dir2d Dir2d;
typedef gp_Pnt2d Pnt2d;
typedef gp_Trsf2d Trsf2d;
@ -30,7 +29,7 @@ typedef gp_Vec2d Vec2d;
Handle(Geom2d_Geometry) Geom2d_AxisPlacement::Copy() const {
Handle(AxisPlacement) A;
Handle(Geom2d_AxisPlacement) A;
A = new AxisPlacement (axis);
return A;
}
@ -56,11 +55,11 @@ Pnt2d Geom2d_AxisPlacement::Location () const { return axis.Location(); }
void Geom2d_AxisPlacement::Reverse() { axis.Reverse(); }
Handle(AxisPlacement) Geom2d_AxisPlacement::Reversed() const {
Handle(Geom2d_AxisPlacement) Geom2d_AxisPlacement::Reversed() const {
gp_Ax2d A = axis;
A.Reverse();
Handle(AxisPlacement) Temp = new AxisPlacement (A);
Handle(Geom2d_AxisPlacement) Temp = new AxisPlacement (A);
return Temp;
}
@ -76,7 +75,7 @@ void Geom2d_AxisPlacement::SetDirection (const Dir2d& V) {
axis.SetDirection(V);
}
Standard_Real Geom2d_AxisPlacement::Angle (const Handle(AxisPlacement)& Other) const {
Standard_Real Geom2d_AxisPlacement::Angle (const Handle(Geom2d_AxisPlacement)& Other) const {
return axis.Angle (Other->Ax2d());
}

3
src/Geom2d/Geom2d_CartesianPoint.cxx
View File

@ -17,7 +17,6 @@
#include <Geom2d_CartesianPoint.ixx>
typedef Geom2d_CartesianPoint CartesianPoint;
typedef Handle(Geom2d_CartesianPoint) Handle(CartesianPoint);
typedef gp_Ax2d Ax2d;
typedef gp_Vec2d Vec2d;
typedef gp_Trsf2d Trsf2d;
@ -33,7 +32,7 @@ Geom2d_CartesianPoint::Geom2d_CartesianPoint (const Standard_Real X, const Stand
Handle(Geom2d_Geometry) Geom2d_CartesianPoint::Copy() const {
Handle(CartesianPoint) P;
Handle(Geom2d_CartesianPoint) P;
P = new CartesianPoint (gpPnt2d);
return P;
}

10
src/Geom2d/Geom2d_Circle.cxx
View File

@ -22,7 +22,6 @@
typedef Geom2d_Circle Circle;
typedef Handle(Geom2d_Circle) Handle(Circle);
typedef gp_Ax2d Ax2d;
typedef gp_Dir2d Dir2d;
typedef gp_Pnt2d Pnt2d;
@ -30,13 +29,6 @@ typedef gp_Trsf2d Trsf2d;
typedef gp_Vec2d Vec2d;
typedef gp_XY XY;
//=======================================================================
//function : Copy
//purpose :
@ -44,7 +36,7 @@ typedef gp_XY XY;
Handle(Geom2d_Geometry) Geom2d_Circle::Copy() const
{
Handle(Circle) C;
Handle(Geom2d_Circle) C;
C = new Circle (pos, radius);
return C;
}

3
src/Geom2d/Geom2d_Curve.cxx
View File

@ -19,7 +19,6 @@
typedef Geom2d_Curve Curve;
typedef Handle(Geom2d_Curve) Handle(Curve);
//=======================================================================
@ -29,7 +28,7 @@ typedef Handle(Geom2d_Curve) Handle(Curve);
Handle(Geom2d_Curve) Geom2d_Curve::Reversed () const
{
Handle(Curve) C = Handle(Curve)::DownCast(Copy());
Handle(Geom2d_Curve) C = Handle(Geom2d_Curve)::DownCast(Copy());
C->Reverse();
return C;
}

6
src/Geom2d/Geom2d_Direction.cxx
View File

@ -19,8 +19,6 @@
#include <Standard_ConstructionError.hxx>
typedef Geom2d_Direction Direction;
typedef Handle(Geom2d_Direction) Handle(Direction);
typedef Handle(Geom2d_Vector) Handle(Vector);
typedef gp_Ax2d Ax2d;
typedef gp_Pnt2d Pnt2d;
typedef gp_Trsf2d Trsf2d;
@ -31,7 +29,7 @@ typedef gp_Trsf2d Trsf2d;
Handle(Geom2d_Geometry) Geom2d_Direction::Copy() const {
Handle(Direction) D;
Handle(Geom2d_Direction) D;
D = new Direction (gpVec2d);
return D;
}
@ -88,7 +86,7 @@ Standard_Real Geom2d_Direction::Magnitude () const { return 1.0; }
Standard_Real Geom2d_Direction::SquareMagnitude () const { return 1.0; }
Standard_Real Geom2d_Direction::Crossed (const Handle(Vector)& Other) const {
Standard_Real Geom2d_Direction::Crossed (const Handle(Geom2d_Vector)& Other) const {
return gpVec2d.Crossed (Other->Vec2d());
}

8
src/Geom2d/Geom2d_Ellipse.cxx
View File

@ -22,9 +22,7 @@
#include <Standard_RangeError.hxx>
#include <Standard_ConstructionError.hxx>
typedef Geom2d_Ellipse Ellipse;
typedef Handle(Geom2d_Ellipse) Handle(Ellipse);
typedef gp_Ax2d Ax2d;
typedef gp_Dir2d Dir2d;
typedef gp_Pnt2d Pnt2d;
@ -32,10 +30,6 @@ typedef gp_Vec2d Vec2d;
typedef gp_Trsf2d Trsf2d;
typedef gp_XY XY;
//=======================================================================
//function : Copy
//purpose :
@ -43,7 +37,7 @@ typedef gp_XY XY;
Handle(Geom2d_Geometry) Geom2d_Ellipse::Copy() const
{
Handle(Ellipse) E;
Handle(Geom2d_Ellipse) E;
E = new Ellipse (pos, majorRadius, minorRadius);
return E;
}

55
src/Geom2d/Geom2d_Geometry.cxx
View File

@ -17,15 +17,12 @@
#include <Geom2d_Geometry.ixx>
#include <Standard_ConstructionError.hxx>
typedef Handle(Geom2d_Geometry) Handle(Geometry);
typedef Geom2d_Geometry Geometry;
typedef gp_Ax2d Ax2d;
typedef gp_Pnt2d Pnt2d;
typedef gp_Vec2d Vec2d;
typedef gp_Trsf2d Trsf2d;
void Geom2d_Geometry::Mirror (const gp_Pnt2d& P) {
Trsf2d T;
@ -74,67 +71,57 @@ void Geom2d_Geometry::Translate (const gp_Pnt2d& P1, const gp_Pnt2d& P2) {
}
Handle(Geometry) Geom2d_Geometry::Mirrored (const gp_Pnt2d& P) const {
Handle(Geometry) me = this;
Handle(Geometry) G = me->Copy();
Handle(Geom2d_Geometry) Geom2d_Geometry::Mirrored (const gp_Pnt2d& P) const
{
Handle(Geom2d_Geometry) G = Copy();
G->Mirror (P);
return G;
}
Handle(Geometry) Geom2d_Geometry::Mirrored (const gp_Ax2d& A) const {
Handle(Geometry) me = this;
Handle(Geometry) G = me->Copy();
Handle(Geom2d_Geometry) Geom2d_Geometry::Mirrored (const gp_Ax2d& A) const
{
Handle(Geom2d_Geometry) G = Copy();
G->Mirror (A);
return G;
}
Handle(Geometry) Geom2d_Geometry::Rotated (
const gp_Pnt2d& P, const Standard_Real Ang) const {
Handle(Geometry) me = this;
Handle(Geometry) G = me->Copy();
Handle(Geom2d_Geometry) Geom2d_Geometry::Rotated (const gp_Pnt2d& P, const Standard_Real Ang) const
{
Handle(Geom2d_Geometry) G = Copy();
G->Rotate (P, Ang);
return G;
}
Handle(Geometry) Geom2d_Geometry::Scaled (
const gp_Pnt2d& P, const Standard_Real S) const {
Handle(Geometry) me = this;
Handle(Geometry) G = me->Copy();
Handle(Geom2d_Geometry) Geom2d_Geometry::Scaled (const gp_Pnt2d& P, const Standard_Real S) const
{
Handle(Geom2d_Geometry) G = Copy();
G->Scale (P, S);
return G;
}
Handle(Geometry) Geom2d_Geometry::Transformed (const gp_Trsf2d& T) const {
Handle(Geometry) me = this;
Handle(Geometry) G = me->Copy();
Handle(Geom2d_Geometry) Geom2d_Geometry::Transformed (const gp_Trsf2d& T) const
{
Handle(Geom2d_Geometry) G = Copy();
G->Transform (T);
return G;
}
Handle(Geometry) Geom2d_Geometry::Translated (const gp_Vec2d& V) const {
Handle(Geometry) me = this;
Handle(Geometry) G = me->Copy();
Handle(Geom2d_Geometry) Geom2d_Geometry::Translated (const gp_Vec2d& V) const
{
Handle(Geom2d_Geometry) G = Copy();
G->Translate (V);
return G;
}
Handle(Geometry) Geom2d_Geometry::Translated (
const gp_Pnt2d& P1, const gp_Pnt2d& P2) const {
Handle(Geometry) me = this;
Handle(Geometry) G = me->Copy();
Handle(Geom2d_Geometry) Geom2d_Geometry::Translated (const gp_Pnt2d& P1, const gp_Pnt2d& P2) const
{
Handle(Geom2d_Geometry) G = Copy();
G->Translate (P1, P2);
return G;
}

9
src/Geom2d/Geom2d_Hyperbola.cxx
View File

@ -25,10 +25,7 @@
#include <Standard_DomainError.hxx>
#include <Standard_RangeError.hxx>
typedef Geom2d_Hyperbola Hyperbola;
typedef Handle(Geom2d_Hyperbola) Handle(Hyperbola);
typedef gp_Ax2d Ax2d;
typedef gp_Dir2d Dir2d;
typedef gp_Pnt2d Pnt2d;
@ -36,10 +33,6 @@ typedef gp_Vec2d Vec2d;
typedef gp_Trsf2d Trsf2d;
typedef gp_XY XY;
//=======================================================================
//function : Copy
//purpose :
@ -47,7 +40,7 @@ typedef gp_XY XY;
Handle(Geom2d_Geometry) Geom2d_Hyperbola::Copy() const
{
Handle(Hyperbola) H;
Handle(Geom2d_Hyperbola) H;
H = new Hyperbola (pos, majorRadius, minorRadius);
return H;
}

8
src/Geom2d/Geom2d_Line.cxx
View File

@ -21,9 +21,7 @@
#include <gp_XY.hxx>
#include <Standard_RangeError.hxx>
typedef Geom2d_Line Line;
typedef Handle(Geom2d_Line) Handle(Line);
typedef gp_Ax2d Ax2d;
typedef gp_Dir2d Dir2d;
typedef gp_Pnt2d Pnt2d;
@ -31,10 +29,6 @@ typedef gp_Vec2d Vec2d;
typedef gp_Trsf2d Trsf2d;
typedef gp_XY XY;
//=======================================================================
//function : Copy
//purpose :
@ -42,7 +36,7 @@ typedef gp_XY XY;
Handle(Geom2d_Geometry) Geom2d_Line::Copy() const
{
Handle(Line) L;
Handle(Geom2d_Line) L;
L = new Line (pos);
return L;
}

9
src/Geom2d/Geom2d_OffsetCurve.cxx
View File

@ -37,10 +37,7 @@
#include <gp_XY.hxx>
#include <Precision.hxx>
typedef Handle(Geom2d_OffsetCurve) Handle(OffsetCurve);
typedef Geom2d_OffsetCurve OffsetCurve;
typedef Handle(Geom2d_Geometry) Handle(Geometry);
typedef Handle(Geom2d_Curve) Handle(Curve);
typedef Geom2d_Curve Curve;
typedef gp_Dir2d Dir2d;
typedef gp_Pnt2d Pnt2d;
@ -70,7 +67,7 @@ static Standard_Boolean AdjustDerivative(const Handle(Geom2d_Curve)& theCurve, S
Handle(Geom2d_Geometry) Geom2d_OffsetCurve::Copy () const
{
Handle(OffsetCurve) C;
Handle(Geom2d_OffsetCurve) C;
C = new OffsetCurve (basisCurve, offsetValue);
return C;
}
@ -116,7 +113,7 @@ Standard_Real Geom2d_OffsetCurve::ReversedParameter( const Standard_Real U) cons
//purpose :
//=======================================================================
void Geom2d_OffsetCurve::SetBasisCurve (const Handle(Curve)& C,
void Geom2d_OffsetCurve::SetBasisCurve (const Handle(Geom2d_Curve)& C,
const Standard_Boolean isNotCheckC0)
{
const Standard_Real aUf = C->FirstParameter(),
@ -189,7 +186,7 @@ void Geom2d_OffsetCurve::SetOffsetValue (const Standard_Real D) { offsetValue =
//purpose :
//=======================================================================
Handle(Curve) Geom2d_OffsetCurve::BasisCurve () const
Handle(Geom2d_Curve) Geom2d_OffsetCurve::BasisCurve () const
{
return basisCurve;
}

8
src/Geom2d/Geom2d_Parabola.cxx
View File

@ -24,7 +24,6 @@
#include <Standard_RangeError.hxx>
typedef Geom2d_Parabola Parabola;
typedef Handle(Geom2d_Parabola) Handle(Parabola);
typedef gp_Ax2d Ax2d;
typedef gp_Dir2d Dir2d;
typedef gp_Pnt2d Pnt2d;
@ -32,11 +31,6 @@ typedef gp_Vec2d Vec2d;
typedef gp_Trsf2d Trsf2d;
typedef gp_XY XY;
//=======================================================================
//function : Copy
//purpose :
@ -44,7 +38,7 @@ typedef gp_XY XY;
Handle(Geom2d_Geometry) Geom2d_Parabola::Copy() const
{
Handle(Parabola) Prb;
Handle(Geom2d_Parabola) Prb;
Prb = new Parabola (pos, focalLength);
return Prb;
}

6
src/Geom2d/Geom2d_Point.cxx
View File

@ -17,10 +17,8 @@
#include <Geom2d_Point.ixx>
typedef Geom2d_Point Point;
typedef Handle(Geom2d_Point) Handle(Point);
Standard_Real Geom2d_Point::Distance (const Handle(Point)& Other) const {
Standard_Real Geom2d_Point::Distance (const Handle(Geom2d_Point)& Other) const {
gp_Pnt2d P1 = this-> Pnt2d ();
gp_Pnt2d P2 = Other->Pnt2d ();
@ -28,7 +26,7 @@ Standard_Real Geom2d_Point::Distance (const Handle(Point)& Other) const {
}
Standard_Real Geom2d_Point::SquareDistance (const Handle(Point)& Other) const {
Standard_Real Geom2d_Point::SquareDistance (const Handle(Geom2d_Point)& Other) const {
gp_Pnt2d P1 = this-> Pnt2d ();
gp_Pnt2d P2 = Other->Pnt2d ();

21
src/Geom2d/Geom2d_Transformation.cxx
View File

@ -18,23 +18,14 @@
typedef Geom2d_Transformation Transformation;
typedef Handle(Geom2d_Transformation) Handle(Transformation);
typedef gp_Ax2d Ax2d;
typedef gp_Pnt2d Pnt2d;
typedef gp_TrsfForm TrsfForm;
typedef gp_Vec2d Vec2d;
Handle(Geom2d_Transformation) Geom2d_Transformation::Copy() const {
Handle(Transformation) T;
Handle(Geom2d_Transformation) T;
T = new Transformation (gpTrsf2d);
return T;
}
@ -49,21 +40,21 @@ Geom2d_Transformation::Geom2d_Transformation (const gp_Trsf2d& T)
: gpTrsf2d (T) { }
Handle(Transformation) Geom2d_Transformation::Inverted () const {
Handle(Geom2d_Transformation) Geom2d_Transformation::Inverted () const {
return new Transformation (gpTrsf2d.Inverted());
}
Handle(Transformation) Geom2d_Transformation::Multiplied (
Handle(Geom2d_Transformation) Geom2d_Transformation::Multiplied (
const Handle(Transformation)& Other) const {
const Handle(Geom2d_Transformation)& Other) const {
return new Transformation (gpTrsf2d.Multiplied (Other->Trsf2d()));
}
Handle(Transformation) Geom2d_Transformation::Powered (const Standard_Integer N) const{
Handle(Geom2d_Transformation) Geom2d_Transformation::Powered (const Standard_Integer N) const{
gp_Trsf2d Temp = gpTrsf2d;
Temp.Power (N);
@ -168,7 +159,7 @@ void Geom2d_Transformation::Power (const Standard_Integer N) { gpTrsf2d.Power (N
void Geom2d_Transformation::PreMultiply (
const Handle(Transformation)& Other) {
const Handle(Geom2d_Transformation)& Other) {
gpTrsf2d.PreMultiply (Other->Trsf2d());
}

15
src/Geom2d/Geom2d_TrimmedCurve.cxx
View File

@ -31,19 +31,12 @@
#include <Precision.hxx>
typedef Handle(Geom2d_TrimmedCurve) Handle(TrimmedCurve);
typedef Geom2d_TrimmedCurve TrimmedCurve;
typedef Handle(Geom2d_Curve) Handle(Curve);
typedef Handle(Geom2d_Geometry) Handle(Geometry);
typedef gp_Ax2d Ax2d;
typedef gp_Pnt2d Pnt2d;
typedef gp_Trsf2d Trsf2d;
typedef gp_Vec2d Vec2d;
//=======================================================================
//function : Copy
//purpose :
@ -51,7 +44,7 @@ typedef gp_Vec2d Vec2d;
Handle(Geom2d_Geometry) Geom2d_TrimmedCurve::Copy () const
{
Handle(TrimmedCurve) Tc;
Handle(Geom2d_TrimmedCurve) Tc;
Tc = new TrimmedCurve (basisCurve, uTrim1, uTrim2);
return Tc;
}
@ -73,9 +66,9 @@ Geom2d_TrimmedCurve::Geom2d_TrimmedCurve (const Handle(Geom2d_Curve)& C,
// kill trimmed basis curves
Handle(Geom2d_TrimmedCurve) T = Handle(Geom2d_TrimmedCurve)::DownCast(C);
if (!T.IsNull())
basisCurve = Handle(Curve)::DownCast(T->BasisCurve()->Copy());
basisCurve = Handle(Geom2d_Curve)::DownCast(T->BasisCurve()->Copy());
else
basisCurve = Handle(Curve)::DownCast(C->Copy());
basisCurve = Handle(Geom2d_Curve)::DownCast(C->Copy());
SetTrim(U1, U2, Sense, theAdjustPeriodic);
}
@ -160,7 +153,7 @@ void Geom2d_TrimmedCurve::SetTrim (const Standard_Real U1,
//purpose :
//=======================================================================
Handle(Curve) Geom2d_TrimmedCurve::BasisCurve () const
Handle(Geom2d_Curve) Geom2d_TrimmedCurve::BasisCurve () const
{
return basisCurve;
}

9
src/Geom2d/Geom2d_Vector.cxx
View File

@ -17,12 +17,9 @@
#include <Geom2d_Vector.ixx>
typedef Geom2d_Vector Vector;
typedef Handle(Geom2d_Vector) Handle(Vector);
typedef gp_Ax2d Ax2d;
typedef gp_Pnt2d Pnt2d;
Standard_Real Geom2d_Vector::Angle (
const Handle(Geom2d_Vector)& Other) const {
@ -39,9 +36,9 @@ Standard_Real Geom2d_Vector::X () const { return gpVec2d.X(); }
Standard_Real Geom2d_Vector::Y () const { return gpVec2d.Y(); }
Handle(Vector) Geom2d_Vector::Reversed () const {
Handle(Geom2d_Vector) Geom2d_Vector::Reversed () const {
Handle(Vector) V = Handle(Vector)::DownCast(Copy());
Handle(Geom2d_Vector) V = Handle(Geom2d_Vector)::DownCast(Copy());
V->Reverse();
return V;
}
@ -53,7 +50,7 @@ void Geom2d_Vector::Coord (Standard_Real& X, Standard_Real& Y) const {
}
Standard_Real Geom2d_Vector::Dot (const Handle(Vector)& Other) const {
Standard_Real Geom2d_Vector::Dot (const Handle(Geom2d_Vector)& Other) const {
return gpVec2d.Dot (Other->Vec2d());
}

27
src/Geom2d/Geom2d_VectorWithMagnitude.cxx
View File

@ -19,15 +19,10 @@
typedef Geom2d_Vector Vector;
typedef Geom2d_VectorWithMagnitude VectorWithMagnitude;
typedef Handle(Geom2d_VectorWithMagnitude) Handle(VectorWithMagnitude);
typedef Handle(Geom2d_Vector) Handle(Vector);
typedef gp_Ax2d Ax2d;
typedef gp_Pnt2d Pnt2d;
typedef gp_Trsf2d Trsf2d;
Geom2d_VectorWithMagnitude::Geom2d_VectorWithMagnitude (const gp_Vec2d& V)
{ gpVec2d = V; }
@ -42,7 +37,7 @@ const Pnt2d& P1, const Pnt2d& P2) { gpVec2d = gp_Vec2d (P1, P2); }
Handle(Geom2d_Geometry) Geom2d_VectorWithMagnitude::Copy() const {
Handle(VectorWithMagnitude) V;
Handle(Geom2d_VectorWithMagnitude) V;
V = new VectorWithMagnitude (gpVec2d);
return V;
}
@ -74,15 +69,15 @@ Standard_Real Geom2d_VectorWithMagnitude::SquareMagnitude () const {
}
void Geom2d_VectorWithMagnitude::Add (const Handle(Vector)& Other) {
void Geom2d_VectorWithMagnitude::Add (const Handle(Geom2d_Vector)& Other) {
gpVec2d.Add (Other->Vec2d());
}
Handle(VectorWithMagnitude) Geom2d_VectorWithMagnitude::Added (
Handle(Geom2d_VectorWithMagnitude) Geom2d_VectorWithMagnitude::Added (
const Handle(Vector)& Other) const {
const Handle(Geom2d_Vector)& Other) const {
gp_Vec2d Temp = Other->Vec2d();
Temp.Add (gpVec2d);
@ -90,7 +85,7 @@ const Handle(Vector)& Other) const {
}
Standard_Real Geom2d_VectorWithMagnitude::Crossed (const Handle(Vector)& Other) const{
Standard_Real Geom2d_VectorWithMagnitude::Crossed (const Handle(Geom2d_Vector)& Other) const{
return gpVec2d.Crossed (Other->Vec2d());
}
@ -102,7 +97,7 @@ void Geom2d_VectorWithMagnitude::Divide (const Standard_Real Scalar) {
}
Handle(VectorWithMagnitude) Geom2d_VectorWithMagnitude::Divided (
Handle(Geom2d_VectorWithMagnitude) Geom2d_VectorWithMagnitude::Divided (
const Standard_Real Scalar) const {
gp_Vec2d V (gpVec2d);
@ -111,7 +106,7 @@ const Standard_Real Scalar) const {
}
Handle(VectorWithMagnitude) Geom2d_VectorWithMagnitude::Multiplied (
Handle(Geom2d_VectorWithMagnitude) Geom2d_VectorWithMagnitude::Multiplied (
const Standard_Real Scalar) const {
gp_Vec2d V(gpVec2d);
@ -129,7 +124,7 @@ void Geom2d_VectorWithMagnitude::Multiply (const Standard_Real Scalar) {
void Geom2d_VectorWithMagnitude::Normalize () { gpVec2d.Normalize (); }
Handle(VectorWithMagnitude) Geom2d_VectorWithMagnitude::Normalized () const {
Handle(Geom2d_VectorWithMagnitude) Geom2d_VectorWithMagnitude::Normalized () const {
gp_Vec2d V = gpVec2d;
V.Normalized ();
@ -137,14 +132,14 @@ Handle(VectorWithMagnitude) Geom2d_VectorWithMagnitude::Normalized () const {
}
void Geom2d_VectorWithMagnitude::Subtract (const Handle(Vector)& Other) {
void Geom2d_VectorWithMagnitude::Subtract (const Handle(Geom2d_Vector)& Other) {
gpVec2d.Subtract (Other->Vec2d());
}
Handle(VectorWithMagnitude) Geom2d_VectorWithMagnitude::Subtracted (
const Handle(Vector)& Other) const {
Handle(Geom2d_VectorWithMagnitude) Geom2d_VectorWithMagnitude::Subtracted (
const Handle(Geom2d_Vector)& Other) const {
gp_Vec2d V = gpVec2d;
V.Subtract (Other->Vec2d());

61
src/Geom2dConvert/Geom2dConvert.cxx
View File

@ -78,39 +78,24 @@ typedef gp_Hypr2d Hypr2d;
typedef gp_Parab2d Parab2d;
typedef gp_Pnt2d Pnt2d;
typedef gp_Trsf2d Trsf2d;
typedef Geom2d_Curve Curve;
typedef Geom2d_BSplineCurve BSplineCurve;
typedef Handle(Geom2d_Curve) Handle(Curve);
typedef Handle(Geom2d_Conic) Handle(Conic);
typedef Handle(Geom2d_Circle) Handle(Circle);
typedef Handle(Geom2d_Ellipse) Handle(Ellipse);
typedef Handle(Geom2d_Hyperbola) Handle(Hyperbola);
typedef Handle(Geom2d_Parabola) Handle(Parabola);
typedef Handle(Geom2d_Geometry) Handle(Geometry);
typedef Handle(Geom2d_BezierCurve) Handle(BezierCurve);
typedef Handle(Geom2d_TrimmedCurve) Handle(TrimmedCurve);
typedef Handle(Geom2d_BSplineCurve) Handle(BSplineCurve);
typedef TColStd_Array1OfReal Array1OfReal;
typedef TColStd_Array1OfInteger Array1OfInteger;
typedef TColgp_Array1OfPnt2d Array1OfPnt2d;
//=======================================================================
//function : BSplineCurveBuilder
//purpose :
//=======================================================================
static Handle(BSplineCurve) BSplineCurveBuilder (
static Handle(Geom2d_BSplineCurve) BSplineCurveBuilder (
const Handle(Conic)& TheConic,
const Handle(Geom2d_Conic)& TheConic,
const Convert_ConicToBSplineCurve& Convert
) {
Handle(BSplineCurve) TheCurve;
Handle(Geom2d_BSplineCurve) TheCurve;
Standard_Integer NbPoles = Convert.NbPoles();
Standard_Integer NbKnots = Convert.NbKnots();
Array1OfPnt2d Poles (1, NbPoles);
@ -140,8 +125,8 @@ const Convert_ConicToBSplineCurve& Convert
Trsf2d T;
T.SetTransformation (TheConic->XAxis(), gp::OX2d());
Handle(BSplineCurve) Cres =
Handle(BSplineCurve)::DownCast(TheCurve->Transformed (T));
Handle(Geom2d_BSplineCurve) Cres =
Handle(Geom2d_BSplineCurve)::DownCast(TheCurve->Transformed (T));
return Cres;
}
@ -151,9 +136,9 @@ const Convert_ConicToBSplineCurve& Convert
//purpose :
//=======================================================================
Handle(BSplineCurve) Geom2dConvert::SplitBSplineCurve (
Handle(Geom2d_BSplineCurve) Geom2dConvert::SplitBSplineCurve (
const Handle(BSplineCurve)& C,
const Handle(Geom2d_BSplineCurve)& C,
const Standard_Integer FromK1,
const Standard_Integer ToK2,
const Standard_Boolean SameOrientation
@ -166,7 +151,7 @@ const Standard_Boolean SameOrientation
Standard_Integer LastK = Max (FromK1, ToK2);
if (FirstK < TheFirst || LastK > TheLast) Standard_OutOfRange::Raise();
Handle(BSplineCurve) NewCurve = Handle(BSplineCurve)::DownCast(C->Copy());
Handle(Geom2d_BSplineCurve) NewCurve = Handle(Geom2d_BSplineCurve)::DownCast(C->Copy());
NewCurve->Segment(C->Knot(FirstK),C->Knot(LastK));
@ -185,9 +170,9 @@ const Standard_Boolean SameOrientation
//purpose :
//=======================================================================
Handle(BSplineCurve) Geom2dConvert::SplitBSplineCurve (
Handle(Geom2d_BSplineCurve) Geom2dConvert::SplitBSplineCurve (
const Handle(BSplineCurve)& C,
const Handle(Geom2d_BSplineCurve)& C,
const Standard_Real FromU1,
const Standard_Real ToU2,
const Standard_Real, // ParametricTolerance,
@ -218,9 +203,9 @@ const Standard_Boolean SameOrientation
//purpose :
//=======================================================================
Handle(BSplineCurve) Geom2dConvert::CurveToBSplineCurve (
Handle(Geom2d_BSplineCurve) Geom2dConvert::CurveToBSplineCurve (
const Handle(Curve)& C,
const Handle(Geom2d_Curve)& C,
const Convert_ParameterisationType Parameterisation)
{
@ -228,7 +213,7 @@ const Convert_ParameterisationType Parameterisation)
if (C->IsKind(STANDARD_TYPE(Geom2d_TrimmedCurve))) {
Handle (Curve) Curv;
Handle(TrimmedCurve) Ctrim = Handle(TrimmedCurve)::DownCast(C);
Handle(Geom2d_TrimmedCurve) Ctrim = Handle(Geom2d_TrimmedCurve)::DownCast(C);
Curv = Ctrim->BasisCurve();
Standard_Real U1 = Ctrim->FirstParameter();
Standard_Real U2 = Ctrim->LastParameter();
@ -259,7 +244,7 @@ const Convert_ParameterisationType Parameterisation)
}
else if (Curv->IsKind(STANDARD_TYPE(Geom2d_Circle))) {
Handle(Circle) TheConic= Handle(Circle)::DownCast(Curv);
Handle(Geom2d_Circle) TheConic= Handle(Geom2d_Circle)::DownCast(Curv);
Circ2d C2d (gp::OX2d(), TheConic->Radius());
if(Parameterisation != Convert_RationalC1) {
Convert_CircleToBSplineCurve Convert (C2d,
@ -306,7 +291,7 @@ const Convert_ParameterisationType Parameterisation)
}
else if (Curv->IsKind(STANDARD_TYPE(Geom2d_Ellipse))) {
Handle(Ellipse) TheConic = Handle(Ellipse)::DownCast(Curv);
Handle(Geom2d_Ellipse) TheConic = Handle(Geom2d_Ellipse)::DownCast(Curv);
Elips2d E2d (gp::OX2d(),
TheConic->MajorRadius(),
@ -356,7 +341,7 @@ const Convert_ParameterisationType Parameterisation)
}
else if (Curv->IsKind(STANDARD_TYPE(Geom2d_Hyperbola))) {
Handle(Hyperbola) TheConic = Handle(Hyperbola)::DownCast(Curv);
Handle(Geom2d_Hyperbola) TheConic = Handle(Geom2d_Hyperbola)::DownCast(Curv);
Hypr2d H2d (gp::OX2d(),
TheConic->MajorRadius(), TheConic->MinorRadius());
@ -365,7 +350,7 @@ const Convert_ParameterisationType Parameterisation)
}
else if (Curv->IsKind(STANDARD_TYPE(Geom2d_Parabola))) {
Handle(Parabola) TheConic = Handle(Parabola)::DownCast(Curv);
Handle(Geom2d_Parabola) TheConic = Handle(Geom2d_Parabola)::DownCast(Curv);
Parab2d Prb2d (gp::OX2d(), TheConic->Focal());
Convert_ParabolaToBSplineCurve Convert (Prb2d, U1, U2);
@ -374,7 +359,7 @@ const Convert_ParameterisationType Parameterisation)
else if (Curv->IsKind (STANDARD_TYPE(Geom2d_BezierCurve))) {
Handle(BezierCurve) CBez = Handle(BezierCurve)::DownCast(Curv->Copy());
Handle(Geom2d_BezierCurve) CBez = Handle(Geom2d_BezierCurve)::DownCast(Curv->Copy());
CBez->Segment (U1, U2);
Standard_Integer NbPoles = CBez->NbPoles();
@ -422,7 +407,7 @@ const Convert_ParameterisationType Parameterisation)
else {
if (C->IsKind(STANDARD_TYPE(Geom2d_Ellipse))) {
Handle(Ellipse) TheConic = Handle(Ellipse)::DownCast(C);
Handle(Geom2d_Ellipse) TheConic = Handle(Geom2d_Ellipse)::DownCast(C);
Elips2d E2d (gp::OX2d(),
TheConic->MajorRadius(), TheConic->MinorRadius());
@ -433,7 +418,7 @@ const Convert_ParameterisationType Parameterisation)
}
else if (C->IsKind(STANDARD_TYPE(Geom2d_Circle))) {
Handle(Circle) TheConic = Handle(Circle)::DownCast(C);
Handle(Geom2d_Circle) TheConic = Handle(Geom2d_Circle)::DownCast(C);
Circ2d C2d (gp::OX2d(), TheConic->Radius());
Convert_CircleToBSplineCurve Convert (C2d,
@ -443,7 +428,7 @@ const Convert_ParameterisationType Parameterisation)
}
else if (C->IsKind (STANDARD_TYPE(Geom2d_BezierCurve))) {
Handle(BezierCurve) CBez = Handle(BezierCurve)::DownCast(C);
Handle(Geom2d_BezierCurve) CBez = Handle(Geom2d_BezierCurve)::DownCast(C);
Standard_Integer NbPoles = CBez->NbPoles();
Standard_Integer Degree = CBez->Degree();
@ -1477,7 +1462,7 @@ void Geom2dConvert::C0BSplineToC1BSplineCurve(Handle(Geom2d_BSplineCurve)& BS,
U2=BSKnots(j);
j++;
Handle(Geom2d_BSplineCurve) BSbis=Handle(Geom2d_BSplineCurve::DownCast(BS->Copy()));
Handle(Geom2d_BSplineCurve) BSbis=Handle(Geom2d_BSplineCurve)::DownCast(BS->Copy());
BSbis->Segment(U1,U2);
ArrayOfCurves(i)=BSbis;
}
@ -1566,7 +1551,7 @@ void Geom2dConvert::C0BSplineToArrayOfC1BSplineCurve(const Handle(Geom2d_BSpline
j++;
U2=BSKnots(j);
j++;
Handle(Geom2d_BSplineCurve) BSbis=Handle(Geom2d_BSplineCurve::DownCast(BS->Copy()));
Handle(Geom2d_BSplineCurve) BSbis=Handle(Geom2d_BSplineCurve)::DownCast(BS->Copy());
BSbis->Segment(U1,U2);
ArrayOfCurves(i)=BSbis;
}

6
src/Geom2dConvert/Geom2dConvert_BSplineCurveKnotSplitting.cxx
View File

@ -20,17 +20,13 @@
#include <BSplCLib.hxx>
typedef Handle(Geom2d_BSplineCurve) Handle(BSplineCurve);
typedef TColStd_Array1OfInteger Array1OfInteger;
typedef TColStd_HArray1OfInteger HArray1OfInteger;
Geom2dConvert_BSplineCurveKnotSplitting::
Geom2dConvert_BSplineCurveKnotSplitting (
const Handle(BSplineCurve)& BasisCurve,
const Handle(Geom2d_BSplineCurve)& BasisCurve,
const Standard_Integer ContinuityRange
) {

3
src/Geom2dGcc/Geom2dGcc_Circ2dTanCen.cxx
View File

@ -22,13 +22,14 @@
#include <GccEnt_BadQualifier.hxx>
#include <Geom2d_Circle.hxx>
#include <Geom2d_Line.hxx>
#include <Geom2d_Point.hxx>
#include <GccEnt_QualifiedCirc.hxx>
#include <GccEnt_QualifiedLin.hxx>
#include <StdFail_NotDone.hxx>
Geom2dGcc_Circ2dTanCen::
Geom2dGcc_Circ2dTanCen (const Geom2dGcc_QualifiedCurve& Qualified1 ,
const Handle(Geom2d_Point&) PCenter ,
const Handle(Geom2d_Point)& PCenter ,
const Standard_Real Tolerance ):
cirsol(1,2) ,
qualifier1(1,2),

2
src/Geom2dGcc/Geom2dGcc_Circ2dTanOnRad.cxx
View File

@ -140,7 +140,7 @@ Geom2dGcc_Circ2dTanOnRad::
}
Geom2dGcc_Circ2dTanOnRad::
Geom2dGcc_Circ2dTanOnRad (const Handle(Geom2d_Point&) Point1 ,
Geom2dGcc_Circ2dTanOnRad (const Handle(Geom2d_Point)& Point1 ,
const Geom2dAdaptor_Curve& OnCurve ,
const Standard_Real Radius ,
const Standard_Real Tolerance ):

2
src/GeomConvert/GeomConvert.cxx
View File

@ -1331,7 +1331,7 @@ void GeomConvert::C0BSplineToArrayOfC1BSplineCurve(
U2=BSKnots(j);
j++;
Handle(Geom_BSplineCurve)
BSbis=Handle(Geom_BSplineCurve::DownCast(BS->Copy()));
BSbis=Handle(Geom_BSplineCurve)::DownCast(BS->Copy());
BSbis->Segment(U1,U2);
ArrayOfCurves(i)=BSbis;
}

52
src/GeomConvert/GeomConvert_1.cxx
View File

@ -68,47 +68,25 @@
#include <gp_Trsf.hxx>
#include <gp_GTrsf.hxx>
typedef Geom_Surface Surface;
typedef Geom_BSplineSurface BSplineSurface;
typedef Handle(Geom_Curve) Handle(Curve);
typedef Handle(Geom_BSplineCurve) Handle(BSplineCurve);
typedef Handle(Geom_BezierSurface) Handle(BezierSurface);
typedef Handle(Geom_Geometry) Handle(Geometry);
typedef Handle(Geom_Surface) Handle(Surface);
typedef Handle(Geom_Plane) Handle(Plane);
typedef Handle(Geom_CylindricalSurface) Handle(CylindricalSurface);
typedef Handle(Geom_ConicalSurface) Handle(ConicalSurface);
typedef Handle(Geom_SphericalSurface) Handle(SphericalSurface);
typedef Handle(Geom_ToroidalSurface) Handle(ToroidalSurface);
typedef Handle(Geom_BSplineSurface) Handle(BSplineSurface);
typedef Handle(Geom_SurfaceOfRevolution) Handle(SurfaceOfRevolution);
typedef Handle(Geom_SurfaceOfLinearExtrusion) Handle(SurfaceOfLinearExtrusion);
typedef Handle(Geom_RectangularTrimmedSurface)
Handle(RectangularTrimmedSurface);
typedef TColStd_Array1OfReal Array1OfReal;
typedef TColStd_Array2OfReal Array2OfReal;
typedef TColStd_Array1OfInteger Array1OfInteger;
typedef TColStd_Array2OfInteger Array2OfInteger;
typedef TColgp_Array2OfPnt Array2OfPnt;
typedef TColgp_Array1OfPnt Array1OfPnt;
typedef gp_Pnt Pnt;
//=======================================================================
//function : BSplineSurfaceBuilder
//purpose :
//=======================================================================
Handle(BSplineSurface) BSplineSurfaceBuilder
Handle(Geom_BSplineSurface) BSplineSurfaceBuilder
(const Convert_ElementarySurfaceToBSplineSurface& Convert)
{
Handle(BSplineSurface) TheSurface;
Handle(Geom_BSplineSurface) TheSurface;
Standard_Integer UDegree = Convert.UDegree ();
Standard_Integer VDegree = Convert.VDegree ();
Standard_Integer NbUPoles = Convert.NbUPoles();
@ -148,8 +126,8 @@ Handle(BSplineSurface) BSplineSurfaceBuilder
//purpose :
//=======================================================================
Handle(BSplineSurface) GeomConvert::SplitBSplineSurface
(const Handle(BSplineSurface)& S,
Handle(Geom_BSplineSurface) GeomConvert::SplitBSplineSurface
(const Handle(Geom_BSplineSurface)& S,
const Standard_Integer FromUK1,
const Standard_Integer ToUK2,
const Standard_Integer FromVK1,
@ -169,7 +147,7 @@ Handle(BSplineSurface) GeomConvert::SplitBSplineSurface
if (FirstUK < FirstU || LastUK > LastU ||
FirstVK < FirstV || LastVK > LastV) { Standard_DomainError::Raise(); }
Handle(BSplineSurface) S1= Handle(BSplineSurface)::DownCast(S->Copy());
Handle(Geom_BSplineSurface) S1= Handle(Geom_BSplineSurface)::DownCast(S->Copy());
S1->Segment(S1->UKnot(FirstUK),S1->UKnot(LastUK),
S1->VKnot(FirstVK),S1->VKnot(LastVK));
@ -195,8 +173,8 @@ Handle(BSplineSurface) GeomConvert::SplitBSplineSurface
//purpose :
//=======================================================================
Handle(BSplineSurface) GeomConvert::SplitBSplineSurface
(const Handle(BSplineSurface)& S,
Handle(Geom_BSplineSurface) GeomConvert::SplitBSplineSurface
(const Handle(Geom_BSplineSurface)& S,
const Standard_Integer FromK1,
const Standard_Integer ToK2,
const Standard_Boolean USplit,
@ -205,7 +183,7 @@ Handle(BSplineSurface) GeomConvert::SplitBSplineSurface
if (FromK1 == ToK2) Standard_DomainError::Raise();
Handle(BSplineSurface) S1 = Handle(BSplineSurface)::DownCast(S->Copy());
Handle(Geom_BSplineSurface) S1 = Handle(Geom_BSplineSurface)::DownCast(S->Copy());
if (USplit) {
@ -258,8 +236,8 @@ Handle(BSplineSurface) GeomConvert::SplitBSplineSurface
//purpose :
//=======================================================================
Handle(BSplineSurface) GeomConvert::SplitBSplineSurface
(const Handle(BSplineSurface)& S,
Handle(Geom_BSplineSurface) GeomConvert::SplitBSplineSurface
(const Handle(Geom_BSplineSurface)& S,
const Standard_Real FromU1,
const Standard_Real ToU2,
const Standard_Real FromV1,
@ -300,8 +278,8 @@ Handle(BSplineSurface) GeomConvert::SplitBSplineSurface
//purpose :
//=======================================================================
Handle(BSplineSurface) GeomConvert::SplitBSplineSurface
(const Handle(BSplineSurface)& S,
Handle(Geom_BSplineSurface) GeomConvert::SplitBSplineSurface
(const Handle(Geom_BSplineSurface)& S,
const Standard_Real FromParam1,
const Standard_Real ToParam2,
const Standard_Boolean USplit,
@ -311,7 +289,7 @@ Handle(BSplineSurface) GeomConvert::SplitBSplineSurface
if (Abs (FromParam1 - ToParam2) <= Abs(ParametricTolerance)) {
Standard_DomainError::Raise();
}
Handle(BSplineSurface) NewSurface
Handle(Geom_BSplineSurface) NewSurface
= Handle(Geom_BSplineSurface)::DownCast(S->Copy());
if (USplit) {
@ -356,7 +334,7 @@ Handle(BSplineSurface) GeomConvert::SplitBSplineSurface
//=======================================================================
Handle(Geom_BSplineSurface) GeomConvert::SurfaceToBSplineSurface
(const Handle(Surface)& Sr)
(const Handle(Geom_Surface)& Sr)
{
Standard_Real U1, U2, V1, V2;
Sr->Bounds (U1, U2, V1, V2);
@ -374,7 +352,7 @@ Handle(Geom_BSplineSurface) GeomConvert::SurfaceToBSplineSurface
}
Handle(Geom_BSplineSurface) TheSurface;
Handle(Surface) S;
Handle(Geom_Surface) S;
Handle(Geom_OffsetSurface) OffsetSur;
if (Sr->IsKind(STANDARD_TYPE(Geom_OffsetSurface))) {
OffsetSur = *((Handle(Geom_OffsetSurface)*)& Sr);

Some files were not shown because too many files have changed in this diff Show More