src/BinTools/BinTools_Curve2dSet.cxx

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