8b32e03daa6258e3a0b23848a9b044c9a66036d4
[occt.git] / src / IntPatch / IntPatch_SpecialPoints.hxx
1 //! Created on: 2016-06-03
2 //! Created by: NIKOLAI BUKHALOV
3 //! Copyright (c) 2016 OPEN CASCADE SAS
4 //!
5 //! This file is part of Open CASCADE Technology software library.
6 //!
7 //! This library is free software; you can redistribute it and/or modify it under
8 //! the terms of the GNU Lesser General Public License version 2.1 as published
9 //! by the Free Software Foundation, with special exception defined in the file
10 //! OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
11 //! distribution for complete text of the license and disclaimer of any warranty.
12 //!
13 //! Alternatively, this file may be used under the terms of Open CASCADE
14 //! commercial license or contractual agreement.
15
16 #ifndef _IntPatch_SpecialPoints_HeaderFile
17 #define _IntPatch_SpecialPoints_HeaderFile
18
19 //! Contains methods to add some special points
20 //! (such as apex of cone, pole of sphere,
21 //! point on surface boundary etc.) in the intersection line.
22
23 #include <IntPatch_SpecPntType.hxx>
24 #include <Standard_Handle.hxx>
25
26 class Adaptor3d_HSurface;
27 class gp_Cone;
28 class gp_Vec;
29 class gp_XYZ;
30 class IntPatch_Point;
31 class IntSurf_PntOn2S;
32 class math_Vector;
33
34 class IntPatch_SpecialPoints
35 {
36 public:
37   //! Adds the point defined as intersection
38   //! of two isolines (U = 0 and V = 0) on theQSurf in theLine.
39   //! theRefPt is used to correct adjusting parameters.
40   //! If theIsReversed is TRUE then theQSurf correspond to the 
41   //! second (otherwise, the first) surface while forming
42   //! intersection point IntSurf_PntOn2S.
43   Standard_EXPORT static Standard_Boolean 
44                       AddCrossUVIsoPoint(const Handle(Adaptor3d_HSurface)& theQSurf,
45                                          const Handle(Adaptor3d_HSurface)& thePSurf,
46                                          const IntSurf_PntOn2S& theRefPt,
47                                          const Standard_Real theTol3d,
48                                          IntSurf_PntOn2S& theAddedPoint,
49                                          const Standard_Boolean theIsReversed
50                                                                 = Standard_False);
51
52   //! Adds the point lain strictly in the isoline U = 0 or V = 0 of theQSurf,
53   //! in theLine.
54   //! theRefPt is used to correct adjusting parameters.
55   //! If theIsReversed is TRUE then theQSurf corresponds to the 
56   //! second (otherwise, the first) surface while forming
57   //! intersection point IntSurf_PntOn2S.
58   //! All math_Vector-objects must be filled as follows:
59   //!   [1] - U-parameter of thePSurf;
60   //!   [2] - V-parameter of thePSurf;
61   //!   [3] - U- (if V-isoline is considered) or V-parameter
62   //!         (if U-isoline is considered) of theQSurf.
63   Standard_EXPORT static Standard_Boolean
64                       AddPointOnUorVIso(const Handle(Adaptor3d_HSurface)& theQSurf,
65                                         const Handle(Adaptor3d_HSurface)& thePSurf,
66                                         const IntSurf_PntOn2S& theRefPt,
67                                         const Standard_Boolean theIsU,
68                                         const Standard_Real theIsoParameter,
69                                         const math_Vector& theToler,
70                                         const math_Vector& theInitPoint,
71                                         const math_Vector& theInfBound,
72                                         const math_Vector& theSupBound,
73                                         IntSurf_PntOn2S& theAddedPoint,
74                                         const Standard_Boolean theIsReversed
75                                                                 = Standard_False);
76
77   //! Computes the pole of sphere to add it in the intersection line.
78   //! Stores the result in theAddedPoint variable (does not add in the line).
79   //! At that, cone and sphere (with singularity) must be set in theQSurf parameter.
80   //! By default (if theIsReversed == FALSE), theQSurf is the first surface of the
81   //! Walking line. If it is not, theIsReversed parameter must be set to TRUE.
82   //! theIsReqRefCheck is TRUE if and only if 3D-point of theRefPt must be pole or apex
83   //! for check (e.g. if it is vertex).
84   //! thePtIso is the reference point for obtaining isoline where must be placed the Apex/Pole.
85   //!
86   //! ATTENTION!!!
87   //!   theVertex must be initialized before calling the method .
88   Standard_EXPORT static Standard_Boolean
89                       AddSingularPole(const Handle(Adaptor3d_HSurface)& theQSurf,
90                                       const Handle(Adaptor3d_HSurface)& thePSurf,
91                                       const IntSurf_PntOn2S& thePtIso,
92                                       IntPatch_Point& theVertex,
93                                       IntSurf_PntOn2S& theAddedPoint,                                      
94                                       const Standard_Boolean theIsReversed =
95                                                                 Standard_False,
96                                       const Standard_Boolean theIsReqRefCheck = 
97                                                                 Standard_False);
98
99   //! Special point has already been added in the line. Now, we need in correct
100   //! prolongation of the line or in start new line. This function returns new point.
101   //!
102   //! ATTENTION!!!
103   //!   theNewPoint is not only Output parameter. It is Input/Output one. I.e. 
104   //! theNewPoint is reference point together with theRefPt.
105   Standard_EXPORT static Standard_Boolean
106                     ContinueAfterSpecialPoint(const Handle(Adaptor3d_HSurface)& theQSurf,
107                                               const Handle(Adaptor3d_HSurface)& thePSurf,
108                                               const IntSurf_PntOn2S& theRefPt,
109                                               const IntPatch_SpecPntType theSPType,
110                                               const Standard_Real theTol2D,
111                                               IntSurf_PntOn2S& theNewPoint,
112                                               const Standard_Boolean theIsReversed
113                                                                 = Standard_False);
114
115   //! Sets theNewPoint parameters in 2D-space the closest to
116   //! theRefPoint with help of adding/subtracting corresponding periods.
117   //! theArrPeriods must be filled as follows:
118   //! {<U-period of 1st surface>, <V-period of 1st surface>,
119   //!  <U-period of 2nd surface>, <V-period of 2nd surface>}.
120   //! If theVertex != 0 then its parameters will be filled as
121   //! corresponding parameters of theNewPoint.
122   //!
123   //! ATTENTION!!!
124   //!   theNewPoint is not only Output parameter. It is Input/Output one. I.e. 
125   //! theNewPoint is reference point together with theRefPt.
126   Standard_EXPORT static void 
127                       AdjustPointAndVertex(const IntSurf_PntOn2S &theRefPoint,
128                                            const Standard_Real theArrPeriods[4],
129                                            IntSurf_PntOn2S &theNewPoint,
130                                            IntPatch_Point* const theVertex = 0);
131
132 protected:
133   //! Computes "special point" in the sphere
134   //! The parameter will be found in the range [0, 2*PI].
135   //! Therefore it must be adjusted to valid range by
136   //! the high-level algorithm
137   static Standard_EXPORT Standard_Boolean ProcessSphere(const IntSurf_PntOn2S& thePtIso,
138                                                         const gp_Vec& theDUofPSurf,
139                                                         const gp_Vec& theDVofPSurf,
140                                                         const Standard_Boolean theIsReversed,
141                                                         const Standard_Real theVquad,
142                                                         Standard_Real& theUquad,
143                                                         Standard_Boolean& theIsIsoChoosen);
144
145   //! Computes "special point" in the cone.
146   //! The parameter will be found in the range [0, 2*PI].
147   //! Therefore it must be adjusted to valid range by
148   //! the high-level algorithm.
149   static Standard_EXPORT Standard_Boolean ProcessCone(const IntSurf_PntOn2S& thePtIso,
150                                                       const gp_Vec& theDUofPSurf,
151                                                       const gp_Vec& theDVofPSurf,
152                                                       const gp_Cone& theCone,
153                                                       const Standard_Boolean theIsReversed,
154                                                       Standard_Real& theUquad,
155                                                       Standard_Boolean& theIsIsoChoosen);
156
157   //! Computes vector tangent to the intersection line in cone apex.
158   //! There exist not more than 2 tangent. They will be stores in theResult vector.
159   //! Returns the number of found tangents.
160   //! thePlnNormal is the normalized vector of the normal to the plane intersected the cone.
161   static Standard_EXPORT Standard_Integer GetTangentToIntLineForCone(const Standard_Real theConeSemiAngle,
162                                                                      const gp_XYZ& thePlnNormal,
163                                                                      gp_XYZ theResult[2]);
164 };
165
166 #endif // _IntPatch_AddSpecialPoints_HeaderFile