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,
 500                                    const Handle(Message_ProgressIndicator) &theProgress)const
 501 {
 502   std::streamsize prec = OS.precision(17);
 503
 504   Standard_Integer i, nbsurf = myMap.Extent();
 505   OS << "Curve2ds "<< nbsurf << "\n";
 506   //OCC19559
 507   Message_ProgressSentry PS(theProgress, "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                                   const Handle(Message_ProgressIndicator) &theProgress)
 845 {
 846   char buffer[255];
 847   IS >> buffer;
 848   if (strcmp(buffer,"Curve2ds")) {
 849     std::cout << "Not a Curve2d table"<<std::endl;
 850     return;
 851   }
 852
 853   Standard_Integer i, nbcurve;
 854   IS >> nbcurve;
 855   //OCC19559
 856   Message_ProgressSentry PS(theProgress, "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 }