include/opencascade/BRepBlend_Walking.hxx

0001 // Copyright (c) 1993-1999 Matra Datavision
0002 // Copyright (c) 1999-2024 OPEN CASCADE SAS
0003 //
0004 // This file is part of Open CASCADE Technology software library.
0005 //
0006 // This library is free software; you can redistribute it and/or modify it under
0007 // the terms of the GNU Lesser General Public License version 2.1 as published
0008 // by the Free Software Foundation, with special exception defined in the file
0009 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
0010 // distribution for complete text of the license and disclaimer of any warranty.
0011 //
0012 // Alternatively, this file may be used under the terms of Open CASCADE
0013 // commercial license or contractual agreement.
0014
0015 #ifndef _BRepBlend_Walking_HeaderFile
0016 #define _BRepBlend_Walking_HeaderFile
0017
0018 #include <Adaptor3d_Surface.hxx>
0019 #include <BRepBlend_SequenceOfPointOnRst.hxx>
0020 #include <Blend_Point.hxx>
0021 #include <Blend_SequenceOfPoint.hxx>
0022 #include <Blend_Status.hxx>
0023 #include <ChFiDS_ElSpine.hxx>
0024 #include <StdFail_NotDone.hxx>
0025 #include <TopAbs_State.hxx>
0026 #include <math_Vector.hxx>
0027
0028 class BRepBlend_Line;
0029 class Adaptor3d_TopolTool;
0030 class StdFail_NotDone;
0031 class Adaptor3d_HVertex;
0032 class BRepBlend_HCurve2dTool;
0033 class Adaptor3d_HSurfaceTool;
0034 class BRepBlend_HCurveTool;
0035 class BRepBlend_BlendTool;
0036 class BRepBlend_PointOnRst;
0037 class BRepBlend_Extremity;
0038 class Blend_Point;
0039 class Blend_Function;
0040 class Blend_FuncInv;
0041 class gp_Pnt;
0042 class gp_Pnt2d;
0043 class IntSurf_Transition;
0044
0045 class BRepBlend_Walking
0046 {
0047 public:
0048   DEFINE_STANDARD_ALLOC
0049
0050   Standard_EXPORT BRepBlend_Walking(const Handle(Adaptor3d_Surface)&   Surf1,
0051                                     const Handle(Adaptor3d_Surface)&   Surf2,
0052                                     const Handle(Adaptor3d_TopolTool)& Domain1,
0053                                     const Handle(Adaptor3d_TopolTool)& Domain2,
0054                                     const Handle(ChFiDS_ElSpine)&      HGuide);
0055
0056   //! To define different domains for control and clipping.
0057   Standard_EXPORT void SetDomainsToRecadre(const Handle(Adaptor3d_TopolTool)& RecDomain1,
0058                                            const Handle(Adaptor3d_TopolTool)& RecDomain2);
0059
0060   //! To define singular points computed before walking.
0061   Standard_EXPORT void AddSingularPoint(const Blend_Point& P);
0062
0063   Standard_EXPORT void Perform(Blend_Function&        F,
0064                                Blend_FuncInv&         FInv,
0065                                const Standard_Real    Pdep,
0066                                const Standard_Real    Pmax,
0067                                const Standard_Real    MaxStep,
0068                                const Standard_Real    Tol3d,
0069                                const Standard_Real    TolGuide,
0070                                const math_Vector&     Soldep,
0071                                const Standard_Real    Fleche,
0072                                const Standard_Boolean Appro = Standard_False);
0073
0074   Standard_EXPORT Standard_Boolean PerformFirstSection(Blend_Function&     F,
0075                                                        const Standard_Real Pdep,
0076                                                        math_Vector&        ParDep,
0077                                                        const Standard_Real Tol3d,
0078                                                        const Standard_Real TolGuide,
0079                                                        TopAbs_State&       Pos1,
0080                                                        TopAbs_State&       Pos2);
0081
0082   Standard_EXPORT Standard_Boolean PerformFirstSection(Blend_Function&        F,
0083                                                        Blend_FuncInv&         FInv,
0084                                                        const Standard_Real    Pdep,
0085                                                        const Standard_Real    Pmax,
0086                                                        const math_Vector&     ParDep,
0087                                                        const Standard_Real    Tol3d,
0088                                                        const Standard_Real    TolGuide,
0089                                                        const Standard_Boolean RecOnS1,
0090                                                        const Standard_Boolean RecOnS2,
0091                                                        Standard_Real&         Psol,
0092                                                        math_Vector&           ParSol);
0093
0094   Standard_EXPORT Standard_Boolean Continu(Blend_Function&     F,
0095                                            Blend_FuncInv&      FInv,
0096                                            const Standard_Real P);
0097
0098   Standard_EXPORT Standard_Boolean Continu(Blend_Function&        F,
0099                                            Blend_FuncInv&         FInv,
0100                                            const Standard_Real    P,
0101                                            const Standard_Boolean OnS1);
0102
0103   Standard_EXPORT Standard_Boolean Complete(Blend_Function&     F,
0104                                             Blend_FuncInv&      FInv,
0105                                             const Standard_Real Pmin);
0106
0107   Standard_EXPORT void ClassificationOnS1(const Standard_Boolean C);
0108
0109   Standard_EXPORT void ClassificationOnS2(const Standard_Boolean C);
0110
0111   Standard_EXPORT void Check2d(const Standard_Boolean C);
0112
0113   Standard_EXPORT void Check(const Standard_Boolean C);
0114
0115   inline Standard_Boolean TwistOnS1() const { return twistflag1; }
0116
0117   inline Standard_Boolean TwistOnS2() const { return twistflag2; }
0118
0119   inline Standard_Boolean IsDone() const { return done; }
0120
0121   inline const Handle(BRepBlend_Line)& Line() const
0122   {
0123     if (!done)
0124     {
0125       throw StdFail_NotDone();
0126     }
0127     return line;
0128   }
0129
0130 private:
0131   Standard_EXPORT void InternalPerform(Blend_Function&     F,
0132                                        Blend_FuncInv&      FInv,
0133                                        const Standard_Real Bound);
0134
0135   Standard_EXPORT Standard_Boolean CorrectExtremityOnOneRst(const Standard_Integer IndexOfRst,
0136                                                             const Standard_Real    theU,
0137                                                             const Standard_Real    theV,
0138                                                             const Standard_Real    theParam,
0139                                                             const gp_Pnt&          thePntOnRst,
0140                                                             Standard_Real&         NewU,
0141                                                             Standard_Real&         NewV,
0142                                                             gp_Pnt&                NewPoint,
0143                                                             Standard_Real&         NewParam) const;
0144
0145   Standard_EXPORT Standard_Integer ArcToRecadre(const Standard_Boolean OnFirst,
0146                                                 const math_Vector&     Sol,
0147                                                 const Standard_Integer PrevIndex,
0148                                                 gp_Pnt2d&              lpt2d,
0149                                                 gp_Pnt2d&              pt2d,
0150                                                 Standard_Real&         ponarc);
0151
0152   Standard_EXPORT Standard_Boolean Recadre(Blend_FuncInv&             FInv,
0153                                            const Standard_Boolean     OnFirst,
0154                                            const math_Vector&         Sol,
0155                                            math_Vector&               Solrst,
0156                                            Standard_Integer&          Indexsol,
0157                                            Standard_Boolean&          IsVtx,
0158                                            Handle(Adaptor3d_HVertex)& Vtx,
0159                                            const Standard_Real        Extrap = 0.0);
0160
0161   Standard_EXPORT void Transition(const Standard_Boolean           OnFirst,
0162                                   const Handle(Adaptor2d_Curve2d)& A,
0163                                   const Standard_Real              Param,
0164                                   IntSurf_Transition&              TLine,
0165                                   IntSurf_Transition&              TArc);
0166
0167   Standard_EXPORT void MakeExtremity(BRepBlend_Extremity&             Extrem,
0168                                      const Standard_Boolean           OnFirst,
0169                                      const Standard_Integer           Index,
0170                                      const Standard_Real              Param,
0171                                      const Standard_Boolean           IsVtx,
0172                                      const Handle(Adaptor3d_HVertex)& Vtx);
0173
0174   Standard_EXPORT void MakeSingularExtremity(BRepBlend_Extremity&             Extrem,
0175                                              const Standard_Boolean           OnFirst,
0176                                              const Handle(Adaptor3d_HVertex)& Vtx);
0177
0178   Standard_EXPORT Blend_Status CheckDeflection(const Standard_Boolean OnFirst,
0179                                                const Blend_Point&     CurPoint);
0180
0181   Standard_EXPORT Blend_Status TestArret(Blend_Function&        F,
0182                                          const Blend_Status     State,
0183                                          const Standard_Boolean TestDeflection = Standard_True,
0184                                          const Standard_Boolean TestSolution   = Standard_True,
0185                                          const Standard_Boolean TestLengthStep = Standard_False);
0186
0187   Blend_Point                 previousP;
0188   Handle(BRepBlend_Line)      line;
0189   math_Vector                 sol;
0190   Blend_SequenceOfPoint       jalons;
0191   Handle(Adaptor3d_Surface)   surf1;
0192   Handle(Adaptor3d_Surface)   surf2;
0193   Handle(Adaptor3d_TopolTool) domain1;
0194   Handle(Adaptor3d_TopolTool) domain2;
0195   Handle(Adaptor3d_TopolTool) recdomain1;
0196   Handle(Adaptor3d_TopolTool) recdomain2;
0197   Handle(ChFiDS_ElSpine)      hguide;
0198   Standard_Boolean            ToCorrectOnRst1;
0199   Standard_Boolean            ToCorrectOnRst2;
0200   Standard_Real               CorrectedParam;
0201   Standard_Real               tolpoint3d;
0202   Standard_Real               tolgui;
0203   Standard_Real               pasmax;
0204   Standard_Real               fleche;
0205   Standard_Real               param;
0206   Standard_Real               sens;
0207   Standard_Boolean            done;
0208   Standard_Boolean            rebrou;
0209   Standard_Boolean            iscomplete;
0210   Standard_Boolean            comptra;
0211   Standard_Boolean            clasonS1;
0212   Standard_Boolean            clasonS2;
0213   Standard_Boolean            check2d;
0214   Standard_Boolean            check;
0215   Standard_Boolean            twistflag1;
0216   Standard_Boolean            twistflag2;
0217 };
0218
0219 #endif // _BRepBlend_Walking_HeaderFile