0031918: Application Framework - New binary format for fast reading part of OCAF...
[occt.git] / src / BinTools / BinTools_SurfaceSet.cxx
1 // Created on: 2004-05-20
2 // Created by: Sergey ZARITCHNY
3 // Copyright (c) 2004-2014 OPEN CASCADE SAS
4 //
5 // This file is part of Open CASCADE Technology software library.
6 //
7 // This library is free software; you can redistribute it and/or modify it under
8 // the terms of the GNU Lesser General Public License version 2.1 as published
9 // by the Free Software Foundation, with special exception defined in the file
10 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
11 // distribution for complete text of the license and disclaimer of any warranty.
12 //
13 // Alternatively, this file may be used under the terms of Open CASCADE
14 // commercial license or contractual agreement.
15
16
17 #include <BinTools.hxx>
18 #include <BinTools_CurveSet.hxx>
19 #include <BinTools_SurfaceSet.hxx>
20 #include <Geom_BezierSurface.hxx>
21 #include <Geom_BSplineSurface.hxx>
22 #include <Geom_ConicalSurface.hxx>
23 #include <Geom_CylindricalSurface.hxx>
24 #include <Geom_OffsetSurface.hxx>
25 #include <Geom_Plane.hxx>
26 #include <Geom_RectangularTrimmedSurface.hxx>
27 #include <Geom_SphericalSurface.hxx>
28 #include <Geom_Surface.hxx>
29 #include <Geom_SurfaceOfLinearExtrusion.hxx>
30 #include <Geom_SurfaceOfRevolution.hxx>
31 #include <Geom_ToroidalSurface.hxx>
32 #include <gp_Cone.hxx>
33 #include <gp_Cylinder.hxx>
34 #include <gp_Pln.hxx>
35 #include <gp_Sphere.hxx>
36 #include <gp_Torus.hxx>
37 #include <Standard_ErrorHandler.hxx>
38 #include <Standard_Failure.hxx>
39 #include <Standard_OutOfRange.hxx>
40 #include <TColgp_Array1OfPnt.hxx>
41 #include <TColgp_Array2OfPnt.hxx>
42 #include <TColStd_Array1OfInteger.hxx>
43 #include <TColStd_Array1OfReal.hxx>
44 #include <TColStd_Array2OfReal.hxx>
45 #include <Message_ProgressScope.hxx>
46
47 #define PLANE           1
48 #define CYLINDER        2
49 #define CONE            3
50 #define SPHERE          4
51 #define TORUS           5
52 #define LINEAREXTRUSION 6
53 #define REVOLUTION      7
54 #define BEZIER          8
55 #define BSPLINE         9
56 #define RECTANGULAR     10
57 #define OFFSET          11
58
59 //=======================================================================
60 //function : BinTools_SurfaceSet
61 //purpose  : 
62 //=======================================================================
63
64 BinTools_SurfaceSet::BinTools_SurfaceSet() 
65 {
66 }
67
68
69 //=======================================================================
70 //function : Clear
71 //purpose  : 
72 //=======================================================================
73
74 void  BinTools_SurfaceSet::Clear()
75 {
76   myMap.Clear();
77 }
78
79
80 //=======================================================================
81 //function : Add
82 //purpose  : 
83 //=======================================================================
84
85 Standard_Integer  BinTools_SurfaceSet::Add(const Handle(Geom_Surface)& S)
86 {
87   return myMap.Add(S);
88 }
89
90
91 //=======================================================================
92 //function : Surface
93 //purpose  : 
94 //=======================================================================
95
96 Handle(Geom_Surface)  BinTools_SurfaceSet::Surface
97        (const Standard_Integer I)const 
98 {
99   return  Handle(Geom_Surface)::DownCast(myMap(I));
100 }
101
102
103 //=======================================================================
104 //function : Index
105 //purpose  : 
106 //=======================================================================
107
108 Standard_Integer  BinTools_SurfaceSet::Index
109   (const Handle(Geom_Surface)& S)const 
110 {
111   return myMap.FindIndex(S);
112 }
113
114 //=======================================================================
115 //function : operator <<(Geom_Plane)
116 //purpose  : 
117 //=======================================================================
118
119 static BinTools_OStream& operator <<(BinTools_OStream& OS, const Handle(Geom_Plane)& S)
120 {
121   OS << (Standard_Byte)PLANE;
122   gp_Pln P = S->Pln();
123   OS << P.Location(); // Pnt
124   OS << P.Axis().Direction();
125   OS << P.XAxis().Direction();
126   OS << P.YAxis().Direction();
127   return OS;
128 }
129
130
131 //=======================================================================
132 //function : operator <<(Geom_CylindricalSurface)
133 //purpose  : 
134 //=======================================================================
135
136 static BinTools_OStream& operator <<(BinTools_OStream& OS, const Handle(Geom_CylindricalSurface)& S)
137 {
138   OS << (Standard_Byte)CYLINDER;
139   gp_Cylinder P = S->Cylinder();
140   OS << P.Location(); // Pnt
141   OS << P.Axis().Direction();
142   OS << P.XAxis().Direction();
143   OS << P.YAxis().Direction();
144   OS << P.Radius();
145   return OS;
146 }
147
148
149 //=======================================================================
150 //function : operator <<(Geom_ConicalSurface)
151 //purpose  : 
152 //=======================================================================
153
154 static BinTools_OStream& operator <<(BinTools_OStream& OS, const Handle(Geom_ConicalSurface)& S)
155 {
156   OS << (Standard_Byte)CONE;
157   gp_Cone P = S->Cone();
158   OS << P.Location(); // Pnt
159   OS << P.Axis().Direction();
160   OS << P.XAxis().Direction();
161   OS << P.YAxis().Direction();
162   OS << P.RefRadius();
163   OS << P.SemiAngle();
164   return OS;
165 }
166
167
168 //=======================================================================
169 //function : operator <<(Geom_SphericalSurface)
170 //purpose  : 
171 //=======================================================================
172
173 static BinTools_OStream& operator <<(BinTools_OStream& OS, const Handle(Geom_SphericalSurface)& S)
174 {
175   OS << (Standard_Byte)SPHERE;
176   gp_Sphere P = S->Sphere();
177   OS << P.Location(); // Pnt
178   OS << P.Position().Axis().Direction();
179   OS << P.XAxis().Direction();
180   OS << P.YAxis().Direction();
181   OS << P.Radius();
182   return OS;
183 }
184
185
186 //=======================================================================
187 //function : operator <<(Geom_ToroidalSurface)
188 //purpose  : 
189 //=======================================================================
190
191 static BinTools_OStream& operator <<(BinTools_OStream& OS, const Handle(Geom_ToroidalSurface)& S)
192 {
193   OS << (Standard_Byte)TORUS;
194   gp_Torus P = S->Torus();
195   OS << P.Location(); // Pnt
196   OS << P.Axis().Direction();
197   OS << P.XAxis().Direction();
198   OS << P.YAxis().Direction();
199   OS << P.MajorRadius();
200   OS << P.MinorRadius();
201   return OS;
202 }
203
204
205 //=======================================================================
206 //function : operator <<(Geom_SurfaceOfLinearExtrusion)
207 //purpose  : 
208 //=======================================================================
209
210 static BinTools_OStream& operator <<(BinTools_OStream& OS, const Handle(Geom_SurfaceOfLinearExtrusion)& S)
211 {
212   OS << (Standard_Byte)LINEAREXTRUSION;
213   OS << S->Direction();
214   BinTools_CurveSet::WriteCurve (S->BasisCurve(), OS);
215   return OS;
216 }
217
218
219 //=======================================================================
220 //function : operator <<(Geom_SurfaceOfRevolution)
221 //purpose  : 
222 //=======================================================================
223
224 static BinTools_OStream& operator <<(BinTools_OStream& OS, const Handle(Geom_SurfaceOfRevolution)& S)
225 {
226   OS << (Standard_Byte)REVOLUTION;
227   OS << S->Location();
228   OS << S->Direction();
229   BinTools_CurveSet::WriteCurve (S->BasisCurve(), OS);
230   return OS;
231 }
232
233
234 //=======================================================================
235 //function : operator <<(Geom_BezierSurface)
236 //purpose  : 
237 //=======================================================================
238
239 static BinTools_OStream& operator <<(BinTools_OStream& OS, const Handle(Geom_BezierSurface)& S)
240 {
241   OS << (Standard_Byte)BEZIER;
242   Standard_Boolean urational = S->IsURational() ? 1:0;
243   Standard_Boolean vrational = S->IsVRational() ? 1:0;
244   OS << urational; // rational
245   OS << vrational;
246
247   // poles and weights
248   Standard_Integer i,j,udegree,vdegree;
249   udegree = S->UDegree();
250   vdegree = S->VDegree();
251   OS << (Standard_ExtCharacter)udegree;
252   OS << (Standard_ExtCharacter)vdegree;
253   for (i = 1; i <= udegree+1; i++) {
254     for (j = 1; j <= vdegree+1; j++) {
255       OS << S->Pole (i,j); // Pnt
256       if (urational || vrational) {
257               OS << S->Weight (i,j); // Real
258       }
259     }
260   }
261   return OS;
262 }
263
264
265 //=======================================================================
266 //function : operator <<(Geom_BSplineSurface)
267 //purpose  : 
268 //=======================================================================
269
270 static BinTools_OStream& operator <<(BinTools_OStream& OS, const Handle(Geom_BSplineSurface)& S)
271 {
272   OS << (Standard_Byte)BSPLINE;
273   Standard_Boolean urational = S->IsURational() ? 1:0;
274   Standard_Boolean vrational = S->IsVRational() ? 1:0;
275   Standard_Boolean uperiodic = S->IsUPeriodic() ? 1:0;
276   Standard_Boolean vperiodic = S->IsVPeriodic() ? 1:0;
277   OS << urational;
278   OS << vrational; 
279   OS << uperiodic;
280   OS << vperiodic;
281
282 // poles and weights
283   Standard_Integer i,j,udegree,vdegree,nbupoles,nbvpoles,nbuknots,nbvknots;
284   udegree  = S->UDegree();
285   vdegree  = S->VDegree();
286   nbupoles = S->NbUPoles();
287   nbvpoles = S->NbVPoles();
288   nbuknots = S->NbUKnots();
289   nbvknots = S->NbVKnots();
290   OS << (Standard_ExtCharacter) udegree;
291   OS << (Standard_ExtCharacter) vdegree;
292   OS << nbupoles;
293   OS << nbvpoles;
294   OS << nbuknots;
295   OS << nbvknots;
296   for (i = 1; i <= nbupoles; i++) {
297     for (j = 1; j <= nbvpoles; j++) {
298       OS << S->Pole (i,j); // Pnt
299       if (urational || vrational)
300               OS << S->Weight (i,j); // Real    
301     }
302   }
303
304   for (i = 1; i <= nbuknots; i++) {
305     OS << S->UKnot (i);
306     OS << S->UMultiplicity (i);
307   }
308
309   for (i = 1; i <= nbvknots; i++) {
310     OS << S->VKnot (i);
311     OS << S->VMultiplicity (i);
312   }
313   return OS;
314 }
315
316
317 //=======================================================================
318 //function :  operator <<(Geom_RectangularTrimmedSurface)
319 //purpose  : 
320 //=======================================================================
321
322 static BinTools_OStream& operator <<(BinTools_OStream& OS, const Handle(Geom_RectangularTrimmedSurface)& S)
323 {
324   OS << (Standard_Byte)RECTANGULAR;
325   Standard_Real U1,U2,V1,V2;
326   S->Bounds(U1,U2,V1,V2);
327   OS << U1 << U2 << V1 << V2;
328   BinTools_SurfaceSet::WriteSurface (S->BasisSurface(), OS);
329   return OS;
330 }
331
332
333 //=======================================================================
334 //function : operator <<(Geom_OffsetSurface)
335 //purpose  : 
336 //=======================================================================
337
338 static BinTools_OStream& operator <<(BinTools_OStream& OS, const Handle(Geom_OffsetSurface)& S)
339 {
340   OS << (Standard_Byte)OFFSET;
341   OS << S->Offset();
342   BinTools_SurfaceSet::WriteSurface (S->BasisSurface(), OS);
343   return OS;
344 }
345
346
347 //=======================================================================
348 //function : WriteSurface
349 //purpose  : 
350 //=======================================================================
351
352 void BinTools_SurfaceSet::WriteSurface (const Handle(Geom_Surface)& S,
353   BinTools_OStream& OS)
354 {
355   Handle(Standard_Type) TheType = S->DynamicType();
356   try {
357     OCC_CATCH_SIGNALS
358     if ( TheType ==  STANDARD_TYPE(Geom_Plane)) {
359       OS << Handle(Geom_Plane)::DownCast(S);
360     }
361     else if ( TheType ==  STANDARD_TYPE(Geom_CylindricalSurface)) {
362       OS << Handle(Geom_CylindricalSurface)::DownCast(S);
363     }
364     else if ( TheType ==  STANDARD_TYPE(Geom_ConicalSurface)) {
365       OS << Handle(Geom_ConicalSurface)::DownCast(S);
366     }
367     else if ( TheType ==  STANDARD_TYPE(Geom_SphericalSurface)) {
368       OS << Handle(Geom_SphericalSurface)::DownCast(S);
369     }
370     else if ( TheType ==  STANDARD_TYPE(Geom_ToroidalSurface)) {
371       OS << Handle(Geom_ToroidalSurface)::DownCast(S);
372     }
373     else if ( TheType ==  STANDARD_TYPE(Geom_SurfaceOfLinearExtrusion)) {
374       OS << Handle(Geom_SurfaceOfLinearExtrusion)::DownCast(S);
375     }
376     else if ( TheType ==  STANDARD_TYPE(Geom_SurfaceOfRevolution)) {
377       OS << Handle(Geom_SurfaceOfRevolution)::DownCast(S);
378     }
379     else if ( TheType ==  STANDARD_TYPE(Geom_BezierSurface)) {
380       OS << Handle(Geom_BezierSurface)::DownCast(S);
381     }
382     else if ( TheType ==  STANDARD_TYPE(Geom_BSplineSurface)) {
383       OS << Handle(Geom_BSplineSurface)::DownCast(S);
384     }
385     else if ( TheType ==  STANDARD_TYPE(Geom_RectangularTrimmedSurface)) {
386       OS << Handle(Geom_RectangularTrimmedSurface)::DownCast(S);
387     }
388     else if ( TheType ==  STANDARD_TYPE(Geom_OffsetSurface)) {
389       OS << Handle(Geom_OffsetSurface)::DownCast(S);
390     }
391     else {
392       throw Standard_Failure("UNKNOWN SURFACE TYPE");
393     }
394   }
395    catch(Standard_Failure const& anException) {
396      Standard_SStream aMsg;
397     aMsg << "EXCEPTION in BinTools_SurfaceSet::WriteSurface(..)" << std::endl;
398     aMsg << anException << std::endl;
399     throw Standard_Failure(aMsg.str().c_str());
400   }  
401 }
402
403 //=======================================================================
404 //function : Write
405 //purpose  : 
406 //=======================================================================
407
408 void  BinTools_SurfaceSet::Write (Standard_OStream& OS,
409                                   const Message_ProgressRange& theRange)const
410 {
411
412   Standard_Integer i, nbsurf = myMap.Extent();
413   Message_ProgressScope aPS(theRange, "Writing surfaces", nbsurf);
414   OS << "Surfaces "<< nbsurf << "\n";
415   BinTools_OStream aStream (OS);
416   for (i = 1; i <= nbsurf && aPS.More(); i++, aPS.Next()) {
417     WriteSurface(Handle(Geom_Surface)::DownCast(myMap(i)), aStream);
418   }
419
420 }
421
422
423 //=======================================================================
424 //function : ReadPnt
425 //purpose  : 
426 //=======================================================================
427
428 static Standard_IStream& operator>>(Standard_IStream& IS, gp_Pnt& P)
429 {
430   Standard_Real X=0.,Y=0.,Z=0.;
431   BinTools::GetReal(IS, X);
432   BinTools::GetReal(IS, Y);
433   BinTools::GetReal(IS, Z);
434   P.SetCoord(X,Y,Z);
435   return IS;
436 }
437
438 //=======================================================================
439 //function : ReadDir
440 //purpose  : 
441 //=======================================================================
442
443 static Standard_IStream& operator>>(Standard_IStream& IS, gp_Dir& D)
444 {
445   Standard_Real X=0.,Y=0.,Z=0.;
446   BinTools::GetReal(IS, X);
447   BinTools::GetReal(IS, Y);
448   BinTools::GetReal(IS, Z);
449   D.SetCoord(X,Y,Z);
450   return IS;
451 }
452
453 //=======================================================================
454 //function : ReadAx3
455 //purpose  : 
456 //=======================================================================
457
458 static Standard_IStream& operator>>(Standard_IStream& IS, gp_Ax3& A3)
459 {
460   gp_Pnt P(0.,0.,0.);
461   gp_Dir A(1.,0.,0.),AX(1.,0.,0.),AY(1.,0.,0.);
462   IS >> P >> A >> AX >> AY;
463   gp_Ax3 ax3(P,A,AX);
464   if (AY.DotCross(A,AX) < 0)
465     ax3.YReverse();
466   A3 = ax3;
467   return IS;
468 }
469
470
471 //=======================================================================
472 //function : operator>>
473 //purpose  : 
474 //=======================================================================
475
476 static Standard_IStream& operator>>(Standard_IStream& IS,
477                                     Handle(Geom_Plane)& S)
478 {
479   gp_Ax3 A;
480   IS >> A;
481   S = new Geom_Plane(A);
482   return IS;
483 }
484
485 //=======================================================================
486 //function : operator>>
487 //purpose  : 
488 //=======================================================================
489
490 static Standard_IStream& operator>>(Standard_IStream& IS,
491                                     Handle(Geom_CylindricalSurface)& S)
492 {
493   gp_Ax3 A;
494   Standard_Real R=0.;
495   IS >> A;
496   BinTools::GetReal(IS, R);
497   S = new Geom_CylindricalSurface(A,R);
498   return IS;
499 }
500
501 //=======================================================================
502 //function : operator>>
503 //purpose  : 
504 //=======================================================================
505
506 static Standard_IStream& operator>>(Standard_IStream& IS,
507                                     Handle(Geom_ConicalSurface)& S)
508 {
509   gp_Ax3 A;
510   Standard_Real R=0.,Ang=0.;
511   IS >> A;
512   BinTools::GetReal(IS, R);
513   BinTools::GetReal(IS, Ang);
514   S = new Geom_ConicalSurface(A,Ang,R);
515   return IS;
516 }
517
518 //=======================================================================
519 //function : operator>>
520 //purpose  : 
521 //=======================================================================
522
523 static Standard_IStream& operator>>(Standard_IStream& IS,
524                                     Handle(Geom_SphericalSurface)& S)
525 {
526   gp_Ax3 A;
527   Standard_Real R=0.;
528   IS >> A;
529   BinTools::GetReal(IS, R);
530   S = new Geom_SphericalSurface(A,R);
531   return IS;
532 }
533
534 //=======================================================================
535 //function : operator>>
536 //purpose  : 
537 //=======================================================================
538
539 static Standard_IStream& operator>>(Standard_IStream& IS,
540                                     Handle(Geom_ToroidalSurface)& S)
541 {
542   gp_Ax3 A;
543   Standard_Real R1=0.,R2=0.;
544   IS >> A;
545   BinTools::GetReal(IS, R1);
546   BinTools::GetReal(IS, R2);
547   S = new Geom_ToroidalSurface(A,R1,R2);
548   return IS;
549 }
550
551 //=======================================================================
552 //function : operator>>
553 //purpose  : 
554 //=======================================================================
555
556 static Standard_IStream& operator>>(Standard_IStream& IS,
557                                     Handle(Geom_SurfaceOfLinearExtrusion)& S)
558 {
559   gp_Dir D(1.,0.,0.);
560   Handle(Geom_Curve) C;
561   IS >> D;
562   BinTools_CurveSet::ReadCurve(IS,C);
563   S = new Geom_SurfaceOfLinearExtrusion(C,D);
564   return IS;
565 }
566
567 //=======================================================================
568 //function : operator>>
569 //purpose  : 
570 //=======================================================================
571
572 static Standard_IStream& operator>>(Standard_IStream& IS,
573                                     Handle(Geom_SurfaceOfRevolution)& S)
574 {
575   gp_Pnt P(0.,0.,0.);
576   gp_Dir D(1.,0.,0.);
577   Handle(Geom_Curve) C;
578   IS >> P >> D;
579   BinTools_CurveSet::ReadCurve(IS, C);
580   S = new Geom_SurfaceOfRevolution(C,gp_Ax1(P,D));
581   return IS;
582 }
583
584 //=======================================================================
585 //function : operator>>
586 //purpose  : 
587 //=======================================================================
588
589 static Standard_IStream& operator>>(Standard_IStream& IS,
590                                     Handle(Geom_BezierSurface)& S)
591 {
592 //  std::cout << "BezierSurface:" <<std::endl;
593   Standard_Boolean urational=Standard_False, vrational=Standard_False;
594   BinTools::GetBool(IS, urational);
595   BinTools::GetBool(IS, vrational);
596
597 //  std::cout << "\turational = " << urational << " vrational = " << vrational<<std::endl;
598   Standard_Integer udegree=0, vdegree=0;
599   Standard_ExtCharacter aVal='\0';
600   BinTools::GetExtChar(IS, aVal);
601   
602   udegree = (Standard_Integer)aVal;
603   BinTools::GetExtChar(IS, aVal);
604   vdegree = (Standard_Integer)aVal;
605 //  std::cout << "\ttudegree  = " << udegree << ", vdegree = " << vdegree << std::endl;
606
607   TColgp_Array2OfPnt poles(1,udegree+1,1,vdegree+1);
608   TColStd_Array2OfReal weights(1,udegree+1,1,vdegree+1);
609   
610   Standard_Integer i,j;
611   for (i = 1; i <= udegree+1; i++) {
612     for (j = 1; j <= vdegree+1; j++) {
613       IS >> poles(i,j);//Pnt
614 //      std::cout <<"Pole X = " <<poles(i,j).X()<< " Y = " <<poles(i,j).Y()<< " Z = " << poles(i,j).Z()<<std::endl;
615       if (urational || vrational)
616         BinTools::GetReal(IS, weights(i,j));
617     }
618   }
619
620   if (urational || vrational)
621     S = new Geom_BezierSurface(poles,weights);
622   else
623     S = new Geom_BezierSurface(poles);
624   return IS;
625 }
626
627 //=======================================================================
628 //function : operator>>
629 //purpose  : 
630 //=======================================================================
631
632 static Standard_IStream& operator>>(Standard_IStream& IS,
633                                     Handle(Geom_BSplineSurface)& S)
634 {
635   Standard_Boolean urational=Standard_False, vrational=Standard_False,
636                    uperiodic=Standard_False, vperiodic=Standard_False;
637   BinTools::GetBool(IS, urational); 
638   BinTools::GetBool(IS, vrational); 
639   BinTools::GetBool(IS, uperiodic);
640   BinTools::GetBool(IS, vperiodic);
641
642   Standard_Integer udegree=0, vdegree=0,nbupoles=0,nbvpoles=0,nbuknots=0,nbvknots=0;
643   Standard_ExtCharacter aVal='\0';
644   BinTools::GetExtChar(IS, aVal);
645   udegree = (Standard_Integer)aVal;
646   BinTools::GetExtChar(IS, aVal);
647   vdegree = (Standard_Integer)aVal;
648   BinTools::GetInteger(IS, nbupoles);
649   BinTools::GetInteger(IS, nbvpoles);
650   BinTools::GetInteger(IS, nbuknots);
651   BinTools::GetInteger(IS, nbvknots);
652
653   TColgp_Array2OfPnt poles(1,nbupoles,1,nbvpoles);
654   TColStd_Array2OfReal weights(1,nbupoles,1,nbvpoles);
655   
656   Standard_Integer i,j;
657   for (i = 1; i <= nbupoles; i++) {
658     for (j = 1; j <= nbvpoles; j++) {
659       IS >> poles(i,j);//Pnt
660       if (urational || vrational)
661         BinTools::GetReal(IS, weights(i,j)); 
662     }
663   }
664
665   TColStd_Array1OfReal uknots(1,nbuknots);
666   TColStd_Array1OfInteger umults(1,nbuknots);
667   for (i = 1; i <= nbuknots; i++) {
668     BinTools::GetReal(IS, uknots(i));
669     BinTools::GetInteger(IS, umults(i));
670   }
671
672   TColStd_Array1OfReal vknots(1,nbvknots);
673   TColStd_Array1OfInteger vmults(1,nbvknots);
674   for (i = 1; i <= nbvknots; i++) {
675     BinTools::GetReal(IS, vknots(i));
676     BinTools::GetInteger(IS, vmults(i));
677   }
678
679   if (urational || vrational)
680     S = new Geom_BSplineSurface(poles,weights,uknots,vknots,umults,vmults,
681                                 udegree,vdegree,uperiodic,vperiodic);
682   else
683     S = new Geom_BSplineSurface(poles,uknots,vknots,umults,vmults,
684                                 udegree,vdegree,uperiodic,vperiodic);
685   return IS;
686 }
687
688 //=======================================================================
689 //function : operator>>
690 //purpose  : 
691 //=======================================================================
692
693 static Standard_IStream& operator>>(Standard_IStream& IS,
694                                     Handle(Geom_RectangularTrimmedSurface)& S)
695 {
696   Standard_Real U1=0.,U2=0.,V1=0.,V2=0.;
697   BinTools::GetReal(IS, U1);
698   BinTools::GetReal(IS, U2);
699   BinTools::GetReal(IS, V1);
700   BinTools::GetReal(IS, V2);
701   Handle(Geom_Surface) BS;
702   BinTools_SurfaceSet::ReadSurface(IS, BS);
703   S = new Geom_RectangularTrimmedSurface(BS,U1,U2,V1,V2);
704   return IS;
705 }
706
707 //=======================================================================
708 //function : operator>>
709 //purpose  : 
710 //=======================================================================
711
712 static Standard_IStream& operator>>(Standard_IStream& IS,
713                                     Handle(Geom_OffsetSurface)& S)
714 {
715   Standard_Real O=0.;
716   BinTools::GetReal(IS, O);
717   Handle(Geom_Surface) BS;
718   BinTools_SurfaceSet::ReadSurface(IS, BS);
719   S = new Geom_OffsetSurface(BS,O);
720   return IS;
721 }
722
723
724 //=======================================================================
725 //function : ReadSurface
726 //purpose  : 
727 //=======================================================================
728
729 Standard_IStream& BinTools_SurfaceSet::ReadSurface(Standard_IStream& IS,
730                                                     Handle(Geom_Surface)& S)
731 {
732   try {
733     OCC_CATCH_SIGNALS
734     const Standard_Byte stype = (Standard_Byte) IS.get();
735     switch (stype) {
736
737     case PLANE :
738       {
739         Handle(Geom_Plane) SS;
740         IS >> SS;
741         S = SS;
742       }
743       break;
744
745     case CYLINDER :
746       {
747         Handle(Geom_CylindricalSurface) SS;
748         IS >> SS;
749         S = SS;
750       }
751       break;
752
753     case CONE :
754       {
755         Handle(Geom_ConicalSurface) SS;
756         IS >> SS;
757         S = SS;
758       }
759       break;
760
761     case SPHERE :
762       {
763         Handle(Geom_SphericalSurface) SS;
764         IS >> SS;
765         S = SS;
766       }
767       break;
768
769     case TORUS :
770       {
771         Handle(Geom_ToroidalSurface) SS;
772         IS >> SS;
773         S = SS;
774       }
775       break;
776
777     case LINEAREXTRUSION :
778       {
779         Handle(Geom_SurfaceOfLinearExtrusion) SS;
780         IS >> SS;
781         S = SS;
782       }
783       break;
784
785     case REVOLUTION :
786       {
787         Handle(Geom_SurfaceOfRevolution) SS;
788         IS >> SS;
789         S = SS;
790       }
791       break;
792
793     case BEZIER :
794       {
795         Handle(Geom_BezierSurface) SS;
796         IS >> SS;
797         S = SS;
798       }
799       break;
800
801     case BSPLINE :
802       {
803         Handle(Geom_BSplineSurface) SS;
804         IS >> SS;
805         S = SS;
806       }
807       break;
808
809     case RECTANGULAR :
810       {
811         Handle(Geom_RectangularTrimmedSurface) SS;
812         IS >> SS;
813         S = SS;
814       }
815       break;
816
817     case OFFSET :
818       {
819         Handle(Geom_OffsetSurface) SS;
820         IS >> SS;
821         S = SS;
822       }
823       break;
824       
825     default :
826       {
827         S = NULL;
828         throw Standard_Failure("UNKNOWN SURFACE TYPE");
829       }
830       break;
831     }
832   }
833   catch(Standard_Failure const& anException) {
834     S = NULL;
835     Standard_SStream aMsg;
836     aMsg << "EXCEPTION in BinTools_SurfaceSet::ReadSurface(..)" << std::endl;
837     aMsg << anException << std::endl;
838     throw Standard_Failure(aMsg.str().c_str());
839   }
840   return IS;
841 }
842
843 //=======================================================================
844 //function : Read
845 //purpose  : 
846 //=======================================================================
847
848 void  BinTools_SurfaceSet::Read (Standard_IStream& IS,
849                                  const Message_ProgressRange& theRange)
850 {
851   char buffer[255];
852   IS >> buffer;
853   if (IS.fail() || strcmp(buffer,"Surfaces")) {
854     Standard_SStream aMsg;
855     aMsg << "BinTools_SurfaceSet::Read:  Not a surface table"<<std::endl;
856 #ifdef OCCT_DEBUG
857     std::cout <<"SurfaceSet buffer: " << buffer << std::endl;
858 #endif
859     throw Standard_Failure(aMsg.str().c_str());
860     return;
861   }
862
863   Handle(Geom_Surface) S;
864   Standard_Integer i, nbsurf;
865   IS >> nbsurf;
866   Message_ProgressScope aPS(theRange, "Reading surfaces", nbsurf);
867   IS.get ();//remove <lf>
868   for (i = 1; i <= nbsurf && aPS.More(); i++, aPS.Next()) {
869     BinTools_SurfaceSet::ReadSurface(IS,S);
870     myMap.Add(S);
871   }
872 }