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

0028966: Coding Rules - remove Adaptor2d_HCurve2d, Adaptor3d_HCurve and Adaptor3d_HSurface classes

Browse Source 
Adaptor2d_Curve2d, Adaptor3d_Curve and Adaptor3d_Surface now inherit Standard_Transient.
Interfaces Adaptor2d_HCurve2d, Adaptor3d_HCurve, Adaptor3d_HSurface and their subclasses
are now aliases to Adaptor2d_Curve2d, Adaptor3d_Curve and Adaptor3d_Surface.
Removed numerous unsafe reinterpret casts.

Generic classes Adaptor3d_GenHCurve, Adaptor3d_GenHSurface, Adaptor2d_GenHCurve2d have been removed.
Several redundant .lxx files have been merged into .hxx.

Removed obsolete adaptor classes with H suffix.
This commit is contained in:
kgv
2020-12-03 17:36:19 +03:00
committed by bugmaster
parent 266877a7c3
commit c22b52d60e
710 changed files with 6144 additions and 14175 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/ChFi3d/ChFi3d.cxx
View File

@@ -31,7 +31,7 @@
#include <TopoDS_Edge.hxx>
#include <BRepTools.hxx>
#include <IntTools_Tools.hxx>
#include <BRepAdaptor_HSurface.hxx>
#include <BRepAdaptor_Surface.hxx>
#include <BRepTopAdaptor_TopolTool.hxx>
#include <LocalAnalysis_SurfaceContinuity.hxx>
#include <TopOpeBRepTool_TOOL.hxx>
@@ -174,8 +174,8 @@ Standard_Boolean ChFi3d::IsTangentFaces(const TopoDS_Edge& theEdge,
// Computation of the number of samples on the edge.
BRepAdaptor_Surface aBAS1(theFace1);
BRepAdaptor_Surface aBAS2(theFace2);
Handle(BRepAdaptor_HSurface) aBAHS1 = new BRepAdaptor_HSurface(aBAS1);
Handle(BRepAdaptor_HSurface) aBAHS2 = new BRepAdaptor_HSurface(aBAS2);
Handle(BRepAdaptor_Surface) aBAHS1 = new BRepAdaptor_Surface(aBAS1);
Handle(BRepAdaptor_Surface) aBAHS2 = new BRepAdaptor_Surface(aBAS2);
Handle(BRepTopAdaptor_TopolTool) aTool1 = new BRepTopAdaptor_TopolTool(aBAHS1);
Handle(BRepTopAdaptor_TopolTool) aTool2 = new BRepTopAdaptor_TopolTool(aBAHS2);
Standard_Integer aNbSamples1 = aTool1->NbSamples();

10
src/ChFi3d/ChFi3d_Builder.cxx
View File

@@ -15,8 +15,8 @@
// commercial license or contractual agreement.
#include <Adaptor2d_HCurve2d.hxx>
#include <Adaptor3d_HSurface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor3d_TopolTool.hxx>
#include <AppBlend_Approx.hxx>
#include <Blend_CurvPointFuncInv.hxx>
@@ -28,8 +28,8 @@
#include <Blend_SurfRstFunction.hxx>
#include <BRep_Builder.hxx>
#include <BRep_Tool.hxx>
#include <BRepAdaptor_HCurve2d.hxx>
#include <BRepAdaptor_HSurface.hxx>
#include <BRepAdaptor_Curve2d.hxx>
#include <BRepAdaptor_Surface.hxx>
#include <BRepBlend_Line.hxx>
#include <BRepLib.hxx>
#include <BRepTopAdaptor_TopolTool.hxx>
@@ -38,7 +38,7 @@
#include <ChFi3d_Builder_0.hxx>
#include <ChFiDS_CommonPoint.hxx>
#include <ChFiDS_HData.hxx>
#include <ChFiDS_HElSpine.hxx>
#include <ChFiDS_ElSpine.hxx>
#include <ChFiDS_ListIteratorOfListOfStripe.hxx>
#include <ChFiDS_SequenceOfSurfData.hxx>
#include <ChFiDS_Spine.hxx>

246
src/ChFi3d/ChFi3d_Builder.hxx
View File

@@ -17,50 +17,38 @@
#ifndef _ChFi3d_Builder_HeaderFile
#define _ChFi3d_Builder_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <TopoDS_Shape.hxx>
#include <Standard_Real.hxx>
#include <BRepAdaptor_Curve2d.hxx>
#include <BRepAdaptor_Surface.hxx>
#include <GeomAbs_Shape.hxx>
#include <ChFiDS_Map.hxx>
#include <ChFiDS_ErrorStatus.hxx>
#include <ChFiDS_ListOfStripe.hxx>
#include <ChFiDS_StripeMap.hxx>
#include <ChFiDS_Map.hxx>
#include <ChFiDS_Regularities.hxx>
#include <ChFiDS_SequenceOfSurfData.hxx>
#include <ChFiDS_StripeMap.hxx>
#include <ChFiDS_ElSpine.hxx>
#include <math_Vector.hxx>
#include <TopoDS_Shape.hxx>
#include <TopTools_ListOfShape.hxx>
#include <TopTools_DataMapOfShapeListOfInteger.hxx>
#include <TopTools_DataMapOfShapeShape.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Integer.hxx>
#include <ChFiDS_ErrorStatus.hxx>
#include <math_Vector.hxx>
#include <TopAbs_Orientation.hxx>
#include <ChFiDS_SequenceOfSurfData.hxx>
#include <TopAbs_State.hxx>
#include <BRepAdaptor_Surface.hxx>
class TopOpeBRepDS_HDataStructure;
class TopOpeBRepBuild_HBuilder;
class Standard_OutOfRange;
class Standard_NoSuchObject;
class Standard_ConstructionError;
class TopoDS_Shape;
class TopoDS_Edge;
class ChFiDS_Spine;
class TopoDS_Vertex;
class Geom_Surface;
class ChFiDS_SurfData;
class ChFiDS_HElSpine;
class BRepAdaptor_HSurface;
class Adaptor3d_TopolTool;
class BRepAdaptor_HCurve2d;
class BRepBlend_Line;
class Adaptor3d_HSurface;
class Blend_Function;
class Blend_FuncInv;
class Adaptor2d_HCurve2d;
class Blend_SurfRstFunction;
class Blend_SurfPointFuncInv;
class Blend_SurfCurvFuncInv;
@@ -207,9 +195,9 @@ public:
ChFiDS_SequenceOfSurfData& SetData,
const Handle(ChFiDS_Spine)& Spine,
const Standard_Integer Iedge,
const Handle(Adaptor3d_HSurface)& S1,
const Handle(Adaptor3d_Surface)& S1,
const Handle(Adaptor3d_TopolTool)& I1,
const Handle(Adaptor3d_HSurface)& S2,
const Handle(Adaptor3d_Surface)& S2,
const Handle(Adaptor3d_TopolTool)& I2,
Standard_Boolean& Intf,
Standard_Boolean& Intl);
@@ -227,12 +215,12 @@ protected:
Standard_EXPORT virtual void SimulKPart (const Handle(ChFiDS_SurfData)& SD) const = 0;
Standard_EXPORT virtual Standard_Boolean SimulSurf (Handle(ChFiDS_SurfData)& Data,
const Handle(ChFiDS_HElSpine)& Guide,
const Handle(ChFiDS_ElSpine)& Guide,
const Handle(ChFiDS_Spine)& Spine,
const Standard_Integer Choix,
const Handle(BRepAdaptor_HSurface)& S1,
const Handle(BRepAdaptor_Surface)& S1,
const Handle(Adaptor3d_TopolTool)& I1,
const Handle(BRepAdaptor_HSurface)& S2,
const Handle(BRepAdaptor_Surface)& S2,
const Handle(Adaptor3d_TopolTool)& I2,
const Standard_Real TolGuide,
Standard_Real& First,
@@ -247,16 +235,16 @@ protected:
Standard_Integer& Intl) = 0;
Standard_EXPORT virtual void SimulSurf (Handle(ChFiDS_SurfData)& Data,
const Handle(ChFiDS_HElSpine)& Guide,
const Handle(ChFiDS_ElSpine)& Guide,
const Handle(ChFiDS_Spine)& Spine,
const Standard_Integer Choix,
const Handle(BRepAdaptor_HSurface)& S1,
const Handle(BRepAdaptor_Surface)& S1,
const Handle(Adaptor3d_TopolTool)& I1,
const Handle(BRepAdaptor_HCurve2d)& PC1,
const Handle(BRepAdaptor_HSurface)& Sref1,
const Handle(BRepAdaptor_HCurve2d)& PCref1,
const Handle(BRepAdaptor_Curve2d)& PC1,
const Handle(BRepAdaptor_Surface)& Sref1,
const Handle(BRepAdaptor_Curve2d)& PCref1,
Standard_Boolean& Decroch1,
const Handle(BRepAdaptor_HSurface)& S2,
const Handle(BRepAdaptor_Surface)& S2,
const Handle(Adaptor3d_TopolTool)& I2,
const TopAbs_Orientation Or2,
const Standard_Real Fleche,
@@ -272,17 +260,17 @@ protected:
const math_Vector& Soldep);
Standard_EXPORT virtual void SimulSurf (Handle(ChFiDS_SurfData)& Data,
const Handle(ChFiDS_HElSpine)& Guide,
const Handle(ChFiDS_ElSpine)& Guide,
const Handle(ChFiDS_Spine)& Spine,
const Standard_Integer Choix,
const Handle(BRepAdaptor_HSurface)& S1,
const Handle(BRepAdaptor_Surface)& S1,
const Handle(Adaptor3d_TopolTool)& I1,
const TopAbs_Orientation Or1,
const Handle(BRepAdaptor_HSurface)& S2,
const Handle(BRepAdaptor_Surface)& S2,
const Handle(Adaptor3d_TopolTool)& I2,
const Handle(BRepAdaptor_HCurve2d)& PC2,
const Handle(BRepAdaptor_HSurface)& Sref2,
const Handle(BRepAdaptor_HCurve2d)& PCref2,
const Handle(BRepAdaptor_Curve2d)& PC2,
const Handle(BRepAdaptor_Surface)& Sref2,
const Handle(BRepAdaptor_Curve2d)& PCref2,
Standard_Boolean& Decroch2,
const Standard_Real Fleche,
const Standard_Real TolGuide,
@@ -297,21 +285,21 @@ protected:
const math_Vector& Soldep);
Standard_EXPORT virtual void SimulSurf (Handle(ChFiDS_SurfData)& Data,
const Handle(ChFiDS_HElSpine)& Guide,
const Handle(ChFiDS_ElSpine)& Guide,
const Handle(ChFiDS_Spine)& Spine,
const Standard_Integer Choix,
const Handle(BRepAdaptor_HSurface)& S1,
const Handle(BRepAdaptor_Surface)& S1,
const Handle(Adaptor3d_TopolTool)& I1,
const Handle(BRepAdaptor_HCurve2d)& PC1,
const Handle(BRepAdaptor_HSurface)& Sref1,
const Handle(BRepAdaptor_HCurve2d)& PCref1,
const Handle(BRepAdaptor_Curve2d)& PC1,
const Handle(BRepAdaptor_Surface)& Sref1,
const Handle(BRepAdaptor_Curve2d)& PCref1,
Standard_Boolean& Decroch1,
const TopAbs_Orientation Or1,
const Handle(BRepAdaptor_HSurface)& S2,
const Handle(BRepAdaptor_Surface)& S2,
const Handle(Adaptor3d_TopolTool)& I2,
const Handle(BRepAdaptor_HCurve2d)& PC2,
const Handle(BRepAdaptor_HSurface)& Sref2,
const Handle(BRepAdaptor_HCurve2d)& PCref2,
const Handle(BRepAdaptor_Curve2d)& PC2,
const Handle(BRepAdaptor_Surface)& Sref2,
const Handle(BRepAdaptor_Curve2d)& PCref2,
Standard_Boolean& Decroch2,
const TopAbs_Orientation Or2,
const Standard_Real Fleche,
@@ -328,12 +316,12 @@ protected:
const math_Vector& Soldep);
Standard_EXPORT Standard_Boolean SimulData (Handle(ChFiDS_SurfData)& Data,
const Handle(ChFiDS_HElSpine)& Guide,
const Handle(ChFiDS_HElSpine)& AdditionalGuide,
const Handle(ChFiDS_ElSpine)& Guide,
const Handle(ChFiDS_ElSpine)& AdditionalGuide,
Handle(BRepBlend_Line)& Lin,
const Handle(Adaptor3d_HSurface)& S1,
const Handle(Adaptor3d_Surface)& S1,
const Handle(Adaptor3d_TopolTool)& I1,
const Handle(Adaptor3d_HSurface)& S2,
const Handle(Adaptor3d_Surface)& S2,
const Handle(Adaptor3d_TopolTool)& I2,
Blend_Function& Func,
Blend_FuncInv& FInv,
@@ -352,12 +340,12 @@ protected:
const Standard_Boolean RecOnS2 = Standard_False);
Standard_EXPORT Standard_Boolean SimulData (Handle(ChFiDS_SurfData)& Data,
const Handle(ChFiDS_HElSpine)& HGuide,
const Handle(ChFiDS_ElSpine)& HGuide,
Handle(BRepBlend_Line)& Lin,
const Handle(Adaptor3d_HSurface)& S1,
const Handle(Adaptor3d_Surface)& S1,
const Handle(Adaptor3d_TopolTool)& I1,
const Handle(Adaptor3d_HSurface)& S2,
const Handle(Adaptor2d_HCurve2d)& PC2,
const Handle(Adaptor3d_Surface)& S2,
const Handle(Adaptor2d_Curve2d)& PC2,
const Handle(Adaptor3d_TopolTool)& I2,
Standard_Boolean& Decroch,
Blend_SurfRstFunction& Func,
@@ -380,14 +368,14 @@ protected:
const Standard_Boolean RecRst);
Standard_EXPORT Standard_Boolean SimulData (Handle(ChFiDS_SurfData)& Data,
const Handle(ChFiDS_HElSpine)& HGuide,
const Handle(ChFiDS_ElSpine)& HGuide,
Handle(BRepBlend_Line)& Lin,
const Handle(Adaptor3d_HSurface)& S1,
const Handle(Adaptor2d_HCurve2d)& PC1,
const Handle(Adaptor3d_Surface)& S1,
const Handle(Adaptor2d_Curve2d)& PC1,
const Handle(Adaptor3d_TopolTool)& I1,
Standard_Boolean& Decroch1,
const Handle(Adaptor3d_HSurface)& S2,
const Handle(Adaptor2d_HCurve2d)& PC2,
const Handle(Adaptor3d_Surface)& S2,
const Handle(Adaptor2d_Curve2d)& PC2,
const Handle(Adaptor3d_TopolTool)& I2,
Standard_Boolean& Decroch2,
Blend_RstRstFunction& Func,
@@ -430,8 +418,8 @@ protected:
Standard_EXPORT void Trunc (const Handle(ChFiDS_SurfData)& SD,
const Handle(ChFiDS_Spine)& Spine,
const Handle(Adaptor3d_HSurface)& S1,
const Handle(Adaptor3d_HSurface)& S2,
const Handle(Adaptor3d_Surface)& S1,
const Handle(Adaptor3d_Surface)& S2,
const Standard_Integer iedge,
const Standard_Boolean isfirst,
const Standard_Integer cntlFiOnS);
@@ -440,15 +428,15 @@ protected:
const Standard_Boolean Simul,
ChFiDS_SequenceOfSurfData& SeqSD,
Handle(ChFiDS_SurfData)& SD,
const Handle(ChFiDS_HElSpine)& Guide,
const Handle(ChFiDS_ElSpine)& Guide,
const Handle(ChFiDS_Spine)& Spine,
const Handle(BRepAdaptor_HSurface)& HS1,
const Handle(BRepAdaptor_HSurface)& HS3,
const Handle(BRepAdaptor_Surface)& HS1,
const Handle(BRepAdaptor_Surface)& HS3,
const gp_Pnt2d& P1,
const gp_Pnt2d& P3,
const Handle(Adaptor3d_TopolTool)& I1,
const Handle(BRepAdaptor_HSurface)& HS2,
const Handle(BRepAdaptor_HSurface)& HS4,
const Handle(BRepAdaptor_Surface)& HS2,
const Handle(BRepAdaptor_Surface)& HS4,
const gp_Pnt2d& P2, const gp_Pnt2d& P4,
const Handle(Adaptor3d_TopolTool)& I2,
const Standard_Real MaxStep,
@@ -464,19 +452,19 @@ protected:
math_Vector& Soldep,
Standard_Integer& Intf,
Standard_Integer& Intl,
Handle(BRepAdaptor_HSurface)& Surf1,
Handle(BRepAdaptor_HSurface)& Surf2);
Handle(BRepAdaptor_Surface)& Surf1,
Handle(BRepAdaptor_Surface)& Surf2);
//! Method, implemented in the inheritants, calculating
//! elements of construction of the surface (fillet or
//! chamfer).
Standard_EXPORT virtual Standard_Boolean PerformSurf (ChFiDS_SequenceOfSurfData& Data,
const Handle(ChFiDS_HElSpine)& Guide,
const Handle(ChFiDS_ElSpine)& Guide,
const Handle(ChFiDS_Spine)& Spine,
const Standard_Integer Choix,
const Handle(BRepAdaptor_HSurface)& S1,
const Handle(BRepAdaptor_Surface)& S1,
const Handle(Adaptor3d_TopolTool)& I1,
const Handle(BRepAdaptor_HSurface)& S2,
const Handle(BRepAdaptor_Surface)& S2,
const Handle(Adaptor3d_TopolTool)& I2,
const Standard_Real MaxStep,
const Standard_Real Fleche,
@@ -496,16 +484,16 @@ protected:
//! the elements of construction of the surface (fillet
//! or chamfer) contact edge/face.
Standard_EXPORT virtual void PerformSurf (ChFiDS_SequenceOfSurfData& Data,
const Handle(ChFiDS_HElSpine)& Guide,
const Handle(ChFiDS_ElSpine)& Guide,
const Handle(ChFiDS_Spine)& Spine,
const Standard_Integer Choix,
const Handle(BRepAdaptor_HSurface)& S1,
const Handle(BRepAdaptor_Surface)& S1,
const Handle(Adaptor3d_TopolTool)& I1,
const Handle(BRepAdaptor_HCurve2d)& PC1,
const Handle(BRepAdaptor_HSurface)& Sref1,
const Handle(BRepAdaptor_HCurve2d)& PCref1,
const Handle(BRepAdaptor_Curve2d)& PC1,
const Handle(BRepAdaptor_Surface)& Sref1,
const Handle(BRepAdaptor_Curve2d)& PCref1,
Standard_Boolean& Decroch1,
const Handle(BRepAdaptor_HSurface)& S2,
const Handle(BRepAdaptor_Surface)& S2,
const Handle(Adaptor3d_TopolTool)& I2,
const TopAbs_Orientation Or2,
const Standard_Real MaxStep,
@@ -525,17 +513,17 @@ protected:
//! the elements of construction of the surface (fillet
//! or chamfer) contact edge/face.
Standard_EXPORT virtual void PerformSurf (ChFiDS_SequenceOfSurfData& Data,
const Handle(ChFiDS_HElSpine)& Guide,
const Handle(ChFiDS_ElSpine)& Guide,
const Handle(ChFiDS_Spine)& Spine,
const Standard_Integer Choix,
const Handle(BRepAdaptor_HSurface)& S1,
const Handle(BRepAdaptor_Surface)& S1,
const Handle(Adaptor3d_TopolTool)& I1,
const TopAbs_Orientation Or1,
const Handle(BRepAdaptor_HSurface)& S2,
const Handle(BRepAdaptor_Surface)& S2,
const Handle(Adaptor3d_TopolTool)& I2,
const Handle(BRepAdaptor_HCurve2d)& PC2,
const Handle(BRepAdaptor_HSurface)& Sref2,
const Handle(BRepAdaptor_HCurve2d)& PCref2,
const Handle(BRepAdaptor_Curve2d)& PC2,
const Handle(BRepAdaptor_Surface)& Sref2,
const Handle(BRepAdaptor_Curve2d)& PCref2,
Standard_Boolean& Decroch2,
const Standard_Real MaxStep,
const Standard_Real Fleche,
@@ -554,21 +542,21 @@ protected:
//! the elements of construction of the surface (fillet
//! or chamfer) contact edge/edge.
Standard_EXPORT virtual void PerformSurf (ChFiDS_SequenceOfSurfData& Data,
const Handle(ChFiDS_HElSpine)& Guide,
const Handle(ChFiDS_ElSpine)& Guide,
const Handle(ChFiDS_Spine)& Spine,
const Standard_Integer Choix,
const Handle(BRepAdaptor_HSurface)& S1,
const Handle(BRepAdaptor_Surface)& S1,
const Handle(Adaptor3d_TopolTool)& I1,
const Handle(BRepAdaptor_HCurve2d)& PC1,
const Handle(BRepAdaptor_HSurface)& Sref1,
const Handle(BRepAdaptor_HCurve2d)& PCref1,
const Handle(BRepAdaptor_Curve2d)& PC1,
const Handle(BRepAdaptor_Surface)& Sref1,
const Handle(BRepAdaptor_Curve2d)& PCref1,
Standard_Boolean& Decroch1,
const TopAbs_Orientation Or1,
const Handle(BRepAdaptor_HSurface)& S2,
const Handle(BRepAdaptor_Surface)& S2,
const Handle(Adaptor3d_TopolTool)& I2,
const Handle(BRepAdaptor_HCurve2d)& PC2,
const Handle(BRepAdaptor_HSurface)& Sref2,
const Handle(BRepAdaptor_HCurve2d)& PCref2,
const Handle(BRepAdaptor_Curve2d)& PC2,
const Handle(BRepAdaptor_Surface)& Sref2,
const Handle(BRepAdaptor_Curve2d)& PCref2,
Standard_Boolean& Decroch2,
const TopAbs_Orientation Or2,
const Standard_Real MaxStep,
@@ -602,10 +590,10 @@ protected:
const ChFiDS_ListOfStripe& LS) = 0;
Standard_EXPORT virtual Standard_Boolean PerformFirstSection (const Handle(ChFiDS_Spine)& S,
const Handle(ChFiDS_HElSpine)& HGuide,
const Handle(ChFiDS_ElSpine)& HGuide,
const Standard_Integer Choix,
Handle(BRepAdaptor_HSurface)& S1,
Handle(BRepAdaptor_HSurface)& S2,
Handle(BRepAdaptor_Surface)& S1,
Handle(BRepAdaptor_Surface)& S2,
const Handle(Adaptor3d_TopolTool)& I1,
const Handle(Adaptor3d_TopolTool)& I2,
const Standard_Real Par,
@@ -625,12 +613,12 @@ protected:
//! Calculates a Line of contact face/face.
Standard_EXPORT Standard_Boolean ComputeData (Handle(ChFiDS_SurfData)& Data,
const Handle(ChFiDS_HElSpine)& Guide,
const Handle(ChFiDS_ElSpine)& Guide,
const Handle(ChFiDS_Spine)& Spine,
Handle(BRepBlend_Line)& Lin,
const Handle(Adaptor3d_HSurface)& S1,
const Handle(Adaptor3d_Surface)& S1,
const Handle(Adaptor3d_TopolTool)& I1,
const Handle(Adaptor3d_HSurface)& S2,
const Handle(Adaptor3d_Surface)& S2,
const Handle(Adaptor3d_TopolTool)& I2,
Blend_Function& Func,
Blend_FuncInv& FInv,
@@ -655,12 +643,12 @@ protected:
//! Calculates a Line of contact edge/face.
Standard_EXPORT Standard_Boolean ComputeData (Handle(ChFiDS_SurfData)& Data,
const Handle(ChFiDS_HElSpine)& HGuide,
const Handle(ChFiDS_ElSpine)& HGuide,
Handle(BRepBlend_Line)& Lin,
const Handle(Adaptor3d_HSurface)& S1,
const Handle(Adaptor3d_Surface)& S1,
const Handle(Adaptor3d_TopolTool)& I1,
const Handle(Adaptor3d_HSurface)& S2,
const Handle(Adaptor2d_HCurve2d)& PC2,
const Handle(Adaptor3d_Surface)& S2,
const Handle(Adaptor2d_Curve2d)& PC2,
const Handle(Adaptor3d_TopolTool)& I2,
Standard_Boolean& Decroch,
Blend_SurfRstFunction& Func,
@@ -683,14 +671,14 @@ protected:
//! Calculates a Line of contact edge/edge.
Standard_EXPORT Standard_Boolean ComputeData (Handle(ChFiDS_SurfData)& Data,
const Handle(ChFiDS_HElSpine)& HGuide,
const Handle(ChFiDS_ElSpine)& HGuide,
Handle(BRepBlend_Line)& Lin,
const Handle(Adaptor3d_HSurface)& S1,
const Handle(Adaptor2d_HCurve2d)& PC1,
const Handle(Adaptor3d_Surface)& S1,
const Handle(Adaptor2d_Curve2d)& PC1,
const Handle(Adaptor3d_TopolTool)& I1,
Standard_Boolean& Decroch1,
const Handle(Adaptor3d_HSurface)& S2,
const Handle(Adaptor2d_HCurve2d)& PC2,
const Handle(Adaptor3d_Surface)& S2,
const Handle(Adaptor2d_Curve2d)& PC2,
const Handle(Adaptor3d_TopolTool)& I2,
Standard_Boolean& Decroch2,
Blend_RstRstFunction& Func,
@@ -716,8 +704,8 @@ protected:
Standard_EXPORT Standard_Boolean CompleteData (Handle(ChFiDS_SurfData)& Data,
Blend_Function& Func,
Handle(BRepBlend_Line)& Lin,
const Handle(Adaptor3d_HSurface)& S1,
const Handle(Adaptor3d_HSurface)& S2,
const Handle(Adaptor3d_Surface)& S1,
const Handle(Adaptor3d_Surface)& S2,
const TopAbs_Orientation Or1,
const Standard_Boolean Gd1,
const Standard_Boolean Gd2,
@@ -728,23 +716,23 @@ protected:
Standard_EXPORT Standard_Boolean CompleteData (Handle(ChFiDS_SurfData)& Data,
Blend_SurfRstFunction& Func,
Handle(BRepBlend_Line)& Lin,
const Handle(Adaptor3d_HSurface)& S1,
const Handle(Adaptor3d_HSurface)& S2,
const Handle(Adaptor3d_Surface)& S1,
const Handle(Adaptor3d_Surface)& S2,
const TopAbs_Orientation Or,
const Standard_Boolean Reversed);
Standard_EXPORT Standard_Boolean CompleteData (Handle(ChFiDS_SurfData)& Data,
Blend_RstRstFunction& Func,
Handle(BRepBlend_Line)& Lin,
const Handle(Adaptor3d_HSurface)& S1,
const Handle(Adaptor3d_HSurface)& S2,
const Handle(Adaptor3d_Surface)& S1,
const Handle(Adaptor3d_Surface)& S2,
const TopAbs_Orientation Or);
Standard_EXPORT Standard_Boolean StoreData (Handle(ChFiDS_SurfData)& Data,
const AppBlend_Approx& Approx,
const Handle(BRepBlend_Line)& Lin,
const Handle(Adaptor3d_HSurface)& S1,
const Handle(Adaptor3d_HSurface)& S2,
const Handle(Adaptor3d_Surface)& S1,
const Handle(Adaptor3d_Surface)& S2,
const TopAbs_Orientation Or1,
const Standard_Boolean Gd1,
const Standard_Boolean Gd2,
@@ -754,9 +742,9 @@ protected:
Standard_EXPORT Standard_Boolean CompleteData (Handle(ChFiDS_SurfData)& Data,
const Handle(Geom_Surface)& Surfcoin,
const Handle(Adaptor3d_HSurface)& S1,
const Handle(Adaptor3d_Surface)& S1,
const Handle(Geom2d_Curve)& PC1,
const Handle(Adaptor3d_HSurface)& S2,
const Handle(Adaptor3d_Surface)& S2,
const Handle(Geom2d_Curve)& PC2,
const TopAbs_Orientation Or,
const Standard_Boolean On1,
@@ -798,7 +786,7 @@ private:
const TopoDS_Edge& E1,
const TopoDS_Vertex& V) const;
Standard_EXPORT void PerformSetOfSurfOnElSpine (const Handle(ChFiDS_HElSpine)& ES,
Standard_EXPORT void PerformSetOfSurfOnElSpine (const Handle(ChFiDS_ElSpine)& ES,
Handle(ChFiDS_Stripe)& St,
Handle(BRepTopAdaptor_TopolTool)& It1,
Handle(BRepTopAdaptor_TopolTool)& It2,
@@ -833,28 +821,28 @@ private:
Standard_EXPORT Standard_Boolean MoreSurfdata (const Standard_Integer Index) const;
Standard_EXPORT Standard_Boolean StartSol (const Handle(ChFiDS_Spine)& Spine,
Handle(BRepAdaptor_HSurface)& HS,
Handle(BRepAdaptor_Surface)& HS,
gp_Pnt2d& P,
Handle(BRepAdaptor_HCurve2d)& HC,
Handle(BRepAdaptor_Curve2d)& HC,
Standard_Real& W,
const Handle(ChFiDS_SurfData)& SD,
const Standard_Boolean isFirst,
const Standard_Integer OnS,
Handle(BRepAdaptor_HSurface)& HSref,
Handle(BRepAdaptor_HCurve2d)& HCref,
Handle(BRepAdaptor_Surface)& HSref,
Handle(BRepAdaptor_Curve2d)& HCref,
Standard_Boolean& RecP,
Standard_Boolean& RecS,
Standard_Boolean& RecRst,
Standard_Boolean& C1Obst,
Handle(BRepAdaptor_HSurface)& HSbis,
Handle(BRepAdaptor_Surface)& HSbis,
gp_Pnt2d& Pbis,
const Standard_Boolean Decroch,
const TopoDS_Vertex& Vref) const;
Standard_EXPORT void StartSol (const Handle(ChFiDS_Stripe)& S,
const Handle(ChFiDS_HElSpine)& HGuide,
Handle(BRepAdaptor_HSurface)& HS1,
Handle(BRepAdaptor_HSurface)& HS2,
const Handle(ChFiDS_ElSpine)& HGuide,
Handle(BRepAdaptor_Surface)& HS1,
Handle(BRepAdaptor_Surface)& HS2,
Handle(BRepTopAdaptor_TopolTool)& I1,
Handle(BRepTopAdaptor_TopolTool)& I2,
gp_Pnt2d& P1,
@@ -863,8 +851,8 @@ private:
Standard_EXPORT void ConexFaces (const Handle(ChFiDS_Spine)& Sp,
const Standard_Integer IEdge,
Handle(BRepAdaptor_HSurface)& HS1,
Handle(BRepAdaptor_HSurface)& HS2) const;
Handle(BRepAdaptor_Surface)& HS1,
Handle(BRepAdaptor_Surface)& HS2) const;
TopoDS_Shape myShape;

182
src/ChFi3d/ChFi3d_Builder_0.cxx
View File

@@ -62,11 +62,11 @@
#include <Geom2d_Line.hxx>
#include <Geom2d_OffsetCurve.hxx>
#include <Geom2dAdaptor_Curve.hxx>
#include <Geom2dAdaptor_HCurve.hxx>
#include <Geom2dAdaptor_Curve.hxx>
#include <Adaptor3d_TopolTool.hxx>
#include <Adaptor3d_CurveOnSurface.hxx>
#include <Adaptor3d_HCurveOnSurface.hxx>
#include <GeomAdaptor_HSurface.hxx>
#include <Adaptor3d_CurveOnSurface.hxx>
#include <GeomAdaptor_Surface.hxx>
#include <FairCurve_Batten.hxx>
#include <FairCurve_AnalysisCode.hxx>
@@ -78,8 +78,8 @@
#include <GeomAPI_ProjectPointOnCurve.hxx>
#include <GC_MakeCircle.hxx>
#include <BRepAdaptor_Curve.hxx>
#include <BRepAdaptor_HCurve.hxx>
#include <BRepAdaptor_HCurve2d.hxx>
#include <BRepAdaptor_Curve.hxx>
#include <BRepAdaptor_Curve2d.hxx>
#include <BRepAdaptor_Surface.hxx>
#include <BRepTopAdaptor_HVertex.hxx>
#include <BRepTopAdaptor_TopolTool.hxx>
@@ -172,8 +172,8 @@ extern void ChFi3d_SettraceDRAWSPINE(const Standard_Boolean b);
#include <stdio.h>
#include <GeomAdaptor_HCurve.hxx>
#include <BRepAdaptor_HSurface.hxx>
#include <GeomAdaptor_Curve.hxx>
#include <BRepAdaptor_Surface.hxx>
#include <TopOpeBRepDS_SurfaceCurveInterference.hxx>
//=======================================================================
@@ -225,21 +225,21 @@ void ChFi3d_Boite(const gp_Pnt2d& p1,const gp_Pnt2d& p2,
//function : EnlargeBox and its friends.
//purpose :
//=======================================================================
static Handle(Adaptor3d_HSurface) Geometry(TopOpeBRepDS_DataStructure& DStr,
static Handle(Adaptor3d_Surface) Geometry(TopOpeBRepDS_DataStructure& DStr,
const Standard_Integer ind)
{
if(ind == 0) return Handle(Adaptor3d_HSurface)();
if(ind == 0) return Handle(Adaptor3d_Surface)();
if(ind > 0) {
TopoDS_Face F = TopoDS::Face(DStr.Shape(ind));
if(F.IsNull()) return Handle(Adaptor3d_HSurface)();
Handle(BRepAdaptor_HSurface) HS = new BRepAdaptor_HSurface();
HS->ChangeSurface().Initialize(F,0);
if(F.IsNull()) return Handle(Adaptor3d_Surface)();
Handle(BRepAdaptor_Surface) HS = new BRepAdaptor_Surface();
HS->Initialize(F,0);
return HS;
}
else{
Handle(Geom_Surface) S = DStr.Surface(-ind).Surface();
if(S.IsNull()) return Handle(Adaptor3d_HSurface)();
return new GeomAdaptor_HSurface(S);
if(S.IsNull()) return Handle(Adaptor3d_Surface)();
return new GeomAdaptor_Surface(S);
}
}
//=======================================================================
@@ -274,7 +274,7 @@ void ChFi3d_EnlargeBox(const Handle(Geom_Curve)& C,
//function : ChFi3d_EnlargeBox
//purpose :
//=======================================================================
void ChFi3d_EnlargeBox(const Handle(Adaptor3d_HSurface)& S,
void ChFi3d_EnlargeBox(const Handle(Adaptor3d_Surface)& S,
const Handle(Geom2d_Curve)& PC,
const Standard_Real wd,
const Standard_Real wf,
@@ -331,8 +331,8 @@ void ChFi3d_EnlargeBox(TopOpeBRepDS_DataStructure& DStr,
const Handle(Geom2d_Curve)& pcs2 = fi2.PCurveOnSurf();
const Handle(Geom_Curve)& c3d1 = DStr.Curve(fi1.LineIndex()).Curve();
const Handle(Geom_Curve)& c3d2 = DStr.Curve(fi2.LineIndex()).Curve();
Handle(Adaptor3d_HSurface) F1 = Geometry(DStr,sd->IndexOfS1());
Handle(Adaptor3d_HSurface) F2 = Geometry(DStr,sd->IndexOfS2());
Handle(Adaptor3d_Surface) F1 = Geometry(DStr,sd->IndexOfS1());
Handle(Adaptor3d_Surface) F2 = Geometry(DStr,sd->IndexOfS2());
Standard_Real p1 = fi1.Parameter(isfirst);
if(!c3d1.IsNull()) b1.Add(c3d1->Value(p1));
if(!pcs1.IsNull()) {
@@ -629,8 +629,8 @@ void ChFi3d_BoundSrf(GeomAdaptor_Surface& S,
//function : ChFi3d_InterPlaneEdge
//purpose :
//=======================================================================
Standard_Boolean ChFi3d_InterPlaneEdge (const Handle(Adaptor3d_HSurface)& Plan,
const Handle(Adaptor3d_HCurve)& C,
Standard_Boolean ChFi3d_InterPlaneEdge (const Handle(Adaptor3d_Surface)& Plan,
const Handle(Adaptor3d_Curve)& C,
Standard_Real& W,
const Standard_Boolean Sens,
const Standard_Real tolc)
@@ -710,7 +710,7 @@ void ChFi3d_ExtrSpineCarac(const TopOpeBRepDS_DataStructure& DStr,
const Handle(ChFiDS_Spine)& sp = cd->Spine();
Handle(ChFiDS_FilSpine) fsp = Handle(ChFiDS_FilSpine)::DownCast(sp);
nbelspine=sp->NbEdges();
Handle(ChFiDS_HElSpine) hels;
Handle(ChFiDS_ElSpine) hels;
if (nbelspine==1) hels = sp->ElSpine(1);
else hels = sp->ElSpine(p);
if(fsp->IsConstant()) { R = fsp->Radius(); }
@@ -1173,8 +1173,8 @@ void ChFi3d_ReparamPcurv(const Standard_Real Uf,
//purpose : Calculation of the pcurve corresponding to a line of intersection
// 3d. Should be called only in analytic cases.
//=======================================================================
void ChFi3d_ProjectPCurv(const Handle(Adaptor3d_HCurve)& HCg,
const Handle(Adaptor3d_HSurface)& HSg,
void ChFi3d_ProjectPCurv(const Handle(Adaptor3d_Curve)& HCg,
const Handle(Adaptor3d_Surface)& HSg,
Handle(Geom2d_Curve)& Pcurv,
const Standard_Real tol,
Standard_Real& tolreached)
@@ -1229,9 +1229,9 @@ void ChFi3d_ProjectPCurv(const Handle(Adaptor3d_HCurve)& HCg,
//function : CheckSameParameter
//purpose : Controls a posteriori that sameparameter worked well
//=======================================================================
Standard_Boolean ChFi3d_CheckSameParameter (const Handle(Adaptor3d_HCurve)& C3d,
Standard_Boolean ChFi3d_CheckSameParameter (const Handle(Adaptor3d_Curve)& C3d,
Handle(Geom2d_Curve)& Pcurv,
const Handle(Adaptor3d_HSurface)& S,
const Handle(Adaptor3d_Surface)& S,
const Standard_Real tol3d,
Standard_Real& tolreached)
{
@@ -1263,9 +1263,9 @@ Standard_Boolean ChFi3d_CheckSameParameter (const Handle(Adaptor3d_HCurve)& C3
//function : SameParameter
//purpose : Encapsulation of Sameparameter
//=======================================================================
Standard_Boolean ChFi3d_SameParameter(const Handle(Adaptor3d_HCurve)& C3d,
Standard_Boolean ChFi3d_SameParameter(const Handle(Adaptor3d_Curve)& C3d,
Handle(Geom2d_Curve)& Pcurv,
const Handle(Adaptor3d_HSurface)& S,
const Handle(Adaptor3d_Surface)& S,
const Standard_Real tol3d,
Standard_Real& tolreached)
{
@@ -1290,8 +1290,8 @@ Standard_Boolean ChFi3d_SameParameter(const Handle(Geom_Curve)& C3d,
const Standard_Real tol3d,
Standard_Real& tolreached)
{
/*szv:static*/ Handle(GeomAdaptor_HSurface) hs(new GeomAdaptor_HSurface(S));
/*szv:static*/ Handle(GeomAdaptor_HCurve) hc(new GeomAdaptor_HCurve(C3d,Pardeb,Parfin));
/*szv:static*/ Handle(GeomAdaptor_Surface) hs(new GeomAdaptor_Surface(S));
/*szv:static*/ Handle(GeomAdaptor_Curve) hc(new GeomAdaptor_Curve(C3d,Pardeb,Parfin));
return ChFi3d_SameParameter(hc,Pcurv,hs,tol3d,tolreached);
}
//=======================================================================
@@ -1300,11 +1300,11 @@ Standard_Boolean ChFi3d_SameParameter(const Handle(Geom_Curve)& C3d,
// to guarantee the same range and parameters as of the
// reference 3D curve.
//=======================================================================
void ChFi3d_ComputePCurv(const Handle(Adaptor3d_HCurve)& C3d,
void ChFi3d_ComputePCurv(const Handle(Adaptor3d_Curve)& C3d,
const gp_Pnt2d& UV1,
const gp_Pnt2d& UV2,
Handle(Geom2d_Curve)& Pcurv,
const Handle(Adaptor3d_HSurface)& S,
const Handle(Adaptor3d_Surface)& S,
const Standard_Real Pardeb,
const Standard_Real Parfin,
const Standard_Real tol3d,
@@ -1331,8 +1331,8 @@ void ChFi3d_ComputePCurv(const Handle(Geom_Curve)& C3d,
Standard_Real& tolreached,
const Standard_Boolean reverse)
{
Handle(Adaptor3d_HSurface) hs(new GeomAdaptor_HSurface(S));
Handle(Adaptor3d_HCurve) hc(new GeomAdaptor_HCurve(C3d,Pardeb,Parfin));
Handle(Adaptor3d_Surface) hs(new GeomAdaptor_Surface(S));
Handle(Adaptor3d_Curve) hc(new GeomAdaptor_Curve(C3d,Pardeb,Parfin));
ChFi3d_ComputePCurv(hc,UV1,UV2,Pcurv,hs,Pardeb,Parfin,tol3d,tolreached,reverse);
}
//=======================================================================
@@ -1395,7 +1395,7 @@ void ChFi3d_ComputePCurv(const gp_Pnt2d& UV1,
//function : ChFi3d_mkbound
//purpose :
//=======================================================================
Handle(GeomFill_Boundary) ChFi3d_mkbound(const Handle(Adaptor3d_HSurface)& Fac,
Handle(GeomFill_Boundary) ChFi3d_mkbound(const Handle(Adaptor3d_Surface)& Fac,
Handle(Geom2d_Curve)& curv,
const Standard_Integer sens1,
const gp_Pnt2d& pfac1,
@@ -1417,7 +1417,7 @@ Handle(GeomFill_Boundary) ChFi3d_mkbound(const Handle(Adaptor3d_HSurface)& Fac,
//function : ChFi3d_mkbound
//purpose :
//=======================================================================
Handle(GeomFill_Boundary) ChFi3d_mkbound(const Handle(Adaptor3d_HSurface)& Surf,
Handle(GeomFill_Boundary) ChFi3d_mkbound(const Handle(Adaptor3d_Surface)& Surf,
Handle(Geom2d_Curve)& curv,
const Standard_Integer sens1,
const gp_Pnt2d& p1,
@@ -1444,14 +1444,14 @@ Handle(GeomFill_Boundary) ChFi3d_mkbound(const Handle(Geom_Surface)& s,
const Standard_Real ta,
const Standard_Boolean isfreeboundary)
{
Handle(Adaptor3d_HSurface) HS = new GeomAdaptor_HSurface(s);
Handle(Adaptor3d_Surface) HS = new GeomAdaptor_Surface(s);
return ChFi3d_mkbound(HS,p1,p2,t3d,ta,isfreeboundary);
}
//=======================================================================
//function : ChFi3d_mkbound
//purpose :
//=======================================================================
Handle(GeomFill_Boundary) ChFi3d_mkbound(const Handle(Adaptor3d_HSurface)& HS,
Handle(GeomFill_Boundary) ChFi3d_mkbound(const Handle(Adaptor3d_Surface)& HS,
const gp_Pnt2d& p1,
const gp_Pnt2d& p2,
const Standard_Real t3d,
@@ -1468,16 +1468,16 @@ Handle(GeomFill_Boundary) ChFi3d_mkbound(const Handle(Adaptor3d_HSurface)& HS,
//function : ChFi3d_mkbound
//purpose :
//=======================================================================
Handle(GeomFill_Boundary) ChFi3d_mkbound(const Handle(Adaptor3d_HSurface)& HS,
Handle(GeomFill_Boundary) ChFi3d_mkbound(const Handle(Adaptor3d_Surface)& HS,
const Handle(Geom2d_Curve)& curv,
const Standard_Real t3d,
const Standard_Real ta,
const Standard_Boolean isfreeboundary)
{
Handle(Geom2dAdaptor_HCurve) HC = new Geom2dAdaptor_HCurve(curv);
Handle(Geom2dAdaptor_Curve) HC = new Geom2dAdaptor_Curve(curv);
Adaptor3d_CurveOnSurface COnS(HC,HS);
if (isfreeboundary) {
Handle(Adaptor3d_HCurveOnSurface) HCOnS = new Adaptor3d_HCurveOnSurface(COnS);
Handle(Adaptor3d_CurveOnSurface) HCOnS = new Adaptor3d_CurveOnSurface(COnS);
return new GeomFill_SimpleBound(HCOnS,t3d,ta);
}
return new GeomFill_BoundWithSurf(COnS,t3d,ta);
@@ -1486,7 +1486,7 @@ Handle(GeomFill_Boundary) ChFi3d_mkbound(const Handle(Adaptor3d_HSurface)& HS,
//function : ChFi3d_mkbound
//purpose :
//=======================================================================
Handle(GeomFill_Boundary) ChFi3d_mkbound(const Handle(Adaptor3d_HSurface)& Fac,
Handle(GeomFill_Boundary) ChFi3d_mkbound(const Handle(Adaptor3d_Surface)& Fac,
Handle(Geom2d_Curve)& curv,
const gp_Pnt2d& p1,
const gp_Pnt2d& p2,
@@ -1533,7 +1533,7 @@ Handle(Geom2d_Curve) ChFi3d_BuildPCurve(const gp_Pnt2d& p1,
//function : ChFi3d_BuildPCurve
//purpose :
//=======================================================================
Handle(Geom2d_Curve) ChFi3d_BuildPCurve(const Handle(Adaptor3d_HSurface)& Surf,
Handle(Geom2d_Curve) ChFi3d_BuildPCurve(const Handle(Adaptor3d_Surface)& Surf,
const gp_Pnt2d& p1,
const gp_Vec2d& v1,
const gp_Pnt2d& p2,
@@ -1565,7 +1565,7 @@ Handle(Geom2d_Curve) ChFi3d_BuildPCurve(const Handle(Adaptor3d_HSurface)& Surf,
//function : ChFi3d_BuildPCurve
//purpose :
//=======================================================================
Handle(Geom2d_Curve) ChFi3d_BuildPCurve(const Handle(Adaptor3d_HSurface)& Surf,
Handle(Geom2d_Curve) ChFi3d_BuildPCurve(const Handle(Adaptor3d_Surface)& Surf,
const gp_Pnt2d& p1,
const gp_Vec& v1,
const gp_Pnt2d& p2,
@@ -1620,8 +1620,8 @@ void ChFi3d_ComputeArete(const ChFiDS_CommonPoint& P1,
// IFlag=0 pcurve et courbe 3d
// IFlag>0 pcurve (parametrage impose si IFlag=2)
{
/*szv:static*/ Handle(GeomAdaptor_HSurface) hs(new GeomAdaptor_HSurface());
/*szv:static*/ Handle(GeomAdaptor_HCurve) hc(new GeomAdaptor_HCurve());
/*szv:static*/ Handle(GeomAdaptor_Surface) hs(new GeomAdaptor_Surface());
/*szv:static*/ Handle(GeomAdaptor_Curve) hc(new GeomAdaptor_Curve());
tolreached = tol3d;
@@ -1645,9 +1645,9 @@ void ChFi3d_ComputeArete(const ChFiDS_CommonPoint& P1,
}
}
if(IFlag != 1) {
hs->ChangeSurface().Load(Surf);
hc->ChangeCurve().Load(C3d,Pardeb,Parfin);
const Handle(Adaptor3d_HCurve)& aHCurve = hc; // to avoid ambiguity
hs->Load(Surf);
hc->Load(C3d,Pardeb,Parfin);
const Handle(Adaptor3d_Curve)& aHCurve = hc; // to avoid ambiguity
ChFi3d_ComputePCurv(aHCurve,UV1,UV2,Pcurv,hs,Pardeb,Parfin,tol3d,tolreached,Standard_False);
}
else{
@@ -1675,9 +1675,9 @@ void ChFi3d_ComputeArete(const ChFiDS_CommonPoint& P1,
}
}
if(IFlag != 1) {
hs->ChangeSurface().Load(Surf);
hc->ChangeCurve().Load(C3d,Pardeb,Parfin);
const Handle(Adaptor3d_HCurve)& aHCurve = hc; // to avoid ambiguity
hs->Load(Surf);
hc->Load(C3d,Pardeb,Parfin);
const Handle(Adaptor3d_Curve)& aHCurve = hc; // to avoid ambiguity
ChFi3d_ComputePCurv(aHCurve,UV1,UV2,Pcurv,hs,Pardeb,Parfin,tol3d,tolreached,Standard_False);
}
else{
@@ -1702,7 +1702,7 @@ void ChFi3d_ComputeArete(const ChFiDS_CommonPoint& P1,
C1.Initialize(P2.Arc());
gp_Vec Vv2;
C1.D1(P2.ParameterOnArc(),Pp,Vv2);
hs->ChangeSurface().Load(Surf);
hs->Load(Surf);
Pcurv = ChFi3d_BuildPCurve(hs,UV1,Vv1,UV2,Vv2,Standard_True);
// There are some cases when PCurve constructed in this way
// leaves the surface, in particular if it results from an
@@ -1726,11 +1726,11 @@ void ChFi3d_ComputeArete(const ChFiDS_CommonPoint& P1,
}
}
Geom2dAdaptor_Curve AC(Pcurv);
Handle(Geom2dAdaptor_HCurve) AHC =
new Geom2dAdaptor_HCurve(AC);
Handle(Geom2dAdaptor_Curve) AHC =
new Geom2dAdaptor_Curve(AC);
GeomAdaptor_Surface AS(Surf);
Handle(GeomAdaptor_HSurface) AHS =
new GeomAdaptor_HSurface(AS);
Handle(GeomAdaptor_Surface) AHS =
new GeomAdaptor_Surface(AS);
Adaptor3d_CurveOnSurface Cs(AHC,AHS);
Pardeb = Cs.FirstParameter();
Parfin = Cs.LastParameter();
@@ -1738,8 +1738,8 @@ void ChFi3d_ComputeArete(const ChFiDS_CommonPoint& P1,
GeomLib::BuildCurve3d(tol3d,Cs,Pardeb,Parfin,C3d,tolreached,avtol);
}
else {
hs->ChangeSurface().Load(Surf);
hc->ChangeCurve().Load(C3d,Pardeb,Parfin);
hs->Load(Surf);
hc->Load(C3d,Pardeb,Parfin);
ChFi3d_ProjectPCurv(hc,hs,Pcurv,tol3d,tolreached);
gp_Pnt2d p2d = Pcurv->Value(Pardeb);
if(!UV1.IsEqual(p2d,Precision::PConfusion())) {
@@ -1826,13 +1826,13 @@ Standard_EXPORT void ChFi3d_FilCommonPoint(const BRepBlend_Extremity& SP,
if (SP.NbPointOnRst() != 0) { // An arc, and/or a vertex is loaded
const BRepBlend_PointOnRst& PR = SP.PointOnRst(1);
Handle(BRepAdaptor_HCurve2d)
Harc = Handle(BRepAdaptor_HCurve2d)::DownCast(PR.Arc());
Handle(BRepAdaptor_Curve2d)
Harc = Handle(BRepAdaptor_Curve2d)::DownCast(PR.Arc());
if(!Harc.IsNull()) {
Standard_Real DistF, DistL, LeParamAmoi;
Standard_Integer Index_min;
TopoDS_Edge E = Harc->ChangeCurve2d().Edge();
TopoDS_Edge E = Harc->Edge();
TopoDS_Vertex V[2];
TopExp::Vertices(E, V[0], V[1]);
@@ -2900,7 +2900,7 @@ TopoDS_Edge ChFi3d_EdgeFromV1(const TopoDS_Vertex& V1,
//purpose : Comme son nom l indique.
//=======================================================================
Standard_Real ChFi3d_ConvTol2dToTol3d(const Handle(Adaptor3d_HSurface)& S,
Standard_Real ChFi3d_ConvTol2dToTol3d(const Handle(Adaptor3d_Surface)& S,
const Standard_Real tol2d)
{
Standard_Real ures = S->UResolution(1.e-7);
@@ -2915,9 +2915,9 @@ Standard_Real ChFi3d_ConvTol2dToTol3d(const Handle(Adaptor3d_HSurface)& S,
// parametrization of surfaces is not homogenous.
//=======================================================================
Standard_Real ChFi3d_EvalTolReached(const Handle(Adaptor3d_HSurface)& S1,
Standard_Real ChFi3d_EvalTolReached(const Handle(Adaptor3d_Surface)& S1,
const Handle(Geom2d_Curve)& pc1,
const Handle(Adaptor3d_HSurface)& S2,
const Handle(Adaptor3d_Surface)& S2,
const Handle(Geom2d_Curve)& pc2,
const Handle(Geom_Curve)& C)
{
@@ -2952,20 +2952,20 @@ Standard_Real ChFi3d_EvalTolReached(const Handle(Adaptor3d_HSurface)& S1,
//function : trsfsurf
//purpose :
//=======================================================================
Handle(Geom_Surface) trsfsurf(const Handle(Adaptor3d_HSurface)& HS,
Handle(Geom_Surface) trsfsurf(const Handle(Adaptor3d_Surface)& HS,
Handle(Adaptor3d_TopolTool)& /*dom*/)
{
//Pour l utilisation des domaines voir avec BUBUCH!!
Handle(Geom_Surface) res;
Handle(BRepAdaptor_HSurface) hbs = Handle(BRepAdaptor_HSurface)::DownCast(HS);
Handle(GeomAdaptor_HSurface) hgs = Handle(GeomAdaptor_HSurface)::DownCast(HS);
Handle(BRepAdaptor_Surface) hbs = Handle(BRepAdaptor_Surface)::DownCast(HS);
Handle(GeomAdaptor_Surface) hgs = Handle(GeomAdaptor_Surface)::DownCast(HS);
if(!hbs.IsNull()) {
res = hbs->ChangeSurface().Surface().Surface();
gp_Trsf trsf = hbs->ChangeSurface().Trsf();
res = hbs->Surface().Surface();
gp_Trsf trsf = hbs->Trsf();
res = Handle(Geom_Surface)::DownCast(res->Transformed(trsf));
}
else if(!hgs.IsNull()) {
res = hgs->ChangeSurface().Surface();
res = hgs->Surface();
}
Handle(Geom_RectangularTrimmedSurface)
tr = Handle(Geom_RectangularTrimmedSurface)::DownCast(res);
@@ -2987,7 +2987,7 @@ Handle(Geom_Surface) trsfsurf(const Handle(Adaptor3d_HSurface)& HS,
}
res = new Geom_RectangularTrimmedSurface(res,U1,U2,V1,V2);
}
// Handle(GeomAdaptor_HSurface) temp = new GeomAdaptor_HSurface(res,U1,U2,V1,V2);
// Handle(GeomAdaptor_Surface) temp = new GeomAdaptor_Surface(res,U1,U2,V1,V2);
// dom = new Adaptor3d_TopolTool(temp);
return res;
}
@@ -3024,8 +3024,8 @@ static void CurveCleaner(Handle(Geom_BSplineCurve)& BS,
// <wholeCurv> means that the resulting curve is restricted by
// boundaries of input surfaces (eap 30 May occ354)
//=======================================================================
Standard_Boolean ChFi3d_ComputeCurves(const Handle(Adaptor3d_HSurface)& S1,
const Handle(Adaptor3d_HSurface)& S2,
Standard_Boolean ChFi3d_ComputeCurves(const Handle(Adaptor3d_Surface)& S1,
const Handle(Adaptor3d_Surface)& S2,
const TColStd_Array1OfReal& Pardeb,
const TColStd_Array1OfReal& Parfin,
Handle(Geom_Curve)& C3d,
@@ -3138,8 +3138,8 @@ Standard_Boolean ChFi3d_ComputeCurves(const Handle(Adaptor3d_HSurface)& S1,
}
}
if(!c1line) ElCLib::AdjustPeriodic(0.,2*M_PI,Precision::Angular(),Udeb,Ufin);
Handle(GeomAdaptor_HCurve) HC = new GeomAdaptor_HCurve();
HC->ChangeCurve().Load(C3d,Udeb,Ufin);
Handle(GeomAdaptor_Curve) HC = new GeomAdaptor_Curve();
HC->Load(C3d,Udeb,Ufin);
ChFi3d_ProjectPCurv(HC,S1,Pc1,tol3d,tolr1);
if(S1->GetType() == GeomAbs_Cylinder) {
Standard_Real x,y;
@@ -3175,8 +3175,8 @@ Standard_Boolean ChFi3d_ComputeCurves(const Handle(Adaptor3d_HSurface)& S1,
Udeb = - Udeb;
Ufin = - Ufin;
}
Handle(GeomAdaptor_HCurve) HC = new GeomAdaptor_HCurve();
HC->ChangeCurve().Load(C3d,Udeb,Ufin);
Handle(GeomAdaptor_Curve) HC = new GeomAdaptor_Curve();
HC->Load(C3d,Udeb,Ufin);
ChFi3d_ProjectPCurv(HC,S1,Pc1,tol3d,tolr1);
ChFi3d_ProjectPCurv(HC,S2,Pc2,tol3d,tolr2);
C3d = new Geom_TrimmedCurve(C3d,Udeb,Ufin);
@@ -3511,8 +3511,8 @@ Standard_Boolean ChFi3d_ComputeCurves(const Handle(Adaptor3d_HSurface)& S1,
//
//=======================================================================
Standard_Boolean ChFi3d_IntCS(const Handle(Adaptor3d_HSurface)& S,
const Handle(Adaptor3d_HCurve)& C,
Standard_Boolean ChFi3d_IntCS(const Handle(Adaptor3d_Surface)& S,
const Handle(Adaptor3d_Curve)& C,
gp_Pnt2d& p2dS,
Standard_Real& wc)
{
@@ -3575,8 +3575,8 @@ Standard_Boolean ChFi3d_IntCS(const Handle(Adaptor3d_HSurface)& S,
void ChFi3d_ComputesIntPC (const ChFiDS_FaceInterference& Fi1,
const ChFiDS_FaceInterference& Fi2,
const Handle(GeomAdaptor_HSurface)& HS1,
const Handle(GeomAdaptor_HSurface)& HS2,
const Handle(GeomAdaptor_Surface)& HS1,
const Handle(GeomAdaptor_Surface)& HS2,
Standard_Real& UInt1,
Standard_Real& UInt2)
{
@@ -3590,8 +3590,8 @@ void ChFi3d_ComputesIntPC (const ChFiDS_FaceInterference& Fi1,
//=======================================================================
void ChFi3d_ComputesIntPC (const ChFiDS_FaceInterference& Fi1,
const ChFiDS_FaceInterference& Fi2,
const Handle(GeomAdaptor_HSurface)& HS1,
const Handle(GeomAdaptor_HSurface)& HS2,
const Handle(GeomAdaptor_Surface)& HS1,
const Handle(GeomAdaptor_Surface)& HS2,
Standard_Real& UInt1,
Standard_Real& UInt2,
gp_Pnt& P)
@@ -3610,13 +3610,13 @@ void ChFi3d_ComputesIntPC (const ChFiDS_FaceInterference& Fi1,
// recalculation of the extremums
Standard_Real delt1 =
Min(0.1,0.05*(Fi1.LastParameter() - Fi1.FirstParameter()));
Handle(Geom2dAdaptor_HCurve) hc2d1 =
new Geom2dAdaptor_HCurve(Fi1.PCurveOnSurf(),UInt1-delt1,UInt1+delt1);
Handle(Geom2dAdaptor_Curve) hc2d1 =
new Geom2dAdaptor_Curve(Fi1.PCurveOnSurf(),UInt1-delt1,UInt1+delt1);
Adaptor3d_CurveOnSurface cons1(hc2d1,HS1);
Standard_Real delt2 =
Min(0.1,0.05*(Fi2.LastParameter() - Fi2.FirstParameter()));
Handle(Geom2dAdaptor_HCurve) hc2d2 =
new Geom2dAdaptor_HCurve(Fi2.PCurveOnSurf(),UInt2-delt2,UInt2+delt2);
Handle(Geom2dAdaptor_Curve) hc2d2 =
new Geom2dAdaptor_Curve(Fi2.PCurveOnSurf(),UInt2-delt2,UInt2+delt2);
Adaptor3d_CurveOnSurface cons2(hc2d2,HS2);
Extrema_LocateExtCC ext(cons1,cons2,UInt1,UInt2);
if(ext.IsDone()) {
@@ -3639,7 +3639,7 @@ void ChFi3d_ComputesIntPC (const ChFiDS_FaceInterference& Fi1,
// SurfData Fd1 and trims it to allow the intersection computation
//=======================================================================
Handle(GeomAdaptor_HSurface) ChFi3d_BoundSurf(TopOpeBRepDS_DataStructure& DStr,
Handle(GeomAdaptor_Surface) ChFi3d_BoundSurf(TopOpeBRepDS_DataStructure& DStr,
const Handle(ChFiDS_SurfData)& Fd1,
const Standard_Integer& IFaCo1,
const Standard_Integer& IFaArc1)
@@ -3649,8 +3649,8 @@ Handle(GeomAdaptor_HSurface) ChFi3d_BoundSurf(TopOpeBRepDS_DataStructure& DSt
// They are preserver here as an option in case it will be necessary to set
// more restrictive limits (with intersection points as additional argument).
Handle(GeomAdaptor_HSurface) HS1 = new GeomAdaptor_HSurface();
GeomAdaptor_Surface& S1 = HS1->ChangeSurface();
Handle(GeomAdaptor_Surface) HS1 = new GeomAdaptor_Surface();
GeomAdaptor_Surface& S1 = *HS1;
S1.Load(DStr.Surface(Fd1->Surf()).Surface());
if ((IFaCo1 == 0)||(IFaArc1 == 0))
@@ -3917,7 +3917,7 @@ static Standard_Boolean GoodExt(const Handle(Geom_Curve)& C,
//purpose :
//=======================================================================
Standard_EXPORT
void ChFi3d_PerformElSpine(Handle(ChFiDS_HElSpine)& HES,
void ChFi3d_PerformElSpine(Handle(ChFiDS_ElSpine)& HES,
Handle(ChFiDS_Spine)& Spine,
const GeomAbs_Shape continuity,
const Standard_Real tol,
@@ -3937,7 +3937,7 @@ void ChFi3d_PerformElSpine(Handle(ChFiDS_HElSpine)& HES,
TopoDS_Edge E, Eold;
TopoDS_Vertex V;
//
ChFiDS_ElSpine& ES = HES->ChangeCurve();
ChFiDS_ElSpine& ES = *HES;
WF = ES.FirstParameter();
WL = ES.LastParameter();
Wrefdeb = WF;

76
src/ChFi3d/ChFi3d_Builder_0.hxx
View File

@@ -26,7 +26,7 @@
#include <ChFiDS_Stripe.hxx>
#include <ChFiDS_SurfData.hxx>
#include <ChFiDS_Spine.hxx>
#include <ChFiDS_HElSpine.hxx>
#include <ChFiDS_ElSpine.hxx>
#include <ChFiDS_CommonPoint.hxx>
#include <ChFiDS_Regularities.hxx>
#include <ChFiDS_FaceInterference.hxx>
@@ -51,12 +51,12 @@
#include <Geom_Circle.hxx>
#include <GeomAdaptor_Curve.hxx>
#include <GeomAdaptor_Surface.hxx>
#include <GeomAdaptor_HSurface.hxx>
#include <GeomAdaptor_Surface.hxx>
#include <BRepAdaptor_Surface.hxx>
#include <BRepAdaptor_HSurface.hxx>
#include <Adaptor3d_HCurve.hxx>
#include <Adaptor3d_HCurveOnSurface.hxx>
#include <Adaptor3d_HSurface.hxx>
#include <BRepAdaptor_Surface.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_CurveOnSurface.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Extrema_LocateExtCC.hxx>
#include <Extrema_POnCurv.hxx>
#include <Bnd_Box.hxx>
@@ -101,7 +101,7 @@ void ChFi3d_EnlargeBox(const Handle(Geom_Curve)& C,
Bnd_Box& box1,
Bnd_Box& box2);
void ChFi3d_EnlargeBox(const Handle(Adaptor3d_HSurface)& S,
void ChFi3d_EnlargeBox(const Handle(Adaptor3d_Surface)& S,
const Handle(Geom2d_Curve)& PC,
const Standard_Real wd,
const Standard_Real wf,
@@ -152,8 +152,8 @@ void ChFi3d_BoundSrf(GeomAdaptor_Surface& S,
const Standard_Real vmax,
const Standard_Boolean checknaturalbounds = Standard_True);
Standard_Boolean ChFi3d_InterPlaneEdge (const Handle(Adaptor3d_HSurface)& Plan,
const Handle(Adaptor3d_HCurve)& C,
Standard_Boolean ChFi3d_InterPlaneEdge (const Handle(Adaptor3d_Surface)& Plan,
const Handle(Adaptor3d_Curve)& C,
Standard_Real& W,
const Standard_Boolean Sens,
const Standard_Real tolc);
@@ -183,7 +183,7 @@ Handle(Geom_BezierCurve) ChFi3d_Spine(const gp_Pnt& pd,
const Standard_Real R);
Handle(GeomFill_Boundary) ChFi3d_mkbound
(const Handle(Adaptor3d_HSurface)& Fac,
(const Handle(Adaptor3d_Surface)& Fac,
Handle(Geom2d_Curve)& curv,
const Standard_Integer sens1,
const gp_Pnt2d& pfac1,
@@ -195,7 +195,7 @@ Handle(GeomFill_Boundary) ChFi3d_mkbound
const Standard_Real ta);
Handle(GeomFill_Boundary) ChFi3d_mkbound
(const Handle(Adaptor3d_HSurface)& Surf,
(const Handle(Adaptor3d_Surface)& Surf,
Handle(Geom2d_Curve)& curv,
const Standard_Integer sens1,
const gp_Pnt2d& p1,
@@ -215,7 +215,7 @@ Handle(GeomFill_Boundary) ChFi3d_mkbound
const Standard_Boolean isfreeboundary = Standard_False);
Handle(GeomFill_Boundary) ChFi3d_mkbound
(const Handle(Adaptor3d_HSurface)& HS,
(const Handle(Adaptor3d_Surface)& HS,
const gp_Pnt2d& p1,
const gp_Pnt2d& p2,
const Standard_Real t3d,
@@ -223,14 +223,14 @@ Handle(GeomFill_Boundary) ChFi3d_mkbound
const Standard_Boolean isfreeboundary = Standard_False);
Handle(GeomFill_Boundary) ChFi3d_mkbound
(const Handle(Adaptor3d_HSurface)& HS,
(const Handle(Adaptor3d_Surface)& HS,
const Handle(Geom2d_Curve)& curv,
const Standard_Real t3d,
const Standard_Real ta,
const Standard_Boolean isfreeboundary = Standard_False);
Handle(GeomFill_Boundary) ChFi3d_mkbound
(const Handle(Adaptor3d_HSurface)& Fac,
(const Handle(Adaptor3d_Surface)& Fac,
Handle(Geom2d_Curve)& curv,
const gp_Pnt2d& p1,
const gp_Pnt2d& p2,
@@ -252,7 +252,7 @@ Handle(Geom2d_Curve) ChFi3d_BuildPCurve
const Standard_Boolean redresse = Standard_True);
Handle(Geom2d_Curve) ChFi3d_BuildPCurve
(const Handle(Adaptor3d_HSurface)& Surf,
(const Handle(Adaptor3d_Surface)& Surf,
const gp_Pnt2d& p1,
const gp_Vec& v1,
const gp_Pnt2d& p2,
@@ -260,7 +260,7 @@ Handle(Geom2d_Curve) ChFi3d_BuildPCurve
const Standard_Boolean redresse = Standard_False);
Handle(Geom2d_Curve) ChFi3d_BuildPCurve
(const Handle(Adaptor3d_HSurface)& Surf,
(const Handle(Adaptor3d_Surface)& Surf,
const gp_Pnt2d& p1,
const gp_Vec2d& v1,
const gp_Pnt2d& p2,
@@ -268,15 +268,15 @@ Handle(Geom2d_Curve) ChFi3d_BuildPCurve
const Standard_Boolean redresse = Standard_False);
Standard_Boolean ChFi3d_CheckSameParameter
(const Handle(Adaptor3d_HCurve)& C3d,
(const Handle(Adaptor3d_Curve)& C3d,
Handle(Geom2d_Curve)& Pcurv,
const Handle(Adaptor3d_HSurface)& S,
const Handle(Adaptor3d_Surface)& S,
const Standard_Real tol3d,
Standard_Real& tolreached);
Standard_Boolean ChFi3d_SameParameter(const Handle(Adaptor3d_HCurve)& C3d,
Standard_Boolean ChFi3d_SameParameter(const Handle(Adaptor3d_Curve)& C3d,
Handle(Geom2d_Curve)& Pcurv,
const Handle(Adaptor3d_HSurface)& S,
const Handle(Adaptor3d_Surface)& S,
const Standard_Real tol3d,
Standard_Real& tolreached);
@@ -299,11 +299,11 @@ void ChFi3d_ComputePCurv(const Handle(Geom_Curve)& C3d,
Standard_Real& tolreached,
const Standard_Boolean reverse = Standard_False);
void ChFi3d_ComputePCurv(const Handle(Adaptor3d_HCurve)& C3d,
void ChFi3d_ComputePCurv(const Handle(Adaptor3d_Curve)& C3d,
const gp_Pnt2d& UV1,
const gp_Pnt2d& UV2,
Handle(Geom2d_Curve)& Pcurv,
const Handle(Adaptor3d_HSurface)& S,
const Handle(Adaptor3d_Surface)& S,
const Standard_Real Pardeb,
const Standard_Real Parfin,
const Standard_Real tol3d,
@@ -349,8 +349,8 @@ Standard_Boolean ChFi3d_IsInFront(TopOpeBRepDS_DataStructure& DStr,
const Standard_Boolean Check2dDistance = Standard_False,
const Standard_Boolean enlarge = Standard_False);
void ChFi3d_ProjectPCurv(const Handle(Adaptor3d_HCurve)& HCg,
const Handle(Adaptor3d_HSurface)& HSg,
void ChFi3d_ProjectPCurv(const Handle(Adaptor3d_Curve)& HCg,
const Handle(Adaptor3d_Surface)& HSg,
Handle(Geom2d_Curve)& Pcurv,
const Standard_Real tol3d,
Standard_Real& tolreached) ;
@@ -430,11 +430,11 @@ TopoDS_Edge ChFi3d_EdgeFromV1(const TopoDS_Vertex& V1,
const Handle(ChFiDS_Stripe)& CD,
Standard_Integer& sens);
Standard_Real ChFi3d_ConvTol2dToTol3d(const Handle(Adaptor3d_HSurface)& S,
Standard_Real ChFi3d_ConvTol2dToTol3d(const Handle(Adaptor3d_Surface)& S,
const Standard_Real tol2d);
Standard_Boolean ChFi3d_ComputeCurves(const Handle(Adaptor3d_HSurface)& S1,
const Handle(Adaptor3d_HSurface)& S2,
Standard_Boolean ChFi3d_ComputeCurves(const Handle(Adaptor3d_Surface)& S1,
const Handle(Adaptor3d_Surface)& S2,
const TColStd_Array1OfReal& Pardeb,
const TColStd_Array1OfReal& Parfin,
Handle(Geom_Curve)& C3d,
@@ -446,27 +446,27 @@ Standard_Boolean ChFi3d_ComputeCurves(const Handle(Adaptor3d_HSurface)& S1,
const Standard_Boolean wholeCurv
= Standard_True);
Standard_Boolean ChFi3d_IntCS(const Handle(Adaptor3d_HSurface)& S,
const Handle(Adaptor3d_HCurve)& C,
Standard_Boolean ChFi3d_IntCS(const Handle(Adaptor3d_Surface)& S,
const Handle(Adaptor3d_Curve)& C,
gp_Pnt2d& p2dS,
Standard_Real& wc);
void ChFi3d_ComputesIntPC (const ChFiDS_FaceInterference& Fi1,
const ChFiDS_FaceInterference& Fi2,
const Handle(GeomAdaptor_HSurface)& HS1,
const Handle(GeomAdaptor_HSurface)& HS2,
const Handle(GeomAdaptor_Surface)& HS1,
const Handle(GeomAdaptor_Surface)& HS2,
Standard_Real& UInt1,
Standard_Real& UInt2);
void ChFi3d_ComputesIntPC (const ChFiDS_FaceInterference& Fi1,
const ChFiDS_FaceInterference& Fi2,
const Handle(GeomAdaptor_HSurface)& HS1,
const Handle(GeomAdaptor_HSurface)& HS2,
const Handle(GeomAdaptor_Surface)& HS1,
const Handle(GeomAdaptor_Surface)& HS2,
Standard_Real& UInt1,
Standard_Real& UInt2,
gp_Pnt& P);
Handle(GeomAdaptor_HSurface) ChFi3d_BoundSurf(TopOpeBRepDS_DataStructure& DStr,
Handle(GeomAdaptor_Surface) ChFi3d_BoundSurf(TopOpeBRepDS_DataStructure& DStr,
const Handle(ChFiDS_SurfData)& Fd1,
const Standard_Integer& IFaCo1,
const Standard_Integer& IFaArc1);
@@ -502,14 +502,14 @@ void ChFi3d_TrimCurve(const Handle(Geom_Curve)& gc,
const gp_Pnt& LastP,
Handle(Geom_TrimmedCurve)& gtc);
Standard_EXPORT void ChFi3d_PerformElSpine(Handle(ChFiDS_HElSpine)& HES,
Standard_EXPORT void ChFi3d_PerformElSpine(Handle(ChFiDS_ElSpine)& HES,
Handle(ChFiDS_Spine)& Spine,
const GeomAbs_Shape continuity,
const Standard_Real tol,
const Standard_Boolean IsOffset = Standard_False);
TopoDS_Face ChFi3d_EnlargeFace(const Handle(ChFiDS_Spine)& Spine,
const Handle(BRepAdaptor_HSurface)& HS,
const Handle(BRepAdaptor_Surface)& HS,
const Standard_Real Tol );
@@ -523,9 +523,9 @@ void ChFi3d_cherche_element( const TopoDS_Vertex & V,
TopoDS_Edge & E ,
TopoDS_Vertex & Vtx );
Standard_Real ChFi3d_EvalTolReached(const Handle(Adaptor3d_HSurface)& S1,
Standard_Real ChFi3d_EvalTolReached(const Handle(Adaptor3d_Surface)& S1,
const Handle(Geom2d_Curve)& pc1,
const Handle(Adaptor3d_HSurface)& S2,
const Handle(Adaptor3d_Surface)& S2,
const Handle(Geom2d_Curve)& pc2,
const Handle(Geom_Curve)& C);

27
src/ChFi3d/ChFi3d_Builder_1.cxx
View File

@@ -15,8 +15,8 @@
// commercial license or contractual agreement.
#include <Adaptor2d_HCurve2d.hxx>
#include <Adaptor3d_HSurface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor3d_TopolTool.hxx>
#include <AppBlend_Approx.hxx>
#include <Blend_CurvPointFuncInv.hxx>
@@ -28,8 +28,7 @@
#include <Blend_SurfRstFunction.hxx>
#include <BRep_Tool.hxx>
#include <BRepAdaptor_Curve.hxx>
#include <BRepAdaptor_HCurve2d.hxx>
#include <BRepAdaptor_HSurface.hxx>
#include <BRepAdaptor_Curve2d.hxx>
#include <BRepAdaptor_Surface.hxx>
#include <BRepBlend_Line.hxx>
#include <BRepLProp_SLProps.hxx>
@@ -41,7 +40,7 @@
#include <ChFiDS_ErrorStatus.hxx>
#include <ChFiDS_FilSpine.hxx>
#include <ChFiDS_HData.hxx>
#include <ChFiDS_HElSpine.hxx>
#include <ChFiDS_ElSpine.hxx>
#include <ChFiDS_ListIteratorOfListOfStripe.hxx>
#include <ChFiDS_ListIteratorOfRegularities.hxx>
#include <ChFiDS_Regul.hxx>
@@ -627,15 +626,15 @@ Standard_Boolean ChFi3d_Builder::FaceTangency(const TopoDS_Edge& E0,
//=======================================================================
static Standard_Boolean TangentExtremity(const TopoDS_Vertex& V,
const TopoDS_Edge& E,
const Handle(BRepAdaptor_HSurface)& hs1,
const Handle(BRepAdaptor_HSurface)& hs2,
const Handle(BRepAdaptor_Surface)& hs1,
const Handle(BRepAdaptor_Surface)& hs2,
// const Standard_Real t3d,
const Standard_Real tang)
{
TopoDS_Face f1 = hs1->ChangeSurface().Face();
TopoDS_Face f1 = hs1->Face();
TopAbs_Orientation O1 = f1.Orientation();
f1.Orientation(TopAbs_FORWARD);
TopoDS_Face f2 = hs2->ChangeSurface().Face();
TopoDS_Face f2 = hs2->Face();
TopAbs_Orientation O2 = f2.Orientation();
f2.Orientation(TopAbs_FORWARD);
TopoDS_Edge e1 = E, e2 = E;
@@ -649,7 +648,7 @@ static Standard_Boolean TangentExtremity(const TopoDS_Vertex& V,
gp_Vec n1, n2;// gp_Pnt pt1,pt2;
Handle(Geom2d_Curve) pc1 = BRep_Tool::CurveOnSurface(e1,f1,f,l);
pc1->Value(p1).Coord(u,v);
BRepLProp_SLProps theProp1(hs1->ChangeSurface(), u, v, 1, Eps);
BRepLProp_SLProps theProp1 (*hs1, u, v, 1, Eps);
if (theProp1.IsNormalDefined()) {
n1.SetXYZ(theProp1.Normal().XYZ());
if (O1 == TopAbs_REVERSED) n1.Reverse();
@@ -659,7 +658,7 @@ static Standard_Boolean TangentExtremity(const TopoDS_Vertex& V,
Handle(Geom2d_Curve) pc2 = BRep_Tool::CurveOnSurface(e2,f2,f,l);
pc2->Value(p2).Coord(u,v);
BRepLProp_SLProps theProp2(hs2->ChangeSurface(), u, v, 1, Eps);
BRepLProp_SLProps theProp2 (*hs2, u, v, 1, Eps);
if (theProp2.IsNormalDefined()) {
n2.SetXYZ(theProp2.Normal().XYZ());
if(O2 == TopAbs_REVERSED) n2.Reverse();
@@ -681,8 +680,8 @@ static Standard_Boolean TangentOnVertex(const TopoDS_Vertex& V,
TopoDS_Face ff1,ff2;
ChFi3d_conexfaces(E,ff1,ff2,EFMap);
if(ff1.IsNull() || ff2.IsNull()) return 0;
Handle(BRepAdaptor_HSurface) S1 = new (BRepAdaptor_HSurface)(ff1);
Handle(BRepAdaptor_HSurface) S2 = new (BRepAdaptor_HSurface)(ff2);
Handle(BRepAdaptor_Surface) S1 = new (BRepAdaptor_Surface)(ff1);
Handle(BRepAdaptor_Surface) S2 = new (BRepAdaptor_Surface)(ff2);
return TangentExtremity(V, E, S1, S2, tang);
}
@@ -702,7 +701,7 @@ void ChFi3d_Builder::PerformExtremity (const Handle(ChFiDS_Spine)& Spine)
TopoDS_Vertex V;
ChFiDS_State sst;
Standard_Integer iedge;
Handle(BRepAdaptor_HSurface) hs1,hs2;
Handle(BRepAdaptor_Surface) hs1,hs2;
if(ii == 1){
sst = Spine->FirstStatus();
iedge = 1;

383
src/ChFi3d/ChFi3d_Builder_2.cxx
View File

@@ -15,8 +15,8 @@
// commercial license or contractual agreement.
#include <Adaptor2d_HCurve2d.hxx>
#include <Adaptor3d_HSurface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor3d_TopolTool.hxx>
#include <AppBlend_Approx.hxx>
#include <Blend_CurvPointFuncInv.hxx>
@@ -28,9 +28,7 @@
#include <Blend_SurfRstFunction.hxx>
#include <BRep_Tool.hxx>
#include <BRepAdaptor_Curve.hxx>
#include <BRepAdaptor_HCurve.hxx>
#include <BRepAdaptor_HCurve2d.hxx>
#include <BRepAdaptor_HSurface.hxx>
#include <BRepAdaptor_Curve2d.hxx>
#include <BRepAdaptor_Surface.hxx>
#include <BRepBlend_Line.hxx>
#include <BRepLib_MakeFace.hxx>
@@ -48,7 +46,7 @@
#include <ChFiDS_FaceInterference.hxx>
#include <ChFiDS_FilSpine.hxx>
#include <ChFiDS_HData.hxx>
#include <ChFiDS_HElSpine.hxx>
#include <ChFiDS_ElSpine.hxx>
#include <ChFiDS_ListIteratorOfListOfHElSpine.hxx>
#include <ChFiDS_ListOfHElSpine.hxx>
#include <ChFiDS_SequenceOfSurfData.hxx>
@@ -68,8 +66,8 @@
#include <Geom_Line.hxx>
#include <Geom_Plane.hxx>
#include <Geom_Surface.hxx>
#include <GeomAdaptor_HCurve.hxx>
#include <GeomAdaptor_HSurface.hxx>
#include <GeomAdaptor_Curve.hxx>
#include <GeomAdaptor_Surface.hxx>
#include <GeomAdaptor_Surface.hxx>
#include <GeomAPI_ProjectPointOnCurve.hxx>
#include <gp_Pln.hxx>
@@ -129,7 +127,7 @@ extern void ChFi3d_ResultChron(OSD_Chronometer & ch, Standard_Real& time);
//====================================================================
static void ChFi3d_CoupeParPlan (const ChFiDS_CommonPoint & compoint1,
const ChFiDS_CommonPoint & compoint2,
Handle(GeomAdaptor_HSurface)& HConge,
Handle(GeomAdaptor_Surface)& HConge,
const gp_Pnt2d & UV1,
const gp_Pnt2d & UV2,
const Standard_Real tol3d,
@@ -160,7 +158,7 @@ static void ChFi3d_CoupeParPlan (const ChFiDS_CommonPoint & compoint1,
Standard_Real scal;
scal=Abs(nor.Dot(tgt2));
if (scal<0.01) {
Handle(GeomAdaptor_HSurface) HPlan=new GeomAdaptor_HSurface(Plan);
Handle(GeomAdaptor_Surface) HPlan=new GeomAdaptor_Surface(Plan);
Handle(Geom2d_Curve) C2dint2;
TColStd_Array1OfReal Pdeb(1,4),Pfin(1,4);
GeomAdaptor_Surface AS(Plan);
@@ -212,9 +210,9 @@ static Standard_Boolean SortieTangente(const ChFiDS_CommonPoint& CP,
//=======================================================================
static Standard_Boolean BonVoisin(const gp_Pnt& Point,
Handle(BRepAdaptor_HSurface)& HS,
Handle(BRepAdaptor_Surface)& HS,
TopoDS_Face& F,
Handle(GeomAdaptor_HSurface)& plane,
Handle(GeomAdaptor_Surface)& plane,
const TopoDS_Edge& cured,
Standard_Real& XDep,
Standard_Real& YDep,
@@ -225,7 +223,7 @@ static Standard_Boolean BonVoisin(const gp_Pnt& Point,
Standard_Real winter, Uf, Ul;
gp_Pnt papp = HS->Value(XDep, YDep);
Standard_Real dist = RealLast();
Handle(BRepAdaptor_HCurve) hc = new BRepAdaptor_HCurve();
Handle(BRepAdaptor_Curve) hc = new BRepAdaptor_Curve();
Handle(Geom2d_Curve) PC;
Standard_Boolean found = 0;
@@ -233,8 +231,8 @@ static Standard_Boolean BonVoisin(const gp_Pnt& Point,
for(Ex.Init(F,TopAbs_EDGE); Ex.More(); Ex.Next()){
const TopoDS_Edge& ecur = TopoDS::Edge(Ex.Current());
if(!ecur.IsSame(cured)){
hc->ChangeCurve().Initialize(ecur);
Standard_Real tolc = hc->ChangeCurve().Resolution(tolesp);
hc->Initialize(ecur);
Standard_Real tolc = hc->Resolution(tolesp);
if(ChFi3d_InterPlaneEdge(plane,hc,winter,1,tolc)){
gp_Pnt np = hc->Value(winter);
Standard_Real ndist = np.SquareDistance(papp);
@@ -257,7 +255,7 @@ static Standard_Boolean BonVoisin(const gp_Pnt& Point,
TopoDS_Edge newe = ecur;
newe.Orientation(TopAbs_FORWARD);
dist = ndist;
HS->ChangeSurface().Initialize(ff);
HS->Initialize(ff);
if(isclosed && !isreallyclosed){
TopoDS_Face fff = ff;
fff.Orientation(TopAbs_FORWARD);
@@ -586,15 +584,15 @@ CallPerformSurf(Handle(ChFiDS_Stripe)& Stripe,
const Standard_Boolean Simul,
ChFiDS_SequenceOfSurfData& SeqSD,
Handle(ChFiDS_SurfData)& SD,
const Handle(ChFiDS_HElSpine)& HGuide,
const Handle(ChFiDS_ElSpine)& HGuide,
const Handle(ChFiDS_Spine)& Spine,
const Handle(BRepAdaptor_HSurface)& HS1,
const Handle(BRepAdaptor_HSurface)& HS3,
const Handle(BRepAdaptor_Surface)& HS1,
const Handle(BRepAdaptor_Surface)& HS3,
const gp_Pnt2d& pp1,
const gp_Pnt2d& pp3,
const Handle(Adaptor3d_TopolTool)& It1,
const Handle(BRepAdaptor_HSurface)& HS2,
const Handle(BRepAdaptor_HSurface)& HS4,
const Handle(BRepAdaptor_Surface)& HS2,
const Handle(BRepAdaptor_Surface)& HS4,
const gp_Pnt2d& pp2,
const gp_Pnt2d& pp4,
const Handle(Adaptor3d_TopolTool)& It2,
@@ -611,22 +609,22 @@ CallPerformSurf(Handle(ChFiDS_Stripe)& Stripe,
math_Vector& Soldep,
Standard_Integer& intf,
Standard_Integer& intl,
Handle(BRepAdaptor_HSurface)& Surf1,
Handle(BRepAdaptor_HSurface)& Surf2)
Handle(BRepAdaptor_Surface)& Surf1,
Handle(BRepAdaptor_Surface)& Surf2)
{
#ifdef OCCT_DEBUG
OSD_Chronometer ch1;
#endif
Handle(BRepAdaptor_HSurface) HSon1, HSon2;
Handle(BRepAdaptor_Surface) HSon1, HSon2;
HSon1 = HS1;
HSon2 = HS2;
// Definition of the domain of path It1, It2
It1->Initialize((const Handle(Adaptor3d_HSurface)&)HSon1);
It2->Initialize((const Handle(Adaptor3d_HSurface)&)HSon2);
It1->Initialize((const Handle(Adaptor3d_Surface)&)HSon1);
It2->Initialize((const Handle(Adaptor3d_Surface)&)HSon2);
TopAbs_Orientation Or1 = HS1->ChangeSurface().Face().Orientation();
TopAbs_Orientation Or2 = HS2->ChangeSurface().Face().Orientation();
TopAbs_Orientation Or1 = HS1->Face().Orientation();
TopAbs_Orientation Or2 = HS2->Face().Orientation();
Standard_Integer Choix =
ChFi3d::NextSide(Or1,Or2,
Stripe->OrientationOnFace1(),
@@ -664,15 +662,15 @@ CallPerformSurf(Handle(ChFiDS_Stripe)& Stripe,
Standard_Boolean reprise = Standard_False;
if (! HS3.IsNull()) {
HSon1 = HS3;
It1->Initialize((const Handle(Adaptor3d_HSurface)&)HS3);
Or1 = HS3->ChangeSurface().Face().Orientation();
It1->Initialize((const Handle(Adaptor3d_Surface)&)HS3);
Or1 = HS3->Face().Orientation();
Soldep(1) = pp3.X(); Soldep(2) = pp3.Y();
reprise = Standard_True;
}
else if (! HS4.IsNull()) {
HSon2 = HS4;
It2->Initialize((const Handle(Adaptor3d_HSurface)&)HS4);
Or2 = HS4->ChangeSurface().Face().Orientation();
It2->Initialize((const Handle(Adaptor3d_Surface)&)HS4);
Or2 = HS4->Face().Orientation();
Soldep(3) = pp4.X(); Soldep(4) = pp4.Y();
reprise = Standard_True;
}
@@ -751,13 +749,13 @@ Standard_Boolean ChFi3d_Builder::StripeOrientations
void ChFi3d_Builder::ConexFaces (const Handle(ChFiDS_Spine)& Spine,
const Standard_Integer IEdge,
Handle(BRepAdaptor_HSurface)& HS1,
Handle(BRepAdaptor_HSurface)& HS2) const
Handle(BRepAdaptor_Surface)& HS1,
Handle(BRepAdaptor_Surface)& HS2) const
{
if(HS1.IsNull()) HS1 = new BRepAdaptor_HSurface ();
if(HS2.IsNull()) HS2 = new BRepAdaptor_HSurface ();
BRepAdaptor_Surface& Sb1 = HS1->ChangeSurface();
BRepAdaptor_Surface& Sb2 = HS2->ChangeSurface();
if(HS1.IsNull()) HS1 = new BRepAdaptor_Surface ();
if(HS2.IsNull()) HS2 = new BRepAdaptor_Surface ();
BRepAdaptor_Surface& Sb1 = *HS1;
BRepAdaptor_Surface& Sb2 = *HS2;
TopoDS_Face ff1,ff2;
TopoDS_Edge anEdge = Spine->Edges(IEdge);
@@ -781,9 +779,9 @@ void ChFi3d_Builder::ConexFaces (const Handle(ChFiDS_Spine)& Spine,
//=======================================================================
void ChFi3d_Builder::StartSol(const Handle(ChFiDS_Stripe)& Stripe,
const Handle(ChFiDS_HElSpine)& HGuide,
Handle(BRepAdaptor_HSurface)& HS1,
Handle(BRepAdaptor_HSurface)& HS2,
const Handle(ChFiDS_ElSpine)& HGuide,
Handle(BRepAdaptor_Surface)& HS1,
Handle(BRepAdaptor_Surface)& HS2,
Handle(BRepTopAdaptor_TopolTool)& I1,
Handle(BRepTopAdaptor_TopolTool)& I2,
gp_Pnt2d& P1,
@@ -791,7 +789,7 @@ void ChFi3d_Builder::StartSol(const Handle(ChFiDS_Stripe)& Stripe,
Standard_Real& First) const
{
Handle(ChFiDS_Spine)& Spine = Stripe->ChangeSpine();
ChFiDS_ElSpine& els = HGuide->ChangeCurve();
ChFiDS_ElSpine& els = *HGuide;
Standard_Integer nbed = Spine->NbEdges();
Standard_Integer nbessaimax = 3*nbed;
if (nbessaimax < 10) nbessaimax = 10;
@@ -830,8 +828,8 @@ void ChFi3d_Builder::StartSol(const Handle(ChFiDS_Stripe)& Stripe,
cured = Spine->Edges(iedge);
TolE = BRep_Tool::Tolerance(cured);
ConexFaces(Spine,iedge,HS1,HS2);
f1 = HS1->ChangeSurface().Face();
f2 = HS2->ChangeSurface().Face();
f1 = HS1->Face();
f2 = HS2->Face();
Or1 = f1.Orientation();
Or2 = f2.Orientation();
Choix = ChFi3d::NextSide(Or1,Or2,
@@ -847,7 +845,7 @@ void ChFi3d_Builder::StartSol(const Handle(ChFiDS_Stripe)& Stripe,
f1forward.Orientation(TopAbs_FORWARD);
f2forward.Orientation(TopAbs_FORWARD);
PC = BRep_Tool::CurveOnSurface(cured,f1forward,Uf,Ul);
I1->Initialize((const Handle(Adaptor3d_HSurface)&)HS1);
I1->Initialize((const Handle(Adaptor3d_Surface)&)HS1);
PC->D1(woned, P1, derive);
// There are ponts on the border, and internal points are found
if (derive.Magnitude() > Precision::PConfusion()) {
@@ -871,7 +869,7 @@ void ChFi3d_Builder::StartSol(const Handle(ChFiDS_Stripe)& Stripe,
if(f1.IsSame(f2)) cured.Orientation(TopAbs_REVERSED);
PC = BRep_Tool::CurveOnSurface(cured,f2forward,Uf,Ul);
P2 = PC->Value(woned);
const Handle(Adaptor3d_HSurface)& HSon2 = HS2; // to avoid ambiguity
const Handle(Adaptor3d_Surface)& HSon2 = HS2; // to avoid ambiguity
I2->Initialize(HSon2);
SolDep(1) = P1.X(); SolDep(2) = P1.Y();
@@ -897,8 +895,8 @@ void ChFi3d_Builder::StartSol(const Handle(ChFiDS_Stripe)& Stripe,
iedge = Spine->Index(w);
cured = Spine->Edges(iedge);
ConexFaces(Spine,iedge,HS1,HS2);
f1 = HS1->ChangeSurface().Face();
f2 = HS2->ChangeSurface().Face();
f1 = HS1->Face();
f2 = HS2->Face();
Or1 = f1.Orientation();
Or2 = f2.Orientation();
Choix = ChFi3d::NextSide(Or1,Or2,
@@ -914,8 +912,8 @@ void ChFi3d_Builder::StartSol(const Handle(ChFiDS_Stripe)& Stripe,
P1 = PC->Value(woned);
PC = BRep_Tool::CurveOnSurface(cured,f2forward,Uf,Ul);
P2 = PC->Value(woned);
const Handle(Adaptor3d_HSurface)& HSon1 = HS1; // to avoid ambiguity
const Handle(Adaptor3d_HSurface)& HSon2 = HS2; // to avoid ambiguity
const Handle(Adaptor3d_Surface)& HSon1 = HS1; // to avoid ambiguity
const Handle(Adaptor3d_Surface)& HSon2 = HS2; // to avoid ambiguity
I1->Initialize(HSon1);
I2->Initialize(HSon2);
SolDep(1) = P1.X(); SolDep(2) = P1.Y();
@@ -932,7 +930,7 @@ void ChFi3d_Builder::StartSol(const Handle(ChFiDS_Stripe)& Stripe,
gp_Vec V;
HGuide->D1(w,P,V);
Handle(Geom_Plane) pl = new Geom_Plane(P,V);
Handle(GeomAdaptor_HSurface) plane = new GeomAdaptor_HSurface(pl);
Handle(GeomAdaptor_Surface) plane = new GeomAdaptor_Surface(pl);
Standard_Boolean bonvoisin = 1, found = 0;
Standard_Integer NbChangement;
@@ -947,16 +945,16 @@ void ChFi3d_Builder::StartSol(const Handle(ChFiDS_Stripe)& Stripe,
SolDep(3),SolDep(4), myEFMap, tolesp);
}
if(bonvoisin){
f1 = HS1->ChangeSurface().Face();
f2 = HS2->ChangeSurface().Face();
f1 = HS1->Face();
f2 = HS2->Face();
Or1 = f1.Orientation();
Or2 = f2.Orientation();
Choix = ChFi3d::NextSide(Or1,Or2,
Stripe->OrientationOnFace1(),
Stripe->OrientationOnFace2(),
RC);
const Handle(Adaptor3d_HSurface)& HSon1new = HS1; // to avoid ambiguity
const Handle(Adaptor3d_HSurface)& HSon2new = HS2; // to avoid ambiguity
const Handle(Adaptor3d_Surface)& HSon1new = HS1; // to avoid ambiguity
const Handle(Adaptor3d_Surface)& HSon2new = HS2; // to avoid ambiguity
I1->Initialize(HSon1new);
I2->Initialize(HSon2new);
if(PerformFirstSection(Spine,HGuide,Choix,HS1,HS2,
@@ -981,7 +979,7 @@ void ChFi3d_Builder::StartSol(const Handle(ChFiDS_Stripe)& Stripe,
//=======================================================================
static void ChFi3d_BuildPlane (TopOpeBRepDS_DataStructure& DStr,
Handle(BRepAdaptor_HSurface)& HS,
Handle(BRepAdaptor_Surface)& HS,
gp_Pnt2d& pons,
const Handle(ChFiDS_SurfData)& SD,
const Standard_Boolean isfirst,
@@ -997,14 +995,14 @@ static void ChFi3d_BuildPlane (TopOpeBRepDS_DataStructure& DStr,
Hc = BRep_Tool::CurveOnSurface
(SD->Vertex(isfirst,ons).Arc(),F,u,v);
Hc->Value(SD->Vertex(isfirst,ons).ParameterOnArc()).Coord(u,v);
BRepLProp_SLProps theProp(HS->ChangeSurface(), u, v, 1, 1.e-12);
BRepLProp_SLProps theProp (*HS, u, v, 1, 1.e-12);
if (theProp.IsNormalDefined()) {
P = theProp.Value();
Handle(Geom_Plane) Pln = new Geom_Plane(P, theProp.Normal());
TopoDS_Face NewF = BRepLib_MakeFace(Pln, Precision::Confusion());
NewF.Orientation(F.Orientation());
pons.SetCoord(0.,0.);
HS->ChangeSurface().Initialize(NewF);
HS->Initialize(NewF);
return; // everything is good !
}
}
@@ -1029,20 +1027,20 @@ static void ChFi3d_BuildPlane (TopOpeBRepDS_DataStructure& DStr,
Standard_Boolean
ChFi3d_Builder::StartSol(const Handle(ChFiDS_Spine)& Spine,
Handle(BRepAdaptor_HSurface)& HS, // New face
Handle(BRepAdaptor_Surface)& HS, // New face
gp_Pnt2d& pons,// " Localization
Handle(BRepAdaptor_HCurve2d)& HC, // Representation of the obstacle
Handle(BRepAdaptor_Curve2d)& HC, // Representation of the obstacle
Standard_Real& W,
const Handle(ChFiDS_SurfData)& SD,
const Standard_Boolean isfirst,
const Standard_Integer ons,
Handle(BRepAdaptor_HSurface)& HSref, // The other representation
Handle(BRepAdaptor_HCurve2d)& HCref, // of the obstacle
Handle(BRepAdaptor_Surface)& HSref, // The other representation
Handle(BRepAdaptor_Curve2d)& HCref, // of the obstacle
Standard_Boolean& RecP,
Standard_Boolean& RecS,
Standard_Boolean& RecRst,
Standard_Boolean& c1obstacle,
Handle(BRepAdaptor_HSurface)& HSBis, // Face of support
Handle(BRepAdaptor_Surface)& HSBis, // Face of support
gp_Pnt2d& PBis, // and its point
const Standard_Boolean decroch,
const TopoDS_Vertex& Vref) const
@@ -1055,7 +1053,7 @@ ChFi3d_Builder::StartSol(const Handle(ChFiDS_Spine)& Spine,
Standard_Real Uf,Ul;
TopoDS_Face F = TopoDS::Face(DStr.Shape(SD->Index(ons)));
if(!HSref.IsNull()) Fref = HSref->ChangeSurface().Face();
if(!HSref.IsNull()) Fref = HSref->Face();
const ChFiDS_CommonPoint& CP = SD->Vertex(isfirst,ons);
HSBis.Nullify();
@@ -1075,7 +1073,7 @@ ChFi3d_Builder::StartSol(const Handle(ChFiDS_Spine)& Spine,
else isExtend = (tns-ts > 100*tolesp);
if (isExtend && !CP.Point().IsEqual(CPbis.Point(), 0) ) {
// the state is preserved and False is returned (extension by the expected plane).
HS->ChangeSurface().Initialize(F);
HS->Initialize(F);
pc = SD->Interference(ons).PCurveOnFace();
// The 2nd point is given by its trace on the support surface
RecS = Standard_False;
@@ -1089,7 +1087,7 @@ ChFi3d_Builder::StartSol(const Handle(ChFiDS_Spine)& Spine,
//The edge is changed, the parameter is updated and
//eventually the support face and(or) the reference face.
TopoDS_Vertex VCP = CP.Vertex();
TopoDS_Edge EHC = HC->ChangeCurve2d().Edge();
TopoDS_Edge EHC = HC->Edge();
//One starts by searching in Fref another edge referencing VCP.
TopExp_Explorer ex1,ex2;
TopoDS_Edge newedge, edgereg;
@@ -1146,7 +1144,7 @@ ChFi3d_Builder::StartSol(const Handle(ChFiDS_Spine)& Spine,
else if(!edgereg.IsNull()){
// the reference edge and face are changed.
Fref = facereg;
HSref->ChangeSurface().Initialize(Fref);
HSref->Initialize(Fref);
for(ex1.Init(facereg,TopAbs_EDGE); ex1.More() && newedge.IsNull(); ex1.Next()){
const TopoDS_Edge& cured = TopoDS::Edge(ex1.Current());
if(!cured.IsSame(edgereg)){
@@ -1173,9 +1171,9 @@ ChFi3d_Builder::StartSol(const Handle(ChFiDS_Spine)& Spine,
throw Standard_Failure("StartSol : chain is not possible, new obstacle not found");
}
else{
HS->ChangeSurface().Initialize(Fv);
HS->Initialize(Fv);
W = BRep_Tool::Parameter(VCP,newedge);
HCref->ChangeCurve2d().Initialize(newedge,Fref);
HCref->Initialize(newedge,Fref);
TopoDS_Face newface = Fv;
newface.Orientation(TopAbs_FORWARD);
TopExp_Explorer ex;
@@ -1185,7 +1183,7 @@ ChFi3d_Builder::StartSol(const Handle(ChFiDS_Spine)& Spine,
break;
}
}
HC->ChangeCurve2d().Initialize(newedge,Fv);
HC->Initialize(newedge,Fv);
pons = HC->Value(W);
}
RecP = c1obstacle = 1;
@@ -1204,7 +1202,7 @@ ChFi3d_Builder::StartSol(const Handle(ChFiDS_Spine)& Spine,
if (CP.IsOnArc()){
const TopoDS_Edge& E = CP.Arc();
if(decroch){
HS->ChangeSurface().Initialize(Fref);
HS->Initialize(Fref);
W = CP.ParameterOnArc();
pc = BRep_Tool::CurveOnSurface(E,Fref,Uf,Ul);
pons = pc->Value(W);
@@ -1212,7 +1210,7 @@ ChFi3d_Builder::StartSol(const Handle(ChFiDS_Spine)& Spine,
return 1;
}
if (SearchFace(Spine,CP,F,Fv)){
HS->ChangeSurface().Initialize(Fv);
HS->Initialize(Fv);
RecS = 1;
if (CP.IsVertex()) {
// One goes directly by the Vertex
@@ -1222,9 +1220,9 @@ ChFi3d_Builder::StartSol(const Handle(ChFiDS_Spine)& Spine,
Nb = SearchFaceOnV(CP, F, myVEMap, myEFMap, Fv, aux);
pons = BRep_Tool::Parameters(CP.Vertex(), Fv);
HS->ChangeSurface().Initialize(Fv);
HS->Initialize(Fv);
if (Nb >=2) {
HSBis = new (BRepAdaptor_HSurface)(aux);
HSBis = new (BRepAdaptor_Surface)(aux);
PBis = BRep_Tool::Parameters(CP.Vertex(), aux);
}
return 1;
@@ -1244,7 +1242,7 @@ ChFi3d_Builder::StartSol(const Handle(ChFiDS_Spine)& Spine,
// In cas of Tangent output, the current face becomes the support face
if (SortieTangente(CP, F, SD, ons, 0.1)) {
pc = BRep_Tool::CurveOnSurface(CP.Arc(),F,Uf,Ul);
HSBis = new (BRepAdaptor_HSurface)(F);
HSBis = new (BRepAdaptor_Surface)(F);
PBis = pc->Value(CP.ParameterOnArc());
}
@@ -1272,10 +1270,10 @@ ChFi3d_Builder::StartSol(const Handle(ChFiDS_Spine)& Spine,
}
}
if(c1obstacle){
HS->ChangeSurface().Initialize(Fv);
HSref->ChangeSurface().Initialize(F);
HS->Initialize(Fv);
HSref->Initialize(F);
W = CP.ParameterOnArc();
HC = new BRepAdaptor_HCurve2d();
HC = new BRepAdaptor_Curve2d();
TopoDS_Edge newedge;
TopoDS_Face newface = Fv;
newface.Orientation(TopAbs_FORWARD);
@@ -1286,15 +1284,15 @@ ChFi3d_Builder::StartSol(const Handle(ChFiDS_Spine)& Spine,
break;
}
}
HC->ChangeCurve2d().Initialize(newedge,Fv);
HC->Initialize(newedge,Fv);
pons = HC->Value(W);
HCref->ChangeCurve2d().Initialize(E,F);
HCref->Initialize(E,F);
if(CP.IsVertex()) RecP = 1;
else RecRst = 1;
return 1;
}
else{
HS->ChangeSurface().Initialize(F);
HS->Initialize(F);
W = CP.ParameterOnArc();
pc = BRep_Tool::CurveOnSurface(E,F,Uf,Ul);
pons = pc->Value(W);
@@ -1302,7 +1300,7 @@ ChFi3d_Builder::StartSol(const Handle(ChFiDS_Spine)& Spine,
}
}
else{ // there is no neighbor face, the state is preserved and False is returned.
HS->ChangeSurface().Initialize(F);
HS->Initialize(F);
W = CP.ParameterOnArc();
pc = BRep_Tool::CurveOnSurface(E,F,Uf,Ul);
pons = pc->Value(W);
@@ -1310,7 +1308,7 @@ ChFi3d_Builder::StartSol(const Handle(ChFiDS_Spine)& Spine,
}
}
else{
HS->ChangeSurface().Initialize(F);
HS->Initialize(F);
const ChFiDS_FaceInterference& FI = SD->Interference(ons);
if(FI.PCurveOnFace().IsNull()) pons = SD->Get2dPoints(isfirst,ons);
else pons = FI.PCurveOnFace()->Value(FI.Parameter(isfirst));
@@ -1628,7 +1626,7 @@ static void ChFi3d_MakeExtremities(Handle(ChFiDS_Stripe)& Stripe,
Value(SDdeb->InterferenceOnS2().FirstParameter());
// The intersection of the fillet by a plane is attempted
Handle(GeomAdaptor_HSurface) HConge=ChFi3d_BoundSurf(DStr,SDdeb,1,2);
Handle(GeomAdaptor_Surface) HConge=ChFi3d_BoundSurf(DStr,SDdeb,1,2);
ChFi3d_CoupeParPlan(cpdeb1,cpdeb2,HConge,UV1,UV2,
tol3d,tol2d,C3d,Stripe->ChangeFirstPCurve(),tolreached,
Pardeb,Parfin,plane);
@@ -1690,7 +1688,7 @@ static void ChFi3d_MakeExtremities(Handle(ChFiDS_Stripe)& Stripe,
Value(SDfin->InterferenceOnS2().LastParameter());
// Intersection of the fillet by a plane is attempted
Handle(GeomAdaptor_HSurface) HConge=ChFi3d_BoundSurf(DStr,SDfin,1,2);
Handle(GeomAdaptor_Surface) HConge=ChFi3d_BoundSurf(DStr,SDfin,1,2);
ChFi3d_CoupeParPlan(cpfin1,cpfin2,HConge,UV1,UV2,
tol3d,tol2d,C3d,Stripe->ChangeLastPCurve(),tolreached,
Pardeb,Parfin,plane);
@@ -1855,7 +1853,7 @@ static void InsertBefore (Handle(ChFiDS_Stripe)& Stripe,
//=======================================================================
void ChFi3d_Builder::PerformSetOfSurfOnElSpine
(const Handle(ChFiDS_HElSpine)& HGuide,
(const Handle(ChFiDS_ElSpine)& HGuide,
Handle(ChFiDS_Stripe)& Stripe,
Handle(BRepTopAdaptor_TopolTool)& It1,
Handle(BRepTopAdaptor_TopolTool)& It2,
@@ -1870,9 +1868,9 @@ void ChFi3d_Builder::PerformSetOfSurfOnElSpine
//gp_Vec d1gui;
//( HGuide->Curve() ).D1(HGuide->FirstParameter(),ptgui,d1gui);
ChFiDS_ElSpine& Guide = HGuide->ChangeCurve();
ChFiDS_ElSpine& Guide = *HGuide;
Handle(ChFiDS_HElSpine) OffsetHGuide;
Handle(ChFiDS_ElSpine) OffsetHGuide;
Handle(ChFiDS_Spine)& Spine = Stripe->ChangeSpine();
if (Spine->Mode() == ChFiDS_ConstThroatWithPenetrationChamfer)
{
@@ -1881,7 +1879,7 @@ void ChFi3d_Builder::PerformSetOfSurfOnElSpine
ChFiDS_ListIteratorOfListOfHElSpine ILES(ll), ILES_offset(ll_offset);
for ( ; ILES.More(); ILES.Next(),ILES_offset.Next())
{
const Handle(ChFiDS_HElSpine)& aHElSpine = ILES.Value();
const Handle(ChFiDS_ElSpine)& aHElSpine = ILES.Value();
if (aHElSpine == HGuide)
OffsetHGuide = ILES_offset.Value();
}
@@ -1899,8 +1897,8 @@ void ChFi3d_Builder::PerformSetOfSurfOnElSpine
Guide.LastParameter (wl+prab*(wl-wf));
if (!OffsetHGuide.IsNull())
{
OffsetHGuide->ChangeCurve().FirstParameter(wf-prab*(wl-wf));
OffsetHGuide->ChangeCurve().LastParameter (wl+prab*(wl-wf));
OffsetHGuide->FirstParameter(wf-prab*(wl-wf));
OffsetHGuide->LastParameter (wl+prab*(wl-wf));
}
}
//Handle(ChFiDS_Spine)& Spine = Stripe->ChangeSpine();
@@ -1914,14 +1912,14 @@ void ChFi3d_Builder::PerformSetOfSurfOnElSpine
Handle(ChFiDS_SurfData) raf = Guide.Next();
RemoveSD(Stripe,ref,raf);
Handle(BRepAdaptor_HSurface) HS1 = new BRepAdaptor_HSurface();
Handle(BRepAdaptor_HSurface) HS2 = new BRepAdaptor_HSurface();
Handle(BRepAdaptor_HSurface) HS3, HS4;
Handle(BRepAdaptor_HSurface) HSref1 = new BRepAdaptor_HSurface();
Handle(BRepAdaptor_HSurface) HSref2 = new BRepAdaptor_HSurface();
Handle(BRepAdaptor_HCurve2d) HC1,HC2;
Handle(BRepAdaptor_HCurve2d) HCref1 = new BRepAdaptor_HCurve2d();
Handle(BRepAdaptor_HCurve2d) HCref2 = new BRepAdaptor_HCurve2d();
Handle(BRepAdaptor_Surface) HS1 = new BRepAdaptor_Surface();
Handle(BRepAdaptor_Surface) HS2 = new BRepAdaptor_Surface();
Handle(BRepAdaptor_Surface) HS3, HS4;
Handle(BRepAdaptor_Surface) HSref1 = new BRepAdaptor_Surface();
Handle(BRepAdaptor_Surface) HSref2 = new BRepAdaptor_Surface();
Handle(BRepAdaptor_Curve2d) HC1,HC2;
Handle(BRepAdaptor_Curve2d) HCref1 = new BRepAdaptor_Curve2d();
Handle(BRepAdaptor_Curve2d) HCref2 = new BRepAdaptor_Curve2d();
Standard_Boolean decroch1 = Standard_False, decroch2 = Standard_False;
Standard_Boolean RecP1 = Standard_False, RecS1 = Standard_False, RecRst1 = Standard_False, obstacleon1 = Standard_False;
Standard_Boolean RecP2 = Standard_False, RecS2 = Standard_False, RecRst2 = Standard_False, obstacleon2 = Standard_False;
@@ -1963,10 +1961,10 @@ void ChFi3d_Builder::PerformSetOfSurfOnElSpine
Guide.LastParameter (First * 1.1);//Extension to help rsnld.
if (!OffsetHGuide.IsNull())
{
OffsetHGuide->ChangeCurve().SaveFirstParameter();
OffsetHGuide->ChangeCurve().FirstParameter(Last);
OffsetHGuide->ChangeCurve().SaveLastParameter();
OffsetHGuide->ChangeCurve().LastParameter (First * 1.1);//Extension to help rsnld.
OffsetHGuide->SaveFirstParameter();
OffsetHGuide->FirstParameter(Last);
OffsetHGuide->SaveLastParameter();
OffsetHGuide->LastParameter (First * 1.1);//Extension to help rsnld.
}
}
}
@@ -2007,13 +2005,13 @@ void ChFi3d_Builder::PerformSetOfSurfOnElSpine
{
Guide.FirstParameter(wf);
if (!OffsetHGuide.IsNull())
OffsetHGuide->ChangeCurve().FirstParameter(wf);
OffsetHGuide->FirstParameter(wf);
}
else
{
Guide.LastParameter(wl);
if (!OffsetHGuide.IsNull())
OffsetHGuide->ChangeCurve().LastParameter(wl);
OffsetHGuide->LastParameter(wl);
}
}
}
@@ -2053,7 +2051,7 @@ void ChFi3d_Builder::PerformSetOfSurfOnElSpine
intf = 4;
Guide.FirstParameter(wfsav);
if (!OffsetHGuide.IsNull())
OffsetHGuide->ChangeCurve().FirstParameter(wfsav);
OffsetHGuide->FirstParameter(wfsav);
}
if(wl - lastedlastp > -tolesp){
if(Spine->LastStatus() == ChFiDS_OnSame) intl = 2;
@@ -2063,7 +2061,7 @@ void ChFi3d_Builder::PerformSetOfSurfOnElSpine
intl = 4;
Guide.LastParameter(wlsav);
if (!OffsetHGuide.IsNull())
OffsetHGuide->ChangeCurve().LastParameter(wlsav);
OffsetHGuide->LastParameter(wlsav);
}
}
if(intf && !forward) Vref = Spine->FirstVertex();
@@ -2099,21 +2097,21 @@ void ChFi3d_Builder::PerformSetOfSurfOnElSpine
{
Guide.FirstParameter(wf);
if (!OffsetHGuide.IsNull())
OffsetHGuide->ChangeCurve().FirstParameter(wf);
OffsetHGuide->FirstParameter(wf);
}
else
{
Guide.LastParameter(wl);
if (!OffsetHGuide.IsNull())
OffsetHGuide->ChangeCurve().LastParameter(wl);
OffsetHGuide->LastParameter(wl);
}
}
else throw Standard_Failure("PerformSetOfSurfOnElSpine : Chaining is impossible.");
}
// Definition of the domain of patch It1, It2
const Handle(Adaptor3d_HSurface)& HSon1 = HS1; // to avoid ambiguity
const Handle(Adaptor3d_HSurface)& HSon2 = HS2; // to avoid ambiguity
const Handle(Adaptor3d_Surface)& HSon1 = HS1; // to avoid ambiguity
const Handle(Adaptor3d_Surface)& HSon2 = HS2; // to avoid ambiguity
It1->Initialize(HSon1);
It2->Initialize(HSon2);
@@ -2123,8 +2121,8 @@ void ChFi3d_Builder::PerformSetOfSurfOnElSpine
SeqSD.Append(SD);
if(obstacleon1 && obstacleon2){
TopAbs_Orientation Or1 = HSref1->ChangeSurface().Face().Orientation();
TopAbs_Orientation Or2 = HSref2->ChangeSurface().Face().Orientation();
TopAbs_Orientation Or1 = HSref1->Face().Orientation();
TopAbs_Orientation Or2 = HSref2->Face().Orientation();
Standard_Integer Choix = ChFi3d::NextSide(Or1,Or2,
Stripe->OrientationOnFace1(),
Stripe->OrientationOnFace2(),
@@ -2156,12 +2154,12 @@ void ChFi3d_Builder::PerformSetOfSurfOnElSpine
ChFi3d_ResultChron(ch1,t_performsurf); //result perf for PerformSurf
#endif
}
SD->ChangeIndexOfS1(DStr.AddShape(HS1->ChangeSurface().Face()));
SD->ChangeIndexOfS2(DStr.AddShape(HS2->ChangeSurface().Face()));
SD->ChangeIndexOfS1(DStr.AddShape(HS1->Face()));
SD->ChangeIndexOfS2(DStr.AddShape(HS2->Face()));
}
else if (obstacleon1){
TopAbs_Orientation Or1 = HSref1->ChangeSurface().Face().Orientation();
TopAbs_Orientation Or2 = HS2->ChangeSurface().Face().Orientation();
TopAbs_Orientation Or1 = HSref1->Face().Orientation();
TopAbs_Orientation Or2 = HS2->Face().Orientation();
Standard_Integer Choix = ChFi3d::NextSide(Or1,Or2,
Stripe->OrientationOnFace1(),
Stripe->OrientationOnFace2(),
@@ -2185,13 +2183,13 @@ void ChFi3d_Builder::PerformSetOfSurfOnElSpine
ChFi3d_ResultChron(ch1,t_performsurf);//result perf for PerformSurf
#endif
}
SD->ChangeIndexOfS1(DStr.AddShape(HS1->ChangeSurface().Face()));
SD->ChangeIndexOfS2(DStr.AddShape(HS2->ChangeSurface().Face()));
SD->ChangeIndexOfS1(DStr.AddShape(HS1->Face()));
SD->ChangeIndexOfS2(DStr.AddShape(HS2->Face()));
decroch2 = 0;
}
else if (obstacleon2){
TopAbs_Orientation Or1 = HS1->ChangeSurface().Face().Orientation();
TopAbs_Orientation Or2 = HSref2->ChangeSurface().Face().Orientation();
TopAbs_Orientation Or1 = HS1->Face().Orientation();
TopAbs_Orientation Or2 = HSref2->Face().Orientation();
Standard_Integer Choix = ChFi3d::NextSide(Or1,Or2,
Stripe->OrientationOnFace1(),
Stripe->OrientationOnFace2(),
@@ -2213,8 +2211,8 @@ void ChFi3d_Builder::PerformSetOfSurfOnElSpine
ChFi3d_ResultChron(ch1,t_performsurf); //result perf for PerformSurf
#endif
}
SD->ChangeIndexOfS1(DStr.AddShape(HS1->ChangeSurface().Face()));
SD->ChangeIndexOfS2(DStr.AddShape(HS2->ChangeSurface().Face()));
SD->ChangeIndexOfS1(DStr.AddShape(HS1->Face()));
SD->ChangeIndexOfS2(DStr.AddShape(HS2->Face()));
decroch1 = 0;
}
else{
@@ -2251,10 +2249,10 @@ void ChFi3d_Builder::PerformSetOfSurfOnElSpine
if(forward) {
for (ii=1; ii<=SeqSD.Length(); ii++) {
SD = SeqSD(ii);
SD->ChangeIndexOfS1(DStr.AddShape(HS1->ChangeSurface().Face()));
if(obstacleon1) SD->SetIndexOfC1(DStr.AddShape(HC1->ChangeCurve2d().Edge()));
SD->ChangeIndexOfS2(DStr.AddShape(HS2->ChangeSurface().Face()));
if(obstacleon2) SD->SetIndexOfC2(DStr.AddShape(HC2->ChangeCurve2d().Edge()));
SD->ChangeIndexOfS1(DStr.AddShape(HS1->Face()));
if(obstacleon1) SD->SetIndexOfC1(DStr.AddShape(HC1->Edge()));
SD->ChangeIndexOfS2(DStr.AddShape(HS2->Face()));
if(obstacleon2) SD->SetIndexOfC2(DStr.AddShape(HC2->Edge()));
InsertAfter (Stripe, refbis, SD);
refbis = SD;
}
@@ -2262,10 +2260,10 @@ void ChFi3d_Builder::PerformSetOfSurfOnElSpine
else {
for (ii=SeqSD.Length(); ii>=1; ii--) {
SD = SeqSD(ii);
SD->ChangeIndexOfS1(DStr.AddShape(HS1->ChangeSurface().Face()));
if(obstacleon1) SD->SetIndexOfC1(DStr.AddShape(HC1->ChangeCurve2d().Edge()));
SD->ChangeIndexOfS2(DStr.AddShape(HS2->ChangeSurface().Face()));
if(obstacleon2) SD->SetIndexOfC2(DStr.AddShape(HC2->ChangeCurve2d().Edge()));
SD->ChangeIndexOfS1(DStr.AddShape(HS1->Face()));
if(obstacleon1) SD->SetIndexOfC1(DStr.AddShape(HC1->Edge()));
SD->ChangeIndexOfS2(DStr.AddShape(HS2->Face()));
if(obstacleon2) SD->SetIndexOfC2(DStr.AddShape(HC2->Edge()));
InsertBefore(Stripe,refbis,SD);
refbis = SD;
}
@@ -2343,8 +2341,8 @@ void ChFi3d_Builder::PerformSetOfSurfOnElSpine
Guide.LastParameter (wlsav);
if (!OffsetHGuide.IsNull())
{
OffsetHGuide->ChangeCurve().FirstParameter(wfsav);
OffsetHGuide->ChangeCurve().LastParameter (wlsav);
OffsetHGuide->FirstParameter(wfsav);
OffsetHGuide->LastParameter (wlsav);
}
}
@@ -2360,7 +2358,7 @@ void ChFi3d_Builder::PerformSetOfKPart(Handle(ChFiDS_Stripe)& Stripe,
{
TopOpeBRepDS_DataStructure& DStr = myDS->ChangeDS();
Handle(ChFiDS_Spine)& Spine = Stripe->ChangeSpine();
Handle(BRepAdaptor_HSurface) HS1,HS2;
Handle(BRepAdaptor_Surface) HS1,HS2;
TopAbs_Orientation Or1,Or2,RefOr1,RefOr2;
Standard_Integer RefChoix;
@@ -2384,13 +2382,13 @@ void ChFi3d_Builder::PerformSetOfKPart(Handle(ChFiDS_Stripe)& Stripe,
Standard_Boolean intf = Standard_False, intl = Standard_False;
ChFiDS_ElSpine anElSpine, anOffsetElSpine;
Handle(ChFiDS_HElSpine) CurrentHE = new ChFiDS_HElSpine(anElSpine);
Handle(ChFiDS_HElSpine) CurrentOffsetHE = new ChFiDS_HElSpine(anOffsetElSpine);
Handle(ChFiDS_ElSpine) CurrentHE = new ChFiDS_ElSpine(anElSpine);
Handle(ChFiDS_ElSpine) CurrentOffsetHE = new ChFiDS_ElSpine(anOffsetElSpine);
Spine->D1(Spine->FirstParameter(),PFirst,TFirst);
CurrentHE->ChangeCurve().FirstParameter(Spine->FirstParameter());
CurrentHE->ChangeCurve().SetFirstPointAndTgt(PFirst,TFirst);
CurrentOffsetHE->ChangeCurve().FirstParameter(Spine->FirstParameter());
CurrentOffsetHE->ChangeCurve().SetFirstPointAndTgt(PFirst,TFirst);
CurrentHE->FirstParameter(Spine->FirstParameter());
CurrentHE->SetFirstPointAndTgt(PFirst,TFirst);
CurrentOffsetHE->FirstParameter(Spine->FirstParameter());
CurrentOffsetHE->SetFirstPointAndTgt(PFirst,TFirst);
Standard_Boolean YaKPart = Standard_False;
Standard_Integer iedgelastkpart = 0;
@@ -2405,14 +2403,14 @@ void ChFi3d_Builder::PerformSetOfKPart(Handle(ChFiDS_Stripe)& Stripe,
ConexFaces(Spine,iedge,HS1,HS2);
if (ChFi3d_KParticular(Spine,iedge,HS1->ChangeSurface(),HS2->ChangeSurface())) {
if (ChFi3d_KParticular (Spine, iedge, *HS1, *HS2)) {
intf = ((iedge == 1) && !Spine->IsPeriodic());
intl = ((iedge == Spine->NbEdges()) && !Spine->IsPeriodic());
Or1 = HS1->ChangeSurface().Face().Orientation();
Or2 = HS2->ChangeSurface().Face().Orientation();
Or1 = HS1->Face().Orientation();
Or2 = HS2->Face().Orientation();
ChFi3d::NextSide(Or1,Or2,RefOr1,RefOr2,RefChoix);
const Handle(Adaptor3d_HSurface)& HSon1 = HS1; // to avoid ambiguity
const Handle(Adaptor3d_HSurface)& HSon2 = HS2; // to avoid ambiguity
const Handle(Adaptor3d_Surface)& HSon1 = HS1; // to avoid ambiguity
const Handle(Adaptor3d_Surface)& HSon2 = HS2; // to avoid ambiguity
It1->Initialize(HSon1);
It2->Initialize(HSon2);
@@ -2495,47 +2493,47 @@ void ChFi3d_Builder::PerformSetOfKPart(Handle(ChFiDS_Stripe)& Stripe,
// start section -> first KPart
// update of extension.
Spine->SetFirstTgt(Min(0.,WFirst));
CurrentHE->ChangeCurve().LastParameter (WFirst);
CurrentHE->ChangeCurve().SetLastPointAndTgt(PFirst,TFirst);
CurrentHE->LastParameter (WFirst);
CurrentHE->SetLastPointAndTgt(PFirst,TFirst);
Spine->AppendElSpine(CurrentHE);
CurrentHE->ChangeCurve().ChangeNext() = LSD.Value(j);
CurrentHE = new ChFiDS_HElSpine();
CurrentHE->ChangeNext() = LSD.Value(j);
CurrentHE = new ChFiDS_ElSpine();
CurrentOffsetHE->ChangeCurve().LastParameter (WFirst);
CurrentOffsetHE->ChangeCurve().SetLastPointAndTgt(PFirst,TFirst);
CurrentOffsetHE->LastParameter (WFirst);
CurrentOffsetHE->SetLastPointAndTgt(PFirst,TFirst);
Spine->AppendOffsetElSpine(CurrentOffsetHE);
CurrentOffsetHE->ChangeCurve().ChangeNext() = LSD.Value(j);
CurrentOffsetHE = new ChFiDS_HElSpine();
CurrentOffsetHE->ChangeNext() = LSD.Value(j);
CurrentOffsetHE = new ChFiDS_ElSpine();
}
CurrentHE->ChangeCurve().FirstParameter(WLast);
CurrentHE->ChangeCurve().SetFirstPointAndTgt(PLast,TLast);
CurrentHE->ChangeCurve().ChangePrevious() = LSD.Value(j);
CurrentOffsetHE->ChangeCurve().FirstParameter(WLast);
CurrentOffsetHE->ChangeCurve().SetFirstPointAndTgt(PLast,TLast);
CurrentOffsetHE->ChangeCurve().ChangePrevious() = LSD.Value(j);
CurrentHE->FirstParameter(WLast);
CurrentHE->SetFirstPointAndTgt(PLast,TLast);
CurrentHE->ChangePrevious() = LSD.Value(j);
CurrentOffsetHE->FirstParameter(WLast);
CurrentOffsetHE->SetFirstPointAndTgt(PLast,TLast);
CurrentOffsetHE->ChangePrevious() = LSD.Value(j);
YaKPart = Standard_True;
}
else {
if (WFirst - CurrentHE->FirstParameter() > tolesp) {
// section between two KPart
CurrentHE->ChangeCurve().LastParameter(WFirst);
CurrentHE->ChangeCurve().SetLastPointAndTgt(PFirst,TFirst);
CurrentHE->LastParameter(WFirst);
CurrentHE->SetLastPointAndTgt(PFirst,TFirst);
Spine->AppendElSpine(CurrentHE);
CurrentHE->ChangeCurve().ChangeNext() = LSD.Value(j);
CurrentHE = new ChFiDS_HElSpine();
CurrentHE->ChangeNext() = LSD.Value(j);
CurrentHE = new ChFiDS_ElSpine();
CurrentOffsetHE->ChangeCurve().LastParameter(WFirst);
CurrentOffsetHE->ChangeCurve().SetLastPointAndTgt(PFirst,TFirst);
CurrentOffsetHE->LastParameter(WFirst);
CurrentOffsetHE->SetLastPointAndTgt(PFirst,TFirst);
Spine->AppendOffsetElSpine(CurrentOffsetHE);
CurrentOffsetHE->ChangeCurve().ChangeNext() = LSD.Value(j);
CurrentOffsetHE = new ChFiDS_HElSpine();
CurrentOffsetHE->ChangeNext() = LSD.Value(j);
CurrentOffsetHE = new ChFiDS_ElSpine();
}
CurrentHE->ChangeCurve().FirstParameter(WLast);
CurrentHE->ChangeCurve().SetFirstPointAndTgt(PLast,TLast);
CurrentHE->ChangeCurve().ChangePrevious() = LSD.Value(j);
CurrentOffsetHE->ChangeCurve().FirstParameter(WLast);
CurrentOffsetHE->ChangeCurve().SetFirstPointAndTgt(PLast,TLast);
CurrentOffsetHE->ChangeCurve().ChangePrevious() = LSD.Value(j);
CurrentHE->FirstParameter(WLast);
CurrentHE->SetFirstPointAndTgt(PLast,TLast);
CurrentHE->ChangePrevious() = LSD.Value(j);
CurrentOffsetHE->FirstParameter(WLast);
CurrentOffsetHE->SetFirstPointAndTgt(PLast,TLast);
CurrentOffsetHE->ChangePrevious() = LSD.Value(j);
}
}
if(!li.IsEmpty()) myEVIMap.Bind(Spine->Edges(iedge),li);
@@ -2548,14 +2546,14 @@ void ChFi3d_Builder::PerformSetOfKPart(Handle(ChFiDS_Stripe)& Stripe,
if(Spine->IsPeriodic()){
if(WEndPeriodic - WLast > tolesp){
CurrentHE->ChangeCurve().LastParameter(WEndPeriodic);
CurrentHE->ChangeCurve().SetLastPointAndTgt(PEndPeriodic,TEndPeriodic);
if(!YaKPart) CurrentHE->ChangeCurve().SetPeriodic(Standard_True);
CurrentHE->LastParameter(WEndPeriodic);
CurrentHE->SetLastPointAndTgt(PEndPeriodic,TEndPeriodic);
if(!YaKPart) CurrentHE->SetPeriodic(Standard_True);
Spine->AppendElSpine(CurrentHE);
CurrentOffsetHE->ChangeCurve().LastParameter(WEndPeriodic);
CurrentOffsetHE->ChangeCurve().SetLastPointAndTgt(PEndPeriodic,TEndPeriodic);
if(!YaKPart) CurrentOffsetHE->ChangeCurve().SetPeriodic(Standard_True);
CurrentOffsetHE->LastParameter(WEndPeriodic);
CurrentOffsetHE->SetLastPointAndTgt(PEndPeriodic,TEndPeriodic);
if(!YaKPart) CurrentOffsetHE->SetPeriodic(Standard_True);
Spine->AppendOffsetElSpine(CurrentOffsetHE);
}
}
@@ -2564,12 +2562,12 @@ void ChFi3d_Builder::PerformSetOfKPart(Handle(ChFiDS_Stripe)& Stripe,
Spine->SetLastTgt(Max(Spine->LastParameter(Spine->NbEdges()),
WLast));
if (Spine->LastParameter() - WLast > tolesp) {
CurrentHE->ChangeCurve().LastParameter(Spine->LastParameter());
CurrentHE->ChangeCurve().SetLastPointAndTgt(PLast,TLast);
CurrentHE->LastParameter(Spine->LastParameter());
CurrentHE->SetLastPointAndTgt(PLast,TLast);
Spine->AppendElSpine(CurrentHE);
CurrentOffsetHE->ChangeCurve().LastParameter(Spine->LastParameter());
CurrentOffsetHE->ChangeCurve().SetLastPointAndTgt(PLast,TLast);
CurrentOffsetHE->LastParameter(Spine->LastParameter());
CurrentOffsetHE->SetLastPointAndTgt(PLast,TLast);
Spine->AppendOffsetElSpine(CurrentOffsetHE);
}
}
@@ -2701,12 +2699,12 @@ void ChFi3d_Builder::PerformSetOfKGen(Handle(ChFiDS_Stripe)& Stripe,
// A contour of filling is constructed
Handle(Geom2d_Curve) PC1 = intf1.PCurveOnFace();
Handle(Geom2d_Curve) PC2 = intf2.PCurveOnFace();
Handle(BRepAdaptor_HSurface) S1 = new BRepAdaptor_HSurface();
Handle(BRepAdaptor_Surface) S1 = new BRepAdaptor_Surface();
TopoDS_Face F1 = TopoDS::Face(DStr.Shape(cursurf1));
S1->ChangeSurface().Initialize(F1);
Handle(BRepAdaptor_HSurface) S2 = new BRepAdaptor_HSurface();
S1->Initialize(F1);
Handle(BRepAdaptor_Surface) S2 = new BRepAdaptor_Surface();
TopoDS_Face F2 = TopoDS::Face(DStr.Shape(cursurf2));
S2->ChangeSurface().Initialize(F2);
S2->Initialize(F2);
Handle(GeomFill_Boundary) Bdeb,Bfin,Bon1,Bon2;
Standard_Boolean pointuon1 = 0, pointuon2 = 0;
if(tw1){
@@ -2951,10 +2949,9 @@ void ChFi3d_Builder::PerformSetOfKGen(Handle(ChFiDS_Stripe)& Stripe,
}
// The connections edge/new faces are updated.
for (ILES.Initialize(ll) ; ILES.More(); ILES.Next()) {
const Handle(ChFiDS_HElSpine)& curhels = ILES.Value();
const ChFiDS_ElSpine& curels = curhels->ChangeCurve();
Standard_Real WF = curels.FirstParameter();
Standard_Real WL = curels.LastParameter();
const Handle(ChFiDS_ElSpine)& curhels = ILES.Value();
Standard_Real WF = curhels->FirstParameter();
Standard_Real WL = curhels->LastParameter();
Standard_Integer IF,IL;
Standard_Real nwf = WF, nwl = WL;
Standard_Real period = 0.;
@@ -3000,11 +2997,11 @@ void ChFi3d_Builder::PerformSetOfKGen(Handle(ChFiDS_Stripe)& Stripe,
if(periodic) wi = ElCLib::InPeriod(wi,WF,WF+period);
gp_Pnt pv = Spine->Value(wi);
#ifdef OCCT_DEBUG
gp_Pnt pelsapp = curels.Value(wi);
gp_Pnt pelsapp = curhels->Value(wi);
Standard_Real distinit = pv.Distance(pelsapp);
std::cout<<"distance psp/papp : "<<distinit<<std::endl;
#endif
Extrema_LocateExtPC ext(pv,curels,wi,1.e-8);
Extrema_LocateExtPC ext(pv,*curhels,wi,1.e-8);
wv(i) = wi;
if(ext.IsDone()){
wv(i) = ext.Point().Parameter();

144
src/ChFi3d/ChFi3d_Builder_6.cxx
View File

@@ -19,8 +19,8 @@
// modified by Edward AGAPOV (eap) Fri Feb 8 2002 (bug occ67 == BUC61052)
// ComputeData(), case where BRepBlend_Walking::Continu() can't get up to Target
#include <Adaptor2d_HCurve2d.hxx>
#include <Adaptor3d_HSurface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor3d_TopolTool.hxx>
#include <AppBlend_Approx.hxx>
#include <Approx_SweepFunction.hxx>
@@ -35,8 +35,6 @@
#include <BRep_Tool.hxx>
#include <BRepAdaptor_Curve.hxx>
#include <BRepAdaptor_Curve2d.hxx>
#include <BRepAdaptor_HCurve2d.hxx>
#include <BRepAdaptor_HSurface.hxx>
#include <BRepAdaptor_Surface.hxx>
#include <BRepBlend_AppFunc.hxx>
#include <BRepBlend_AppFuncRst.hxx>
@@ -59,7 +57,7 @@
#include <ChFi3d_Builder_0.hxx>
#include <ChFiDS_CommonPoint.hxx>
#include <ChFiDS_FaceInterference.hxx>
#include <ChFiDS_HElSpine.hxx>
#include <ChFiDS_ElSpine.hxx>
#include <ChFiDS_Spine.hxx>
#include <ChFiDS_Stripe.hxx>
#include <ChFiDS_SurfData.hxx>
@@ -72,8 +70,8 @@
#include <Geom_BSplineSurface.hxx>
#include <Geom_Curve.hxx>
#include <Geom_Surface.hxx>
#include <GeomAdaptor_HCurve.hxx>
#include <GeomAdaptor_HSurface.hxx>
#include <GeomAdaptor_Curve.hxx>
#include <GeomAdaptor_Surface.hxx>
#include <GeomLib.hxx>
#include <gp_Dir2d.hxx>
#include <gp_Pnt.hxx>
@@ -111,7 +109,7 @@
#include <Draw_Marker3D.hxx>
#include <Draw.hxx>
#include <DrawTrSurf.hxx>
#include <BRepAdaptor_HSurface.hxx>
#include <BRepAdaptor_Surface.hxx>
static Standard_Integer IndexOfConge = 0;
#endif
@@ -425,9 +423,9 @@ static void UpdateLine(Handle(BRepBlend_Line)& Line,
Standard_Boolean ChFi3d_Builder::CompleteData
(Handle(ChFiDS_SurfData)& Data,
const Handle(Geom_Surface)& Surfcoin,
const Handle(Adaptor3d_HSurface)& S1,
const Handle(Adaptor3d_Surface)& S1,
const Handle(Geom2d_Curve)& PC1,
const Handle(Adaptor3d_HSurface)& S2,
const Handle(Adaptor3d_Surface)& S2,
const Handle(Geom2d_Curve)& PC2,
const TopAbs_Orientation Or,
const Standard_Boolean On1,
@@ -469,7 +467,7 @@ Standard_Boolean ChFi3d_Builder::CompleteData
Handle(Geom2d_Curve) c2dtrim;
Standard_Real tolreached = 1.e-5;
if(!PC1.IsNull()){
Handle(GeomAdaptor_HCurve) hcS1 = new GeomAdaptor_HCurve(Crv3d1);
Handle(GeomAdaptor_Curve) hcS1 = new GeomAdaptor_Curve(Crv3d1);
c2dtrim = new Geom2d_TrimmedCurve(PC1,UFirst,ULast);
ChFi3d_SameParameter(hcS1,c2dtrim,S1,tolapp3d,tolreached);
c2dtrim->Value(w).Coord(x,y);
@@ -494,7 +492,7 @@ Standard_Boolean ChFi3d_Builder::CompleteData
PCurveOnSurf = new Geom2d_Line(lfil2);
TopAbs_Orientation tra2 = TopAbs_FORWARD;
if(!PC2.IsNull()){
Handle(GeomAdaptor_HCurve) hcS2 = new GeomAdaptor_HCurve(Crv3d2);
Handle(GeomAdaptor_Curve) hcS2 = new GeomAdaptor_Curve(Crv3d2);
c2dtrim = new Geom2d_TrimmedCurve(PC2,UFirst,ULast);
ChFi3d_SameParameter(hcS2,c2dtrim,S2,tolapp3d,tolreached);
c2dtrim->Value(w).Coord(x,y);
@@ -530,8 +528,8 @@ Standard_Boolean ChFi3d_Builder::CompleteData
(Handle(ChFiDS_SurfData)& Data,
Blend_Function& Func,
Handle(BRepBlend_Line)& lin,
const Handle(Adaptor3d_HSurface)& S1,
const Handle(Adaptor3d_HSurface)& S2,
const Handle(Adaptor3d_Surface)& S1,
const Handle(Adaptor3d_Surface)& S2,
const TopAbs_Orientation Or1,
const Standard_Boolean Gd1,
const Standard_Boolean Gd2,
@@ -572,8 +570,8 @@ Standard_Boolean ChFi3d_Builder::CompleteData
(Handle(ChFiDS_SurfData)& Data,
Blend_SurfRstFunction& Func,
Handle(BRepBlend_Line)& lin,
const Handle(Adaptor3d_HSurface)& S1,
const Handle(Adaptor3d_HSurface)& S2,
const Handle(Adaptor3d_Surface)& S1,
const Handle(Adaptor3d_Surface)& S2,
const TopAbs_Orientation Or,
const Standard_Boolean Reversed)
{
@@ -610,8 +608,8 @@ Standard_Boolean ChFi3d_Builder::CompleteData
(Handle(ChFiDS_SurfData)& Data,
Blend_RstRstFunction& Func,
Handle(BRepBlend_Line)& lin,
const Handle(Adaptor3d_HSurface)& S1,
const Handle(Adaptor3d_HSurface)& S2,
const Handle(Adaptor3d_Surface)& S1,
const Handle(Adaptor3d_Surface)& S2,
const TopAbs_Orientation Or)
{
Handle(BRepBlend_AppFuncRstRst) TheFunc
@@ -646,8 +644,8 @@ Standard_Boolean ChFi3d_Builder::CompleteData
Standard_Boolean ChFi3d_Builder::StoreData(Handle(ChFiDS_SurfData)& Data,
const AppBlend_Approx& approx,
const Handle(BRepBlend_Line)& lin,
const Handle(Adaptor3d_HSurface)& S1,
const Handle(Adaptor3d_HSurface)& S2,
const Handle(Adaptor3d_Surface)& S1,
const Handle(Adaptor3d_Surface)& S2,
const TopAbs_Orientation Or1,
const Standard_Boolean Gd1,
const Standard_Boolean Gd2,
@@ -656,9 +654,9 @@ Standard_Boolean ChFi3d_Builder::StoreData(Handle(ChFiDS_SurfData)& Data,
const Standard_Boolean Reversed)
{
// Small control tools.
static Handle(GeomAdaptor_HCurve) checkcurve;
if(checkcurve.IsNull()) checkcurve = new GeomAdaptor_HCurve();
GeomAdaptor_Curve& chc = checkcurve->ChangeCurve();
static Handle(GeomAdaptor_Curve) checkcurve;
if(checkcurve.IsNull()) checkcurve = new GeomAdaptor_Curve();
GeomAdaptor_Curve& chc = *checkcurve;
Standard_Real tolget3d, tolget2d, tolaux, tolC1, tolcheck;
Standard_Real tolC2 = 0.;
approx.TolReached(tolget3d, tolget2d);
@@ -751,10 +749,10 @@ Standard_Boolean ChFi3d_Builder::StoreData(Handle(ChFiDS_SurfData)& Data,
Surf->Bounds(UFirst,ULast,VFirst,VLast);
BRepAdaptor_Curve2d brc;
BRepAdaptor_Curve CArc;
Handle(BRepAdaptor_HSurface)
BS1 = Handle(BRepAdaptor_HSurface)::DownCast(S1);
Handle(BRepAdaptor_HSurface)
BS2 = Handle(BRepAdaptor_HSurface)::DownCast(S2);
Handle(BRepAdaptor_Surface)
BS1 = Handle(BRepAdaptor_Surface)::DownCast(S1);
Handle(BRepAdaptor_Surface)
BS2 = Handle(BRepAdaptor_Surface)::DownCast(S2);
Geom2dAPI_ProjectPointOnCurve projector;
Standard_Real Uon1 = UFirst, Uon2 = ULast;
@@ -787,7 +785,7 @@ Standard_Boolean ChFi3d_Builder::StoreData(Handle(ChFiDS_SurfData)& Data,
Standard_Real uarc,utg;
if(Gd1){
TopoDS_Face forwfac = BS1->ChangeSurface().Face();
TopoDS_Face forwfac = BS1->Face();
forwfac.Orientation(TopAbs_FORWARD);
brc.Initialize(Data->VertexFirstOnS1().Arc(),forwfac);
ChFiDS_CommonPoint& V = Data->ChangeVertexFirstOnS1();
@@ -799,7 +797,7 @@ Standard_Boolean ChFi3d_Builder::StoreData(Handle(ChFiDS_SurfData)& Data,
}
else pppdeb = VFirst;
if(Gf1){
TopoDS_Face forwfac = BS1->ChangeSurface().Face();
TopoDS_Face forwfac = BS1->Face();
forwfac.Orientation(TopAbs_FORWARD);
ChFiDS_CommonPoint& V = Data->ChangeVertexLastOnS1();
brc.Initialize(V.Arc(),forwfac);
@@ -839,7 +837,7 @@ Standard_Boolean ChFi3d_Builder::StoreData(Handle(ChFiDS_SurfData)& Data,
Standard_Integer Index2OfCurve =
DStr.AddCurve(TopOpeBRepDS_Curve(Crv3d2,tolC2));
if(Gd2){
TopoDS_Face forwfac = BS2->ChangeSurface().Face();
TopoDS_Face forwfac = BS2->Face();
forwfac.Orientation(TopAbs_FORWARD);
brc.Initialize(Data->VertexFirstOnS2().Arc(),forwfac);
ChFiDS_CommonPoint& V = Data->ChangeVertexFirstOnS2();
@@ -851,7 +849,7 @@ Standard_Boolean ChFi3d_Builder::StoreData(Handle(ChFiDS_SurfData)& Data,
}
else pppdeb = VFirst;
if(Gf2){
TopoDS_Face forwfac = BS2->ChangeSurface().Face();
TopoDS_Face forwfac = BS2->Face();
forwfac.Orientation(TopAbs_FORWARD);
brc.Initialize(Data->VertexLastOnS2().Arc(),forwfac);
ChFiDS_CommonPoint& V = Data->ChangeVertexLastOnS2();
@@ -879,7 +877,7 @@ Standard_Boolean ChFi3d_Builder::StoreData(Handle(ChFiDS_SurfData)& Data,
// the orientation of the fillet in relation to the faces is evaluated,
Handle(Adaptor3d_HSurface) Sref = S1;
Handle(Adaptor3d_Surface) Sref = S1;
PCurveOnFace = Fint1.PCurveOnFace();
if(Reversed){ Sref = S2; PCurveOnFace = Fint2.PCurveOnFace(); }
@@ -961,12 +959,12 @@ Standard_Boolean ChFi3d_Builder::StoreData(Handle(ChFiDS_SurfData)& Data,
Standard_Boolean ChFi3d_Builder::ComputeData
(Handle(ChFiDS_SurfData)& Data,
const Handle(ChFiDS_HElSpine)& HGuide,
const Handle(ChFiDS_ElSpine)& HGuide,
Handle(BRepBlend_Line)& Lin,
const Handle(Adaptor3d_HSurface)& S1,
const Handle(Adaptor3d_Surface)& S1,
const Handle(Adaptor3d_TopolTool)& I1,
const Handle(Adaptor3d_HSurface)& S2,
const Handle(Adaptor2d_HCurve2d)& PC2,
const Handle(Adaptor3d_Surface)& S2,
const Handle(Adaptor2d_Curve2d)& PC2,
const Handle(Adaptor3d_TopolTool)& I2,
Standard_Boolean& Decroch,
Blend_SurfRstFunction& Func,
@@ -1089,14 +1087,14 @@ Standard_Boolean ChFi3d_Builder::ComputeData
Standard_Boolean ChFi3d_Builder::ComputeData
(Handle(ChFiDS_SurfData)& Data,
const Handle(ChFiDS_HElSpine)& HGuide,
const Handle(ChFiDS_ElSpine)& HGuide,
Handle(BRepBlend_Line)& Lin,
const Handle(Adaptor3d_HSurface)& S1,
const Handle(Adaptor2d_HCurve2d)& PC1,
const Handle(Adaptor3d_Surface)& S1,
const Handle(Adaptor2d_Curve2d)& PC1,
const Handle(Adaptor3d_TopolTool)& I1,
Standard_Boolean& Decroch1,
const Handle(Adaptor3d_HSurface)& S2,
const Handle(Adaptor2d_HCurve2d)& PC2,
const Handle(Adaptor3d_Surface)& S2,
const Handle(Adaptor2d_Curve2d)& PC2,
const Handle(Adaptor3d_TopolTool)& I2,
Standard_Boolean& Decroch2,
Blend_RstRstFunction& Func,
@@ -1226,12 +1224,12 @@ Standard_Boolean ChFi3d_Builder::ComputeData
Standard_Boolean ChFi3d_Builder::SimulData
(Handle(ChFiDS_SurfData)& /*Data*/,
const Handle(ChFiDS_HElSpine)& HGuide,
const Handle(ChFiDS_ElSpine)& HGuide,
Handle(BRepBlend_Line)& Lin,
const Handle(Adaptor3d_HSurface)& S1,
const Handle(Adaptor3d_Surface)& S1,
const Handle(Adaptor3d_TopolTool)& I1,
const Handle(Adaptor3d_HSurface)& S2,
const Handle(Adaptor2d_HCurve2d)& PC2,
const Handle(Adaptor3d_Surface)& S2,
const Handle(Adaptor2d_Curve2d)& PC2,
const Handle(Adaptor3d_TopolTool)& I2,
Standard_Boolean& Decroch,
Blend_SurfRstFunction& Func,
@@ -1348,14 +1346,14 @@ Standard_Boolean ChFi3d_Builder::SimulData
Standard_Boolean ChFi3d_Builder::SimulData
(Handle(ChFiDS_SurfData)& /*Data*/,
const Handle(ChFiDS_HElSpine)& HGuide,
const Handle(ChFiDS_ElSpine)& HGuide,
Handle(BRepBlend_Line)& Lin,
const Handle(Adaptor3d_HSurface)& S1,
const Handle(Adaptor2d_HCurve2d)& PC1,
const Handle(Adaptor3d_Surface)& S1,
const Handle(Adaptor2d_Curve2d)& PC1,
const Handle(Adaptor3d_TopolTool)& I1,
Standard_Boolean& Decroch1,
const Handle(Adaptor3d_HSurface)& S2,
const Handle(Adaptor2d_HCurve2d)& PC2,
const Handle(Adaptor3d_Surface)& S2,
const Handle(Adaptor2d_Curve2d)& PC2,
const Handle(Adaptor3d_TopolTool)& I2,
Standard_Boolean& Decroch2,
Blend_RstRstFunction& Func,
@@ -1482,12 +1480,12 @@ Standard_Boolean ChFi3d_Builder::SimulData
Standard_Boolean ChFi3d_Builder::ComputeData
(Handle(ChFiDS_SurfData)& Data,
const Handle(ChFiDS_HElSpine)& HGuide,
const Handle(ChFiDS_ElSpine)& HGuide,
const Handle(ChFiDS_Spine)& Spine,
Handle(BRepBlend_Line)& Lin,
const Handle(Adaptor3d_HSurface)& S1,
const Handle(Adaptor3d_Surface)& S1,
const Handle(Adaptor3d_TopolTool)& I1,
const Handle(Adaptor3d_HSurface)& S2,
const Handle(Adaptor3d_Surface)& S2,
const Handle(Adaptor3d_TopolTool)& I2,
Blend_Function& Func,
Blend_FuncInv& FInv,
@@ -1511,7 +1509,7 @@ Standard_Boolean ChFi3d_Builder::ComputeData
const Standard_Boolean RecOnS2)
{
//Get offset guide if exists
Handle(ChFiDS_HElSpine) OffsetHGuide;
Handle(ChFiDS_ElSpine) OffsetHGuide;
if (!Spine.IsNull() &&
Spine->Mode() == ChFiDS_ConstThroatWithPenetrationChamfer)
{
@@ -1520,7 +1518,7 @@ Standard_Boolean ChFi3d_Builder::ComputeData
ChFiDS_ListIteratorOfListOfHElSpine ILES(ll), ILES_offset(ll_offset);
for ( ; ILES.More(); ILES.Next(),ILES_offset.Next())
{
const Handle(ChFiDS_HElSpine)& aHElSpine = ILES.Value();
const Handle(ChFiDS_ElSpine)& aHElSpine = ILES.Value();
if (aHElSpine == HGuide)
OffsetHGuide = ILES_offset.Value();
}
@@ -1533,10 +1531,10 @@ Standard_Boolean ChFi3d_Builder::ComputeData
//The eventual faces are restored to test the jump of edge.
TopoDS_Face F1, F2;
Handle(BRepAdaptor_HSurface) HS = Handle(BRepAdaptor_HSurface)::DownCast(S1);
if(!HS.IsNull()) F1 = HS->ChangeSurface().Face();
HS = Handle(BRepAdaptor_HSurface)::DownCast(S2);
if(!HS.IsNull()) F2 = HS->ChangeSurface().Face();
Handle(BRepAdaptor_Surface) HS = Handle(BRepAdaptor_Surface)::DownCast(S1);
if(!HS.IsNull()) F1 = HS->Face();
HS = Handle(BRepAdaptor_Surface)::DownCast(S2);
if(!HS.IsNull()) F2 = HS->Face();
// Path framing variables
Standard_Real TolGuide=tolguide, TolEsp = tolesp;
@@ -1652,14 +1650,14 @@ Standard_Boolean ChFi3d_Builder::ComputeData
if(HGuide->IsPeriodic() && Inside) {
SpFirst = Lin->Point(1).Parameter();
SpLast = SpFirst + HGuide->Period();
HGuide->ChangeCurve().FirstParameter(SpFirst);
HGuide->ChangeCurve().LastParameter (SpLast );
HGuide->ChangeCurve().SetOrigin(SpFirst);
HGuide->FirstParameter(SpFirst);
HGuide->LastParameter (SpLast );
HGuide->SetOrigin(SpFirst);
if (!OffsetHGuide.IsNull())
{
OffsetHGuide->ChangeCurve().FirstParameter(SpFirst);
OffsetHGuide->ChangeCurve().LastParameter (SpLast );
OffsetHGuide->ChangeCurve().SetOrigin(SpFirst);
OffsetHGuide->FirstParameter(SpFirst);
OffsetHGuide->LastParameter (SpLast );
OffsetHGuide->SetOrigin(SpFirst);
}
}
Standard_Boolean complmnt = Standard_True;
@@ -2119,12 +2117,12 @@ Standard_Boolean ChFi3d_Builder::ComputeData
Standard_Boolean ChFi3d_Builder::SimulData
(Handle(ChFiDS_SurfData)& /*Data*/,
const Handle(ChFiDS_HElSpine)& HGuide,
const Handle(ChFiDS_HElSpine)& AdditionalHGuide,
const Handle(ChFiDS_ElSpine)& HGuide,
const Handle(ChFiDS_ElSpine)& AdditionalHGuide,
Handle(BRepBlend_Line)& Lin,
const Handle(Adaptor3d_HSurface)& S1,
const Handle(Adaptor3d_Surface)& S1,
const Handle(Adaptor3d_TopolTool)& I1,
const Handle(Adaptor3d_HSurface)& S2,
const Handle(Adaptor3d_Surface)& S2,
const Handle(Adaptor3d_TopolTool)& I2,
Blend_Function& Func,
Blend_FuncInv& FInv,
@@ -2201,12 +2199,12 @@ Standard_Boolean ChFi3d_Builder::SimulData
if(HGuide->IsPeriodic()) {
SpFirst = Lin->Point(1).Parameter();
SpLast = SpFirst + HGuide->Period();
HGuide->ChangeCurve().FirstParameter(SpFirst);
HGuide->ChangeCurve().LastParameter (SpLast );
HGuide->FirstParameter(SpFirst);
HGuide->LastParameter (SpLast );
if (!AdditionalHGuide.IsNull())
{
AdditionalHGuide->ChangeCurve().FirstParameter(SpFirst);
AdditionalHGuide->ChangeCurve().LastParameter (SpLast );
AdditionalHGuide->FirstParameter(SpFirst);
AdditionalHGuide->LastParameter (SpLast );
}
}
Standard_Boolean complmnt = Standard_True;

134
src/ChFi3d/ChFi3d_Builder_C1.cxx
View File

@@ -17,10 +17,9 @@
// Modified by skv - Mon Jun 7 18:38:57 2004 OCC5898
// Modified by skv - Thu Aug 21 11:55:58 2008 OCC20222
#include <Adaptor2d_HCurve2d.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_CurveOnSurface.hxx>
#include <Adaptor3d_HCurveOnSurface.hxx>
#include <Adaptor3d_HSurface.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor3d_TopolTool.hxx>
#include <AppBlend_Approx.hxx>
#include <Blend_CurvPointFuncInv.hxx>
@@ -34,9 +33,6 @@
#include <BRep_Tool.hxx>
#include <BRepAdaptor_Curve.hxx>
#include <BRepAdaptor_Curve2d.hxx>
#include <BRepAdaptor_HCurve.hxx>
#include <BRepAdaptor_HCurve2d.hxx>
#include <BRepAdaptor_HSurface.hxx>
#include <BRepAdaptor_Surface.hxx>
#include <BRepAlgo_NormalProjection.hxx>
#include <BRepBlend_Line.hxx>
@@ -50,7 +46,7 @@
#include <ChFiDS_CommonPoint.hxx>
#include <ChFiDS_FaceInterference.hxx>
#include <ChFiDS_HData.hxx>
#include <ChFiDS_HElSpine.hxx>
#include <ChFiDS_ElSpine.hxx>
#include <ChFiDS_ListIteratorOfListOfStripe.hxx>
#include <ChFiDS_Map.hxx>
#include <ChFiDS_SequenceOfSurfData.hxx>
@@ -69,7 +65,7 @@
#include <Geom2d_Curve.hxx>
#include <Geom2d_Line.hxx>
#include <Geom2d_TrimmedCurve.hxx>
#include <Geom2dAdaptor_HCurve.hxx>
#include <Geom2dAdaptor_Curve.hxx>
#include <Geom2dInt_GInter.hxx>
#include <Geom_BezierSurface.hxx>
#include <Geom_BoundedCurve.hxx>
@@ -83,8 +79,8 @@
#include <Geom_Surface.hxx>
#include <Geom_TrimmedCurve.hxx>
#include <GeomAbs_Shape.hxx>
#include <GeomAdaptor_HCurve.hxx>
#include <GeomAdaptor_HSurface.hxx>
#include <GeomAdaptor_Curve.hxx>
#include <GeomAdaptor_Surface.hxx>
#include <GeomAdaptor_Surface.hxx>
#include <GeomAPI_ExtremaCurveCurve.hxx>
#include <GeomInt_IntSS.hxx>
@@ -183,9 +179,9 @@ static Standard_Real recadre(const Standard_Real p,
// parameter in FaceInterference.
//=======================================================================
static Standard_Boolean Update(const Handle(Adaptor3d_HSurface)& fb,
const Handle(Adaptor2d_HCurve2d)& pcfb,
const Handle(Adaptor3d_HSurface)& surf,
static Standard_Boolean Update(const Handle(Adaptor3d_Surface)& fb,
const Handle(Adaptor2d_Curve2d)& pcfb,
const Handle(Adaptor3d_Surface)& surf,
ChFiDS_FaceInterference& fi,
ChFiDS_CommonPoint& cp,
gp_Pnt2d& p2dbout,
@@ -196,7 +192,7 @@ static Standard_Boolean Update(const Handle(Adaptor3d_HSurface)& fb,
{
Adaptor3d_CurveOnSurface c1(pcfb,fb);
Handle(Geom2d_Curve) pc = fi.PCurveOnSurf();
Handle(Geom2dAdaptor_HCurve) hpc = new Geom2dAdaptor_HCurve(pc);
Handle(Geom2dAdaptor_Curve) hpc = new Geom2dAdaptor_Curve(pc);
Adaptor3d_CurveOnSurface c2(hpc,surf);
Extrema_LocateExtCC ext(c1,c2,pared,wop);
if (ext.IsDone()) {
@@ -225,8 +221,8 @@ static Standard_Boolean Update(const Handle(Adaptor3d_HSurface)& fb,
// and <p2dbout>
//=======================================================================
static Standard_Boolean Update(const Handle(Adaptor3d_HSurface)& fb,
const Handle(Adaptor3d_HCurve)& ct,
static Standard_Boolean Update(const Handle(Adaptor3d_Surface)& fb,
const Handle(Adaptor3d_Curve)& ct,
ChFiDS_FaceInterference& fi,
ChFiDS_CommonPoint& cp,
gp_Pnt2d& p2dbout,
@@ -308,8 +304,8 @@ static Standard_Boolean Update(const Handle(Adaptor3d_HSurface)& fb,
// <Vtx> is a corner vertex
//=======================================================================
static Standard_Boolean IntersUpdateOnSame(Handle(GeomAdaptor_HSurface)& HGs,
Handle(BRepAdaptor_HSurface)& HBs,
static Standard_Boolean IntersUpdateOnSame(Handle(GeomAdaptor_Surface)& HGs,
Handle(BRepAdaptor_Surface)& HBs,
const Handle(Geom_Curve)& c3dFI,
const TopoDS_Face& Fop,
const TopoDS_Face& Fprol,
@@ -327,9 +323,9 @@ static Standard_Boolean IntersUpdateOnSame(Handle(GeomAdaptor_HSurface)& HGs,
// extended end or if the end is sharp.
Standard_Real uf = FIop.FirstParameter();
Standard_Real ul = FIop.LastParameter();
Handle(GeomAdaptor_HCurve) Hc3df;
if (c3dFI->IsPeriodic()) Hc3df = new GeomAdaptor_HCurve(c3dFI);
else Hc3df = new GeomAdaptor_HCurve(c3dFI,uf,ul);
Handle(GeomAdaptor_Curve) Hc3df;
if (c3dFI->IsPeriodic()) Hc3df = new GeomAdaptor_Curve(c3dFI);
else Hc3df = new GeomAdaptor_Curve(c3dFI,uf,ul);
if ( Update(HBs,Hc3df,FIop,CPop,FprolUV,isFirst,c3dU) )
return Standard_True;
@@ -338,7 +334,7 @@ static Standard_Boolean IntersUpdateOnSame(Handle(GeomAdaptor_HSurface)& HGs,
return Standard_False;
Handle(Geom2d_Curve) gpcprol = BRep_Tool::CurveOnSurface(Eprol,Fprol,uf,ul);
Handle(Geom2dAdaptor_HCurve) pcprol = new Geom2dAdaptor_HCurve(gpcprol);
Handle(Geom2dAdaptor_Curve) pcprol = new Geom2dAdaptor_Curve(gpcprol);
Standard_Real partemp = BRep_Tool::Parameter(Vtx,Eprol);
return
@@ -352,9 +348,9 @@ static Standard_Boolean IntersUpdateOnSame(Handle(GeomAdaptor_HSurface)& HGs,
// face at end.
//=======================================================================
static Standard_Boolean Update(const Handle(Adaptor3d_HSurface)& face,
const Handle(Adaptor2d_HCurve2d)& edonface,
const Handle(Adaptor3d_HSurface)& surf,
static Standard_Boolean Update(const Handle(Adaptor3d_Surface)& face,
const Handle(Adaptor2d_Curve2d)& edonface,
const Handle(Adaptor3d_Surface)& surf,
ChFiDS_FaceInterference& fi,
ChFiDS_CommonPoint& cp,
const Standard_Boolean isfirst)
@@ -369,7 +365,7 @@ static Standard_Boolean Update(const Handle(Adaptor3d_HSurface)& face,
Standard_Real delta = 0.1 * ( l - f );
f = Max(f-delta,pc->FirstParameter());
l = Min(l+delta,pc->LastParameter());
Handle(Geom2dAdaptor_HCurve) hpc = new Geom2dAdaptor_HCurve(pc,f,l);
Handle(Geom2dAdaptor_Curve) hpc = new Geom2dAdaptor_Curve(pc,f,l);
Adaptor3d_CurveOnSurface c2(hpc,surf);
Extrema_LocateExtCC ext(c1,c2,pared,parltg);
@@ -615,12 +611,12 @@ void ChFi3d_Builder::PerformOneCorner(const Standard_Integer Index,
else Arcspine = spine->Edges(spine->NbEdges());
TopAbs_Orientation OArcprolv = TopAbs_FORWARD, OArcprolop = TopAbs_FORWARD;
Standard_Integer ICurve;
Handle(BRepAdaptor_HSurface) HBs = new BRepAdaptor_HSurface();
Handle(BRepAdaptor_HSurface) HBad = new BRepAdaptor_HSurface();
Handle(BRepAdaptor_HSurface) HBop = new BRepAdaptor_HSurface();
BRepAdaptor_Surface& Bs = HBs->ChangeSurface();
BRepAdaptor_Surface& Bad = HBad->ChangeSurface();
BRepAdaptor_Surface& Bop = HBop->ChangeSurface();
Handle(BRepAdaptor_Surface) HBs = new BRepAdaptor_Surface();
Handle(BRepAdaptor_Surface) HBad = new BRepAdaptor_Surface();
Handle(BRepAdaptor_Surface) HBop = new BRepAdaptor_Surface();
BRepAdaptor_Surface& Bs = *HBs;
BRepAdaptor_Surface& Bad = *HBad;
BRepAdaptor_Surface& Bop = *HBop;
Handle(Geom_Curve) Cc;
Handle(Geom2d_Curve) Pc,Ps;
Standard_Real Ubid,Vbid;//,mu,Mu,mv,Mv;
@@ -757,8 +753,8 @@ void ChFi3d_Builder::PerformOneCorner(const Standard_Integer Index,
//its opposite (point on arc).
Standard_Real wop = Fd->ChangeInterference(IFadArc).Parameter(isfirst);
Handle(Geom_Curve) c3df;
Handle(GeomAdaptor_HSurface)
HGs = new GeomAdaptor_HSurface(DStr.Surface(Fd->Surf()).Surface());
Handle(GeomAdaptor_Surface)
HGs = new GeomAdaptor_Surface(DStr.Surface(Fd->Surf()).Surface());
gp_Pnt2d p2dbout;
if (onsame) {
@@ -769,8 +765,8 @@ void ChFi3d_Builder::PerformOneCorner(const Standard_Integer Index,
inters = IntersUpdateOnSame (HGs,HBs,c3df,Fop,Fv,Arcprol,Vtx,isfirst,10*tolesp, // in
FiopArc,CPopArc,p2dbout,wop); // out
Handle(BRepAdaptor_HCurve2d) pced = new BRepAdaptor_HCurve2d();
pced->ChangeCurve2d().Initialize(CPadArc.Arc(),Fv);
Handle(BRepAdaptor_Curve2d) pced = new BRepAdaptor_Curve2d();
pced->Initialize(CPadArc.Arc(),Fv);
// in the case of degenerated Fi, parameter difference can be even negative (eap, occ293)
if ((FiadArc.LastParameter() - FiadArc.FirstParameter()) > 10*tolesp)
Update(HBs,pced,HGs,FiadArc,CPadArc,isfirst);
@@ -789,10 +785,10 @@ void ChFi3d_Builder::PerformOneCorner(const Standard_Integer Index,
return;
}
Bs.Initialize(Fv);
Handle(BRepAdaptor_HCurve2d) pced = new BRepAdaptor_HCurve2d();
pced->ChangeCurve2d().Initialize(CV1.Arc(),Fv);
Handle(BRepAdaptor_Curve2d) pced = new BRepAdaptor_Curve2d();
pced->Initialize(CV1.Arc(),Fv);
Update(HBs,pced,HGs,Fd->ChangeInterferenceOnS1(),CV1,isfirst);
pced->ChangeCurve2d().Initialize(CV2.Arc(),Fv);
pced->Initialize(CV2.Arc(),Fv);
Update(HBs,pced,HGs,Fd->ChangeInterferenceOnS2(),CV2,isfirst);
}
@@ -1692,12 +1688,12 @@ void ChFi3d_Builder::PerformIntersectionAtEnd(const Standard_Integer Index)
PerformMoreThreeCorner (Index,1);
return;
}
Handle(GeomAdaptor_HSurface) HGs = ChFi3d_BoundSurf(DStr,Fd,1,2);
Handle(GeomAdaptor_Surface) HGs = ChFi3d_BoundSurf(DStr,Fd,1,2);
ChFiDS_FaceInterference Fi1 = Fd->InterferenceOnS1();
ChFiDS_FaceInterference Fi2 = Fd->InterferenceOnS2();
GeomAdaptor_Surface& Gs = HGs->ChangeSurface();
Handle(BRepAdaptor_HSurface) HBs = new BRepAdaptor_HSurface();
BRepAdaptor_Surface& Bs = HBs->ChangeSurface();
GeomAdaptor_Surface& Gs = *HGs;
Handle(BRepAdaptor_Surface) HBs = new BRepAdaptor_Surface();
BRepAdaptor_Surface& Bs = *HBs;
Handle(Geom_Curve) Cc;
Handle(Geom2d_Curve) Pc,Ps;
Standard_Real Ubid,Vbid;
@@ -2236,9 +2232,9 @@ void ChFi3d_Builder::PerformIntersectionAtEnd(const Standard_Integer Index)
Ubid=Utrim;
Vbid=Vtrim;
}
Handle(GeomAdaptor_HCurve) HC =
new GeomAdaptor_HCurve(C,Ubid,Vbid);
GeomAdaptor_Curve & Cad =HC->ChangeCurve();
Handle(GeomAdaptor_Curve) HC =
new GeomAdaptor_Curve(C,Ubid,Vbid);
GeomAdaptor_Curve & Cad = *HC;
inters.Perform(HC, HGs);
if ( !prolface[nn] && ( !inters.IsDone() || (inters.NbPoints()==0) )) {
// extend surface of conge
@@ -2309,8 +2305,8 @@ void ChFi3d_Builder::PerformIntersectionAtEnd(const Standard_Integer Index)
inters.Perform(HC, HGs);
trouve=inters.IsDone()&&inters.NbPoints()!=0;
// eap occ293, eval tolex on finally trimmed curves
// Handle(GeomAdaptor_HSurface) H1=new GeomAdaptor_HSurface(Sfacemoins1);
// Handle(GeomAdaptor_HSurface) H2=new GeomAdaptor_HSurface(Sface);
// Handle(GeomAdaptor_Surface) H1=new GeomAdaptor_Surface(Sfacemoins1);
// Handle(GeomAdaptor_Surface) H2=new GeomAdaptor_Surface(Sface);
// tolex=ChFi3d_EvalTolReached(H1,C2dint1,H2,C2dint2,cint);
tolex = InterSS.TolReached3d();
}
@@ -2739,12 +2735,12 @@ void ChFi3d_Builder::PerformIntersectionAtEnd(const Standard_Integer Index)
Ct=new Geom_TrimmedCurve (csau,par1,par2);
if (oneintersection1||oneintersection2) tolex=10*BRep_Tool::Tolerance(edgesau);
if (extend) {
Handle(GeomAdaptor_HSurface) H1, H2;
H1=new GeomAdaptor_HSurface(Sfacemoins1);
Handle(GeomAdaptor_Surface) H1, H2;
H1=new GeomAdaptor_Surface(Sfacemoins1);
if (Sface.IsNull())
tolex = Max (tolex, ChFi3d_EvalTolReached(H1,C2dint1,H1,C2dint1,Ct));
else {
H2=new GeomAdaptor_HSurface(Sface);
H2=new GeomAdaptor_Surface(Sface);
tolex = Max (tolex, ChFi3d_EvalTolReached(H1,C2dint1,H2,C2dint2,Ct));
}
}
@@ -3145,8 +3141,8 @@ void ChFi3d_Builder::PerformMoreSurfdata(const Standard_Integer Index)
Handle(Geom_Curve) aCint1;
Handle(Geom2d_Curve) aPCint11;
Handle(Geom2d_Curve) aPCint12;
Handle(GeomAdaptor_HSurface) H1 = new GeomAdaptor_HSurface(aSurfPrev);
Handle(GeomAdaptor_HSurface) H2 = new GeomAdaptor_HSurface(aSurf);
Handle(GeomAdaptor_Surface) H1 = new GeomAdaptor_Surface(aSurfPrev);
Handle(GeomAdaptor_Surface) H2 = new GeomAdaptor_Surface(aSurf);
Standard_Real aTolex1=0.;
Standard_Integer i;
gp_Pnt aPext1;
@@ -3254,8 +3250,8 @@ void ChFi3d_Builder::PerformMoreSurfdata(const Standard_Integer Index)
if (!anInterSS2.IsDone())
return;
H1 = new GeomAdaptor_HSurface(aSurfPrev);
H2 = new GeomAdaptor_HSurface(aSurf);
H1 = new GeomAdaptor_Surface(aSurfPrev);
H2 = new GeomAdaptor_Surface(aSurf);
isFound = Standard_False;
@@ -3809,12 +3805,12 @@ void ChFi3d_Builder::IntersectMoreCorner(const Standard_Integer Index)
TopAbs_Orientation OArcprolbis = TopAbs_FORWARD;
TopAbs_Orientation OArcprolv = TopAbs_FORWARD, OArcprolop = TopAbs_FORWARD;
Standard_Integer ICurve;
Handle(BRepAdaptor_HSurface) HBs = new BRepAdaptor_HSurface();
Handle(BRepAdaptor_HSurface) HBad = new BRepAdaptor_HSurface();
Handle(BRepAdaptor_HSurface) HBop = new BRepAdaptor_HSurface();
BRepAdaptor_Surface& Bs = HBs->ChangeSurface();
BRepAdaptor_Surface& Bad = HBad->ChangeSurface();
BRepAdaptor_Surface& Bop = HBop->ChangeSurface();
Handle(BRepAdaptor_Surface) HBs = new BRepAdaptor_Surface();
Handle(BRepAdaptor_Surface) HBad = new BRepAdaptor_Surface();
Handle(BRepAdaptor_Surface) HBop = new BRepAdaptor_Surface();
BRepAdaptor_Surface& Bs = *HBs;
BRepAdaptor_Surface& Bad = *HBad;
BRepAdaptor_Surface& Bop = *HBop;
Handle(Geom_Curve) Cc;
Handle(Geom2d_Curve) Pc,Ps;
Standard_Real Ubid,Vbid;//,mu,Mu,mv,Mv;
@@ -3949,8 +3945,8 @@ void ChFi3d_Builder::IntersectMoreCorner(const Standard_Integer Index)
// of its opposing vertex (point on arc).
Standard_Real wop = Fd->ChangeInterference(IFadArc).Parameter(isfirst);
Handle(Geom_Curve) c3df;
Handle(GeomAdaptor_HSurface)
HGs = new GeomAdaptor_HSurface(DStr.Surface(Fd->Surf()).Surface());
Handle(GeomAdaptor_Surface)
HGs = new GeomAdaptor_Surface(DStr.Surface(Fd->Surf()).Surface());
gp_Pnt2d p2dbout;
{
@@ -3960,12 +3956,12 @@ void ChFi3d_Builder::IntersectMoreCorner(const Standard_Integer Index)
c3df = DStr.Curve(FiopArc.LineIndex()).Curve();
Standard_Real uf = FiopArc.FirstParameter();
Standard_Real ul = FiopArc.LastParameter();
Handle(GeomAdaptor_HCurve) Hc3df;
Handle(GeomAdaptor_Curve) Hc3df;
if(c3df->IsPeriodic()){
Hc3df = new GeomAdaptor_HCurve(c3df);
Hc3df = new GeomAdaptor_Curve(c3df);
}
else{
Hc3df = new GeomAdaptor_HCurve(c3df,uf,ul);
Hc3df = new GeomAdaptor_Curve(c3df,uf,ul);
}
inters = Update(HBs,Hc3df,FiopArc,CPopArc,p2dbout,isfirst,wop);
// Modified by Sergey KHROMOV - Fri Dec 21 18:08:27 2001 Begin
@@ -3975,13 +3971,13 @@ void ChFi3d_Builder::IntersectMoreCorner(const Standard_Integer Index)
// Arcprol is an edge of tangency, ultimate adjustment by an extrema curve/curve is attempted.
Standard_Real ff,ll;
Handle(Geom2d_Curve) gpcprol = BRep_Tool::CurveOnSurface(Arcprol,Fv,ff,ll);
Handle(Geom2dAdaptor_HCurve) pcprol = new Geom2dAdaptor_HCurve(gpcprol);
Handle(Geom2dAdaptor_Curve) pcprol = new Geom2dAdaptor_Curve(gpcprol);
Standard_Real partemp = BRep_Tool::Parameter(Vtx,Arcprol);
inters = Update(HBs,pcprol,HGs,FiopArc,CPopArc,p2dbout,
isfirst,partemp,wop,10*tolesp);
}
Handle(BRepAdaptor_HCurve2d) pced = new BRepAdaptor_HCurve2d();
pced->ChangeCurve2d().Initialize(CPadArc.Arc(),Fv);
Handle(BRepAdaptor_Curve2d) pced = new BRepAdaptor_Curve2d();
pced->Initialize(CPadArc.Arc(),Fv);
Update(HBs,pced,HGs,FiadArc,CPadArc,isfirst);
}
#ifdef OCCT_DEBUG

51
src/ChFi3d/ChFi3d_Builder_C2.cxx
View File

@@ -15,9 +15,9 @@
// commercial license or contractual agreement.
#include <Adaptor2d_HCurve2d.hxx>
#include <Adaptor3d_HCurveOnSurface.hxx>
#include <Adaptor3d_HSurface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_CurveOnSurface.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor3d_TopolTool.hxx>
#include <AppBlend_Approx.hxx>
#include <Blend_CurvPointFuncInv.hxx>
@@ -30,9 +30,6 @@
#include <BRep_Tool.hxx>
#include <BRepAdaptor_Curve.hxx>
#include <BRepAdaptor_Curve2d.hxx>
#include <BRepAdaptor_HCurve.hxx>
#include <BRepAdaptor_HCurve2d.hxx>
#include <BRepAdaptor_HSurface.hxx>
#include <BRepAdaptor_Surface.hxx>
#include <BRepBlend_Line.hxx>
#include <BRepTopAdaptor_TopolTool.hxx>
@@ -42,7 +39,7 @@
#include <ChFiDS_CommonPoint.hxx>
#include <ChFiDS_FaceInterference.hxx>
#include <ChFiDS_HData.hxx>
#include <ChFiDS_HElSpine.hxx>
#include <ChFiDS_ElSpine.hxx>
#include <ChFiDS_ListIteratorOfListOfStripe.hxx>
#include <ChFiDS_SequenceOfSurfData.hxx>
#include <ChFiDS_Spine.hxx>
@@ -50,13 +47,13 @@
#include <ChFiDS_SurfData.hxx>
#include <Extrema_ExtPC.hxx>
#include <Geom2d_Curve.hxx>
#include <Geom2dAdaptor_HCurve.hxx>
#include <Geom2dAdaptor_Curve.hxx>
#include <Geom_BoundedCurve.hxx>
#include <Geom_Curve.hxx>
#include <Geom_Surface.hxx>
#include <GeomAbs_Shape.hxx>
#include <GeomAdaptor_HCurve.hxx>
#include <GeomAdaptor_HSurface.hxx>
#include <GeomAdaptor_Curve.hxx>
#include <GeomAdaptor_Surface.hxx>
#include <GeomAdaptor_Surface.hxx>
#include <GeomLib.hxx>
#include <gp_Ax3.hxx>
@@ -97,11 +94,11 @@
static void Reduce(const Standard_Real& p1,
const Standard_Real& p2,
Handle(GeomAdaptor_HSurface)& hs1,
Handle(GeomAdaptor_HSurface)& hs2)
Handle(GeomAdaptor_Surface)& hs1,
Handle(GeomAdaptor_Surface)& hs2)
{
GeomAdaptor_Surface& s1 = hs1->ChangeSurface();
GeomAdaptor_Surface& s2 = hs2->ChangeSurface();
GeomAdaptor_Surface& s1 = *hs1;
GeomAdaptor_Surface& s2 = *hs2;
const Handle(Geom_Surface)& surf = s1.Surface();
Standard_Real ud,uf,vd,vf;
surf->Bounds(ud,uf,vd,vf);
@@ -118,9 +115,9 @@ static void Reduce(const Standard_Real& p1,
static void Reduce(const Standard_Real& p1,
const Standard_Real& p2,
Handle(GeomAdaptor_HCurve)& hc)
Handle(GeomAdaptor_Curve)& hc)
{
GeomAdaptor_Curve& c = hc->ChangeCurve();
GeomAdaptor_Curve& c = *hc;
Standard_Real f = c.FirstParameter();
Standard_Real l = c.LastParameter();
Standard_Real milmoins = 0.51*f+0.49*l, milplus = 0.49*f+0.51*l;
@@ -249,7 +246,7 @@ Standard_Boolean ChFi3d_Builder::PerformTwoCornerbyInter(const Standard_Integer
pivot = CP1.Arc();
Standard_Real parCP1 = CP1.ParameterOnArc();
Standard_Real parCP2 = CP2.ParameterOnArc();
Handle(BRepAdaptor_HCurve) Hpivot = new BRepAdaptor_HCurve(pivot);
Handle(BRepAdaptor_Curve) Hpivot = new BRepAdaptor_Curve(pivot);
if (!pivot.IsSame(CP2.Arc())){
Handle(Geom_Curve) csau;
Standard_Real ubid,vbid;
@@ -288,7 +285,7 @@ Standard_Boolean ChFi3d_Builder::PerformTwoCornerbyInter(const Standard_Integer
return done;
}
Handle(GeomAdaptor_HSurface) HS1, HS2;
Handle(GeomAdaptor_Surface) HS1, HS2;
HS1 = ChFi3d_BoundSurf (DStr,Fd1,IFaCo1,IFaArc1);
HS2 = ChFi3d_BoundSurf (DStr,Fd2,IFaCo2,IFaArc2);
@@ -307,7 +304,7 @@ Standard_Boolean ChFi3d_Builder::PerformTwoCornerbyInter(const Standard_Integer
Pardeb(1)= UV.X(); Pardeb(2)=UV.Y();
UV = Fd2->Interference(IFaCo2).PCurveOnSurf()->Value(UIntPC2);
Pardeb(3)= UV.X(); Pardeb(4)=UV.Y();
gp_Pnt PFaCo = HS1->Surface().Value(Pardeb(1),Pardeb(2));
gp_Pnt PFaCo = HS1->Value(Pardeb(1),Pardeb(2));
// Side arc, calculation of Parfin.
Standard_Real UIntArc1 = Fd1->Interference(IFaArc1).Parameter(isfirst1);
@@ -410,7 +407,7 @@ Standard_Boolean ChFi3d_Builder::PerformTwoCornerbyInter(const Standard_Integer
}
Handle(ChFiDS_Stripe) BigCD, SmaCD;
Handle(ChFiDS_SurfData) BigFD, SmaFD;
Handle(GeomAdaptor_HSurface) BigHS, SmaHS;
Handle(GeomAdaptor_Surface) BigHS, SmaHS;
Standard_Integer IFaCoBig, IFaCoSma, IFaArcBig, IFaArcSma;
Standard_Boolean isfirstBig, isfirstSma;
Standard_Real UIntPCBig, UIntPCSma;
@@ -452,8 +449,8 @@ Standard_Boolean ChFi3d_Builder::PerformTwoCornerbyInter(const Standard_Integer
// Parfin (parameters of point PMil)
const ChFiDS_FaceInterference& FiArcSma = SmaFD->Interference(IFaArcSma);
Handle(Geom_Curve) ctg = DStr.Curve(FiArcSma.LineIndex()).Curve();
Handle(GeomAdaptor_HCurve) Hctg = new GeomAdaptor_HCurve();
GeomAdaptor_Curve& bid = Hctg->ChangeCurve();
Handle(GeomAdaptor_Curve) Hctg = new GeomAdaptor_Curve();
GeomAdaptor_Curve& bid = *Hctg;
Standard_Real temp,wi;
if (isfirstSma) {
@@ -560,7 +557,7 @@ Standard_Boolean ChFi3d_Builder::PerformTwoCornerbyInter(const Standard_Integer
// The intersection curve surface is tried again, now with representation
// pcurve on face of the curve to be sure.
TopoDS_Face F = TopoDS::Face(DStr.Shape(SmaFD->Index(IFaArcSma)));
Handle(BRepAdaptor_HSurface) HF = new BRepAdaptor_HSurface(F);
Handle(BRepAdaptor_Surface) HF = new BRepAdaptor_Surface(F);
Standard_Real fsma = FiArcSma.FirstParameter();
Standard_Real lsma = FiArcSma.LastParameter();
Standard_Real deltSma = 0.05 * (lsma - fsma);
@@ -571,10 +568,10 @@ Standard_Boolean ChFi3d_Builder::PerformTwoCornerbyInter(const Standard_Integer
done=Standard_False;
return done;
}
Handle(Geom2dAdaptor_HCurve) c2df =
new Geom2dAdaptor_HCurve(SmaFD->Interference(IFaArcSma).PCurveOnFace(),fsma,lsma);
Handle(Geom2dAdaptor_Curve) c2df =
new Geom2dAdaptor_Curve(SmaFD->Interference(IFaArcSma).PCurveOnFace(),fsma,lsma);
Adaptor3d_CurveOnSurface consf(c2df,HF);
Handle(Adaptor3d_HCurveOnSurface) Hconsf = new Adaptor3d_HCurveOnSurface(consf);
Handle(Adaptor3d_CurveOnSurface) Hconsf = new Adaptor3d_CurveOnSurface(consf);
if(!ChFi3d_IntCS(BigHS,Hconsf,UVi,wi)) {
#ifdef OCCT_DEBUG
std::cout<<"bevel : failed inter C S"<<std::endl;
@@ -605,7 +602,7 @@ Standard_Boolean ChFi3d_Builder::PerformTwoCornerbyInter(const Standard_Integer
// for the case when two chamfers are on two edges OnSame,
// it is necessary to extend the surface carrying F, or at least
// not to limit it.
ChFi3d_BoundFac(HF->ChangeSurface(),uu1,uu2,vv1,vv2,Standard_True);
ChFi3d_BoundFac (*HF, uu1, uu2, vv1, vv2, Standard_True);
if (!ChFi3d_ComputeCurves(HF,BigHS,Pardeb,Parfin,Gc,
PGc1,PGc2,tolesp,tol2d,tolreached)) {

61
src/ChFi3d/ChFi3d_Builder_CnCrn.cxx
View File

@@ -35,10 +35,9 @@
// consecutives
// Traitement des coins
#include <Adaptor2d_HCurve2d.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_CurveOnSurface.hxx>
#include <Adaptor3d_HCurveOnSurface.hxx>
#include <Adaptor3d_HSurface.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor3d_TopolTool.hxx>
#include <AppBlend_Approx.hxx>
#include <Blend_CurvPointFuncInv.hxx>
@@ -51,8 +50,8 @@
#include <Bnd_Box2d.hxx>
#include <BndLib_Add2dCurve.hxx>
#include <BRep_Tool.hxx>
#include <BRepAdaptor_HCurve2d.hxx>
#include <BRepAdaptor_HSurface.hxx>
#include <BRepAdaptor_Curve2d.hxx>
#include <BRepAdaptor_Surface.hxx>
#include <BRepAlgo_NormalProjection.hxx>
#include <BRepBlend_Line.hxx>
#include <BRepLib_MakeEdge.hxx>
@@ -64,7 +63,7 @@
#include <ChFiDS_CommonPoint.hxx>
#include <ChFiDS_FaceInterference.hxx>
#include <ChFiDS_HData.hxx>
#include <ChFiDS_HElSpine.hxx>
#include <ChFiDS_ElSpine.hxx>
#include <ChFiDS_ListIteratorOfListOfStripe.hxx>
#include <ChFiDS_Regul.hxx>
#include <ChFiDS_SequenceOfSurfData.hxx>
@@ -80,7 +79,7 @@
#include <Geom2d_Curve.hxx>
#include <Geom2d_Line.hxx>
#include <Geom2d_TrimmedCurve.hxx>
#include <Geom2dAdaptor_HCurve.hxx>
#include <Geom2dAdaptor_Curve.hxx>
#include <Geom2dLProp_CLProps2d.hxx>
#include <Geom_BezierCurve.hxx>
#include <Geom_BSplineSurface.hxx>
@@ -88,7 +87,7 @@
#include <Geom_Line.hxx>
#include <Geom_Surface.hxx>
#include <GeomAdaptor.hxx>
#include <GeomAdaptor_HSurface.hxx>
#include <GeomAdaptor_Surface.hxx>
#include <GeomInt_IntSS.hxx>
#include <GeomLib.hxx>
#include <GeomPlate_BuildPlateSurface.hxx>
@@ -494,7 +493,7 @@ static void CalculDroite(const gp_Pnt2d & p2d1,
//purpose : calcule a batten between curves 2d curv2d1 and curv2d2 at points p2d1 and p2d2
//=======================================================================
static void CalculBatten (const Handle (GeomAdaptor_HSurface) ASurf,
static void CalculBatten (const Handle (GeomAdaptor_Surface) ASurf,
const TopoDS_Face Face ,
const Standard_Real xdir,
const Standard_Real ydir,
@@ -719,8 +718,8 @@ static void PerformTwoCornerSameExt(TopOpeBRepDS_DataStructure& DStr,
Parfin(1)= pfi12.X();Parfin(2) = pfi12.Y();
Parfin(3)= pfi22.X();Parfin(4) = pfi22.Y();
Handle(GeomAdaptor_HSurface) HS1= ChFi3d_BoundSurf(DStr,Fd1,1,2);
Handle(GeomAdaptor_HSurface) HS2= ChFi3d_BoundSurf(DStr,Fd2,1,2);
Handle(GeomAdaptor_Surface) HS1= ChFi3d_BoundSurf(DStr,Fd1,1,2);
Handle(GeomAdaptor_Surface) HS2= ChFi3d_BoundSurf(DStr,Fd2,1,2);
trouve=Standard_False;
if (ChFi3d_ComputeCurves(HS1,HS2,Pardeb,Parfin,cint,
C2dint1,C2dint2,1.e-4,1.e-5,tol)){
@@ -2064,8 +2063,8 @@ void ChFi3d_Builder::PerformMoreThreeCorner(const Standard_Integer Jndex,
Calcul_P2dOnSurf(CD.Value(ic),jf.Value(ic),i.Value(ic,icplus),p.Value(ic,icplus),p2d2);
// if (i[ic][icplus]!= i[ic][icmoins]) std::cout<<"probleme surface"<<std::endl;
indice= SurfIndex(CD, ic, i.Value(ic,icplus), ChFiSURFACE);
Handle (GeomAdaptor_HSurface) Asurf =
new GeomAdaptor_HSurface(DStr.Surface(indice).Surface());
Handle (GeomAdaptor_Surface) Asurf =
new GeomAdaptor_Surface(DStr.Surface(indice).Surface());
// calculation of curve 2d
xdir= p2d2.X()-p2d1.X();
ydir= p2d2.Y()-p2d1.Y();
@@ -2073,10 +2072,10 @@ void ChFi3d_Builder::PerformMoreThreeCorner(const Standard_Integer Jndex,
gp_Dir2d dir (xdir, ydir);
Handle(Geom2d_Line) l= new Geom2d_Line (p2d1 ,dir);
Handle (Geom2d_Curve) pcurve = new Geom2d_TrimmedCurve(l,0,l0);
Handle (Geom2dAdaptor_HCurve) Acurv = new Geom2dAdaptor_HCurve(pcurve);
Handle (Geom2dAdaptor_Curve) Acurv = new Geom2dAdaptor_Curve(pcurve);
Adaptor3d_CurveOnSurface CurvOnS (Acurv,Asurf);
Handle(Adaptor3d_HCurveOnSurface) HCons =
new Adaptor3d_HCurveOnSurface(CurvOnS);
Handle(Adaptor3d_CurveOnSurface) HCons =
new Adaptor3d_CurveOnSurface(CurvOnS);
Order.SetValue(ic,1);
Handle(GeomPlate_CurveConstraint) Cont =
new GeomPlate_CurveConstraint(HCons,Order.Value(ic),10,tolesp,angular,0.1);
@@ -2217,7 +2216,7 @@ void ChFi3d_Builder::PerformMoreThreeCorner(const Standard_Integer Jndex,
Handle(Geom2d_Curve) curv2d1,curv2d2;
Handle (Geom2d_Curve) pcurve;
Handle (Geom_Curve) curveint;
Handle (GeomAdaptor_HSurface) Asurf;
Handle (GeomAdaptor_Surface) Asurf;
Standard_Real u1bid,u2bid;
// return the 1st curve 2d
@@ -2240,10 +2239,10 @@ void ChFi3d_Builder::PerformMoreThreeCorner(const Standard_Integer Jndex,
}
p2d2 = curv2d2 ->Value(p.Value(icplus,ic));
Asurf = new GeomAdaptor_HSurface(BRep_Tool::Surface(TopoDS::Face(Fvive.Value(ic,icplus))));
Asurf = new GeomAdaptor_Surface(BRep_Tool::Surface(TopoDS::Face(Fvive.Value(ic,icplus))));
Standard_Real tolu,tolv,ratio;
tolu=Asurf->Surface().UResolution(1.e-3);
tolv=Asurf->Surface().VResolution(1.e-3);
tolu=Asurf->UResolution(1.e-3);
tolv=Asurf->VResolution(1.e-3);
if (tolu>tolv) ratio=tolu/tolv;
else ratio=tolv/tolu;
@@ -2351,10 +2350,10 @@ void ChFi3d_Builder::PerformMoreThreeCorner(const Standard_Integer Jndex,
}
// construction of borders for Plate
Handle (Geom2dAdaptor_HCurve) Acurv=new Geom2dAdaptor_HCurve(pcurve);
Handle (Geom2dAdaptor_Curve) Acurv=new Geom2dAdaptor_Curve(pcurve);
Adaptor3d_CurveOnSurface CurvOnS (Acurv,Asurf);
Handle(Adaptor3d_HCurveOnSurface) HCons =
new Adaptor3d_HCurveOnSurface(CurvOnS);
Handle(Adaptor3d_CurveOnSurface) HCons =
new Adaptor3d_CurveOnSurface(CurvOnS);
// constraints G1 are set if edges ic and icplus are not both alive
@@ -2483,12 +2482,12 @@ void ChFi3d_Builder::PerformMoreThreeCorner(const Standard_Integer Jndex,
indpoint2= DStr.AddPoint(tpoint2);
ind=indpoint2;
}
Handle (GeomAdaptor_HSurface) Asurf;
Asurf = new GeomAdaptor_HSurface(BRep_Tool::Surface
Handle (GeomAdaptor_Surface) Asurf;
Asurf = new GeomAdaptor_Surface(BRep_Tool::Surface
(TopoDS::Face(Fproj.Value(nb))));
Handle (Geom2dAdaptor_HCurve) Acurv=new Geom2dAdaptor_HCurve(proj2d);
Handle (Geom2dAdaptor_Curve) Acurv=new Geom2dAdaptor_Curve(proj2d);
Adaptor3d_CurveOnSurface CurvOnS (Acurv,Asurf);
Handle(Adaptor3d_HCurveOnSurface) HCons =new Adaptor3d_HCurveOnSurface(CurvOnS);
Handle(Adaptor3d_CurveOnSurface) HCons =new Adaptor3d_CurveOnSurface(CurvOnS);
Order.SetValue(n3d,1);
Handle(GeomPlate_CurveConstraint) Cont =
new GeomPlate_CurveConstraint(HCons,Order.Value(n3d),10,tolesp,angular,0.1);
@@ -2596,12 +2595,12 @@ void ChFi3d_Builder::PerformMoreThreeCorner(const Standard_Integer Jndex,
}
ufirst=ctrim->FirstParameter();
ulast=ctrim->LastParameter();
Handle (GeomAdaptor_HSurface) Asurf;
Asurf = new GeomAdaptor_HSurface(BRep_Tool::Surface
Handle (GeomAdaptor_Surface) Asurf;
Asurf = new GeomAdaptor_Surface(BRep_Tool::Surface
(TopoDS::Face(Fvive.Value(ic,icplus))));
Handle (Geom2dAdaptor_HCurve) Acurv=new Geom2dAdaptor_HCurve(ctrim2d);
Handle (Geom2dAdaptor_Curve) Acurv=new Geom2dAdaptor_Curve(ctrim2d);
Adaptor3d_CurveOnSurface CurvOnS (Acurv,Asurf);
Handle(Adaptor3d_HCurveOnSurface) HCons =new Adaptor3d_HCurveOnSurface(CurvOnS);
Handle(Adaptor3d_CurveOnSurface) HCons =new Adaptor3d_CurveOnSurface(CurvOnS);
Order.SetValue(n3d,0);
Handle(GeomPlate_CurveConstraint) Cont =
new GeomPlate_CurveConstraint(HCons,Order.Value(n3d),10,tolesp,angular,0.1);

94
src/ChFi3d/ChFi3d_Builder_NotImp.cxx
View File

@@ -15,8 +15,8 @@
// commercial license or contractual agreement.
#include <Adaptor2d_HCurve2d.hxx>
#include <Adaptor3d_HSurface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor3d_TopolTool.hxx>
#include <AppBlend_Approx.hxx>
#include <Blend_CurvPointFuncInv.hxx>
@@ -26,13 +26,13 @@
#include <Blend_SurfCurvFuncInv.hxx>
#include <Blend_SurfPointFuncInv.hxx>
#include <Blend_SurfRstFunction.hxx>
#include <BRepAdaptor_HCurve2d.hxx>
#include <BRepAdaptor_HSurface.hxx>
#include <BRepAdaptor_Curve2d.hxx>
#include <BRepAdaptor_Surface.hxx>
#include <BRepBlend_Line.hxx>
#include <BRepTopAdaptor_TopolTool.hxx>
#include <ChFi3d_Builder.hxx>
#include <ChFiDS_CommonPoint.hxx>
#include <ChFiDS_HElSpine.hxx>
#include <ChFiDS_ElSpine.hxx>
#include <ChFiDS_Spine.hxx>
#include <ChFiDS_Stripe.hxx>
#include <ChFiDS_SurfData.hxx>
@@ -54,16 +54,16 @@
//purpose :
//=======================================================================
void ChFi3d_Builder::SimulSurf(Handle(ChFiDS_SurfData)& ,
const Handle(ChFiDS_HElSpine)& ,
const Handle(ChFiDS_ElSpine)& ,
const Handle(ChFiDS_Spine)& ,
const Standard_Integer ,
const Handle(BRepAdaptor_HSurface)& ,
const Handle(BRepAdaptor_Surface)& ,
const Handle(Adaptor3d_TopolTool)& ,
const Handle(BRepAdaptor_HCurve2d)& ,
const Handle(BRepAdaptor_HSurface)& ,
const Handle(BRepAdaptor_HCurve2d)& ,
const Handle(BRepAdaptor_Curve2d)& ,
const Handle(BRepAdaptor_Surface)& ,
const Handle(BRepAdaptor_Curve2d)& ,
Standard_Boolean& ,
const Handle(BRepAdaptor_HSurface)& ,
const Handle(BRepAdaptor_Surface)& ,
const Handle(Adaptor3d_TopolTool)& ,
const TopAbs_Orientation ,
const Standard_Real ,
@@ -87,17 +87,17 @@ void ChFi3d_Builder::SimulSurf(Handle(ChFiDS_SurfData)& ,
//=======================================================================
void ChFi3d_Builder::SimulSurf(Handle(ChFiDS_SurfData)& ,
const Handle(ChFiDS_HElSpine)& ,
const Handle(ChFiDS_ElSpine)& ,
const Handle(ChFiDS_Spine)& ,
const Standard_Integer ,
const Handle(BRepAdaptor_HSurface)& ,
const Handle(BRepAdaptor_Surface)& ,
const Handle(Adaptor3d_TopolTool)& ,
const TopAbs_Orientation ,
const Handle(BRepAdaptor_HSurface)& ,
const Handle(BRepAdaptor_Surface)& ,
const Handle(Adaptor3d_TopolTool)& ,
const Handle(BRepAdaptor_HCurve2d)& ,
const Handle(BRepAdaptor_HSurface)& ,
const Handle(BRepAdaptor_HCurve2d)& ,
const Handle(BRepAdaptor_Curve2d)& ,
const Handle(BRepAdaptor_Surface)& ,
const Handle(BRepAdaptor_Curve2d)& ,
Standard_Boolean& ,
const Standard_Real ,
const Standard_Real ,
@@ -121,21 +121,21 @@ void ChFi3d_Builder::SimulSurf(Handle(ChFiDS_SurfData)& ,
//=======================================================================
void ChFi3d_Builder::SimulSurf(Handle(ChFiDS_SurfData)& ,
const Handle(ChFiDS_HElSpine)& ,
const Handle(ChFiDS_ElSpine)& ,
const Handle(ChFiDS_Spine)& ,
const Standard_Integer ,
const Handle(BRepAdaptor_HSurface)& ,
const Handle(BRepAdaptor_Surface)& ,
const Handle(Adaptor3d_TopolTool)& ,
const Handle(BRepAdaptor_HCurve2d)& ,
const Handle(BRepAdaptor_HSurface)& ,
const Handle(BRepAdaptor_HCurve2d)& ,
const Handle(BRepAdaptor_Curve2d)& ,
const Handle(BRepAdaptor_Surface)& ,
const Handle(BRepAdaptor_Curve2d)& ,
Standard_Boolean& ,
const TopAbs_Orientation ,
const Handle(BRepAdaptor_HSurface)& ,
const Handle(BRepAdaptor_Surface)& ,
const Handle(Adaptor3d_TopolTool)& ,
const Handle(BRepAdaptor_HCurve2d)& ,
const Handle(BRepAdaptor_HSurface)& ,
const Handle(BRepAdaptor_HCurve2d)& ,
const Handle(BRepAdaptor_Curve2d)& ,
const Handle(BRepAdaptor_Surface)& ,
const Handle(BRepAdaptor_Curve2d)& ,
Standard_Boolean& ,
const TopAbs_Orientation ,
const Standard_Real ,
@@ -162,16 +162,16 @@ void ChFi3d_Builder::SimulSurf(Handle(ChFiDS_SurfData)& ,
//=======================================================================
void ChFi3d_Builder::PerformSurf(ChFiDS_SequenceOfSurfData& ,
const Handle(ChFiDS_HElSpine)& ,
const Handle(ChFiDS_ElSpine)& ,
const Handle(ChFiDS_Spine)& ,
const Standard_Integer ,
const Handle(BRepAdaptor_HSurface)& ,
const Handle(BRepAdaptor_Surface)& ,
const Handle(Adaptor3d_TopolTool)& ,
const Handle(BRepAdaptor_HCurve2d)& ,
const Handle(BRepAdaptor_HSurface)& ,
const Handle(BRepAdaptor_HCurve2d)& ,
const Handle(BRepAdaptor_Curve2d)& ,
const Handle(BRepAdaptor_Surface)& ,
const Handle(BRepAdaptor_Curve2d)& ,
Standard_Boolean& ,
const Handle(BRepAdaptor_HSurface)& ,
const Handle(BRepAdaptor_Surface)& ,
const Handle(Adaptor3d_TopolTool)& ,
const TopAbs_Orientation ,
const Standard_Real ,
@@ -196,17 +196,17 @@ void ChFi3d_Builder::PerformSurf(ChFiDS_SequenceOfSurfData& ,
//=======================================================================
void ChFi3d_Builder::PerformSurf(ChFiDS_SequenceOfSurfData& ,
const Handle(ChFiDS_HElSpine)& ,
const Handle(ChFiDS_ElSpine)& ,
const Handle(ChFiDS_Spine)& ,
const Standard_Integer ,
const Handle(BRepAdaptor_HSurface)& ,
const Handle(BRepAdaptor_Surface)& ,
const Handle(Adaptor3d_TopolTool)& ,
const TopAbs_Orientation ,
const Handle(BRepAdaptor_HSurface)& ,
const Handle(BRepAdaptor_Surface)& ,
const Handle(Adaptor3d_TopolTool)& ,
const Handle(BRepAdaptor_HCurve2d)& ,
const Handle(BRepAdaptor_HSurface)& ,
const Handle(BRepAdaptor_HCurve2d)& ,
const Handle(BRepAdaptor_Curve2d)& ,
const Handle(BRepAdaptor_Surface)& ,
const Handle(BRepAdaptor_Curve2d)& ,
Standard_Boolean& ,
const Standard_Real ,
const Standard_Real ,
@@ -235,21 +235,21 @@ void ChFi3d_Builder::PerformSurf(ChFiDS_SequenceOfSurfData& ,
//=======================================================================
void ChFi3d_Builder::PerformSurf(ChFiDS_SequenceOfSurfData& ,
const Handle(ChFiDS_HElSpine)& ,
const Handle(ChFiDS_ElSpine)& ,
const Handle(ChFiDS_Spine)& ,
const Standard_Integer ,
const Handle(BRepAdaptor_HSurface)& ,
const Handle(BRepAdaptor_Surface)& ,
const Handle(Adaptor3d_TopolTool)& ,
const Handle(BRepAdaptor_HCurve2d)& ,
const Handle(BRepAdaptor_HSurface)& ,
const Handle(BRepAdaptor_HCurve2d)& ,
const Handle(BRepAdaptor_Curve2d)& ,
const Handle(BRepAdaptor_Surface)& ,
const Handle(BRepAdaptor_Curve2d)& ,
Standard_Boolean& ,
const TopAbs_Orientation ,
const Handle(BRepAdaptor_HSurface)& ,
const Handle(BRepAdaptor_Surface)& ,
const Handle(Adaptor3d_TopolTool)& ,
const Handle(BRepAdaptor_HCurve2d)& ,
const Handle(BRepAdaptor_HSurface)& ,
const Handle(BRepAdaptor_HCurve2d)& ,
const Handle(BRepAdaptor_Curve2d)& ,
const Handle(BRepAdaptor_Surface)& ,
const Handle(BRepAdaptor_Curve2d)& ,
Standard_Boolean& ,
const TopAbs_Orientation ,
const Standard_Real ,

88
src/ChFi3d/ChFi3d_Builder_SpKP.cxx
View File

@@ -15,8 +15,8 @@
// commercial license or contractual agreement.
#include <Adaptor2d_HCurve2d.hxx>
#include <Adaptor3d_HSurface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor3d_TopolTool.hxx>
#include <AppBlend_Approx.hxx>
#include <Blend_CurvPointFuncInv.hxx>
@@ -28,15 +28,15 @@
#include <Blend_SurfRstFunction.hxx>
#include <BRep_Tool.hxx>
#include <BRepAdaptor_Curve2d.hxx>
#include <BRepAdaptor_HCurve.hxx>
#include <BRepAdaptor_HCurve2d.hxx>
#include <BRepAdaptor_HSurface.hxx>
#include <BRepAdaptor_Curve.hxx>
#include <BRepAdaptor_Curve2d.hxx>
#include <BRepAdaptor_Surface.hxx>
#include <BRepBlend_Line.hxx>
#include <BRepTopAdaptor_TopolTool.hxx>
#include <ChFi3d_Builder.hxx>
#include <ChFi3d_Builder_0.hxx>
#include <ChFiDS_CommonPoint.hxx>
#include <ChFiDS_HElSpine.hxx>
#include <ChFiDS_ElSpine.hxx>
#include <ChFiDS_Spine.hxx>
#include <ChFiDS_Stripe.hxx>
#include <ChFiDS_SurfData.hxx>
@@ -48,7 +48,7 @@
#include <Geom2d_Curve.hxx>
#include <Geom2d_Line.hxx>
#include <Geom2dAdaptor_Curve.hxx>
#include <Geom2dAdaptor_HCurve.hxx>
#include <Geom2dAdaptor_Curve.hxx>
#include <Geom2dHatch_Hatcher.hxx>
#include <Geom2dHatch_Intersector.hxx>
#include <Geom_Curve.hxx>
@@ -57,7 +57,7 @@
#include <GeomAbs_CurveType.hxx>
#include <GeomAbs_SurfaceType.hxx>
#include <GeomAdaptor_Curve.hxx>
#include <GeomAdaptor_HSurface.hxx>
#include <GeomAdaptor_Surface.hxx>
#include <gp.hxx>
#include <gp_Circ.hxx>
#include <gp_Dir2d.hxx>
@@ -260,8 +260,8 @@ static Standard_Real ParamOnSpine(const TopOpeBRepDS_DataStructure& DStr,
gp_Pln nlp(PP,gp_Dir(VV));
Handle(Geom_Plane) pln = new Geom_Plane(nlp);
Handle(GeomAdaptor_HSurface)
plan = new GeomAdaptor_HSurface(GeomAdaptor_Surface(pln));
Handle(GeomAdaptor_Surface)
plan = new GeomAdaptor_Surface(GeomAdaptor_Surface(pln));
// intersection plane spine.
Standard_Boolean found = Standard_False;
@@ -277,8 +277,8 @@ static Standard_Real ParamOnSpine(const TopOpeBRepDS_DataStructure& DStr,
pok = 1;
return Nl;
}
Handle(BRepAdaptor_HCurve) HE = new BRepAdaptor_HCurve();
BRepAdaptor_Curve& CE = HE->ChangeCurve();
Handle(BRepAdaptor_Curve) HE = new BRepAdaptor_Curve();
BRepAdaptor_Curve& CE = *HE;
while (!found && !fini) {
TopAbs_Orientation O = Spine->Edges(ii).Orientation();
@@ -346,8 +346,8 @@ static Standard_Boolean YaUnVoisin(const Handle(ChFiDS_Spine)& Spine,
void ChFi3d_Builder::Trunc(const Handle(ChFiDS_SurfData)& SD,
const Handle(ChFiDS_Spine)& Spine,
const Handle(Adaptor3d_HSurface)& S1,
const Handle(Adaptor3d_HSurface)& S2,
const Handle(Adaptor3d_Surface)& S1,
const Handle(Adaptor3d_Surface)& S2,
const Standard_Integer iedge,
const Standard_Boolean isfirst,
const Standard_Integer cntlFiOnS)
@@ -400,17 +400,17 @@ void ChFi3d_Builder::Trunc(const Handle(ChFiDS_SurfData)& SD,
if(dis1 >= 0.1*dis2) tron = Standard_True;
Standard_Integer ivois;
if(!tron && YaUnVoisin(Spine,iedge,ivois,isfirst)) {
Handle(BRepAdaptor_HSurface) BS1 = Handle(BRepAdaptor_HSurface)::DownCast(S1);
Handle(BRepAdaptor_HSurface) BS2 = Handle(BRepAdaptor_HSurface)::DownCast(S2);
Handle(BRepAdaptor_Surface) BS1 = Handle(BRepAdaptor_Surface)::DownCast(S1);
Handle(BRepAdaptor_Surface) BS2 = Handle(BRepAdaptor_Surface)::DownCast(S2);
if(!BS1.IsNull() && !BS2.IsNull()) {
TopoDS_Face FBID;
TopoDS_Face F1 = BS1->ChangeSurface().Face();
TopoDS_Face F2 = BS2->ChangeSurface().Face();
TopoDS_Face F1 = BS1->Face();
TopoDS_Face F2 = BS2->Face();
const ChFiDS_CommonPoint& cp1 = SD->Vertex(isfirst,1);
const ChFiDS_CommonPoint& cp2 = SD->Vertex(isfirst,2);
if(!((cp1.IsOnArc() && SearchFace(Spine,cp1,F1,FBID)) ||
(cp2.IsOnArc() && SearchFace(Spine,cp2,F2,FBID)))) {
tron = ChFi3d_KParticular(Spine,ivois,BS1->ChangeSurface(),BS2->ChangeSurface());
tron = ChFi3d_KParticular (Spine, ivois, *BS1, *BS2);
}
}
}
@@ -603,9 +603,9 @@ 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_Curve2d) HE = Handle(BRepAdaptor_Curve2d)::DownCast(M(IE));
if(!HE.IsNull()) {
const TopoDS_Edge& Etemp = HE->ChangeCurve2d().Edge();
const TopoDS_Edge& Etemp = HE->Edge();
TopExp::Vertices(Etemp,V1,V2);
}
else {
@@ -628,10 +628,10 @@ static void FillSD (TopOpeBRepDS_DataStructure& DStr,
}
const HatchGen_PointOnElement& PE = pPH->Point(LeType);
Standard_Integer IE = PE.Index();
Handle(BRepAdaptor_HCurve2d)
HE = Handle(BRepAdaptor_HCurve2d)::DownCast(M(IE));
Handle(BRepAdaptor_Curve2d)
HE = Handle(BRepAdaptor_Curve2d)::DownCast(M(IE));
if(HE.IsNull()) return;
const TopoDS_Edge& E = HE->ChangeCurve2d().Edge();
const TopoDS_Edge& E = HE->Edge();
if (PE.Position() != TopAbs_INTERNAL) {
TopAbs_Orientation O = CD->Interference(ons).Transition();
@@ -665,9 +665,9 @@ Standard_Boolean ChFi3d_Builder::SplitKPart
ChFiDS_SequenceOfSurfData& SetData,
const Handle(ChFiDS_Spine)& Spine,
const Standard_Integer Iedge,
const Handle(Adaptor3d_HSurface)& S1,
const Handle(Adaptor3d_Surface)& S1,
const Handle(Adaptor3d_TopolTool)& I1,
const Handle(Adaptor3d_HSurface)& S2,
const Handle(Adaptor3d_Surface)& S2,
const Handle(Adaptor3d_TopolTool)& I2,
Standard_Boolean& intf,
Standard_Boolean& intl)
@@ -689,13 +689,12 @@ Standard_Boolean ChFi3d_Builder::SplitKPart
if (!C1.IsNull()) {
ll1.Load(C1);
for(I1->Init(); I1->More(); I1->Next()) {
Handle(BRepAdaptor_HCurve2d)
Bc = Handle(BRepAdaptor_HCurve2d)::DownCast(I1->Value());
Handle(Geom2dAdaptor_HCurve)
Gc = Handle(Geom2dAdaptor_HCurve)::DownCast(I1->Value());
if(Bc.IsNull()) ie = H1.AddElement(Gc->ChangeCurve2d(),TopAbs_FORWARD);
else ie = H1.AddElement(Bc->ChangeCurve2d(),
Bc->ChangeCurve2d().Edge().Orientation());
Handle(BRepAdaptor_Curve2d)
Bc = Handle(BRepAdaptor_Curve2d)::DownCast(I1->Value());
Handle(Geom2dAdaptor_Curve)
Gc = Handle(Geom2dAdaptor_Curve)::DownCast(I1->Value());
if(Bc.IsNull()) ie = H1.AddElement (*Gc, TopAbs_FORWARD);
else ie = H1.AddElement (*Bc, Bc->Edge().Orientation());
M1.Bind(ie,I1->Value());
}
iH1 = H1.Trim(ll1);
@@ -715,13 +714,12 @@ Standard_Boolean ChFi3d_Builder::SplitKPart
if (!C2.IsNull()) {
ll2.Load(C2);
for(I2->Init(); I2->More(); I2->Next()) {
Handle(BRepAdaptor_HCurve2d)
Bc = Handle(BRepAdaptor_HCurve2d)::DownCast(I2->Value());
Handle(Geom2dAdaptor_HCurve)
Gc = Handle(Geom2dAdaptor_HCurve)::DownCast(I2->Value());
if(Bc.IsNull()) ie = H2.AddElement(Gc->ChangeCurve2d(),TopAbs_FORWARD);
else ie = H2.AddElement(Bc->ChangeCurve2d(),
Bc->ChangeCurve2d().Edge().Orientation());
Handle(BRepAdaptor_Curve2d)
Bc = Handle(BRepAdaptor_Curve2d)::DownCast(I2->Value());
Handle(Geom2dAdaptor_Curve)
Gc = Handle(Geom2dAdaptor_Curve)::DownCast(I2->Value());
if(Bc.IsNull()) ie = H2.AddElement (*Gc, TopAbs_FORWARD);
else ie = H2.AddElement (*Bc, Bc->Edge().Orientation());
M2.Bind(ie,I2->Value());
}
iH2 = H2.Trim(ll2);
@@ -749,11 +747,11 @@ Standard_Boolean ChFi3d_Builder::SplitKPart
// Return faces.
TopoDS_Face F1, F2;
Handle(BRepAdaptor_HSurface)
bhs = Handle(BRepAdaptor_HSurface)::DownCast(S1);
if(!bhs.IsNull()) F1 = bhs->ChangeSurface().Face();
bhs = Handle(BRepAdaptor_HSurface)::DownCast(S2);
if(!bhs.IsNull()) F2 = bhs->ChangeSurface().Face();
Handle(BRepAdaptor_Surface)
bhs = Handle(BRepAdaptor_Surface)::DownCast(S1);
if(!bhs.IsNull()) F1 = bhs->Face();
bhs = Handle(BRepAdaptor_Surface)::DownCast(S2);
if(!bhs.IsNull()) F2 = bhs->Face();
TopoDS_Face FBID;
// Restriction of SurfDatas by cut lines.

172
src/ChFi3d/ChFi3d_ChBuilder.cxx
View File

@@ -19,8 +19,8 @@
#include <Blend_Point.hxx>
#include <BlendFunc_SectionShape.hxx>
#include <BRepAdaptor_Curve2d.hxx>
#include <BRepAdaptor_HCurve2d.hxx>
#include <BRepAdaptor_HSurface.hxx>
#include <BRepAdaptor_Curve2d.hxx>
#include <BRepAdaptor_Surface.hxx>
#include <BRepAdaptor_Surface.hxx>
#include <BRepBlend_Chamfer.hxx>
#include <BRepBlend_ChamfInv.hxx>
@@ -39,7 +39,7 @@
#include <ChFiDS_ChamfSpine.hxx>
#include <ChFiDS_CircSection.hxx>
#include <ChFiDS_HData.hxx>
#include <ChFiDS_HElSpine.hxx>
#include <ChFiDS_ElSpine.hxx>
#include <ChFiDS_ListIteratorOfListOfStripe.hxx>
#include <ChFiDS_ListIteratorOfRegularities.hxx>
#include <ChFiDS_ListOfStripe.hxx>
@@ -50,7 +50,7 @@
#include <ChFiDS_SurfData.hxx>
#include <ElSLib.hxx>
#include <Extrema_GenLocateExtPS.hxx>
#include <GeomAdaptor_HCurve.hxx>
#include <GeomAdaptor_Curve.hxx>
#include <Standard_ConstructionError.hxx>
#include <Standard_DomainError.hxx>
#include <Standard_NotImplemented.hxx>
@@ -729,12 +729,12 @@ void ChFi3d_ChBuilder::SimulKPart(const Handle(ChFiDS_SurfData)& SD ) const
Standard_Boolean
ChFi3d_ChBuilder::SimulSurf(Handle(ChFiDS_SurfData)& Data,
const Handle(ChFiDS_HElSpine)& HGuide,
const Handle(ChFiDS_ElSpine)& HGuide,
const Handle(ChFiDS_Spine)& Spine,
const Standard_Integer Choix,
const Handle(BRepAdaptor_HSurface)& S1,
const Handle(BRepAdaptor_Surface)& S1,
const Handle(Adaptor3d_TopolTool)& I1,
const Handle(BRepAdaptor_HSurface)& S2,
const Handle(BRepAdaptor_Surface)& S2,
const Handle(Adaptor3d_TopolTool)& I2,
const Standard_Real TolGuide,
Standard_Real& First,
@@ -781,7 +781,7 @@ ChFi3d_ChBuilder::SimulSurf(Handle(ChFiDS_SurfData)& Data,
if(intl) Last = chsp->LastParameter(chsp->NbEdges());
Handle(ChFiDS_HElSpine) OffsetHGuide;
Handle(ChFiDS_ElSpine) OffsetHGuide;
if (chsp->IsChamfer() == ChFiDS_Sym) {
Standard_Real dis;
@@ -850,14 +850,14 @@ ChFi3d_ChBuilder::SimulSurf(Handle(ChFiDS_SurfData)& Data,
Standard_Boolean ok = Standard_False;
const ChFiDS_CommonPoint& cp1 = Data->VertexFirstOnS1();
if(cp1.IsOnArc()){
TopoDS_Face F1 = S1->ChangeSurface().Face();
TopoDS_Face F1 = S1->Face();
TopoDS_Face bid;
intf = !SearchFace(Spine,cp1,F1,bid);
ok = intf != 0;
}
const ChFiDS_CommonPoint& cp2 = Data->VertexFirstOnS2();
if(cp2.IsOnArc() && !ok){
TopoDS_Face F2 = S2->ChangeSurface().Face();
TopoDS_Face F2 = S2->Face();
TopoDS_Face bid;
intf = !SearchFace(Spine,cp2,F2,bid);
}
@@ -866,14 +866,14 @@ ChFi3d_ChBuilder::SimulSurf(Handle(ChFiDS_SurfData)& Data,
Standard_Boolean ok = Standard_False;
const ChFiDS_CommonPoint& cp1 = Data->VertexLastOnS1();
if(cp1.IsOnArc()){
TopoDS_Face F1 = S1->ChangeSurface().Face();
TopoDS_Face F1 = S1->Face();
TopoDS_Face bid;
intl = !SearchFace(Spine,cp1,F1,bid);
ok = intl != 0;
}
const ChFiDS_CommonPoint& cp2 = Data->VertexLastOnS2();
if(cp2.IsOnArc() && !ok){
TopoDS_Face F2 = S2->ChangeSurface().Face();
TopoDS_Face F2 = S2->Face();
TopoDS_Face bid;
intl = !SearchFace(Spine,cp2,F2,bid);
}
@@ -907,7 +907,7 @@ ChFi3d_ChBuilder::SimulSurf(Handle(ChFiDS_SurfData)& Data,
ChFiDS_ListIteratorOfListOfHElSpine ILES(ll), ILES_offset(ll_offset);
for ( ; ILES.More(); ILES.Next(),ILES_offset.Next())
{
const Handle(ChFiDS_HElSpine)& aHElSpine = ILES.Value();
const Handle(ChFiDS_ElSpine)& aHElSpine = ILES.Value();
if (aHElSpine == HGuide)
OffsetHGuide = ILES_offset.Value();
}
@@ -965,14 +965,14 @@ ChFi3d_ChBuilder::SimulSurf(Handle(ChFiDS_SurfData)& Data,
Standard_Boolean ok = Standard_False;
const ChFiDS_CommonPoint& cp1 = Data->VertexFirstOnS1();
if(cp1.IsOnArc()){
TopoDS_Face F1 = S1->ChangeSurface().Face();
TopoDS_Face F1 = S1->Face();
TopoDS_Face bid;
intf = !SearchFace(Spine,cp1,F1,bid);
ok = intf != 0;
}
const ChFiDS_CommonPoint& cp2 = Data->VertexFirstOnS2();
if(cp2.IsOnArc() && !ok){
TopoDS_Face F2 = S2->ChangeSurface().Face();
TopoDS_Face F2 = S2->Face();
TopoDS_Face bid;
intf = !SearchFace(Spine,cp2,F2,bid);
}
@@ -981,14 +981,14 @@ ChFi3d_ChBuilder::SimulSurf(Handle(ChFiDS_SurfData)& Data,
Standard_Boolean ok = Standard_False;
const ChFiDS_CommonPoint& cp1 = Data->VertexLastOnS1();
if(cp1.IsOnArc()){
TopoDS_Face F1 = S1->ChangeSurface().Face();
TopoDS_Face F1 = S1->Face();
TopoDS_Face bid;
intl = !SearchFace(Spine,cp1,F1,bid);
ok = intl != 0;
}
const ChFiDS_CommonPoint& cp2 = Data->VertexLastOnS2();
if(cp2.IsOnArc() && !ok){
TopoDS_Face F2 = S2->ChangeSurface().Face();
TopoDS_Face F2 = S2->Face();
TopoDS_Face bid;
intl = !SearchFace(Spine,cp2,F2,bid);
}
@@ -1050,14 +1050,14 @@ ChFi3d_ChBuilder::SimulSurf(Handle(ChFiDS_SurfData)& Data,
Standard_Boolean ok = Standard_False;
const ChFiDS_CommonPoint& cp1 = Data->VertexFirstOnS1();
if(cp1.IsOnArc()){
TopoDS_Face F1 = S1->ChangeSurface().Face();
TopoDS_Face F1 = S1->Face();
TopoDS_Face bid;
intf = !SearchFace(Spine,cp1,F1,bid);
ok = intf != 0;
}
const ChFiDS_CommonPoint& cp2 = Data->VertexFirstOnS2();
if(cp2.IsOnArc() && !ok){
TopoDS_Face F2 = S2->ChangeSurface().Face();
TopoDS_Face F2 = S2->Face();
TopoDS_Face bid;
intf = !SearchFace(Spine,cp2,F2,bid);
}
@@ -1067,14 +1067,14 @@ ChFi3d_ChBuilder::SimulSurf(Handle(ChFiDS_SurfData)& Data,
Standard_Boolean ok = Standard_False;
const ChFiDS_CommonPoint& cp1 = Data->VertexLastOnS1();
if(cp1.IsOnArc()){
TopoDS_Face F1 = S1->ChangeSurface().Face();
TopoDS_Face F1 = S1->Face();
TopoDS_Face bid;
intl = !SearchFace(Spine,cp1,F1,bid);
ok = intl != 0;
}
const ChFiDS_CommonPoint& cp2 = Data->VertexLastOnS2();
if(cp2.IsOnArc() && !ok){
TopoDS_Face F2 = S2->ChangeSurface().Face();
TopoDS_Face F2 = S2->Face();
TopoDS_Face bid;
intl = !SearchFace(Spine,cp2,F2,bid);
}
@@ -1084,16 +1084,16 @@ ChFi3d_ChBuilder::SimulSurf(Handle(ChFiDS_SurfData)& Data,
}
void ChFi3d_ChBuilder::SimulSurf(Handle(ChFiDS_SurfData)& ,
const Handle(ChFiDS_HElSpine)& ,
const Handle(ChFiDS_ElSpine)& ,
const Handle(ChFiDS_Spine)& ,
const Standard_Integer ,
const Handle(BRepAdaptor_HSurface)& ,
const Handle(BRepAdaptor_Surface)& ,
const Handle(Adaptor3d_TopolTool)& ,
const Handle(BRepAdaptor_HCurve2d)& ,
const Handle(BRepAdaptor_HSurface)& ,
const Handle(BRepAdaptor_HCurve2d)& ,
const Handle(BRepAdaptor_Curve2d)& ,
const Handle(BRepAdaptor_Surface)& ,
const Handle(BRepAdaptor_Curve2d)& ,
Standard_Boolean& ,
const Handle(BRepAdaptor_HSurface)& ,
const Handle(BRepAdaptor_Surface)& ,
const Handle(Adaptor3d_TopolTool)& ,
const TopAbs_Orientation ,
const Standard_Real ,
@@ -1111,17 +1111,17 @@ void ChFi3d_ChBuilder::SimulSurf(Handle(ChFiDS_SurfData)& ,
throw Standard_Failure("SimulSurf Not Implemented");
}
void ChFi3d_ChBuilder::SimulSurf(Handle(ChFiDS_SurfData)& ,
const Handle(ChFiDS_HElSpine)& ,
const Handle(ChFiDS_ElSpine)& ,
const Handle(ChFiDS_Spine)& ,
const Standard_Integer ,
const Handle(BRepAdaptor_HSurface)& ,
const Handle(BRepAdaptor_Surface)& ,
const Handle(Adaptor3d_TopolTool)& ,
const TopAbs_Orientation ,
const Handle(BRepAdaptor_HSurface)& ,
const Handle(BRepAdaptor_Surface)& ,
const Handle(Adaptor3d_TopolTool)& ,
const Handle(BRepAdaptor_HCurve2d)& ,
const Handle(BRepAdaptor_HSurface)& ,
const Handle(BRepAdaptor_HCurve2d)& ,
const Handle(BRepAdaptor_Curve2d)& ,
const Handle(BRepAdaptor_Surface)& ,
const Handle(BRepAdaptor_Curve2d)& ,
Standard_Boolean& ,
const Standard_Real ,
const Standard_Real ,
@@ -1138,21 +1138,21 @@ void ChFi3d_ChBuilder::SimulSurf(Handle(ChFiDS_SurfData)& ,
throw Standard_Failure("SimulSurf Not Implemented");
}
void ChFi3d_ChBuilder::SimulSurf(Handle(ChFiDS_SurfData)& ,
const Handle(ChFiDS_HElSpine)& ,
const Handle(ChFiDS_ElSpine)& ,
const Handle(ChFiDS_Spine)& ,
const Standard_Integer ,
const Handle(BRepAdaptor_HSurface)& ,
const Handle(BRepAdaptor_Surface)& ,
const Handle(Adaptor3d_TopolTool)& ,
const Handle(BRepAdaptor_HCurve2d)& ,
const Handle(BRepAdaptor_HSurface)& ,
const Handle(BRepAdaptor_HCurve2d)& ,
const Handle(BRepAdaptor_Curve2d)& ,
const Handle(BRepAdaptor_Surface)& ,
const Handle(BRepAdaptor_Curve2d)& ,
Standard_Boolean& ,
const TopAbs_Orientation ,
const Handle(BRepAdaptor_HSurface)& ,
const Handle(BRepAdaptor_Surface)& ,
const Handle(Adaptor3d_TopolTool)& ,
const Handle(BRepAdaptor_HCurve2d)& ,
const Handle(BRepAdaptor_HSurface)& ,
const Handle(BRepAdaptor_HCurve2d)& ,
const Handle(BRepAdaptor_Curve2d)& ,
const Handle(BRepAdaptor_Surface)& ,
const Handle(BRepAdaptor_Curve2d)& ,
Standard_Boolean& ,
const TopAbs_Orientation ,
const Standard_Real ,
@@ -1178,10 +1178,10 @@ void ChFi3d_ChBuilder::SimulSurf(Handle(ChFiDS_SurfData)& ,
Standard_Boolean ChFi3d_ChBuilder::PerformFirstSection
(const Handle(ChFiDS_Spine)& Spine,
const Handle(ChFiDS_HElSpine)& HGuide,
const Handle(ChFiDS_ElSpine)& HGuide,
const Standard_Integer Choix,
Handle(BRepAdaptor_HSurface)& S1,
Handle(BRepAdaptor_HSurface)& S2,
Handle(BRepAdaptor_Surface)& S1,
Handle(BRepAdaptor_Surface)& S2,
const Handle(Adaptor3d_TopolTool)& I1,
const Handle(Adaptor3d_TopolTool)& I2,
const Standard_Real Par,
@@ -1223,8 +1223,8 @@ Standard_Boolean ChFi3d_ChBuilder::PerformFirstSection
gp_Pnt pt1, pt2, ptgui;
gp_XYZ temp;
( HGuide->Curve() ).D1(Par,ptgui,d1gui);
// ptgui = (S1->Surface()).Value(SolDep(1),SolDep(2));
HGuide->D1(Par,ptgui,d1gui);
// ptgui = S1->Value(SolDep(1),SolDep(2));
pFunc->Set(Par);
pFunc->Tangent(SolDep(1),SolDep(2),SolDep(3),SolDep(4),TgF,TgL,tmp1,tmp2);
@@ -1255,9 +1255,9 @@ Standard_Boolean ChFi3d_ChBuilder::PerformFirstSection
Standard_Real tol = tolesp*1.e2;
// Standard_Real u,v;
Extrema_GenLocateExtPS proj1(S1->Surface(), tol, tol);
Extrema_GenLocateExtPS proj1(*S1, tol, tol);
proj1.Perform(pt1, SolDep(1), SolDep(2));
Extrema_GenLocateExtPS proj2(S2->Surface(), tol, tol);
Extrema_GenLocateExtPS proj2(*S2, tol, tol);
proj2.Perform(pt2, SolDep(3), SolDep(4));
if( proj1.IsDone() ){
@@ -1286,13 +1286,13 @@ Standard_Boolean ChFi3d_ChBuilder::PerformFirstSection
}
else
{
Handle(ChFiDS_HElSpine) OffsetHGuide;
Handle(ChFiDS_ElSpine) OffsetHGuide;
ChFiDS_ListOfHElSpine& ll = Spine->ChangeElSpines();
ChFiDS_ListOfHElSpine& ll_offset = Spine->ChangeOffsetElSpines();
ChFiDS_ListIteratorOfListOfHElSpine ILES(ll), ILES_offset(ll_offset);
for ( ; ILES.More(); ILES.Next(),ILES_offset.Next())
{
const Handle(ChFiDS_HElSpine)& aHElSpine = ILES.Value();
const Handle(ChFiDS_ElSpine)& aHElSpine = ILES.Value();
if (aHElSpine == HGuide)
OffsetHGuide = ILES_offset.Value();
}
@@ -1313,8 +1313,8 @@ Standard_Boolean ChFi3d_ChBuilder::PerformFirstSection
gp_Pnt pt1, pt2, ptgui;
gp_XYZ temp;
( HGuide->Curve() ).D1(Par,ptgui,d1gui);
// ptgui = (S1->Surface()).Value(SolDep(1),SolDep(2));
HGuide->D1(Par,ptgui,d1gui);
// ptgui = S1->Value(SolDep(1),SolDep(2));
pFunc->Set(Par);
pFunc->Tangent(SolDep(1),SolDep(2),SolDep(3),SolDep(4),TgF,TgL,tmp1,tmp2);
@@ -1362,9 +1362,9 @@ Standard_Boolean ChFi3d_ChBuilder::PerformFirstSection
Standard_Real tol = tolesp*1.e2;
// Standard_Real u,v;
Extrema_GenLocateExtPS proj1(S1->Surface(), tol, tol);
Extrema_GenLocateExtPS proj1(*S1, tol, tol);
proj1.Perform(pt1, SolDep(1), SolDep(2));
Extrema_GenLocateExtPS proj2(S2->Surface(), tol, tol);
Extrema_GenLocateExtPS proj2(*S2, tol, tol);
proj2.Perform(pt2, SolDep(3), SolDep(4));
if( proj1.IsDone() ){
@@ -1392,8 +1392,8 @@ Standard_Boolean ChFi3d_ChBuilder::PerformFirstSection
gp_Pnt pt1, pt2, ptgui;
gp_XYZ temp;
( HGuide->Curve() ).D1(Par,ptgui,d1gui);
// ptgui = (S1->Surface()).Value(SolDep(1),SolDep(2));
HGuide->D1(Par,ptgui,d1gui);
// ptgui = S1->Value(SolDep(1),SolDep(2));
Func.Set(Par);
Func.Tangent(SolDep(1),SolDep(2),SolDep(3),SolDep(4),TgF,TgL,tmp1,tmp2);
@@ -1431,9 +1431,9 @@ Standard_Boolean ChFi3d_ChBuilder::PerformFirstSection
Standard_Real tol = tolesp*1.e2;
// Standard_Real u,v;
Extrema_GenLocateExtPS proj1(S1->Surface(), tol, tol);
Extrema_GenLocateExtPS proj1(*S1, tol, tol);
proj1.Perform(pt1, SolDep(1), SolDep(2));
Extrema_GenLocateExtPS proj2(S2->Surface(), tol, tol);
Extrema_GenLocateExtPS proj2(*S2, tol, tol);
proj2.Perform(pt2, SolDep(3), SolDep(4));
if( proj1.IsDone() ){
(proj1.Point()).Parameter(SolDep(1),SolDep(2));
@@ -1455,12 +1455,12 @@ Standard_Boolean ChFi3d_ChBuilder::PerformFirstSection
Standard_Boolean
ChFi3d_ChBuilder::PerformSurf(ChFiDS_SequenceOfSurfData& SeqData,
const Handle(ChFiDS_HElSpine)& HGuide,
const Handle(ChFiDS_ElSpine)& HGuide,
const Handle(ChFiDS_Spine)& Spine,
const Standard_Integer Choix,
const Handle(BRepAdaptor_HSurface)& S1,
const Handle(BRepAdaptor_Surface)& S1,
const Handle(Adaptor3d_TopolTool)& I1,
const Handle(BRepAdaptor_HSurface)& S2,
const Handle(BRepAdaptor_Surface)& S2,
const Handle(Adaptor3d_TopolTool)& I2,
const Standard_Real MaxStep,
const Standard_Real Fleche,
@@ -1486,7 +1486,7 @@ ChFi3d_ChBuilder::PerformSurf(ChFiDS_SequenceOfSurfData& SeqData,
Standard_Boolean gd1,gd2,gf1,gf2;
Handle(BRepBlend_Line) lin;
TopAbs_Orientation Or = S1->ChangeSurface().Face().Orientation();
TopAbs_Orientation Or = S1->Face().Orientation();
Standard_Real PFirst = First;
if(intf) First = chsp->FirstParameter(1);
if(intl) Last = chsp->LastParameter(chsp->NbEdges());
@@ -1543,13 +1543,13 @@ ChFi3d_ChBuilder::PerformSurf(ChFiDS_SequenceOfSurfData& SeqData,
}
else
{
Handle(ChFiDS_HElSpine) OffsetHGuide;
Handle(ChFiDS_ElSpine) OffsetHGuide;
ChFiDS_ListOfHElSpine& ll = Spine->ChangeElSpines();
ChFiDS_ListOfHElSpine& ll_offset = Spine->ChangeOffsetElSpines();
ChFiDS_ListIteratorOfListOfHElSpine ILES(ll), ILES_offset(ll_offset);
for ( ; ILES.More(); ILES.Next(),ILES_offset.Next())
{
const Handle(ChFiDS_HElSpine)& aHElSpine = ILES.Value();
const Handle(ChFiDS_ElSpine)& aHElSpine = ILES.Value();
if (aHElSpine == HGuide)
OffsetHGuide = ILES_offset.Value();
}
@@ -1599,16 +1599,16 @@ ChFi3d_ChBuilder::PerformSurf(ChFiDS_SequenceOfSurfData& SeqData,
}
void ChFi3d_ChBuilder::PerformSurf(ChFiDS_SequenceOfSurfData& ,
const Handle(ChFiDS_HElSpine)& ,
const Handle(ChFiDS_ElSpine)& ,
const Handle(ChFiDS_Spine)& ,
const Standard_Integer ,
const Handle(BRepAdaptor_HSurface)& ,
const Handle(BRepAdaptor_Surface)& ,
const Handle(Adaptor3d_TopolTool)& ,
const Handle(BRepAdaptor_HCurve2d)& ,
const Handle(BRepAdaptor_HSurface)& ,
const Handle(BRepAdaptor_HCurve2d)& ,
const Handle(BRepAdaptor_Curve2d)& ,
const Handle(BRepAdaptor_Surface)& ,
const Handle(BRepAdaptor_Curve2d)& ,
Standard_Boolean& ,
const Handle(BRepAdaptor_HSurface)& ,
const Handle(BRepAdaptor_Surface)& ,
const Handle(Adaptor3d_TopolTool)& ,
const TopAbs_Orientation ,
const Standard_Real ,
@@ -1627,17 +1627,17 @@ void ChFi3d_ChBuilder::PerformSurf(ChFiDS_SequenceOfSurfData& ,
throw Standard_Failure("PerformSurf Not Implemented");
}
void ChFi3d_ChBuilder::PerformSurf(ChFiDS_SequenceOfSurfData& ,
const Handle(ChFiDS_HElSpine)& ,
const Handle(ChFiDS_ElSpine)& ,
const Handle(ChFiDS_Spine)& ,
const Standard_Integer ,
const Handle(BRepAdaptor_HSurface)& ,
const Handle(BRepAdaptor_Surface)& ,
const Handle(Adaptor3d_TopolTool)& ,
const TopAbs_Orientation ,
const Handle(BRepAdaptor_HSurface)& ,
const Handle(BRepAdaptor_Surface)& ,
const Handle(Adaptor3d_TopolTool)& ,
const Handle(BRepAdaptor_HCurve2d)& ,
const Handle(BRepAdaptor_HSurface)& ,
const Handle(BRepAdaptor_HCurve2d)& ,
const Handle(BRepAdaptor_Curve2d)& ,
const Handle(BRepAdaptor_Surface)& ,
const Handle(BRepAdaptor_Curve2d)& ,
Standard_Boolean& ,
const Standard_Real ,
const Standard_Real ,
@@ -1656,21 +1656,21 @@ void ChFi3d_ChBuilder::PerformSurf(ChFiDS_SequenceOfSurfData& ,
}
void ChFi3d_ChBuilder::PerformSurf(ChFiDS_SequenceOfSurfData& ,
const Handle(ChFiDS_HElSpine)& ,
const Handle(ChFiDS_ElSpine)& ,
const Handle(ChFiDS_Spine)& ,
const Standard_Integer ,
const Handle(BRepAdaptor_HSurface)& ,
const Handle(BRepAdaptor_Surface)& ,
const Handle(Adaptor3d_TopolTool)& ,
const Handle(BRepAdaptor_HCurve2d)& ,
const Handle(BRepAdaptor_HSurface)& ,
const Handle(BRepAdaptor_HCurve2d)& ,
const Handle(BRepAdaptor_Curve2d)& ,
const Handle(BRepAdaptor_Surface)& ,
const Handle(BRepAdaptor_Curve2d)& ,
Standard_Boolean& ,
const TopAbs_Orientation ,
const Handle(BRepAdaptor_HSurface)& ,
const Handle(BRepAdaptor_Surface)& ,
const Handle(Adaptor3d_TopolTool)& ,
const Handle(BRepAdaptor_HCurve2d)& ,
const Handle(BRepAdaptor_HSurface)& ,
const Handle(BRepAdaptor_HCurve2d)& ,
const Handle(BRepAdaptor_Curve2d)& ,
const Handle(BRepAdaptor_Surface)& ,
const Handle(BRepAdaptor_Curve2d)& ,
Standard_Boolean& ,
const TopAbs_Orientation ,
const Standard_Real ,

120
src/ChFi3d/ChFi3d_ChBuilder.hxx
View File

@@ -17,33 +17,27 @@
#ifndef _ChFi3d_ChBuilder_HeaderFile
#define _ChFi3d_ChBuilder_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <BRepAdaptor_Curve2d.hxx>
#include <BRepAdaptor_Surface.hxx>
#include <ChFi3d_Builder.hxx>
#include <Standard_Real.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Boolean.hxx>
#include <ChFiDS_ChamfMethod.hxx>
#include <ChFiDS_ChamfMode.hxx>
#include <ChFiDS_SecHArray1.hxx>
#include <ChFiDS_ListOfStripe.hxx>
#include <ChFiDS_SequenceOfSurfData.hxx>
#include <ChFiDS_ElSpine.hxx>
#include <math_Vector.hxx>
#include <TopAbs_Orientation.hxx>
#include <TopAbs_State.hxx>
#include <ChFiDS_SequenceOfSurfData.hxx>
#include <ChFiDS_ListOfStripe.hxx>
class Standard_ConstructionError;
class Standard_DomainError;
class TopoDS_Shape;
class TopoDS_Edge;
class TopoDS_Face;
class ChFiDS_SurfData;
class ChFiDS_HElSpine;
class ChFiDS_Spine;
class BRepAdaptor_HSurface;
class Adaptor3d_TopolTool;
class BRepAdaptor_HCurve2d;
class TopoDS_Vertex;
class ChFiDS_Stripe;
@@ -153,16 +147,16 @@ public:
const Standard_Integer IS) const;
Standard_EXPORT virtual void SimulSurf (Handle(ChFiDS_SurfData)& Data,
const Handle(ChFiDS_HElSpine)& Guide,
const Handle(ChFiDS_ElSpine)& Guide,
const Handle(ChFiDS_Spine)& Spine,
const Standard_Integer Choix,
const Handle(BRepAdaptor_HSurface)& S1,
const Handle(BRepAdaptor_Surface)& S1,
const Handle(Adaptor3d_TopolTool)& I1,
const Handle(BRepAdaptor_HCurve2d)& PC1,
const Handle(BRepAdaptor_HSurface)& Sref1,
const Handle(BRepAdaptor_HCurve2d)& PCref1,
const Handle(BRepAdaptor_Curve2d)& PC1,
const Handle(BRepAdaptor_Surface)& Sref1,
const Handle(BRepAdaptor_Curve2d)& PCref1,
Standard_Boolean& Decroch1,
const Handle(BRepAdaptor_HSurface)& S2,
const Handle(BRepAdaptor_Surface)& S2,
const Handle(Adaptor3d_TopolTool)& I2,
const TopAbs_Orientation Or2,
const Standard_Real Fleche,
@@ -178,17 +172,17 @@ public:
const math_Vector& Soldep) Standard_OVERRIDE;
Standard_EXPORT virtual void SimulSurf (Handle(ChFiDS_SurfData)& Data,
const Handle(ChFiDS_HElSpine)& Guide,
const Handle(ChFiDS_ElSpine)& Guide,
const Handle(ChFiDS_Spine)& Spine,
const Standard_Integer Choix,
const Handle(BRepAdaptor_HSurface)& S1,
const Handle(BRepAdaptor_Surface)& S1,
const Handle(Adaptor3d_TopolTool)& I1,
const TopAbs_Orientation Or1,
const Handle(BRepAdaptor_HSurface)& S2,
const Handle(BRepAdaptor_Surface)& S2,
const Handle(Adaptor3d_TopolTool)& I2,
const Handle(BRepAdaptor_HCurve2d)& PC2,
const Handle(BRepAdaptor_HSurface)& Sref2,
const Handle(BRepAdaptor_HCurve2d)& PCref2,
const Handle(BRepAdaptor_Curve2d)& PC2,
const Handle(BRepAdaptor_Surface)& Sref2,
const Handle(BRepAdaptor_Curve2d)& PCref2,
Standard_Boolean& Decroch2,
const Standard_Real Fleche,
const Standard_Real TolGuide,
@@ -203,21 +197,21 @@ public:
const math_Vector& Soldep) Standard_OVERRIDE;
Standard_EXPORT virtual void SimulSurf (Handle(ChFiDS_SurfData)& Data,
const Handle(ChFiDS_HElSpine)& Guide,
const Handle(ChFiDS_ElSpine)& Guide,
const Handle(ChFiDS_Spine)& Spine,
const Standard_Integer Choix,
const Handle(BRepAdaptor_HSurface)& S1,
const Handle(BRepAdaptor_Surface)& S1,
const Handle(Adaptor3d_TopolTool)& I1,
const Handle(BRepAdaptor_HCurve2d)& PC1,
const Handle(BRepAdaptor_HSurface)& Sref1,
const Handle(BRepAdaptor_HCurve2d)& PCref1,
const Handle(BRepAdaptor_Curve2d)& PC1,
const Handle(BRepAdaptor_Surface)& Sref1,
const Handle(BRepAdaptor_Curve2d)& PCref1,
Standard_Boolean& Decroch1,
const TopAbs_Orientation Or1,
const Handle(BRepAdaptor_HSurface)& S2,
const Handle(BRepAdaptor_Surface)& S2,
const Handle(Adaptor3d_TopolTool)& I2,
const Handle(BRepAdaptor_HCurve2d)& PC2,
const Handle(BRepAdaptor_HSurface)& Sref2,
const Handle(BRepAdaptor_HCurve2d)& PCref2,
const Handle(BRepAdaptor_Curve2d)& PC2,
const Handle(BRepAdaptor_Surface)& Sref2,
const Handle(BRepAdaptor_Curve2d)& PCref2,
Standard_Boolean& Decroch2,
const TopAbs_Orientation Or2,
const Standard_Real Fleche,
@@ -237,12 +231,12 @@ public:
//! the elements of construction of the surface (fillet
//! or chamfer).
Standard_EXPORT virtual Standard_Boolean PerformSurf (ChFiDS_SequenceOfSurfData& Data,
const Handle(ChFiDS_HElSpine)& Guide,
const Handle(ChFiDS_ElSpine)& Guide,
const Handle(ChFiDS_Spine)& Spine,
const Standard_Integer Choix,
const Handle(BRepAdaptor_HSurface)& S1,
const Handle(BRepAdaptor_Surface)& S1,
const Handle(Adaptor3d_TopolTool)& I1,
const Handle(BRepAdaptor_HSurface)& S2,
const Handle(BRepAdaptor_Surface)& S2,
const Handle(Adaptor3d_TopolTool)& I2,
const Standard_Real MaxStep,
const Standard_Real Fleche,
@@ -262,16 +256,16 @@ public:
//! the elements of construction of the surface (fillet
//! or chamfer) contact edge/face.
Standard_EXPORT virtual void PerformSurf (ChFiDS_SequenceOfSurfData& Data,
const Handle(ChFiDS_HElSpine)& Guide,
const Handle(ChFiDS_ElSpine)& Guide,
const Handle(ChFiDS_Spine)& Spine,
const Standard_Integer Choix,
const Handle(BRepAdaptor_HSurface)& S1,
const Handle(BRepAdaptor_Surface)& S1,
const Handle(Adaptor3d_TopolTool)& I1,
const Handle(BRepAdaptor_HCurve2d)& PC1,
const Handle(BRepAdaptor_HSurface)& Sref1,
const Handle(BRepAdaptor_HCurve2d)& PCref1,
const Handle(BRepAdaptor_Curve2d)& PC1,
const Handle(BRepAdaptor_Surface)& Sref1,
const Handle(BRepAdaptor_Curve2d)& PCref1,
Standard_Boolean& Decroch1,
const Handle(BRepAdaptor_HSurface)& S2,
const Handle(BRepAdaptor_Surface)& S2,
const Handle(Adaptor3d_TopolTool)& I2,
const TopAbs_Orientation Or2,
const Standard_Real MaxStep,
@@ -291,17 +285,17 @@ public:
//! the elements of construction of the surface (fillet
//! or chamfer) contact edge/face.
Standard_EXPORT virtual void PerformSurf (ChFiDS_SequenceOfSurfData& Data,
const Handle(ChFiDS_HElSpine)& Guide,
const Handle(ChFiDS_ElSpine)& Guide,
const Handle(ChFiDS_Spine)& Spine,
const Standard_Integer Choix,
const Handle(BRepAdaptor_HSurface)& S1,
const Handle(BRepAdaptor_Surface)& S1,
const Handle(Adaptor3d_TopolTool)& I1,
const TopAbs_Orientation Or1,
const Handle(BRepAdaptor_HSurface)& S2,
const Handle(BRepAdaptor_Surface)& S2,
const Handle(Adaptor3d_TopolTool)& I2,
const Handle(BRepAdaptor_HCurve2d)& PC2,
const Handle(BRepAdaptor_HSurface)& Sref2,
const Handle(BRepAdaptor_HCurve2d)& PCref2,
const Handle(BRepAdaptor_Curve2d)& PC2,
const Handle(BRepAdaptor_Surface)& Sref2,
const Handle(BRepAdaptor_Curve2d)& PCref2,
Standard_Boolean& Decroch2,
const Standard_Real MaxStep,
const Standard_Real Fleche,
@@ -320,21 +314,21 @@ public:
//! the elements of construction of the surface (fillet
//! or chamfer) contact edge/edge.
Standard_EXPORT virtual void PerformSurf (ChFiDS_SequenceOfSurfData& Data,
const Handle(ChFiDS_HElSpine)& Guide,
const Handle(ChFiDS_ElSpine)& Guide,
const Handle(ChFiDS_Spine)& Spine,
const Standard_Integer Choix,
const Handle(BRepAdaptor_HSurface)& S1,
const Handle(BRepAdaptor_Surface)& S1,
const Handle(Adaptor3d_TopolTool)& I1,
const Handle(BRepAdaptor_HCurve2d)& PC1,
const Handle(BRepAdaptor_HSurface)& Sref1,
const Handle(BRepAdaptor_HCurve2d)& PCref1,
const Handle(BRepAdaptor_Curve2d)& PC1,
const Handle(BRepAdaptor_Surface)& Sref1,
const Handle(BRepAdaptor_Curve2d)& PCref1,
Standard_Boolean& Decroch1,
const TopAbs_Orientation Or1,
const Handle(BRepAdaptor_HSurface)& S2,
const Handle(BRepAdaptor_Surface)& S2,
const Handle(Adaptor3d_TopolTool)& I2,
const Handle(BRepAdaptor_HCurve2d)& PC2,
const Handle(BRepAdaptor_HSurface)& Sref2,
const Handle(BRepAdaptor_HCurve2d)& PCref2,
const Handle(BRepAdaptor_Curve2d)& PC2,
const Handle(BRepAdaptor_Surface)& Sref2,
const Handle(BRepAdaptor_Curve2d)& PCref2,
Standard_Boolean& Decroch2,
const TopAbs_Orientation Or2,
const Standard_Real MaxStep,
@@ -360,12 +354,12 @@ protected:
Standard_EXPORT void SimulKPart (const Handle(ChFiDS_SurfData)& SD) const Standard_OVERRIDE;
Standard_EXPORT Standard_Boolean SimulSurf (Handle(ChFiDS_SurfData)& Data,
const Handle(ChFiDS_HElSpine)& Guide,
const Handle(ChFiDS_ElSpine)& Guide,
const Handle(ChFiDS_Spine)& Spine,
const Standard_Integer Choix,
const Handle(BRepAdaptor_HSurface)& S1,
const Handle(BRepAdaptor_Surface)& S1,
const Handle(Adaptor3d_TopolTool)& I1,
const Handle(BRepAdaptor_HSurface)& S2,
const Handle(BRepAdaptor_Surface)& S2,
const Handle(Adaptor3d_TopolTool)& I2,
const Standard_Real TolGuide,
Standard_Real& First,
@@ -380,10 +374,10 @@ protected:
Standard_Integer& Intl) Standard_OVERRIDE;
Standard_EXPORT Standard_Boolean PerformFirstSection (const Handle(ChFiDS_Spine)& S,
const Handle(ChFiDS_HElSpine)& HGuide,
const Handle(ChFiDS_ElSpine)& HGuide,
const Standard_Integer Choix,
Handle(BRepAdaptor_HSurface)& S1,
Handle(BRepAdaptor_HSurface)& S2,
Handle(BRepAdaptor_Surface)& S1,
Handle(BRepAdaptor_Surface)& S2,
const Handle(Adaptor3d_TopolTool)& I1,
const Handle(Adaptor3d_TopolTool)& I2,
const Standard_Real Par,

6
src/ChFi3d/ChFi3d_ChBuilder_C2.cxx
View File

@@ -16,10 +16,10 @@
#include <Adaptor3d_TopolTool.hxx>
#include <BRepAdaptor_HCurve2d.hxx>
#include <BRepAdaptor_HSurface.hxx>
#include <BRepAdaptor_Curve2d.hxx>
#include <BRepAdaptor_Surface.hxx>
#include <ChFi3d_ChBuilder.hxx>
#include <ChFiDS_HElSpine.hxx>
#include <ChFiDS_ElSpine.hxx>
#include <ChFiDS_Spine.hxx>
#include <ChFiDS_Stripe.hxx>
#include <ChFiDS_SurfData.hxx>

54
src/ChFi3d/ChFi3d_ChBuilder_C3.cxx
View File

@@ -17,15 +17,15 @@
#include <Adaptor3d_TopolTool.hxx>
#include <BRep_Tool.hxx>
#include <BRepAdaptor_HCurve2d.hxx>
#include <BRepAdaptor_HSurface.hxx>
#include <BRepAdaptor_Curve2d.hxx>
#include <BRepAdaptor_Surface.hxx>
#include <BRepAdaptor_Surface.hxx>
#include <BRepLib_MakeEdge.hxx>
#include <ChFi3d_Builder_0.hxx>
#include <ChFi3d_ChBuilder.hxx>
#include <ChFiDS_ChamfSpine.hxx>
#include <ChFiDS_HData.hxx>
#include <ChFiDS_HElSpine.hxx>
#include <ChFiDS_ElSpine.hxx>
#include <ChFiDS_ListIteratorOfListOfStripe.hxx>
#include <ChFiDS_Regul.hxx>
#include <ChFiDS_Spine.hxx>
@@ -37,7 +37,7 @@
#include <Geom2d_Curve.hxx>
#include <Geom2d_Line.hxx>
#include <Geom2dAdaptor_Curve.hxx>
#include <Geom2dAdaptor_HCurve.hxx>
#include <Geom2dAdaptor_Curve.hxx>
#include <Geom2dInt_GInter.hxx>
#include <Geom_BSplineSurface.hxx>
#include <Geom_Curve.hxx>
@@ -46,8 +46,8 @@
#include <Geom_Surface.hxx>
#include <Geom_TrimmedCurve.hxx>
#include <GeomAbs_SurfaceType.hxx>
#include <GeomAdaptor_HCurve.hxx>
#include <GeomAdaptor_HSurface.hxx>
#include <GeomAdaptor_Curve.hxx>
#include <GeomAdaptor_Surface.hxx>
#include <GeomAPI_ProjectPointOnCurve.hxx>
#include <GeomAPI_ProjectPointOnSurf.hxx>
#include <GeomInt_IntSS.hxx>
@@ -120,12 +120,12 @@ static Standard_Boolean CoPlanar(const gp_Pnt PntA,
// it to allow the intersection computation
//=======================================================================
static Handle(GeomAdaptor_HSurface) BoundSurf(const Handle(Geom_Surface)& S,
static Handle(GeomAdaptor_Surface) BoundSurf(const Handle(Geom_Surface)& S,
const gp_Pnt2d& Pdeb,
const gp_Pnt2d& Pfin)
{
Handle(GeomAdaptor_HSurface) HS = new GeomAdaptor_HSurface();
GeomAdaptor_Surface& GAS = HS->ChangeSurface();
Handle(GeomAdaptor_Surface) HS = new GeomAdaptor_Surface();
GeomAdaptor_Surface& GAS = *HS;
GAS.Load(S);
Standard_Real uu1,uu2,vv1,vv2;
@@ -174,7 +174,7 @@ static Standard_Boolean ComputeIntersection(TopOpeBRepDS_DataStructure& DStr,
// take the surface of the pivot SurfData and trim it to allow
// the intersection computation if it's an analytic surface
Handle(GeomAdaptor_HSurface) HS1;
Handle(GeomAdaptor_Surface) HS1;
HS1 = ChFi3d_BoundSurf(DStr,SD,1,2);
const Handle(Geom_Surface)& gpl = DStr.Surface(SDCoin->Surf()).Surface();
@@ -211,7 +211,7 @@ static Standard_Boolean ComputeIntersection(TopOpeBRepDS_DataStructure& DStr,
// Trims the chamfer surface to allow the intersection computation
// and computes a GeomAdaptor_Surface for using the ComputeCurves
// function
Handle(GeomAdaptor_HSurface) HS2;
Handle(GeomAdaptor_Surface) HS2;
HS2 = BoundSurf(gpl,ptcoindeb,cpf2);
// compute the intersection curves and pcurves
@@ -351,12 +351,12 @@ void ChFi3d_ChBuilder::PerformThreeCorner(const Standard_Integer Jndex)
// On construit les HSurfaces et autres outils qui vont bien.
// ----------------------------------------------------------
Handle(BRepAdaptor_HSurface) Fac = new BRepAdaptor_HSurface(face[pivot]);
Handle(GeomAdaptor_HSurface)
bidsurf = new GeomAdaptor_HSurface(Fac->ChangeSurface().Surface());
Handle(BRepAdaptor_Surface) Fac = new BRepAdaptor_Surface(face[pivot]);
Handle(GeomAdaptor_Surface)
bidsurf = new GeomAdaptor_Surface(Fac->Surface());
Handle(Adaptor3d_TopolTool) IFac = new Adaptor3d_TopolTool(bidsurf);
Handle(GeomAdaptor_HSurface) Surf = ChFi3d_BoundSurf (DStr,fdpiv,jf[pivot][deb],jf[pivot][fin]);
Handle(GeomAdaptor_Surface) Surf = ChFi3d_BoundSurf (DStr,fdpiv,jf[pivot][deb],jf[pivot][fin]);
Handle(Adaptor3d_TopolTool) ISurf = new Adaptor3d_TopolTool(Surf);
// Creation of a new Stripe for the corner
@@ -368,12 +368,12 @@ void ChFi3d_ChBuilder::PerformThreeCorner(const Standard_Integer Jndex)
// Pour plus de surete, on verifie les intersections des pcurves des chanfreins sur leur
// face commune
Handle(GeomAdaptor_HSurface) HSdeb
= new GeomAdaptor_HSurface( GeomAdaptor_Surface(DStr.Surface(fddeb->Surf()).Surface()) );
Handle(GeomAdaptor_HSurface) HSfin
= new GeomAdaptor_HSurface( GeomAdaptor_Surface(DStr.Surface(fdfin->Surf()).Surface()) );
Handle(GeomAdaptor_HSurface) HSpiv
= new GeomAdaptor_HSurface( GeomAdaptor_Surface(DStr.Surface(fdpiv->Surf()).Surface()) );
Handle(GeomAdaptor_Surface) HSdeb
= new GeomAdaptor_Surface( GeomAdaptor_Surface(DStr.Surface(fddeb->Surf()).Surface()) );
Handle(GeomAdaptor_Surface) HSfin
= new GeomAdaptor_Surface( GeomAdaptor_Surface(DStr.Surface(fdfin->Surf()).Surface()) );
Handle(GeomAdaptor_Surface) HSpiv
= new GeomAdaptor_Surface( GeomAdaptor_Surface(DStr.Surface(fdpiv->Surf()).Surface()) );
gp_Pnt2d p2d[4];
gp_Pnt p3d[4], PSom;
@@ -557,12 +557,12 @@ void ChFi3d_ChBuilder::PerformThreeCorner(const Standard_Integer Jndex)
else if (nbl == 1) {
ChFi3d_TrimCurve(inter.Line(1),p3d[pivot],p3dface,gcface);
Handle(GeomAdaptor_HCurve) gac = new GeomAdaptor_HCurve();
gac->ChangeCurve().Load(gcface);
Handle(GeomAdaptor_HSurface) gas = new GeomAdaptor_HSurface;
gas->ChangeSurface().Load(gpl);
Handle(BRepAdaptor_HSurface) gaf = new BRepAdaptor_HSurface;
gaf->ChangeSurface().Initialize(face[pivot]);
Handle(GeomAdaptor_Curve) gac = new GeomAdaptor_Curve();
gac->Load(gcface);
Handle(GeomAdaptor_Surface) gas = new GeomAdaptor_Surface;
gas->Load(gpl);
Handle(BRepAdaptor_Surface) gaf = new BRepAdaptor_Surface;
gaf->Initialize(face[pivot]);
Standard_Real tolr;
ChFi3d_ProjectPCurv(gac,gaf,facepc1,tolesp,tolr);

204
src/ChFi3d/ChFi3d_FilBuilder.cxx
View File

@@ -18,8 +18,8 @@
#include <Adaptor3d_TopolTool.hxx>
#include <Blend_Point.hxx>
#include <BRepAdaptor_HCurve2d.hxx>
#include <BRepAdaptor_HSurface.hxx>
#include <BRepAdaptor_Curve2d.hxx>
#include <BRepAdaptor_Surface.hxx>
#include <BRepBlend_ConstRad.hxx>
#include <BRepBlend_ConstRadInv.hxx>
#include <BRepBlend_CurvPointRadInv.hxx>
@@ -41,7 +41,7 @@
#include <ChFiDS_ErrorStatus.hxx>
#include <ChFiDS_FilSpine.hxx>
#include <ChFiDS_HData.hxx>
#include <ChFiDS_HElSpine.hxx>
#include <ChFiDS_ElSpine.hxx>
#include <ChFiDS_ListIteratorOfListOfStripe.hxx>
#include <ChFiDS_ListIteratorOfRegularities.hxx>
#include <ChFiDS_ListOfStripe.hxx>
@@ -52,7 +52,7 @@
#include <ChFiDS_SurfData.hxx>
#include <ElSLib.hxx>
#include <Geom_Curve.hxx>
#include <GeomAdaptor_HCurve.hxx>
#include <GeomAdaptor_Curve.hxx>
#include <gp_XY.hxx>
#include <Law_Composite.hxx>
#include <Law_Function.hxx>
@@ -92,7 +92,7 @@ static Standard_Real MaxRad(const Handle(ChFiDS_FilSpine)& fsp,
return (fsp->MaxRadFromSeqAndLaws());
/*
Handle(ChFiDS_HElSpine) HGuide = fsp->ElSpine(IE);
Handle(ChFiDS_ElSpine) HGuide = fsp->ElSpine(IE);
Standard_Real la = HGuide->LastParameter(), fi = HGuide->FirstParameter();
Standard_Real longueur = la - fi, temp, w;
//#ifndef OCCT_DEBUG
@@ -110,7 +110,7 @@ static Standard_Real MaxRad(const Handle(ChFiDS_FilSpine)& fsp,
*/
}
static void SimulParams(const Handle(ChFiDS_HElSpine)& HGuide,
static void SimulParams(const Handle(ChFiDS_ElSpine)& HGuide,
const Handle(ChFiDS_FilSpine)& fsp,
Standard_Real& MaxStep,
Standard_Real& Fleche)
@@ -602,12 +602,12 @@ void ChFi3d_FilBuilder::SimulKPart(const Handle(ChFiDS_SurfData)& SD) const
Standard_Boolean
ChFi3d_FilBuilder::SimulSurf(Handle(ChFiDS_SurfData)& Data,
const Handle(ChFiDS_HElSpine)& HGuide,
const Handle(ChFiDS_ElSpine)& HGuide,
const Handle(ChFiDS_Spine)& Spine,
const Standard_Integer Choix,
const Handle(BRepAdaptor_HSurface)& S1,
const Handle(BRepAdaptor_Surface)& S1,
const Handle(Adaptor3d_TopolTool)& I1,
const Handle(BRepAdaptor_HSurface)& S2,
const Handle(BRepAdaptor_Surface)& S2,
const Handle(Adaptor3d_TopolTool)& I2,
const Standard_Real TolGuide,
Standard_Real& First,
@@ -625,7 +625,7 @@ ChFi3d_FilBuilder::SimulSurf(Handle(ChFiDS_SurfData)& Data,
if(fsp.IsNull()) throw Standard_ConstructionError("SimulSurf : this is not the spine of the fillet");
Handle(BRepBlend_Line) lin;
#ifdef OCCT_DEBUG
// TopAbs_Orientation Or = S1->ChangeSurface().Face().Orientation();
// TopAbs_Orientation Or = S1->Face().Orientation();
#endif
// Flexible parameters!!!
Standard_Real locfleche, MaxStep;
@@ -633,7 +633,7 @@ ChFi3d_FilBuilder::SimulSurf(Handle(ChFiDS_SurfData)& Data,
Handle(ChFiDS_SecHArray1) sec;
gp_Pnt2d pf1,pl1,pf2,pl2;
Handle(ChFiDS_HElSpine) EmptyHGuide;
Handle(ChFiDS_ElSpine) EmptyHGuide;
Standard_Real PFirst = First;
if(intf) First = fsp->FirstParameter(1);
@@ -707,14 +707,14 @@ ChFi3d_FilBuilder::SimulSurf(Handle(ChFiDS_SurfData)& Data,
Standard_Boolean ok = Standard_False;
const ChFiDS_CommonPoint& cp1 = Data->VertexFirstOnS1();
if(cp1.IsOnArc()){
TopoDS_Face F1 = S1->ChangeSurface().Face();
TopoDS_Face F1 = S1->Face();
TopoDS_Face bid;
intf = !SearchFace(Spine,cp1,F1,bid);
ok = intf != 0;
}
const ChFiDS_CommonPoint& cp2 = Data->VertexFirstOnS2();
if(cp2.IsOnArc() && !ok){
TopoDS_Face F2 = S2->ChangeSurface().Face();
TopoDS_Face F2 = S2->Face();
TopoDS_Face bid;
intf = !SearchFace(Spine,cp2,F2,bid);
}
@@ -723,14 +723,14 @@ ChFi3d_FilBuilder::SimulSurf(Handle(ChFiDS_SurfData)& Data,
Standard_Boolean ok = 0;
const ChFiDS_CommonPoint& cp1 = Data->VertexLastOnS1();
if(cp1.IsOnArc()){
TopoDS_Face F1 = S1->ChangeSurface().Face();
TopoDS_Face F1 = S1->Face();
TopoDS_Face bid;
intl = !SearchFace(Spine,cp1,F1,bid);
ok = intl != 0;
}
const ChFiDS_CommonPoint& cp2 = Data->VertexLastOnS2();
if(cp2.IsOnArc() && !ok){
TopoDS_Face F2 = S2->ChangeSurface().Face();
TopoDS_Face F2 = S2->Face();
TopoDS_Face bid;
intl = !SearchFace(Spine,cp2,F2,bid);
}
@@ -744,16 +744,16 @@ ChFi3d_FilBuilder::SimulSurf(Handle(ChFiDS_SurfData)& Data,
//=======================================================================
void ChFi3d_FilBuilder::SimulSurf(Handle(ChFiDS_SurfData)& Data,
const Handle(ChFiDS_HElSpine)& HGuide,
const Handle(ChFiDS_ElSpine)& HGuide,
const Handle(ChFiDS_Spine)& Spine,
const Standard_Integer Choix,
const Handle(BRepAdaptor_HSurface)& HS1,
const Handle(BRepAdaptor_Surface)& HS1,
const Handle(Adaptor3d_TopolTool)& I1,
const Handle(BRepAdaptor_HCurve2d)& PC1,
const Handle(BRepAdaptor_HSurface)& HSref1,
const Handle(BRepAdaptor_HCurve2d)& PCref1,
const Handle(BRepAdaptor_Curve2d)& PC1,
const Handle(BRepAdaptor_Surface)& HSref1,
const Handle(BRepAdaptor_Curve2d)& PCref1,
Standard_Boolean& Decroch1,
const Handle(BRepAdaptor_HSurface)& HS2,
const Handle(BRepAdaptor_Surface)& HS2,
const Handle(Adaptor3d_TopolTool)& I2,
const TopAbs_Orientation Or2,
const Standard_Real /*Fleche*/,
@@ -782,8 +782,8 @@ void ChFi3d_FilBuilder::SimulSurf(Handle(ChFiDS_SurfData)& Data,
if(fsp->IsConstant()){
BRepBlend_SurfRstConstRad func(HS2,HS1,PC1,HGuide);
func.Set(HSref1,PCref1);
Handle(Adaptor3d_HCurveOnSurface) HC = new Adaptor3d_HCurveOnSurface();
HC->ChangeCurve().Load(PC1, HS1);
Handle(Adaptor3d_CurveOnSurface) HC = new Adaptor3d_CurveOnSurface();
HC->Load(PC1, HS1);
BRepBlend_SurfCurvConstRadInv finvc(HS2,HC,HGuide);
BRepBlend_SurfPointConstRadInv finvp(HS2,HGuide);
BRepBlend_ConstRadInv finv(HS2,HSref1,HGuide);
@@ -824,8 +824,8 @@ void ChFi3d_FilBuilder::SimulSurf(Handle(ChFiDS_SurfData)& Data,
}
else {
BRepBlend_SurfRstEvolRad func(HS2,HS1,PC1,HGuide,fsp->Law(HGuide));
Handle(Adaptor3d_HCurveOnSurface) HC = new Adaptor3d_HCurveOnSurface();
HC->ChangeCurve().Load(PC1, HS1);
Handle(Adaptor3d_CurveOnSurface) HC = new Adaptor3d_CurveOnSurface();
HC->Load(PC1, HS1);
BRepBlend_SurfCurvEvolRadInv finvc(HS2,HC,HGuide,fsp->Law(HGuide));
BRepBlend_SurfPointEvolRadInv finvp(HS2,HGuide,fsp->Law(HGuide));
BRepBlend_EvolRadInv finv(HS2,HSref1,HGuide,fsp->Law(HGuide));
@@ -878,17 +878,17 @@ void ChFi3d_FilBuilder::SimulSurf(Handle(ChFiDS_SurfData)& Data,
//=======================================================================
void ChFi3d_FilBuilder::SimulSurf(Handle(ChFiDS_SurfData)& Data,
const Handle(ChFiDS_HElSpine)& HGuide,
const Handle(ChFiDS_ElSpine)& HGuide,
const Handle(ChFiDS_Spine)& Spine,
const Standard_Integer Choix,
const Handle(BRepAdaptor_HSurface)& HS1,
const Handle(BRepAdaptor_Surface)& HS1,
const Handle(Adaptor3d_TopolTool)& I1,
const TopAbs_Orientation Or1,
const Handle(BRepAdaptor_HSurface)& HS2,
const Handle(BRepAdaptor_Surface)& HS2,
const Handle(Adaptor3d_TopolTool)& I2,
const Handle(BRepAdaptor_HCurve2d)& PC2,
const Handle(BRepAdaptor_HSurface)& HSref2,
const Handle(BRepAdaptor_HCurve2d)& PCref2,
const Handle(BRepAdaptor_Curve2d)& PC2,
const Handle(BRepAdaptor_Surface)& HSref2,
const Handle(BRepAdaptor_Curve2d)& PCref2,
Standard_Boolean& Decroch2,
const Standard_Real /*Arrow*/,
const Standard_Real TolGuide,
@@ -916,8 +916,8 @@ void ChFi3d_FilBuilder::SimulSurf(Handle(ChFiDS_SurfData)& Data,
if(fsp->IsConstant()){
BRepBlend_SurfRstConstRad func(HS1,HS2,PC2,HGuide);
func.Set(HSref2,PCref2);
Handle(Adaptor3d_HCurveOnSurface) HC = new Adaptor3d_HCurveOnSurface();
HC->ChangeCurve().Load(PC2, HS2);
Handle(Adaptor3d_CurveOnSurface) HC = new Adaptor3d_CurveOnSurface();
HC->Load(PC2, HS2);
BRepBlend_SurfCurvConstRadInv finvc(HS1,HC,HGuide);
BRepBlend_SurfPointConstRadInv finvp(HS1,HGuide);
BRepBlend_ConstRadInv finv(HS1,HSref2,HGuide);
@@ -956,8 +956,8 @@ void ChFi3d_FilBuilder::SimulSurf(Handle(ChFiDS_SurfData)& Data,
}
else {
BRepBlend_SurfRstEvolRad func(HS1,HS2,PC2,HGuide,fsp->Law(HGuide));
Handle(Adaptor3d_HCurveOnSurface) HC = new Adaptor3d_HCurveOnSurface();
HC->ChangeCurve().Load(PC2, HS2);
Handle(Adaptor3d_CurveOnSurface) HC = new Adaptor3d_CurveOnSurface();
HC->Load(PC2, HS2);
BRepBlend_SurfCurvEvolRadInv finvc(HS1,HC,HGuide,fsp->Law(HGuide));
BRepBlend_SurfPointEvolRadInv finvp(HS1,HGuide,fsp->Law(HGuide));
BRepBlend_EvolRadInv finv(HS1,HSref2,HGuide,fsp->Law(HGuide));
@@ -1012,21 +1012,21 @@ void ChFi3d_FilBuilder::SimulSurf(Handle(ChFiDS_SurfData)& Data,
//=======================================================================
void ChFi3d_FilBuilder::SimulSurf(Handle(ChFiDS_SurfData)& Data,
const Handle(ChFiDS_HElSpine)& HGuide,
const Handle(ChFiDS_ElSpine)& HGuide,
const Handle(ChFiDS_Spine)& Spine,
const Standard_Integer Choix,
const Handle(BRepAdaptor_HSurface)& HS1,
const Handle(BRepAdaptor_Surface)& HS1,
const Handle(Adaptor3d_TopolTool)& I1,
const Handle(BRepAdaptor_HCurve2d)& PC1,
const Handle(BRepAdaptor_HSurface)& HSref1,
const Handle(BRepAdaptor_HCurve2d)& PCref1,
const Handle(BRepAdaptor_Curve2d)& PC1,
const Handle(BRepAdaptor_Surface)& HSref1,
const Handle(BRepAdaptor_Curve2d)& PCref1,
Standard_Boolean& Decroch1,
const TopAbs_Orientation Or1,
const Handle(BRepAdaptor_HSurface)& HS2,
const Handle(BRepAdaptor_Surface)& HS2,
const Handle(Adaptor3d_TopolTool)& I2,
const Handle(BRepAdaptor_HCurve2d)& PC2,
const Handle(BRepAdaptor_HSurface)& HSref2,
const Handle(BRepAdaptor_HCurve2d)& PCref2,
const Handle(BRepAdaptor_Curve2d)& PC2,
const Handle(BRepAdaptor_Surface)& HSref2,
const Handle(BRepAdaptor_Curve2d)& PCref2,
Standard_Boolean& Decroch2,
const TopAbs_Orientation Or2,
const Standard_Real /*Fleche*/,
@@ -1058,10 +1058,10 @@ void ChFi3d_FilBuilder::SimulSurf(Handle(ChFiDS_SurfData)& Data,
if(fsp->IsConstant()){
BRepBlend_RstRstConstRad func(HS1, PC1, HS2, PC2, HGuide);
func.Set(HSref1, PCref1, HSref2, PCref2);
Handle(Adaptor3d_HCurveOnSurface) HC1 = new Adaptor3d_HCurveOnSurface();
HC1->ChangeCurve().Load(PC1, HS1);
Handle(Adaptor3d_HCurveOnSurface) HC2 = new Adaptor3d_HCurveOnSurface();
HC2->ChangeCurve().Load(PC2, HS2);
Handle(Adaptor3d_CurveOnSurface) HC1 = new Adaptor3d_CurveOnSurface();
HC1->Load(PC1, HS1);
Handle(Adaptor3d_CurveOnSurface) HC2 = new Adaptor3d_CurveOnSurface();
HC2->Load(PC2, HS2);
BRepBlend_SurfCurvConstRadInv finv1(HSref1, HC2, HGuide);
BRepBlend_CurvPointRadInv finvp1(HGuide, HC2);
BRepBlend_SurfCurvConstRadInv finv2(HSref2, HC1, HGuide);
@@ -1106,10 +1106,10 @@ void ChFi3d_FilBuilder::SimulSurf(Handle(ChFiDS_SurfData)& Data,
else {
BRepBlend_RstRstEvolRad func(HS1,PC1, HS2, PC2, HGuide, fsp->Law(HGuide));
func.Set(HSref1, PCref1, HSref2, PCref2);
Handle(Adaptor3d_HCurveOnSurface) HC1 = new Adaptor3d_HCurveOnSurface();
HC1->ChangeCurve().Load(PC1, HS1);
Handle(Adaptor3d_HCurveOnSurface) HC2 = new Adaptor3d_HCurveOnSurface();
HC2->ChangeCurve().Load(PC2, HS2);
Handle(Adaptor3d_CurveOnSurface) HC1 = new Adaptor3d_CurveOnSurface();
HC1->Load(PC1, HS1);
Handle(Adaptor3d_CurveOnSurface) HC2 = new Adaptor3d_CurveOnSurface();
HC2->Load(PC2, HS2);
BRepBlend_SurfCurvEvolRadInv finv1(HSref1, HC2, HGuide, fsp->Law(HGuide));
BRepBlend_CurvPointRadInv finvp1(HGuide, HC2);
@@ -1181,10 +1181,10 @@ void ChFi3d_FilBuilder::SimulSurf(Handle(ChFiDS_SurfData)& Data,
Standard_Boolean ChFi3d_FilBuilder::PerformFirstSection
(const Handle(ChFiDS_Spine)& Spine,
const Handle(ChFiDS_HElSpine)& HGuide,
const Handle(ChFiDS_ElSpine)& HGuide,
const Standard_Integer Choix,
Handle(BRepAdaptor_HSurface)& S1,
Handle(BRepAdaptor_HSurface)& S2,
Handle(BRepAdaptor_Surface)& S1,
Handle(BRepAdaptor_Surface)& S2,
const Handle(Adaptor3d_TopolTool)& I1,
const Handle(Adaptor3d_TopolTool)& I2,
const Standard_Real Par,
@@ -1220,12 +1220,12 @@ Standard_Boolean ChFi3d_FilBuilder::PerformFirstSection
Standard_Boolean
ChFi3d_FilBuilder::PerformSurf(ChFiDS_SequenceOfSurfData& SeqData,
const Handle(ChFiDS_HElSpine)& HGuide,
const Handle(ChFiDS_ElSpine)& HGuide,
const Handle(ChFiDS_Spine)& Spine,
const Standard_Integer Choix,
const Handle(BRepAdaptor_HSurface)& S1,
const Handle(BRepAdaptor_Surface)& S1,
const Handle(Adaptor3d_TopolTool)& I1,
const Handle(BRepAdaptor_HSurface)& S2,
const Handle(BRepAdaptor_Surface)& S2,
const Handle(Adaptor3d_TopolTool)& I2,
const Standard_Real MaxStep,
const Standard_Real Fleche,
@@ -1249,7 +1249,7 @@ ChFi3d_FilBuilder::PerformSurf(ChFiDS_SequenceOfSurfData& SeqData,
if(fsp.IsNull()) throw Standard_ConstructionError("PerformSurf : this is not the spine of a fillet");
Standard_Boolean gd1,gd2,gf1,gf2, maybesingular;
Handle(BRepBlend_Line) lin;
TopAbs_Orientation Or = S1->ChangeSurface().Face().Orientation();
TopAbs_Orientation Or = S1->Face().Orientation();
Standard_Real PFirst = First;
if(intf) First = fsp->FirstParameter(1);
if(intl) Last = fsp->LastParameter(fsp->NbEdges());
@@ -1332,16 +1332,16 @@ ChFi3d_FilBuilder::PerformSurf(ChFiDS_SequenceOfSurfData& SeqData,
//=======================================================================
void ChFi3d_FilBuilder::PerformSurf(ChFiDS_SequenceOfSurfData& SeqData,
const Handle(ChFiDS_HElSpine)& HGuide,
const Handle(ChFiDS_ElSpine)& HGuide,
const Handle(ChFiDS_Spine)& Spine,
const Standard_Integer Choix,
const Handle(BRepAdaptor_HSurface)& HS1,
const Handle(BRepAdaptor_Surface)& HS1,
const Handle(Adaptor3d_TopolTool)& I1,
const Handle(BRepAdaptor_HCurve2d)& PC1,
const Handle(BRepAdaptor_HSurface)& HSref1,
const Handle(BRepAdaptor_HCurve2d)& PCref1,
const Handle(BRepAdaptor_Curve2d)& PC1,
const Handle(BRepAdaptor_Surface)& HSref1,
const Handle(BRepAdaptor_Curve2d)& PCref1,
Standard_Boolean& Decroch1,
const Handle(BRepAdaptor_HSurface)& HS2,
const Handle(BRepAdaptor_Surface)& HS2,
const Handle(Adaptor3d_TopolTool)& I2,
const TopAbs_Orientation Or2,
const Standard_Real MaxStep,
@@ -1367,8 +1367,8 @@ void ChFi3d_FilBuilder::PerformSurf(ChFiDS_SequenceOfSurfData& SeqData
if(fsp->IsConstant()){
BRepBlend_SurfRstConstRad func(HS2,HS1,PC1,HGuide);
func.Set(HSref1,PCref1);
Handle(Adaptor3d_HCurveOnSurface) HC = new Adaptor3d_HCurveOnSurface();
HC->ChangeCurve().Load(PC1, HS1);
Handle(Adaptor3d_CurveOnSurface) HC = new Adaptor3d_CurveOnSurface();
HC->Load(PC1, HS1);
BRepBlend_SurfCurvConstRadInv finvc(HS2,HC,HGuide);
BRepBlend_SurfPointConstRadInv finvp(HS2,HGuide);
BRepBlend_ConstRadInv finv(HS2,HSref1,HGuide);
@@ -1392,7 +1392,7 @@ void ChFi3d_FilBuilder::PerformSurf(ChFiDS_SequenceOfSurfData& SeqData
Spine->SetErrorStatus(ChFiDS_WalkingFailure);
throw Standard_Failure("PerformSurf : Failed processing!");
}
TopAbs_Orientation Or = HS2->ChangeSurface().Face().Orientation();
TopAbs_Orientation Or = HS2->Face().Orientation();
done = CompleteData(Data,func,lin,HS1,HS2,Or,1);
if(!done) throw Standard_Failure("PerformSurf : Failed approximation!");
maybesingular = (func.GetMinimalDistance()<=100*tolapp3d);
@@ -1400,8 +1400,8 @@ void ChFi3d_FilBuilder::PerformSurf(ChFiDS_SequenceOfSurfData& SeqData
else {
BRepBlend_SurfRstEvolRad func(HS2,HS1,PC1,HGuide,fsp->Law(HGuide));
func.Set(HSref1,PCref1);
Handle(Adaptor3d_HCurveOnSurface) HC = new Adaptor3d_HCurveOnSurface();
HC->ChangeCurve().Load(PC1, HS1);
Handle(Adaptor3d_CurveOnSurface) HC = new Adaptor3d_CurveOnSurface();
HC->Load(PC1, HS1);
BRepBlend_SurfCurvEvolRadInv finvc(HS2,HC,HGuide,fsp->Law(HGuide));
BRepBlend_SurfPointEvolRadInv finvp(HS2,HGuide,fsp->Law(HGuide));
BRepBlend_EvolRadInv finv(HS2,HSref1,HGuide,fsp->Law(HGuide));
@@ -1422,7 +1422,7 @@ void ChFi3d_FilBuilder::PerformSurf(ChFiDS_SequenceOfSurfData& SeqData
Spine->SetErrorStatus(ChFiDS_WalkingFailure);
throw Standard_Failure("PerformSurf : Failed processing!");
}
TopAbs_Orientation Or = HS2->ChangeSurface().Face().Orientation();
TopAbs_Orientation Or = HS2->Face().Orientation();
done = CompleteData(Data,func,lin,HS1,HS2,Or,1);
if(!done) throw Standard_Failure("PerformSurf : Failed approximation!");
maybesingular = (func.GetMinimalDistance()<=100*tolapp3d);
@@ -1436,17 +1436,17 @@ void ChFi3d_FilBuilder::PerformSurf(ChFiDS_SequenceOfSurfData& SeqData
//=======================================================================
void ChFi3d_FilBuilder::PerformSurf(ChFiDS_SequenceOfSurfData& SeqData,
const Handle(ChFiDS_HElSpine)& HGuide,
const Handle(ChFiDS_ElSpine)& HGuide,
const Handle(ChFiDS_Spine)& Spine,
const Standard_Integer Choix,
const Handle(BRepAdaptor_HSurface)& HS1,
const Handle(BRepAdaptor_Surface)& HS1,
const Handle(Adaptor3d_TopolTool)& I1,
const TopAbs_Orientation Or1,
const Handle(BRepAdaptor_HSurface)& HS2,
const Handle(BRepAdaptor_Surface)& HS2,
const Handle(Adaptor3d_TopolTool)& I2,
const Handle(BRepAdaptor_HCurve2d)& PC2,
const Handle(BRepAdaptor_HSurface)& HSref2,
const Handle(BRepAdaptor_HCurve2d)& PCref2,
const Handle(BRepAdaptor_Curve2d)& PC2,
const Handle(BRepAdaptor_Surface)& HSref2,
const Handle(BRepAdaptor_Curve2d)& PCref2,
Standard_Boolean& Decroch2,
const Standard_Real MaxStep,
const Standard_Real Fleche,
@@ -1471,8 +1471,8 @@ void ChFi3d_FilBuilder::PerformSurf(ChFiDS_SequenceOfSurfData& SeqData
if(fsp->IsConstant()){
BRepBlend_SurfRstConstRad func(HS1,HS2,PC2,HGuide);
func.Set(HSref2,PCref2);
Handle(Adaptor3d_HCurveOnSurface) HC = new Adaptor3d_HCurveOnSurface();
HC->ChangeCurve().Load(PC2, HS2);
Handle(Adaptor3d_CurveOnSurface) HC = new Adaptor3d_CurveOnSurface();
HC->Load(PC2, HS2);
BRepBlend_SurfCurvConstRadInv finvc(HS1,HC,HGuide);
BRepBlend_SurfPointConstRadInv finvp(HS1,HGuide);
BRepBlend_ConstRadInv finv(HS1,HSref2,HGuide);
@@ -1496,7 +1496,7 @@ void ChFi3d_FilBuilder::PerformSurf(ChFiDS_SequenceOfSurfData& SeqData
Spine->SetErrorStatus(ChFiDS_WalkingFailure);
throw Standard_Failure("PerformSurf : Failed processing!");
}
TopAbs_Orientation Or = HS1->ChangeSurface().Face().Orientation();
TopAbs_Orientation Or = HS1->Face().Orientation();
done = CompleteData(Data,func,lin,HS1,HS2,Or,0);
if(!done) throw Standard_Failure("PerformSurf : Failed approximation!");
maybesingular = (func.GetMinimalDistance()<=100*tolapp3d);
@@ -1504,8 +1504,8 @@ void ChFi3d_FilBuilder::PerformSurf(ChFiDS_SequenceOfSurfData& SeqData
else {
BRepBlend_SurfRstEvolRad func(HS1,HS2,PC2,HGuide,fsp->Law(HGuide));
func.Set(HSref2,PCref2);
Handle(Adaptor3d_HCurveOnSurface) HC = new Adaptor3d_HCurveOnSurface();
HC->ChangeCurve().Load(PC2, HS2);
Handle(Adaptor3d_CurveOnSurface) HC = new Adaptor3d_CurveOnSurface();
HC->Load(PC2, HS2);
BRepBlend_SurfCurvEvolRadInv finvc(HS1,HC,HGuide,fsp->Law(HGuide));
BRepBlend_SurfPointEvolRadInv finvp(HS1,HGuide,fsp->Law(HGuide));
BRepBlend_EvolRadInv finv(HS1,HSref2,HGuide,fsp->Law(HGuide));
@@ -1527,7 +1527,7 @@ void ChFi3d_FilBuilder::PerformSurf(ChFiDS_SequenceOfSurfData& SeqData
Spine->SetErrorStatus(ChFiDS_WalkingFailure);
throw Standard_Failure("PerformSurf : Failed processing!");
}
TopAbs_Orientation Or = HS1->ChangeSurface().Face().Orientation();
TopAbs_Orientation Or = HS1->Face().Orientation();
done = CompleteData(Data,func,lin,HS1,HS2,Or,0);
if(!done) throw Standard_Failure("PerformSurf : Failed approximation!");
maybesingular = (func.GetMinimalDistance()<=100*tolapp3d);
@@ -1546,21 +1546,21 @@ void ChFi3d_FilBuilder::PerformSurf(ChFiDS_SequenceOfSurfData& SeqData
//=======================================================================
void ChFi3d_FilBuilder::PerformSurf(ChFiDS_SequenceOfSurfData& SeqData,
const Handle(ChFiDS_HElSpine)& HGuide,
const Handle(ChFiDS_ElSpine)& HGuide,
const Handle(ChFiDS_Spine)& Spine,
const Standard_Integer Choix,
const Handle(BRepAdaptor_HSurface)& HS1,
const Handle(BRepAdaptor_Surface)& HS1,
const Handle(Adaptor3d_TopolTool)& I1,
const Handle(BRepAdaptor_HCurve2d)& PC1,
const Handle(BRepAdaptor_HSurface)& HSref1,
const Handle(BRepAdaptor_HCurve2d)& PCref1,
const Handle(BRepAdaptor_Curve2d)& PC1,
const Handle(BRepAdaptor_Surface)& HSref1,
const Handle(BRepAdaptor_Curve2d)& PCref1,
Standard_Boolean& Decroch1,
const TopAbs_Orientation Or1,
const Handle(BRepAdaptor_HSurface)& HS2,
const Handle(BRepAdaptor_Surface)& HS2,
const Handle(Adaptor3d_TopolTool)& I2,
const Handle(BRepAdaptor_HCurve2d)& PC2,
const Handle(BRepAdaptor_HSurface)& HSref2,
const Handle(BRepAdaptor_HCurve2d)& PCref2,
const Handle(BRepAdaptor_Curve2d)& PC2,
const Handle(BRepAdaptor_Surface)& HSref2,
const Handle(BRepAdaptor_Curve2d)& PCref2,
Standard_Boolean& Decroch2,
const TopAbs_Orientation Or2,
const Standard_Real MaxStep,
@@ -1587,10 +1587,10 @@ void ChFi3d_FilBuilder::PerformSurf(ChFiDS_SequenceOfSurfData& SeqData
if(fsp->IsConstant()){
BRepBlend_RstRstConstRad func(HS1, PC1, HS2, PC2, HGuide);
func.Set(HSref1, PCref1, HSref2, PCref2);
Handle(Adaptor3d_HCurveOnSurface) HC1 = new Adaptor3d_HCurveOnSurface();
HC1->ChangeCurve().Load(PC1, HS1);
Handle(Adaptor3d_HCurveOnSurface) HC2 = new Adaptor3d_HCurveOnSurface();
HC2->ChangeCurve().Load(PC2, HS2);
Handle(Adaptor3d_CurveOnSurface) HC1 = new Adaptor3d_CurveOnSurface();
HC1->Load(PC1, HS1);
Handle(Adaptor3d_CurveOnSurface) HC2 = new Adaptor3d_CurveOnSurface();
HC2->Load(PC2, HS2);
BRepBlend_SurfCurvConstRadInv finv1(HSref1, HC2, HGuide);
BRepBlend_CurvPointRadInv finvp1(HGuide, HC2);
BRepBlend_SurfCurvConstRadInv finv2(HSref2, HC1, HGuide);
@@ -1619,7 +1619,7 @@ void ChFi3d_FilBuilder::PerformSurf(ChFiDS_SequenceOfSurfData& SeqData
Spine->SetErrorStatus(ChFiDS_WalkingFailure);
throw Standard_Failure("PerformSurf : Failed processing!");
}
TopAbs_Orientation Or = HS1->ChangeSurface().Face().Orientation();
TopAbs_Orientation Or = HS1->Face().Orientation();
done = CompleteData(Data, func, lin, HS1, HS2, Or);
if(!done) throw Standard_Failure("PerformSurf : Failed approximation!");
maybesingular = (func.GetMinimalDistance()<=100*tolapp3d);
@@ -1627,10 +1627,10 @@ void ChFi3d_FilBuilder::PerformSurf(ChFiDS_SequenceOfSurfData& SeqData
else {
BRepBlend_RstRstEvolRad func(HS1,PC1, HS2, PC2, HGuide, fsp->Law(HGuide));
func.Set(HSref1, PCref1, HSref2, PCref2);
Handle(Adaptor3d_HCurveOnSurface) HC1 = new Adaptor3d_HCurveOnSurface();
HC1->ChangeCurve().Load(PC1, HS1);
Handle(Adaptor3d_HCurveOnSurface) HC2 = new Adaptor3d_HCurveOnSurface();
HC2->ChangeCurve().Load(PC2, HS2);
Handle(Adaptor3d_CurveOnSurface) HC1 = new Adaptor3d_CurveOnSurface();
HC1->Load(PC1, HS1);
Handle(Adaptor3d_CurveOnSurface) HC2 = new Adaptor3d_CurveOnSurface();
HC2->Load(PC2, HS2);
BRepBlend_SurfCurvEvolRadInv finv1(HSref1, HC2, HGuide, fsp->Law(HGuide));
BRepBlend_CurvPointRadInv finvp1(HGuide, HC2);
@@ -1662,7 +1662,7 @@ void ChFi3d_FilBuilder::PerformSurf(ChFiDS_SequenceOfSurfData& SeqData
Spine->SetErrorStatus(ChFiDS_WalkingFailure);
throw Standard_Failure("PerformSurf : Failed processing!");
}
TopAbs_Orientation Or = HS1->ChangeSurface().Face().Orientation();
TopAbs_Orientation Or = HS1->Face().Orientation();
done = CompleteData(Data, func, lin, HS1, HS2, Or);
if(!done) throw Standard_Failure("PerformSurf : Failed approximation!");
maybesingular = (func.GetMinimalDistance()<=100*tolapp3d);

49
src/ChFi3d/ChFi3d_FilBuilder.hxx
View File

@@ -17,36 +17,29 @@
#ifndef _ChFi3d_FilBuilder_HeaderFile
#define _ChFi3d_FilBuilder_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <BRepAdaptor_Curve2d.hxx>
#include <BRepAdaptor_Surface.hxx>
#include <BlendFunc_SectionShape.hxx>
#include <ChFi3d_Builder.hxx>
#include <ChFi3d_FilletShape.hxx>
#include <Standard_Real.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Boolean.hxx>
#include <ChFiDS_ListOfStripe.hxx>
#include <ChFiDS_ElSpine.hxx>
#include <ChFiDS_SecHArray1.hxx>
#include <ChFiDS_SequenceOfSurfData.hxx>
#include <math_Vector.hxx>
#include <TopAbs_Orientation.hxx>
#include <TopAbs_State.hxx>
#include <ChFiDS_SequenceOfSurfData.hxx>
#include <ChFiDS_ListOfStripe.hxx>
class TopoDS_Shape;
class TopoDS_Edge;
class Law_Function;
class TopoDS_Vertex;
class Adaptor3d_TopolTool;
class BRepBlend_Line;
class gp_XY;
class ChFiDS_SurfData;
class ChFiDS_HElSpine;
class ChFiDS_Spine;
class BRepAdaptor_HSurface;
class Adaptor3d_TopolTool;
class BRepAdaptor_HCurve2d;
class BRepBlend_Line;
class ChFiDS_Stripe;
class Law_Function;
class TopoDS_Edge;
class TopoDS_Shape;
class TopoDS_Vertex;
//! Tool of construction of fillets 3d on edges (on a solid).
class ChFi3d_FilBuilder : public ChFi3d_Builder
@@ -136,25 +129,25 @@ protected:
Standard_EXPORT void SimulKPart (const Handle(ChFiDS_SurfData)& SD) const Standard_OVERRIDE;
Standard_EXPORT Standard_Boolean SimulSurf (Handle(ChFiDS_SurfData)& Data, const Handle(ChFiDS_HElSpine)& Guide, const Handle(ChFiDS_Spine)& Spine, const Standard_Integer Choix, const Handle(BRepAdaptor_HSurface)& S1, const Handle(Adaptor3d_TopolTool)& I1, const Handle(BRepAdaptor_HSurface)& S2, const Handle(Adaptor3d_TopolTool)& I2, const Standard_Real TolGuide, Standard_Real& First, Standard_Real& Last, const Standard_Boolean Inside, const Standard_Boolean Appro, const Standard_Boolean Forward, const Standard_Boolean RecOnS1, const Standard_Boolean RecOnS2, const math_Vector& Soldep, Standard_Integer& Intf, Standard_Integer& Intl) Standard_OVERRIDE;
Standard_EXPORT Standard_Boolean SimulSurf (Handle(ChFiDS_SurfData)& Data, const Handle(ChFiDS_ElSpine)& Guide, const Handle(ChFiDS_Spine)& Spine, const Standard_Integer Choix, const Handle(BRepAdaptor_Surface)& S1, const Handle(Adaptor3d_TopolTool)& I1, const Handle(BRepAdaptor_Surface)& S2, const Handle(Adaptor3d_TopolTool)& I2, const Standard_Real TolGuide, Standard_Real& First, Standard_Real& Last, const Standard_Boolean Inside, const Standard_Boolean Appro, const Standard_Boolean Forward, const Standard_Boolean RecOnS1, const Standard_Boolean RecOnS2, const math_Vector& Soldep, Standard_Integer& Intf, Standard_Integer& Intl) Standard_OVERRIDE;
Standard_EXPORT virtual void SimulSurf (Handle(ChFiDS_SurfData)& Data, const Handle(ChFiDS_HElSpine)& Guide, const Handle(ChFiDS_Spine)& Spine, const Standard_Integer Choix, const Handle(BRepAdaptor_HSurface)& S1, const Handle(Adaptor3d_TopolTool)& I1, const Handle(BRepAdaptor_HCurve2d)& PC1, const Handle(BRepAdaptor_HSurface)& Sref1, const Handle(BRepAdaptor_HCurve2d)& PCref1, Standard_Boolean& Decroch1, const Handle(BRepAdaptor_HSurface)& S2, const Handle(Adaptor3d_TopolTool)& I2, const TopAbs_Orientation Or2, const Standard_Real Fleche, const Standard_Real TolGuide, Standard_Real& First, Standard_Real& Last, const Standard_Boolean Inside, const Standard_Boolean Appro, const Standard_Boolean Forward, const Standard_Boolean RecP, const Standard_Boolean RecS, const Standard_Boolean RecRst, const math_Vector& Soldep) Standard_OVERRIDE;
Standard_EXPORT virtual void SimulSurf (Handle(ChFiDS_SurfData)& Data, const Handle(ChFiDS_ElSpine)& Guide, const Handle(ChFiDS_Spine)& Spine, const Standard_Integer Choix, const Handle(BRepAdaptor_Surface)& S1, const Handle(Adaptor3d_TopolTool)& I1, const Handle(BRepAdaptor_Curve2d)& PC1, const Handle(BRepAdaptor_Surface)& Sref1, const Handle(BRepAdaptor_Curve2d)& PCref1, Standard_Boolean& Decroch1, const Handle(BRepAdaptor_Surface)& S2, const Handle(Adaptor3d_TopolTool)& I2, const TopAbs_Orientation Or2, const Standard_Real Fleche, const Standard_Real TolGuide, Standard_Real& First, Standard_Real& Last, const Standard_Boolean Inside, const Standard_Boolean Appro, const Standard_Boolean Forward, const Standard_Boolean RecP, const Standard_Boolean RecS, const Standard_Boolean RecRst, const math_Vector& Soldep) Standard_OVERRIDE;
Standard_EXPORT virtual void SimulSurf (Handle(ChFiDS_SurfData)& Data, const Handle(ChFiDS_HElSpine)& Guide, const Handle(ChFiDS_Spine)& Spine, const Standard_Integer Choix, const Handle(BRepAdaptor_HSurface)& S1, const Handle(Adaptor3d_TopolTool)& I1, const TopAbs_Orientation Or1, const Handle(BRepAdaptor_HSurface)& S2, const Handle(Adaptor3d_TopolTool)& I2, const Handle(BRepAdaptor_HCurve2d)& PC2, const Handle(BRepAdaptor_HSurface)& Sref2, const Handle(BRepAdaptor_HCurve2d)& PCref2, Standard_Boolean& Decroch2, const Standard_Real Fleche, const Standard_Real TolGuide, Standard_Real& First, Standard_Real& Last, const Standard_Boolean Inside, const Standard_Boolean Appro, const Standard_Boolean Forward, const Standard_Boolean RecP, const Standard_Boolean RecS, const Standard_Boolean RecRst, const math_Vector& Soldep) Standard_OVERRIDE;
Standard_EXPORT virtual void SimulSurf (Handle(ChFiDS_SurfData)& Data, const Handle(ChFiDS_ElSpine)& Guide, const Handle(ChFiDS_Spine)& Spine, const Standard_Integer Choix, const Handle(BRepAdaptor_Surface)& S1, const Handle(Adaptor3d_TopolTool)& I1, const TopAbs_Orientation Or1, const Handle(BRepAdaptor_Surface)& S2, const Handle(Adaptor3d_TopolTool)& I2, const Handle(BRepAdaptor_Curve2d)& PC2, const Handle(BRepAdaptor_Surface)& Sref2, const Handle(BRepAdaptor_Curve2d)& PCref2, Standard_Boolean& Decroch2, const Standard_Real Fleche, const Standard_Real TolGuide, Standard_Real& First, Standard_Real& Last, const Standard_Boolean Inside, const Standard_Boolean Appro, const Standard_Boolean Forward, const Standard_Boolean RecP, const Standard_Boolean RecS, const Standard_Boolean RecRst, const math_Vector& Soldep) Standard_OVERRIDE;
Standard_EXPORT virtual void SimulSurf (Handle(ChFiDS_SurfData)& Data, const Handle(ChFiDS_HElSpine)& Guide, const Handle(ChFiDS_Spine)& Spine, const Standard_Integer Choix, const Handle(BRepAdaptor_HSurface)& S1, const Handle(Adaptor3d_TopolTool)& I1, const Handle(BRepAdaptor_HCurve2d)& PC1, const Handle(BRepAdaptor_HSurface)& Sref1, const Handle(BRepAdaptor_HCurve2d)& PCref1, Standard_Boolean& Decroch1, const TopAbs_Orientation Or1, const Handle(BRepAdaptor_HSurface)& S2, const Handle(Adaptor3d_TopolTool)& I2, const Handle(BRepAdaptor_HCurve2d)& PC2, const Handle(BRepAdaptor_HSurface)& Sref2, const Handle(BRepAdaptor_HCurve2d)& PCref2, Standard_Boolean& Decroch2, const TopAbs_Orientation Or2, const Standard_Real Fleche, const Standard_Real TolGuide, Standard_Real& First, Standard_Real& Last, const Standard_Boolean Inside, const Standard_Boolean Appro, const Standard_Boolean Forward, const Standard_Boolean RecP1, const Standard_Boolean RecRst1, const Standard_Boolean RecP2, const Standard_Boolean RecRst2, const math_Vector& Soldep) Standard_OVERRIDE;
Standard_EXPORT virtual void SimulSurf (Handle(ChFiDS_SurfData)& Data, const Handle(ChFiDS_ElSpine)& Guide, const Handle(ChFiDS_Spine)& Spine, const Standard_Integer Choix, const Handle(BRepAdaptor_Surface)& S1, const Handle(Adaptor3d_TopolTool)& I1, const Handle(BRepAdaptor_Curve2d)& PC1, const Handle(BRepAdaptor_Surface)& Sref1, const Handle(BRepAdaptor_Curve2d)& PCref1, Standard_Boolean& Decroch1, const TopAbs_Orientation Or1, const Handle(BRepAdaptor_Surface)& S2, const Handle(Adaptor3d_TopolTool)& I2, const Handle(BRepAdaptor_Curve2d)& PC2, const Handle(BRepAdaptor_Surface)& Sref2, const Handle(BRepAdaptor_Curve2d)& PCref2, Standard_Boolean& Decroch2, const TopAbs_Orientation Or2, const Standard_Real Fleche, const Standard_Real TolGuide, Standard_Real& First, Standard_Real& Last, const Standard_Boolean Inside, const Standard_Boolean Appro, const Standard_Boolean Forward, const Standard_Boolean RecP1, const Standard_Boolean RecRst1, const Standard_Boolean RecP2, const Standard_Boolean RecRst2, const math_Vector& Soldep) Standard_OVERRIDE;
Standard_EXPORT Standard_Boolean PerformFirstSection (const Handle(ChFiDS_Spine)& S, const Handle(ChFiDS_HElSpine)& HGuide, const Standard_Integer Choix, Handle(BRepAdaptor_HSurface)& S1, Handle(BRepAdaptor_HSurface)& S2, const Handle(Adaptor3d_TopolTool)& I1, const Handle(Adaptor3d_TopolTool)& I2, const Standard_Real Par, math_Vector& SolDep, TopAbs_State& Pos1, TopAbs_State& Pos2) const Standard_OVERRIDE;
Standard_EXPORT Standard_Boolean PerformFirstSection (const Handle(ChFiDS_Spine)& S, const Handle(ChFiDS_ElSpine)& HGuide, const Standard_Integer Choix, Handle(BRepAdaptor_Surface)& S1, Handle(BRepAdaptor_Surface)& S2, const Handle(Adaptor3d_TopolTool)& I1, const Handle(Adaptor3d_TopolTool)& I2, const Standard_Real Par, math_Vector& SolDep, TopAbs_State& Pos1, TopAbs_State& Pos2) const Standard_OVERRIDE;
//! Method calculates the elements of construction of the
//! fillet (constant or evolutive).
Standard_EXPORT Standard_Boolean PerformSurf (ChFiDS_SequenceOfSurfData& SeqData, const Handle(ChFiDS_HElSpine)& Guide, const Handle(ChFiDS_Spine)& Spine, const Standard_Integer Choix, const Handle(BRepAdaptor_HSurface)& S1, const Handle(Adaptor3d_TopolTool)& I1, const Handle(BRepAdaptor_HSurface)& S2, const Handle(Adaptor3d_TopolTool)& I2, const Standard_Real MaxStep, const Standard_Real Fleche, const Standard_Real TolGuide, Standard_Real& First, Standard_Real& Last, const Standard_Boolean Inside, const Standard_Boolean Appro, const Standard_Boolean Forward, const Standard_Boolean RecOnS1, const Standard_Boolean RecOnS2, const math_Vector& Soldep, Standard_Integer& Intf, Standard_Integer& Intl) Standard_OVERRIDE;
Standard_EXPORT Standard_Boolean PerformSurf (ChFiDS_SequenceOfSurfData& SeqData, const Handle(ChFiDS_ElSpine)& Guide, const Handle(ChFiDS_Spine)& Spine, const Standard_Integer Choix, const Handle(BRepAdaptor_Surface)& S1, const Handle(Adaptor3d_TopolTool)& I1, const Handle(BRepAdaptor_Surface)& S2, const Handle(Adaptor3d_TopolTool)& I2, const Standard_Real MaxStep, const Standard_Real Fleche, const Standard_Real TolGuide, Standard_Real& First, Standard_Real& Last, const Standard_Boolean Inside, const Standard_Boolean Appro, const Standard_Boolean Forward, const Standard_Boolean RecOnS1, const Standard_Boolean RecOnS2, const math_Vector& Soldep, Standard_Integer& Intf, Standard_Integer& Intl) Standard_OVERRIDE;
Standard_EXPORT virtual void PerformSurf (ChFiDS_SequenceOfSurfData& SeqData, const Handle(ChFiDS_HElSpine)& Guide, const Handle(ChFiDS_Spine)& Spine, const Standard_Integer Choix, const Handle(BRepAdaptor_HSurface)& S1, const Handle(Adaptor3d_TopolTool)& I1, const Handle(BRepAdaptor_HCurve2d)& PC1, const Handle(BRepAdaptor_HSurface)& Sref1, const Handle(BRepAdaptor_HCurve2d)& PCref1, Standard_Boolean& Decroch1, const Handle(BRepAdaptor_HSurface)& S2, const Handle(Adaptor3d_TopolTool)& I2, const TopAbs_Orientation Or2, const Standard_Real MaxStep, const Standard_Real Fleche, const Standard_Real TolGuide, Standard_Real& First, Standard_Real& Last, const Standard_Boolean Inside, const Standard_Boolean Appro, const Standard_Boolean Forward, const Standard_Boolean RecP, const Standard_Boolean RecS, const Standard_Boolean RecRst, const math_Vector& Soldep) Standard_OVERRIDE;
Standard_EXPORT virtual void PerformSurf (ChFiDS_SequenceOfSurfData& SeqData, const Handle(ChFiDS_ElSpine)& Guide, const Handle(ChFiDS_Spine)& Spine, const Standard_Integer Choix, const Handle(BRepAdaptor_Surface)& S1, const Handle(Adaptor3d_TopolTool)& I1, const Handle(BRepAdaptor_Curve2d)& PC1, const Handle(BRepAdaptor_Surface)& Sref1, const Handle(BRepAdaptor_Curve2d)& PCref1, Standard_Boolean& Decroch1, const Handle(BRepAdaptor_Surface)& S2, const Handle(Adaptor3d_TopolTool)& I2, const TopAbs_Orientation Or2, const Standard_Real MaxStep, const Standard_Real Fleche, const Standard_Real TolGuide, Standard_Real& First, Standard_Real& Last, const Standard_Boolean Inside, const Standard_Boolean Appro, const Standard_Boolean Forward, const Standard_Boolean RecP, const Standard_Boolean RecS, const Standard_Boolean RecRst, const math_Vector& Soldep) Standard_OVERRIDE;
Standard_EXPORT virtual void PerformSurf (ChFiDS_SequenceOfSurfData& SeqData, const Handle(ChFiDS_HElSpine)& Guide, const Handle(ChFiDS_Spine)& Spine, const Standard_Integer Choix, const Handle(BRepAdaptor_HSurface)& S1, const Handle(Adaptor3d_TopolTool)& I1, const TopAbs_Orientation Or1, const Handle(BRepAdaptor_HSurface)& S2, const Handle(Adaptor3d_TopolTool)& I2, const Handle(BRepAdaptor_HCurve2d)& PC2, const Handle(BRepAdaptor_HSurface)& Sref2, const Handle(BRepAdaptor_HCurve2d)& PCref2, Standard_Boolean& Decroch2, const Standard_Real MaxStep, const Standard_Real Fleche, const Standard_Real TolGuide, Standard_Real& First, Standard_Real& Last, const Standard_Boolean Inside, const Standard_Boolean Appro, const Standard_Boolean Forward, const Standard_Boolean RecP, const Standard_Boolean RecS, const Standard_Boolean RecRst, const math_Vector& Soldep) Standard_OVERRIDE;
Standard_EXPORT virtual void PerformSurf (ChFiDS_SequenceOfSurfData& SeqData, const Handle(ChFiDS_ElSpine)& Guide, const Handle(ChFiDS_Spine)& Spine, const Standard_Integer Choix, const Handle(BRepAdaptor_Surface)& S1, const Handle(Adaptor3d_TopolTool)& I1, const TopAbs_Orientation Or1, const Handle(BRepAdaptor_Surface)& S2, const Handle(Adaptor3d_TopolTool)& I2, const Handle(BRepAdaptor_Curve2d)& PC2, const Handle(BRepAdaptor_Surface)& Sref2, const Handle(BRepAdaptor_Curve2d)& PCref2, Standard_Boolean& Decroch2, const Standard_Real MaxStep, const Standard_Real Fleche, const Standard_Real TolGuide, Standard_Real& First, Standard_Real& Last, const Standard_Boolean Inside, const Standard_Boolean Appro, const Standard_Boolean Forward, const Standard_Boolean RecP, const Standard_Boolean RecS, const Standard_Boolean RecRst, const math_Vector& Soldep) Standard_OVERRIDE;
Standard_EXPORT virtual void PerformSurf (ChFiDS_SequenceOfSurfData& Data, const Handle(ChFiDS_HElSpine)& Guide, const Handle(ChFiDS_Spine)& Spine, const Standard_Integer Choix, const Handle(BRepAdaptor_HSurface)& S1, const Handle(Adaptor3d_TopolTool)& I1, const Handle(BRepAdaptor_HCurve2d)& PC1, const Handle(BRepAdaptor_HSurface)& Sref1, const Handle(BRepAdaptor_HCurve2d)& PCref1, Standard_Boolean& Decroch1, const TopAbs_Orientation Or1, const Handle(BRepAdaptor_HSurface)& S2, const Handle(Adaptor3d_TopolTool)& I2, const Handle(BRepAdaptor_HCurve2d)& PC2, const Handle(BRepAdaptor_HSurface)& Sref2, const Handle(BRepAdaptor_HCurve2d)& PCref2, Standard_Boolean& Decroch2, const TopAbs_Orientation Or2, const Standard_Real MaxStep, const Standard_Real Fleche, const Standard_Real TolGuide, Standard_Real& First, Standard_Real& Last, const Standard_Boolean Inside, const Standard_Boolean Appro, const Standard_Boolean Forward, const Standard_Boolean RecP1, const Standard_Boolean RecRst1, const Standard_Boolean RecP2, const Standard_Boolean RecRst2, const math_Vector& Soldep) Standard_OVERRIDE;
Standard_EXPORT virtual void PerformSurf (ChFiDS_SequenceOfSurfData& Data, const Handle(ChFiDS_ElSpine)& Guide, const Handle(ChFiDS_Spine)& Spine, const Standard_Integer Choix, const Handle(BRepAdaptor_Surface)& S1, const Handle(Adaptor3d_TopolTool)& I1, const Handle(BRepAdaptor_Curve2d)& PC1, const Handle(BRepAdaptor_Surface)& Sref1, const Handle(BRepAdaptor_Curve2d)& PCref1, Standard_Boolean& Decroch1, const TopAbs_Orientation Or1, const Handle(BRepAdaptor_Surface)& S2, const Handle(Adaptor3d_TopolTool)& I2, const Handle(BRepAdaptor_Curve2d)& PC2, const Handle(BRepAdaptor_Surface)& Sref2, const Handle(BRepAdaptor_Curve2d)& PCref2, Standard_Boolean& Decroch2, const TopAbs_Orientation Or2, const Standard_Real MaxStep, const Standard_Real Fleche, const Standard_Real TolGuide, Standard_Real& First, Standard_Real& Last, const Standard_Boolean Inside, const Standard_Boolean Appro, const Standard_Boolean Forward, const Standard_Boolean RecP1, const Standard_Boolean RecRst1, const Standard_Boolean RecP2, const Standard_Boolean RecRst2, const math_Vector& Soldep) Standard_OVERRIDE;
//! Method to split an singular SurfData in several non
//! singular SurfData..

49
src/ChFi3d/ChFi3d_FilBuilder_C2.cxx
View File

@@ -16,14 +16,14 @@
#include <Adaptor3d_CurveOnSurface.hxx>
#include <Adaptor3d_HCurveOnSurface.hxx>
#include <Adaptor3d_CurveOnSurface.hxx>
#include <Adaptor3d_TopolTool.hxx>
#include <BRep_Tool.hxx>
#include <BRepAdaptor_Curve.hxx>
#include <BRepAdaptor_Curve2d.hxx>
#include <BRepAdaptor_HCurve.hxx>
#include <BRepAdaptor_HCurve2d.hxx>
#include <BRepAdaptor_HSurface.hxx>
#include <BRepAdaptor_Curve.hxx>
#include <BRepAdaptor_Curve2d.hxx>
#include <BRepAdaptor_Surface.hxx>
#include <BRepAdaptor_Surface.hxx>
#include <BRepBlend_CSCircular.hxx>
#include <BRepBlend_Line.hxx>
@@ -37,7 +37,7 @@
#include <ChFiDS_FaceInterference.hxx>
#include <ChFiDS_FilSpine.hxx>
#include <ChFiDS_HData.hxx>
#include <ChFiDS_HElSpine.hxx>
#include <ChFiDS_ElSpine.hxx>
#include <ChFiDS_ListIteratorOfListOfStripe.hxx>
#include <ChFiDS_Regul.hxx>
#include <ChFiDS_SequenceOfSurfData.hxx>
@@ -49,13 +49,13 @@
#include <Geom2d_BSplineCurve.hxx>
#include <Geom2d_TrimmedCurve.hxx>
#include <Geom2dAdaptor_Curve.hxx>
#include <Geom2dAdaptor_HCurve.hxx>
#include <Geom2dAdaptor_Curve.hxx>
#include <Geom2dConvert.hxx>
#include <Geom_BSplineCurve.hxx>
#include <Geom_BSplineSurface.hxx>
#include <GeomAdaptor_Curve.hxx>
#include <GeomAdaptor_HCurve.hxx>
#include <GeomAdaptor_HSurface.hxx>
#include <GeomAdaptor_Curve.hxx>
#include <GeomAdaptor_Surface.hxx>
#include <GeomAdaptor_Surface.hxx>
#include <GeomFill_ConstrainedFilling.hxx>
#include <GeomFill_SimpleBound.hxx>
@@ -342,25 +342,25 @@ void ChFi3d_FilBuilder::PerformTwoCorner(const Standard_Integer Index)
if(CP1.IsOnArc()&& CP2.IsOnArc()){
yapiv = (pivot.IsSame(CP2.Arc()));
}
Handle(BRepAdaptor_HCurve) Hpivot;
Handle(BRepAdaptor_Curve) Hpivot;
Standard_Boolean sameparam = Standard_False;
Standard_Real parCP1 = 0., parCP2 = 0.;
if(yapiv) {
Hpivot = new BRepAdaptor_HCurve(pivot);
Hpivot = new BRepAdaptor_Curve(pivot);
parCP1 = CP1.ParameterOnArc();
parCP2 = CP2.ParameterOnArc();
gp_Pnt tst1 = Hpivot->Value(parCP1);
gp_Pnt tst2 = Hpivot->Value(parCP2);
sameparam = tst1.Distance(tst2) <= tolesp;
}
Handle(BRepAdaptor_HSurface) HFaCo = new BRepAdaptor_HSurface();
Handle(BRepAdaptor_HSurface) HFaPiv;
Handle(BRepAdaptor_HSurface) HBRS1 = new BRepAdaptor_HSurface();
Handle(BRepAdaptor_HSurface) HBRS2 = new BRepAdaptor_HSurface();
Handle(BRepAdaptor_Surface) HFaCo = new BRepAdaptor_Surface();
Handle(BRepAdaptor_Surface) HFaPiv;
Handle(BRepAdaptor_Surface) HBRS1 = new BRepAdaptor_Surface();
Handle(BRepAdaptor_Surface) HBRS2 = new BRepAdaptor_Surface();
BRepAdaptor_Surface& BRS1 = HBRS1->ChangeSurface();
BRepAdaptor_Surface& BRS2 = HBRS2->ChangeSurface();
BRepAdaptor_Surface& BRFaCo = HFaCo->ChangeSurface();
BRepAdaptor_Surface& BRS1 = *HBRS1;
BRepAdaptor_Surface& BRS2 = *HBRS2;
BRepAdaptor_Surface& BRFaCo = *HFaCo;
BRFaCo.Initialize(FaCo);
TopoDS_Face FF1,FF2,F,FaPiv;
@@ -517,8 +517,7 @@ void ChFi3d_FilBuilder::PerformTwoCorner(const Standard_Integer Index)
fil.Init(Bfac,B2,B1,1);
}
else {
Handle(Adaptor3d_HCurve) HPivTrim = Hpivot->ChangeCurve().
Trim(Min(parCP1,parCP2),Max(parCP1,parCP2),tolesp);
Handle(Adaptor3d_Curve) HPivTrim = Hpivot->Trim(Min(parCP1,parCP2),Max(parCP1,parCP2),tolesp);
Bpiv = new GeomFill_SimpleBound(HPivTrim,tolesp,2.e-4);
fil.Init(Bfac,B2,Bpiv,B1,1);
BRepAdaptor_Curve2d pcpivot;
@@ -761,7 +760,7 @@ void ChFi3d_FilBuilder::PerformTwoCorner(const Standard_Integer Index)
gp_Pnt2d ppcosam =
sdsam->Interference(ifacosam).PCurveOnSurf()->Value(uintpcsam);
Handle(Geom_Surface) surfsam = DStr.Surface(sdsam->Surf()).Surface();
Handle(GeomAdaptor_HSurface) Hsurfsam = new GeomAdaptor_HSurface(surfsam);
Handle(GeomAdaptor_Surface) Hsurfsam = new GeomAdaptor_Surface(surfsam);
Handle(Geom2d_Curve) pcsurfsam;
Bsam = ChFi3d_mkbound(Hsurfsam,pcsurfsam,ppopsam,ppcosam,tolesp,2.e-4);
Standard_Real upcopdif = sddif->Interference(ifaopdif).Parameter(isfirstdif);
@@ -770,7 +769,7 @@ void ChFi3d_FilBuilder::PerformTwoCorner(const Standard_Integer Index)
gp_Pnt2d ppcodif =
sddif->Interference(ifacodif).PCurveOnSurf()->Value(uintpcdif);
Handle(Geom_Surface) surfdif = DStr.Surface(sddif->Surf()).Surface();
Handle(GeomAdaptor_HSurface) Hsurfdif = new GeomAdaptor_HSurface(surfdif);
Handle(GeomAdaptor_Surface) Hsurfdif = new GeomAdaptor_Surface(surfdif);
Handle(Geom2d_Curve) pcsurfdif;
Bdif = ChFi3d_mkbound(Hsurfdif,pcsurfdif,ppcodif,ppopdif,tolesp,2.e-4);
gp_Pnt2d ppfacsam,ppfacdif;
@@ -798,8 +797,8 @@ void ChFi3d_FilBuilder::PerformTwoCorner(const Standard_Integer Index)
//////////////////
BRepAdaptor_Curve CArcFac(Arcopdif);
CArcFac.D1(cpopdif.ParameterOnArc(),PPfacdif,VVfacdif);
Handle(BRepAdaptor_HSurface) HBRFopsam = new BRepAdaptor_HSurface();
BRepAdaptor_Surface& BRFopsam = HBRFopsam->ChangeSurface();
Handle(BRepAdaptor_Surface) HBRFopsam = new BRepAdaptor_Surface();
BRepAdaptor_Surface& BRFopsam = *HBRFopsam;
BRFopsam.Initialize(Fopsam,Standard_False);
Handle(Geom2d_Curve) pcFopsam = ChFi3d_BuildPCurve(HBRFopsam,
ppfacsam,VVfacsam,
@@ -860,7 +859,7 @@ void ChFi3d_FilBuilder::PerformTwoCorner(const Standard_Integer Index)
corner->ChangeFirstPCurve(),P1deb,P2deb,
tolesp,tol2d,tolreached,0);
Standard_Real tolr1;
Handle(GeomAdaptor_HCurve) HC3d = new GeomAdaptor_HCurve(C3d);
Handle(GeomAdaptor_Curve) HC3d = new GeomAdaptor_Curve(C3d);
ChFi3d_SameParameter(HC3d,pcFopsam,HBRFopsam,tolesp,tolr1);
tolreached = Max(tolreached,tolr1);
TopOpeBRepDS_Curve Tcurv1(C3d,tolreached);
@@ -891,7 +890,7 @@ void ChFi3d_FilBuilder::PerformTwoCorner(const Standard_Integer Index)
corner->ChangeLastPCurve(),P1fin,P2fin,
tolesp,tol2d,tolreached,0);
Standard_Real tolr2;
HC3d->ChangeCurve().Load(C3d);
HC3d->Load(C3d);
ChFi3d_SameParameter(HC3d,pcsurfdif,Hsurfdif,tolesp,tolr2);
tolreached = Max(tolreached,tolr2);
TopOpeBRepDS_Curve Tcurv2(C3d,tolreached);

32
src/ChFi3d/ChFi3d_FilBuilder_C3.cxx
View File

@@ -16,12 +16,12 @@
#include <Adaptor3d_CurveOnSurface.hxx>
#include <Adaptor3d_HSurface.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor3d_TopolTool.hxx>
#include <BRepAdaptor_Curve.hxx>
#include <BRepAdaptor_HCurve.hxx>
#include <BRepAdaptor_HCurve2d.hxx>
#include <BRepAdaptor_HSurface.hxx>
#include <BRepAdaptor_Curve.hxx>
#include <BRepAdaptor_Curve2d.hxx>
#include <BRepAdaptor_Surface.hxx>
#include <BRepAdaptor_Surface.hxx>
#include <BRepBlend_ConstRad.hxx>
#include <BRepBlend_ConstRadInv.hxx>
@@ -35,7 +35,7 @@
#include <ChFiDS_CommonPoint.hxx>
#include <ChFiDS_FaceInterference.hxx>
#include <ChFiDS_HData.hxx>
#include <ChFiDS_HElSpine.hxx>
#include <ChFiDS_ElSpine.hxx>
#include <ChFiDS_ListIteratorOfListOfStripe.hxx>
#include <ChFiDS_Regul.hxx>
#include <ChFiDS_SequenceOfSurfData.hxx>
@@ -50,14 +50,14 @@
#include <Geom2d_Line.hxx>
#include <Geom2d_TrimmedCurve.hxx>
#include <Geom2dAdaptor_Curve.hxx>
#include <Geom2dAdaptor_HCurve.hxx>
#include <Geom2dAdaptor_Curve.hxx>
#include <Geom_BezierCurve.hxx>
#include <Geom_BSplineSurface.hxx>
#include <Geom_Circle.hxx>
#include <Geom_Plane.hxx>
#include <GeomAdaptor_Curve.hxx>
#include <GeomAdaptor_HCurve.hxx>
#include <GeomAdaptor_HSurface.hxx>
#include <GeomAdaptor_Curve.hxx>
#include <GeomAdaptor_Surface.hxx>
#include <GeomAdaptor_Surface.hxx>
#include <gp_Ax2.hxx>
#include <gp_Ax3.hxx>
@@ -397,7 +397,7 @@ void ChFi3d_FilBuilder::PerformThreeCorner(const Standard_Integer Jndex)
// ----------------------------------------------------------
TopAbs_Orientation OFac = face[pivot].Orientation();
Handle(BRepAdaptor_HSurface) Fac = new BRepAdaptor_HSurface(face[pivot]);
Handle(BRepAdaptor_Surface) Fac = new BRepAdaptor_Surface(face[pivot]);
gp_Pnt2d ppp1,ppp2;
const ChFiDS_FaceInterference& bid1 = CD[pivot]->SetOfSurfData()->
Value(i[pivot][deb])->InterferenceOnS1();
@@ -432,12 +432,12 @@ void ChFi3d_FilBuilder::PerformThreeCorner(const Standard_Integer Jndex)
Value(i[pivot][deb])->Surf())).Surface());
}
Handle(GeomAdaptor_HSurface) Surf = new GeomAdaptor_HSurface(gasurf);
Handle(GeomAdaptor_Surface) Surf = new GeomAdaptor_Surface(gasurf);
// Handle(BRepTopAdaptor_TopolTool) IFac = new BRepTopAdaptor_TopolTool(Fac);
// Try to not classify on the face for cases of reentering fillets which naturally depass
// the border.
Handle(GeomAdaptor_HSurface)
bidsurf = new GeomAdaptor_HSurface(Fac->ChangeSurface().Surface());
Handle(GeomAdaptor_Surface)
bidsurf = new GeomAdaptor_Surface(Fac->ChangeSurface().Surface());
Handle(Adaptor3d_TopolTool)
IFac = new Adaptor3d_TopolTool(bidsurf);
// end of the attempt.
@@ -554,10 +554,10 @@ void ChFi3d_FilBuilder::PerformThreeCorner(const Standard_Integer Jndex)
}
else locfleche = radpondere * (WLast - WFirst) * fleche;
Standard_Real pasmax = (WLast-WFirst)*0.05;
Handle(ChFiDS_HElSpine) cornerspine = new ChFiDS_HElSpine();
cornerspine->ChangeCurve().SetCurve(spinecoin);
cornerspine->ChangeCurve().FirstParameter(WFirst - pasmax);
cornerspine->ChangeCurve().LastParameter(WLast + pasmax);
Handle(ChFiDS_ElSpine) cornerspine = new ChFiDS_ElSpine();
cornerspine->SetCurve(spinecoin);
cornerspine->FirstParameter(WFirst - pasmax);
cornerspine->LastParameter(WLast + pasmax);
// Just to confuse Compute that should not require this
// in this exact case ...
Handle(ChFiDS_Spine) NullSpine;