0024893: CLang warnings -Wlogical-not-parentheses for gce_Done comparisons
[occt.git] / src / gce / gce_MakeCirc.cxx
1 // Created on: 1992-09-02
2 // Created by: Remi GILET
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 <gce_MakeCirc.ixx>
18
19 #include <StdFail_NotDone.hxx>
20
21 #include <gp.hxx>
22 #include <gp_Ax1.hxx>
23 #include <gp_Lin.hxx>
24
25 #include <gce_MakeDir.hxx>
26
27 #include <Extrema_POnCurv.hxx>
28 #include <Extrema_ExtElC.hxx>
29 //=======================================================================
30 //function : gce_MakeCirc
31 //purpose  : 
32 //   Creation d un cercle 3d de gp passant par trois points.              +
33 //   Trois cas de figures :                                               +
34 //      1/ Les trois points sont confondus.                               +
35 //      -----------------------------------                               +
36 //      Le resultat est le cercle centre en Point1 de rayon zero.         +
37 //      2/ Deux des trois points sont confondus.                          +
38 //      ----------------------------------------                          +
39 //      Pas de solution (Erreur : Points confondus).                      +
40 //      3/ Les trois points sont distinct.                                +
41 //      ----------------------------------                                +
42 //      On cree la mediatrice a P1P2 ainsi que la mediatrice a P1P3.      +
43 //      La solution a pour centre l intersection de ces deux droite et    +
44 //      pour rayon la distance entre ce centre et l un des trois points.  +
45 //=========================================================================
46 gce_MakeCirc::gce_MakeCirc(const gp_Pnt&  P1 ,
47                            const gp_Pnt&  P2 ,
48                            const gp_Pnt&  P3) {
49 //=========================================================================
50 //   Traitement.                                                          +
51 //=========================================================================
52   Standard_Real dist1, dist2, dist3, aResolution;
53   //
54   aResolution=gp::Resolution();
55   //
56   dist1 = P1.Distance(P2);
57   dist2 = P1.Distance(P3);
58   dist3 = P2.Distance(P3);
59   //
60   if ((dist1<aResolution) && (dist2<aResolution) && (dist3<aResolution)) {
61     gp_Dir Dirx(1.,0.,0.);
62     gp_Dir Dirz(0.,0.,1.);
63     TheCirc = gp_Circ(gp_Ax2(P1,Dirx,Dirz), 0.);
64     return;
65   }
66   if (!(dist1 >= aResolution && dist2 >= aResolution)) {
67     TheError = gce_ConfusedPoints;
68     return;
69   }
70   //
71   Standard_Real x1,y1,z1,x2,y2,z2,x3,y3,z3;
72   //
73   P1.Coord(x1,y1,z1);
74   P2.Coord(x2,y2,z2);
75   P3.Coord(x3,y3,z3);
76   gp_Dir Dir1(x2-x1,y2-y1,z2-z1);
77   gp_Dir Dir2(x3-x2,y3-y2,z3-z2);
78   //
79   gp_Ax1 anAx1(P1, Dir1);
80   gp_Lin aL12 (anAx1);
81   if (aL12.Distance(P3)<aResolution) {
82     TheError = gce_ColinearPoints;
83     return;
84   }
85   //
86   gp_Dir Dir3 = Dir1.Crossed(Dir2);
87   //
88   gp_Dir dir = Dir1.Crossed(Dir3);
89   gp_Lin L1(gp_Pnt((P1.XYZ()+P2.XYZ())/2.),dir);
90   dir = Dir2.Crossed(Dir3);
91   gp_Lin L2(gp_Pnt((P3.XYZ()+P2.XYZ())/2.),dir);
92
93   Standard_Real Tol = 0.000000001;
94   Extrema_ExtElC distmin(L1,L2,Tol);
95   
96   if (!distmin.IsDone()) { 
97     TheError = gce_IntersectionError; 
98   }
99   else {
100     Standard_Integer nbext;
101     //
102     //
103     if (distmin.IsParallel()) {
104       TheError = gce_IntersectionError;
105       return;
106     }
107     nbext = distmin.NbExt();
108     //
109     //
110     if (nbext == 0) {
111       TheError = gce_IntersectionError; 
112     }
113     else {
114       Standard_Real TheDist = RealLast();
115       gp_Pnt pInt,pon1,pon2;
116       Standard_Integer i = 1;
117       Extrema_POnCurv Pon1,Pon2;
118       while (i<=nbext) {
119         if (distmin.SquareDistance(i)<TheDist) {
120           TheDist = distmin.SquareDistance(i);
121           distmin.Points(i,Pon1,Pon2);
122           pon1 = Pon1.Value();
123           pon2 = Pon2.Value();
124           pInt = gp_Pnt((pon1.XYZ()+pon2.XYZ())/2.);
125         }
126         i++;
127       }
128       //modified by NIZNHY-PKV Thu Mar  3 11:30:34 2005f
129       //Dir2.Cross(Dir1);
130       //modified by NIZNHY-PKV Thu Mar  3 11:30:37 2005t
131       dist1 = P1.Distance(pInt);
132       dist2 = P2.Distance(pInt);
133       dist3 = P3.Distance(pInt);
134       pInt.Coord(x3,y3,z3);
135       Dir1 = gp_Dir(x1-x3,y1-y3,z1-z3);
136       //modified by NIZNHY-PKV Thu Mar  3 11:31:11 2005f
137       //Dir2 = gp_Dir(x2-x3,y2-y3,z2-z3);
138       //modified by NIZNHY-PKV Thu Mar  3 11:31:13 2005t
139       //
140       TheCirc = gp_Circ(gp_Ax2(pInt, Dir3, Dir1),(dist1+dist2+dist3)/3.);
141       TheError = gce_Done;
142     }
143   }
144 }
145 //=======================================================================
146 //function : gce_MakeCirc
147 //purpose  : 
148 //=======================================================================
149 gce_MakeCirc::gce_MakeCirc(const gp_Ax2&       A2      ,
150                            const Standard_Real Radius  ) {
151   if (Radius < 0.) { 
152     TheError = gce_NegativeRadius;
153   }
154   else {
155     TheError = gce_Done;
156     TheCirc = gp_Circ(A2,Radius);
157   }
158 }
159 //=========================================================================
160 //   Creation d un gp_Circ par son centre <Center>, son plan <Plane> et   +
161 //   son rayon <Radius>.                                                  +
162 //=========================================================================
163 gce_MakeCirc::gce_MakeCirc(const gp_Pnt&       Center  ,
164                            const gp_Pln&       Plane   ,
165                            const Standard_Real Radius  ) {
166   gce_MakeCirc C = gce_MakeCirc(Center,Plane.Position().Direction(),Radius);
167   TheCirc = C.Value();
168   TheError = C.Status();
169 }
170 //=======================================================================
171 //function : gce_MakeCirc
172 //purpose  : Creation d un gp_Circ par son centre <Center>, 
173 //sa normale <Norm> et son rayon <Radius>.  
174 //=======================================================================
175 gce_MakeCirc::gce_MakeCirc(const gp_Pnt&       Center  ,
176                            const gp_Dir&       Norm    ,
177                            const Standard_Real Radius  ) {
178    if (Radius < 0.) { 
179      TheError = gce_NegativeRadius;
180    }
181    else {
182      Standard_Real A = Norm.X();
183      Standard_Real B = Norm.Y();
184      Standard_Real C = Norm.Z();
185      Standard_Real Aabs = Abs(A);
186      Standard_Real Babs = Abs(B);
187      Standard_Real Cabs = Abs(C);
188      gp_Ax2 Pos;
189
190 //=========================================================================
191 //  pour determiner l'axe X :                                             +
192 //  on dit que le produit scalaire Vx.Norm = 0.                           +
193 //  et on recherche le max(A,B,C) pour faire la division.                 +
194 //  l'une des coordonnees du vecteur est nulle.                           +
195 //=========================================================================
196
197      if( Babs <= Aabs && Babs <= Cabs) {
198        if(Aabs > Cabs) { Pos = gp_Ax2(Center,Norm,gp_Dir(-C,0.,A)); }
199        else { Pos = gp_Ax2(Center,Norm,gp_Dir(C,0.,-A)); }
200      }
201      else if( Aabs <= Babs && Aabs <= Cabs) {
202        if(Babs > Cabs) { Pos = gp_Ax2(Center,Norm,gp_Dir(0.,-C,B)); }
203        else { Pos = gp_Ax2(Center,Norm,gp_Dir(0.,C,-B)); }
204      }
205      else {
206        if(Aabs > Babs) { Pos = gp_Ax2(Center,Norm,gp_Dir(-B,A,0.)); }
207        else { Pos = gp_Ax2(Center,Norm,gp_Dir(B,-A,0.)); }
208      }
209      TheCirc = gp_Circ(Pos,Radius);
210      TheError = gce_Done;
211    }
212  }
213 //=======================================================================
214 //function : gce_MakeCirc
215 //purpose  :  Creation d un gp_Circ par son centre <Center>, 
216 // sa normale <Ptaxis> et  son rayon <Radius>
217 //=======================================================================
218 gce_MakeCirc::gce_MakeCirc(const gp_Pnt&       Center  ,
219                            const gp_Pnt&       Ptaxis  ,
220                            const Standard_Real Radius  ) {
221    if (Radius < 0.) { 
222      TheError = gce_NegativeRadius;
223    }
224    else {
225      if (Center.Distance(Ptaxis) <= gp::Resolution()) {
226        TheError = gce_NullAxis;
227      }
228      else {
229        Standard_Real A = Ptaxis.X()-Center.X();
230        Standard_Real B = Ptaxis.Y()-Center.Y();
231        Standard_Real C = Ptaxis.Z()-Center.Z();
232        Standard_Real Aabs = Abs(A);
233        Standard_Real Babs = Abs(B);
234        Standard_Real Cabs = Abs(C);
235        gp_Ax2 Pos;
236
237 //=========================================================================
238 //  pour determiner l'axe X :                                             +
239 //  on dit que le produit scalaire Vx.Norm = 0.                           +
240 //  et on recherche le max(A,B,C) pour faire la division.                 +
241 //  l'une des coordonnees du vecteur est nulle.                           +
242 //=========================================================================
243
244        gp_Dir Norm = gce_MakeDir(Center,Ptaxis);
245        if( Babs <= Aabs && Babs <= Cabs) {
246          if(Aabs > Cabs) { Pos = gp_Ax2(Center,Norm,gp_Dir(-C,0.,A)); }
247          else { Pos = gp_Ax2(Center,Norm,gp_Dir(C,0.,-A)); }
248        }
249        else if( Aabs <= Babs && Aabs <= Cabs) {
250          if(Babs > Cabs) { Pos = gp_Ax2(Center,Norm,gp_Dir(0.,-C,B)); }
251          else { Pos = gp_Ax2(Center,Norm,gp_Dir(0.,C,-B)); }
252        }
253        else {
254          if(Aabs > Babs) { Pos = gp_Ax2(Center,Norm,gp_Dir(-B,A,0.)); }
255          else { Pos = gp_Ax2(Center,Norm,gp_Dir(B,-A,0.)); }
256        }
257        TheCirc = gp_Circ(Pos,Radius);
258        TheError = gce_Done;
259      }
260    }
261  }
262 //=======================================================================
263 //function : gce_MakeCirc
264 //purpose  : Creation d un gp_Circ par son axe <Axis> et son rayon <Radius>.  
265 //=======================================================================
266 gce_MakeCirc::gce_MakeCirc(const gp_Ax1&       Axis    ,
267                            const Standard_Real Radius  ) 
268 {
269   if (Radius < 0.) { 
270     TheError = gce_NegativeRadius;
271   }
272   else {
273     gp_Dir Norm(Axis.Direction());
274     gp_Pnt Center(Axis.Location());
275     Standard_Real A = Norm.X();
276     Standard_Real B = Norm.Y();
277     Standard_Real C = Norm.Z();
278     Standard_Real Aabs = Abs(A);
279     Standard_Real Babs = Abs(B);
280     Standard_Real Cabs = Abs(C);
281     gp_Ax2 Pos;
282
283 //=========================================================================
284 //  pour determiner l'axe X :                                             +
285 //  on dit que le produit scalaire Vx.Norm = 0.                           +
286 //  et on recherche le max(A,B,C) pour faire la division.                 +
287 //  l'une des coordonnees du vecteur est nulle.                           +
288 //=========================================================================
289
290     if( Babs <= Aabs && Babs <= Cabs) {
291       if(Aabs > Cabs) { Pos = gp_Ax2(Center,Norm,gp_Dir(-C,0.,A)); }
292       else { Pos = gp_Ax2(Center,Norm,gp_Dir(C,0.,-A)); }
293     }
294     else if( Aabs <= Babs && Aabs <= Cabs) {
295       if(Babs > Cabs) { Pos = gp_Ax2(Center,Norm,gp_Dir(0.,-C,B)); }
296       else { Pos = gp_Ax2(Center,Norm,gp_Dir(0.,C,-B)); }
297     }
298     else {
299       if(Aabs > Babs) { Pos = gp_Ax2(Center,Norm,gp_Dir(-B,A,0.)); }
300       else { Pos = gp_Ax2(Center,Norm,gp_Dir(B,-A,0.)); }
301     }
302     TheCirc = gp_Circ(Pos,Radius);
303     TheError = gce_Done;
304   }
305 }
306 //=======================================================================
307 //function : gce_MakeCirc
308 //purpose  : Creation d un gp_Circ concentrique a un autre gp_circ a une distance +
309 //   donnee.                
310 //=======================================================================
311 gce_MakeCirc::gce_MakeCirc(const gp_Circ&      Circ    ,
312                            const Standard_Real Dist    )
313 {
314   Standard_Real Rad = Circ.Radius()+Dist;
315   if (Rad < 0.) { 
316     TheError = gce_NegativeRadius;
317   }
318   else {
319     TheCirc = gp_Circ(Circ.Position(),Rad);
320     TheError = gce_Done;
321   }
322 }
323 //=======================================================================
324 //function : gce_MakeCirc
325 //purpose  : Creation d un gp_Circ concentrique a un autre gp_circ dont le rayon 
326 //   est egal a la distance de <Point> a l axe de <Circ>. 
327 //=======================================================================
328 gce_MakeCirc::gce_MakeCirc(const gp_Circ& Circ ,
329                            const gp_Pnt&  P    ) 
330 {
331   Standard_Real Rad = gp_Lin(Circ.Axis()).Distance(P);
332   TheCirc = gp_Circ(Circ.Position(),Rad);
333   TheError = gce_Done;
334 }
335 //=======================================================================
336 //function : Value
337 //purpose  : 
338 //=======================================================================
339 const gp_Circ& gce_MakeCirc::Value() const
340
341   StdFail_NotDone_Raise_if(TheError != gce_Done,"");
342   return TheCirc;
343 }
344 //=======================================================================
345 //function : Operator
346 //purpose  : 
347 //=======================================================================
348 const gp_Circ& gce_MakeCirc::Operator() const 
349 {
350   return Value();
351 }
352 //=======================================================================
353 //function : operator
354 //purpose  : 
355 //=======================================================================
356 gce_MakeCirc::operator gp_Circ() const
357 {
358   return Value();
359 }
360