0024927: Getting rid of "Persistent" functionality -- Code
[occt.git] / src / MgtGeom / MgtGeom.cxx
1 // Created on: 1993-03-05
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 <MgtGeom.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_Array1OfPnt.hxx>
36 #include <TColgp_Array2OfPnt.hxx>
37 #include <TColgp_HArray1OfPnt.hxx>
38 #include <TColgp_HArray2OfPnt.hxx>
39
40 #include <PColgp_HArray1OfPnt.hxx>
41 #include <PColgp_HArray2OfPnt.hxx>
42
43 #include <gp_Vec.hxx>
44 #include <gp_Circ.hxx>
45 #include <gp_Ax1.hxx>
46
47 //modif wok++
48 #include <Standard_NullObject.hxx>
49 #include <gp_Lin.hxx>
50 #include <gp_Pln.hxx>
51
52 // *******************************************************************
53 // The following methods are subroutines used to copy elements
54 // from structures to other structures, as array1 or array2.
55 // *******************************************************************
56
57 // *******************************************************************
58 // Structures from TCollection to structures from PCollection.
59 // *******************************************************************
60
61 //=======================================================================
62 //function : ArrayCopy
63 //purpose  : Copy the gp_Pnt
64 //           from an Array1 from TColgp (TCollection)
65 //           to an HArray1 from PColgp (PCollection)
66 //=======================================================================
67
68 static Handle(PColgp_HArray1OfPnt) ArrayCopy
69        (const TColgp_Array1OfPnt& TArray)
70 {
71   Standard_Integer Lower = TArray.Lower();
72   Standard_Integer Upper = TArray.Upper();
73   Standard_Integer Index;
74   Handle(PColgp_HArray1OfPnt) PArray = new PColgp_HArray1OfPnt(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 gp_Pnt
84 //           from an Array2 from TColgp (TCollection)
85 //           to an HArray2 from PColgp (PCollection)
86 //=======================================================================
87
88 static Handle(PColgp_HArray2OfPnt) ArrayCopy
89        (const TColgp_Array2OfPnt& TArray)
90 {
91   Standard_Integer LowerRow = TArray.LowerRow();
92   Standard_Integer UpperRow = TArray.UpperRow();
93   Standard_Integer LowerCol = TArray.LowerCol();
94   Standard_Integer UpperCol = TArray.UpperCol();
95   Standard_Integer IndexRow, IndexCol;
96   Handle(PColgp_HArray2OfPnt) PArray =
97     new PColgp_HArray2OfPnt(LowerRow, UpperRow, LowerCol, UpperCol);
98   for (IndexRow = LowerRow; IndexRow <= UpperRow; IndexRow++) {
99     for (IndexCol = LowerCol; IndexCol <= UpperCol; IndexCol++) {
100       PArray->SetValue(IndexRow, IndexCol, TArray(IndexRow, IndexCol));
101     }
102   }
103   return PArray;
104 }
105
106 //=======================================================================
107 //function : ArrayCopy
108 //purpose  : Copy the Standard_Real
109 //           from an Array1 from TColStd (TCollection)
110 //           to an SingleArray from PCollection
111 //=======================================================================
112
113 static Handle(PColStd_HArray1OfReal) ArrayCopy
114        (const TColStd_Array1OfReal& TArray)
115 {
116   Standard_Integer Lower = TArray.Lower();
117   Standard_Integer Upper = TArray.Upper();
118   Standard_Integer Index;
119   Handle(PColStd_HArray1OfReal) PArray =
120     new PColStd_HArray1OfReal(Lower, Upper);
121   for (Index = Lower; Index <= Upper; Index++) {
122     PArray->SetValue(Index, TArray(Index));
123   }
124   return PArray;
125 }
126
127 //=======================================================================
128 //function : ArrayCopy
129 //purpose  : Copy the Standard_Real
130 //           from an Array2 from TColStd (TCollection)
131 //           to an DoubleArray from PCollection
132 //=======================================================================
133
134 static Handle(PColStd_HArray2OfReal) ArrayCopy
135        (const TColStd_Array2OfReal& TArray)
136 {
137   Standard_Integer LowerRow = TArray.LowerRow();
138   Standard_Integer UpperRow = TArray.UpperRow();
139   Standard_Integer LowerCol = TArray.LowerCol();
140   Standard_Integer UpperCol = TArray.UpperCol();
141   Standard_Integer IndexRow, IndexCol;
142   Handle(PColStd_HArray2OfReal) PArray =
143     new PColStd_HArray2OfReal(LowerRow, UpperRow, LowerCol, UpperCol);
144   for (IndexRow = LowerRow; IndexRow <= UpperRow; IndexRow++) {
145     for (IndexCol = LowerCol; IndexCol <= UpperCol; IndexCol++) {
146       PArray->SetValue(IndexRow, IndexCol, TArray(IndexRow, IndexCol));
147     }
148   }
149   return PArray;
150 }
151
152 //=======================================================================
153 //function : ArrayCopy
154 //purpose  : Copy the Standard_Integer
155 //           from an Array1 from TColStd (TCollection)
156 //           to an SingleArray from PCollection
157 //=======================================================================
158
159 static Handle(PColStd_HArray1OfInteger) ArrayCopy
160        (const TColStd_Array1OfInteger& TArray)
161 {
162   Standard_Integer Lower = TArray.Lower();
163   Standard_Integer Upper = TArray.Upper();
164   Standard_Integer Index;
165   Handle(PColStd_HArray1OfInteger) PArray =
166     new PColStd_HArray1OfInteger(Lower, Upper);
167   for (Index = Lower; Index <= Upper; Index++) {
168     PArray->SetValue(Index, TArray(Index));
169   }
170   return PArray;
171 }
172
173 // *******************************************************************
174 // Structures from PCollection to structures from TCollection.
175 // *******************************************************************
176
177 //=======================================================================
178 //function : ArrayCopy
179 //purpose  : Copy the gp_Pnt
180 //           from an HArray1 from PColgp (PCollection)
181 //           to an Array1 from TColgp (TCollection)
182 //=======================================================================
183
184 static void ArrayCopy
185   (const Handle(PColgp_HArray1OfPnt)& PArray,
186    TColgp_Array1OfPnt& TArray)
187 {
188   Standard_Integer Lower = PArray->Lower();
189   Standard_Integer Upper = PArray->Upper();
190   Standard_Integer Index;
191   for (Index = Lower; Index <= Upper; Index++) {
192     TArray(Index) = PArray->Value(Index);
193   }
194 }
195
196 //=======================================================================
197 //function : ArrayCopy
198 //purpose  : Copy the gp_Pnt
199 //           from an HArray2 from PColgp (PCollection)
200 //           to an Array2 from TColgp (TCollection)
201 //=======================================================================
202
203 static void ArrayCopy
204   (const Handle(PColgp_HArray2OfPnt)& PArray,
205    TColgp_Array2OfPnt& TArray)
206 {
207   Standard_Integer LowerRow = TArray.LowerRow();
208   Standard_Integer UpperRow = TArray.UpperRow();
209   Standard_Integer LowerCol = TArray.LowerCol();
210   Standard_Integer UpperCol = TArray.UpperCol();
211   Standard_Integer IndexRow, IndexCol;
212   for (IndexRow = LowerRow; IndexRow <= UpperRow; IndexRow++) {
213     for (IndexCol = LowerCol; IndexCol <= UpperCol; IndexCol++) {
214       TArray(IndexRow, IndexCol) = PArray->Value(IndexRow, IndexCol);
215     }
216   }
217 }
218
219 //=======================================================================
220 //function : ArrayCopy
221 //purpose  : Copy the Standard_Real
222 //           from an SingleArray from PCollection
223 //           to an Array1 from TColStd (TCollection)
224 //=======================================================================
225
226 static void ArrayCopy
227   (const Handle(PColStd_HArray1OfReal)& PArray,
228    TColStd_Array1OfReal& TArray)
229 {
230   Standard_Integer Lower = PArray->Lower();
231   Standard_Integer Upper = PArray->Upper();
232   Standard_Integer Index;
233   for (Index = Lower; Index <= Upper; Index++) {
234     TArray(Index) = PArray->Value(Index);
235   }
236 }
237
238 //=======================================================================
239 //function : ArrayCopy
240 //purpose  : Copy the Standard_Real
241 //           from an DoubleArray from PCollection
242 //           to an Array2 from TColStd (TCollection)
243 //=======================================================================
244
245 static void ArrayCopy
246   (const Handle(PColStd_HArray2OfReal)& PArray,
247    TColStd_Array2OfReal& TArray)
248 {
249   Standard_Integer LowerRow = TArray.LowerRow();
250   Standard_Integer UpperRow = TArray.UpperRow();
251   Standard_Integer LowerCol = TArray.LowerCol();
252   Standard_Integer UpperCol = TArray.UpperCol();
253   Standard_Integer IndexRow, IndexCol;
254   for (IndexRow = LowerRow; IndexRow <= UpperRow; IndexRow++) {
255     for (IndexCol = LowerCol; IndexCol <= UpperCol; IndexCol++) {
256       TArray(IndexRow, IndexCol) = PArray->Value(IndexRow, IndexCol);
257     }
258   }
259 }
260
261 //=======================================================================
262 //function : ArrayCopy
263 //purpose  : Copy the Standard_Integer
264 //           from an SingleArray from PCollection
265 //           to an Array1 from TColStd (TCollection)
266 //=======================================================================
267
268 static void ArrayCopy
269   (const Handle(PColStd_HArray1OfInteger)& PArray,
270    TColStd_Array1OfInteger& TArray)
271 {
272   Standard_Integer Lower = PArray->Lower();
273   Standard_Integer Upper = PArray->Upper();
274   Standard_Integer Index;
275   for (Index = Lower; Index <= Upper; Index++) {
276     TArray(Index) = PArray->Value(Index);
277   }
278 }
279
280
281
282 // *******************************************************************
283 // Here is the implementation of the package methods.
284 // *******************************************************************
285
286
287 //=======================================================================
288 //function : Translate
289 //purpose  : Translates a PGeom_Axis1Placement to a Geom_Axis1Placement.
290 //=======================================================================
291
292 Handle(Geom_Axis1Placement)  MgtGeom::Translate
293        (const Handle(PGeom_Axis1Placement)& PObj)
294 {
295   return new Geom_Axis1Placement(PObj->Axis());
296 }
297
298
299 //=======================================================================
300 //function : Translate
301 //purpose  : Translates a Geom_Axis1Placement to a PGeom_Axis1Placement.
302 //=======================================================================
303
304 Handle(PGeom_Axis1Placement)  MgtGeom::Translate
305        (const Handle(Geom_Axis1Placement)& TObj)
306 {
307   return new PGeom_Axis1Placement(TObj->Axis());
308 }
309
310
311 //=======================================================================
312 //function : Translate
313 //purpose  : Translates a PGeom_Axis2Placement to a Geom_Axis2Placement.
314 //=======================================================================
315
316 Handle(Geom_Axis2Placement)  MgtGeom::Translate
317        (const Handle(PGeom_Axis2Placement)& PObj)
318 {
319   return new Geom_Axis2Placement(PObj->Axis().Location(),
320                                  PObj->Axis().Direction(),
321                                  PObj->XDirection());
322 }
323
324
325 //=======================================================================
326 //function : Translate
327 //purpose  : Translates a Geom_Axis2Placement to a PGeom_Axis2Placement.
328 //=======================================================================
329
330 Handle(PGeom_Axis2Placement)  MgtGeom::Translate
331        (const Handle(Geom_Axis2Placement)& TObj)
332 {
333   return new PGeom_Axis2Placement(TObj->Axis(),
334                                   TObj->XDirection());
335 }
336
337
338 //=======================================================================
339 //function : Translate
340 //purpose  : Translates a PGeom_BSplineCurve to a Geom_BSplineCurve.
341 //=======================================================================
342
343 Handle(Geom_BSplineCurve)  MgtGeom::Translate
344        (const Handle(PGeom_BSplineCurve)& PObj)
345 {
346   Handle(Geom_BSplineCurve)  TBSplC;
347
348   Handle(PColgp_HArray1OfPnt) oldPoles = PObj->Poles();
349   TColgp_Array1OfPnt newPoles (oldPoles->Lower(),oldPoles->Upper());
350   ArrayCopy(oldPoles,newPoles);
351
352   Handle(PColStd_HArray1OfInteger) oldMult = PObj->Multiplicities();
353   TColStd_Array1OfInteger newMultiplicities(oldMult->Lower(),oldMult->Upper());
354   ArrayCopy(oldMult,newMultiplicities);
355
356   Handle(PColStd_HArray1OfReal) oldKnots = PObj->Knots();
357   TColStd_Array1OfReal newKnots (oldKnots->Lower(),oldKnots->Upper());
358   ArrayCopy(oldKnots,newKnots);
359
360   if (PObj->Rational()) {
361     Handle(PColStd_HArray1OfReal) oldWeights = PObj->Weights();
362     TColStd_Array1OfReal newWeights (oldWeights->Lower(),oldWeights->Upper());
363     ArrayCopy(oldWeights,newWeights);
364     TBSplC = new Geom_BSplineCurve
365       (newPoles, newWeights, newKnots, newMultiplicities, PObj->SpineDegree(),PObj->Periodic());
366   }
367   else {
368     TBSplC = new Geom_BSplineCurve
369       (newPoles, newKnots, newMultiplicities, PObj->SpineDegree(),PObj->Periodic());
370   }
371 //  if (PObj->Periodic()) TBSplC->SetPeriodic();
372   return TBSplC;
373 }
374
375
376 //=======================================================================
377 //function : Translate
378 //purpose  : Translates a Geom_BSplineCurve to a PGeom_BSplineCurve.
379 //=======================================================================
380
381 Handle(PGeom_BSplineCurve)  MgtGeom::Translate
382        (const Handle(Geom_BSplineCurve)& TObj)
383 {
384   Standard_Integer Upper;
385
386   Upper = TObj->NbPoles();
387
388   TColgp_Array1OfPnt oldPoles(1, Upper);
389   TObj->Poles(oldPoles);
390   Handle(PColgp_HArray1OfPnt) newPPoles = ArrayCopy(oldPoles);
391   
392   Handle(PColStd_HArray1OfReal) newPWeights;
393   if (TObj->IsRational()) {
394     TColStd_Array1OfReal oldWeights(1, Upper);
395     TObj->Weights(oldWeights);
396     newPWeights = ArrayCopy(oldWeights);
397   }
398   
399   Upper = TObj->NbKnots();
400
401   TColStd_Array1OfReal oldKnots(1, Upper);
402   TObj->Knots(oldKnots);
403   Handle(PColStd_HArray1OfReal) newPKnots = ArrayCopy(oldKnots);
404
405   TColStd_Array1OfInteger oldMultiplicities(1, Upper);
406   TObj->Multiplicities(oldMultiplicities);
407   Handle(PColStd_HArray1OfInteger) newPMultiplicities =
408     ArrayCopy(oldMultiplicities);
409   
410   return new PGeom_BSplineCurve(TObj->IsRational(),
411                                 TObj->IsPeriodic(),
412                                 TObj->Degree(),
413                                 newPPoles,
414                                 newPWeights,
415                                 newPKnots,
416                                 newPMultiplicities);
417 }
418
419
420 //=======================================================================
421 //function : Translate
422 //purpose  : Translates a PGeom_BSplineSurface to a Geom_BSplineSurface.
423 //=======================================================================
424
425 Handle(Geom_BSplineSurface)  MgtGeom::Translate
426        (const Handle(PGeom_BSplineSurface)& PObj)
427 {
428   Handle(Geom_BSplineSurface)  TBSplS;
429
430   Handle(PColgp_HArray2OfPnt) oldPoles = PObj->Poles();
431   TColgp_Array2OfPnt newPoles (oldPoles->LowerRow(),oldPoles->UpperRow(),
432                                oldPoles->LowerCol(),oldPoles->UpperCol());
433   ArrayCopy(oldPoles,newPoles);
434
435   Handle(PColStd_HArray1OfInteger) oldUMult = PObj->UMultiplicities();
436   TColStd_Array1OfInteger
437     newUMultiplicities (oldUMult->Lower(),oldUMult->Upper());
438   ArrayCopy(oldUMult,newUMultiplicities);
439
440   Handle(PColStd_HArray1OfInteger) oldVMult = PObj->VMultiplicities();
441   TColStd_Array1OfInteger
442     newVMultiplicities (oldVMult->Lower(),oldVMult->Upper());
443   ArrayCopy(oldVMult,newVMultiplicities);
444
445   Handle(PColStd_HArray1OfReal) oldUKnots = PObj->UKnots();
446   TColStd_Array1OfReal newUKnots (oldUKnots->Lower(),oldUKnots->Upper());
447   ArrayCopy(oldUKnots,newUKnots);
448
449   Handle(PColStd_HArray1OfReal) oldVKnots = PObj->VKnots();
450   TColStd_Array1OfReal newVKnots (oldVKnots->Lower(),oldVKnots->Upper());
451   ArrayCopy(oldVKnots,newVKnots);
452
453   if (!PObj->URational() && !PObj->VRational()) {
454     TBSplS = new Geom_BSplineSurface
455       (newPoles,
456        newUKnots, newVKnots,
457        newUMultiplicities,newVMultiplicities,
458        PObj->USpineDegree(),
459        PObj->VSpineDegree(),
460        PObj->UPeriodic(),
461        PObj->VPeriodic());
462   }
463   else {
464     Handle(PColStd_HArray2OfReal) oldWeights = PObj->Weights();
465     TColStd_Array2OfReal
466       newWeights (oldWeights->LowerRow(),oldWeights->UpperRow(),
467                   oldWeights->LowerCol(),oldWeights->UpperCol());
468     ArrayCopy(oldWeights,newWeights);
469     TBSplS = new Geom_BSplineSurface
470       (newPoles,
471        newWeights,
472        newUKnots, newVKnots,
473        newUMultiplicities,newVMultiplicities,
474        PObj->USpineDegree(),
475        PObj->VSpineDegree(),
476        PObj->UPeriodic(),
477        PObj->VPeriodic());
478   }
479 //  if (PObj->UPeriodic()) TBSplS->SetUPeriodic();
480 //  if (PObj->VPeriodic()) TBSplS->SetVPeriodic();
481   return TBSplS;
482 }
483
484
485 //=======================================================================
486 //function : Translate
487 //purpose  : Translates a Geom_BSplineSurface to a PGeom_BSplineSurface.
488 //=======================================================================
489
490 Handle(PGeom_BSplineSurface)  MgtGeom::Translate
491        (const Handle(Geom_BSplineSurface)& TObj)
492 {
493   Standard_Integer UpperU, UpperV;
494
495   UpperU = TObj->NbUPoles();
496   UpperV = TObj->NbVPoles();
497
498   TColgp_Array2OfPnt oldPoles(1, UpperU, 1, UpperV);
499   TObj->Poles(oldPoles);
500   Handle(PColgp_HArray2OfPnt) newPPoles =
501     ArrayCopy(oldPoles);
502   
503   Handle(PColStd_HArray2OfReal) newPWeights;
504   if (TObj->IsURational() || TObj->IsVRational()) {
505     TColStd_Array2OfReal oldWeights(1, UpperU, 1, UpperV);
506     TObj->Weights(oldWeights);
507     newPWeights = ArrayCopy(oldWeights);
508   }
509   
510   UpperU = TObj->NbUKnots();
511
512   TColStd_Array1OfReal oldUKnots(1, UpperU);
513   TObj->UKnots(oldUKnots);
514   Handle(PColStd_HArray1OfReal) newPUKnots =
515     ArrayCopy(oldUKnots);
516   
517   TColStd_Array1OfInteger oldUMultiplicities(1, UpperU);
518   TObj->UMultiplicities(oldUMultiplicities);
519   Handle(PColStd_HArray1OfInteger) newPUMultiplicities =
520     ArrayCopy(oldUMultiplicities);
521   
522   UpperV = TObj->NbVKnots();
523
524   TColStd_Array1OfReal oldVKnots(1, UpperV);
525   TObj->VKnots(oldVKnots);
526   Handle(PColStd_HArray1OfReal) newPVKnots =
527     ArrayCopy(oldVKnots);
528   
529   TColStd_Array1OfInteger oldVMultiplicities(1, UpperV);
530   TObj->VMultiplicities(oldVMultiplicities);
531   Handle(PColStd_HArray1OfInteger) newPVMultiplicities =
532     ArrayCopy(oldVMultiplicities);
533   
534   return new PGeom_BSplineSurface(TObj->IsURational(),
535                                   TObj->IsVRational(),
536                                   TObj->IsUPeriodic(),
537                                   TObj->IsVPeriodic(),
538                                   TObj->UDegree(),
539                                   TObj->VDegree(),
540                                   newPPoles,
541                                   newPWeights,
542                                   newPUKnots,
543                                   newPVKnots,
544                                   newPUMultiplicities,
545                                   newPVMultiplicities);
546 }
547
548
549 //=======================================================================
550 //function : Translate
551 //purpose  : Translates a PGeom_BezierCurve to a Geom_BezierCurve.
552 //=======================================================================
553
554 Handle(Geom_BezierCurve)  MgtGeom::Translate
555        (const Handle(PGeom_BezierCurve)& PObj)
556 {
557   Handle(Geom_BezierCurve) TBzC;
558
559   Handle(PColgp_HArray1OfPnt) oldPoles = PObj->Poles();
560   TColgp_Array1OfPnt newPoles (oldPoles->Lower(),oldPoles->Upper());
561   ArrayCopy(oldPoles,newPoles);
562
563   if (PObj->Rational()) {
564     Handle(PColStd_HArray1OfReal) oldWeights = PObj->Weights();
565     TColStd_Array1OfReal newWeights (oldWeights->Lower(),oldWeights->Upper());
566     ArrayCopy(oldWeights,newWeights);
567     TBzC = new Geom_BezierCurve(newPoles, newWeights);
568   }
569   else {
570     TBzC = new Geom_BezierCurve(newPoles);
571   }
572   return TBzC;
573 }
574
575
576 //=======================================================================
577 //function : Translate
578 //purpose  : Translates a Geom_BezierCurve to a PGeom_BezierCurve.
579 //=======================================================================
580
581 Handle(PGeom_BezierCurve)  MgtGeom::Translate
582        (const Handle(Geom_BezierCurve)& TObj)
583 {
584   Standard_Integer Upper;
585
586   Upper = TObj->NbPoles();
587
588   TColgp_Array1OfPnt oldPoles(1, Upper);
589   TObj->Poles(oldPoles);
590   Handle(PColgp_HArray1OfPnt) newPPoles = ArrayCopy(oldPoles);
591   
592   Handle(PColStd_HArray1OfReal) newPWeights;
593   if (TObj->IsRational()) {
594     TColStd_Array1OfReal oldWeights(1, Upper);
595     TObj->Weights(oldWeights);
596     newPWeights = ArrayCopy(oldWeights);
597   }
598   
599   return new PGeom_BezierCurve(newPPoles,
600                                newPWeights,
601                                TObj->IsRational());
602 }
603
604
605 //=======================================================================
606 //function : Translate
607 //purpose  : Translates a PGeom_BezierSurface to a Geom_BezierSurface.
608 //=======================================================================
609
610 Handle(Geom_BezierSurface)  MgtGeom::Translate
611        (const Handle(PGeom_BezierSurface)& PObj)
612 {
613   Handle(Geom_BezierSurface)  TBzS;
614
615   Handle(PColgp_HArray2OfPnt) oldPoles = PObj->Poles();
616   TColgp_Array2OfPnt newPoles (oldPoles->LowerRow(),oldPoles->UpperRow(),
617                                oldPoles->LowerCol(),oldPoles->UpperCol());
618   ArrayCopy(oldPoles,newPoles);
619
620   if (!PObj->URational() && !PObj->VRational()) {
621     TBzS = new Geom_BezierSurface(newPoles);
622   }
623   else {
624     Handle(PColStd_HArray2OfReal) oldWeights = PObj->Weights();
625     TColStd_Array2OfReal
626       newWeights (oldWeights->LowerRow(),oldWeights->UpperRow(),
627                   oldWeights->LowerCol(),oldWeights->UpperCol());
628     ArrayCopy(oldWeights,newWeights);
629
630     TBzS = new Geom_BezierSurface(newPoles, newWeights);
631   }
632   return TBzS;
633 }
634
635
636 //=======================================================================
637 //function : Translate
638 //purpose  : Translates a Geom_BezierSurface to a PGeom_BezierSurface.
639 //=======================================================================
640
641 Handle(PGeom_BezierSurface)  MgtGeom::Translate(const Handle(Geom_BezierSurface)& TObj)
642 {
643   Standard_Integer UpperU, UpperV;
644
645   UpperU = TObj->NbUPoles();
646   UpperV = TObj->NbVPoles();
647
648   TColgp_Array2OfPnt oldPoles(1, UpperU, 1, UpperV);
649   TObj->Poles(oldPoles);
650   Handle(PColgp_HArray2OfPnt) newPPoles =
651     ArrayCopy(oldPoles);
652   
653   Handle(PColStd_HArray2OfReal) newPWeights;
654   if (TObj->IsURational() || TObj->IsVRational()) {
655     TColStd_Array2OfReal oldWeights(1, UpperU, 1, UpperV);
656     TObj->Weights(oldWeights);
657     newPWeights = ArrayCopy(oldWeights);
658   }
659   
660   return new PGeom_BezierSurface(TObj->IsURational(),
661                                  TObj->IsVRational(),
662                                  newPPoles,
663                                  newPWeights);
664 }
665
666
667 //=======================================================================
668 //function : Translate
669 //purpose  : Translates a PGeom_CartesianPoint to a Geom_CartesianPoint.
670 //=======================================================================
671
672 Handle(Geom_CartesianPoint)  MgtGeom::Translate
673        (const Handle(PGeom_CartesianPoint)& PObj)
674 { return new Geom_CartesianPoint(PObj->Pnt()); }
675
676
677 //=======================================================================
678 //function : Translate
679 //purpose  : Translates a Geom_CartesianPoint to a PGeom_CartesianPoint.
680 //=======================================================================
681
682 Handle(PGeom_CartesianPoint)  MgtGeom::Translate
683        (const Handle(Geom_CartesianPoint)& TObj)
684 { return new PGeom_CartesianPoint(TObj->Pnt()); }
685
686
687 //=======================================================================
688 //function : Translate
689 //purpose  : Translates a PGeom_Circle to a Geom_Circle.
690 //=======================================================================
691
692 Handle(Geom_Circle)  MgtGeom::Translate(const Handle(PGeom_Circle)& PObj)
693 {
694   return new Geom_Circle(PObj->Position(),
695                          PObj->Radius());
696 }
697
698
699 //=======================================================================
700 //function : Translate
701 //purpose  : Translates a Geom_Circle to a PGeom_Circle.
702 //=======================================================================
703
704 Handle(PGeom_Circle)  MgtGeom::Translate(const Handle(Geom_Circle)& TObj)
705 {
706   gp_Circ cir = TObj->Circ();
707   return new PGeom_Circle(cir.Position(),cir.Radius());
708 }
709
710
711 //=======================================================================
712 //function : Translate
713 //purpose  : Translates a PGeom_ConicalSurface to a Geom_ConicalSurface.
714 //=======================================================================
715
716 Handle(Geom_ConicalSurface)  MgtGeom::Translate
717        (const Handle(PGeom_ConicalSurface)& PObj)
718 {
719   return new Geom_ConicalSurface(PObj->Position(),
720                                  PObj->SemiAngle(),
721                                  PObj->Radius());
722 }
723
724
725 //=======================================================================
726 //function : Translate
727 //purpose  : Translates a Geom_ConicalSurface to a PGeom_ConicalSurface.
728 //=======================================================================
729
730 Handle(PGeom_ConicalSurface)  MgtGeom::Translate
731        (const Handle(Geom_ConicalSurface)& TObj)
732 {
733   return new PGeom_ConicalSurface(TObj->Position(),
734                                   TObj->RefRadius(),
735                                   TObj->SemiAngle());
736 }
737
738
739 //=======================================================================
740 //function : Translate
741 //purpose  : Translates a PGeom_Curve to a Geom_Curve.
742 //=======================================================================
743
744 Handle(Geom_Curve)  MgtGeom::Translate(const Handle(PGeom_Curve)& PObj)
745 {
746   Handle(Standard_Type) CurveType = PObj->DynamicType();
747   
748   if (CurveType == STANDARD_TYPE(PGeom_Line)) {
749     Handle(PGeom_Line)& TLine = 
750       (Handle(PGeom_Line)&) PObj;
751     return MgtGeom::Translate(TLine);
752   }
753   else if (CurveType ==  STANDARD_TYPE(PGeom_Circle)) {
754     Handle(PGeom_Circle)& TCircle = 
755       (Handle(PGeom_Circle)&) PObj;
756     return MgtGeom::Translate(TCircle);
757   }
758   else if (CurveType ==  STANDARD_TYPE(PGeom_Ellipse)) {
759     Handle(PGeom_Ellipse)& TEllipse = 
760       (Handle(PGeom_Ellipse)&) PObj;
761     return MgtGeom::Translate(TEllipse);
762   }
763   else if (CurveType ==  STANDARD_TYPE(PGeom_Hyperbola)) {
764     Handle(PGeom_Hyperbola)& THyperbola = 
765       (Handle(PGeom_Hyperbola)&) PObj;
766     return MgtGeom::Translate(THyperbola);
767   }
768   else if (CurveType ==  STANDARD_TYPE(PGeom_Parabola)) {
769     Handle(PGeom_Parabola)& TParabola = 
770       (Handle(PGeom_Parabola)&) PObj;
771     return MgtGeom::Translate(TParabola);
772   }
773   else if (CurveType ==  STANDARD_TYPE(PGeom_BezierCurve)) {
774     Handle(PGeom_BezierCurve)& TBezierCurve = 
775       (Handle(PGeom_BezierCurve)&) PObj;
776     return MgtGeom::Translate(TBezierCurve);
777   }
778   else if (CurveType ==  STANDARD_TYPE(PGeom_BSplineCurve)) {
779     Handle(PGeom_BSplineCurve)& TBSplineCurve = 
780       (Handle(PGeom_BSplineCurve)&) PObj;
781     return MgtGeom::Translate(TBSplineCurve);
782   }
783   else if (CurveType ==  STANDARD_TYPE(PGeom_TrimmedCurve)) {
784     Handle(PGeom_TrimmedCurve)& TTrimmedCurve = 
785       (Handle(PGeom_TrimmedCurve)&) PObj;
786     return MgtGeom::Translate(TTrimmedCurve);
787   }
788   else if (CurveType ==  STANDARD_TYPE(PGeom_OffsetCurve)) {
789     Handle(PGeom_OffsetCurve)& TOffsetCurve = 
790       (Handle(PGeom_OffsetCurve)&) PObj;
791     return MgtGeom::Translate(TOffsetCurve);
792   }
793   else {
794 #ifdef OCCT_DEBUG
795     cout << "MgtGeom : Unknown curve type ???? : " << endl;
796 #endif
797     Standard_NullObject::Raise("No mapping for the current Persistent Curve");
798   }
799 // POP pour NT
800   Handle(Geom_Curve) dummy;
801   return dummy;
802 }
803
804
805 //=======================================================================
806 //function : Translate
807 //purpose  : Translates a Geom_Curve to a PGeom_Curve.
808 //=======================================================================
809
810 Handle(PGeom_Curve)  MgtGeom::Translate(const Handle(Geom_Curve)& TObj)
811 {
812   Handle(Standard_Type) CurveType = TObj->DynamicType();
813
814   if (CurveType == STANDARD_TYPE(Geom_Line)) {
815     Handle(Geom_Line)& PLine = 
816       (Handle(Geom_Line)&) TObj;
817     return MgtGeom::Translate(PLine);
818   }
819   else if (CurveType ==  STANDARD_TYPE(Geom_Circle)) {
820     Handle(Geom_Circle)& PCircle = 
821       (Handle(Geom_Circle)&) TObj;
822     return MgtGeom::Translate(PCircle);
823   }
824   else if (CurveType ==  STANDARD_TYPE(Geom_Ellipse)) {
825     Handle(Geom_Ellipse)& PEllipse = 
826       (Handle(Geom_Ellipse)&) TObj;
827     return MgtGeom::Translate(PEllipse);
828   }
829   else if (CurveType ==  STANDARD_TYPE(Geom_Hyperbola)) {
830     Handle(Geom_Hyperbola)& PHyperbola = 
831       (Handle(Geom_Hyperbola)&) TObj;
832     return MgtGeom::Translate(PHyperbola);
833   }
834   else if (CurveType ==  STANDARD_TYPE(Geom_Parabola)) {
835     Handle(Geom_Parabola)& PParabola = 
836       (Handle(Geom_Parabola)&) TObj;
837     return MgtGeom::Translate(PParabola);
838   }
839   else if (CurveType ==  STANDARD_TYPE(Geom_BezierCurve)) {
840     Handle(Geom_BezierCurve)& PBezierCurve = 
841       (Handle(Geom_BezierCurve)&) TObj;
842     return MgtGeom::Translate(PBezierCurve);
843   }
844   else if (CurveType ==  STANDARD_TYPE(Geom_BSplineCurve)) {
845     Handle(Geom_BSplineCurve)& PBSplineCurve = 
846       (Handle(Geom_BSplineCurve)&) TObj;
847     return MgtGeom::Translate(PBSplineCurve);
848   }
849   else if (CurveType ==  STANDARD_TYPE(Geom_TrimmedCurve)) {
850     Handle(Geom_TrimmedCurve)& PTrimmedCurve = 
851       (Handle(Geom_TrimmedCurve)&) TObj;
852     return MgtGeom::Translate(PTrimmedCurve);
853   }
854   else if (CurveType ==  STANDARD_TYPE(Geom_OffsetCurve)) {
855     Handle(Geom_OffsetCurve)& POffsetCurve = 
856       (Handle(Geom_OffsetCurve)&) TObj;
857     return MgtGeom::Translate(POffsetCurve);
858   }
859   else {
860 #ifdef OCCT_DEBUG
861     cout << "MgtGeom : Unknown curve type ????"<<endl;
862 #endif
863     Standard_NullObject::Raise("No mapping for the current Transient Curve");
864
865   }
866 // POP pour NT
867   Handle(PGeom_Curve) dummy;
868   return dummy;
869 }
870
871
872 //=======================================================================
873 //function : Translate
874 //purpose  : Translates a PGeom_CylindricalSurface to a
875 //           Geom_CylindricalSurface.
876 //=======================================================================
877
878 Handle(Geom_CylindricalSurface)  MgtGeom::Translate
879        (const Handle(PGeom_CylindricalSurface)& PObj)
880 {
881   return  new Geom_CylindricalSurface(PObj->Position(),
882                                       PObj->Radius());
883 }
884
885
886 //=======================================================================
887 //function : Translate
888 //purpose  : Translates a Geom_CylindricalSurface to a PGeom_CylindricalSurface.
889 //=======================================================================
890
891 Handle(PGeom_CylindricalSurface)  MgtGeom::Translate(const Handle(Geom_CylindricalSurface)& TObj)
892 {
893   return new PGeom_CylindricalSurface(TObj->Position(),
894                                       TObj->Radius());
895 }
896
897
898 //=======================================================================
899 //function : Translate
900 //purpose  : Translates a PGeom_Direction to a Geom_Direction.
901 //=======================================================================
902
903 Handle(Geom_Direction)  MgtGeom::Translate
904        (const Handle(PGeom_Direction)& PObj)
905 {
906   gp_Vec vec = PObj->Vec();
907   return new Geom_Direction(vec.X(), vec.Y(), vec.Z()); }
908
909
910 //=======================================================================
911 //function : Translate
912 //purpose  : Translates a Geom_Direction to a PGeom_Direction.
913 //=======================================================================
914
915 Handle(PGeom_Direction)  MgtGeom::Translate
916        (const Handle(Geom_Direction)& TObj)
917 { return new PGeom_Direction(TObj->Vec()); }
918
919
920 //=======================================================================
921 //function : Translate
922 //purpose  : Translates a PGeom_Ellipse to a Geom_Ellipse.
923 //=======================================================================
924
925 Handle(Geom_Ellipse)  MgtGeom::Translate
926        (const Handle(PGeom_Ellipse)& PObj)
927 {
928   return new Geom_Ellipse(PObj->Position(),
929                           PObj->MajorRadius(),
930                           PObj->MinorRadius());
931 }
932
933
934 //=======================================================================
935 //function : Translate
936 //purpose  : Translates a Geom_Ellipse to a PGeom_Ellipse.
937 //=======================================================================
938
939 Handle(PGeom_Ellipse)  MgtGeom::Translate
940        (const Handle(Geom_Ellipse)& TObj)
941 {
942   return new PGeom_Ellipse(TObj->Position(),
943                            TObj->MajorRadius(),
944                            TObj->MinorRadius());
945 }
946
947
948 //=======================================================================
949 //function : Translate
950 //purpose  : Translates a PGeom_Hyperbola to a Geom_Hyperbola.
951 //=======================================================================
952
953 Handle(Geom_Hyperbola)  MgtGeom::Translate
954        (const Handle(PGeom_Hyperbola)& PObj)
955 {
956   return new Geom_Hyperbola(PObj->Position(),
957                             PObj->MajorRadius(),
958                             PObj->MinorRadius());
959 }
960
961
962 //=======================================================================
963 //function : Translate
964 //purpose  : Translates a Geom_Hyperbola to a PGeom_Hyperbola.
965 //=======================================================================
966
967 Handle(PGeom_Hyperbola)  MgtGeom::Translate(const Handle(Geom_Hyperbola)& TObj)
968 {
969   return new PGeom_Hyperbola(TObj->Position(),
970                              TObj->MajorRadius(),
971                              TObj->MinorRadius());
972 }
973
974
975 //=======================================================================
976 //function : Translate
977 //purpose  : Translates a PGeom_Line to a Geom_Line.
978 //=======================================================================
979
980 Handle(Geom_Line)  MgtGeom::Translate(const Handle(PGeom_Line)& PObj)
981 { return new Geom_Line(PObj->Position()); }
982
983
984 //=======================================================================
985 //function : Translate
986 //purpose  : Translates a Geom_Line to a PGeom_Line.
987 //=======================================================================
988
989 Handle(PGeom_Line)  MgtGeom::Translate(const Handle(Geom_Line)& TObj)
990 { return new PGeom_Line(TObj->Lin().Position()); }
991
992
993 //=======================================================================
994 //function : Translate
995 //purpose  : Translates a PGeom_OffsetCurve to a Geom_OffsetCurve.
996 //=======================================================================
997
998 Handle(Geom_OffsetCurve)  MgtGeom::Translate
999        (const Handle(PGeom_OffsetCurve)& PObj)
1000 {
1001   return new Geom_OffsetCurve(MgtGeom::Translate(PObj->BasisCurve()),
1002                               PObj->OffsetValue(),
1003                               PObj->OffsetDirection());
1004 }
1005
1006
1007 //=======================================================================
1008 //function : Translate
1009 //purpose  : Translates a Geom_OffsetCurve to a PGeom_OffsetCurve.
1010 //=======================================================================
1011
1012 Handle(PGeom_OffsetCurve)  MgtGeom::Translate(const Handle(Geom_OffsetCurve)& TObj)
1013 {
1014   return new PGeom_OffsetCurve(MgtGeom::Translate(TObj->BasisCurve()),
1015                                TObj->Offset(),
1016                                TObj->Direction());
1017 }
1018
1019
1020 //=======================================================================
1021 //function : Translate
1022 //purpose  : Translates a PGeom_OffsetSurface to a Geom_OffsetSurface.
1023 //=======================================================================
1024
1025 Handle(Geom_OffsetSurface)  MgtGeom::Translate
1026        (const Handle(PGeom_OffsetSurface)& PObj)
1027 {
1028   return new Geom_OffsetSurface(MgtGeom::Translate(PObj->BasisSurface()),
1029                                 PObj->OffsetValue());
1030 }
1031
1032
1033 //=======================================================================
1034 //function : Translate
1035 //purpose  : Translates a Geom_OffsetSurface to a PGeom_OffsetSurface.
1036 //=======================================================================
1037
1038 Handle(PGeom_OffsetSurface)  MgtGeom::Translate
1039        (const Handle(Geom_OffsetSurface)& TObj)
1040 {
1041   return new PGeom_OffsetSurface(MgtGeom::Translate(TObj->BasisSurface()),
1042                                  TObj->Offset());
1043 }
1044
1045
1046 //=======================================================================
1047 //function : Translate
1048 //purpose  : Translates a PGeom_Parabola to a Geom_Parabola.
1049 //=======================================================================
1050
1051 Handle(Geom_Parabola)  MgtGeom::Translate
1052        (const Handle(PGeom_Parabola)& PObj)
1053 {
1054   return new Geom_Parabola(PObj->Position(),
1055                            PObj->FocalLength());
1056 }
1057
1058
1059 //=======================================================================
1060 //function : Translate
1061 //purpose  : Translates a Geom_Parabola to a PGeom_Parabola.
1062 //=======================================================================
1063
1064 Handle(PGeom_Parabola)  MgtGeom::Translate
1065        (const Handle(Geom_Parabola)& TObj)
1066 {
1067   return new PGeom_Parabola(TObj->Position(),
1068                             TObj->Focal());
1069 }
1070
1071
1072 //=======================================================================
1073 //function : Translate
1074 //purpose  : Translates a PGeom_Plane to a Geom_Plane.
1075 //=======================================================================
1076
1077 Handle(Geom_Plane)  MgtGeom::Translate(const Handle(PGeom_Plane)& PObj)
1078 {  return new Geom_Plane(PObj->Position()); }
1079
1080
1081 //=======================================================================
1082 //function : Translate
1083 //purpose  : Translates a Geom_Plane to a PGeom_Plane.
1084 //=======================================================================
1085
1086 Handle(PGeom_Plane)  MgtGeom::Translate(const Handle(Geom_Plane)& TObj)
1087 {
1088   return new PGeom_Plane(TObj->Pln().Position());
1089 }
1090
1091 //=======================================================================
1092 //function : Translate
1093 //purpose  : Translates a PGeom_Point to a Geom_Point.
1094 //         : Optimized valid until new subtypes of GeomPoint exist
1095 //=======================================================================
1096
1097 Handle(Geom_Point)  MgtGeom::Translate
1098        (const Handle(PGeom_Point)& PObj)
1099 {
1100 /*
1101   Handle(Geom_Point) GeomP;
1102   Handle(Standard_Type) PointType = PObj->DynamicType();
1103   
1104   if (PointType == STANDARD_TYPE(PGeom_CartesianPoint)) {
1105     Handle(PGeom_CartesianPoint)& PCPoint = 
1106       (Handle(PGeom_CartesianPoint)&) PObj;
1107     GeomP = MgtGeom::Translate(PCPoint);
1108   }
1109   return GeomP;
1110 */
1111
1112   Handle(PGeom_CartesianPoint)& PCPoint = 
1113     (Handle(PGeom_CartesianPoint)&) PObj;
1114   return new Geom_CartesianPoint(PCPoint->Pnt());
1115 }
1116
1117
1118 //=======================================================================
1119 //function : Translate
1120 //purpose  : Translates a Geom_Point to a PGeom_Point.
1121 //         : Optimized valid until new subtypes of GeomPoint exist
1122 //=======================================================================
1123
1124 Handle(PGeom_Point)  MgtGeom::Translate
1125        (const Handle(Geom_Point)& TObj)
1126 {
1127 /*
1128   Handle(PGeom_Point) PGeomP;
1129   Handle(Standard_Type) PointType = TObj->DynamicType();
1130
1131   if (PointType == STANDARD_TYPE(Geom_CartesianPoint)) {
1132     Handle(Geom_CartesianPoint)& TCPoint = 
1133       (Handle(Geom_CartesianPoint)&) TObj;
1134     PGeomP = MgtGeom::Translate(TCPoint);
1135   }
1136   return PGeomP;
1137 */
1138
1139   Handle(Geom_CartesianPoint)& TCPoint = 
1140     (Handle(Geom_CartesianPoint)&) TObj;
1141
1142   return new PGeom_CartesianPoint(TCPoint->Pnt());
1143 }
1144
1145
1146 //=======================================================================
1147 //function : Translate
1148 //purpose  : Translates a PGeom_RectangularTrimmedSurface to a
1149 //           Geom_RectangularTrimmedSurface.
1150 //=======================================================================
1151
1152 Handle(Geom_RectangularTrimmedSurface)  MgtGeom::Translate
1153        (const Handle(PGeom_RectangularTrimmedSurface)& PObj)
1154 {
1155   return new Geom_RectangularTrimmedSurface
1156     (MgtGeom::Translate(PObj->BasisSurface()),
1157      PObj->FirstU(),
1158      PObj->LastU(),
1159      PObj->FirstV(),
1160      PObj->LastV(),
1161      Standard_True, Standard_True); // En attendant leur suppression.
1162 }
1163
1164
1165 //=======================================================================
1166 //function : Translate
1167 //purpose  : Translates a Geom_RectangularTrimmedSurface to a
1168 //           PGeom_RectangularTrimmedSurface.
1169 //=======================================================================
1170
1171 Handle(PGeom_RectangularTrimmedSurface)  MgtGeom::Translate
1172        (const Handle(Geom_RectangularTrimmedSurface)& TObj)
1173 {
1174   Standard_Real FirstU, LastU, FirstV, LastV;
1175   TObj->Bounds(FirstU, LastU, FirstV, LastV);
1176
1177   return new PGeom_RectangularTrimmedSurface
1178     (MgtGeom::Translate(TObj->BasisSurface()),
1179      FirstU, LastU,
1180      FirstV, LastV);
1181 }
1182
1183
1184 //=======================================================================
1185 //function : Translate
1186 //purpose  : Translates a PGeom_SphericalSurface to a
1187 //           Geom_SphericalSurface.
1188 //=======================================================================
1189
1190 Handle(Geom_SphericalSurface)  MgtGeom::Translate
1191        (const Handle(PGeom_SphericalSurface)& PObj)
1192 {
1193   return new Geom_SphericalSurface(PObj->Position(),
1194                                    PObj->Radius());
1195 }
1196
1197
1198 //=======================================================================
1199 //function : Translate
1200 //purpose  : Translates a Geom_SphericalSurface to a
1201 //           PGeom_SphericalSurface.
1202 //=======================================================================
1203
1204 Handle(PGeom_SphericalSurface)  MgtGeom::Translate
1205        (const Handle(Geom_SphericalSurface)& TObj)
1206 {
1207   return new PGeom_SphericalSurface(TObj->Position(),
1208                                     TObj->Radius());
1209 }
1210
1211
1212 //=======================================================================
1213 //function : Translate
1214 //purpose  : Translates a PGeom_Surface to a Geom_Surface.
1215 //=======================================================================
1216
1217 Handle(Geom_Surface)  MgtGeom::Translate(const Handle(PGeom_Surface)& PObj)
1218 {
1219   Handle(Standard_Type) SurfaceType = PObj->DynamicType();
1220
1221   if (SurfaceType == STANDARD_TYPE(PGeom_Plane)) {
1222     Handle(PGeom_Plane)& TPlane = 
1223       (Handle(PGeom_Plane)&) PObj;
1224     return MgtGeom::Translate(TPlane);
1225   }
1226   else if (SurfaceType ==  STANDARD_TYPE(PGeom_CylindricalSurface)) {
1227     Handle(PGeom_CylindricalSurface)& TCylindricalSurface = 
1228       (Handle(PGeom_CylindricalSurface)&) PObj;
1229     return MgtGeom::Translate(TCylindricalSurface);
1230   }
1231   else if (SurfaceType ==  STANDARD_TYPE(PGeom_ConicalSurface)) {
1232     Handle(PGeom_ConicalSurface)& TConicalSurface = 
1233       (Handle(PGeom_ConicalSurface)&) PObj;
1234     return MgtGeom::Translate(TConicalSurface);
1235   }
1236   else if (SurfaceType ==  STANDARD_TYPE(PGeom_SphericalSurface)) {
1237     Handle(PGeom_SphericalSurface)& TSphericalSurface = 
1238       (Handle(PGeom_SphericalSurface)&) PObj;
1239     return MgtGeom::Translate(TSphericalSurface);
1240   }
1241   else if (SurfaceType ==  STANDARD_TYPE(PGeom_ToroidalSurface)) {
1242     Handle(PGeom_ToroidalSurface)& TToroidalSurface = 
1243       (Handle(PGeom_ToroidalSurface)&) PObj;
1244     return MgtGeom::Translate(TToroidalSurface);
1245   }
1246   else if (SurfaceType ==  STANDARD_TYPE(PGeom_SurfaceOfLinearExtrusion)) {
1247     Handle(PGeom_SurfaceOfLinearExtrusion)& TSurfaceOfLinearExtrusion = 
1248       (Handle(PGeom_SurfaceOfLinearExtrusion)&) PObj;
1249     return MgtGeom::Translate(TSurfaceOfLinearExtrusion);
1250   }
1251   else if (SurfaceType ==  STANDARD_TYPE(PGeom_SurfaceOfRevolution)) {
1252     Handle(PGeom_SurfaceOfRevolution)& TSurfaceOfRevolution = 
1253       (Handle(PGeom_SurfaceOfRevolution)&) PObj;
1254     return MgtGeom::Translate(TSurfaceOfRevolution);
1255   }
1256   else if (SurfaceType ==  STANDARD_TYPE(PGeom_BezierSurface)) {
1257     Handle(PGeom_BezierSurface)& TBezierSurface = 
1258       (Handle(PGeom_BezierSurface)&) PObj;
1259     return MgtGeom::Translate(TBezierSurface);
1260   }
1261   else if (SurfaceType ==  STANDARD_TYPE(PGeom_BSplineSurface)) {
1262     Handle(PGeom_BSplineSurface)& TBSplineSurface = 
1263       (Handle(PGeom_BSplineSurface)&) PObj;
1264     return MgtGeom::Translate(TBSplineSurface);
1265   }
1266   else if (SurfaceType ==  STANDARD_TYPE(PGeom_RectangularTrimmedSurface)) {
1267     Handle(PGeom_RectangularTrimmedSurface)& TRectangularTrimmedSurface = 
1268       (Handle(PGeom_RectangularTrimmedSurface)&) PObj;
1269     return MgtGeom::Translate(TRectangularTrimmedSurface);
1270   }
1271   else if (SurfaceType ==  STANDARD_TYPE(PGeom_OffsetSurface)) {
1272     Handle(PGeom_OffsetSurface)& TOffsetSurface = 
1273       (Handle(PGeom_OffsetSurface)&) PObj;
1274     return MgtGeom::Translate(TOffsetSurface);
1275   }
1276   else {
1277 #ifdef OCCT_DEBUG
1278     cout << "MgtGeom : Unknown surface type ????"<<endl;
1279 #endif
1280     Standard_NullObject::Raise("No mapping for the current Persistent Surface");
1281
1282   }
1283 // POP pour NT
1284   Handle(Geom_Surface) dummy;
1285   return dummy;
1286 }
1287
1288
1289 //=======================================================================
1290 //function : Translate
1291 //purpose  : Translates a Geom_Surface to a PGeom_Surface.
1292 //=======================================================================
1293
1294 Handle(PGeom_Surface)  MgtGeom::Translate(const Handle(Geom_Surface)& TObj)
1295 {
1296   Handle(Standard_Type) SurfaceType = TObj->DynamicType();
1297
1298   if (SurfaceType == STANDARD_TYPE(Geom_Plane)) {
1299     Handle(Geom_Plane)& PPlane = 
1300       (Handle(Geom_Plane)&) TObj;
1301     return MgtGeom::Translate(PPlane);
1302   }
1303   else if (SurfaceType ==  STANDARD_TYPE(Geom_CylindricalSurface)) {
1304     Handle(Geom_CylindricalSurface)& PCylindricalSurface = 
1305       (Handle(Geom_CylindricalSurface)&) TObj;
1306     return MgtGeom::Translate(PCylindricalSurface);
1307   }
1308   else if (SurfaceType ==  STANDARD_TYPE(Geom_ConicalSurface)) {
1309     Handle(Geom_ConicalSurface)& PConicalSurface = 
1310       (Handle(Geom_ConicalSurface)&) TObj;
1311     return MgtGeom::Translate(PConicalSurface);
1312   }
1313   else if (SurfaceType ==  STANDARD_TYPE(Geom_SphericalSurface)) {
1314     Handle(Geom_SphericalSurface)& PSphericalSurface = 
1315       (Handle(Geom_SphericalSurface)&) TObj;
1316     return MgtGeom::Translate(PSphericalSurface);
1317   }
1318   else if (SurfaceType ==  STANDARD_TYPE(Geom_ToroidalSurface)) {
1319     Handle(Geom_ToroidalSurface)& PToroidalSurface = 
1320       (Handle(Geom_ToroidalSurface)&) TObj;
1321     return MgtGeom::Translate(PToroidalSurface);
1322   }
1323   else if (SurfaceType ==  STANDARD_TYPE(Geom_SurfaceOfLinearExtrusion)) {
1324     Handle(Geom_SurfaceOfLinearExtrusion)& PSurfaceOfLinearExtrusion = 
1325       (Handle(Geom_SurfaceOfLinearExtrusion)&) TObj;
1326     return MgtGeom::Translate(PSurfaceOfLinearExtrusion);
1327   }
1328   else if (SurfaceType ==  STANDARD_TYPE(Geom_SurfaceOfRevolution)) {
1329     Handle(Geom_SurfaceOfRevolution)& PSurfaceOfRevolution = 
1330       (Handle(Geom_SurfaceOfRevolution)&) TObj;
1331     return MgtGeom::Translate(PSurfaceOfRevolution);
1332   }
1333   else if (SurfaceType ==  STANDARD_TYPE(Geom_BezierSurface)) {
1334     Handle(Geom_BezierSurface)& PBezierSurface = 
1335       (Handle(Geom_BezierSurface)&) TObj;
1336     return MgtGeom::Translate(PBezierSurface);
1337   }
1338   else if (SurfaceType ==  STANDARD_TYPE(Geom_BSplineSurface)) {
1339     Handle(Geom_BSplineSurface)& PBSplineSurface = 
1340       (Handle(Geom_BSplineSurface)&) TObj;
1341     return MgtGeom::Translate(PBSplineSurface);
1342   }
1343   else if (SurfaceType ==  STANDARD_TYPE(Geom_RectangularTrimmedSurface)) {
1344     Handle(Geom_RectangularTrimmedSurface)& PRectangularTrimmedSurface = 
1345       (Handle(Geom_RectangularTrimmedSurface)&) TObj;
1346     return MgtGeom::Translate(PRectangularTrimmedSurface);
1347   }
1348   else if (SurfaceType ==  STANDARD_TYPE(Geom_OffsetSurface)) {
1349     Handle(Geom_OffsetSurface)& POffsetSurface = 
1350       (Handle(Geom_OffsetSurface)&) TObj;
1351     return MgtGeom::Translate(POffsetSurface);
1352   }
1353   else {
1354 #ifdef OCCT_DEBUG
1355     cout << "MgtGeom : Unknown surface type ????"<<endl;
1356 #endif
1357     Standard_NullObject::Raise("No mapping for the current Transient Surface");
1358   }
1359 // POP pour NT
1360   Handle(PGeom_Surface) dummy;
1361   return dummy;
1362 }
1363
1364
1365 //=======================================================================
1366 //function : Translate
1367 //purpose  : Translates a PGeom_SurfaceOfLinearExtrusion to a
1368 //           Geom_SurfaceOfLinearExtrusion.
1369 //=======================================================================
1370
1371 Handle(Geom_SurfaceOfLinearExtrusion)  MgtGeom::Translate
1372        (const Handle(PGeom_SurfaceOfLinearExtrusion)& PObj)
1373 {
1374   return new Geom_SurfaceOfLinearExtrusion
1375     (MgtGeom::Translate(PObj->BasisCurve()),
1376      PObj->Direction());
1377 }
1378
1379
1380 //=======================================================================
1381 //function : Translate
1382 //purpose  : Translates a Geom_SurfaceOfLinearExtrusion to a
1383 //           PGeom_SurfaceOfLinearExtrusion.
1384 //=======================================================================
1385
1386 Handle(PGeom_SurfaceOfLinearExtrusion)  MgtGeom::Translate
1387        (const Handle(Geom_SurfaceOfLinearExtrusion)& TObj)
1388 {
1389   return new PGeom_SurfaceOfLinearExtrusion
1390     (MgtGeom::Translate(TObj->BasisCurve()),
1391      TObj->Direction());
1392 }
1393
1394
1395 //=======================================================================
1396 //function : Translate
1397 //purpose  : Translates a PGeom_SurfaceOfRevolution to a
1398 //           Geom_SurfaceOfRevolution.
1399 //=======================================================================
1400
1401 Handle(Geom_SurfaceOfRevolution)  MgtGeom::Translate
1402        (const Handle(PGeom_SurfaceOfRevolution)& PObj)
1403 {
1404   gp_Ax1 axis(PObj->Location(), PObj->Direction());
1405   return new Geom_SurfaceOfRevolution(MgtGeom::Translate(PObj->BasisCurve()),
1406                                       axis);
1407
1408 }
1409
1410
1411 //=======================================================================
1412 //function : Translate
1413 //purpose  : Translates a Geom_SurfaceOfRevolution to a
1414 //           PGeom_SurfaceOfRevolution.
1415 //=======================================================================
1416
1417 Handle(PGeom_SurfaceOfRevolution)  MgtGeom::Translate
1418        (const Handle(Geom_SurfaceOfRevolution)& TObj)
1419 {
1420   return new PGeom_SurfaceOfRevolution(MgtGeom::Translate(TObj->BasisCurve()),
1421                                        TObj->Direction(),
1422                                        TObj->Location());
1423 }
1424
1425
1426 //=======================================================================
1427 //function : Translate
1428 //purpose  : Translates a PGeom_ToroidalSurface to a Geom_ToroidalSurface.
1429 //=======================================================================
1430
1431 Handle(Geom_ToroidalSurface)  MgtGeom::Translate
1432        (const Handle(PGeom_ToroidalSurface)& PObj)
1433 {
1434   return new Geom_ToroidalSurface(PObj->Position(),
1435                                   PObj->MajorRadius(),
1436                                   PObj->MinorRadius());
1437 }
1438
1439
1440 //=======================================================================
1441 //function : Translate
1442 //purpose  : Translates a Geom_ToroidalSurface to a PGeom_ToroidalSurface.
1443 //=======================================================================
1444
1445 Handle(PGeom_ToroidalSurface)  MgtGeom::Translate
1446        (const Handle(Geom_ToroidalSurface)& TObj)
1447 {
1448   return new PGeom_ToroidalSurface(TObj->Position(),
1449                                    TObj->MajorRadius(),
1450                                    TObj->MinorRadius());
1451 }
1452
1453
1454 //=======================================================================
1455 //function : Translate
1456 //purpose  : Translates a PGeom_Transformation to a Geom_Transformation.
1457 //=======================================================================
1458
1459 Handle(Geom_Transformation)  MgtGeom::Translate
1460        (const Handle(PGeom_Transformation)& PObj)
1461 { return new Geom_Transformation(PObj->Trsf()); }
1462
1463
1464 //=======================================================================
1465 //function : Translate
1466 //purpose  : Translates a Geom_Transformation to a PGeom_Transformation.
1467 //=======================================================================
1468
1469 Handle(PGeom_Transformation)  MgtGeom::Translate
1470        (const Handle(Geom_Transformation)& TObj)
1471 { return new PGeom_Transformation(TObj->Trsf()); }
1472
1473
1474 //=======================================================================
1475 //function : Translate
1476 //purpose  : Translates a PGeom_TrimmedCurve to a Geom_TrimmedCurve.
1477 //=======================================================================
1478
1479 Handle(Geom_TrimmedCurve)  MgtGeom::Translate
1480        (const Handle(PGeom_TrimmedCurve)& PObj)
1481 {
1482   return new Geom_TrimmedCurve(MgtGeom::Translate(PObj->BasisCurve()),
1483                                PObj->FirstU(),
1484                                PObj->LastU(),
1485                                Standard_True); // En attendant sa suppression.
1486 }
1487
1488
1489 //=======================================================================
1490 //function : Translate
1491 //purpose  : Translates a Geom_TrimmedCurve to a PGeom_TrimmedCurve.
1492 //=======================================================================
1493
1494 Handle(PGeom_TrimmedCurve)  MgtGeom::Translate
1495        (const Handle(Geom_TrimmedCurve)& TObj)
1496 {
1497   return new PGeom_TrimmedCurve(MgtGeom::Translate(TObj->BasisCurve()),
1498                                 TObj->FirstParameter(),
1499                                 TObj->LastParameter());
1500 }
1501
1502
1503 //=======================================================================
1504 //function : Translate
1505 //purpose  : Translates a PGeom_VectorWithMagnitude to a
1506 //           Geom_VectorWithMagnitude.
1507 //=======================================================================
1508
1509 Handle(Geom_VectorWithMagnitude)  MgtGeom::Translate
1510        (const Handle(PGeom_VectorWithMagnitude)& PObj)
1511 { return new Geom_VectorWithMagnitude(PObj->Vec()); }
1512
1513
1514 //=======================================================================
1515 //function : Translate
1516 //purpose  : Translates a Geom_VectorWithMagnitude to a
1517 //           PGeom_VectorWithMagnitude.
1518 //=======================================================================
1519
1520 Handle(PGeom_VectorWithMagnitude)  MgtGeom::Translate
1521        (const Handle(Geom_VectorWithMagnitude)& TObj)
1522 { return new PGeom_VectorWithMagnitude(TObj->Vec()); }