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