src/GeomToIGES/GeomToIGES_GeomCurve.cxx

   1 // Copyright (c) 1999-2014 OPEN CASCADE SAS
   2 //
   3 // This file is part of Open CASCADE Technology software library.
   4 //
   5 // This library is free software; you can redistribute it and/or modify it under
   6 // the terms of the GNU Lesser General Public License version 2.1 as published
   7 // by the Free Software Foundation, with special exception defined in the file
   8 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
   9 // distribution for complete text of the license and disclaimer of any warranty.
  10 //
  11 // Alternatively, this file may be used under the terms of Open CASCADE
  12 // commercial license or contractual agreement.
  13
  14 // modif du 04/03/96 mjm
  15 // modif dans IGESConvGeom_GeomBuilder
  16 //#53 rln 24.12.98 CCI60005
  17 //#59 rln 29.12.98 PRO17015
  18 //%11 pdn 12.01.99 CTS22023: writing offset curves and detecting planar curves
  19 //%12 pdn 13.01.99: CTS22023: cutting bspline curves (for Euclid3)
  20 //:l7 abv 13.01.99: CTS22021: using QuasiAngular parametrisation for circles (more precise)
  21 //:l5 abv 14.01.99: CTS22022-1: protection against exceptions in Segment()
  22 //:q3 abv 17.03.99: PRO17828: using GeomConvert_ApproxCurve for converting circle to bspline
  23
  24 #include <BSplCLib.hxx>
  25 #include <Geom_BezierCurve.hxx>
  26 #include <Geom_BoundedCurve.hxx>
  27 #include <Geom_BSplineCurve.hxx>
  28 #include <Geom_Circle.hxx>
  29 #include <Geom_Conic.hxx>
  30 #include <Geom_Curve.hxx>
  31 #include <Geom_Ellipse.hxx>
  32 #include <Geom_Hyperbola.hxx>
  33 #include <Geom_Line.hxx>
  34 #include <Geom_OffsetCurve.hxx>
  35 #include <Geom_Parabola.hxx>
  36 #include <Geom_TrimmedCurve.hxx>
  37 #include <GeomConvert.hxx>
  38 #include <GeomConvert_ApproxCurve.hxx>
  39 #include <GeomToIGES_GeomCurve.hxx>
  40 #include <GeomToIGES_GeomEntity.hxx>
  41 #include <gp.hxx>
  42 #include <gp_Ax2.hxx>
  43 #include <gp_Ax3.hxx>
  44 #include <gp_Ax22d.hxx>
  45 #include <gp_Circ.hxx>
  46 #include <gp_Dir.hxx>
  47 #include <gp_Elips.hxx>
  48 #include <gp_Elips2d.hxx>
  49 #include <gp_Hypr.hxx>
  50 #include <gp_Hypr2d.hxx>
  51 #include <gp_Parab.hxx>
  52 #include <gp_Parab2d.hxx>
  53 #include <gp_Pnt.hxx>
  54 #include <gp_XY.hxx>
  55 #include <gp_XYZ.hxx>
  56 #include <IGESConvGeom_GeomBuilder.hxx>
  57 #include <IGESData_IGESEntity.hxx>
  58 #include <IGESData_ToolLocation.hxx>
  59 #include <IGESGeom_BSplineCurve.hxx>
  60 #include <IGESGeom_CircularArc.hxx>
  61 #include <IGESGeom_CompositeCurve.hxx>
  62 #include <IGESGeom_ConicArc.hxx>
  63 #include <IGESGeom_CopiousData.hxx>
  64 #include <IGESGeom_CurveOnSurface.hxx>
  65 #include <IGESGeom_Line.hxx>
  66 #include <IGESGeom_OffsetCurve.hxx>
  67 #include <IGESGeom_Point.hxx>
  68 #include <IGESGeom_TransformationMatrix.hxx>
  69 #include <Interface_Macros.hxx>
  70 #include <Interface_Static.hxx>
  71 #include <Precision.hxx>
  72 #include <ShapeCustom_BSplineRestriction.hxx>
  73 #include <Standard_ErrorHandler.hxx>
  74 #include <Standard_Failure.hxx>
  75 #include <TColgp_Array1OfPnt.hxx>
  76 #include <TColgp_HArray1OfXYZ.hxx>
  77 #include <TColStd_Array1OfReal.hxx>
  78 #include <TColStd_HArray1OfReal.hxx>
  79
  80 // Pour toutes les courbes infinies soit
  81 // Udeb <= -Precision::Infinite() et/ou Ufin >= Precision::Infinite()
  82 // on choisit arbitrairement de les construire entre
  83 // Udeb = -Precision::Infinite() et Ufin = Precision::Infinite()
  84 //=============================================================================
  85 // GeomToIGES_GeomCurve
  86 //=============================================================================
  87 GeomToIGES_GeomCurve::GeomToIGES_GeomCurve()
  88 :GeomToIGES_GeomEntity()
  89 {
  90 }
  91
  92
  93 //=============================================================================
  94 // GeomToIGES_GeomCurve
  95 //=============================================================================
  96
  97 GeomToIGES_GeomCurve::GeomToIGES_GeomCurve
  98 (const GeomToIGES_GeomEntity& GE)
  99 :GeomToIGES_GeomEntity(GE)
 100 {
 101 }
 102
 103
 104 //=============================================================================
 105 // Transfer des Entites Curve de Geom vers IGES
 106 // TransferCurve
 107 //=============================================================================
 108
 109 Handle(IGESData_IGESEntity) GeomToIGES_GeomCurve::TransferCurve
 110 (const Handle(Geom_Curve)& start, const Standard_Real Udeb,
 111  const Standard_Real Ufin)
 112 {
 113   Handle(IGESData_IGESEntity) res;
 114   if (start.IsNull()) {
 115     return res;
 116   }
 117
 118   if (start->IsKind(STANDARD_TYPE(Geom_BoundedCurve))) {
 119     DeclareAndCast(Geom_BoundedCurve, Bounded, start);
 120     res = TransferCurve(Bounded, Udeb, Ufin);
 121   }
 122   else if (start->IsKind(STANDARD_TYPE(Geom_Conic))) {
 123     DeclareAndCast(Geom_Conic, Conic, start);
 124     res = TransferCurve(Conic, Udeb, Ufin);
 125   }
 126   else if ( start->IsKind(STANDARD_TYPE(Geom_OffsetCurve))) {
 127     DeclareAndCast(Geom_OffsetCurve, OffsetC, start);
 128     res = TransferCurve(OffsetC, Udeb, Ufin);
 129   }
 130   else if ( start->IsKind(STANDARD_TYPE(Geom_Line))) {
 131     DeclareAndCast(Geom_Line, Line, start);
 132     res = TransferCurve(Line, Udeb, Ufin);
 133   }
 134   return res;
 135 }
 136
 137
 138
 139 //=============================================================================
 140 // Transfer des Entites BoundedCurve de Geom vers IGES
 141 // TransferCurve
 142 //=============================================================================
 143
 144 Handle(IGESData_IGESEntity) GeomToIGES_GeomCurve::TransferCurve
 145 (const Handle(Geom_BoundedCurve)& start, const Standard_Real Udeb,
 146  const Standard_Real Ufin)
 147 {
 148   Handle(IGESData_IGESEntity) res;
 149   if (start.IsNull()) {
 150     return res;
 151   }
 152
 153   if (start->IsKind(STANDARD_TYPE(Geom_BSplineCurve))) {
 154     DeclareAndCast(Geom_BSplineCurve, Bspline, start);
 155     res = TransferCurve(Bspline, Udeb, Ufin);
 156   }
 157   else if (start->IsKind(STANDARD_TYPE(Geom_BezierCurve))) {
 158     DeclareAndCast(Geom_BezierCurve, Bezier, start);
 159     res = TransferCurve(Bezier, Udeb, Ufin);
 160   }
 161   else if ( start->IsKind(STANDARD_TYPE(Geom_TrimmedCurve))) {
 162     DeclareAndCast(Geom_TrimmedCurve, Trimmed, start);
 163     res = TransferCurve(Trimmed, Udeb, Ufin);
 164   }
 165
 166   return res;
 167 }
 168
 169 //%11 pdn 12.01.98
 170 //=============================================================================
 171 // Detects if curve lies in some plane and returns normal
 172 // IsPlanar
 173 //=============================================================================
 174 static gp_XYZ GetAnyNormal ( gp_XYZ orig )
 175 {
 176   gp_XYZ Norm;
 177   if ( Abs ( orig.Z() ) < Precision::Confusion() )
 178     Norm.SetCoord ( 0, 0, 1 );
 179   else {
 180     Norm.SetCoord ( orig.Z(), 0, -orig.X() );
 181     Standard_Real nrm = Norm.Modulus();
 182     if ( nrm < Precision::Confusion() ) Norm.SetCoord ( 0, 0, 1 );
 183     else Norm = Norm / nrm;
 184   }
 185   return Norm;
 186 }
 187
 188 //%11 pdn 12.01.98
 189 //=============================================================================
 190 // Detects if curve lies in some plane and returns normal
 191 // IsPlanar
 192 //=============================================================================
 193 static Standard_Boolean ArePolesPlanar (const TColgp_Array1OfPnt& Poles,
 194                                         gp_XYZ& Normal)
 195 {
 196   if(Poles.Length()<3) {
 197     Normal = GetAnyNormal(Poles(1).XYZ()-Poles(2).XYZ());
 198     return Standard_True;
 199   }
 200
 201   Normal = Poles(Poles.Length()).XYZ() ^ Poles(1).XYZ();
 202   Standard_Integer i; // svv Jan 10 2000 : porting on DEC
 203   for ( i = 1; i < Poles.Length(); i++)
 204     Normal += Poles ( i ).XYZ() ^ Poles ( i + 1 ).XYZ();
 205
 206   Standard_Real tol = Precision::Confusion();
 207   Standard_Real nrm = Normal.Modulus();
 208   if ( nrm < tol ) {
 209     Normal.SetCoord ( 0, 0, 1 );
 210     return Standard_False;
 211   }
 212   Normal = Normal / nrm;
 213
 214   Standard_Real scl = Poles(1).XYZ() * Normal;
 215   for ( i = 2; i <= Poles.Length(); i++ )
 216     if ( Abs ( Poles(i).XYZ() * Normal - scl ) > tol ) return Standard_False;
 217   return Standard_True;
 218 }
 219
 220 //%11 pdn 12.01.98
 221 //=============================================================================
 222 // Detects if curve lies in some plane and returns normal
 223 // IsPlanar
 224 //=============================================================================
 225 static Standard_Boolean IsPlanar(const Handle(Geom_Curve)& curve,
 226                                  gp_XYZ& Normal)
 227 {
 228   Normal.SetCoord(0,0,0);
 229   if ( curve->IsKind(STANDARD_TYPE(Geom_Line))) {
 230     DeclareAndCast(Geom_Line, Line, curve);
 231     Normal = GetAnyNormal(Line->Position().Direction().XYZ());
 232     return Standard_True;
 233   }
 234   if ( curve->IsKind(STANDARD_TYPE(Geom_Conic))) {
 235     DeclareAndCast(Geom_Conic, Conic, curve);
 236     Normal = Conic->Axis().Direction().XYZ();
 237     return Standard_True;
 238   }
 239   if ( curve->IsKind(STANDARD_TYPE(Geom_TrimmedCurve))) {
 240     DeclareAndCast(Geom_TrimmedCurve, Trimmed, curve);
 241     return IsPlanar(Trimmed->BasisCurve(),Normal);
 242   }
 243   if ( curve->IsKind(STANDARD_TYPE(Geom_OffsetCurve))) {
 244     DeclareAndCast(Geom_OffsetCurve, OffsetC, curve);
 245     return IsPlanar(OffsetC->BasisCurve(),Normal);
 246   }
 247   if ( curve->IsKind(STANDARD_TYPE(Geom_BSplineCurve))) {
 248     DeclareAndCast(Geom_BSplineCurve, BSpline, curve);
 249     TColgp_Array1OfPnt Poles(1,BSpline->NbPoles());
 250     BSpline->Poles(Poles);
 251     return ArePolesPlanar(Poles,Normal);
 252   }
 253   if ( curve->IsKind(STANDARD_TYPE(Geom_BezierCurve)))  {
 254     DeclareAndCast(Geom_BezierCurve, Bezier, curve);
 255     TColgp_Array1OfPnt Poles(1,Bezier->NbPoles());
 256     Bezier->Poles(Poles);
 257     return ArePolesPlanar(Poles,Normal);
 258   }
 259   return Standard_False;
 260 }
 261
 262 //=============================================================================
 263 // Transfer des Entites BSplineCurve de Geom vers IGES
 264 // TransferCurve
 265 //=============================================================================
 266
 267 Handle(IGESData_IGESEntity) GeomToIGES_GeomCurve::TransferCurve
 268 (const Handle(Geom_BSplineCurve)& start, const Standard_Real Udeb,
 269  const Standard_Real Ufin)
 270 {
 271   Handle(IGESData_IGESEntity) res;
 272   if (start.IsNull()) {
 273     return res;
 274   }
 275
 276   Handle(Geom_BSplineCurve) mycurve;
 277   Standard_Boolean IPlan  = Standard_False;
 278   gp_XYZ Norm = gp_XYZ(0.,0.,1.);
 279
 280 // Si la courbe est periodique, on passe par une fonction pour recuperer tous
 281 // les parametres necessaires a l`ecriture IGES.
 282
 283   Standard_Boolean IPerio  = start->IsPeriodic();
 284
 285   if (IPerio) {
 286     mycurve = Handle(Geom_BSplineCurve)::DownCast(start->Copy());
 287     mycurve->SetNotPeriodic();
 288   }
 289   else {
 290     mycurve = start;
 291   }
 292
 293   Standard_Real Umin = Udeb;
 294   Standard_Real Umax = Ufin;
 295   if (Precision::IsNegativeInfinite(Udeb)) Umin = -Precision::Infinite();
 296   if (Precision::IsPositiveInfinite(Ufin)) Umax = Precision::Infinite();
 297
 298   //%12 pdn: cut curve for E3
 299   Standard_Real First = mycurve->FirstParameter();
 300   Standard_Real Last = mycurve->LastParameter();
 301   //:l5 abv 14 Jan 99: protect against exceptions in Segment()
 302   if ( Umin - First < Precision::PConfusion() ) Umin = First;
 303   if ( Last - Umax  < Precision::PConfusion() ) Umax = Last;
 304   if ( Umin - First > Precision::PConfusion() || Last - Umax > Precision::PConfusion() ) {
 305     try {
 306       OCC_CATCH_SIGNALS
 307       Handle(Geom_BSplineCurve) bspl = Handle(Geom_BSplineCurve)::DownCast ( mycurve->Copy() );
 308       if ( ! bspl.IsNull() ) {
 309         if (Abs(Umax-Umin) > Precision::PConfusion())
 310           bspl->Segment ( Umin, Umax );
 311         mycurve = bspl;
 312       }
 313     }
 314     catch ( Standard_Failure const& anException) {
 315 #ifdef OCCT_DEBUG
 316       std::cout << "Warning: GeomToIGES_GeomCurve: can't trim bspline" << std::endl;
 317       std::cout << "Warning: Exception in Segment(): " ;
 318       anException.Print(std::cout);
 319 #endif
 320       (void)anException;
 321     }
 322   }
 323
 324   Standard_Boolean IClos   = mycurve->IsClosed();
 325 //  Standard_Boolean IRatio  = mycurve->IsRational();
 326   Standard_Boolean IPolyn  = !(mycurve->IsRational());
 327   //Standard_Boolean IPerio  = mycurve->IsPeriodic();
 328   Standard_Integer Deg     = mycurve->Degree();
 329   Standard_Integer Nbpoles = mycurve->NbPoles();
 330 //  Standard_Integer Nbknots = mycurve->NbKnots();
 331   Standard_Integer Index = Nbpoles -1;
 332
 333
 334 // Sequence des Knots de [-Deg, Index+1] dans IGESGeom.
 335 // et de [1, Nbpoles+Deg+1] dans Geom
 336   Standard_Integer Knotindex;
 337   Standard_Real rtampon;
 338   TColStd_Array1OfReal K(1, Nbpoles+Deg+1);
 339   mycurve->KnotSequence(K);
 340   Standard_Integer itampon = -Deg;
 341   Handle(TColStd_HArray1OfReal) Knots = new TColStd_HArray1OfReal(-Deg,Index+1);
 342   for ( Knotindex=K.Lower(); Knotindex<=K.Upper(); Knotindex++) {
 343     rtampon = K.Value(Knotindex);
 344     Knots->SetValue(itampon, rtampon);
 345     itampon++;
 346   }
 347
 348
 349 // Tableau Weights de [0,Index]
 350   TColStd_Array1OfReal W(1, Nbpoles);
 351   mycurve->Weights(W);
 352   itampon = 0;
 353   Handle(TColStd_HArray1OfReal) Weights = new TColStd_HArray1OfReal(0,Index);
 354   for ( Knotindex=W.Lower(); Knotindex<=W.Upper(); Knotindex++) {
 355     rtampon = W.Value(Knotindex);
 356     Weights->SetValue(itampon, rtampon);
 357     itampon++;
 358   }
 359
 360
 361 // Tableau Poles de [0,Index]
 362   TColgp_Array1OfPnt P(1, Nbpoles);
 363   mycurve->Poles(P);
 364   Standard_Integer Poleindex;
 365   itampon = 0;
 366   Standard_Real Xpt, Ypt, Zpt;
 367   Handle(TColgp_HArray1OfXYZ) Poles = new TColgp_HArray1OfXYZ(0,Index);
 368   for ( Poleindex=P.Lower(); Poleindex<=P.Upper(); Poleindex++) {
 369     gp_Pnt ptampon = P.Value(Poleindex);
 370     ptampon.Coord(Xpt, Ypt, Zpt);
 371     gp_XYZ xyztampon = gp_XYZ (Xpt/GetUnit(), Ypt/GetUnit(), Zpt/GetUnit());
 372     Poles->SetValue(itampon, xyztampon);
 373     itampon++;
 374   }
 375
 376   // modif mjm du 9/10/97 : mise en place d'une protection.
 377 //%12  Standard_Real First = mycurve->FirstParameter();
 378 //%12  Standard_Real Last = mycurve->LastParameter();
 379 //:l5  if (First >  Umin) Umin = First;
 380 //:l5  if (Last  <  Umax) Umax = Last;
 381   Handle(IGESGeom_BSplineCurve) BSplineC = new IGESGeom_BSplineCurve;
 382   //%11 pdn 13.01.98 computing planar flag and normal
 383   IPlan = IsPlanar(start,Norm);
 384   if ( Norm.Z() <0 ) Norm.Reverse();
 385   BSplineC->Init
 386     (Index, Deg, IPlan, IClos, IPolyn, IPerio, Knots, Weights, Poles,
 387      Umin, Umax, Norm);
 388
 389   res = BSplineC;
 390   return res;
 391 }
 392
 393
 394 //=============================================================================
 395 // Transfer des Entites BezierCurve de Geom vers IGES
 396 // TransferCurve
 397 //=============================================================================
 398
 399 Handle(IGESData_IGESEntity) GeomToIGES_GeomCurve::TransferCurve
 400 (const Handle(Geom_BezierCurve)& start, const Standard_Real Udeb,
 401  const Standard_Real Ufin)
 402 {
 403   Handle(IGESData_IGESEntity) res;
 404   if (start.IsNull()) {
 405     return res;
 406   }
 407
 408   Handle(Geom_TrimmedCurve) mycurve3d =
 409           new Geom_TrimmedCurve(start, Udeb, Ufin);
 410   Handle(Geom_BSplineCurve) Bspline = GeomConvert::CurveToBSplineCurve(mycurve3d,
 411     Convert_RationalC1);//#28 rln 19.10.98 UKI60155
 412   Standard_Real First = Bspline->FirstParameter();
 413   Standard_Real Last  = Bspline->LastParameter();
 414   res = TransferCurve(Bspline, First, Last);
 415   return res;
 416 }
 417
 418
 419 //=============================================================================
 420 // Transfer des Entites TrimmedCurve de Geom vers IGES
 421 // TransferCurve
 422 //=============================================================================
 423
 424 Handle(IGESData_IGESEntity) GeomToIGES_GeomCurve::TransferCurve
 425 (const Handle(Geom_TrimmedCurve)& start, const Standard_Real Udeb,
 426  const Standard_Real Ufin)
 427 {
 428   Handle(IGESData_IGESEntity) res;
 429   if (start.IsNull()) {
 430     return res;
 431   }
 432
 433   Handle(Geom_Curve) st = start->BasisCurve();
 434   if (st->IsKind(STANDARD_TYPE(Geom_TrimmedCurve))) {
 435     DeclareAndCast(Geom_TrimmedCurve, Trimmed, st);
 436     Handle(Geom_Curve) st1 = Trimmed->BasisCurve();
 437     res = TransferCurve(st1, Udeb, Ufin);
 438   }
 439
 440   res = TransferCurve(st, Udeb, Ufin);
 441   return res;
 442 }
 443
 444
 445
 446 //=============================================================================
 447 // Transfer des Entites Conic de Geom vers IGES
 448 // TransferCurve
 449 //=============================================================================
 450
 451 Handle(IGESData_IGESEntity) GeomToIGES_GeomCurve::TransferCurve
 452 (const Handle(Geom_Conic)& start, const Standard_Real Udeb,
 453  const Standard_Real Ufin)
 454 {
 455   Handle(IGESData_IGESEntity) res;
 456   if (start.IsNull()) {
 457     return res;
 458   }
 459
 460   // conic curve : Ellipse, Circle, Hyperbola, Parabola.
 461   // All the conics are planar curves. An axis placement (two axis)
 462   // defines the local coordinate system of the conic.
 463   // The Location point, the XDirection and the YDirection of this
 464   // axis placement define the plane of the conic.
 465   // The XDirection defines the origin of the curve's parametrization.
 466   // The Direction (main direction) of the axis placement is normal
 467   // to the plane of the conic.
 468
 469   if (start->IsKind(STANDARD_TYPE(Geom_Circle))) {
 470     DeclareAndCast(Geom_Circle, Circle, start);
 471     res = TransferCurve(Circle, Udeb, Ufin);
 472   }
 473   else if (start->IsKind(STANDARD_TYPE(Geom_Ellipse))) {
 474     DeclareAndCast(Geom_Ellipse, Ellipse, start);
 475     res = TransferCurve(Ellipse, Udeb, Ufin);
 476   }
 477   else if ( start->IsKind(STANDARD_TYPE(Geom_Hyperbola))) {
 478     DeclareAndCast(Geom_Hyperbola, Hyperbola, start);
 479     res = TransferCurve(Hyperbola, Udeb, Ufin);
 480   }
 481   else if ( start->IsKind(STANDARD_TYPE(Geom_Parabola))) {
 482     DeclareAndCast(Geom_Parabola, Parabola, start);
 483     res = TransferCurve(Parabola, Udeb, Ufin);
 484   }
 485
 486   return res;
 487 }
 488
 489
 490 //=============================================================================
 491 // Transfer des Entites Circle de Geom vers IGES
 492 // TransferCurve
 493 //=============================================================================
 494
 495 Handle(IGESData_IGESEntity) GeomToIGES_GeomCurve::TransferCurve
 496 (const Handle(Geom_Circle)& start , const Standard_Real Udeb,
 497  const Standard_Real Ufin)
 498 {
 499
 500   Handle(IGESData_IGESEntity) res;
 501   if (start.IsNull()) {
 502     return res;
 503   }
 504   Handle(IGESGeom_CircularArc) Circle = new IGESGeom_CircularArc;;
 505   IGESConvGeom_GeomBuilder Build;
 506
 507   Standard_Real U1 = Udeb;
 508   Standard_Real U2 = Ufin;
 509   if (Abs(Udeb) <= gp::Resolution()) U1 = 0.0;
 510
 511 // creation du "CircularArc" (#100)
 512 // --------------------------------
 513   Standard_Real xloc,yloc,zloc;
 514   start->Circ().Location().Coord(xloc,yloc,zloc);
 515   gp_Pnt Loc;
 516   Loc.SetCoord(xloc,yloc,zloc);
 517   gp_Ax3 Pos = gp_Ax3(start->Circ().Position());
 518 // unusable  Standard_Boolean IsDirect = Pos.Direct();
 519   Pos.SetLocation(Loc);
 520   Build.SetPosition(Pos);
 521
 522   Standard_Real Xc, Yc, Zc;
 523   Standard_Real Xs, Ys, Zs;
 524   Standard_Real Xe, Ye, Ze;
 525   //gka BUG 6542 1.09.04 BSpline curve was written in the IGES instead circle.
 526   gp_Pnt pfirst,plast;
 527   start->D0(U1,pfirst);
 528   if(Abs (Ufin - Udeb - 2 * M_PI) <= Precision::PConfusion())
 529     plast = pfirst;
 530   else
 531     start->D0(U2,plast);
 532   //
 533   Build.EvalXYZ(((start->Circ()).Location()).XYZ(), Xc, Yc, Zc);
 534   Build.EvalXYZ(pfirst.XYZ(), Xs, Ys, Zs);
 535   Build.EvalXYZ(plast.XYZ(), Xe, Ye, Ze);
 536   Circle->Init (Zc/GetUnit(),
 537                 gp_XY( Xc/GetUnit(), Yc/GetUnit()),
 538                 gp_XY( Xs/GetUnit(), Ys/GetUnit()),
 539                 gp_XY( Xe/GetUnit(), Ye/GetUnit()));
 540
 541   // creation de la Trsf (#124)
 542   // il faut tenir compte de l`unite pour la matrice de transformation
 543   // (partie translation).
 544
 545   if (!Build.IsIdentity()){
 546     Handle(IGESGeom_TransformationMatrix) TMat =
 547       new IGESGeom_TransformationMatrix;
 548     TMat = Build.MakeTransformation(GetUnit());
 549     Circle->InitTransf(TMat);
 550   }
 551
 552   res = Circle;
 553   return res;
 554 }
 555
 556
 557 //=============================================================================
 558 // Transfer des Entites Ellipse de Geom vers IGES
 559 // TransferCurve
 560 //=============================================================================
 561
 562 Handle(IGESData_IGESEntity) GeomToIGES_GeomCurve::TransferCurve
 563 (const Handle(Geom_Ellipse)& start, const Standard_Real Udeb,
 564  const Standard_Real Ufin)
 565 {
 566
 567   Handle(IGESData_IGESEntity) res;
 568   if (start.IsNull()) {
 569     return res;
 570   }
 571
 572   //#35 rln 22.10.98 BUC60391 face 9
 573   //Closed Conic Arc is incorrectly oriented when reading back to CAS.CADE
 574   if (Abs (Ufin - Udeb - 2 * M_PI) <= Precision::PConfusion()) {
 575     //#53 rln 24.12.98 CCI60005
 576     //Trimmed ellipse. To avoid huge weights in B-Spline first rotate it and then convert
 577     Handle(Geom_Ellipse) copystart = Handle(Geom_Ellipse)::DownCast (start->Copy());
 578     gp_Ax2 pos = copystart->Position();
 579     copystart->SetPosition (pos.Rotated (pos.Axis(), gp_Ax3 (pos).Direct() ? Udeb : 2 * M_PI - Udeb));
 580     Handle(Geom_BSplineCurve) Bspline;
 581     //:q3 abv 17 Mar 99: use GeomConvert_ApproxCurve for precise conversion
 582     const Handle(Geom_Curve)& aCopy = copystart; // to avoid ambiguity
 583     GeomConvert_ApproxCurve approx (aCopy, Precision::Approximation(),
 584                                     GeomAbs_C1, 100, 6 );
 585     if ( approx.HasResult() ) Bspline = approx.Curve();
 586     if ( Bspline.IsNull() )
 587       GeomConvert::CurveToBSplineCurve (copystart, Convert_QuasiAngular);
 588     TColStd_Array1OfReal Knots(1, Bspline->NbKnots());
 589     Bspline->Knots (Knots);
 590     BSplCLib::Reparametrize (Udeb, Udeb + 2 * M_PI, Knots);
 591     Bspline->SetKnots (Knots);
 592     return TransferCurve (Bspline, Udeb, Ufin);
 593   }
 594
 595   Handle(IGESGeom_ConicArc) Conic = new IGESGeom_ConicArc;
 596   IGESConvGeom_GeomBuilder Build;
 597   Standard_Real U1 = Udeb;
 598   Standard_Real U2 = Ufin;
 599   if (Abs(Udeb) <= gp::Resolution()) U1 = 0.0;
 600
 601 // creation du "ConicArc" (#104)
 602 // -----------------------------
 603
 604   Standard_Real xloc,yloc,zloc;
 605   start->Elips().Location().Coord(xloc,yloc,zloc);
 606   gp_Pnt Loc;
 607   Loc.SetCoord(xloc, yloc, zloc);
 608   gp_Ax3 Pos = gp_Ax3(start->Elips().Position());
 609   Pos.SetLocation(Loc);
 610   Build.SetPosition(Pos);
 611
 612   Standard_Real Xs, Ys, Zs;
 613   Standard_Real Xe, Ye, Ze;
 614   Build.EvalXYZ((start->Value(U1)).XYZ(), Xs, Ys, Zs);
 615   Build.EvalXYZ((start->Value(U2)).XYZ(), Xe, Ye, Ze);
 616   gp_Elips2d E2d = gp_Elips2d(gp_Ax22d(gp::Origin2d(), gp::DX2d(), gp::DY2d()),
 617                               (start->MajorRadius() / GetUnit()),
 618                               (start->MinorRadius() / GetUnit()));
 619   Standard_Real A, B, C, D, E, F;
 620   E2d.Coefficients(A, C, B, D, E, F);//#59 rln 29.12.98 PRO17015 face 67
 621                                      //gp_Elips2d returns 0.5*K not K
 622
 623   Conic->Init (A, 2 * B, C, 2 * D, 2 * E, F, 0., //#59 rln
 624                gp_XY( Xs/GetUnit(), Ys/GetUnit()),
 625                gp_XY( Xe/GetUnit(), Ye/GetUnit()));
 626
 627
 628   // creation de la Trsf (#124)
 629   // il faut tenir compte de l'unite pour la matrice de transformation
 630   // (partie translation).
 631
 632   if (!Build.IsIdentity()){
 633     Handle(IGESGeom_TransformationMatrix) TMat =
 634       new IGESGeom_TransformationMatrix;
 635     TMat = Build.MakeTransformation(GetUnit());
 636     Conic->InitTransf(TMat);
 637   }
 638   res = Conic;
 639   return res;
 640 }
 641
 642
 643 //=============================================================================
 644 // Transfer des Entites Hyperbola de Geom vers IGES
 645 // TransferCurve
 646 //=============================================================================
 647
 648 Handle(IGESData_IGESEntity) GeomToIGES_GeomCurve::TransferCurve
 649 (const Handle(Geom_Hyperbola)& start, const Standard_Real Udeb,
 650  const Standard_Real Ufin)
 651 {
 652   Handle(IGESData_IGESEntity) res;
 653   if (start.IsNull()) {
 654     return res;
 655   }
 656
 657   Handle(IGESGeom_ConicArc) Conic = new IGESGeom_ConicArc;
 658   IGESConvGeom_GeomBuilder Build;
 659   Standard_Real U1 = Udeb;
 660   Standard_Real U2 = Ufin;
 661   if (Precision::IsNegativeInfinite(Udeb)) U1 = -Precision::Infinite();
 662   if (Precision::IsPositiveInfinite(Ufin)) U2 = Precision::Infinite();
 663
 664 // creation du "ConicArc" (#104)
 665 // -----------------------------
 666   Standard_Real xloc,yloc,zloc;
 667   start->Hypr().Location().Coord(xloc,yloc,zloc);
 668   gp_Pnt Loc;
 669   Loc.SetCoord(xloc, yloc, zloc);
 670   gp_Ax3 Pos = gp_Ax3(start->Hypr().Position());
 671   Pos.SetLocation(Loc);
 672   Build.SetPosition(Pos);
 673
 674   Standard_Real Xs, Ys, Zs;
 675   Standard_Real Xe, Ye, Ze;
 676   Build.EvalXYZ((start->Value(U1)).XYZ(), Xs, Ys, Zs);
 677   Build.EvalXYZ((start->Value(U2)).XYZ(), Xe, Ye, Ze);
 678   gp_Hypr2d H2d = gp_Hypr2d (gp_Ax22d(gp::Origin2d(), gp::DX2d(), gp::DY2d()),
 679                              (start->MajorRadius() / GetUnit()),
 680                              (start->MinorRadius() / GetUnit()));
 681   Standard_Real A, B, C, D, E, F;
 682   H2d.Coefficients(A, C, B, D, E, F);
 683
 684   Conic->Init (A, B, C, D, E, F, 0.,
 685                gp_XY( Xs/GetUnit(), Ys/GetUnit()),
 686                gp_XY( Xe/GetUnit(), Ye/GetUnit()));
 687
 688
 689   // creation de la Trsf (#124)
 690   // il faut tenir compte de l'unite pour la matrice de transformation
 691   // (partie translation).
 692
 693   if (!Build.IsIdentity()){
 694     Handle(IGESGeom_TransformationMatrix) TMat =
 695       new IGESGeom_TransformationMatrix;
 696     TMat = Build.MakeTransformation(GetUnit());
 697     Conic->InitTransf(TMat);
 698   }
 699   res = Conic;
 700   return res;
 701 }
 702
 703
 704 //=============================================================================
 705 // Transfer des Entites Parabola de Geom vers IGES
 706 // TransferCurve
 707 //=============================================================================
 708
 709 Handle(IGESData_IGESEntity) GeomToIGES_GeomCurve::TransferCurve
 710 (const Handle(Geom_Parabola)& start, const Standard_Real Udeb,
 711  const Standard_Real Ufin)
 712 {
 713   Handle(IGESData_IGESEntity) res;
 714   if (start.IsNull()) {
 715     return res;
 716   }
 717
 718   Handle(IGESGeom_ConicArc) Conic = new IGESGeom_ConicArc;
 719   IGESConvGeom_GeomBuilder Build;
 720   Standard_Real U1 = Udeb;
 721   Standard_Real U2 = Ufin;
 722   if (Precision::IsNegativeInfinite(Udeb)) U1 = -Precision::Infinite();
 723   if (Precision::IsPositiveInfinite(Ufin)) U2 = Precision::Infinite();
 724
 725 // creation du "ConicArc" (#104)
 726 // -----------------------------
 727   Standard_Real xloc,yloc,zloc;
 728   start->Parab().Location().Coord(xloc,yloc,zloc);
 729   gp_Pnt Loc;
 730   Loc.SetCoord(xloc, yloc, zloc);
 731   gp_Ax3 Pos = gp_Ax3(start->Parab().Position());
 732   Pos.SetLocation(Loc);
 733   Build.SetPosition(Pos);
 734
 735   Standard_Real Xs, Ys, Zs;
 736   Standard_Real Xe, Ye, Ze;
 737   Build.EvalXYZ((start->Value(U1)).XYZ(), Xs, Ys, Zs);
 738   Build.EvalXYZ((start->Value(U2)).XYZ(), Xe, Ye, Ze);
 739   gp_Parab2d P2d = gp_Parab2d (gp_Ax22d(gp::Origin2d(), gp::DX2d(), gp::DY2d()),
 740                                (start->Focal()*2.));
 741   Standard_Real A, B, C, D, E, F;
 742   P2d.Coefficients(A, C, B, D, E, F);
 743
 744   Conic->Init (A, B, C, D, E, F, 0.,
 745                gp_XY( Xs/GetUnit(), Ys/GetUnit()),
 746                gp_XY( Xe/GetUnit(), Ye/GetUnit()));
 747
 748
 749   // creation de la Trsf (#124)
 750   // il faut tenir compte de l'unite pour la matrice de transformation
 751   // (partie translation).
 752
 753   if (!Build.IsIdentity()){
 754     Handle(IGESGeom_TransformationMatrix) TMat =
 755       new IGESGeom_TransformationMatrix;
 756     TMat = Build.MakeTransformation(GetUnit());
 757     Conic->InitTransf(TMat);
 758   }
 759   res = Conic;
 760   return res;
 761 }
 762
 763
 764 //=============================================================================
 765 // Transfer des Entites Line de Geom vers IGES
 766 // TransferCurve
 767 //=============================================================================
 768
 769 Handle(IGESData_IGESEntity) GeomToIGES_GeomCurve::TransferCurve
 770 (const Handle(Geom_Line)& start, const Standard_Real Udeb,
 771  const Standard_Real Ufin)
 772 {
 773   Handle(IGESData_IGESEntity) res;
 774   if (start.IsNull()) {
 775     return res;
 776   }
 777
 778   Handle(IGESGeom_Line) Line = new IGESGeom_Line;
 779   Standard_Real U1 = Udeb;
 780   Standard_Real U2 = Ufin;
 781   if (Precision::IsNegativeInfinite(Udeb)) U1 = -Precision::Infinite();
 782   if (Precision::IsPositiveInfinite(Ufin)) U2 = Precision::Infinite();
 783
 784 // creation du "Line" (#110)
 785 // -------------------------
 786
 787   Standard_Real X1,Y1,Z1,X2,Y2,Z2;
 788   start->Value(U1).Coord(X1,Y1,Z1);
 789   start->Value(U2).Coord(X2,Y2,Z2);
 790
 791   Line->Init((gp_XYZ(X1/GetUnit(),Y1/GetUnit(),Z1/GetUnit())),
 792              (gp_XYZ(X2/GetUnit(),Y2/GetUnit(),Z2/GetUnit())));
 793   res = Line;
 794   return res;
 795 }
 796
 797
 798 //=============================================================================
 799 // Transfer des Entites OffsetCurve de Geom vers IGES
 800 // TransferCurve
 801 //=============================================================================
 802
 803 Handle(IGESData_IGESEntity) GeomToIGES_GeomCurve::TransferCurve
 804 (const Handle(Geom_OffsetCurve)& start, const Standard_Real Udeb,
 805  const Standard_Real Ufin)
 806 {
 807   Handle(IGESData_IGESEntity) res;
 808   if (start.IsNull()) {
 809     return res;
 810   }
 811
 812   Handle(IGESGeom_OffsetCurve) OffsetC = new IGESGeom_OffsetCurve;
 813   Standard_Real U1 = Udeb;
 814   Standard_Real U2 = Ufin;
 815   if (Precision::IsNegativeInfinite(Udeb)) U1 = -Precision::Infinite();
 816   if (Precision::IsPositiveInfinite(Ufin)) U2 = Precision::Infinite();
 817
 818   if (Interface_Static::IVal("write.iges.offset.mode") == 0)
 819   {
 820     res = TransferCurve(GeomConvert::CurveToBSplineCurve(start),U1,U2);
 821     return res;
 822   }
 823
 824   Handle(Geom_Curve) Curve = start->BasisCurve();
 825   Standard_Real Deb = Curve->FirstParameter();
 826   Standard_Real Fin = Curve->LastParameter();
 827   //%11 pdn 12.01.98 offset curve should be planar
 828   gp_XYZ Normal;
 829   if (!IsPlanar(Curve,Normal)) {
 830     //%11 pdn 12.01.98 protection against exceptions
 831     try{
 832       OCC_CATCH_SIGNALS
 833       res = TransferCurve(GeomConvert::CurveToBSplineCurve(start),U1,U2);
 834       return res;
 835     }
 836     catch(Standard_Failure const& anException) {
 837 #ifdef OCCT_DEBUG
 838       std::cout << "writing non-planar offset curve."<<std::endl;
 839       std::cout << "Warning: GeomConvert::CurveToBSplineCurve raised an exception: ";
 840       anException.Print(std::cout);
 841 #endif
 842       (void)anException;
 843     }
 844   }
 845
 846   Handle(IGESData_IGESEntity) BaseCurve = TransferCurve(Curve, Deb, Fin);
 847   Handle(IGESData_IGESEntity) voident;
 848
 849   OffsetC->Init( BaseCurve, 1,voident, 0, 0, (start->Offset()/GetUnit()), 0.,
 850                 (start->Offset()/GetUnit()), 0.,
 851                 start->Direction().XYZ().Reversed(), U1, U2);  //%11 pdn 12.01.99 // valeur (0,0,1) pour l'instant
 852
 853   res = OffsetC;
 854   return res;
 855 }