b311480e |
1 | // Created on: 1992-11-24 |
2 | // Created by: Laurent BUCHARD |
3 | // Copyright (c) 1992-1999 Matra Datavision |
973c2be1 |
4 | // Copyright (c) 1999-2014 OPEN CASCADE SAS |
b311480e |
5 | // |
973c2be1 |
6 | // This file is part of Open CASCADE Technology software library. |
b311480e |
7 | // |
d5f74e42 |
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 |
973c2be1 |
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. |
b311480e |
13 | // |
973c2be1 |
14 | // Alternatively, this file may be used under the terms of Open CASCADE |
15 | // commercial license or contractual agreement. |
7fd59977 |
16 | |
17 | #include <IntCurve_IntConicConic.hxx> |
18 | #include <gp_Lin2d.hxx> |
19 | #include <gp_Circ2d.hxx> |
20 | #include <gp_Elips2d.hxx> |
21 | #include <gp_Parab2d.hxx> |
22 | #include <gp_Hypr2d.hxx> |
23 | #include <Precision.hxx> |
24 | |
25 | |
26 | |
27 | IntCurve_UserIntConicCurveGen::IntCurve_UserIntConicCurveGen () { |
28 | done = Standard_False; |
29 | } |
30 | //------------------------------------------------------------------------------------- |
31 | IntCurve_UserIntConicCurveGen::IntCurve_UserIntConicCurveGen (const gp_Lin2d& Lin1, |
32 | const IntRes2d_Domain& D1, |
33 | const ThePCurve& C2, |
34 | const IntRes2d_Domain& D2, |
35 | const Standard_Real TolConf, |
36 | const Standard_Real Tol) { |
37 | Perform(Lin1,D1,C2,D2,TolConf,Tol); |
38 | } |
39 | //------------------------------------------------------------------------------------- |
40 | IntCurve_UserIntConicCurveGen::IntCurve_UserIntConicCurveGen (const gp_Circ2d& Circ1, |
41 | const IntRes2d_Domain& D1, |
42 | const ThePCurve& C2, |
43 | const IntRes2d_Domain& D2, |
44 | const Standard_Real TolConf, |
45 | const Standard_Real Tol) { |
46 | Perform(Circ1,D1,C2,D2,TolConf,Tol); |
47 | } |
48 | //------------------------------------------------------------------------------------- |
49 | IntCurve_UserIntConicCurveGen::IntCurve_UserIntConicCurveGen (const gp_Parab2d& Parab1, |
50 | const IntRes2d_Domain& D1, |
51 | const ThePCurve& C2, |
52 | const IntRes2d_Domain& D2, |
53 | const Standard_Real TolConf, |
54 | const Standard_Real Tol) { |
55 | Perform(Parab1,D1,C2,D2,TolConf,Tol); |
56 | } |
57 | //------------------------------------------------------------------------------------- |
58 | IntCurve_UserIntConicCurveGen::IntCurve_UserIntConicCurveGen (const gp_Elips2d& Elips1, |
59 | const IntRes2d_Domain& D1, |
60 | const ThePCurve& C2, |
61 | const IntRes2d_Domain& D2, |
62 | const Standard_Real TolConf, |
63 | const Standard_Real Tol) { |
64 | Perform(Elips1,D1,C2,D2,TolConf,Tol); |
65 | } |
66 | //------------------------------------------------------------------------------------- |
67 | IntCurve_UserIntConicCurveGen::IntCurve_UserIntConicCurveGen (const gp_Hypr2d& Hyper1, |
68 | const IntRes2d_Domain& D1, |
69 | const ThePCurve& C2, |
70 | const IntRes2d_Domain& D2, |
71 | const Standard_Real TolConf, |
72 | const Standard_Real Tol) { |
73 | Perform(Hyper1,D1,C2,D2,TolConf,Tol); |
74 | } |
75 | //------------------------------------------------------------------------------------- |
76 | |
77 | |
78 | //---------------------------------------------------------------------- |
79 | void IntCurve_UserIntConicCurveGen::Perform (const gp_Lin2d& Lin1, |
80 | const IntRes2d_Domain& D1, |
81 | const ThePCurve& C2, |
82 | const IntRes2d_Domain& D2, |
83 | const Standard_Real TolConf, |
84 | const Standard_Real Tol) { |
85 | this->ResetFields(); |
86 | Standard_Integer NbInterC2 = ThePCurveTool::NbIntervals(C2); |
87 | if(NbInterC2 > 1) { |
88 | Standard_Real ParamInf,ParamSup; |
89 | Standard_Real D2FirstParam = D2.FirstParameter(); |
90 | Standard_Real D2LastParam = D2.LastParameter(); |
91 | Standard_Boolean Ok = Standard_True; |
92 | param1inf = (D1.HasFirstPoint()) ? D1.FirstParameter() : -Precision::Infinite(); |
93 | param1sup = (D1.HasLastPoint()) ? D1.LastParameter() : Precision::Infinite(); |
94 | param2inf = ThePCurveTool::FirstParameter(C2); |
95 | param2sup = ThePCurveTool::LastParameter(C2); |
96 | IntRes2d_Domain DomainC2NumInter; |
97 | |
98 | TColStd_Array1OfReal Tab2(1,NbInterC2+1); |
99 | ThePCurveTool::Intervals(C2,Tab2); |
100 | |
101 | for(Standard_Integer NumInterC2=1; Ok && (NumInterC2 <= NbInterC2);NumInterC2++) { |
102 | ThePCurveTool::GetInterval(C2,NumInterC2,Tab2,ParamInf,ParamSup); |
103 | if((ParamInf > D2LastParam)||(ParamSup < D2FirstParam)) Ok=Standard_False; |
104 | else { |
105 | if(ParamInf < D2FirstParam) ParamInf = D2FirstParam; |
106 | if(ParamSup > D2LastParam) ParamSup = D2LastParam; |
107 | if((ParamSup - ParamInf) > RealEpsilon()) { |
108 | DomainC2NumInter.SetValues(ThePCurveTool::Value(C2,ParamInf), |
109 | ParamInf, |
110 | D2.FirstTolerance(), |
111 | ThePCurveTool::Value(C2,ParamSup), |
112 | ParamSup, |
113 | D2.LastTolerance()); |
114 | InternalPerform(Lin1,D1,C2,DomainC2NumInter,TolConf,Tol,Standard_True); |
115 | } |
116 | } |
117 | } |
118 | } |
119 | else { |
120 | InternalPerform(Lin1,D1,C2,D2,TolConf,Tol,Standard_False); |
121 | } |
122 | } |
123 | //-------------------------------------------------------------------------------- |
124 | void IntCurve_UserIntConicCurveGen::Perform (const gp_Circ2d& Circ1, |
125 | const IntRes2d_Domain& D1, |
126 | const ThePCurve& C2, |
127 | const IntRes2d_Domain& D2, |
128 | const Standard_Real TolConf, |
129 | const Standard_Real Tol) { |
130 | this->ResetFields(); |
131 | Standard_Integer NbInterC2 = ThePCurveTool::NbIntervals(C2); |
132 | if(NbInterC2 > 1) { |
133 | Standard_Real ParamInf,ParamSup; |
134 | Standard_Real D2FirstParam = D2.FirstParameter(); |
135 | Standard_Real D2LastParam = D2.LastParameter(); |
136 | Standard_Boolean Ok = Standard_True; |
137 | |
138 | param1inf = (D1.HasFirstPoint()) ? D1.FirstParameter() : -Precision::Infinite(); |
139 | param1sup = (D1.HasLastPoint()) ? D1.LastParameter() : Precision::Infinite(); |
140 | param2inf = ThePCurveTool::FirstParameter(C2); |
141 | param2sup = ThePCurveTool::LastParameter(C2); |
142 | IntRes2d_Domain DomainC2NumInter; |
143 | |
144 | TColStd_Array1OfReal Tab2(1,NbInterC2+1); |
145 | ThePCurveTool::Intervals(C2,Tab2); |
146 | |
147 | |
148 | for(Standard_Integer NumInterC2=1; Ok && (NumInterC2<=NbInterC2);NumInterC2++) { |
149 | ThePCurveTool::GetInterval(C2,NumInterC2,Tab2,ParamInf,ParamSup); |
150 | if((ParamInf > D2LastParam)||(ParamSup < D2FirstParam)) Ok=Standard_False; |
151 | else { |
152 | if(ParamInf < D2FirstParam) ParamInf = D2FirstParam; |
153 | if(ParamSup > D2LastParam) ParamSup = D2LastParam; |
154 | if((ParamSup - ParamInf) > RealEpsilon()) { |
155 | DomainC2NumInter.SetValues(ThePCurveTool::Value(C2,ParamInf), |
156 | ParamInf, |
157 | D2.FirstTolerance(), |
158 | ThePCurveTool::Value(C2,ParamSup), |
159 | ParamSup, |
160 | D2.LastTolerance()); |
161 | InternalPerform(Circ1,D1,C2,DomainC2NumInter,TolConf,Tol,Standard_True); |
162 | } |
163 | } |
164 | } |
165 | } |
166 | else { |
167 | InternalPerform(Circ1,D1,C2,D2,TolConf,Tol,Standard_False); |
168 | } |
169 | } |
170 | //-------------------------------------------------------------------------------- |
171 | void IntCurve_UserIntConicCurveGen::Perform (const gp_Parab2d& Parab1, |
172 | const IntRes2d_Domain& D1, |
173 | const ThePCurve& C2, |
174 | const IntRes2d_Domain& D2, |
175 | const Standard_Real TolConf, |
176 | const Standard_Real Tol) { |
177 | this->ResetFields(); |
178 | Standard_Integer NbInterC2 = ThePCurveTool::NbIntervals(C2); |
179 | if(NbInterC2 > 1) { |
180 | Standard_Real ParamInf,ParamSup; |
181 | Standard_Real D2FirstParam = D2.FirstParameter(); |
182 | Standard_Real D2LastParam = D2.LastParameter(); |
183 | Standard_Boolean Ok = Standard_True; |
184 | param1inf = (D1.HasFirstPoint()) ? D1.FirstParameter() : -Precision::Infinite(); |
185 | param1sup = (D1.HasLastPoint()) ? D1.LastParameter() : Precision::Infinite(); |
186 | param2inf = ThePCurveTool::FirstParameter(C2); |
187 | param2sup = ThePCurveTool::LastParameter(C2); |
188 | IntRes2d_Domain DomainC2NumInter; |
189 | |
190 | TColStd_Array1OfReal Tab2(1,NbInterC2+1); |
191 | ThePCurveTool::Intervals(C2,Tab2); |
192 | |
193 | for(Standard_Integer NumInterC2=1; Ok && (NumInterC2<=NbInterC2);NumInterC2++) { |
194 | ThePCurveTool::GetInterval(C2,NumInterC2,Tab2,ParamInf,ParamSup); |
195 | if((ParamInf > D2LastParam)||(ParamSup < D2FirstParam)) Ok=Standard_False; |
196 | else { |
197 | if(ParamInf < D2FirstParam) ParamInf = D2FirstParam; |
198 | if(ParamSup > D2LastParam) ParamSup = D2LastParam; |
199 | if((ParamSup - ParamInf) > RealEpsilon()) { |
200 | DomainC2NumInter.SetValues(ThePCurveTool::Value(C2,ParamInf), |
201 | ParamInf, |
202 | D2.FirstTolerance(), |
203 | ThePCurveTool::Value(C2,ParamSup), |
204 | ParamSup, |
205 | D2.LastTolerance()); |
206 | InternalPerform(Parab1,D1,C2,DomainC2NumInter,TolConf,Tol,Standard_True); |
207 | } |
208 | } |
209 | } |
210 | } |
211 | else { |
212 | InternalPerform(Parab1,D1,C2,D2,TolConf,Tol,Standard_False); |
213 | } |
214 | } |
215 | //-------------------------------------------------------------------------------- |
216 | void IntCurve_UserIntConicCurveGen::Perform (const gp_Elips2d& Elips1, |
217 | const IntRes2d_Domain& D1, |
218 | const ThePCurve& C2, |
219 | const IntRes2d_Domain& D2, |
220 | const Standard_Real TolConf, |
221 | const Standard_Real Tol) { |
222 | this->ResetFields(); |
223 | Standard_Integer NbInterC2 = ThePCurveTool::NbIntervals(C2); |
224 | if(NbInterC2 > 1) { |
225 | Standard_Real ParamInf,ParamSup; |
226 | Standard_Real D2FirstParam = D2.FirstParameter(); |
227 | Standard_Real D2LastParam = D2.LastParameter(); |
228 | Standard_Boolean Ok = Standard_True; |
229 | param1inf = (D1.HasFirstPoint()) ? D1.FirstParameter() : -Precision::Infinite(); |
230 | param1sup = (D1.HasLastPoint()) ? D1.LastParameter() : Precision::Infinite(); |
231 | param2inf = ThePCurveTool::FirstParameter(C2); |
232 | param2sup = ThePCurveTool::LastParameter(C2); |
233 | IntRes2d_Domain DomainC2NumInter; |
234 | |
235 | TColStd_Array1OfReal Tab2(1,NbInterC2+1); |
236 | ThePCurveTool::Intervals(C2,Tab2); |
237 | |
238 | for(Standard_Integer NumInterC2=1; Ok && (NumInterC2<=NbInterC2);NumInterC2++) { |
239 | ThePCurveTool::GetInterval(C2,NumInterC2,Tab2,ParamInf,ParamSup); |
240 | if((ParamInf > D2LastParam)||(ParamSup < D2FirstParam)) Ok=Standard_False; |
241 | else { |
242 | if(ParamInf < D2FirstParam) ParamInf = D2FirstParam; |
243 | if(ParamSup > D2LastParam) ParamSup = D2LastParam; |
244 | if((ParamSup - ParamInf) > RealEpsilon()) { |
245 | DomainC2NumInter.SetValues(ThePCurveTool::Value(C2,ParamInf), |
246 | ParamInf, |
247 | D2.FirstTolerance(), |
248 | ThePCurveTool::Value(C2,ParamSup), |
249 | ParamSup, |
250 | D2.LastTolerance()); |
251 | InternalPerform(Elips1,D1,C2,DomainC2NumInter,TolConf,Tol,Standard_True); |
252 | } |
253 | } |
254 | } |
255 | } |
256 | else { |
257 | InternalPerform(Elips1,D1,C2,D2,TolConf,Tol,Standard_False); |
258 | } |
259 | } |
260 | //-------------------------------------------------------------------------------- |
261 | void IntCurve_UserIntConicCurveGen::Perform (const gp_Hypr2d& Hyper1, |
262 | const IntRes2d_Domain& D1, |
263 | const ThePCurve& C2, |
264 | const IntRes2d_Domain& D2, |
265 | const Standard_Real TolConf, |
266 | const Standard_Real Tol) { |
267 | this->ResetFields(); |
268 | Standard_Integer NbInterC2 = ThePCurveTool::NbIntervals(C2); |
269 | if(NbInterC2 > 1) { |
270 | Standard_Real ParamInf,ParamSup; |
271 | Standard_Real D2FirstParam = D2.FirstParameter(); |
272 | Standard_Real D2LastParam = D2.LastParameter(); |
273 | Standard_Boolean Ok = Standard_True; |
274 | param1inf = (D1.HasFirstPoint()) ? D1.FirstParameter() : -Precision::Infinite(); |
275 | param1sup = (D1.HasLastPoint()) ? D1.LastParameter() : Precision::Infinite(); |
276 | param2inf = ThePCurveTool::FirstParameter(C2); |
277 | param2sup = ThePCurveTool::LastParameter(C2); |
278 | IntRes2d_Domain DomainC2NumInter; |
279 | |
280 | TColStd_Array1OfReal Tab2(1,NbInterC2+1); |
281 | ThePCurveTool::Intervals(C2,Tab2); |
282 | |
283 | for(Standard_Integer NumInterC2=1; Ok && (NumInterC2<=NbInterC2);NumInterC2++) { |
284 | ThePCurveTool::GetInterval(C2,NumInterC2,Tab2,ParamInf,ParamSup); |
285 | if((ParamInf > D2LastParam)||(ParamSup < D2FirstParam)) Ok=Standard_False; |
286 | else { |
287 | if(ParamInf < D2FirstParam) ParamInf = D2FirstParam; |
288 | if(ParamSup > D2LastParam) ParamSup = D2LastParam; |
289 | if((ParamSup - ParamInf) > RealEpsilon()) { |
290 | DomainC2NumInter.SetValues(ThePCurveTool::Value(C2,ParamInf), |
291 | ParamInf, |
292 | D2.FirstTolerance(), |
293 | ThePCurveTool::Value(C2,ParamSup), |
294 | ParamSup, |
295 | D2.LastTolerance()); |
296 | InternalPerform(Hyper1,D1,C2,DomainC2NumInter,TolConf,Tol,Standard_True); |
297 | } |
298 | } |
299 | } |
300 | } |
301 | else { |
302 | InternalPerform(Hyper1,D1,C2,D2,TolConf,Tol,Standard_False); |
303 | } |
304 | } |
305 | |
306 | //---------------------------------------------------------------------- |
307 | //-- InternalPerform |
308 | //-- Suppose des Courbes Lin...Hypr |
309 | //-- Si Composite == True |
310 | //-- Les Resultats sont Ajoutes |
311 | //-- Sinon |
312 | //-- Les Resultats sont Copies |
313 | //---------------------------------------------------------------------- |
314 | void IntCurve_UserIntConicCurveGen::InternalPerform (const gp_Lin2d& Lin1, |
315 | const IntRes2d_Domain& D1, |
316 | const ThePCurve& C2, |
317 | const IntRes2d_Domain& D2, |
318 | const Standard_Real TolConf, |
319 | const Standard_Real Tol, |
320 | const Standard_Boolean Composite) { |
321 | |
32ca7a51 |
322 | GeomAbs_CurveType typ2 = ThePCurveTool::GetType(C2); |
7fd59977 |
323 | |
324 | switch (typ2) { |
325 | |
326 | case GeomAbs_Line: |
327 | { |
328 | intconiconi.SetReversedParameters(Standard_False); |
329 | intconiconi.Perform(Lin1,D1,ThePCurveTool::Line(C2),D2,TolConf,Tol); |
330 | if(Composite) { this->Append(intconiconi, |
331 | param1inf, |
332 | param1sup, |
333 | param2inf, |
334 | param2sup); } |
335 | else { this->SetValues(intconiconi); } |
336 | } |
337 | break; |
338 | |
339 | case GeomAbs_Circle: |
340 | { |
341 | intconiconi.SetReversedParameters(Standard_False); |
342 | intconiconi.Perform(Lin1,D1,ThePCurveTool::Circle(C2),D2,TolConf,Tol); |
343 | if(Composite) { this->Append(intconiconi, |
344 | param1inf, |
345 | param1sup, |
346 | param2inf, |
347 | param2sup); } |
348 | else { this->SetValues(intconiconi); } |
349 | } |
350 | break; |
351 | |
352 | case GeomAbs_Ellipse: |
353 | { |
354 | intconiconi.SetReversedParameters(Standard_False); |
355 | intconiconi.Perform(Lin1,D1,ThePCurveTool::Ellipse(C2),D2,TolConf,Tol); |
356 | if(Composite) { this->Append(intconiconi, |
357 | param1inf, |
358 | param1sup, |
359 | param2inf, |
360 | param2sup); } |
361 | else { this->SetValues(intconiconi); } |
362 | } |
363 | break; |
364 | |
365 | case GeomAbs_Parabola: |
366 | { |
367 | intconiconi.SetReversedParameters(Standard_False); |
368 | intconiconi.Perform(Lin1,D1,ThePCurveTool::Parabola(C2),D2,TolConf,Tol); |
369 | if(Composite) { this->Append(intconiconi, |
370 | param1inf, |
371 | param1sup, |
372 | param2inf, |
373 | param2sup); } |
374 | else { this->SetValues(intconiconi); } |
375 | } |
376 | break; |
377 | |
378 | case GeomAbs_Hyperbola: |
379 | { |
380 | intconiconi.SetReversedParameters(Standard_False); |
381 | intconiconi.Perform(Lin1,D1,ThePCurveTool::Hyperbola(C2),D2,TolConf,Tol); |
382 | if(Composite) { this->Append(intconiconi, |
383 | param1inf, |
384 | param1sup, |
385 | param2inf, |
386 | param2sup); } |
387 | else { this->SetValues(intconiconi); } |
388 | } |
389 | break; |
390 | |
1aec3320 |
391 | default: |
7fd59977 |
392 | { |
393 | intconicurv.SetReversedParameters(Standard_False); |
394 | intconicurv.Perform(Lin1,D1,C2,D2,TolConf,Tol); |
395 | if(Composite) { this->Append(intconicurv, |
396 | param1inf, |
397 | param1sup, |
398 | param2inf, |
399 | param2sup); } |
400 | else { this->SetValues(intconicurv); } |
401 | } |
402 | break; |
403 | } |
404 | } |
405 | |
406 | //---------------------------------------------------------------------- |
407 | void IntCurve_UserIntConicCurveGen::InternalPerform (const gp_Circ2d& Circ1, |
408 | const IntRes2d_Domain& D1, |
409 | const ThePCurve& C2, |
410 | const IntRes2d_Domain& D2, |
411 | const Standard_Real TolConf, |
412 | const Standard_Real Tol, |
413 | const Standard_Boolean Composite) { |
414 | |
32ca7a51 |
415 | GeomAbs_CurveType typ2 = ThePCurveTool::GetType(C2); |
7fd59977 |
416 | |
417 | switch (typ2) { |
418 | |
419 | case GeomAbs_Line: |
420 | { |
421 | intconiconi.SetReversedParameters(Standard_True); |
422 | intconiconi.Perform(ThePCurveTool::Line(C2),D2,Circ1,D1,TolConf,Tol); |
423 | if(Composite) { this->Append(intconiconi, |
424 | param1inf, |
425 | param1sup, |
426 | param2inf, |
427 | param2sup); } |
428 | else { this->SetValues(intconiconi); } |
429 | } |
430 | break; |
431 | |
432 | case GeomAbs_Circle: |
433 | { |
434 | intconiconi.SetReversedParameters(Standard_False); |
435 | intconiconi.Perform(Circ1,D1,ThePCurveTool::Circle(C2),D2,TolConf,Tol); |
436 | if(Composite) { this->Append(intconiconi, |
437 | param1inf, |
438 | param1sup, |
439 | param2inf, |
440 | param2sup); } |
441 | else { this->SetValues(intconiconi); } |
442 | } |
443 | break; |
444 | |
445 | case GeomAbs_Ellipse: |
446 | { |
447 | intconiconi.SetReversedParameters(Standard_False); |
448 | intconiconi.Perform(Circ1,D1,ThePCurveTool::Ellipse(C2),D2,TolConf,Tol); |
449 | if(Composite) { this->Append(intconiconi, |
450 | param1inf, |
451 | param1sup, |
452 | param2inf, |
453 | param2sup); } |
454 | else { this->SetValues(intconiconi); } |
455 | } |
456 | break; |
457 | |
458 | case GeomAbs_Parabola: |
459 | { |
460 | intconiconi.SetReversedParameters(Standard_False); |
461 | intconiconi.Perform(Circ1,D1,ThePCurveTool::Parabola(C2),D2,TolConf,Tol); |
462 | if(Composite) { this->Append(intconiconi, |
463 | param1inf, |
464 | param1sup, |
465 | param2inf, |
466 | param2sup); } |
467 | else { this->SetValues(intconiconi); } |
468 | } |
469 | break; |
470 | |
471 | case GeomAbs_Hyperbola: |
472 | { |
473 | intconiconi.SetReversedParameters(Standard_False); |
474 | intconiconi.Perform(Circ1,D1,ThePCurveTool::Hyperbola(C2),D2,TolConf,Tol); |
475 | if(Composite) { this->Append(intconiconi, |
476 | param1inf, |
477 | param1sup, |
478 | param2inf, |
479 | param2sup); } |
480 | else { this->SetValues(intconiconi); } |
481 | } |
482 | break; |
483 | |
1aec3320 |
484 | default: |
7fd59977 |
485 | { |
486 | intconicurv.SetReversedParameters(Standard_False); |
487 | intconicurv.Perform(Circ1,D1,C2,D2,TolConf,Tol); |
488 | if(Composite) { this->Append(intconicurv, |
489 | param1inf, |
490 | param1sup, |
491 | param2inf, |
492 | param2sup); } |
493 | else { this->SetValues(intconicurv); } |
494 | } |
495 | break; |
496 | } |
497 | } |
498 | //---------------------------------------------------------------------- |
499 | void IntCurve_UserIntConicCurveGen::InternalPerform (const gp_Elips2d& Elips1, |
500 | const IntRes2d_Domain& D1, |
501 | const ThePCurve& C2, |
502 | const IntRes2d_Domain& D2, |
503 | const Standard_Real TolConf, |
504 | const Standard_Real Tol, |
505 | const Standard_Boolean Composite) { |
506 | |
32ca7a51 |
507 | GeomAbs_CurveType typ2 = ThePCurveTool::GetType(C2); |
7fd59977 |
508 | |
509 | switch (typ2) { |
510 | |
511 | case GeomAbs_Line: |
512 | { |
513 | intconiconi.SetReversedParameters(Standard_True); |
514 | intconiconi.Perform(ThePCurveTool::Line(C2),D2,Elips1,D1,TolConf,Tol); |
515 | if(Composite) { this->Append(intconiconi, |
516 | param1inf, |
517 | param1sup, |
518 | param2inf, |
519 | param2sup); } |
520 | else { this->SetValues(intconiconi); } |
521 | } |
522 | break; |
523 | |
524 | case GeomAbs_Circle: |
525 | { |
526 | intconiconi.SetReversedParameters(Standard_True); |
527 | intconiconi.Perform(ThePCurveTool::Circle(C2),D2,Elips1,D1,TolConf,Tol); |
528 | if(Composite) { this->Append(intconiconi, |
529 | param1inf, |
530 | param1sup, |
531 | param2inf, |
532 | param2sup); } |
533 | else { this->SetValues(intconiconi); } |
534 | } |
535 | break; |
536 | |
537 | case GeomAbs_Ellipse: |
538 | { |
539 | intconiconi.SetReversedParameters(Standard_False); |
540 | intconiconi.Perform(Elips1,D1,ThePCurveTool::Ellipse(C2),D2,TolConf,Tol); |
541 | if(Composite) { this->Append(intconiconi, |
542 | param1inf, |
543 | param1sup, |
544 | param2inf, |
545 | param2sup); } |
546 | else { this->SetValues(intconiconi); } |
547 | } |
548 | break; |
549 | |
550 | case GeomAbs_Parabola: |
551 | { |
552 | intconiconi.SetReversedParameters(Standard_False); |
553 | intconiconi.Perform(Elips1,D1,ThePCurveTool::Parabola(C2),D2,TolConf,Tol); |
554 | if(Composite) { this->Append(intconiconi, |
555 | param1inf, |
556 | param1sup, |
557 | param2inf, |
558 | param2sup); } |
559 | else { this->SetValues(intconiconi); } |
560 | } |
561 | break; |
562 | |
563 | case GeomAbs_Hyperbola: |
564 | { |
565 | intconiconi.SetReversedParameters(Standard_False); |
566 | intconiconi.Perform(Elips1,D1,ThePCurveTool::Hyperbola(C2),D2, |
567 | TolConf,Tol); |
568 | if(Composite) { this->Append(intconiconi, |
569 | param1inf, |
570 | param1sup, |
571 | param2inf, |
572 | param2sup); } |
573 | else { this->SetValues(intconiconi); } |
574 | } |
575 | break; |
576 | |
1aec3320 |
577 | default: |
7fd59977 |
578 | { |
579 | intconicurv.SetReversedParameters(Standard_False); |
580 | intconicurv.Perform(Elips1,D1,C2,D2,TolConf,Tol); |
581 | if(Composite) { this->Append(intconicurv, |
582 | param1inf, |
583 | param1sup, |
584 | param2inf, |
585 | param2sup); } |
586 | else { this->SetValues(intconicurv); } |
587 | } |
588 | break; |
589 | } |
590 | } |
591 | |
592 | //---------------------------------------------------------------------- |
593 | void IntCurve_UserIntConicCurveGen::InternalPerform (const gp_Parab2d& Parab1, |
594 | const IntRes2d_Domain& D1, |
595 | const ThePCurve& C2, |
596 | const IntRes2d_Domain& D2, |
597 | const Standard_Real TolConf, |
598 | const Standard_Real Tol, |
599 | const Standard_Boolean Composite) { |
600 | |
32ca7a51 |
601 | GeomAbs_CurveType typ2 = ThePCurveTool::GetType(C2); |
7fd59977 |
602 | |
603 | switch (typ2) { |
604 | |
605 | case GeomAbs_Line: |
606 | { |
607 | intconiconi.SetReversedParameters(Standard_True); |
608 | intconiconi.Perform(ThePCurveTool::Line(C2),D2,Parab1,D1,TolConf,Tol); |
609 | if(Composite) { this->Append(intconiconi, |
610 | param1inf, |
611 | param1sup, |
612 | param2inf, |
613 | param2sup); } |
614 | else { this->SetValues(intconiconi); } |
615 | } |
616 | break; |
617 | |
618 | case GeomAbs_Circle: |
619 | { |
620 | intconiconi.SetReversedParameters(Standard_True); |
621 | intconiconi.Perform(ThePCurveTool::Circle(C2),D2,Parab1,D1,TolConf,Tol); |
622 | if(Composite) { this->Append(intconiconi, |
623 | param1inf, |
624 | param1sup, |
625 | param2inf, |
626 | param2sup); } |
627 | else { this->SetValues(intconiconi); } |
628 | } |
629 | break; |
630 | |
631 | case GeomAbs_Ellipse: |
632 | { |
633 | intconiconi.SetReversedParameters(Standard_True); |
634 | intconiconi.Perform(ThePCurveTool::Ellipse(C2),D2,Parab1,D1,TolConf,Tol); |
635 | if(Composite) { this->Append(intconiconi, |
636 | param1inf, |
637 | param1sup, |
638 | param2inf, |
639 | param2sup); } |
640 | else { this->SetValues(intconiconi); } |
641 | } |
642 | break; |
643 | |
644 | case GeomAbs_Parabola: |
645 | { |
646 | intconiconi.SetReversedParameters(Standard_False); |
647 | intconiconi.Perform(Parab1,D1,ThePCurveTool::Parabola(C2),D2,TolConf,Tol); |
648 | if(Composite) { this->Append(intconiconi, |
649 | param1inf, |
650 | param1sup, |
651 | param2inf, |
652 | param2sup); } |
653 | else { this->SetValues(intconiconi); } |
654 | } |
655 | break; |
656 | |
657 | case GeomAbs_Hyperbola: |
658 | { |
659 | intconiconi.SetReversedParameters(Standard_False); |
660 | intconiconi.Perform(Parab1,D1,ThePCurveTool::Hyperbola(C2),D2,TolConf,Tol); |
661 | if(Composite) { this->Append(intconiconi, |
662 | param1inf, |
663 | param1sup, |
664 | param2inf, |
665 | param2sup); } |
666 | else { this->SetValues(intconiconi); } |
667 | } |
668 | break; |
669 | |
1aec3320 |
670 | default: |
7fd59977 |
671 | { |
672 | intconicurv.SetReversedParameters(Standard_False); |
673 | intconicurv.Perform(Parab1,D1,C2,D2,TolConf,Tol); |
674 | if(Composite) { this->Append(intconicurv, |
675 | param1inf, |
676 | param1sup, |
677 | param2inf, |
678 | param2sup); } |
679 | else { this->SetValues(intconicurv); } |
680 | } |
681 | break; |
682 | } |
683 | } |
684 | |
685 | //---------------------------------------------------------------------- |
686 | void IntCurve_UserIntConicCurveGen::InternalPerform (const gp_Hypr2d& Hyper1, |
687 | const IntRes2d_Domain& D1, |
688 | const ThePCurve& C2, |
689 | const IntRes2d_Domain& D2, |
690 | const Standard_Real TolConf, |
691 | const Standard_Real Tol, |
692 | const Standard_Boolean Composite) { |
693 | |
32ca7a51 |
694 | GeomAbs_CurveType typ2 = ThePCurveTool::GetType(C2); |
7fd59977 |
695 | |
696 | switch (typ2) { |
697 | |
698 | case GeomAbs_Line: |
699 | { |
700 | intconiconi.SetReversedParameters(Standard_True); |
701 | intconiconi.Perform(ThePCurveTool::Line(C2),D2,Hyper1,D1,TolConf,Tol); |
702 | if(Composite) { this->Append(intconiconi, |
703 | param1inf, |
704 | param1sup, |
705 | param2inf, |
706 | param2sup); } |
707 | else { this->SetValues(intconiconi); } |
708 | } |
709 | break; |
710 | |
711 | case GeomAbs_Circle: |
712 | { |
713 | intconiconi.SetReversedParameters(Standard_True); |
714 | intconiconi.Perform(ThePCurveTool::Circle(C2),D2,Hyper1,D1,TolConf,Tol); |
715 | if(Composite) { this->Append(intconiconi, |
716 | param1inf, |
717 | param1sup, |
718 | param2inf, |
719 | param2sup); } |
720 | else { this->SetValues(intconiconi); } |
721 | } |
722 | break; |
723 | |
724 | case GeomAbs_Ellipse: |
725 | { |
726 | intconiconi.SetReversedParameters(Standard_True); |
727 | intconiconi.Perform(ThePCurveTool::Ellipse(C2),D2,Hyper1,D1,TolConf,Tol); |
728 | if(Composite) { this->Append(intconiconi, |
729 | param1inf, |
730 | param1sup, |
731 | param2inf, |
732 | param2sup); } |
733 | else { this->SetValues(intconiconi); } |
734 | } |
735 | break; |
736 | |
737 | case GeomAbs_Parabola: |
738 | { |
739 | intconiconi.SetReversedParameters(Standard_True); |
740 | intconiconi.Perform(ThePCurveTool::Parabola(C2),D2,Hyper1,D1,TolConf,Tol); |
741 | if(Composite) { this->Append(intconiconi, |
742 | param1inf, |
743 | param1sup, |
744 | param2inf, |
745 | param2sup); } |
746 | else { this->SetValues(intconiconi); } |
747 | } |
748 | break; |
749 | |
750 | case GeomAbs_Hyperbola: |
751 | { |
752 | intconiconi.SetReversedParameters(Standard_False); |
753 | intconiconi.Perform(Hyper1,D1,ThePCurveTool::Hyperbola(C2),D2,TolConf,Tol); |
754 | if(Composite) { this->Append(intconiconi, |
755 | param1inf, |
756 | param1sup, |
757 | param2inf, |
758 | param2sup); } |
759 | else { this->SetValues(intconiconi); } |
760 | } |
761 | break; |
762 | |
1aec3320 |
763 | default: |
7fd59977 |
764 | { |
765 | intconicurv.SetReversedParameters(Standard_False); |
766 | intconicurv.Perform(Hyper1,D1, |
767 | C2,D2,TolConf,Tol); |
768 | if(Composite) { this->Append(intconicurv, |
769 | param1inf, |
770 | param1sup, |
771 | param2inf, |
772 | param2sup); } |
773 | else { this->SetValues(intconicurv); } |
774 | } |
775 | break; |
776 | } |
777 | } |
778 | //-------------------------------------------------------------------------------- |