0024927: Getting rid of "Persistent" functionality -- Code
[occt.git] / src / MgtGeom2d / MgtGeom2d.cxx
1 // Created on: 1993-04-14
2 // Created by: Philippe DAUTRY
3 // Copyright (c) 1993-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 <MgtGeom2d.ixx>
18
19 #include <Standard_Type.hxx>
20
21 #include <PColStd_HArray1OfInteger.hxx>
22 #include <PColStd_HArray2OfInteger.hxx>
23 #include <PColStd_HArray1OfReal.hxx>
24 #include <PColStd_HArray2OfReal.hxx>
25
26 #include <TColStd_Array1OfInteger.hxx>
27 #include <TColStd_Array2OfInteger.hxx>
28 #include <TColStd_HArray1OfInteger.hxx>
29
30 #include <TColStd_Array1OfReal.hxx>
31 #include <TColStd_Array2OfReal.hxx>
32 #include <TColStd_HArray1OfReal.hxx>
33 #include <TColStd_HArray2OfReal.hxx>
34
35 #include <TColgp_Array1OfPnt2d.hxx>
36 #include <TColgp_Array2OfPnt2d.hxx>
37 #include <TColgp_HArray1OfPnt2d.hxx>
38 #include <TColgp_HArray2OfPnt2d.hxx>
39
40 #include <PColgp_HArray1OfPnt2d.hxx>
41 #include <PColgp_HArray2OfPnt2d.hxx>
42
43 #include <gp_Vec.hxx>
44 #include <gp_Ax1.hxx>
45
46 //modif wok++
47 #include <gp_Circ2d.hxx>
48 #include <Standard_NullObject.hxx>
49 #include <gp_Lin2d.hxx>
50
51 // *******************************************************************
52 // The following methods are subroutines used to copy elements
53 // from structures to other structures, as array1 or array2.
54 // *******************************************************************
55
56 // *******************************************************************
57 // Structures from TCollection to structures from PCollection.
58 // *******************************************************************
59
60 //=======================================================================
61 //function : ArrayCopy
62 //purpose  : Copy the gp_Pnt2d
63 //           from an Array1 from TColgp (TCollection)
64 //           to an HArray1 from PColgp (PCollection)
65 //=======================================================================
66
67 static Handle(PColgp_HArray1OfPnt2d) ArrayCopy
68        (const TColgp_Array1OfPnt2d& TArray)
69 {
70   Standard_Integer Lower = TArray.Lower();
71   Standard_Integer Upper = TArray.Upper();
72   Standard_Integer Index;
73   Handle(PColgp_HArray1OfPnt2d) PArray = 
74     new PColgp_HArray1OfPnt2d(Lower, Upper);
75   for (Index = Lower; Index <= Upper; Index++) {
76     PArray->SetValue(Index, TArray(Index));
77   }
78   return PArray;
79 }
80
81 //=======================================================================
82 //function : ArrayCopy
83 //purpose  : Copy the Standard_Real
84 //           from an Array1 from TColStd (TCollection)
85 //           to an SingleArray from PCollection
86 //=======================================================================
87
88 static Handle(PColStd_HArray1OfReal) ArrayCopy
89        (const TColStd_Array1OfReal& TArray)
90 {
91   Standard_Integer Lower = TArray.Lower();
92   Standard_Integer Upper = TArray.Upper();
93   Standard_Integer Index;
94   Handle(PColStd_HArray1OfReal) PArray =
95     new PColStd_HArray1OfReal(Lower, Upper);
96   for (Index = Lower; Index <= Upper; Index++) {
97     PArray->SetValue(Index, TArray(Index));
98   }
99   return PArray;
100 }
101
102 //=======================================================================
103 //function : ArrayCopy
104 //purpose  : Copy the Standard_Integer
105 //           from an Array1 from TColStd (TCollection)
106 //           to an SingleArray from PCollection
107 //=======================================================================
108
109 static Handle(PColStd_HArray1OfInteger) ArrayCopy
110        (const TColStd_Array1OfInteger& TArray)
111 {
112   Standard_Integer Lower = TArray.Lower();
113   Standard_Integer Upper = TArray.Upper();
114   Standard_Integer Index;
115   Handle(PColStd_HArray1OfInteger) PArray =
116     new PColStd_HArray1OfInteger(Lower, Upper);
117   for (Index = Lower; Index <= Upper; Index++) {
118     PArray->SetValue(Index, TArray(Index));
119   }
120   return PArray;
121 }
122
123 // *******************************************************************
124 // Structures from PCollection to structures from TCollection.
125 // *******************************************************************
126
127 //=======================================================================
128 //function : ArrayCopy
129 //purpose  : Copy the gp_Pnt2d
130 //           from an HArray1 from PColgp (PCollection)
131 //           to an Array1 from TColgp (TCollection)
132 //=======================================================================
133
134 static void ArrayCopy
135   (const Handle(PColgp_HArray1OfPnt2d)& PArray,
136    TColgp_Array1OfPnt2d& TArray)
137 {
138   Standard_Integer Lower = PArray->Lower();
139   Standard_Integer Upper = PArray->Upper();
140   Standard_Integer Index;
141   for (Index = Lower; Index <= Upper; Index++) {
142     TArray(Index) = PArray->Value(Index);
143   }
144 }
145
146 //=======================================================================
147 //function : ArrayCopy
148 //purpose  : Copy the Standard_Real
149 //           from an SingleArray from PCollection
150 //           to an Array1 from TColStd (TCollection)
151 //=======================================================================
152
153 static void ArrayCopy
154   (const Handle(PColStd_HArray1OfReal)& PArray,
155    TColStd_Array1OfReal& TArray)
156 {
157   Standard_Integer Lower = PArray->Lower();
158   Standard_Integer Upper = PArray->Upper();
159   Standard_Integer Index;
160   for (Index = Lower; Index <= Upper; Index++) {
161     TArray(Index) = PArray->Value(Index);
162   }
163 }
164
165 //=======================================================================
166 //function : ArrayCopy
167 //purpose  : Copy the Standard_Integer
168 //           from an SingleArray from PCollection
169 //           to an Array1 from TColStd (TCollection)
170 //=======================================================================
171
172 static void ArrayCopy
173   (const Handle(PColStd_HArray1OfInteger)& PArray,
174    TColStd_Array1OfInteger& TArray)
175 {
176   Standard_Integer Lower = PArray->Lower();
177   Standard_Integer Upper = PArray->Upper();
178   Standard_Integer Index;
179   for (Index = Lower; Index <= Upper; Index++) {
180     TArray(Index) = PArray->Value(Index);
181   }
182 }
183
184
185
186 // *******************************************************************
187 // Here is the implementation of the package methods.
188 // *******************************************************************
189
190
191 //=======================================================================
192 //function : Translate
193 //purpose  : Translates a PGeom2d_AxisPlacement to a Geom2d_AxisPlacement.
194 //=======================================================================
195
196 Handle(Geom2d_AxisPlacement)  MgtGeom2d::Translate
197        (const Handle(PGeom2d_AxisPlacement)& PObj)
198 {
199   return new Geom2d_AxisPlacement(PObj->Axis());
200 }
201
202
203 //=======================================================================
204 //function : Translate
205 //purpose  : Translates a Geom2d_AxisPlacement to a PGeom2d_AxisPlacement.
206 //=======================================================================
207
208 Handle(PGeom2d_AxisPlacement)  MgtGeom2d::Translate
209        (const Handle(Geom2d_AxisPlacement)& TObj)
210 {
211   return new PGeom2d_AxisPlacement(TObj->Ax2d());
212 }
213
214
215 //=======================================================================
216 //function : Translate
217 //purpose  : Translates a PGeom2d_BSplineCurve to a Geom2d_BSplineCurve.
218 //=======================================================================
219
220 Handle(Geom2d_BSplineCurve)  MgtGeom2d::Translate
221        (const Handle(PGeom2d_BSplineCurve)& PObj)
222 {
223   Handle(Geom2d_BSplineCurve)  TBSplC;
224
225   Handle(PColgp_HArray1OfPnt2d) oldPoles = PObj->Poles();
226   TColgp_Array1OfPnt2d newPoles (oldPoles->Lower(),oldPoles->Upper());
227   ArrayCopy(oldPoles,newPoles);
228
229   Handle(PColStd_HArray1OfInteger) oldMult = PObj->Multiplicities();
230   TColStd_Array1OfInteger newMultiplicities(oldMult->Lower(),oldMult->Upper());
231   ArrayCopy(oldMult,newMultiplicities);
232
233   Handle(PColStd_HArray1OfReal) oldKnots = PObj->Knots();
234   TColStd_Array1OfReal newKnots (oldKnots->Lower(),oldKnots->Upper());
235   ArrayCopy(oldKnots,newKnots);
236
237   if (PObj->Rational()) {
238     Handle(PColStd_HArray1OfReal) oldWeights = PObj->Weights();
239     TColStd_Array1OfReal newWeights (oldWeights->Lower(),oldWeights->Upper());
240     ArrayCopy(oldWeights,newWeights);
241     // modified by NIZHNY-MKK  Fri Oct 17 11:20:32 2003.BEGIN
242     TBSplC = new Geom2d_BSplineCurve
243       //       (newPoles, newWeights, newKnots, newMultiplicities, PObj->SpineDegree());
244       (newPoles, newWeights, newKnots, newMultiplicities, 
245        PObj->SpineDegree(), PObj->Periodic());
246     // modified by NIZHNY-MKK  Fri Oct 17 11:20:38 2003.END
247   }
248   else {
249     // modified by NIZHNY-MKK  Thu Oct 16 18:19:22 2003.BEGIN
250     TBSplC = new Geom2d_BSplineCurve
251       //       (newPoles, newKnots, newMultiplicities, PObj->SpineDegree());
252       (newPoles, newKnots, newMultiplicities, 
253        PObj->SpineDegree(), PObj->Periodic());
254     // modified by NIZHNY-MKK  Fri Oct 17 11:20:52 2003.END
255   }
256   // modified by NIZHNY-MKK  Thu Oct 16 18:19:12 2003
257   //   if (PObj->Periodic()) TBSplC->SetPeriodic();
258   return TBSplC;
259 }
260
261
262 //=======================================================================
263 //function : Translate
264 //purpose  : Translates a Geom2d_BSplineCurve to a PGeom2d_BSplineCurve.
265 //=======================================================================
266
267 Handle(PGeom2d_BSplineCurve)  MgtGeom2d::Translate
268        (const Handle(Geom2d_BSplineCurve)& TObj)
269 {
270   Standard_Integer Upper;
271
272   Upper = TObj->NbPoles();
273
274   TColgp_Array1OfPnt2d oldPoles(1, Upper);
275   TObj->Poles(oldPoles);
276   Handle(PColgp_HArray1OfPnt2d) newPPoles = ArrayCopy(oldPoles);
277   
278   Handle(PColStd_HArray1OfReal) newPWeights;
279   if (TObj->IsRational()) {
280     TColStd_Array1OfReal oldWeights(1, Upper);
281     TObj->Weights(oldWeights);
282     newPWeights = ArrayCopy(oldWeights);
283   }
284   
285   Upper = TObj->NbKnots();
286
287   TColStd_Array1OfReal oldKnots(1, Upper);
288   TObj->Knots(oldKnots);
289   Handle(PColStd_HArray1OfReal) newPKnots = ArrayCopy(oldKnots);
290
291   TColStd_Array1OfInteger oldMultiplicities(1, Upper);
292   TObj->Multiplicities(oldMultiplicities);
293   Handle(PColStd_HArray1OfInteger) newPMultiplicities =
294     ArrayCopy(oldMultiplicities);
295
296   
297   Handle(PGeom2d_BSplineCurve) PBSplC = 
298     new PGeom2d_BSplineCurve(TObj->IsRational(),
299                              TObj->IsPeriodic(),
300                              TObj->Degree(),
301                              newPPoles,
302                              newPWeights,
303                              newPKnots,
304                              newPMultiplicities);
305   return PBSplC;
306 }
307
308
309 //=======================================================================
310 //function : Translate
311 //purpose  : Translates a PGeom2d_BezierCurve to a Geom2d_BezierCurve.
312 //=======================================================================
313
314 Handle(Geom2d_BezierCurve)  MgtGeom2d::Translate
315        (const Handle(PGeom2d_BezierCurve)& PObj)
316 {
317   Handle(Geom2d_BezierCurve) TBzC;
318
319   Handle(PColgp_HArray1OfPnt2d) oldPoles = PObj->Poles();
320   TColgp_Array1OfPnt2d newPoles (oldPoles->Lower(),oldPoles->Upper());
321   ArrayCopy(oldPoles,newPoles);
322
323   if (PObj->Rational()) {
324     Handle(PColStd_HArray1OfReal) oldWeights = PObj->Weights();
325     TColStd_Array1OfReal newWeights (oldWeights->Lower(),oldWeights->Upper());
326     ArrayCopy(oldWeights,newWeights);
327     TBzC = new Geom2d_BezierCurve(newPoles, newWeights);
328   }
329   else {
330     TBzC = new Geom2d_BezierCurve(newPoles);
331   }
332   return TBzC;
333 }
334
335
336 //=======================================================================
337 //function : Translate
338 //purpose  : Translates a Geom2d_BezierCurve to a PGeom2d_BezierCurve.
339 //=======================================================================
340
341 Handle(PGeom2d_BezierCurve)  MgtGeom2d::Translate
342        (const Handle(Geom2d_BezierCurve)& TObj)
343 {
344   Standard_Integer Upper;
345
346   Upper = TObj->NbPoles();
347
348   TColgp_Array1OfPnt2d oldPoles(1, Upper);
349   TObj->Poles(oldPoles);
350   Handle(PColgp_HArray1OfPnt2d) newPPoles = ArrayCopy(oldPoles);
351   
352   Handle(PColStd_HArray1OfReal) newPWeights;
353   if (TObj->IsRational()) {
354     TColStd_Array1OfReal oldWeights(1, Upper);
355     TObj->Weights(oldWeights);
356     newPWeights = ArrayCopy(oldWeights);
357   }
358   
359   Handle(PGeom2d_BezierCurve) PBzC = new PGeom2d_BezierCurve
360     (newPPoles,
361      newPWeights,
362      TObj->IsRational());
363   return PBzC;
364 }
365
366
367 //=======================================================================
368 //function : Translate
369 //purpose  : Translates a PGeom2d_CartesianPoint to a Geom2d_CartesianPoint.
370 //=======================================================================
371
372 Handle(Geom2d_CartesianPoint)  MgtGeom2d::Translate
373        (const Handle(PGeom2d_CartesianPoint)& PObj)
374 { return new Geom2d_CartesianPoint(PObj->Pnt()); }
375
376
377 //=======================================================================
378 //function : Translate
379 //purpose  : Translates a Geom2d_CartesianPoint to a PGeom2d_CartesianPoint.
380 //=======================================================================
381
382 Handle(PGeom2d_CartesianPoint)  MgtGeom2d::Translate
383        (const Handle(Geom2d_CartesianPoint)& TObj)
384 { return new PGeom2d_CartesianPoint(TObj->Pnt2d()); }
385
386
387 //=======================================================================
388 //function : Translate
389 //purpose  : Translates a PGeom2d_Circle to a Geom2d_Circle.
390 //=======================================================================
391
392 Handle(Geom2d_Circle)  MgtGeom2d::Translate(const Handle(PGeom2d_Circle)& PObj)
393 {
394   return new Geom2d_Circle(PObj->Position(),
395                            PObj->Radius());
396 }
397
398
399 //=======================================================================
400 //function : Translate
401 //purpose  : Translates a Geom2d_Circle to a PGeom2d_Circle.
402 //=======================================================================
403
404 Handle(PGeom2d_Circle)  MgtGeom2d::Translate(const Handle(Geom2d_Circle)& TObj)
405 {
406   return new PGeom2d_Circle(TObj->Circ2d().Position(),TObj->Circ2d().Radius());
407 }
408
409
410 //=======================================================================
411 //function : Translate
412 //purpose  : Translates a PGeom2d_Curve to a Geom2d_Curve.
413 //=======================================================================
414
415 Handle(Geom2d_Curve)  MgtGeom2d::Translate(const Handle(PGeom2d_Curve)& PObj)
416 {
417   Handle(Standard_Type) CurveType = PObj->DynamicType();
418
419   if (CurveType == STANDARD_TYPE(PGeom2d_Line)) {
420     Handle(PGeom2d_Line)& TLine = 
421       (Handle(PGeom2d_Line)&) PObj;
422     return MgtGeom2d::Translate(TLine);
423   }
424   else if (CurveType ==  STANDARD_TYPE(PGeom2d_Circle)) {
425     Handle(PGeom2d_Circle)& TCircle = 
426       (Handle(PGeom2d_Circle)&) PObj;
427     return MgtGeom2d::Translate(TCircle);
428   }
429   else if (CurveType ==  STANDARD_TYPE(PGeom2d_Ellipse)) {
430     Handle(PGeom2d_Ellipse)& TEllipse = 
431       (Handle(PGeom2d_Ellipse)&) PObj;
432     return MgtGeom2d::Translate(TEllipse);
433   }
434   else if (CurveType ==  STANDARD_TYPE(PGeom2d_Hyperbola)) {
435     Handle(PGeom2d_Hyperbola)& THyperbola = 
436       (Handle(PGeom2d_Hyperbola)&) PObj;
437     return MgtGeom2d::Translate(THyperbola);
438   }
439   else if (CurveType ==  STANDARD_TYPE(PGeom2d_Parabola)) {
440     Handle(PGeom2d_Parabola)& TParabola = 
441       (Handle(PGeom2d_Parabola)&) PObj;
442     return MgtGeom2d::Translate(TParabola);
443   }
444   else if (CurveType ==  STANDARD_TYPE(PGeom2d_BezierCurve)) {
445     Handle(PGeom2d_BezierCurve)& TBezierCurve = 
446       (Handle(PGeom2d_BezierCurve)&) PObj;
447     return MgtGeom2d::Translate(TBezierCurve);
448   }
449   else if (CurveType ==  STANDARD_TYPE(PGeom2d_BSplineCurve)) {
450     Handle(PGeom2d_BSplineCurve)& TBSplineCurve = 
451       (Handle(PGeom2d_BSplineCurve)&) PObj;
452     return MgtGeom2d::Translate(TBSplineCurve);
453   }
454   else if (CurveType ==  STANDARD_TYPE(PGeom2d_TrimmedCurve)) {
455     Handle(PGeom2d_TrimmedCurve)& TTrimmedCurve = 
456       (Handle(PGeom2d_TrimmedCurve)&) PObj;
457     return MgtGeom2d::Translate(TTrimmedCurve);
458   }
459   else if (CurveType ==  STANDARD_TYPE(PGeom2d_OffsetCurve)) {
460     Handle(PGeom2d_OffsetCurve)& TOffsetCurve = 
461       (Handle(PGeom2d_OffsetCurve)&) PObj;
462     return MgtGeom2d::Translate(TOffsetCurve);
463   }
464   else {
465 #ifdef OCCT_DEBUG
466     cout << "Unknown Geom2d curve type ???? " << endl;
467 #endif
468     Standard_NullObject::Raise("No mapping for the current Persistent Curve");
469   }
470 // POP pour NT
471   Handle(Geom2d_Curve) dummy;
472   return dummy;
473 }
474
475
476 //=======================================================================
477 //function : Translate
478 //purpose  : Translates a Geom2d_Curve to a PGeom2d_Curve.
479 //=======================================================================
480
481 Handle(PGeom2d_Curve)  MgtGeom2d::Translate(const Handle(Geom2d_Curve)& TObj)
482 {
483   Handle(Standard_Type) CurveType = TObj->DynamicType();
484
485   if (CurveType == STANDARD_TYPE(Geom2d_Line)) {
486     Handle(Geom2d_Line)& PLine = 
487       (Handle(Geom2d_Line)&) TObj;
488     return MgtGeom2d::Translate(PLine);
489   }
490   else if (CurveType ==  STANDARD_TYPE(Geom2d_Circle)) {
491     Handle(Geom2d_Circle)& PCircle = 
492       (Handle(Geom2d_Circle)&) TObj;
493     return MgtGeom2d::Translate(PCircle);
494   }
495   else if (CurveType ==  STANDARD_TYPE(Geom2d_Ellipse)) {
496     Handle(Geom2d_Ellipse)& PEllipse = 
497       (Handle(Geom2d_Ellipse)&) TObj;
498     return MgtGeom2d::Translate(PEllipse);
499   }
500   else if (CurveType ==  STANDARD_TYPE(Geom2d_Hyperbola)) {
501     Handle(Geom2d_Hyperbola)& PHyperbola = 
502       (Handle(Geom2d_Hyperbola)&) TObj;
503     return MgtGeom2d::Translate(PHyperbola);
504   }
505   else if (CurveType ==  STANDARD_TYPE(Geom2d_Parabola)) {
506     Handle(Geom2d_Parabola)& PParabola = 
507       (Handle(Geom2d_Parabola)&) TObj;
508     return MgtGeom2d::Translate(PParabola);
509   }
510   else if (CurveType ==  STANDARD_TYPE(Geom2d_BezierCurve)) {
511     Handle(Geom2d_BezierCurve)& PBezierCurve = 
512       (Handle(Geom2d_BezierCurve)&) TObj;
513     return MgtGeom2d::Translate(PBezierCurve);
514   }
515   else if (CurveType ==  STANDARD_TYPE(Geom2d_BSplineCurve)) {
516     Handle(Geom2d_BSplineCurve)& PBSplineCurve = 
517       (Handle(Geom2d_BSplineCurve)&) TObj;
518     return MgtGeom2d::Translate(PBSplineCurve);
519   }
520   else if (CurveType ==  STANDARD_TYPE(Geom2d_TrimmedCurve)) {
521     Handle(Geom2d_TrimmedCurve)& PTrimmedCurve = 
522       (Handle(Geom2d_TrimmedCurve)&) TObj;
523     return MgtGeom2d::Translate(PTrimmedCurve);
524   }
525   else if (CurveType ==  STANDARD_TYPE(Geom2d_OffsetCurve)) {
526     Handle(Geom2d_OffsetCurve)& POffsetCurve = 
527       (Handle(Geom2d_OffsetCurve)&) TObj;
528     return MgtGeom2d::Translate(POffsetCurve);
529   }
530   else {
531 #ifdef OCCT_DEBUG
532     cout << "Unknown Geom2d curve type ???? " << endl;
533 #endif
534     Standard_NullObject::Raise("No mapping for the current Transient Curve");
535   }
536 // POP pour NT
537   Handle(PGeom2d_Curve) dummy;
538   return dummy;
539 }
540
541
542 //=======================================================================
543 //function : Translate
544 //purpose  : Translates a PGeom2d_Direction to a Geom2d_Direction.
545 //=======================================================================
546
547 Handle(Geom2d_Direction)  MgtGeom2d::Translate
548        (const Handle(PGeom2d_Direction)& PObj)
549 {
550   gp_Vec2d vec = PObj->Vec();
551   return new Geom2d_Direction(vec.X(), vec.Y()); 
552 }
553
554
555 //=======================================================================
556 //function : Translate
557 //purpose  : Translates a Geom2d_Direction to a PGeom2d_Direction.
558 //=======================================================================
559
560 Handle(PGeom2d_Direction)  MgtGeom2d::Translate
561 (const Handle(Geom2d_Direction)& TObj)
562 { return new PGeom2d_Direction(TObj->Vec2d()); }
563
564
565 //=======================================================================
566 //function : Translate
567 //purpose  : Translates a PGeom2d_Ellipse to a Geom2d_Ellipse.
568 //=======================================================================
569
570 Handle(Geom2d_Ellipse)  MgtGeom2d::Translate
571 (const Handle(PGeom2d_Ellipse)& PObj)
572 {
573   return new Geom2d_Ellipse(PObj->Position(),
574                             PObj->MajorRadius(),
575                             PObj->MinorRadius());
576 }
577
578
579 //=======================================================================
580 //function : Translate
581 //purpose  : Translates a Geom2d_Ellipse to a PGeom2d_Ellipse.
582 //=======================================================================
583
584 Handle(PGeom2d_Ellipse)  MgtGeom2d::Translate
585 (const Handle(Geom2d_Ellipse)& TObj)
586 {
587   return new PGeom2d_Ellipse(TObj->Position(),
588                              TObj->MajorRadius(),
589                              TObj->MinorRadius());
590 }
591
592
593 //=======================================================================
594 //function : Translate
595 //purpose  : Translates a PGeom2d_Hyperbola to a Geom2d_Hyperbola.
596 //=======================================================================
597
598 Handle(Geom2d_Hyperbola)  MgtGeom2d::Translate
599 (const Handle(PGeom2d_Hyperbola)& PObj)
600 {
601   return new Geom2d_Hyperbola(PObj->Position(),
602                               PObj->MajorRadius(),
603                               PObj->MinorRadius());
604 }
605
606
607 //=======================================================================
608 //function : Translate
609 //purpose  : Translates a Geom2d_Hyperbola to a PGeom2d_Hyperbola.
610 //=======================================================================
611
612 Handle(PGeom2d_Hyperbola)  MgtGeom2d::Translate
613 (const Handle(Geom2d_Hyperbola)& TObj)
614 {
615   return new PGeom2d_Hyperbola(TObj->Position(),
616                                TObj->MajorRadius(),
617                                TObj->MinorRadius());
618 }
619
620
621 //=======================================================================
622 //function : Translate
623 //purpose  : Translates a PGeom2d_Line to a Geom2d_Line.
624 //=======================================================================
625
626 Handle(Geom2d_Line)  MgtGeom2d::Translate(const Handle(PGeom2d_Line)& PObj)
627 { return new Geom2d_Line(PObj->Position()); }
628
629
630 //=======================================================================
631 //function : Translate
632 //purpose  : Translates a Geom2d_Line to a PGeom2d_Line.
633 //=======================================================================
634
635 Handle(PGeom2d_Line)  MgtGeom2d::Translate(const Handle(Geom2d_Line)& TObj)
636 {
637   return new PGeom2d_Line(TObj->Lin2d().Position());
638 }
639
640 //=======================================================================
641 //function : Translate
642 //purpose  : Translates a PGeom2d_OffsetCurve to a Geom2d_OffsetCurve.
643 //=======================================================================
644
645 Handle(Geom2d_OffsetCurve)  MgtGeom2d::Translate
646 (const Handle(PGeom2d_OffsetCurve)& PObj)
647 {
648   return new Geom2d_OffsetCurve(MgtGeom2d::Translate(PObj->BasisCurve()),
649                                 PObj->OffsetValue());
650 }
651
652
653 //=======================================================================
654 //function : Translate
655 //purpose  : Translates a Geom2d_OffsetCurve to a PGeom2d_OffsetCurve.
656 //=======================================================================
657
658 Handle(PGeom2d_OffsetCurve)  MgtGeom2d::Translate
659 (const Handle(Geom2d_OffsetCurve)& TObj)
660 {
661   return new PGeom2d_OffsetCurve(MgtGeom2d::Translate(TObj->BasisCurve()),
662                                  TObj->Offset());
663 }
664
665
666 //=======================================================================
667 //function : Translate
668 //purpose  : Translates a PGeom2d_Parabola to a Geom2d_Parabola.
669 //=======================================================================
670
671 Handle(Geom2d_Parabola)  MgtGeom2d::Translate
672 (const Handle(PGeom2d_Parabola)& PObj)
673 {
674   return new Geom2d_Parabola(PObj->Position(),
675                              PObj->FocalLength());
676 }
677
678
679 //=======================================================================
680 //function : Translate
681 //purpose  : Translates a Geom2d_Parabola to a PGeom2d_Parabola.
682 //=======================================================================
683
684 Handle(PGeom2d_Parabola)  MgtGeom2d::Translate
685 (const Handle(Geom2d_Parabola)& TObj)
686 {
687   return new PGeom2d_Parabola(TObj->Position(),
688                               TObj->Focal());
689 }
690
691 //=======================================================================
692 //function : Translate
693 //purpose  : Translates a PGeom2d_Point to a Geom2d_Point.
694 //           Optimized valid until new subtypes of Geom2dPoint exist
695 //=======================================================================
696
697 Handle(Geom2d_Point)  MgtGeom2d::Translate
698 (const Handle(PGeom2d_Point)& PObj)
699 {
700 /*
701   Handle(Geom2d_Point) Geom2dP;
702   Handle(Standard_Type) PointType = PObj->DynamicType();
703
704   if (PointType == STANDARD_TYPE(PGeom2d_CartesianPoint)) {
705     Handle(PGeom2d_CartesianPoint) PCPoint = 
706       Handle(PGeom2d_CartesianPoint)::DownCast(PObj);
707     Geom2dP = MgtGeom2d::Translate(PCPoint);
708   }
709   return Geom2dP;
710 */
711   Handle(PGeom2d_CartesianPoint)& PCPoint = 
712     (Handle(PGeom2d_CartesianPoint)&) PObj;
713   return new Geom2d_CartesianPoint(PCPoint->Pnt());
714 }
715
716
717 //=======================================================================
718 //function : Translate
719 //purpose  : Translates a Geom2d_Point to a PGeom2d_Point.
720 //           Optimized valid until new subtypes of Geom2dPoint exist
721 //=======================================================================
722
723 Handle(PGeom2d_Point)  MgtGeom2d::Translate
724 (const Handle(Geom2d_Point)& TObj)
725 {
726 /*
727   Handle(PGeom2d_Point) PGeom2dP;
728   Handle(Standard_Type) PointType = TObj->DynamicType();
729
730   if (PointType == STANDARD_TYPE(Geom2d_CartesianPoint)) {
731     Handle(Geom2d_CartesianPoint) TCPoint = 
732       Handle(Geom2d_CartesianPoint)::DownCast(TObj);
733     PGeom2dP = MgtGeom2d::Translate(TCPoint);
734   }
735   return PGeom2dP;
736 */
737   Handle(Geom2d_CartesianPoint)& TCPoint = 
738     (Handle(Geom2d_CartesianPoint)&) TObj;
739   return new PGeom2d_CartesianPoint(TCPoint->Pnt2d());
740 }
741
742
743
744 //=======================================================================
745 //function : Translate
746 //purpose  : Translates a PGeom2d_Transformation to a Geom2d_Transformation.
747 //=======================================================================
748
749 Handle(Geom2d_Transformation)  MgtGeom2d::Translate
750 (const Handle(PGeom2d_Transformation)& PObj)
751 { return new Geom2d_Transformation(PObj->Trsf()); }
752
753
754 //=======================================================================
755 //function : Translate
756 //purpose  : Translates a Geom2d_Transformation to a PGeom2d_Transformation.
757 //=======================================================================
758
759 Handle(PGeom2d_Transformation)  MgtGeom2d::Translate
760 (const Handle(Geom2d_Transformation)& TObj)
761 { return new PGeom2d_Transformation(TObj->Trsf2d()); }
762
763
764 //=======================================================================
765 //function : Translate
766 //purpose  : Translates a PGeom2d_TrimmedCurve to a Geom2d_TrimmedCurve.
767 //=======================================================================
768
769 Handle(Geom2d_TrimmedCurve)  MgtGeom2d::Translate
770 (const Handle(PGeom2d_TrimmedCurve)& PObj)
771 {
772   return new Geom2d_TrimmedCurve(MgtGeom2d::Translate(PObj->BasisCurve()),
773                                  PObj->FirstU(),
774                                  PObj->LastU(),
775                                  Standard_True); // Warning : will desappear
776 }
777
778
779 //=======================================================================
780 //function : Translate
781 //purpose  : Translates a Geom2d_TrimmedCurve to a PGeom2d_TrimmedCurve.
782 //=======================================================================
783
784 Handle(PGeom2d_TrimmedCurve)  MgtGeom2d::Translate
785 (const Handle(Geom2d_TrimmedCurve)& TObj)
786 {
787   return new PGeom2d_TrimmedCurve(MgtGeom2d::Translate(TObj->BasisCurve()),
788                                   TObj->FirstParameter(),
789                                   TObj->LastParameter());
790 }
791
792
793 //=======================================================================
794 //function : Translate
795 //purpose  : Translates a PGeom2d_VectorWithMagnitude to a
796 //           Geom2d_VectorWithMagnitude.
797 //=======================================================================
798
799 Handle(Geom2d_VectorWithMagnitude)  MgtGeom2d::Translate
800 (const Handle(PGeom2d_VectorWithMagnitude)& PObj)
801 { return new Geom2d_VectorWithMagnitude(PObj->Vec()); }
802
803
804 //=======================================================================
805 //function : Translate
806 //purpose  : Translates a Geom2d_VectorWithMagnitude to a
807 //           PGeom2d_VectorWithMagnitude.
808 //=======================================================================
809
810 Handle(PGeom2d_VectorWithMagnitude)  MgtGeom2d::Translate
811 (const Handle(Geom2d_VectorWithMagnitude)& TObj)
812 { return new PGeom2d_VectorWithMagnitude(TObj->Vec2d()); }