0031353: TDocStd_Application does not have api to set progress indicator
[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_ProgressSentry.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 << (gp_Pnt)
116 //purpose  : 
117 //=======================================================================
118
119 static Standard_OStream& operator <<(Standard_OStream& OS, const gp_Pnt P)
120 {
121   BinTools::PutReal(OS, P.X());
122   BinTools::PutReal(OS, P.Y());
123   BinTools::PutReal(OS, P.Z());
124   return OS;
125 }
126
127 //=======================================================================
128 //function : operator << (gp_Dir)
129 //purpose  : 
130 //=======================================================================
131
132 static Standard_OStream& operator <<(Standard_OStream& OS, const gp_Dir D)
133 {
134   BinTools::PutReal(OS, D.X());
135   BinTools::PutReal(OS, D.Y());
136   BinTools::PutReal(OS, D.Z());
137   return OS;
138 }
139
140
141 //=======================================================================
142 //function : operator <<(Geom_Plane)
143 //purpose  : 
144 //=======================================================================
145
146 static Standard_OStream& operator <<(Standard_OStream& OS, const Handle(Geom_Plane)& S)
147 {
148   OS << (Standard_Byte)PLANE;
149   gp_Pln P = S->Pln();
150   OS << P.Location();//Pnt
151   OS << P.Axis().Direction();
152   OS << P.XAxis().Direction();
153   OS << P.YAxis().Direction();
154   return OS;
155 }
156
157
158 //=======================================================================
159 //function : operator <<(Geom_CylindricalSurface)
160 //purpose  : 
161 //=======================================================================
162
163 static Standard_OStream& operator <<(Standard_OStream& OS, const Handle(Geom_CylindricalSurface)& S)
164 {
165   OS << (Standard_Byte)CYLINDER;
166   gp_Cylinder P = S->Cylinder();
167   OS << P.Location();//Pnt
168   OS << P.Axis().Direction();
169   OS << P.XAxis().Direction();
170   OS << P.YAxis().Direction();
171   BinTools::PutReal(OS, P.Radius());
172   return OS;
173 }
174
175
176 //=======================================================================
177 //function : operator <<(Geom_ConicalSurface)
178 //purpose  : 
179 //=======================================================================
180
181 static Standard_OStream& operator <<(Standard_OStream& OS, const Handle(Geom_ConicalSurface)& S)
182 {
183   OS << (Standard_Byte)CONE;
184   gp_Cone P = S->Cone();
185   OS << P.Location();//Pnt
186   OS << P.Axis().Direction();
187   OS << P.XAxis().Direction();
188   OS << P.YAxis().Direction();
189   BinTools::PutReal(OS, P.RefRadius());
190   BinTools::PutReal(OS, P.SemiAngle());
191   return OS;
192 }
193
194
195 //=======================================================================
196 //function : operator <<(Geom_SphericalSurface)
197 //purpose  : 
198 //=======================================================================
199
200 static Standard_OStream& operator <<(Standard_OStream& OS, const Handle(Geom_SphericalSurface)& S)
201 {
202   OS << (Standard_Byte)SPHERE;
203   gp_Sphere P = S->Sphere();
204   OS << P.Location();//Pnt
205   OS << P.Position().Axis().Direction();
206   OS << P.XAxis().Direction();
207   OS << P.YAxis().Direction();
208   BinTools::PutReal(OS, P.Radius());
209   return OS;
210 }
211
212
213 //=======================================================================
214 //function : operator <<(Geom_ToroidalSurface)
215 //purpose  : 
216 //=======================================================================
217
218 static Standard_OStream& operator <<(Standard_OStream& OS, const Handle(Geom_ToroidalSurface)& S)
219 {
220   OS << (Standard_Byte)TORUS;
221   gp_Torus P = S->Torus();
222   OS << P.Location();//Pnt
223   OS << P.Axis().Direction();
224   OS << P.XAxis().Direction();
225   OS << P.YAxis().Direction();
226   BinTools::PutReal(OS, P.MajorRadius());
227   BinTools::PutReal(OS, P.MinorRadius());
228   return OS;
229 }
230
231
232 //=======================================================================
233 //function : operator <<(Geom_SurfaceOfLinearExtrusion)
234 //purpose  : 
235 //=======================================================================
236
237 static Standard_OStream& operator <<(Standard_OStream& OS, const Handle(Geom_SurfaceOfLinearExtrusion)& S)
238 {
239   OS << (Standard_Byte)LINEAREXTRUSION;
240   OS << S->Direction();
241   BinTools_CurveSet::WriteCurve(S->BasisCurve(),OS);
242   return OS;
243 }
244
245
246 //=======================================================================
247 //function : operator <<(Geom_SurfaceOfRevolution)
248 //purpose  : 
249 //=======================================================================
250
251 static Standard_OStream& operator <<(Standard_OStream& OS, const Handle(Geom_SurfaceOfRevolution)& S)
252 {
253   OS << (Standard_Byte)REVOLUTION;
254   OS << S->Location();
255   OS << S->Direction();
256   BinTools_CurveSet::WriteCurve(S->BasisCurve(),OS);
257   return OS;
258 }
259
260
261 //=======================================================================
262 //function : operator <<(Geom_BezierSurface)
263 //purpose  : 
264 //=======================================================================
265
266 static Standard_OStream& operator <<(Standard_OStream& OS, const Handle(Geom_BezierSurface)& S)
267 {
268   OS << (Standard_Byte)BEZIER;
269   Standard_Boolean urational = S->IsURational() ? 1:0;
270   Standard_Boolean vrational = S->IsVRational() ? 1:0;
271   BinTools::PutBool(OS, urational); //rational
272   BinTools::PutBool(OS, vrational);
273 //  std::cout << "Bezier Surface:"<< std::endl;
274 //  std::cout << "\turational = "<<urational<<" vrational = " <<vrational<<std::endl;
275
276 // poles and weights
277   Standard_Integer i,j,udegree,vdegree;
278   udegree = S->UDegree();
279   vdegree = S->VDegree();
280   BinTools::PutExtChar(OS, (Standard_ExtCharacter)udegree);
281   BinTools::PutExtChar(OS, (Standard_ExtCharacter)vdegree);
282   for (i = 1; i <= udegree+1; i++) {
283     for (j = 1; j <= vdegree+1; j++) {
284       OS << S->Pole(i,j); //Pnt
285       if (urational || vrational) {
286         BinTools::PutReal(OS, S->Weight(i,j));//Real
287       }
288     }
289   }
290   return OS;
291 }
292
293
294 //=======================================================================
295 //function : operator <<(Geom_BSplineSurface)
296 //purpose  : 
297 //=======================================================================
298
299 static Standard_OStream& operator <<(Standard_OStream& OS, const Handle(Geom_BSplineSurface)& S)
300 {
301   OS << (Standard_Byte)BSPLINE;
302   Standard_Boolean urational = S->IsURational() ? 1:0;
303   Standard_Boolean vrational = S->IsVRational() ? 1:0;
304   Standard_Boolean uperiodic = S->IsUPeriodic() ? 1:0;
305   Standard_Boolean vperiodic = S->IsVPeriodic() ? 1:0;
306   BinTools::PutBool(OS, urational); 
307   BinTools::PutBool(OS, vrational); 
308   BinTools::PutBool(OS, uperiodic); 
309   BinTools::PutBool(OS, vperiodic); 
310
311 // poles and weights
312   Standard_Integer i,j,udegree,vdegree,nbupoles,nbvpoles,nbuknots,nbvknots;
313   udegree  = S->UDegree();
314   vdegree  = S->VDegree();
315   nbupoles = S->NbUPoles();
316   nbvpoles = S->NbVPoles();
317   nbuknots = S->NbUKnots();
318   nbvknots = S->NbVKnots();
319   BinTools::PutExtChar(OS, (Standard_ExtCharacter) udegree);
320   BinTools::PutExtChar(OS, (Standard_ExtCharacter) vdegree);
321   BinTools::PutInteger(OS, nbupoles);
322   BinTools::PutInteger(OS, nbvpoles);
323   BinTools::PutInteger(OS, nbuknots);
324   BinTools::PutInteger(OS, nbvknots);
325   for (i = 1; i <= nbupoles; i++) {
326     for (j = 1; j <= nbvpoles; j++) {
327       OS << S->Pole(i,j); //Pnt
328       if (urational || vrational)
329         BinTools::PutReal(OS, S->Weight(i,j));//Real    
330     }
331   }
332
333   for (i = 1; i <= nbuknots; i++) {
334     BinTools::PutReal(OS,S->UKnot(i));
335     BinTools::PutInteger(OS, S->UMultiplicity(i));
336   }
337
338   for (i = 1; i <= nbvknots; i++) {
339     BinTools::PutReal(OS,S->VKnot(i));
340     BinTools::PutInteger(OS, S->VMultiplicity(i));
341   }
342   return OS;
343 }
344
345
346 //=======================================================================
347 //function :  operator <<(Geom_RectangularTrimmedSurface)
348 //purpose  : 
349 //=======================================================================
350
351 static Standard_OStream& operator <<(Standard_OStream& OS, const Handle(Geom_RectangularTrimmedSurface)& S)
352 {
353   OS << (Standard_Byte)RECTANGULAR;
354   Standard_Real U1,U2,V1,V2;
355   S->Bounds(U1,U2,V1,V2);
356   BinTools::PutReal(OS, U1);
357   BinTools::PutReal(OS, U2);
358   BinTools::PutReal(OS, V1);
359   BinTools::PutReal(OS, V2);
360   BinTools_SurfaceSet::WriteSurface(S->BasisSurface(),OS);
361   return OS;
362 }
363
364
365 //=======================================================================
366 //function : operator <<(Geom_OffsetSurface)
367 //purpose  : 
368 //=======================================================================
369
370 static Standard_OStream& operator <<(Standard_OStream& OS, const Handle(Geom_OffsetSurface)& S)
371 {
372   OS << (Standard_Byte)OFFSET;
373   BinTools::PutReal(OS, S->Offset());
374   BinTools_SurfaceSet::WriteSurface(S->BasisSurface(),OS);
375   return OS;
376 }
377
378
379 //=======================================================================
380 //function : WriteSurface
381 //purpose  : 
382 //=======================================================================
383
384 void BinTools_SurfaceSet::WriteSurface(const Handle(Geom_Surface)& S,
385                                         Standard_OStream& OS)
386 {
387   Handle(Standard_Type) TheType = S->DynamicType();
388   try {
389     OCC_CATCH_SIGNALS
390     if ( TheType ==  STANDARD_TYPE(Geom_Plane)) {
391       OS << Handle(Geom_Plane)::DownCast(S);
392     }
393     else if ( TheType ==  STANDARD_TYPE(Geom_CylindricalSurface)) {
394       OS << Handle(Geom_CylindricalSurface)::DownCast(S);
395     }
396     else if ( TheType ==  STANDARD_TYPE(Geom_ConicalSurface)) {
397       OS << Handle(Geom_ConicalSurface)::DownCast(S);
398     }
399     else if ( TheType ==  STANDARD_TYPE(Geom_SphericalSurface)) {
400       OS << Handle(Geom_SphericalSurface)::DownCast(S);
401     }
402     else if ( TheType ==  STANDARD_TYPE(Geom_ToroidalSurface)) {
403       OS << Handle(Geom_ToroidalSurface)::DownCast(S);
404     }
405     else if ( TheType ==  STANDARD_TYPE(Geom_SurfaceOfLinearExtrusion)) {
406       OS << Handle(Geom_SurfaceOfLinearExtrusion)::DownCast(S);
407     }
408     else if ( TheType ==  STANDARD_TYPE(Geom_SurfaceOfRevolution)) {
409       OS << Handle(Geom_SurfaceOfRevolution)::DownCast(S);
410     }
411     else if ( TheType ==  STANDARD_TYPE(Geom_BezierSurface)) {
412       OS << Handle(Geom_BezierSurface)::DownCast(S);
413     }
414     else if ( TheType ==  STANDARD_TYPE(Geom_BSplineSurface)) {
415       OS << Handle(Geom_BSplineSurface)::DownCast(S);
416     }
417     else if ( TheType ==  STANDARD_TYPE(Geom_RectangularTrimmedSurface)) {
418       OS << Handle(Geom_RectangularTrimmedSurface)::DownCast(S);
419     }
420     else if ( TheType ==  STANDARD_TYPE(Geom_OffsetSurface)) {
421       OS << Handle(Geom_OffsetSurface)::DownCast(S);
422     }
423     else {
424       throw Standard_Failure("UNKNOWN SURFACE TYPE");
425     }
426   }
427    catch(Standard_Failure const& anException) {
428      Standard_SStream aMsg;
429     aMsg << "EXCEPTION in BinTools_SurfaceSet::WriteSurface(..)" << std::endl;
430     aMsg << anException << std::endl;
431     throw Standard_Failure(aMsg.str().c_str());
432   }  
433 }
434
435 //=======================================================================
436 //function : Write
437 //purpose  : 
438 //=======================================================================
439
440 void  BinTools_SurfaceSet::Write (Standard_OStream& OS,
441                                   const Handle(Message_ProgressIndicator)& theProgress)const
442 {
443
444   Standard_Integer i, nbsurf = myMap.Extent();
445   Message_ProgressSentry aPS(theProgress, "Writing surfases", 0, nbsurf, 1);
446   OS << "Surfaces "<< nbsurf << "\n";
447   for (i = 1; i <= nbsurf && aPS.More(); i++, aPS.Next()) {
448     WriteSurface(Handle(Geom_Surface)::DownCast(myMap(i)),OS);
449   }
450
451 }
452
453
454 //=======================================================================
455 //function : ReadPnt
456 //purpose  : 
457 //=======================================================================
458
459 static Standard_IStream& operator>>(Standard_IStream& IS, gp_Pnt& P)
460 {
461   Standard_Real X=0.,Y=0.,Z=0.;
462   BinTools::GetReal(IS, X);
463   BinTools::GetReal(IS, Y);
464   BinTools::GetReal(IS, Z);
465   P.SetCoord(X,Y,Z);
466   return IS;
467 }
468
469 //=======================================================================
470 //function : ReadDir
471 //purpose  : 
472 //=======================================================================
473
474 static Standard_IStream& operator>>(Standard_IStream& IS, gp_Dir& D)
475 {
476   Standard_Real X=0.,Y=0.,Z=0.;
477   BinTools::GetReal(IS, X);
478   BinTools::GetReal(IS, Y);
479   BinTools::GetReal(IS, Z);
480   D.SetCoord(X,Y,Z);
481   return IS;
482 }
483
484 //=======================================================================
485 //function : ReadAx3
486 //purpose  : 
487 //=======================================================================
488
489 static Standard_IStream& operator>>(Standard_IStream& IS, gp_Ax3& A3)
490 {
491   gp_Pnt P(0.,0.,0.);
492   gp_Dir A(1.,0.,0.),AX(1.,0.,0.),AY(1.,0.,0.);
493   IS >> P >> A >> AX >> AY;
494   gp_Ax3 ax3(P,A,AX);
495   if (AY.DotCross(A,AX) < 0)
496     ax3.YReverse();
497   A3 = ax3;
498   return IS;
499 }
500
501
502 //=======================================================================
503 //function : operator>>
504 //purpose  : 
505 //=======================================================================
506
507 static Standard_IStream& operator>>(Standard_IStream& IS,
508                                     Handle(Geom_Plane)& S)
509 {
510   gp_Ax3 A;
511   IS >> A;
512   S = new Geom_Plane(A);
513   return IS;
514 }
515
516 //=======================================================================
517 //function : operator>>
518 //purpose  : 
519 //=======================================================================
520
521 static Standard_IStream& operator>>(Standard_IStream& IS,
522                                     Handle(Geom_CylindricalSurface)& S)
523 {
524   gp_Ax3 A;
525   Standard_Real R=0.;
526   IS >> A;
527   BinTools::GetReal(IS, R);
528   S = new Geom_CylindricalSurface(A,R);
529   return IS;
530 }
531
532 //=======================================================================
533 //function : operator>>
534 //purpose  : 
535 //=======================================================================
536
537 static Standard_IStream& operator>>(Standard_IStream& IS,
538                                     Handle(Geom_ConicalSurface)& S)
539 {
540   gp_Ax3 A;
541   Standard_Real R=0.,Ang=0.;
542   IS >> A;
543   BinTools::GetReal(IS, R);
544   BinTools::GetReal(IS, Ang);
545   S = new Geom_ConicalSurface(A,Ang,R);
546   return IS;
547 }
548
549 //=======================================================================
550 //function : operator>>
551 //purpose  : 
552 //=======================================================================
553
554 static Standard_IStream& operator>>(Standard_IStream& IS,
555                                     Handle(Geom_SphericalSurface)& S)
556 {
557   gp_Ax3 A;
558   Standard_Real R=0.;
559   IS >> A;
560   BinTools::GetReal(IS, R);
561   S = new Geom_SphericalSurface(A,R);
562   return IS;
563 }
564
565 //=======================================================================
566 //function : operator>>
567 //purpose  : 
568 //=======================================================================
569
570 static Standard_IStream& operator>>(Standard_IStream& IS,
571                                     Handle(Geom_ToroidalSurface)& S)
572 {
573   gp_Ax3 A;
574   Standard_Real R1=0.,R2=0.;
575   IS >> A;
576   BinTools::GetReal(IS, R1);
577   BinTools::GetReal(IS, R2);
578   S = new Geom_ToroidalSurface(A,R1,R2);
579   return IS;
580 }
581
582 //=======================================================================
583 //function : operator>>
584 //purpose  : 
585 //=======================================================================
586
587 static Standard_IStream& operator>>(Standard_IStream& IS,
588                                     Handle(Geom_SurfaceOfLinearExtrusion)& S)
589 {
590   gp_Dir D(1.,0.,0.);
591   Handle(Geom_Curve) C;
592   IS >> D;
593   BinTools_CurveSet::ReadCurve(IS,C);
594   S = new Geom_SurfaceOfLinearExtrusion(C,D);
595   return IS;
596 }
597
598 //=======================================================================
599 //function : operator>>
600 //purpose  : 
601 //=======================================================================
602
603 static Standard_IStream& operator>>(Standard_IStream& IS,
604                                     Handle(Geom_SurfaceOfRevolution)& S)
605 {
606   gp_Pnt P(0.,0.,0.);
607   gp_Dir D(1.,0.,0.);
608   Handle(Geom_Curve) C;
609   IS >> P >> D;
610   BinTools_CurveSet::ReadCurve(IS, C);
611   S = new Geom_SurfaceOfRevolution(C,gp_Ax1(P,D));
612   return IS;
613 }
614
615 //=======================================================================
616 //function : operator>>
617 //purpose  : 
618 //=======================================================================
619
620 static Standard_IStream& operator>>(Standard_IStream& IS,
621                                     Handle(Geom_BezierSurface)& S)
622 {
623 //  std::cout << "BezierSurface:" <<std::endl;
624   Standard_Boolean urational=Standard_False, vrational=Standard_False;
625   BinTools::GetBool(IS, urational);
626   BinTools::GetBool(IS, vrational);
627
628 //  std::cout << "\turational = " << urational << " vrational = " << vrational<<std::endl;
629   Standard_Integer udegree=0, vdegree=0;
630   Standard_ExtCharacter aVal='\0';
631   BinTools::GetExtChar(IS, aVal);
632   
633   udegree = (Standard_Integer)aVal;
634   BinTools::GetExtChar(IS, aVal);
635   vdegree = (Standard_Integer)aVal;
636 //  std::cout << "\ttudegree  = " << udegree << ", vdegree = " << vdegree << std::endl;
637
638   TColgp_Array2OfPnt poles(1,udegree+1,1,vdegree+1);
639   TColStd_Array2OfReal weights(1,udegree+1,1,vdegree+1);
640   
641   Standard_Integer i,j;
642   for (i = 1; i <= udegree+1; i++) {
643     for (j = 1; j <= vdegree+1; j++) {
644       IS >> poles(i,j);//Pnt
645 //      std::cout <<"Pole X = " <<poles(i,j).X()<< " Y = " <<poles(i,j).Y()<< " Z = " << poles(i,j).Z()<<std::endl;
646       if (urational || vrational)
647         BinTools::GetReal(IS, weights(i,j));
648     }
649   }
650
651   if (urational || vrational)
652     S = new Geom_BezierSurface(poles,weights);
653   else
654     S = new Geom_BezierSurface(poles);
655   return IS;
656 }
657
658 //=======================================================================
659 //function : operator>>
660 //purpose  : 
661 //=======================================================================
662
663 static Standard_IStream& operator>>(Standard_IStream& IS,
664                                     Handle(Geom_BSplineSurface)& S)
665 {
666   Standard_Boolean urational=Standard_False, vrational=Standard_False,
667                    uperiodic=Standard_False, vperiodic=Standard_False;
668   BinTools::GetBool(IS, urational); 
669   BinTools::GetBool(IS, vrational); 
670   BinTools::GetBool(IS, uperiodic);
671   BinTools::GetBool(IS, vperiodic);
672
673   Standard_Integer udegree=0, vdegree=0,nbupoles=0,nbvpoles=0,nbuknots=0,nbvknots=0;
674   Standard_ExtCharacter aVal='\0';
675   BinTools::GetExtChar(IS, aVal);
676   udegree = (Standard_Integer)aVal;
677   BinTools::GetExtChar(IS, aVal);
678   vdegree = (Standard_Integer)aVal;
679   BinTools::GetInteger(IS, nbupoles);
680   BinTools::GetInteger(IS, nbvpoles);
681   BinTools::GetInteger(IS, nbuknots);
682   BinTools::GetInteger(IS, nbvknots);
683
684   TColgp_Array2OfPnt poles(1,nbupoles,1,nbvpoles);
685   TColStd_Array2OfReal weights(1,nbupoles,1,nbvpoles);
686   
687   Standard_Integer i,j;
688   for (i = 1; i <= nbupoles; i++) {
689     for (j = 1; j <= nbvpoles; j++) {
690       IS >> poles(i,j);//Pnt
691       if (urational || vrational)
692         BinTools::GetReal(IS, weights(i,j)); 
693     }
694   }
695
696   TColStd_Array1OfReal uknots(1,nbuknots);
697   TColStd_Array1OfInteger umults(1,nbuknots);
698   for (i = 1; i <= nbuknots; i++) {
699     BinTools::GetReal(IS, uknots(i));
700     BinTools::GetInteger(IS, umults(i));
701   }
702
703   TColStd_Array1OfReal vknots(1,nbvknots);
704   TColStd_Array1OfInteger vmults(1,nbvknots);
705   for (i = 1; i <= nbvknots; i++) {
706     BinTools::GetReal(IS, vknots(i));
707     BinTools::GetInteger(IS, vmults(i));
708   }
709
710   if (urational || vrational)
711     S = new Geom_BSplineSurface(poles,weights,uknots,vknots,umults,vmults,
712                                 udegree,vdegree,uperiodic,vperiodic);
713   else
714     S = new Geom_BSplineSurface(poles,uknots,vknots,umults,vmults,
715                                 udegree,vdegree,uperiodic,vperiodic);
716   return IS;
717 }
718
719 //=======================================================================
720 //function : operator>>
721 //purpose  : 
722 //=======================================================================
723
724 static Standard_IStream& operator>>(Standard_IStream& IS,
725                                     Handle(Geom_RectangularTrimmedSurface)& S)
726 {
727   Standard_Real U1=0.,U2=0.,V1=0.,V2=0.;
728   BinTools::GetReal(IS, U1);
729   BinTools::GetReal(IS, U2);
730   BinTools::GetReal(IS, V1);
731   BinTools::GetReal(IS, V2);
732   Handle(Geom_Surface) BS;
733   BinTools_SurfaceSet::ReadSurface(IS, BS);
734   S = new Geom_RectangularTrimmedSurface(BS,U1,U2,V1,V2);
735   return IS;
736 }
737
738 //=======================================================================
739 //function : operator>>
740 //purpose  : 
741 //=======================================================================
742
743 static Standard_IStream& operator>>(Standard_IStream& IS,
744                                     Handle(Geom_OffsetSurface)& S)
745 {
746   Standard_Real O=0.;
747   BinTools::GetReal(IS, O);
748   Handle(Geom_Surface) BS;
749   BinTools_SurfaceSet::ReadSurface(IS, BS);
750   S = new Geom_OffsetSurface(BS,O);
751   return IS;
752 }
753
754
755 //=======================================================================
756 //function : ReadSurface
757 //purpose  : 
758 //=======================================================================
759
760 Standard_IStream& BinTools_SurfaceSet::ReadSurface(Standard_IStream& IS,
761                                                     Handle(Geom_Surface)& S)
762 {
763   try {
764     OCC_CATCH_SIGNALS
765     const Standard_Byte stype = (Standard_Byte) IS.get();
766     switch (stype) {
767
768     case PLANE :
769       {
770         Handle(Geom_Plane) SS;
771         IS >> SS;
772         S = SS;
773       }
774       break;
775
776     case CYLINDER :
777       {
778         Handle(Geom_CylindricalSurface) SS;
779         IS >> SS;
780         S = SS;
781       }
782       break;
783
784     case CONE :
785       {
786         Handle(Geom_ConicalSurface) SS;
787         IS >> SS;
788         S = SS;
789       }
790       break;
791
792     case SPHERE :
793       {
794         Handle(Geom_SphericalSurface) SS;
795         IS >> SS;
796         S = SS;
797       }
798       break;
799
800     case TORUS :
801       {
802         Handle(Geom_ToroidalSurface) SS;
803         IS >> SS;
804         S = SS;
805       }
806       break;
807
808     case LINEAREXTRUSION :
809       {
810         Handle(Geom_SurfaceOfLinearExtrusion) SS;
811         IS >> SS;
812         S = SS;
813       }
814       break;
815
816     case REVOLUTION :
817       {
818         Handle(Geom_SurfaceOfRevolution) SS;
819         IS >> SS;
820         S = SS;
821       }
822       break;
823
824     case BEZIER :
825       {
826         Handle(Geom_BezierSurface) SS;
827         IS >> SS;
828         S = SS;
829       }
830       break;
831
832     case BSPLINE :
833       {
834         Handle(Geom_BSplineSurface) SS;
835         IS >> SS;
836         S = SS;
837       }
838       break;
839
840     case RECTANGULAR :
841       {
842         Handle(Geom_RectangularTrimmedSurface) SS;
843         IS >> SS;
844         S = SS;
845       }
846       break;
847
848     case OFFSET :
849       {
850         Handle(Geom_OffsetSurface) SS;
851         IS >> SS;
852         S = SS;
853       }
854       break;
855       
856     default :
857       {
858         S = NULL;
859         throw Standard_Failure("UNKNOWN SURFACE TYPE");
860       }
861       break;
862     }
863   }
864   catch(Standard_Failure const& anException) {
865     S = NULL;
866     Standard_SStream aMsg;
867     aMsg << "EXCEPTION in BinTools_SurfaceSet::ReadSurface(..)" << std::endl;
868     aMsg << anException << std::endl;
869     throw Standard_Failure(aMsg.str().c_str());
870   }
871   return IS;
872 }
873
874 //=======================================================================
875 //function : Read
876 //purpose  : 
877 //=======================================================================
878
879 void  BinTools_SurfaceSet::Read (Standard_IStream& IS,
880                                  const Handle(Message_ProgressIndicator)& theProgress)
881 {
882   char buffer[255];
883   IS >> buffer;
884   if (IS.fail() || strcmp(buffer,"Surfaces")) {
885     Standard_SStream aMsg;
886     aMsg << "BinTools_SurfaceSet::Read:  Not a surface table"<<std::endl;
887 #ifdef OCCT_DEBUG
888     std::cout <<"SurfaceSet buffer: " << buffer << std::endl;
889 #endif
890     throw Standard_Failure(aMsg.str().c_str());
891     return;
892   }
893
894   Handle(Geom_Surface) S;
895   Standard_Integer i, nbsurf;
896   IS >> nbsurf;
897   Message_ProgressSentry aPS(theProgress, "Reading surfaces", 0, nbsurf, 1);
898   IS.get ();//remove <lf>
899   for (i = 1; i <= nbsurf && aPS.More(); i++, aPS.Next()) {
900     BinTools_SurfaceSet::ReadSurface(IS,S);
901     myMap.Add(S);
902   }
903 }