0031035: Coding - uninitialized class fields reported by Visual Studio Code Analysis
[occt.git] / src / IntCurve / IntCurve_IntConicConic_Tool.cxx
1 // Created on: 1992-05-06
2 // Created by: Laurent BUCHARD
3 // Copyright (c) 1992-1999 Matra Datavision
4 // Copyright (c) 1999-2014 OPEN CASCADE SAS
5 //
6 // This file is part of Open CASCADE Technology software library.
7 //
8 // This library is free software; you can redistribute it and/or modify it under
9 // the terms of the GNU Lesser General Public License version 2.1 as published
10 // by the Free Software Foundation, with special exception defined in the file
11 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
12 // distribution for complete text of the license and disclaimer of any warranty.
13 //
14 // Alternatively, this file may be used under the terms of Open CASCADE
15 // commercial license or contractual agreement.
16
17 #include <IntCurve_IntConicConic_Tool.hxx>
18 #include <gp.hxx>
19
20
21 #define TOLERANCE_ANGULAIRE 0.00000001
22
23
24
25 //======================================================================
26 //===         R e s s o u r c e s        G e n e r a l e s           ===
27 //======================================================================
28
29 void Determine_Transition_LC(const IntRes2d_Position Pos1,
30                              gp_Vec2d& Tan1,
31                              const gp_Vec2d& Norm1,
32                              IntRes2d_Transition& T1,
33                              const IntRes2d_Position Pos2,
34                              gp_Vec2d& Tan2,
35                              const gp_Vec2d& Norm2,
36                              IntRes2d_Transition& T2,
37                              const Standard_Real ) {
38   
39
40   Standard_Real sgn=Tan1.Crossed(Tan2);
41   Standard_Real norm=Tan1.Magnitude()*Tan2.Magnitude();
42   
43   if (Abs(sgn)<=TOLERANCE_ANGULAIRE*norm) {   // Transition TOUCH #########
44     Standard_Boolean opos=(Tan1.Dot(Tan2))<0;
45     
46     gp_Vec2d Norm;
47 //  Modified by Sergey KHROMOV - Thu Nov  2 17:57:15 2000 Begin
48     Tan1.Normalize();
49 //  Modified by Sergey KHROMOV - Thu Nov  2 17:57:16 2000 End
50     Norm.SetCoord(-Tan1.Y(),Tan1.X());
51     
52     Standard_Real Val1=Norm.Dot(Norm1);
53     Standard_Real Val2=Norm.Dot(Norm2);
54     
55     if (Abs(Val1-Val2) <= gp::Resolution()) {
56       T1.SetValue(Standard_True,Pos1,IntRes2d_Unknown,opos);
57       T2.SetValue(Standard_True,Pos2,IntRes2d_Unknown,opos);
58     }
59     else if (Val2 > Val1) {
60       T2.SetValue(Standard_True,Pos2,IntRes2d_Inside,opos);
61       if (opos) { T1.SetValue(Standard_True,Pos1,IntRes2d_Inside,opos);  }
62       else {      T1.SetValue(Standard_True,Pos1,IntRes2d_Outside,opos); }
63     }
64     else {         // Val1 > Val2
65       T2.SetValue(Standard_True,Pos2,IntRes2d_Outside,opos);
66       if (opos) { T1.SetValue(Standard_True,Pos1,IntRes2d_Outside,opos); }
67       else {      T1.SetValue(Standard_True,Pos1,IntRes2d_Inside,opos);  }
68     }
69   }
70   else if (sgn<0) {
71     T1.SetValue(Standard_False,Pos1,IntRes2d_In);
72     T2.SetValue(Standard_False,Pos2,IntRes2d_Out);
73   }
74   else {   
75     T1.SetValue(Standard_False,Pos1,IntRes2d_Out);
76     T2.SetValue(Standard_False,Pos2,IntRes2d_In);
77   }
78 }
79 //----------------------------------------------------------------------
80 Standard_Real NormalizeOnCircleDomain(const Standard_Real _Param
81                                       ,const IntRes2d_Domain& TheDomain) {
82   Standard_Real Param=_Param;
83   while(Param<TheDomain.FirstParameter()) {
84     Param+=PIpPI;
85   }
86   while(Param>TheDomain.LastParameter()) {
87     Param-=PIpPI;
88   }
89   return(Param);
90 }
91 //----------------------------------------------------------------------
92 PeriodicInterval PeriodicInterval::FirstIntersection(PeriodicInterval& PInter)
93 {
94   Standard_Real a,b;
95   if(PInter.isnull  || isnull) {
96     PeriodicInterval PourSGI; return(PourSGI);
97   }
98   else {
99     if(Length() >= PIpPI) 
100       return(PeriodicInterval(PInter.Binf,PInter.Bsup));
101     if(PInter.Length()>=PIpPI) 
102       return(PeriodicInterval(Binf,Bsup));
103     if(PInter.Bsup<=Binf) { 
104       while(PInter.Binf <= Binf && PInter.Bsup <= Binf) { 
105         PInter.Binf+=PIpPI; PInter.Bsup+=PIpPI;
106       }
107     }
108     if(PInter.Binf >= Bsup) { 
109       while(PInter.Binf >=Bsup && PInter.Bsup >= Bsup) { 
110         PInter.Binf-=PIpPI; PInter.Bsup-=PIpPI;
111       }
112     }
113     if((PInter.Bsup < Binf)  || (PInter.Binf > Bsup)) { 
114       PeriodicInterval PourSGI; return(PourSGI);
115     }
116   }
117   
118   a=(PInter.Binf > Binf)? PInter.Binf : Binf;
119   b=(PInter.Bsup < Bsup)? PInter.Bsup : Bsup;
120
121   return(PeriodicInterval(a,b));
122 }
123 //----------------------------------------------------------------------
124 PeriodicInterval PeriodicInterval::SecondIntersection(PeriodicInterval& PInter)
125 {
126   Standard_Real a,b;
127
128   
129   if(PInter.isnull 
130      || isnull 
131      || this->Length()>=PIpPI 
132      || PInter.Length()>=PIpPI) { 
133     PeriodicInterval PourSGI; return(PourSGI);
134   }
135   
136   Standard_Real PInter_inf=PInter.Binf+PIpPI;
137   Standard_Real PInter_sup=PInter.Bsup+PIpPI;
138   if(PInter_inf > Bsup) {
139     PInter_inf=PInter.Binf-PIpPI;
140     PInter_sup=PInter.Bsup-PIpPI;
141   }
142   if((PInter_sup < Binf) || (PInter_inf > Bsup)) { 
143     PeriodicInterval PourSGI; return(PourSGI);
144   }
145   else {
146     a=(PInter_inf > Binf)? PInter_inf : Binf;
147     b=(PInter_sup < Bsup)? PInter_sup : Bsup;
148   }
149   return(PeriodicInterval(a,b));
150 }
151 //----------------------------------------------------------------------
152 Interval::Interval() : 
153     Binf(0.),
154     Bsup(0.),
155     HasFirstBound(Standard_False),
156     HasLastBound(Standard_False)
157 { IsNull=Standard_True; }
158
159 Interval::Interval(const Standard_Real a,const Standard_Real b) { 
160   HasFirstBound=HasLastBound=Standard_True;
161   if(a<b) { Binf=a; Bsup=b; } 
162   else    { Binf=b; Bsup=a; }
163   IsNull=Standard_False;
164 }
165
166 Interval::Interval(const IntRes2d_Domain& Domain)
167 : Binf(0.0),
168   Bsup(0.0)
169 {
170   IsNull=Standard_False;
171   if(Domain.HasFirstPoint()) {
172     HasFirstBound=Standard_True;
173     Binf=Domain.FirstParameter()-Domain.FirstTolerance();
174   }
175   else
176     HasFirstBound=Standard_False;
177   if(Domain.HasLastPoint()) {
178     HasLastBound=Standard_True;
179     Bsup=Domain.LastParameter()+Domain.LastTolerance();
180   }
181   else HasLastBound=Standard_False;
182 }
183
184 Interval::Interval( const Standard_Real a,const Standard_Boolean hf
185                    ,const Standard_Real b,const Standard_Boolean hl) { 
186   Binf=a; Bsup=b;
187   IsNull=Standard_False;
188   HasFirstBound=hf;
189   HasLastBound=hl;
190 }
191   
192 Standard_Real Interval::Length()   { return((IsNull)? -1.0 :Abs(Bsup-Binf)); }
193
194 Interval Interval::IntersectionWithBounded(const Interval& Inter) {
195   if(IsNull || Inter.IsNull) { Interval PourSGI; return(PourSGI); }
196   if(!(HasFirstBound || HasLastBound)) 
197     return(Interval(Inter.Binf,Inter.Bsup));
198   Standard_Real a,b;
199   if(HasFirstBound) {
200     if(Inter.Bsup < Binf) { Interval PourSGI; return(PourSGI); }
201     a=(Inter.Binf < Binf)? Binf : Inter.Binf;
202   }
203   else { a=Inter.Binf; }
204   
205   if(HasLastBound) {
206     if(Inter.Binf > Bsup) { Interval PourSGI; return(PourSGI); }
207     b=(Inter.Bsup > Bsup)? Bsup : Inter.Bsup;
208   }
209   else { b=Inter.Bsup; }  
210   return(Interval(a,b));
211 }