0024186: Eliminate remaining compiler warnings in MSVC++ 2010 64 bit with warning...
[occt.git] / src / Extrema / Extrema_ExtElCS.cxx
CommitLineData
b311480e 1// Copyright (c) 1995-1999 Matra Datavision
2// Copyright (c) 1999-2012 OPEN CASCADE SAS
3//
4// The content of this file is subject to the Open CASCADE Technology Public
5// License Version 6.5 (the "License"). You may not use the content of this file
6// except in compliance with the License. Please obtain a copy of the License
7// at http://www.opencascade.org and read it completely before using this file.
8//
9// The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
10// main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
11//
12// The Original Code and all software distributed under the License is
13// distributed on an "AS IS" basis, without warranty of any kind, and the
14// Initial Developer hereby disclaims all such warranties, including without
15// limitation, any warranties of merchantability, fitness for a particular
16// purpose or non-infringement. Please see the License for the specific terms
17// and conditions governing the rights and limitations under the License.
18
7fd59977 19
20// Modified by skv - Thu Jul 7 14:37:05 2005 OCC9134
21
22#include <Extrema_ExtElCS.ixx>
23#include <Extrema_ExtPElS.hxx>
24#include <Extrema_ExtPElC.hxx>
25#include <Extrema_ExtElC.hxx>
26#include <Extrema_POnCurv.hxx>
27#include <Standard_NotImplemented.hxx>
28#include <StdFail_InfiniteSolutions.hxx>
29#include <Precision.hxx>
30#include <ElSLib.hxx>
31#include <ElCLib.hxx>
32#include <gp_Vec.hxx>
f34cd0d1 33#include <IntAna_Quadric.hxx>
34#include <IntAna_IntConicQuad.hxx>
7fd59977 35
36
37Extrema_ExtElCS::Extrema_ExtElCS()
38{
39 myDone = Standard_False;
40 myIsPar = Standard_False;
41}
42
43
44Extrema_ExtElCS::Extrema_ExtElCS(const gp_Lin& C,
45 const gp_Pln& S)
46{
47 Perform(C, S);
48}
49
50
51
52void Extrema_ExtElCS::Perform(const gp_Lin& C,
53 const gp_Pln& S)
54{
55 myDone = Standard_True;
56 myIsPar = Standard_False;
57
58 if (C.Direction().IsNormal(S.Axis().Direction(),
59 Precision::Angular())) {
60 mySqDist = new TColStd_HArray1OfReal(1, 1);
61 mySqDist->SetValue(1, S.SquareDistance(C));
62 myIsPar = Standard_True;
63 }
64 else {
65 myNbExt = 0;
66 }
67
68}
69
70
71Extrema_ExtElCS::Extrema_ExtElCS(const gp_Lin& C,
72 const gp_Cylinder& S)
73{
74 Perform(C, S);
75}
76
77
78
79void Extrema_ExtElCS::Perform(const gp_Lin& C,
80 const gp_Cylinder& S)
81{
82 myDone = Standard_False;
83 myNbExt = 0;
84 myIsPar = Standard_False;
85
86 gp_Ax3 Pos = S.Position();
f34cd0d1 87 gp_Pnt Origin = Pos.Location();
88 gp_Pnt LineOrig = C.Location();
89
7fd59977 90 Standard_Real radius = S.Radius();
91 Extrema_ExtElC Extrem(gp_Lin(Pos.Axis()), C, Precision::Angular());
92 if (Extrem.IsParallel()) {
93 mySqDist = new TColStd_HArray1OfReal(1, 1);
f34cd0d1 94 myPoint1 = new Extrema_HArray1OfPOnCurv(1, 1);
95 myPoint2 = new Extrema_HArray1OfPOnSurf(1, 1);
96 Standard_Real aDist = sqrt(Extrem.SquareDistance(1)) - radius;
7fd59977 97 mySqDist->SetValue(1, aDist * aDist);
f34cd0d1 98 Standard_Real u, v, w;
99 gp_Vec aVec(LineOrig, Origin);
100 gp_Vec aDirVec(C.Direction());
101 w = aVec*aDirVec;
102 gp_Pnt LinPoint = LineOrig.Translated(w * aDirVec);
103 Extrema_POnCurv PonC(w, LinPoint);
104 myPoint1->SetValue(1, PonC);
105 gp_Pnt CylPoint;
106 gp_Vec OrigToLine(Origin, LinPoint);
107 if (OrigToLine.Magnitude() <= gp::Resolution())
108 {
109 u = 0.;
110 v = 0.;
111 CylPoint = ElSLib::Value(u, v, S);
112 }
113 else
114 {
115 OrigToLine.Normalize();
116 CylPoint = Origin.Translated(radius * OrigToLine);
117 ElSLib::CylinderParameters(Pos, radius, CylPoint, u, v);
118 }
119 Extrema_POnSurf PonS(u, v, CylPoint);
120 myPoint2->SetValue(1, PonS);
7fd59977 121 myDone = Standard_True;
122 myIsPar = Standard_True;
123 }
124 else {
125 Standard_Integer i;
f34cd0d1 126
127 Extrema_POnCurv myPOnC1, myPOnC2;
128 Extrem.Points(1, myPOnC1, myPOnC2);
129 gp_Pnt PonAxis = myPOnC1.Value();
130 gp_Pnt PC = myPOnC2.Value();
131
132 // line is tangent or outside of the cylunder -- single solution
133 if (radius - PonAxis.Distance(PC) < Precision::PConfusion())
134 {
135 Extrema_ExtPElS ExPS(PC, S, Precision::Confusion());
136 if (ExPS.IsDone()) {
137 myNbExt = ExPS.NbExt();
138 mySqDist = new TColStd_HArray1OfReal(1, myNbExt);
139 myPoint1 = new Extrema_HArray1OfPOnCurv(1, myNbExt);
140 myPoint2 = new Extrema_HArray1OfPOnSurf(1, myNbExt);
141 for (i = 1; i <= myNbExt; i++) {
142 myPoint1->SetValue(i, myPOnC2);
143 myPoint2->SetValue(i, ExPS.Point(i));
144 mySqDist->SetValue(i,(myPOnC2.Value()).SquareDistance(ExPS.Point(i).Value()));
145 }
7fd59977 146 }
f34cd0d1 147 }
148 // line intersects the cylinder
149 else
150 {
151 IntAna_Quadric theQuadric(S);
152 IntAna_IntConicQuad Inters(C, theQuadric);
153 if (Inters.IsDone())
154 {
155 myNbExt = Inters.NbPoints();
156 if (myNbExt > 0)
157 {
158 mySqDist = new TColStd_HArray1OfReal(1, myNbExt);
159 myPoint1 = new Extrema_HArray1OfPOnCurv(1, myNbExt);
160 myPoint2 = new Extrema_HArray1OfPOnSurf(1, myNbExt);
161 Standard_Real u, v, w;
162 for (i = 1; i <= myNbExt; i++)
163 {
164 mySqDist->SetValue(i, 0.);
165 gp_Pnt P_int = Inters.Point(i);
166 w = Inters.ParamOnConic(i);
167 Extrema_POnCurv PonC(w, P_int);
168 myPoint1->SetValue(i, PonC);
169 ElSLib::CylinderParameters(Pos, radius, P_int, u, v);
170 Extrema_POnSurf PonS(u, v, P_int);
171 myPoint2->SetValue(i, PonS);
172 }
173 }
7fd59977 174 }
7fd59977 175 }
f34cd0d1 176 myDone = Standard_True;
7fd59977 177 }
178
179}
180
181
182
183Extrema_ExtElCS::Extrema_ExtElCS(const gp_Lin& C,
184 const gp_Cone& S)
185{
186 Perform(C, S);
187}
188
189
190
191//void Extrema_ExtElCS::Perform(const gp_Lin& C,
192// const gp_Cone& S)
193void Extrema_ExtElCS::Perform(const gp_Lin& ,
194 const gp_Cone& )
195{
196 Standard_NotImplemented::Raise();
197
198}
199
200
201
202Extrema_ExtElCS::Extrema_ExtElCS(const gp_Lin& C,
203 const gp_Sphere& S)
204{
205 Perform(C, S);
206}
207
208
209
210void Extrema_ExtElCS::Perform(const gp_Lin& C,
211 const gp_Sphere& S)
212{
213 myDone = Standard_False;
214 myNbExt = 0;
215 myIsPar = Standard_False;
216
217 gp_Pnt O = S.Location();
218
219 Extrema_ExtPElC Extrem(O, C, Precision::Angular(), RealFirst(), RealLast());
220
221 Standard_Integer i;
222 if (Extrem.IsDone()) {
223 Extrema_POnCurv myPOnC1 = Extrem.Point(1);
224 Extrema_ExtPElS ExPS(myPOnC1.Value(), S, Precision::Confusion());
225 if (ExPS.IsDone()) {
226 myNbExt = ExPS.NbExt();
227 mySqDist = new TColStd_HArray1OfReal(1, myNbExt);
228 myPoint1 = new Extrema_HArray1OfPOnCurv(1, myNbExt);
229 myPoint2 = new Extrema_HArray1OfPOnSurf(1, myNbExt);
230 for (i = 1; i <= myNbExt; i++) {
231 myPoint1->SetValue(i, myPOnC1);
232 myPoint2->SetValue(i, ExPS.Point(i));
233 mySqDist->SetValue(i,(myPOnC1.Value()).SquareDistance(ExPS.Point(i).Value()));
234 myDone = Standard_True;
235 }
236 }
237 }
238}
239
240
241Extrema_ExtElCS::Extrema_ExtElCS(const gp_Lin& C,
242 const gp_Torus& S)
243{
244 Perform(C, S);
245}
246
247
248
249//void Extrema_ExtElCS::Perform(const gp_Lin& C,
250// const gp_Torus& S)
251void Extrema_ExtElCS::Perform(const gp_Lin& ,
252 const gp_Torus& )
253{
254 Standard_NotImplemented::Raise();
255
256}
257
258
259// Circle-?
260
261Extrema_ExtElCS::Extrema_ExtElCS(const gp_Circ& C,
262 const gp_Pln& S)
263{
264 Perform(C, S);
265}
266
267
268
269//void Extrema_ExtElCS::Perform(const gp_Circ& C,
270// const gp_Pln& S)
271void Extrema_ExtElCS::Perform(const gp_Circ& ,
272 const gp_Pln& )
273{
274 Standard_NotImplemented::Raise();
275
276}
277
278
279
280Extrema_ExtElCS::Extrema_ExtElCS(const gp_Circ& C,
281 const gp_Cylinder& S)
282{
283 Perform(C, S);
284}
285
286
287
288// Modified by skv - Thu Jul 7 14:37:05 2005 OCC9134 Begin
289// Implementation of the method.
290void Extrema_ExtElCS::Perform(const gp_Circ& C,
291 const gp_Cylinder& S)
292{
293 myDone = Standard_False;
294 myIsPar = Standard_False;
295 myNbExt = 0;
296
297 // Get an axis line of the cylinder.
298 gp_Lin anAxis(S.Axis());
299
300 // Compute extrema between the circle and the line.
301 Extrema_ExtElC anExtC(anAxis, C, 0.);
302
303 if (anExtC.IsDone()) {
304 if (anExtC.IsParallel()) {
305 myIsPar = Standard_True;
306 mySqDist = new TColStd_HArray1OfReal(1, 1);
307 Standard_Real aDist = sqrt (anExtC.SquareDistance(1)) - S.Radius();
308 mySqDist->SetValue(1, aDist * aDist);
309 } else {
310 Standard_Integer aNbExt = anExtC.NbExt();
311 gp_Pnt aCenter = C.Location();
312 Standard_Integer i;
313 Standard_Integer aCurI = 1;
314 Standard_Real aTolConf = Precision::Confusion();
315 Standard_Real aCylRad = S.Radius();
316
317 // Compute the extremas.
318 myNbExt = 2*aNbExt;
319 mySqDist = new TColStd_HArray1OfReal(1, myNbExt);
320 myPoint1 = new Extrema_HArray1OfPOnCurv(1, myNbExt);
321 myPoint2 = new Extrema_HArray1OfPOnSurf(1, myNbExt);
322
323 for (i = 1; i <= aNbExt; i++) {
324 Extrema_POnCurv aPOnAxis;
325 Extrema_POnCurv aPOnCirc;
326 Standard_Real aSqDist = anExtC.SquareDistance(i);
327 Standard_Real aDist = sqrt (aSqDist);
328
329 anExtC.Points(i, aPOnAxis, aPOnCirc);
330
331 if (aSqDist <= (aTolConf * aTolConf) || aCenter.IsEqual(aPOnAxis.Value(), aTolConf)) {
332 myNbExt -= 2;
333 continue;
334 }
335
336 gp_Dir aDir(aPOnAxis.Value().XYZ().
337 Subtracted(aPOnCirc.Value().XYZ()));
338 Standard_Real aShift[2] = { aDist + aCylRad, aDist - aCylRad };
339 Standard_Integer j;
340
341 for (j = 0; j < 2; j++) {
342 gp_Vec aVec(aDir);
343 gp_Pnt aPntOnCyl;
344
345 aVec.Multiply(aShift[j]);
346 aPntOnCyl = aPOnCirc.Value().Translated(aVec);
347
348 Standard_Real aU;
349 Standard_Real aV;
350
351 ElSLib::Parameters(S, aPntOnCyl, aU, aV);
352
353 Extrema_POnSurf aPOnSurf(aU, aV, aPntOnCyl);
354
355 myPoint1->SetValue(aCurI, aPOnCirc);
356 myPoint2->SetValue(aCurI, aPOnSurf);
357 mySqDist->SetValue(aCurI++, aShift[j] * aShift[j]);
358 }
359 }
360 }
361
362 myDone = Standard_True;
363 }
364}
365// Modified by skv - Thu Jul 7 14:37:05 2005 OCC9134 End
366
367
368
369Extrema_ExtElCS::Extrema_ExtElCS(const gp_Circ& C,
370 const gp_Cone& S)
371{
372 Perform(C, S);
373}
374
375
376
377//void Extrema_ExtElCS::Perform(const gp_Circ& C,
378// const gp_Cone& S)
379void Extrema_ExtElCS::Perform(const gp_Circ& ,
380 const gp_Cone& )
381{
382 Standard_NotImplemented::Raise();
383
384}
385
386
387
388Extrema_ExtElCS::Extrema_ExtElCS(const gp_Circ& C,
389 const gp_Sphere& S)
390{
391 Perform(C, S);
392}
393
394
395
396//void Extrema_ExtElCS::Perform(const gp_Circ& C,
397// const gp_Sphere& S)
398void Extrema_ExtElCS::Perform(const gp_Circ& ,
399 const gp_Sphere& )
400{
401 Standard_NotImplemented::Raise();
402
403}
404
405Extrema_ExtElCS::Extrema_ExtElCS(const gp_Circ& C,
406 const gp_Torus& S)
407{
408 Perform(C, S);
409}
410
411
412
413//void Extrema_ExtElCS::Perform(const gp_Circ& C,
414// const gp_Torus& S)
415void Extrema_ExtElCS::Perform(const gp_Circ& ,
416 const gp_Torus& )
417{
418 Standard_NotImplemented::Raise();
419
420}
421
422Extrema_ExtElCS::Extrema_ExtElCS(const gp_Hypr& C,
423 const gp_Pln& S)
424{
425 Perform(C, S);
426}
427
428
429
430void Extrema_ExtElCS::Perform(const gp_Hypr& C,
431 const gp_Pln& S)
432{
433 myDone = Standard_True;
434 myIsPar = Standard_False;
435
436 gp_Ax2 Pos = C.Position();
437 gp_Dir NHypr = Pos.Direction();
438 gp_Dir NPln = S.Axis().Direction();
439
440 if (NHypr.IsParallel(NPln, Precision::Angular())) {
441
442 mySqDist = new TColStd_HArray1OfReal(1, 1);
443 mySqDist->SetValue(1, S.SquareDistance(C.Location()));
444 myIsPar = Standard_True;
445
446 }
447 else {
448
449 gp_Dir XDir = Pos.XDirection();
450 gp_Dir YDir = Pos.YDirection();
451
452 Standard_Real A = C.MinorRadius()*(NPln.Dot(YDir));
453 Standard_Real B = C.MajorRadius()*(NPln.Dot(XDir));
454
455 if(Abs(B) > Abs(A)) {
456 Standard_Real T = -0.5 * Log((A+B)/(B-A));
457 gp_Pnt Ph = ElCLib::HyperbolaValue(T, Pos, C.MajorRadius(), C.MinorRadius());
458 Extrema_POnCurv PC(T, Ph);
459 myPoint1 = new Extrema_HArray1OfPOnCurv(1,1);
460 myPoint1->SetValue(1, PC);
461
462 mySqDist = new TColStd_HArray1OfReal(1, 1);
463 mySqDist->SetValue(1, S.SquareDistance(Ph));
464
465 Standard_Real U, V;
466 ElSLib::PlaneParameters(S.Position(), Ph, U, V);
467 gp_Pnt Pp = ElSLib::PlaneValue(U, V, S.Position());
468 Extrema_POnSurf PS(U, V, Pp);
469 myPoint2 = new Extrema_HArray1OfPOnSurf(1,1);
470 myPoint2->SetValue(1, PS);
471
472 myNbExt = 1;
473 }
474 else {
475 myNbExt = 0;
476 }
477
478 }
479
480}
481
482
483Standard_Boolean Extrema_ExtElCS::IsDone() const
484{
485 return myDone;
486}
487
488
489Standard_Integer Extrema_ExtElCS::NbExt() const
490{
491 if (myIsPar) StdFail_InfiniteSolutions::Raise();
492 return myNbExt;
493}
494
495Standard_Real Extrema_ExtElCS::SquareDistance(const Standard_Integer N) const
496{
497 if (myIsPar && N != 1) StdFail_InfiniteSolutions::Raise();
498 return mySqDist->Value(N);
499}
500
501
502void Extrema_ExtElCS::Points(const Standard_Integer N,
503 Extrema_POnCurv& P1,
504 Extrema_POnSurf& P2) const
505{
506 if (myIsPar) StdFail_InfiniteSolutions::Raise();
507 P1 = myPoint1->Value(N);
508 P2 = myPoint2->Value(N);
509}
510
511
512Standard_Boolean Extrema_ExtElCS::IsParallel() const
513{
514 return myIsPar;
515}