0031687: Draw Harness, ViewerTest - extend command vrenderparams with option updating...
[occt.git] / src / BinTools / BinTools_Curve2dSet.cxx
1 // Created on: 2004-05-18
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_Curve2dSet.hxx>
19 #include <Geom2d_BezierCurve.hxx>
20 #include <Geom2d_BSplineCurve.hxx>
21 #include <Geom2d_Circle.hxx>
22 #include <Geom2d_Curve.hxx>
23 #include <Geom2d_Ellipse.hxx>
24 #include <Geom2d_Hyperbola.hxx>
25 #include <Geom2d_Line.hxx>
26 #include <Geom2d_OffsetCurve.hxx>
27 #include <Geom2d_Parabola.hxx>
28 #include <Geom2d_TrimmedCurve.hxx>
29 #include <gp_Circ2d.hxx>
30 #include <gp_Elips2d.hxx>
31 #include <gp_Hypr2d.hxx>
32 #include <gp_Lin2d.hxx>
33 #include <gp_Parab2d.hxx>
34 #include <Standard_ErrorHandler.hxx>
35 #include <Standard_Failure.hxx>
36 #include <Standard_OutOfRange.hxx>
37 #include <Standard_Stream.hxx>
38 #include <TColgp_Array1OfPnt2d.hxx>
39 #include <TColStd_Array1OfInteger.hxx>
40 #include <TColStd_Array1OfReal.hxx>
41 #include <Message_ProgressSentry.hxx>
42
43 #define LINE      1
44 #define CIRCLE    2
45 #define ELLIPSE   3
46 #define PARABOLA  4
47 #define HYPERBOLA 5
48 #define BEZIER    6
49 #define BSPLINE   7
50 #define TRIMMED   8
51 #define OFFSET    9
52
53 //=======================================================================
54 //function : BinTools_Curve2dSet
55 //purpose  : 
56 //=======================================================================
57
58 BinTools_Curve2dSet::BinTools_Curve2dSet() 
59 {
60 }
61
62
63 //=======================================================================
64 //function : Clear
65 //purpose  : 
66 //=======================================================================
67
68 void  BinTools_Curve2dSet::Clear()
69 {
70   myMap.Clear();
71 }
72
73
74 //=======================================================================
75 //function : Add
76 //purpose  : 
77 //=======================================================================
78
79 Standard_Integer  BinTools_Curve2dSet::Add(const Handle(Geom2d_Curve)& S)
80 {
81   return myMap.Add(S);
82 }
83
84
85 //=======================================================================
86 //function : Curve2d
87 //purpose  : 
88 //=======================================================================
89
90 Handle(Geom2d_Curve)  BinTools_Curve2dSet::Curve2d
91        (const Standard_Integer I)const 
92 {
93   return  Handle(Geom2d_Curve)::DownCast(myMap(I));
94 }
95
96
97 //=======================================================================
98 //function : Index
99 //purpose  : 
100 //=======================================================================
101
102 Standard_Integer  BinTools_Curve2dSet::Index
103   (const Handle(Geom2d_Curve)& S)const 
104 {
105   return myMap.FindIndex(S);
106 }
107
108 //=======================================================================
109 //function : operator << (gp_Pnt2d)
110 //purpose  : 
111 //=======================================================================
112
113 static Standard_OStream& operator <<(Standard_OStream& OS, const gp_Pnt2d P)
114                   
115 {
116   BinTools::PutReal(OS, P.X());
117   return BinTools::PutReal(OS, P.Y());
118 }
119
120 //=======================================================================
121 //function : operator << (gp_Dir2d D)
122 //purpose  : 
123 //=======================================================================
124
125 static Standard_OStream& operator <<(Standard_OStream& OS, const gp_Dir2d D)
126 {
127   BinTools::PutReal(OS, D.X());
128   return BinTools::PutReal(OS, D.Y());
129 }
130
131 //=======================================================================
132 //function : operator << ((Geom2d_Line)& L)
133 //purpose  : 
134 //=======================================================================
135
136 static Standard_OStream& operator <<(Standard_OStream& OS, const Handle(Geom2d_Line)& L)
137 {
138
139   OS << (Standard_Byte)LINE;
140   gp_Lin2d C2d = L->Lin2d();
141   OS << C2d.Location();//Pnt2d
142   OS << C2d.Direction();//Dir2d
143   return OS;
144 }
145
146 //=======================================================================
147 //function : operator << ((Geom2d_Circle)& C)
148 //purpose  : 
149 //=======================================================================
150
151 static Standard_OStream& operator <<(Standard_OStream& OS, const Handle(Geom2d_Circle)& C)
152 {
153   OS << (Standard_Byte)CIRCLE;
154   gp_Circ2d C2d = C->Circ2d();
155   OS << C2d.Location();
156   OS << C2d.XAxis().Direction();
157   OS << C2d.YAxis().Direction();
158   BinTools::PutReal(OS, C2d.Radius());
159   return OS;
160 }
161
162 //=======================================================================
163 //function : operator <<(Geom2d_Ellipse)
164 //purpose  : 
165 //=======================================================================
166
167 static Standard_OStream& operator <<(Standard_OStream& OS, const Handle(Geom2d_Ellipse)& E)
168 {
169   OS << (Standard_Byte)ELLIPSE;
170   gp_Elips2d C2d = E->Elips2d();
171   OS << C2d.Location();
172   OS << C2d.XAxis().Direction();
173   OS << C2d.YAxis().Direction();
174   BinTools::PutReal(OS, C2d.MajorRadius());
175   BinTools::PutReal(OS, C2d.MinorRadius());
176   return OS;
177 }
178
179 //=======================================================================
180 //function :  operator << (Geom2d_Parabola)
181 //purpose  : 
182 //=======================================================================
183
184 static Standard_OStream& operator <<(Standard_OStream& OS, const Handle(Geom2d_Parabola)& P)
185 {
186   OS << (Standard_Byte)PARABOLA;
187   gp_Parab2d C2d = P->Parab2d();
188   OS << C2d.Location();//Loc
189   OS << C2d.Axis().XAxis().Direction();//XDir
190   OS << C2d.Axis().YAxis().Direction();//YDir
191   BinTools::PutReal(OS, C2d.Focal());//Focal
192   return OS;
193 }
194
195 //=======================================================================
196 //function : operator <<(Geom2d_Hyperbola)
197 //purpose  : 
198 //=======================================================================
199
200 static Standard_OStream& operator <<(Standard_OStream& OS, const Handle(Geom2d_Hyperbola)& H)
201 {
202   OS << (Standard_Byte)HYPERBOLA;
203   gp_Hypr2d C2d = H->Hypr2d();
204   OS << C2d.Location(); //Loc
205   OS << C2d.XAxis().Direction();//XDir
206   OS << C2d.YAxis().Direction();//YDir
207   BinTools::PutReal(OS, C2d.MajorRadius());//MajR
208   BinTools::PutReal(OS, C2d.MinorRadius());
209   return OS;
210 }
211
212 //=======================================================================
213 //function : operator <<(Geom2d_BezierCurve)
214 //purpose  : 
215 //=======================================================================
216
217 static Standard_OStream& operator <<(Standard_OStream& OS, const Handle(Geom2d_BezierCurve)& B)
218 {
219   OS << (Standard_Byte)BEZIER;
220   Standard_Boolean aRational = B->IsRational() ? 1:0;
221   BinTools::PutBool(OS, aRational); //rational
222   // poles and weights
223   Standard_Integer i,aDegree = B->Degree(); 
224   BinTools::PutExtChar(OS, (Standard_ExtCharacter)aDegree); //Degree
225   for (i = 1; i <= aDegree+1; i++) {
226     OS << B->Pole(i); //Pnt2d
227     if (aRational)
228       BinTools::PutReal(OS, B->Weight(i));//Real
229   }
230   return OS;
231 }
232
233 //=======================================================================
234 //function : operator <<(Geom2d_BSplineCurve)
235 //purpose  : 
236 //=======================================================================
237
238 static Standard_OStream& operator <<(Standard_OStream& OS, const Handle(Geom2d_BSplineCurve)& B)
239 {
240   OS << (Standard_Byte)BSPLINE;
241   Standard_Boolean aRational = B->IsRational() ? 1:0;
242   BinTools::PutBool(OS, aRational); //rational
243   Standard_Boolean aPeriodic = B->IsPeriodic() ? 1:0;
244   BinTools::PutBool(OS, aPeriodic); //periodic
245   // poles and weights
246   Standard_Integer i,aDegree,aNbPoles,aNbKnots;
247   aDegree = B->Degree();
248   aNbPoles = B->NbPoles();
249   aNbKnots = B->NbKnots();
250   BinTools::PutExtChar(OS, (Standard_ExtCharacter) aDegree);
251   BinTools::PutInteger(OS,  aNbPoles);
252   BinTools::PutInteger(OS,  aNbKnots);
253   for (i = 1; i <= aNbPoles; i++) {
254     OS << B->Pole(i); // Pnt2d
255     if (aRational)
256       BinTools::PutReal(OS, B->Weight(i));
257   }
258
259   for (i = 1; i <= aNbKnots; i++) {
260     BinTools::PutReal(OS, B->Knot(i));
261     BinTools::PutInteger(OS, B->Multiplicity(i));
262   }
263
264   return OS;
265 }
266
267 //=======================================================================
268 //function : operator <<(Geom2d_TrimmedCurve)
269 //purpose  : 
270 //=======================================================================
271
272 static Standard_OStream& operator <<(Standard_OStream& OS, const Handle(Geom2d_TrimmedCurve)& C)
273 {
274   OS << (Standard_Byte)TRIMMED;
275   BinTools::PutReal(OS, C->FirstParameter()); 
276   BinTools::PutReal(OS, C->LastParameter());
277   BinTools_Curve2dSet::WriteCurve2d(C->BasisCurve(),OS);
278   return OS;
279 }
280
281 //=======================================================================
282 //function : operator <<(Geom2d_OffsetCurve)
283 //purpose  : 
284 //=======================================================================
285
286 static Standard_OStream& operator <<(Standard_OStream& OS, const Handle(Geom2d_OffsetCurve)& C)
287 {
288   OS << (Standard_Byte)OFFSET;
289   BinTools::PutReal(OS,C->Offset());//Offset 
290   BinTools_Curve2dSet::WriteCurve2d(C->BasisCurve(),OS);
291   return OS;  
292 }
293
294 //=======================================================================
295 //function : WriteCurve2d
296 //purpose  : 
297 //=======================================================================
298
299 void BinTools_Curve2dSet::WriteCurve2d(const Handle(Geom2d_Curve)& C,
300                                         Standard_OStream& OS)
301 {
302   Handle(Standard_Type) TheType = C->DynamicType();
303   try {
304     OCC_CATCH_SIGNALS
305     if ( TheType ==  STANDARD_TYPE(Geom2d_Circle)) {
306       OS << Handle(Geom2d_Circle)::DownCast(C);
307     }
308     else if ( TheType ==STANDARD_TYPE(Geom2d_Line)) {
309       OS << Handle(Geom2d_Line)::DownCast(C);
310     }
311     else if ( TheType == STANDARD_TYPE(Geom2d_Ellipse)) {
312       OS << Handle(Geom2d_Ellipse)::DownCast(C);
313     }
314     else if ( TheType == STANDARD_TYPE(Geom2d_Parabola)) {
315       OS << Handle(Geom2d_Parabola)::DownCast(C);
316     }
317     else if ( TheType == STANDARD_TYPE(Geom2d_Hyperbola)) {
318       OS << Handle(Geom2d_Hyperbola)::DownCast(C);
319     }
320     else if ( TheType == STANDARD_TYPE(Geom2d_BezierCurve)) {
321       OS << Handle(Geom2d_BezierCurve)::DownCast(C);
322     }
323     else if ( TheType == STANDARD_TYPE(Geom2d_BSplineCurve)) {
324       OS << Handle(Geom2d_BSplineCurve)::DownCast(C);
325     }
326     else if ( TheType == STANDARD_TYPE(Geom2d_TrimmedCurve)) {
327       OS << Handle(Geom2d_TrimmedCurve)::DownCast(C);
328     }
329     else if ( TheType == STANDARD_TYPE(Geom2d_OffsetCurve)) {
330       OS << Handle(Geom2d_OffsetCurve)::DownCast(C);
331     }
332     else {
333       throw Standard_Failure("UNKNOWN CURVE2d TYPE");
334     }
335   }
336   catch(Standard_Failure const& anException) {
337     Standard_SStream aMsg;
338     aMsg << "EXCEPTION in BinTools_Curve2dSet::WriteCurve2d(..)" << std::endl;
339     aMsg << anException << std::endl;
340     throw Standard_Failure(aMsg.str().c_str());
341   }  
342 }
343
344 //=======================================================================
345 //function : Write
346 //purpose  : 
347 //=======================================================================
348
349 void  BinTools_Curve2dSet::Write (Standard_OStream& OS,
350                                   const Handle(Message_ProgressIndicator)& theProgress)const
351 {
352   Standard_Integer i, aNbCurves = myMap.Extent();
353   Message_ProgressSentry aPS(theProgress, "Writing 2D curves", 0, aNbCurves, 1);
354   OS << "Curve2ds "<< aNbCurves << "\n";
355   for (i = 1; i <= aNbCurves && aPS.More(); i++, aPS.Next()) {
356     WriteCurve2d(Handle(Geom2d_Curve)::DownCast(myMap(i)),OS);
357   }
358 }
359
360
361 //=======================================================================
362 //function : ReadPnt2d
363 //purpose  : 
364 //=======================================================================
365
366 static Standard_IStream& operator>>(Standard_IStream& IS, gp_Pnt2d& P)
367 {
368   Standard_Real X=0.,Y=0.;
369   BinTools::GetReal(IS, X);
370   BinTools::GetReal(IS, Y);
371   P.SetCoord(X,Y);
372   return IS;
373 }
374
375 //=======================================================================
376 //function : ReadDir2d
377 //purpose  : 
378 //=======================================================================
379
380 static Standard_IStream& operator>>(Standard_IStream& IS, gp_Dir2d& D)
381 {
382   Standard_Real X=0.,Y=0.;
383   BinTools::GetReal(IS, X);
384   BinTools::GetReal(IS, Y);
385   D.SetCoord(X,Y);
386   return IS;
387 }
388
389
390 //=======================================================================
391 //function : ReadCurve2d
392 //purpose  : 
393 //=======================================================================
394
395 static Standard_IStream& operator>>(Standard_IStream& IS,
396                                     Handle(Geom2d_Line)& L)
397 {
398   gp_Pnt2d P(0.,0.);
399   gp_Dir2d AX(1.,0.);
400   IS >> P >> AX;
401   L = new Geom2d_Line(P,AX);
402   return IS;
403 }
404
405 //=======================================================================
406 //function : ReadCurve2d
407 //purpose  : 
408 //=======================================================================
409 static Standard_IStream& operator>>(Standard_IStream& IS,
410                                     Handle(Geom2d_Circle)& C)
411 {
412   gp_Pnt2d P(0.,0.);
413   gp_Dir2d AX(1.,0.),AY(1.,0.);
414   Standard_Real R=0.;
415   IS >> P >> AX >> AY;
416   BinTools::GetReal(IS, R);
417   C = new Geom2d_Circle(gp_Ax22d(P,AX,AY),R);
418   return IS;
419 }
420
421 //=======================================================================
422 //function : ReadCurve2d
423 //purpose  : 
424 //=======================================================================
425
426 static Standard_IStream& operator>>(Standard_IStream& IS,
427                                     Handle(Geom2d_Ellipse)& E)
428 {
429   gp_Pnt2d P(0.,0.);
430   gp_Dir2d AX(1.,0.),AY(1.,0.);
431   Standard_Real R1=0., R2=0.;
432   IS >> P >> AX >> AY;
433   BinTools::GetReal(IS, R1);
434   BinTools::GetReal(IS, R2);
435   E = new Geom2d_Ellipse(gp_Ax22d(P,AX,AY),R1,R2);
436   return IS;
437 }
438
439 //=======================================================================
440 //function : ReadCurve2d
441 //purpose  : 
442 //=======================================================================
443
444 static Standard_IStream& operator>>(Standard_IStream& IS,
445                                     Handle(Geom2d_Parabola)& C)
446 {
447   gp_Pnt2d P(0.,0.);
448   gp_Dir2d AX(1.,0.),AY(1.,0.);
449   Standard_Real R1=0.;
450   IS >> P >> AX >> AY;
451   BinTools::GetReal(IS, R1);
452   C = new Geom2d_Parabola(gp_Ax22d(P,AX,AY),R1);
453   return IS;
454 }
455
456 //=======================================================================
457 //function : ReadCurve2d
458 //purpose  : 
459 //=======================================================================
460
461 static Standard_IStream& operator>>(Standard_IStream& IS,
462                                     Handle(Geom2d_Hyperbola)& H)
463 {
464   gp_Pnt2d P(0.,0.);
465   gp_Dir2d AX(1.,0.),AY(1.,0.);
466   Standard_Real R1=0.,R2=0.;
467   IS >> P >> AX >> AY;
468   BinTools::GetReal(IS, R1);
469   BinTools::GetReal(IS, R2);
470   H = new Geom2d_Hyperbola(gp_Ax22d(P,AX,AY),R1,R2);
471   return IS;
472 }
473
474 //=======================================================================
475 //function : ReadCurve2d
476 //purpose  : 
477 //=======================================================================
478
479 static Standard_IStream& operator>>(Standard_IStream& IS,
480                                     Handle(Geom2d_BezierCurve)& B)
481 {
482   Standard_Boolean rational=Standard_False;
483   BinTools::GetBool(IS, rational);
484
485 // poles and weights
486   Standard_Integer i=0,degree=0;
487 // degree;
488   Standard_ExtCharacter aVal='\0';
489   BinTools::GetExtChar(IS, aVal);
490   degree = (Standard_Integer)aVal;
491
492   TColgp_Array1OfPnt2d poles(1,degree+1);
493   TColStd_Array1OfReal weights(1,degree+1);
494   
495   for (i = 1; i <= degree+1; i++) {
496     IS >> poles(i);//Pnt2d
497     if (rational)
498       BinTools::GetReal(IS, weights(i));
499   }
500
501   if (rational)
502     B = new Geom2d_BezierCurve(poles,weights);
503   else
504     B = new Geom2d_BezierCurve(poles);
505
506   return IS;
507 }
508
509 //=======================================================================
510 //function : ReadCurve2d
511 //purpose  : 
512 //=======================================================================
513
514 static Standard_IStream& operator>>(Standard_IStream& IS,
515                                     Handle(Geom2d_BSplineCurve)& B)
516 {
517
518   Standard_Boolean rational=Standard_False,periodic=Standard_False;
519   BinTools::GetBool(IS, rational);
520   BinTools::GetBool(IS, periodic);
521 // poles and weights
522   Standard_Integer i=0,degree=0,nbpoles=0,nbknots=0;
523   Standard_ExtCharacter aVal='\0';
524
525   BinTools::GetExtChar(IS, aVal);
526   degree = (Standard_Integer)aVal;
527
528   BinTools::GetInteger(IS, nbpoles);
529   
530   BinTools::GetInteger(IS, nbknots);
531
532   TColgp_Array1OfPnt2d poles(1,nbpoles);
533   TColStd_Array1OfReal weights(1,nbpoles);
534   
535   for (i = 1; i <= nbpoles; i++) {
536     IS >> poles(i);//Pnt2d
537     if (rational)
538       BinTools::GetReal(IS, weights(i));
539   }
540
541   TColStd_Array1OfReal knots(1,nbknots);
542   TColStd_Array1OfInteger mults(1,nbknots);
543
544   for (i = 1; i <= nbknots; i++) {
545     BinTools::GetReal(IS, knots(i));
546     BinTools::GetInteger(IS, mults(i));
547   }
548
549   if (rational)
550     B = new Geom2d_BSplineCurve(poles,weights,knots,mults,degree,periodic);
551   else
552     B = new Geom2d_BSplineCurve(poles,knots,mults,degree,periodic);
553   
554   return IS;
555 }
556
557 //=======================================================================
558 //function : ReadCurve2d
559 //purpose  : 
560 //=======================================================================
561
562 static Standard_IStream& operator>>(Standard_IStream& IS,
563                                     Handle(Geom2d_TrimmedCurve)& C)
564 {
565   Standard_Real p1=0.,p2=0.;
566   BinTools::GetReal(IS, p1);//FirstParameter
567   BinTools::GetReal(IS, p2);//LastParameter
568   Handle(Geom2d_Curve) BC;
569   BinTools_Curve2dSet::ReadCurve2d(IS,BC);
570   C = new Geom2d_TrimmedCurve(BC,p1,p2);
571   return IS;
572 }
573
574 //=======================================================================
575 //function : ReadCurve2d
576 //purpose  : 
577 //=======================================================================
578
579 static Standard_IStream& operator>>(Standard_IStream& IS,
580                                     Handle(Geom2d_OffsetCurve)& C)
581 {
582   Standard_Real p=0.;
583   BinTools::GetReal(IS, p);//Offset
584   Handle(Geom2d_Curve) BC;
585   BinTools_Curve2dSet::ReadCurve2d(IS,BC);
586   C = new Geom2d_OffsetCurve(BC,p);
587   return IS;
588 }
589
590 //=======================================================================
591 //function : ReadCurve2d
592 //purpose  : 
593 //=======================================================================
594
595 Standard_IStream& BinTools_Curve2dSet::ReadCurve2d(Standard_IStream& IS,
596                                                     Handle(Geom2d_Curve)& C)
597 {
598   try {
599     OCC_CATCH_SIGNALS
600     const Standard_Byte ctype = (Standard_Byte) IS.get();
601     switch (ctype) {
602
603     case LINE :
604       {
605         Handle(Geom2d_Line) CC;
606         IS >> CC;
607         C = CC;
608       }
609       break;
610
611     case CIRCLE :
612       {
613         Handle(Geom2d_Circle) CC;
614         IS >> CC;
615         C = CC;
616       }
617       break;
618
619     case ELLIPSE :
620       {
621         Handle(Geom2d_Ellipse) CC;
622         IS >> CC;
623         C = CC;
624       }
625       break;
626
627     case PARABOLA :
628       {
629         Handle(Geom2d_Parabola) CC;
630         IS >> CC;
631         C = CC;
632       }
633       break;
634
635     case HYPERBOLA :
636       {
637         Handle(Geom2d_Hyperbola) CC;
638         IS >> CC;
639         C = CC;
640       }
641       break;
642
643     case BEZIER :
644       {
645         Handle(Geom2d_BezierCurve) CC;
646         IS >> CC;
647         C = CC;
648       }
649       break;
650
651     case BSPLINE :
652       {
653         Handle(Geom2d_BSplineCurve) CC;
654         IS >> CC;
655         C = CC;
656       }
657       break;
658
659     case TRIMMED :
660       {
661         Handle(Geom2d_TrimmedCurve) CC;
662         IS >> CC;
663         C = CC;
664       }
665       break;
666
667     case OFFSET :
668       {
669         Handle(Geom2d_OffsetCurve) CC;
670         IS >> CC;
671         C = CC;
672       }
673       break;
674       
675     default:
676       {
677         C = NULL;
678         throw Standard_Failure("UNKNOWN CURVE2d TYPE");
679       }
680       break;
681     }
682   }
683   catch(Standard_Failure const& anException) {
684     C = NULL;
685     Standard_SStream aMsg;
686     aMsg <<"EXCEPTION in BinTools_Curve2dSet::ReadCurve2d(...)" << std::endl;
687     aMsg << anException << std::endl;
688     throw Standard_Failure(aMsg.str().c_str());
689   }
690   return IS;
691 }
692
693 //=======================================================================
694 //function : Read
695 //purpose  : 
696 //=======================================================================
697
698 void  BinTools_Curve2dSet::Read (Standard_IStream& IS,
699                                  const Handle(Message_ProgressIndicator)& theProgress)
700 {
701   char buffer[255];
702
703   IS >> buffer;
704   if (IS.fail() || strcmp(buffer,"Curve2ds")) {
705     Standard_SStream aMsg;
706     aMsg << "BinTools_Curve2dSet::Read:  Not a Curve2d table"<<std::endl;
707 #ifdef OCCT_DEBUG
708     std::cout <<"Curve2dSet buffer: " << buffer << std::endl;
709 #endif
710     throw Standard_Failure(aMsg.str().c_str());
711     return;
712   }
713
714   Handle(Geom2d_Curve) C;
715   Standard_Integer i, aNbCurves;
716   IS >> aNbCurves;
717   Message_ProgressSentry aPS(theProgress, "Reading curves 2d", 0, aNbCurves, 1);
718   IS.get();//remove <lf>                
719   for (i = 1; i <= aNbCurves && aPS.More(); i++, aPS.Next()) {
720     BinTools_Curve2dSet::ReadCurve2d(IS,C);
721     myMap.Add(C);
722   }
723 }