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-2012 OPEN CASCADE SAS
   5 //
   6 // The content of this file is subject to the Open CASCADE Technology Public
   7 // License Version 6.5 (the "License"). You may not use the content of this file
   8 // except in compliance with the License. Please obtain a copy of the License
   9 // at http://www.opencascade.org and read it completely before using this file.
  10 //
  11 // The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
  12 // main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
  13 //
  14 // The Original Code and all software distributed under the License is
  15 // distributed on an "AS IS" basis, without warranty of any kind, and the
  16 // Initial Developer hereby disclaims all such warranties, including without
  17 // limitation, any warranties of merchantability, fitness for a particular
  18 // purpose or non-infringement. Please see the License for the specific terms
  19 // and conditions governing the rights and limitations under the License.
  20
  21
  22 #include <Standard_Stream.hxx>
  23 #include <GeomTools_Curve2dSet.ixx>
  24 #include <GeomTools.hxx>
  25 #include <GeomTools_UndefinedTypeHandler.hxx>
  26
  27 #include <Geom2d_Circle.hxx>
  28 #include <Geom2d_Line.hxx>
  29 #include <Geom2d_Ellipse.hxx>
  30 #include <Geom2d_Parabola.hxx>
  31 #include <Geom2d_Hyperbola.hxx>
  32 #include <Geom2d_BezierCurve.hxx>
  33 #include <Geom2d_BSplineCurve.hxx>
  34 #include <Geom2d_TrimmedCurve.hxx>
  35 #include <Geom2d_OffsetCurve.hxx>
  36
  37 #include <gp_Lin2d.hxx>
  38 #include <gp_Circ2d.hxx>
  39 #include <gp_Elips2d.hxx>
  40 #include <gp_Parab2d.hxx>
  41 #include <gp_Hypr2d.hxx>
  42
  43 #include <TColStd_Array1OfReal.hxx>
  44 #include <TColStd_Array1OfInteger.hxx>
  45 #include <TColgp_Array1OfPnt2d.hxx>
  46 #include <Standard_Failure.hxx>
  47 #include <Standard_ErrorHandler.hxx>
  48 #include <Message_ProgressSentry.hxx>
  49
  50 #define LINE      1
  51 #define CIRCLE    2
  52 #define ELLIPSE   3
  53 #define PARABOLA  4
  54 #define HYPERBOLA 5
  55 #define BEZIER    6
  56 #define BSPLINE   7
  57 #define TRIMMED   8
  58 #define OFFSET    9
  59
  60
  61 //=======================================================================
  62 //function : GeomTools_Curve2dSet
  63 //purpose  :
  64 //=======================================================================
  65
  66 GeomTools_Curve2dSet::GeomTools_Curve2dSet()
  67 {
  68 }
  69
  70
  71 //=======================================================================
  72 //function : Clear
  73 //purpose  :
  74 //=======================================================================
  75
  76 void  GeomTools_Curve2dSet::Clear()
  77 {
  78   myMap.Clear();
  79 }
  80
  81
  82 //=======================================================================
  83 //function : Add
  84 //purpose  :
  85 //=======================================================================
  86
  87 Standard_Integer  GeomTools_Curve2dSet::Add(const Handle(Geom2d_Curve)& S)
  88 {
  89   return myMap.Add(S);
  90 }
  91
  92
  93 //=======================================================================
  94 //function : Curve2d
  95 //purpose  :
  96 //=======================================================================
  97
  98 Handle(Geom2d_Curve)  GeomTools_Curve2dSet::Curve2d
  99        (const Standard_Integer I)const
 100 {
 101   if (I <= 0 || I > myMap.Extent())
 102      return Handle(Geom2d_Curve)();
 103
 104   return  Handle(Geom2d_Curve)::DownCast(myMap(I));
 105 }
 106
 107
 108 //=======================================================================
 109 //function : Index
 110 //purpose  :
 111 //=======================================================================
 112
 113 Standard_Integer  GeomTools_Curve2dSet::Index
 114   (const Handle(Geom2d_Curve)& S)const
 115 {
 116   return myMap.FindIndex(S);
 117 }
 118
 119 //=======================================================================
 120 //function : Print
 121 //purpose  :
 122 //=======================================================================
 123
 124 static void Print(const gp_Pnt2d P,
 125                   Standard_OStream& OS,
 126                   const Standard_Boolean compact)
 127 {
 128   OS << P.X();
 129   if (!compact) OS << ",";
 130   OS << " ";
 131   OS << P.Y();
 132   OS << " ";
 133 }
 134
 135 //=======================================================================
 136 //function : Print
 137 //purpose  :
 138 //=======================================================================
 139
 140 static void Print(const gp_Dir2d D,
 141                   Standard_OStream& OS,
 142                   const Standard_Boolean compact)
 143 {
 144   OS << D.X();
 145   if (!compact) OS << ",";
 146   OS << " ";
 147   OS << D.Y();
 148   OS << " ";
 149 }
 150
 151 //=======================================================================
 152 //function : Print
 153 //purpose  :
 154 //=======================================================================
 155
 156 static void Print(const Handle(Geom2d_Line)& L,
 157                          Standard_OStream& OS,
 158                          const Standard_Boolean compact)
 159 {
 160   if (compact)
 161     OS << LINE << " ";
 162   else
 163     OS << "Line";
 164
 165   gp_Lin2d C2d = L->Lin2d();
 166   if (!compact) OS << "\n  Origin :";
 167   Print(C2d.Location(),OS,compact);
 168   if (!compact) OS << "\n  Axis   :";
 169   Print(C2d.Direction(),OS,compact);
 170   if (!compact) OS << "\n";
 171   OS << "\n";
 172 }
 173
 174 //=======================================================================
 175 //function : Print
 176 //purpose  :
 177 //=======================================================================
 178
 179 static void Print(const Handle(Geom2d_Circle)& C,
 180                          Standard_OStream& OS,
 181                          const Standard_Boolean compact)
 182 {
 183   if (compact)
 184     OS << CIRCLE << " ";
 185   else
 186     OS << "Circle";
 187
 188   gp_Circ2d C2d = C->Circ2d();
 189   if (!compact) OS << "\n  Center :";
 190   Print(C2d.Location(),OS,compact);
 191   if (!compact) OS << "\n  XAxis  :";
 192   Print(C2d.XAxis().Direction(),OS,compact);
 193   if (!compact) OS << "\n  YAxis  :";
 194   Print(C2d.YAxis().Direction(),OS,compact);
 195   if (!compact) OS << "\n  Radius :";
 196   OS << C2d.Radius();
 197   if (!compact) OS << "\n";
 198   OS << "\n";
 199 }
 200
 201 //=======================================================================
 202 //function : Print
 203 //purpose  :
 204 //=======================================================================
 205
 206 static void Print(const Handle(Geom2d_Ellipse)& E,
 207                          Standard_OStream& OS,
 208                          const Standard_Boolean compact)
 209 {
 210   if (compact)
 211     OS << ELLIPSE << " ";
 212   else
 213     OS << "Ellipse";
 214
 215   gp_Elips2d C2d = E->Elips2d();
 216   if (!compact) OS << "\n  Center :";
 217   Print(C2d.Location(),OS,compact);
 218   if (!compact) OS << "\n  XAxis  :";
 219   Print(C2d.XAxis().Direction(),OS,compact);
 220   if (!compact) OS << "\n  YAxis  :";
 221   Print(C2d.YAxis().Direction(),OS,compact);
 222   if (!compact) OS << "\n  Radii  :";
 223   OS << C2d.MajorRadius();
 224   if (!compact) OS << ",";
 225   OS << " ";
 226   OS << C2d.MinorRadius();
 227   if (!compact) OS << "\n";
 228   OS << "\n";
 229 }
 230
 231 //=======================================================================
 232 //function : Print
 233 //purpose  :
 234 //=======================================================================
 235
 236 static void Print(const Handle(Geom2d_Parabola)& P,
 237                          Standard_OStream& OS,
 238                          const Standard_Boolean compact)
 239 {
 240   if (compact)
 241     OS << PARABOLA << " ";
 242   else
 243     OS << "Parabola";
 244
 245   gp_Parab2d C2d = P->Parab2d();
 246   if (!compact) OS << "\n  Center :";
 247   Print(C2d.Location(),OS,compact);
 248   if (!compact) OS << "\n  XAxis  :";
 249   Print(C2d.Axis().XAxis().Direction(),OS,compact);
 250   if (!compact) OS << "\n  YAxis  :";
 251   Print(C2d.Axis().YAxis().Direction(),OS,compact);
 252   if (!compact) OS << "\n  Focal  :";
 253   OS << C2d.Focal();
 254   if (!compact) OS << "\n";
 255   OS << "\n";
 256 }
 257
 258 //=======================================================================
 259 //function : Print
 260 //purpose  :
 261 //=======================================================================
 262
 263 static void Print(const Handle(Geom2d_Hyperbola)& H,
 264                          Standard_OStream& OS,
 265                          const Standard_Boolean compact)
 266 {
 267   if (compact)
 268     OS << HYPERBOLA << " ";
 269   else
 270     OS << "Hyperbola";
 271
 272   gp_Hypr2d C2d = H->Hypr2d();
 273   if (!compact) OS << "\n  Center :";
 274   Print(C2d.Location(),OS,compact);
 275   if (!compact) OS << "\n  XAxis  :";
 276   Print(C2d.XAxis().Direction(),OS,compact);
 277   if (!compact) OS << "\n  YAxis  :";
 278   Print(C2d.YAxis().Direction(),OS,compact);
 279   if (!compact) OS << "\n  Radii  :";
 280   OS << C2d.MajorRadius();
 281   if (!compact) OS << ",";
 282   OS << " ";
 283   OS << C2d.MinorRadius();
 284   if (!compact) OS << "\n";
 285   OS << "\n";
 286 }
 287
 288 //=======================================================================
 289 //function : Print
 290 //purpose  :
 291 //=======================================================================
 292
 293 static void Print(const Handle(Geom2d_BezierCurve)& B,
 294                          Standard_OStream& OS,
 295                          const Standard_Boolean compact)
 296 {
 297   if (compact)
 298     OS << BEZIER << " ";
 299   else
 300     OS << "BezierCurve";
 301
 302   Standard_Boolean rational = B->IsRational();
 303   if (compact)
 304     OS << (rational ? 1 : 0) << " ";
 305   else {
 306     if (rational)
 307       OS << " rational";
 308   }
 309
 310   // poles and weights
 311   Standard_Integer i,degree = B->Degree();
 312   if (!compact) OS << "\n  Degree :";
 313   OS << degree << " ";
 314
 315   for (i = 1; i <= degree+1; i++) {
 316     if (!compact) OS << "\n  "<<setw(2)<<i<<" : ";
 317     Print(B->Pole(i),OS,compact);
 318     if (rational)
 319       OS << " " << B->Weight(i);
 320     if (compact)
 321       OS << " ";
 322   }
 323   if (!compact) OS << "\n";
 324   OS << "\n";
 325 }
 326
 327 //=======================================================================
 328 //function : Print
 329 //purpose  :
 330 //=======================================================================
 331
 332 static void Print(const Handle(Geom2d_BSplineCurve)& B,
 333                          Standard_OStream& OS,
 334                          const Standard_Boolean compact)
 335 {
 336   if (compact)
 337     OS << BSPLINE << " ";
 338   else
 339     OS << "BSplineCurve";
 340
 341
 342   Standard_Boolean rational = B->IsRational();
 343   if (compact)
 344     OS << (rational ? 1 : 0) << " ";
 345   else {
 346     if (rational)
 347       OS << " rational";
 348   }
 349
 350   Standard_Boolean periodic = B->IsPeriodic();
 351   if (compact)
 352     OS << (periodic ? 1 : 0) << " ";
 353   else {
 354     if (periodic)
 355       OS << " periodic";
 356   }
 357
 358   // poles and weights
 359   Standard_Integer i,degree,nbpoles,nbknots;
 360   degree = B->Degree();
 361   nbpoles = B->NbPoles();
 362   nbknots = B->NbKnots();
 363   if (!compact) OS << "\n  Degree ";
 364   else OS << " ";
 365   OS << degree;
 366   if (!compact) OS << ",";
 367   OS << " ";
 368   OS << nbpoles;
 369   if (!compact) OS << " Poles,";
 370   OS << " ";
 371   OS << nbknots << " ";
 372   if (!compact) OS << " Knots";
 373
 374   if (!compact) OS << "Poles :\n";
 375   for (i = 1; i <= nbpoles; i++) {
 376     if (!compact) OS << "\n  "<<setw(2)<<i<<" : ";
 377     else OS << " ";
 378     Print(B->Pole(i),OS,compact);
 379     if (rational)
 380       OS << " " << B->Weight(i);
 381   }
 382   OS << "\n";
 383
 384   if (!compact) OS << "Knots :\n";
 385   for (i = 1; i <= nbknots; i++) {
 386     if (!compact) OS << "\n  "<<setw(2)<<i<<" : ";
 387     else OS << " ";
 388     OS << B->Knot(i) << " " << B->Multiplicity(i);
 389   }
 390   if (!compact) OS << "\n";
 391   OS << "\n";
 392 }
 393
 394 //=======================================================================
 395 //function : Print
 396 //purpose  :
 397 //=======================================================================
 398
 399 static void Print(const Handle(Geom2d_TrimmedCurve)& C,
 400                          Standard_OStream& OS,
 401                          const Standard_Boolean compact)
 402 {
 403   if (compact)
 404     OS << TRIMMED << " ";
 405   else
 406     OS << "Trimmed curve\n";
 407   if (!compact) OS << "Parameters : ";
 408   OS << C->FirstParameter() << " " << C->LastParameter() << "\n";
 409   if (!compact) OS << "Basis curve :\n";
 410   GeomTools_Curve2dSet::PrintCurve2d(C->BasisCurve(),OS,compact);
 411 }
 412
 413 //=======================================================================
 414 //function : Print
 415 //purpose  :
 416 //=======================================================================
 417
 418 static void Print(const Handle(Geom2d_OffsetCurve)& C,
 419                          Standard_OStream& OS,
 420                          const Standard_Boolean compact)
 421 {
 422   if (compact)
 423     OS << OFFSET << " ";
 424   else
 425     OS << "OffsetCurve";
 426   if (!compact) OS << "Offset : ";
 427   OS << C->Offset() <<  "\n";
 428   if (!compact) OS << "Basis curve :\n";
 429   GeomTools_Curve2dSet::PrintCurve2d(C->BasisCurve(),OS,compact);
 430 }
 431
 432 //=======================================================================
 433 //function : PrintCurve2d
 434 //purpose  :
 435 //=======================================================================
 436
 437 void GeomTools_Curve2dSet::PrintCurve2d(const Handle(Geom2d_Curve)& C,
 438                                         Standard_OStream& OS,
 439                                         const Standard_Boolean compact)
 440 {
 441   Handle(Standard_Type) TheType = C->DynamicType();
 442
 443   if ( TheType ==  STANDARD_TYPE(Geom2d_Circle)) {
 444     Print(Handle(Geom2d_Circle)::DownCast(C),OS,compact);
 445   }
 446   else if ( TheType ==STANDARD_TYPE(Geom2d_Line)) {
 447     Print(Handle(Geom2d_Line)::DownCast(C),OS,compact);
 448   }
 449   else if ( TheType == STANDARD_TYPE(Geom2d_Ellipse)) {
 450     Print(Handle(Geom2d_Ellipse)::DownCast(C),OS,compact);
 451   }
 452   else if ( TheType == STANDARD_TYPE(Geom2d_Parabola)) {
 453     Print(Handle(Geom2d_Parabola)::DownCast(C),OS,compact);
 454   }
 455   else if ( TheType == STANDARD_TYPE(Geom2d_Hyperbola)) {
 456     Print(Handle(Geom2d_Hyperbola)::DownCast(C),OS,compact);
 457   }
 458   else if ( TheType == STANDARD_TYPE(Geom2d_BezierCurve)) {
 459     Print(Handle(Geom2d_BezierCurve)::DownCast(C),OS,compact);
 460   }
 461   else if ( TheType == STANDARD_TYPE(Geom2d_BSplineCurve)) {
 462     Print(Handle(Geom2d_BSplineCurve)::DownCast(C),OS,compact);
 463   }
 464   else if ( TheType == STANDARD_TYPE(Geom2d_TrimmedCurve)) {
 465     Print(Handle(Geom2d_TrimmedCurve)::DownCast(C),OS,compact);
 466   }
 467   else if ( TheType == STANDARD_TYPE(Geom2d_OffsetCurve)) {
 468     Print(Handle(Geom2d_OffsetCurve)::DownCast(C),OS,compact);
 469   }
 470   else {
 471     GeomTools::GetUndefinedTypeHandler()->PrintCurve2d(C,OS,compact);
 472     //if (!compact)
 473     //  OS << "****** UNKNOWN CURVE2d TYPE ******\n";
 474     //else
 475     //  cout << "****** UNKNOWN CURVE2d TYPE ******" << endl;
 476   }
 477 }
 478
 479 //=======================================================================
 480 //function : Dump
 481 //purpose  :
 482 //=======================================================================
 483
 484 void  GeomTools_Curve2dSet::Dump(Standard_OStream& OS)const
 485 {
 486   Standard_Integer i, nbsurf = myMap.Extent();
 487   OS << "\n -------\n";
 488   OS << "Dump of "<< nbsurf << " Curve2ds ";
 489   OS << "\n -------\n\n";
 490
 491   for (i = 1; i <= nbsurf; i++) {
 492     OS << setw(4) << i << " : ";
 493     PrintCurve2d(Handle(Geom2d_Curve)::DownCast(myMap(i)),OS,Standard_False);
 494   }
 495 }
 496
 497
 498 //=======================================================================
 499 //function : Write
 500 //purpose  :
 501 //=======================================================================
 502
 503 void  GeomTools_Curve2dSet::Write(Standard_OStream& OS)const
 504 {
 505   int  prec = OS.precision(17);
 506
 507   Standard_Integer i, nbsurf = myMap.Extent();
 508   OS << "Curve2ds "<< nbsurf << "\n";
 509   //OCC19559
 510   Handle(Message_ProgressIndicator) progress = GetProgress();
 511   Message_ProgressSentry PS(progress, "2D Curves", 0, nbsurf, 1);
 512
 513   for (i = 1; i <= nbsurf && PS.More(); i++, PS.Next()) {
 514     if ( !myProgress.IsNull() )
 515       progress->Show();
 516     PrintCurve2d(Handle(Geom2d_Curve)::DownCast(myMap(i)),OS,Standard_True);
 517   }
 518
 519   OS.precision(prec);
 520 }
 521
 522
 523 //=======================================================================
 524 //function : ReadPnt2d
 525 //purpose  :
 526 //=======================================================================
 527
 528 static Standard_IStream& operator>>(Standard_IStream& IS, gp_Pnt2d& P)
 529 {
 530   Standard_Real X=0.,Y=0.;
 531   IS >> X >> Y;
 532   P.SetCoord(X,Y);
 533   return IS;
 534 }
 535
 536 //=======================================================================
 537 //function : ReadDir2d
 538 //purpose  :
 539 //=======================================================================
 540
 541 static Standard_IStream& operator>>(Standard_IStream& IS, gp_Dir2d& D)
 542 {
 543   Standard_Real X=0.,Y=0.;
 544   IS >> X >> Y;
 545   D.SetCoord(X,Y);
 546   return IS;
 547 }
 548
 549
 550 //=======================================================================
 551 //function : ReadCurve2d
 552 //purpose  :
 553 //=======================================================================
 554
 555 static Standard_IStream& operator>>(Standard_IStream& IS,
 556                                     Handle(Geom2d_Line)& L)
 557 {
 558   gp_Pnt2d P(0.,0.);
 559   gp_Dir2d AX(1.,0.);
 560   IS >> P >> AX;
 561   L = new Geom2d_Line(P,AX);
 562   return IS;
 563 }
 564
 565 //=======================================================================
 566 //function : ReadCurve2d
 567 //purpose  :
 568 //=======================================================================
 569
 570 static Standard_IStream& operator>>(Standard_IStream& IS,
 571                                     Handle(Geom2d_Circle)& C)
 572 {
 573   gp_Pnt2d P(0.,0.);
 574   gp_Dir2d AX(1.,0.),AY(1.,0.);
 575   Standard_Real R=0.;
 576   IS >> P >> AX >> AY >> R;
 577   C = new Geom2d_Circle(gp_Ax22d(P,AX,AY),R);
 578   return IS;
 579 }
 580
 581 //=======================================================================
 582 //function : ReadCurve2d
 583 //purpose  :
 584 //=======================================================================
 585
 586 static Standard_IStream& operator>>(Standard_IStream& IS,
 587                                     Handle(Geom2d_Ellipse)& E)
 588 {
 589   gp_Pnt2d P(0.,0.);
 590   gp_Dir2d AX(1.,0.),AY(1.,0.);
 591   Standard_Real R1=0.,R2=0.;
 592   IS >> P >> AX >> AY >> R1 >> R2;
 593   E = new Geom2d_Ellipse(gp_Ax22d(P,AX,AY),R1,R2);
 594   return IS;
 595 }
 596
 597 //=======================================================================
 598 //function : ReadCurve2d
 599 //purpose  :
 600 //=======================================================================
 601
 602 static Standard_IStream& operator>>(Standard_IStream& IS,
 603                                     Handle(Geom2d_Parabola)& C)
 604 {
 605   gp_Pnt2d P(0.,0.);
 606   gp_Dir2d AX(1.,0.),AY(1.,0.);
 607   Standard_Real R1=0.;
 608   IS >> P >> AX >> AY >> R1;
 609   C = new Geom2d_Parabola(gp_Ax22d(P,AX,AY),R1);
 610   return IS;
 611 }
 612
 613 //=======================================================================
 614 //function : ReadCurve2d
 615 //purpose  :
 616 //=======================================================================
 617
 618 static Standard_IStream& operator>>(Standard_IStream& IS,
 619                                     Handle(Geom2d_Hyperbola)& H)
 620 {
 621   gp_Pnt2d P(0.,0.);
 622   gp_Dir2d AX(1.,0.),AY(1.,0.);
 623   Standard_Real R1=0.,R2=0.;
 624   IS >> P >> AX >> AY >> R1 >> 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       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       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     IS >> knots(i) >> mults(i);
 690   }
 691
 692   if (rational)
 693     B = new Geom2d_BSplineCurve(poles,weights,knots,mults,degree,periodic);
 694   else
 695     B = new Geom2d_BSplineCurve(poles,knots,mults,degree,periodic);
 696
 697   return IS;
 698 }
 699
 700 //=======================================================================
 701 //function : ReadCurve2d
 702 //purpose  :
 703 //=======================================================================
 704
 705 static Standard_IStream& operator>>(Standard_IStream& IS,
 706                                     Handle(Geom2d_TrimmedCurve)& C)
 707 {
 708   Standard_Real p1=0.,p2=0.;
 709   IS >> p1 >> p2;
 710   Handle(Geom2d_Curve) BC;
 711   GeomTools_Curve2dSet::ReadCurve2d(IS,BC);
 712   C = new Geom2d_TrimmedCurve(BC,p1,p2);
 713   return IS;
 714 }
 715
 716 //=======================================================================
 717 //function : ReadCurve2d
 718 //purpose  :
 719 //=======================================================================
 720
 721 static Standard_IStream& operator>>(Standard_IStream& IS,
 722                                     Handle(Geom2d_OffsetCurve)& C)
 723 {
 724   Standard_Real p=0.;
 725   IS >> p;
 726   Handle(Geom2d_Curve) BC;
 727   GeomTools_Curve2dSet::ReadCurve2d(IS,BC);
 728   C = new Geom2d_OffsetCurve(BC,p);
 729   return IS;
 730 }
 731
 732 //=======================================================================
 733 //function : ReadCurve2d
 734 //purpose  :
 735 //=======================================================================
 736
 737 Standard_IStream& GeomTools_Curve2dSet::ReadCurve2d(Standard_IStream& IS,
 738                                                     Handle(Geom2d_Curve)& C)
 739 {
 740   Standard_Integer ctype;
 741
 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) {
 829 #ifdef DEB
 830     Handle(Standard_Failure) anExc = Standard_Failure::Caught();
 831     cout <<"EXCEPTION in GeomTools_Curve2dSet::ReadCurve2d(..)!!!" << endl;
 832     cout << anExc << endl;
 833 #endif
 834     C = NULL;
 835   }
 836   return IS;
 837 }
 838
 839 //=======================================================================
 840 //function : Read
 841 //purpose  :
 842 //=======================================================================
 843
 844 void  GeomTools_Curve2dSet::Read(Standard_IStream& IS)
 845 {
 846   char buffer[255];
 847   IS >> buffer;
 848   if (strcmp(buffer,"Curve2ds")) {
 849     cout << "Not a Curve2d table"<<endl;
 850     return;
 851   }
 852
 853   Handle(Geom2d_Curve) C;
 854   Standard_Integer i, nbcurve;
 855   IS >> nbcurve;
 856   //OCC19559
 857   Handle(Message_ProgressIndicator) progress = GetProgress();
 858   Message_ProgressSentry PS(progress, "2D Curves", 0, nbcurve, 1);
 859
 860   for (i = 1; i <= nbcurve && PS.More(); i++, PS.Next()) {
 861     if ( !myProgress.IsNull() )
 862       progress->Show();
 863
 864     GeomTools_Curve2dSet::ReadCurve2d(IS,C);
 865     myMap.Add(C);
 866   }
 867 }
 868
 869 //=======================================================================
 870 //function : GetProgress
 871 //purpose  :
 872 //=======================================================================
 873
 874 Handle(Message_ProgressIndicator) GeomTools_Curve2dSet::GetProgress() const
 875 {
 876   return myProgress;
 877 }
 878
 879 //=======================================================================
 880 //function : SetProgress
 881 //purpose  :
 882 //=======================================================================
 883
 884 void GeomTools_Curve2dSet::SetProgress(const Handle(Message_ProgressIndicator)& PR)
 885 {
 886   myProgress = PR;
 887 }
 888
 889