0031642: Visualization - crash in Graphic3d_Structure::SetVisual() on redisplaying...
[occt.git] / src / GeomTools / GeomTools_Curve2dSet.cxx
1 // Created on: 1993-07-19
2 // Created by: Remi LEQUETTE
3 // Copyright (c) 1993-1999 Matra Datavision
4 // Copyright (c) 1999-2014 OPEN CASCADE SAS
5 //
6 // This file is part of Open CASCADE Technology software library.
7 //
8 // This library is free software; you can redistribute it and/or modify it under
9 // the terms of the GNU Lesser General Public License version 2.1 as published
10 // by the Free Software Foundation, with special exception defined in the file
11 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
12 // distribution for complete text of the license and disclaimer of any warranty.
13 //
14 // Alternatively, this file may be used under the terms of Open CASCADE
15 // commercial license or contractual agreement.
16
17
18 #include <Geom2d_BezierCurve.hxx>
19 #include <Geom2d_BSplineCurve.hxx>
20 #include <Geom2d_Circle.hxx>
21 #include <Geom2d_Curve.hxx>
22 #include <Geom2d_Ellipse.hxx>
23 #include <Geom2d_Hyperbola.hxx>
24 #include <Geom2d_Line.hxx>
25 #include <Geom2d_OffsetCurve.hxx>
26 #include <Geom2d_Parabola.hxx>
27 #include <Geom2d_TrimmedCurve.hxx>
28 #include <GeomTools.hxx>
29 #include <GeomTools_Curve2dSet.hxx>
30 #include <GeomTools_UndefinedTypeHandler.hxx>
31 #include <gp_Circ2d.hxx>
32 #include <gp_Elips2d.hxx>
33 #include <gp_Hypr2d.hxx>
34 #include <gp_Lin2d.hxx>
35 #include <gp_Parab2d.hxx>
36 #include <Message_ProgressIndicator.hxx>
37 #include <Message_ProgressSentry.hxx>
38 #include <Standard_ErrorHandler.hxx>
39 #include <Standard_Failure.hxx>
40 #include <Standard_OutOfRange.hxx>
41 #include <Standard_Stream.hxx>
42 #include <TColgp_Array1OfPnt2d.hxx>
43 #include <TColStd_Array1OfInteger.hxx>
44 #include <TColStd_Array1OfReal.hxx>
45
46 #define LINE      1
47 #define CIRCLE    2
48 #define ELLIPSE   3
49 #define PARABOLA  4
50 #define HYPERBOLA 5
51 #define BEZIER    6
52 #define BSPLINE   7
53 #define TRIMMED   8
54 #define OFFSET    9
55
56
57 //=======================================================================
58 //function : GeomTools_Curve2dSet
59 //purpose  : 
60 //=======================================================================
61
62 GeomTools_Curve2dSet::GeomTools_Curve2dSet() 
63 {
64 }
65
66
67 //=======================================================================
68 //function : Clear
69 //purpose  : 
70 //=======================================================================
71
72 void  GeomTools_Curve2dSet::Clear()
73 {
74   myMap.Clear();
75 }
76
77
78 //=======================================================================
79 //function : Add
80 //purpose  : 
81 //=======================================================================
82
83 Standard_Integer  GeomTools_Curve2dSet::Add(const Handle(Geom2d_Curve)& S)
84 {
85   return myMap.Add(S);
86 }
87
88
89 //=======================================================================
90 //function : Curve2d
91 //purpose  : 
92 //=======================================================================
93
94 Handle(Geom2d_Curve)  GeomTools_Curve2dSet::Curve2d
95        (const Standard_Integer I)const 
96 {
97   if (I <= 0 || I > myMap.Extent())
98      return Handle(Geom2d_Curve)();
99
100   return  Handle(Geom2d_Curve)::DownCast(myMap(I));
101 }
102
103
104 //=======================================================================
105 //function : Index
106 //purpose  : 
107 //=======================================================================
108
109 Standard_Integer  GeomTools_Curve2dSet::Index
110   (const Handle(Geom2d_Curve)& S)const 
111 {
112   return myMap.FindIndex(S);
113 }
114
115 //=======================================================================
116 //function : Print
117 //purpose  : 
118 //=======================================================================
119
120 static void Print(const gp_Pnt2d P,
121                   Standard_OStream& OS,
122                   const Standard_Boolean compact)
123 {
124   OS << P.X();
125   if (!compact) OS << ",";
126   OS << " ";
127   OS << P.Y();
128   OS << " ";
129 }
130
131 //=======================================================================
132 //function : Print
133 //purpose  : 
134 //=======================================================================
135
136 static void Print(const gp_Dir2d D,
137                   Standard_OStream& OS,
138                   const Standard_Boolean compact)
139 {
140   OS << D.X();
141   if (!compact) OS << ",";
142   OS << " ";
143   OS << D.Y();
144   OS << " ";
145 }
146
147 //=======================================================================
148 //function : Print
149 //purpose  : 
150 //=======================================================================
151
152 static void Print(const Handle(Geom2d_Line)& L,
153                          Standard_OStream& OS,
154                          const Standard_Boolean compact)
155 {
156   if (compact)
157     OS << LINE << " ";
158   else
159     OS << "Line";
160
161   gp_Lin2d C2d = L->Lin2d();
162   if (!compact) OS << "\n  Origin :";
163   Print(C2d.Location(),OS,compact);
164   if (!compact) OS << "\n  Axis   :";
165   Print(C2d.Direction(),OS,compact);
166   if (!compact) OS << "\n";
167   OS << "\n";
168 }
169
170 //=======================================================================
171 //function : Print
172 //purpose  : 
173 //=======================================================================
174
175 static void Print(const Handle(Geom2d_Circle)& C,
176                          Standard_OStream& OS,
177                          const Standard_Boolean compact)
178 {
179   if (compact)
180     OS << CIRCLE << " ";
181   else
182     OS << "Circle";
183
184   gp_Circ2d C2d = C->Circ2d();
185   if (!compact) OS << "\n  Center :";
186   Print(C2d.Location(),OS,compact);
187   if (!compact) OS << "\n  XAxis  :";
188   Print(C2d.XAxis().Direction(),OS,compact);
189   if (!compact) OS << "\n  YAxis  :";
190   Print(C2d.YAxis().Direction(),OS,compact);
191   if (!compact) OS << "\n  Radius :";
192   OS << C2d.Radius();
193   if (!compact) OS << "\n";
194   OS << "\n";
195 }
196
197 //=======================================================================
198 //function : Print
199 //purpose  : 
200 //=======================================================================
201
202 static void Print(const Handle(Geom2d_Ellipse)& E,
203                          Standard_OStream& OS,
204                          const Standard_Boolean compact)
205 {
206   if (compact)
207     OS << ELLIPSE << " ";
208   else
209     OS << "Ellipse";
210
211   gp_Elips2d C2d = E->Elips2d();
212   if (!compact) OS << "\n  Center :";
213   Print(C2d.Location(),OS,compact);
214   if (!compact) OS << "\n  XAxis  :";
215   Print(C2d.XAxis().Direction(),OS,compact);
216   if (!compact) OS << "\n  YAxis  :";
217   Print(C2d.YAxis().Direction(),OS,compact);
218   if (!compact) OS << "\n  Radii  :";
219   OS << C2d.MajorRadius();
220   if (!compact) OS << ",";
221   OS << " ";
222   OS << C2d.MinorRadius();
223   if (!compact) OS << "\n";
224   OS << "\n";
225 }
226
227 //=======================================================================
228 //function : Print
229 //purpose  : 
230 //=======================================================================
231
232 static void Print(const Handle(Geom2d_Parabola)& P,
233                          Standard_OStream& OS,
234                          const Standard_Boolean compact)
235 {
236   if (compact)
237     OS << PARABOLA << " ";
238   else
239     OS << "Parabola";
240
241   gp_Parab2d C2d = P->Parab2d();
242   if (!compact) OS << "\n  Center :";
243   Print(C2d.Location(),OS,compact);
244   if (!compact) OS << "\n  XAxis  :";
245   Print(C2d.Axis().XAxis().Direction(),OS,compact);
246   if (!compact) OS << "\n  YAxis  :";
247   Print(C2d.Axis().YAxis().Direction(),OS,compact);
248   if (!compact) OS << "\n  Focal  :";
249   OS << C2d.Focal();
250   if (!compact) OS << "\n";
251   OS << "\n";
252 }
253
254 //=======================================================================
255 //function : Print
256 //purpose  : 
257 //=======================================================================
258
259 static void Print(const Handle(Geom2d_Hyperbola)& H,
260                          Standard_OStream& OS,
261                          const Standard_Boolean compact)
262 {
263   if (compact)
264     OS << HYPERBOLA << " ";
265   else
266     OS << "Hyperbola";
267
268   gp_Hypr2d C2d = H->Hypr2d();
269   if (!compact) OS << "\n  Center :";
270   Print(C2d.Location(),OS,compact);
271   if (!compact) OS << "\n  XAxis  :";
272   Print(C2d.XAxis().Direction(),OS,compact);
273   if (!compact) OS << "\n  YAxis  :";
274   Print(C2d.YAxis().Direction(),OS,compact);
275   if (!compact) OS << "\n  Radii  :";
276   OS << C2d.MajorRadius();
277   if (!compact) OS << ",";
278   OS << " ";
279   OS << C2d.MinorRadius();
280   if (!compact) OS << "\n";
281   OS << "\n";
282 }
283
284 //=======================================================================
285 //function : Print
286 //purpose  : 
287 //=======================================================================
288
289 static void Print(const Handle(Geom2d_BezierCurve)& B,
290                          Standard_OStream& OS,
291                          const Standard_Boolean compact)
292 {
293   if (compact)
294     OS << BEZIER << " ";
295   else
296     OS << "BezierCurve";
297
298   Standard_Boolean rational = B->IsRational();
299   if (compact)
300     OS << (rational ? 1 : 0) << " ";
301   else {
302     if (rational) 
303       OS << " rational";
304   }
305
306   // poles and weights
307   Standard_Integer i,degree = B->Degree();
308   if (!compact) OS << "\n  Degree :";
309   OS << degree << " ";
310   
311   for (i = 1; i <= degree+1; i++) {
312     if (!compact) OS << "\n  "<<std::setw(2)<<i<<" : ";
313     Print(B->Pole(i),OS,compact);
314     if (rational)
315       OS << " " << B->Weight(i);
316     if (compact)
317       OS << " ";
318   }
319   if (!compact) OS << "\n";
320   OS << "\n";
321 }
322
323 //=======================================================================
324 //function : Print
325 //purpose  : 
326 //=======================================================================
327
328 static void Print(const Handle(Geom2d_BSplineCurve)& B,
329                          Standard_OStream& OS,
330                          const Standard_Boolean compact)
331 {
332   if (compact)
333     OS << BSPLINE << " ";
334   else
335     OS << "BSplineCurve";
336
337
338   Standard_Boolean rational = B->IsRational();
339   if (compact)
340     OS << (rational ? 1 : 0) << " ";
341   else {
342     if (rational) 
343       OS << " rational";
344   }
345
346   Standard_Boolean periodic = B->IsPeriodic();
347   if (compact)
348     OS << (periodic ? 1 : 0) << " ";
349   else {
350     if (periodic) 
351       OS << " periodic";
352   }
353
354   // poles and weights
355   Standard_Integer i,degree,nbpoles,nbknots;
356   degree = B->Degree();
357   nbpoles = B->NbPoles();
358   nbknots = B->NbKnots();
359   if (!compact) OS << "\n  Degree ";
360   else OS << " ";
361   OS << degree;
362   if (!compact) OS << ",";
363   OS << " ";
364   OS << nbpoles;
365   if (!compact) OS << " Poles,";
366   OS << " ";
367   OS << nbknots << " ";
368   if (!compact) OS << " Knots";
369   
370   if (!compact) OS << "Poles :\n";
371   for (i = 1; i <= nbpoles; i++) {
372     if (!compact) OS << "\n  "<<std::setw(2)<<i<<" : ";
373     else OS << " ";
374     Print(B->Pole(i),OS,compact);
375     if (rational)
376       OS << " " << B->Weight(i);
377   }
378   OS << "\n";
379
380   if (!compact) OS << "Knots :\n";
381   for (i = 1; i <= nbknots; i++) {
382     if (!compact) OS << "\n  "<<std::setw(2)<<i<<" : ";
383     else OS << " ";
384     OS << B->Knot(i) << " " << B->Multiplicity(i);
385   }
386   if (!compact) OS << "\n";
387   OS << "\n";
388 }
389
390 //=======================================================================
391 //function : Print
392 //purpose  : 
393 //=======================================================================
394
395 static void Print(const Handle(Geom2d_TrimmedCurve)& C,
396                          Standard_OStream& OS,
397                          const Standard_Boolean compact)
398 {
399   if (compact)
400     OS << TRIMMED << " ";
401   else
402     OS << "Trimmed curve\n";
403   if (!compact) OS << "Parameters : ";
404   OS << C->FirstParameter() << " " << C->LastParameter() << "\n";
405   if (!compact) OS << "Basis curve :\n";
406   GeomTools_Curve2dSet::PrintCurve2d(C->BasisCurve(),OS,compact);
407 }
408
409 //=======================================================================
410 //function : Print
411 //purpose  : 
412 //=======================================================================
413
414 static void Print(const Handle(Geom2d_OffsetCurve)& C,
415                          Standard_OStream& OS,
416                          const Standard_Boolean compact)
417 {
418   if (compact)
419     OS << OFFSET << " ";
420   else
421     OS << "OffsetCurve";
422   if (!compact) OS << "Offset : ";
423   OS << C->Offset() <<  "\n";
424   if (!compact) OS << "Basis curve :\n";
425   GeomTools_Curve2dSet::PrintCurve2d(C->BasisCurve(),OS,compact);
426 }
427
428 //=======================================================================
429 //function : PrintCurve2d
430 //purpose  : 
431 //=======================================================================
432
433 void GeomTools_Curve2dSet::PrintCurve2d(const Handle(Geom2d_Curve)& C,
434                                         Standard_OStream& OS,
435                                         const Standard_Boolean compact)
436 {
437   Handle(Standard_Type) TheType = C->DynamicType();
438
439   if ( TheType ==  STANDARD_TYPE(Geom2d_Circle)) {
440     Print(Handle(Geom2d_Circle)::DownCast(C),OS,compact);
441   }
442   else if ( TheType ==STANDARD_TYPE(Geom2d_Line)) {
443     Print(Handle(Geom2d_Line)::DownCast(C),OS,compact);
444   }
445   else if ( TheType == STANDARD_TYPE(Geom2d_Ellipse)) {
446     Print(Handle(Geom2d_Ellipse)::DownCast(C),OS,compact);
447   }
448   else if ( TheType == STANDARD_TYPE(Geom2d_Parabola)) {
449     Print(Handle(Geom2d_Parabola)::DownCast(C),OS,compact);
450   }
451   else if ( TheType == STANDARD_TYPE(Geom2d_Hyperbola)) {
452     Print(Handle(Geom2d_Hyperbola)::DownCast(C),OS,compact);
453   }
454   else if ( TheType == STANDARD_TYPE(Geom2d_BezierCurve)) {
455     Print(Handle(Geom2d_BezierCurve)::DownCast(C),OS,compact);
456   }
457   else if ( TheType == STANDARD_TYPE(Geom2d_BSplineCurve)) {
458     Print(Handle(Geom2d_BSplineCurve)::DownCast(C),OS,compact);
459   }
460   else if ( TheType == STANDARD_TYPE(Geom2d_TrimmedCurve)) {
461     Print(Handle(Geom2d_TrimmedCurve)::DownCast(C),OS,compact);
462   }
463   else if ( TheType == STANDARD_TYPE(Geom2d_OffsetCurve)) {
464     Print(Handle(Geom2d_OffsetCurve)::DownCast(C),OS,compact);
465   }
466   else {
467     GeomTools::GetUndefinedTypeHandler()->PrintCurve2d(C,OS,compact);
468     //if (!compact)
469     //  OS << "****** UNKNOWN CURVE2d TYPE ******\n";
470     //else 
471     //  std::cout << "****** UNKNOWN CURVE2d TYPE ******" << std::endl;
472   }
473 }
474
475 //=======================================================================
476 //function : Dump
477 //purpose  : 
478 //=======================================================================
479
480 void  GeomTools_Curve2dSet::Dump(Standard_OStream& OS)const 
481 {
482   Standard_Integer i, nbsurf = myMap.Extent();
483   OS << "\n -------\n";
484   OS << "Dump of "<< nbsurf << " Curve2ds ";
485   OS << "\n -------\n\n";
486
487   for (i = 1; i <= nbsurf; i++) {
488     OS << std::setw(4) << i << " : ";
489     PrintCurve2d(Handle(Geom2d_Curve)::DownCast(myMap(i)),OS,Standard_False);
490   }
491 }
492
493
494 //=======================================================================
495 //function : Write
496 //purpose  : 
497 //=======================================================================
498
499 void  GeomTools_Curve2dSet::Write(Standard_OStream& OS)const 
500 {
501   std::streamsize prec = OS.precision(17);
502
503   Standard_Integer i, nbsurf = myMap.Extent();
504   OS << "Curve2ds "<< nbsurf << "\n";
505   //OCC19559
506   Handle(Message_ProgressIndicator) progress = GetProgress();
507   Message_ProgressSentry PS(progress, "2D Curves", 0, nbsurf, 1);
508   for (i = 1; i <= nbsurf && PS.More(); i++, PS.Next()) {
509     PrintCurve2d(Handle(Geom2d_Curve)::DownCast(myMap(i)),OS,Standard_True);
510   }
511   OS.precision(prec);
512 }
513
514
515 //=======================================================================
516 //function : ReadPnt2d
517 //purpose  : 
518 //=======================================================================
519
520 static Standard_IStream& operator>>(Standard_IStream& IS, gp_Pnt2d& P)
521 {
522   Standard_Real X=0.,Y=0.;
523   GeomTools::GetReal(IS, X);
524   GeomTools::GetReal(IS, Y);
525   P.SetCoord(X,Y);
526   return IS;
527 }
528
529 //=======================================================================
530 //function : ReadDir2d
531 //purpose  : 
532 //=======================================================================
533
534 static Standard_IStream& operator>>(Standard_IStream& IS, gp_Dir2d& D)
535 {
536   Standard_Real X=0.,Y=0.;
537   GeomTools::GetReal(IS, X);
538   GeomTools::GetReal(IS, Y);
539   D.SetCoord(X,Y);
540   return IS;
541 }
542
543
544 //=======================================================================
545 //function : ReadCurve2d
546 //purpose  : 
547 //=======================================================================
548
549 static Standard_IStream& operator>>(Standard_IStream& IS,
550                                     Handle(Geom2d_Line)& L)
551 {
552   gp_Pnt2d P(0.,0.);
553   gp_Dir2d AX(1.,0.);
554   IS >> P >> AX;
555   L = new Geom2d_Line(P,AX);
556   return IS;
557 }
558
559 //=======================================================================
560 //function : ReadCurve2d
561 //purpose  : 
562 //=======================================================================
563
564 static Standard_IStream& operator>>(Standard_IStream& IS,
565                                     Handle(Geom2d_Circle)& C)
566 {
567   gp_Pnt2d P(0.,0.);
568   gp_Dir2d AX(1.,0.),AY(1.,0.);
569   Standard_Real R=0.;
570   IS >> P >> AX >> AY;
571   GeomTools::GetReal(IS, R);
572   C = new Geom2d_Circle(gp_Ax22d(P,AX,AY),R);
573   return IS;
574 }
575
576 //=======================================================================
577 //function : ReadCurve2d
578 //purpose  : 
579 //=======================================================================
580
581 static Standard_IStream& operator>>(Standard_IStream& IS,
582                                     Handle(Geom2d_Ellipse)& E)
583 {
584   gp_Pnt2d P(0.,0.);
585   gp_Dir2d AX(1.,0.),AY(1.,0.);
586   Standard_Real R1=0.,R2=0.;
587   IS >> P >> AX >> AY;
588   GeomTools::GetReal(IS, R1);
589   GeomTools::GetReal(IS, R2);
590   E = new Geom2d_Ellipse(gp_Ax22d(P,AX,AY),R1,R2);
591   return IS;
592 }
593
594 //=======================================================================
595 //function : ReadCurve2d
596 //purpose  : 
597 //=======================================================================
598
599 static Standard_IStream& operator>>(Standard_IStream& IS,
600                                     Handle(Geom2d_Parabola)& C)
601 {
602   gp_Pnt2d P(0.,0.);
603   gp_Dir2d AX(1.,0.),AY(1.,0.);
604   Standard_Real R1=0.;
605   IS >> P >> AX >> AY;
606   GeomTools::GetReal(IS, R1);
607   C = new Geom2d_Parabola(gp_Ax22d(P,AX,AY),R1);
608   return IS;
609 }
610
611 //=======================================================================
612 //function : ReadCurve2d
613 //purpose  : 
614 //=======================================================================
615
616 static Standard_IStream& operator>>(Standard_IStream& IS,
617                                     Handle(Geom2d_Hyperbola)& H)
618 {
619   gp_Pnt2d P(0.,0.);
620   gp_Dir2d AX(1.,0.),AY(1.,0.);
621   Standard_Real R1=0.,R2=0.;
622   IS >> P >> AX >> AY;
623   GeomTools::GetReal(IS, R1);
624   GeomTools::GetReal(IS, R2);
625   H = new Geom2d_Hyperbola(gp_Ax22d(P,AX,AY),R1,R2);
626   return IS;
627 }
628
629 //=======================================================================
630 //function : ReadCurve2d
631 //purpose  : 
632 //=======================================================================
633
634 static Standard_IStream& operator>>(Standard_IStream& IS,
635                                     Handle(Geom2d_BezierCurve)& B)
636 {
637   Standard_Boolean rational=Standard_False;
638   IS >> rational;
639
640   // poles and weights
641   Standard_Integer i=0,degree=0;
642   IS >> degree;
643
644   TColgp_Array1OfPnt2d poles(1,degree+1);
645   TColStd_Array1OfReal weights(1,degree+1);
646   
647   for (i = 1; i <= degree+1; i++) {
648     IS >> poles(i);
649     if (rational)
650       GeomTools::GetReal(IS, weights(i));
651   }
652
653   if (rational)
654     B = new Geom2d_BezierCurve(poles,weights);
655   else
656     B = new Geom2d_BezierCurve(poles);
657
658   return IS;
659 }
660
661 //=======================================================================
662 //function : ReadCurve2d
663 //purpose  : 
664 //=======================================================================
665
666 static Standard_IStream& operator>>(Standard_IStream& IS,
667                                     Handle(Geom2d_BSplineCurve)& B)
668 {
669   Standard_Boolean rational=Standard_False,periodic=Standard_False;
670   IS >> rational >> periodic;
671
672   // poles and weights
673   Standard_Integer i=0,degree=0,nbpoles=0,nbknots=0;
674   IS >> degree >> nbpoles >> nbknots;
675
676   TColgp_Array1OfPnt2d poles(1,nbpoles);
677   TColStd_Array1OfReal weights(1,nbpoles);
678
679   for (i = 1; i <= nbpoles; i++) {
680     IS >> poles(i);
681     if (rational)
682       GeomTools::GetReal(IS, weights(i));
683   }
684
685   TColStd_Array1OfReal knots(1,nbknots);
686   TColStd_Array1OfInteger mults(1,nbknots);
687
688   for (i = 1; i <= nbknots; i++) {
689     GeomTools::GetReal(IS, knots(i)); 
690     IS >> mults(i);
691   }
692
693   if (rational)
694     B = new Geom2d_BSplineCurve(poles,weights,knots,mults,degree,periodic);
695   else
696     B = new Geom2d_BSplineCurve(poles,knots,mults,degree,periodic);
697   
698   return IS;
699 }
700
701 //=======================================================================
702 //function : ReadCurve2d
703 //purpose  : 
704 //=======================================================================
705
706 static Standard_IStream& operator>>(Standard_IStream& IS,
707                                     Handle(Geom2d_TrimmedCurve)& C)
708 {
709   Standard_Real p1=0.,p2=0.;
710   GeomTools::GetReal(IS, p1);
711   GeomTools::GetReal(IS, p2);
712   Handle(Geom2d_Curve) BC = GeomTools_Curve2dSet::ReadCurve2d(IS);
713   C = new Geom2d_TrimmedCurve(BC,p1,p2);
714   return IS;
715 }
716
717 //=======================================================================
718 //function : ReadCurve2d
719 //purpose  : 
720 //=======================================================================
721
722 static Standard_IStream& operator>>(Standard_IStream& IS,
723                                     Handle(Geom2d_OffsetCurve)& C)
724 {
725   Standard_Real p=0.;
726   GeomTools::GetReal(IS, p);
727   Handle(Geom2d_Curve) BC = GeomTools_Curve2dSet::ReadCurve2d(IS);
728   C = new Geom2d_OffsetCurve(BC,p);
729   return IS;
730 }
731
732 //=======================================================================
733 //function : ReadCurve2d
734 //purpose  : 
735 //=======================================================================
736
737 Handle(Geom2d_Curve) GeomTools_Curve2dSet::ReadCurve2d(Standard_IStream& IS)
738 {
739   Standard_Integer ctype;
740
741   Handle(Geom2d_Curve) C;
742   try {
743     OCC_CATCH_SIGNALS
744     IS >> ctype;
745     switch (ctype) {
746
747     case LINE :
748       {
749         Handle(Geom2d_Line) CC;
750         IS >> CC;
751         C = CC;
752       }
753       break;
754
755     case CIRCLE :
756       {
757         Handle(Geom2d_Circle) CC;
758         IS >> CC;
759         C = CC;
760       }
761       break;
762
763     case ELLIPSE :
764       {
765         Handle(Geom2d_Ellipse) CC;
766         IS >> CC;
767         C = CC;
768       }
769       break;
770
771     case PARABOLA :
772       {
773         Handle(Geom2d_Parabola) CC;
774         IS >> CC;
775         C = CC;
776       }
777       break;
778
779     case HYPERBOLA :
780       {
781         Handle(Geom2d_Hyperbola) CC;
782         IS >> CC;
783         C = CC;
784       }
785       break;
786
787     case BEZIER :
788       {
789         Handle(Geom2d_BezierCurve) CC;
790         IS >> CC;
791         C = CC;
792       }
793       break;
794
795     case BSPLINE :
796       {
797         Handle(Geom2d_BSplineCurve) CC;
798         IS >> CC;
799         C = CC;
800       }
801       break;
802
803     case TRIMMED :
804       {
805         Handle(Geom2d_TrimmedCurve) CC;
806         IS >> CC;
807         C = CC;
808       }
809       break;
810
811     case OFFSET :
812       {
813         Handle(Geom2d_OffsetCurve) CC;
814         IS >> CC;
815         C = CC;
816       }
817       break;
818       
819     default:
820       {
821         Handle(Geom2d_Curve) CC;
822         GeomTools::GetUndefinedTypeHandler()->ReadCurve2d(ctype,IS,CC);
823         C = CC;
824       }
825       break;
826     }
827   }
828   catch(Standard_Failure const& anException) {
829 #ifdef OCCT_DEBUG
830     std::cout <<"EXCEPTION in GeomTools_Curve2dSet::ReadCurve2d(..)!!!" << std::endl;
831     std::cout << anException << std::endl;
832 #endif
833     (void)anException;
834   }
835   return C;
836 }
837
838 //=======================================================================
839 //function : Read
840 //purpose  : 
841 //=======================================================================
842
843 void  GeomTools_Curve2dSet::Read(Standard_IStream& IS)
844 {
845   char buffer[255];
846   IS >> buffer;
847   if (strcmp(buffer,"Curve2ds")) {
848     std::cout << "Not a Curve2d table"<<std::endl;
849     return;
850   }
851
852   Standard_Integer i, nbcurve;
853   IS >> nbcurve;
854   //OCC19559
855   Handle(Message_ProgressIndicator) progress = GetProgress();
856   Message_ProgressSentry PS(progress, "2D Curves", 0, nbcurve, 1);
857   for (i = 1; i <= nbcurve && PS.More(); i++, PS.Next()) {
858     Handle(Geom2d_Curve) C = GeomTools_Curve2dSet::ReadCurve2d (IS);
859     myMap.Add(C);
860   }
861 }
862
863 //=======================================================================
864 //function : GetProgress
865 //purpose  : 
866 //=======================================================================
867
868 Handle(Message_ProgressIndicator) GeomTools_Curve2dSet::GetProgress() const
869 {
870   return myProgress;
871 }
872
873 //=======================================================================
874 //function : SetProgress
875 //purpose  : 
876 //=======================================================================
877
878 void GeomTools_Curve2dSet::SetProgress(const Handle(Message_ProgressIndicator)& PR)
879 {
880   myProgress = PR;
881 }
882
883