0024927: Getting rid of "Persistent" functionality -- Code
[occt.git] / src / MgtPoly / MgtPoly.cxx
1 // Copyright (c) 1998-1999 Matra Datavision
2 // Copyright (c) 1999-2014 OPEN CASCADE SAS
3 //
4 // This file is part of Open CASCADE Technology software library.
5 //
6 // This library is free software; you can redistribute it and/or modify it under
7 // the terms of the GNU Lesser General Public License version 2.1 as published
8 // by the Free Software Foundation, with special exception defined in the file
9 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
10 // distribution for complete text of the license and disclaimer of any warranty.
11 //
12 // Alternatively, this file may be used under the terms of Open CASCADE
13 // commercial license or contractual agreement.
14
15 #include <MgtPoly.ixx>
16
17 #include <TColgp_Array1OfPnt.hxx>
18 #include <PColgp_HArray1OfPnt.hxx>
19 #include <TColgp_Array1OfPnt2d.hxx>
20 #include <PColgp_HArray1OfPnt2d.hxx>
21
22 #include <TColStd_Array1OfReal.hxx>
23 #include <TColStd_HArray1OfReal.hxx>
24 #include <PColStd_HArray1OfReal.hxx>
25 #include <TColStd_Array1OfInteger.hxx>
26 #include <PColStd_HArray1OfInteger.hxx>
27
28 #include <Poly_Array1OfTriangle.hxx>
29 #include <PPoly_HArray1OfTriangle.hxx>
30
31 //=======================================================================
32 //function : ArrayCopy
33 //purpose  : Copy the gp_Pnt
34 //           from an Array1 from TColgp (TCollection)
35 //           to an HArray1 from PColgp (PCollection)
36 //=======================================================================
37
38 static Handle(PColgp_HArray1OfPnt) ArrayCopy
39        (const TColgp_Array1OfPnt& TArray)
40 {
41   Standard_Integer Lower = TArray.Lower();
42   Standard_Integer Upper = TArray.Upper();
43   Standard_Integer Index;
44   Handle(PColgp_HArray1OfPnt) PArray = new PColgp_HArray1OfPnt(Lower, Upper);
45   for (Index = Lower; Index <= Upper; Index++) {
46     PArray->SetValue(Index, TArray(Index));
47   }
48   return PArray;
49 }
50
51 //=======================================================================
52 //function : ArrayCopy
53 //purpose  : Copy the gp_Pnt
54 //           from an HArray1 from PColgp (PCollection)
55 //           to an Array1 from TColgp (TCollection)
56 //=======================================================================
57
58 static void ArrayCopy(const Handle(PColgp_HArray1OfPnt)& PArray,
59                       TColgp_Array1OfPnt& TArray)
60 {
61   Standard_Integer Lower = PArray->Lower();
62   Standard_Integer Upper = PArray->Upper();
63   Standard_Integer Index;
64   for (Index = Lower; Index <= Upper; Index++) {
65     TArray(Index) = PArray->Value(Index);
66   }
67 }
68
69 //=======================================================================
70 //function : ArrayCopy
71 //purpose  : Copy the gp_Pnt2d
72 //           from an Array1 from TColgp (TCollection)
73 //           to an Array1 from PColgp (PCollection)
74 //=======================================================================
75
76 static Handle(PColgp_HArray1OfPnt2d) ArrayCopy
77        (const TColgp_Array1OfPnt2d& TArray)
78 {
79   Standard_Integer Lower = TArray.Lower();
80   Standard_Integer Upper = TArray.Upper();
81   Standard_Integer Index;
82   Handle(PColgp_HArray1OfPnt2d) PArray = 
83     new PColgp_HArray1OfPnt2d(Lower, Upper);
84   for (Index = Lower; Index <= Upper; Index++) {
85     PArray->SetValue(Index, TArray(Index));
86   }
87   return PArray;
88 }
89
90 //=======================================================================
91 //function : ArrayCopy
92 //purpose  : Copy the gp_Pnt2d
93 //           from an HArray1 from PColgp (PCollection)
94 //           to an Array1 from TColgp (TCollection)
95 //=======================================================================
96
97 static void ArrayCopy
98   (const Handle(PColgp_HArray1OfPnt2d)& PArray,
99    TColgp_Array1OfPnt2d& TArray)
100 {
101   Standard_Integer Lower = PArray->Lower();
102   Standard_Integer Upper = PArray->Upper();
103   Standard_Integer Index;
104   for (Index = Lower; Index <= Upper; Index++) {
105     TArray(Index) = PArray->Value(Index);
106   }
107 }
108
109
110 //=======================================================================
111 //function : ArrayCopy
112 //purpose  : Copy the Triangle
113 //           from an Array1 from Poly (TCollection)
114 //           to an HArray1 from PPoly (PCollection)
115 //=======================================================================
116
117 static Handle(PPoly_HArray1OfTriangle) ArrayCopy
118 (const Poly_Array1OfTriangle& TArray)
119 {
120   Standard_Integer Lower = TArray.Lower();
121   Standard_Integer Upper = TArray.Upper();
122   Standard_Integer Index;
123   Handle(PPoly_HArray1OfTriangle) PArray = 
124     new PPoly_HArray1OfTriangle(Lower, Upper);
125   for (Index = Lower; Index <= Upper; Index++) {
126     PPoly_Triangle aPTriangle = MgtPoly::Translate(TArray(Index));
127     PArray->SetValue(Index, aPTriangle);
128   }
129   return PArray;
130 }
131
132 //=======================================================================
133 //function : ArrayCopy
134 //purpose  : Copy the Triangle
135 //           from an HArray1 from PPoly (PCollection)
136 //           to an Array1 from Poly (TCollection)
137 //=======================================================================
138
139 static void ArrayCopy
140   (const Handle(PPoly_HArray1OfTriangle)& PArray,
141    Poly_Array1OfTriangle& TArray)
142 {
143   Standard_Integer Lower = PArray->Lower();
144   Standard_Integer Upper = PArray->Upper();
145   Standard_Integer Index;
146   for (Index = Lower; Index <= Upper; Index++) {
147     Poly_Triangle aTTriangle = MgtPoly::Translate(PArray->Value(Index));
148     TArray(Index) = aTTriangle;
149   }
150 }
151
152 //=======================================================================
153 //function : ArrayCopy
154 //purpose  : Copy PColStd_HArray1OfInteger to TColStd_Array1OfInteger
155 //=======================================================================
156
157 static void ArrayCopy(const Handle(PColStd_HArray1OfInteger)& PArray,
158                       TColStd_Array1OfInteger&                TArray)
159 {
160   Standard_Integer Lower = PArray->Lower();
161   Standard_Integer Upper = PArray->Upper();
162   Standard_Integer Index;
163   for (Index = Lower; Index <= Upper; Index++) {
164     TArray(Index) = PArray->Value(Index);
165   }
166 }
167
168 //=======================================================================
169 //function : ArrayCopy
170 //purpose  : Copy TColStd_Array1OfInteger to PColStd_HArray1OfInteger
171 //=======================================================================
172
173 static Handle(PColStd_HArray1OfInteger) 
174 ArrayCopy(const TColStd_Array1OfInteger& TArray)
175 {
176   Standard_Integer Lower = TArray.Lower();
177   Standard_Integer Upper = TArray.Upper();
178   Standard_Integer Index;
179   Handle(PColStd_HArray1OfInteger) PArray = 
180     new PColStd_HArray1OfInteger(Lower, Upper);
181   for (Index = Lower; Index <= Upper; Index++) {
182     PArray->SetValue(Index, TArray.Value(Index));
183   }
184   return PArray;
185 }
186
187 //=======================================================================
188 //function : ArrayCopy
189 //purpose  : Copy PColStd_HArray1OfReal to TColStd_Array1OfReal
190 //=======================================================================
191
192 static void ArrayCopy(const Handle(PColStd_HArray1OfReal)& PArray,
193                       TColStd_Array1OfReal&                TArray)
194 {
195   Standard_Integer Lower = PArray->Lower();
196   Standard_Integer Upper = PArray->Upper();
197   Standard_Integer Index;
198   for (Index = Lower; Index <= Upper; Index++) {
199     TArray(Index) = PArray->Value(Index);
200   }
201 }
202
203 //=======================================================================
204 //function : ArrayCopy
205 //purpose  : Copy TColStd_Array1OfReal to PColStd_HArray1OfReal
206 //=======================================================================
207
208 static Handle(PColStd_HArray1OfReal) 
209 ArrayCopy(const TColStd_Array1OfReal& TArray)
210 {
211   Standard_Integer Lower = TArray.Lower();
212   Standard_Integer Upper = TArray.Upper();
213   Standard_Integer Index;
214   Handle(PColStd_HArray1OfReal) PArray = 
215     new PColStd_HArray1OfReal(Lower, Upper);
216   for (Index = Lower; Index <= Upper; Index++) {
217     PArray->SetValue(Index, TArray.Value(Index));
218   }
219   return PArray;
220 }
221
222
223 //=======================================================================
224 //function : 
225 //purpose  : Persistent -> Transient
226 //=======================================================================
227
228 Poly_Triangle MgtPoly::Translate(const PPoly_Triangle& PObj)
229 {
230   Standard_Integer n1, n2, n3;
231   PObj.Get(n1,n2,n3);
232   Poly_Triangle TT(n1, n2, n3);
233   return TT;
234 }
235
236 //=======================================================================
237 //function : 
238 //purpose  : Transient -> Persistent
239 //=======================================================================
240
241 PPoly_Triangle MgtPoly::Translate(const Poly_Triangle& TObj)
242 {
243   Standard_Integer n1, n2, n3;
244   TObj.Get(n1,n2,n3);
245   PPoly_Triangle PT(n1, n2, n3);
246   return PT;
247 }
248
249 //=======================================================================
250 //function : Translate Triangulation
251 //purpose  : Persistent -> Transient
252 //=======================================================================
253
254 Handle(Poly_Triangulation) MgtPoly::Translate
255 (const Handle(PPoly_Triangulation)& PObj, 
256  PTColStd_PersistentTransientMap& aMap)
257 {
258   Handle(Poly_Triangulation) TT;
259   if (!PObj.IsNull()) {
260     if (aMap.IsBound(PObj)) {
261
262       Handle(Standard_Transient) aTrans = aMap.Find(PObj);
263       TT = (Handle(Poly_Triangulation)&) aTrans;
264     }
265     else {              // translate and bind
266       
267       // myNodes
268       Handle(PColgp_HArray1OfPnt) PNodes = PObj->Nodes();
269       TColgp_Array1OfPnt TNodes (PNodes->Lower(), PNodes->Upper());
270       ArrayCopy(PNodes, TNodes);
271
272       // myTriangles
273       Handle(PPoly_HArray1OfTriangle) PTriangles = PObj->Triangles();
274       Poly_Array1OfTriangle TTriangles (PTriangles->Lower(), 
275                                         PTriangles->Upper());
276       ArrayCopy(PTriangles, TTriangles);
277       
278       // myUVNodes
279       if (PObj->HasUVNodes()) {
280         Handle(PColgp_HArray1OfPnt2d) PUVNodes = PObj->UVNodes();
281         TColgp_Array1OfPnt2d TUVNodes(PUVNodes->Lower(), PUVNodes->Upper());
282         ArrayCopy(PUVNodes, TUVNodes);
283         // Constructor
284         TT = new Poly_Triangulation(TNodes, TUVNodes, TTriangles);
285       }
286       else {
287         // Constructor
288         TT = new Poly_Triangulation(TNodes, TTriangles);
289       }
290       // Set deflection
291       TT->Deflection(PObj->Deflection());
292       aMap.Bind(PObj, TT);
293     }
294   }
295   return TT;
296 }
297
298 //=======================================================================
299 //function : Translate Triangulation
300 //purpose  : Transient -> Persistent
301 //=======================================================================
302
303 Handle(PPoly_Triangulation) MgtPoly::Translate
304 (const Handle(Poly_Triangulation)& TObj, 
305  PTColStd_TransientPersistentMap& aMap)
306 {
307   Handle(PPoly_Triangulation) PT;
308   if (!TObj.IsNull()) {
309     if (aMap.IsBound(TObj)) {
310       Handle(Standard_Persistent) aPers = aMap.Find(TObj);
311       PT = (Handle(PPoly_Triangulation)&) aPers;
312     }
313     else {
314       // myNodes
315       const TColgp_Array1OfPnt& TNodes = TObj->Nodes();
316       Handle(PColgp_HArray1OfPnt) PNodes = 
317         new PColgp_HArray1OfPnt(TNodes.Lower(), 
318                                 TNodes.Upper());
319       PNodes = ArrayCopy(TNodes);
320       
321       // myTriangles
322       const Poly_Array1OfTriangle& TTriangle = TObj->Triangles();
323       Handle(PPoly_HArray1OfTriangle) PTriangle =
324         new PPoly_HArray1OfTriangle(TTriangle.Lower(), 
325                                     TTriangle.Upper());
326       PTriangle = ArrayCopy(TTriangle);
327       
328       // myUVNodes
329       Handle(PColgp_HArray1OfPnt2d) PUVNodes;
330       if (TObj->HasUVNodes()) {
331         const TColgp_Array1OfPnt2d& TUVNodes = TObj->UVNodes();
332         PUVNodes = 
333           new PColgp_HArray1OfPnt2d(TUVNodes.Lower(), 
334                                     TUVNodes.Upper());
335         PUVNodes = ArrayCopy(TUVNodes);
336       }
337       // Constructor + Deflection
338       PT = new PPoly_Triangulation(TObj->Deflection(),
339                                    PNodes, PUVNodes, PTriangle);
340       aMap.Bind(TObj, PT);
341     }
342   }
343   return PT;
344 }
345
346 //=======================================================================
347 //function : Translate Polygon3D
348 //purpose  : Persistent -> Transient
349 //=======================================================================
350
351 Handle(Poly_Polygon3D) MgtPoly::Translate
352 (const Handle(PPoly_Polygon3D)& PObj, 
353  PTColStd_PersistentTransientMap& aMap)
354 {
355   Handle(Poly_Polygon3D) TP;
356   if (!PObj.IsNull()) {
357     if (aMap.IsBound(PObj)) {
358       Handle(Standard_Transient) aTrans = aMap.Find(PObj);
359       TP = (Handle(Poly_Polygon3D)&) aTrans;
360     }
361     else {
362
363       // myNodes
364       Handle(PColgp_HArray1OfPnt) PNodes = PObj->Nodes();
365       TColgp_Array1OfPnt TNodes(PNodes->Lower(), PNodes->Upper());
366       ArrayCopy(PNodes, TNodes);
367       
368       // myParameters
369
370       Handle(PColStd_HArray1OfReal) PParam = PObj->Parameters();
371       TColStd_Array1OfReal TParam(PParam->Lower(), PParam->Upper());
372       ArrayCopy(PParam, TParam);
373
374       // Constructor + Deflection
375       TP = new Poly_Polygon3D(TNodes, TParam);
376       TP->Deflection(PObj->Deflection());
377       aMap.Bind(PObj, TP);
378     }
379   }
380   return TP;
381 }
382
383 //=======================================================================
384 //function : Translate Polygon3D
385 //purpose  : Transient -> Persistent
386 //=======================================================================
387
388 Handle(PPoly_Polygon3D) MgtPoly::Translate
389 (const Handle(Poly_Polygon3D)& TObj, 
390  PTColStd_TransientPersistentMap& aMap)
391 {
392   Handle(PPoly_Polygon3D) PT;
393   if (!TObj.IsNull()) {
394     if (aMap.IsBound(TObj)) {
395       Handle(Standard_Persistent) aPers = aMap.Find(TObj);
396       PT = (Handle(PPoly_Polygon3D)&) aPers;
397     }
398     else {
399       // myNodes
400       const TColgp_Array1OfPnt& TNodes = TObj->Nodes();
401       Handle(PColgp_HArray1OfPnt) PNodes = 
402         new PColgp_HArray1OfPnt(TNodes.Lower(), 
403                                 TNodes.Upper());
404       PNodes = ArrayCopy(TNodes);
405
406       // myParameters
407       const TColStd_Array1OfReal& TParam = TObj->Parameters();
408       Handle(PColStd_HArray1OfReal) PParam = 
409         new PColStd_HArray1OfReal(TParam.Lower(), TParam.Upper());
410       PParam = ArrayCopy(TParam);
411
412       // constructor + Deflection
413       PT = new PPoly_Polygon3D(PNodes, PParam, TObj->Deflection());
414       aMap.Bind(TObj, PT);
415     }
416   }
417   return PT;  
418 }
419
420 //=======================================================================
421 //function : Translate Polygon2D
422 //purpose  : Persistent -> Transient
423 //=======================================================================
424
425 Handle(Poly_Polygon2D) MgtPoly::Translate
426 (const Handle(PPoly_Polygon2D)& PObj, 
427  PTColStd_PersistentTransientMap& aMap)
428 {
429   Handle(Poly_Polygon2D) TP;
430   if (!PObj.IsNull()) {
431     if (aMap.IsBound(PObj)) {
432       Handle(Standard_Transient) aTrans = aMap.Find(PObj);
433       TP = (Handle(Poly_Polygon2D)&) aTrans;
434     }
435     else {
436       // myNodes
437       Handle(PColgp_HArray1OfPnt2d) PUVNodes = PObj->Nodes();
438       TColgp_Array1OfPnt2d TUVNodes(PUVNodes->Lower(), PUVNodes->Upper());
439       ArrayCopy(PUVNodes, TUVNodes);
440
441       // Constructor + Deflection
442       TP = new Poly_Polygon2D(TUVNodes);
443       TP->Deflection(PObj->Deflection());
444       aMap.Bind(PObj, TP);
445     }
446   }
447   return TP;
448 }
449
450 //=======================================================================
451 //function : Translate Polygon2D
452 //purpose  : Transient -> Persistent
453 //=======================================================================
454
455 Handle(PPoly_Polygon2D) MgtPoly::Translate
456 (const Handle(Poly_Polygon2D)& TObj, 
457  PTColStd_TransientPersistentMap& aMap)
458 {
459   Handle(PPoly_Polygon2D) PT;
460   if (!TObj.IsNull()) {
461     if (aMap.IsBound(TObj)) {
462       Handle(Standard_Persistent) aPers = aMap.Find(TObj);
463       PT = (Handle(PPoly_Polygon2D)&) aPers;
464     }
465     else {
466       // myNodes
467       const TColgp_Array1OfPnt2d& TUVNodes = TObj->Nodes();
468       Handle(PColgp_HArray1OfPnt2d) PUVNodes = 
469         new PColgp_HArray1OfPnt2d(TUVNodes.Lower(), 
470                                   TUVNodes.Upper());
471       PUVNodes = ArrayCopy(TUVNodes);
472       
473       // constructor + Deflection
474       PT = new PPoly_Polygon2D(PUVNodes, TObj->Deflection());
475       aMap.Bind(TObj, PT);
476     }
477   }
478   return PT;
479 }
480
481 //=======================================================================
482 //function : Translate PolygonOnTriangulation
483 //purpose  : Persistent -> Transient
484 //=======================================================================
485
486 Handle(Poly_PolygonOnTriangulation) MgtPoly::Translate
487 (const Handle(PPoly_PolygonOnTriangulation)& PObj, 
488  PTColStd_PersistentTransientMap& aMap)
489 {
490   Handle(Poly_PolygonOnTriangulation) TP;
491   if (!PObj.IsNull()) {
492     if (aMap.IsBound(PObj)) {
493       Handle(Standard_Transient) aTrans = aMap.Find(PObj);
494       TP = (Handle(Poly_PolygonOnTriangulation)&) aTrans;
495     }
496     else {
497
498       // myNodes
499       Handle(PColStd_HArray1OfInteger) PNodes = PObj->Nodes();
500       TColStd_Array1OfInteger TNodes(PNodes->Lower(), PNodes->Upper());
501       ArrayCopy(PNodes, TNodes);
502
503       // myParameters
504
505       if (PObj->HasParameters()) {
506         Handle(PColStd_HArray1OfReal) PParam = PObj->Parameters();
507         TColStd_Array1OfReal TParam(PParam->Lower(), PParam->Upper());
508         ArrayCopy(PParam, TParam);
509         
510         // Constructor + Deflection
511         TP = new Poly_PolygonOnTriangulation(TNodes, TParam);
512         TP->Deflection(PObj->Deflection());
513         aMap.Bind(PObj, TP);
514       }
515       else {
516         TP = new Poly_PolygonOnTriangulation(TNodes);
517         TP->Deflection(PObj->Deflection());
518         aMap.Bind(PObj, TP);
519       }
520     }
521   }
522   return TP;
523 }
524
525 //=======================================================================
526 //function : Translate PolygonOnTriangulation
527 //purpose  : Transient -> Persistent
528 //=======================================================================
529
530 Handle(PPoly_PolygonOnTriangulation) MgtPoly::Translate
531 (const Handle(Poly_PolygonOnTriangulation)& TObj, 
532  PTColStd_TransientPersistentMap& aMap)
533 {
534   Handle(PPoly_PolygonOnTriangulation) PT;
535   if (!TObj.IsNull()) {
536     if (aMap.IsBound(TObj)) {
537       Handle(Standard_Persistent) aPers = aMap.Find(TObj);
538       PT = (Handle(PPoly_PolygonOnTriangulation)&) aPers;
539     }
540     else {
541       // myNodes
542       const TColStd_Array1OfInteger& TNodes = TObj->Nodes();
543       Handle(PColStd_HArray1OfInteger) PNodes = 
544         new PColStd_HArray1OfInteger(TNodes.Lower(), 
545                                      TNodes.Upper());
546       PNodes = ArrayCopy(TNodes);
547       
548       // myParameters
549
550       if (TObj->HasParameters()) {
551         const TColStd_Array1OfReal& TParam = TObj->Parameters()->Array1();
552         Handle(PColStd_HArray1OfReal) PParam =
553           new PColStd_HArray1OfReal(TParam.Lower(), TParam.Upper());
554         PParam = ArrayCopy(TParam);
555         // constructor + Deflection
556         PT = new PPoly_PolygonOnTriangulation(PNodes, TObj->Deflection(),
557                                               PParam);
558         aMap.Bind(TObj, PT);
559         
560       }
561       else {
562         // constructor + Deflection
563         PT = new PPoly_PolygonOnTriangulation(PNodes, TObj->Deflection());
564         aMap.Bind(TObj, PT);
565       }
566     }
567   }
568   return PT;
569 }