| 1 | // Copyright (c) 1999-2012 OPEN CASCADE SAS |
| 2 | // |
| 3 | // The content of this file is subject to the Open CASCADE Technology Public |
| 4 | // License Version 6.5 (the "License"). You may not use the content of this file |
| 5 | // except in compliance with the License. Please obtain a copy of the License |
| 6 | // at http://www.opencascade.org and read it completely before using this file. |
| 7 | // |
| 8 | // The Initial Developer of the Original Code is Open CASCADE S.A.S., having its |
| 9 | // main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France. |
| 10 | // |
| 11 | // The Original Code and all software distributed under the License is |
| 12 | // distributed on an "AS IS" basis, without warranty of any kind, and the |
| 13 | // Initial Developer hereby disclaims all such warranties, including without |
| 14 | // limitation, any warranties of merchantability, fitness for a particular |
| 15 | // purpose or non-infringement. Please see the License for the specific terms |
| 16 | // and conditions governing the rights and limitations under the License. |
| 17 | |
| 18 | #include <Adaptor3d_OffsetCurve.ixx> |
| 19 | |
| 20 | #include <Adaptor3d_HOffsetCurve.hxx> |
| 21 | #include <GeomAbs_SurfaceType.hxx> |
| 22 | #include <Standard_NoSuchObject.hxx> |
| 23 | #include <Standard_NotImplemented.hxx> |
| 24 | #include <gp_VectorWithNullMagnitude.hxx> |
| 25 | #include <Precision.hxx> |
| 26 | #include <gp_Ax22d.hxx> |
| 27 | #include <gp_Dir2d.hxx> |
| 28 | #include <gp.hxx> |
| 29 | |
| 30 | //======================================================================= |
| 31 | //function : Adaptor3d_OffsetCurve |
| 32 | //purpose : |
| 33 | //======================================================================= |
| 34 | |
| 35 | Adaptor3d_OffsetCurve::Adaptor3d_OffsetCurve() : |
| 36 | myOffset( 0.), |
| 37 | myFirst ( 0.), |
| 38 | myLast ( 0.) |
| 39 | {} |
| 40 | |
| 41 | //======================================================================= |
| 42 | //function : Adaptor3d_OffsetCurve |
| 43 | //purpose : |
| 44 | //======================================================================= |
| 45 | |
| 46 | Adaptor3d_OffsetCurve::Adaptor3d_OffsetCurve(const Handle(Adaptor2d_HCurve2d)& C) : |
| 47 | myFirst ( 0.), |
| 48 | myLast ( 0.) |
| 49 | { |
| 50 | Load(C); |
| 51 | } |
| 52 | |
| 53 | //======================================================================= |
| 54 | //function : Adaptor3d_OffsetCurve |
| 55 | //purpose : |
| 56 | //======================================================================= |
| 57 | |
| 58 | Adaptor3d_OffsetCurve::Adaptor3d_OffsetCurve(const Handle(Adaptor2d_HCurve2d)& C, |
| 59 | const Standard_Real Offset) : |
| 60 | myFirst ( 0.), |
| 61 | myLast ( 0.) |
| 62 | { |
| 63 | Load(C); |
| 64 | Load(Offset); |
| 65 | } |
| 66 | |
| 67 | //======================================================================= |
| 68 | //function : Adaptor3d_OffsetCurve |
| 69 | //purpose : |
| 70 | //======================================================================= |
| 71 | |
| 72 | Adaptor3d_OffsetCurve::Adaptor3d_OffsetCurve(const Handle(Adaptor2d_HCurve2d)& C, |
| 73 | const Standard_Real Offset, |
| 74 | const Standard_Real WFirst, |
| 75 | const Standard_Real WLast) |
| 76 | { |
| 77 | Load(C); |
| 78 | Load(Offset,WFirst,WLast); |
| 79 | } |
| 80 | |
| 81 | //======================================================================= |
| 82 | //function : Load |
| 83 | //purpose : |
| 84 | //======================================================================= |
| 85 | |
| 86 | void Adaptor3d_OffsetCurve::Load(const Handle(Adaptor2d_HCurve2d)& C ) |
| 87 | { |
| 88 | myCurve = C; |
| 89 | myOffset = 0.; |
| 90 | } |
| 91 | |
| 92 | //======================================================================= |
| 93 | //function : Load |
| 94 | //purpose : |
| 95 | //======================================================================= |
| 96 | |
| 97 | void Adaptor3d_OffsetCurve::Load( const Standard_Real Offset) |
| 98 | { |
| 99 | myOffset = Offset; |
| 100 | myFirst = myCurve->FirstParameter(); |
| 101 | myLast = myCurve->LastParameter(); |
| 102 | |
| 103 | } |
| 104 | |
| 105 | //======================================================================= |
| 106 | //function : Load |
| 107 | //purpose : |
| 108 | //======================================================================= |
| 109 | |
| 110 | void Adaptor3d_OffsetCurve::Load(const Standard_Real Offset, |
| 111 | const Standard_Real WFirst, |
| 112 | const Standard_Real WLast) |
| 113 | { |
| 114 | myOffset = Offset; |
| 115 | myFirst = WFirst; |
| 116 | myLast = WLast; |
| 117 | } |
| 118 | |
| 119 | //======================================================================= |
| 120 | //function : Continuity |
| 121 | //purpose : |
| 122 | //======================================================================= |
| 123 | |
| 124 | GeomAbs_Shape Adaptor3d_OffsetCurve::Continuity() const |
| 125 | { |
| 126 | switch (myCurve->Continuity()) { |
| 127 | case GeomAbs_CN: return GeomAbs_CN; |
| 128 | case GeomAbs_C3: return GeomAbs_C2; |
| 129 | case GeomAbs_C2: return GeomAbs_G2; |
| 130 | case GeomAbs_G2: return GeomAbs_C1; |
| 131 | case GeomAbs_C1: return GeomAbs_G1; |
| 132 | case GeomAbs_G1: return GeomAbs_C0; |
| 133 | case GeomAbs_C0: |
| 134 | // No Continuity !! |
| 135 | Standard_TypeMismatch::Raise("Adaptor3d_OffsetCurve::IntervalContinuity"); |
| 136 | break; |
| 137 | } |
| 138 | |
| 139 | //portage WNT |
| 140 | return GeomAbs_C0; |
| 141 | } |
| 142 | |
| 143 | //======================================================================= |
| 144 | //function : NbIntervals |
| 145 | //purpose : |
| 146 | //======================================================================= |
| 147 | |
| 148 | Standard_Integer Adaptor3d_OffsetCurve::NbIntervals(const GeomAbs_Shape S) const |
| 149 | { |
| 150 | GeomAbs_Shape Sh; |
| 151 | if ( S >= GeomAbs_C2) Sh = GeomAbs_CN; |
| 152 | else |
| 153 | Sh = (GeomAbs_Shape)((Standard_Integer)S + 2); |
| 154 | |
| 155 | Standard_Integer nbInter = myCurve->NbIntervals(Sh); |
| 156 | |
| 157 | if(nbInter == 1) return nbInter; |
| 158 | |
| 159 | TColStd_Array1OfReal T(1,nbInter+1); |
| 160 | |
| 161 | myCurve->Intervals(T,Sh); |
| 162 | |
| 163 | Standard_Integer first = 1; |
| 164 | while (T(first) <= myFirst) first++; |
| 165 | Standard_Integer last = nbInter+1; |
| 166 | while (T(last) >= myLast) last--; |
| 167 | return (last - first + 2); |
| 168 | } |
| 169 | |
| 170 | //======================================================================= |
| 171 | //function : Intervals |
| 172 | //purpose : |
| 173 | //======================================================================= |
| 174 | |
| 175 | void Adaptor3d_OffsetCurve::Intervals(TColStd_Array1OfReal& TI, |
| 176 | const GeomAbs_Shape S) const |
| 177 | { |
| 178 | GeomAbs_Shape Sh; |
| 179 | if ( S >= GeomAbs_C2) Sh = GeomAbs_CN; |
| 180 | else |
| 181 | Sh = (GeomAbs_Shape)((Standard_Integer)S + 2); |
| 182 | |
| 183 | Standard_Integer nbInter = myCurve->NbIntervals(Sh); |
| 184 | |
| 185 | |
| 186 | if(nbInter == 1) { |
| 187 | TI(TI.Lower()) = myFirst ; |
| 188 | TI(TI.Lower() + 1) = myLast ; |
| 189 | return; |
| 190 | } |
| 191 | |
| 192 | TColStd_Array1OfReal T(1,nbInter+1); |
| 193 | myCurve->Intervals(T,Sh); |
| 194 | |
| 195 | Standard_Integer first = 1; |
| 196 | while (T(first) <= myFirst) first++; |
| 197 | Standard_Integer last = nbInter+1; |
| 198 | while (T(last) >= myLast) last--; |
| 199 | |
| 200 | Standard_Integer i = TI.Lower(), j; |
| 201 | for (j = first-1; j <= last+1; j++) { |
| 202 | TI(i) = T(j); |
| 203 | i++; |
| 204 | } |
| 205 | |
| 206 | TI(TI.Lower()) = myFirst ; |
| 207 | TI(TI.Lower() + last-first + 2) = myLast ; |
| 208 | |
| 209 | } |
| 210 | |
| 211 | |
| 212 | //======================================================================= |
| 213 | //function : Trim |
| 214 | //purpose : |
| 215 | //======================================================================= |
| 216 | |
| 217 | Handle(Adaptor2d_HCurve2d) Adaptor3d_OffsetCurve::Trim |
| 218 | (const Standard_Real First, |
| 219 | const Standard_Real Last, |
| 220 | const Standard_Real) const |
| 221 | { |
| 222 | Handle(Adaptor3d_HOffsetCurve) HO = new Adaptor3d_HOffsetCurve(*this); |
| 223 | HO->ChangeCurve2d().Load(myOffset,First,Last); |
| 224 | return HO; |
| 225 | } |
| 226 | |
| 227 | |
| 228 | //======================================================================= |
| 229 | //function : IsClosed |
| 230 | //purpose : |
| 231 | //======================================================================= |
| 232 | |
| 233 | Standard_Boolean Adaptor3d_OffsetCurve::IsClosed() const |
| 234 | { |
| 235 | if ( myOffset == 0.) { |
| 236 | return myCurve->IsClosed(); |
| 237 | } |
| 238 | else { |
| 239 | if (myCurve->Continuity() == GeomAbs_C0) |
| 240 | return Standard_False; |
| 241 | else { |
| 242 | if ( myCurve->IsClosed()) { |
| 243 | gp_Vec2d Dummy[2]; |
| 244 | gp_Pnt2d P; |
| 245 | myCurve->D1 |
| 246 | (myCurve->FirstParameter(),P,Dummy[0]); |
| 247 | myCurve->D1 |
| 248 | (myCurve->LastParameter(),P,Dummy[1]); |
| 249 | if (Dummy[0].IsParallel(Dummy[1],Precision::Angular()) && |
| 250 | !(Dummy[0].IsOpposite(Dummy[1],Precision::Angular()))) |
| 251 | return Standard_True; |
| 252 | else |
| 253 | return Standard_False; |
| 254 | } |
| 255 | else |
| 256 | return Standard_False; |
| 257 | } |
| 258 | } |
| 259 | } |
| 260 | |
| 261 | //======================================================================= |
| 262 | //function : IsPeriodic |
| 263 | //purpose : |
| 264 | //======================================================================= |
| 265 | |
| 266 | Standard_Boolean Adaptor3d_OffsetCurve::IsPeriodic() const |
| 267 | { |
| 268 | return myCurve->IsPeriodic(); |
| 269 | } |
| 270 | |
| 271 | //======================================================================= |
| 272 | //function : Period |
| 273 | //purpose : |
| 274 | //======================================================================= |
| 275 | |
| 276 | Standard_Real Adaptor3d_OffsetCurve::Period() const |
| 277 | { |
| 278 | return myCurve->Period(); |
| 279 | } |
| 280 | |
| 281 | //======================================================================= |
| 282 | //function : Value |
| 283 | //purpose : |
| 284 | //======================================================================= |
| 285 | |
| 286 | gp_Pnt2d Adaptor3d_OffsetCurve::Value(const Standard_Real U) const |
| 287 | { |
| 288 | if ( myOffset != 0.) { |
| 289 | gp_Pnt2d P; |
| 290 | gp_Vec2d V; |
| 291 | Standard_Real Norme; |
| 292 | myCurve->D1(U, P, V); |
| 293 | Norme = V.Magnitude(); |
| 294 | V.SetCoord(-V.Y(),V.X()); |
| 295 | if (Norme >= gp::Resolution()) { |
| 296 | return gp_Pnt2d(P.XY()+myOffset*V.XY()/Norme); |
| 297 | } |
| 298 | else { |
| 299 | gp_VectorWithNullMagnitude::Raise("Adaptor3d_OffsetCurve::Value"); |
| 300 | return gp_Pnt2d(); |
| 301 | } |
| 302 | } |
| 303 | else { |
| 304 | return myCurve->Value(U); |
| 305 | } |
| 306 | } |
| 307 | |
| 308 | //======================================================================= |
| 309 | //function : D0 |
| 310 | //purpose : |
| 311 | //======================================================================= |
| 312 | |
| 313 | void Adaptor3d_OffsetCurve::D0(const Standard_Real U, gp_Pnt2d& P) const |
| 314 | { |
| 315 | P = Value( U); |
| 316 | } |
| 317 | |
| 318 | //======================================================================= |
| 319 | //function : D1 |
| 320 | //purpose : |
| 321 | //======================================================================= |
| 322 | |
| 323 | void Adaptor3d_OffsetCurve::D1 |
| 324 | (const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& V) const |
| 325 | { |
| 326 | gp_Vec2d V1,V2,V3; |
| 327 | gp_Pnt2d PP; |
| 328 | Standard_Real Norme; |
| 329 | if ( myOffset != 0. ) { |
| 330 | myCurve->D2(U,PP,V1,V2); |
| 331 | Norme = V1.Magnitude(); |
| 332 | V3.SetCoord( -V1.Y(),V1.X()); |
| 333 | V2.SetCoord( -V2.Y(),V2.X()); |
| 334 | if ( Norme >= gp::Resolution()) { |
| 335 | P = gp_Pnt2d( PP.XY()+myOffset*V3.XY()/Norme); |
| 336 | V = gp_Vec2d( V1.XY()+ |
| 337 | (myOffset/Norme)*(V2.XY()-V3.XY()* |
| 338 | (V2.XY()*V3.XY())/(Norme*Norme))); |
| 339 | } |
| 340 | else { |
| 341 | gp_VectorWithNullMagnitude::Raise("Adaptor3d_OffsetCurve::D1"); |
| 342 | } |
| 343 | } |
| 344 | else { |
| 345 | myCurve->D1(U,P,V); |
| 346 | } |
| 347 | } |
| 348 | |
| 349 | //======================================================================= |
| 350 | //function : D2 |
| 351 | //purpose : |
| 352 | //======================================================================= |
| 353 | |
| 354 | void Adaptor3d_OffsetCurve::D2 |
| 355 | (const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& V1, gp_Vec2d& V2) const |
| 356 | { |
| 357 | if ( myOffset != 0.) { |
| 358 | gp_Vec2d T1,T2,T3; |
| 359 | gp_Pnt2d PP; |
| 360 | Standard_Real Norme; |
| 361 | myCurve->D3(U,PP,T1,T2,T3); |
| 362 | |
| 363 | Norme = T1.Magnitude(); |
| 364 | if ( Norme >= gp::Resolution()) { |
| 365 | gp_Vec2d N1,N2,N3; // Ni = Z ^ Ti |
| 366 | N1.SetCoord( -T1.Y(), T1.X()); |
| 367 | N2.SetCoord( -T2.Y(), T2.X()); |
| 368 | N3.SetCoord( -T3.Y(), T3.X()); |
| 369 | Standard_Real d12,d13,d22,Nor3,Nor11; |
| 370 | d12 = T1*T2; |
| 371 | d22 = T2*T2; |
| 372 | d13 = T1*T3; |
| 373 | Nor3 = Norme*Norme*Norme; |
| 374 | Nor11 = Nor3*Nor3*Nor3*Norme*Norme; |
| 375 | V2 = gp_Vec2d( -1 * ( (d22+d13)/Nor3 + 3*d12*d12/Nor11) * N1.XY()); |
| 376 | V2 = gp_Vec2d( V2.XY() - (2*d12/Nor3)*N2.XY() + N3.XY()/Norme); |
| 377 | V2 = gp_Vec2d( myOffset*V2.XY() + T2.XY()); |
| 378 | |
| 379 | D1( U,P,V1); |
| 380 | } |
| 381 | else { |
| 382 | gp_VectorWithNullMagnitude::Raise("Adaptor3d_OffsetCurve::D2"); |
| 383 | } |
| 384 | } |
| 385 | else { |
| 386 | myCurve->D2(U,P,V1,V2); |
| 387 | } |
| 388 | } |
| 389 | |
| 390 | //======================================================================= |
| 391 | //function : D3 |
| 392 | //purpose : |
| 393 | //======================================================================= |
| 394 | |
| 395 | //void Adaptor3d_OffsetCurve::D3 |
| 396 | // (const Standard_Real T, |
| 397 | // gp_Pnt2d& P, gp_Vec2d& V1, gp_Vec2d& V2, gp_Vec2d& V3) const |
| 398 | void Adaptor3d_OffsetCurve::D3 |
| 399 | (const Standard_Real , |
| 400 | gp_Pnt2d& , gp_Vec2d& , gp_Vec2d& , gp_Vec2d& ) const |
| 401 | { |
| 402 | Standard_NotImplemented::Raise("Adaptor3d_OffsetCurve::D3"); |
| 403 | } |
| 404 | |
| 405 | //======================================================================= |
| 406 | //function : DN |
| 407 | //purpose : |
| 408 | //======================================================================= |
| 409 | |
| 410 | gp_Vec2d Adaptor3d_OffsetCurve::DN |
| 411 | // (const Standard_Real T, const Standard_Integer N) const |
| 412 | (const Standard_Real , const Standard_Integer ) const |
| 413 | { |
| 414 | Standard_NotImplemented::Raise("Adaptor3d_OffsetCurve::DN"); |
| 415 | return gp_Vec2d(); |
| 416 | } |
| 417 | |
| 418 | |
| 419 | //======================================================================= |
| 420 | //function : Resolution |
| 421 | //purpose : |
| 422 | //======================================================================= |
| 423 | |
| 424 | Standard_Real Adaptor3d_OffsetCurve::Resolution(const Standard_Real R3d) const |
| 425 | { |
| 426 | return Precision::PConfusion(R3d); |
| 427 | } |
| 428 | |
| 429 | |
| 430 | //======================================================================= |
| 431 | //function : GetType |
| 432 | //purpose : |
| 433 | //======================================================================= |
| 434 | |
| 435 | GeomAbs_CurveType Adaptor3d_OffsetCurve::GetType() const { |
| 436 | |
| 437 | if ( myOffset == 0.) { |
| 438 | return myCurve->GetType(); |
| 439 | } |
| 440 | else { |
| 441 | switch (myCurve->GetType()) { |
| 442 | |
| 443 | case GeomAbs_Line: |
| 444 | return GeomAbs_Line; |
| 445 | |
| 446 | case GeomAbs_Circle: |
| 447 | return GeomAbs_Circle; |
| 448 | |
| 449 | default: |
| 450 | return GeomAbs_OtherCurve; |
| 451 | |
| 452 | } |
| 453 | } |
| 454 | } |
| 455 | |
| 456 | //======================================================================= |
| 457 | //function : Line |
| 458 | //purpose : |
| 459 | //======================================================================= |
| 460 | |
| 461 | gp_Lin2d Adaptor3d_OffsetCurve::Line() const |
| 462 | { |
| 463 | if ( GetType() == GeomAbs_Line) { |
| 464 | gp_Pnt2d P; |
| 465 | gp_Vec2d V; |
| 466 | D1(0,P,V); |
| 467 | return gp_Lin2d(P,V); |
| 468 | } |
| 469 | else { |
| 470 | Standard_NoSuchObject::Raise("Adaptor3d_OffsetCurve::Line"); |
| 471 | return gp_Lin2d(); |
| 472 | } |
| 473 | } |
| 474 | |
| 475 | |
| 476 | //======================================================================= |
| 477 | //function : Circle |
| 478 | //purpose : |
| 479 | //======================================================================= |
| 480 | |
| 481 | gp_Circ2d Adaptor3d_OffsetCurve::Circle() const |
| 482 | { |
| 483 | if ( GetType() == GeomAbs_Circle) { |
| 484 | if (myOffset == 0.) { |
| 485 | return myCurve->Circle(); |
| 486 | } |
| 487 | else { |
| 488 | gp_Circ2d C1( myCurve->Circle()); |
| 489 | Standard_Real radius = C1.Radius(); |
| 490 | gp_Ax22d axes( C1.Axis()); |
| 491 | gp_Dir2d Xd = axes.XDirection(); |
| 492 | gp_Dir2d Yd = axes.YDirection(); |
| 493 | Standard_Real Crossed = Xd.X()*Yd.Y()-Xd.Y()*Yd.X(); |
| 494 | Standard_Real Signe = ( Crossed > 0.) ? 1. : -1.; |
| 495 | |
| 496 | radius += Signe*myOffset; |
| 497 | if ( radius > 0.) { |
| 498 | return gp_Circ2d( axes,radius); |
| 499 | } |
| 500 | else if ( radius < 0.) { |
| 501 | radius = - radius; |
| 502 | axes.SetXDirection( (axes.XDirection()).Reversed()); |
| 503 | return gp_Circ2d( axes,radius); |
| 504 | } |
| 505 | else { // Cercle de rayon Nul |
| 506 | Standard_NoSuchObject::Raise("Adaptor3d_OffsetCurve::Circle"); |
| 507 | } |
| 508 | } |
| 509 | } |
| 510 | else { |
| 511 | Standard_NoSuchObject::Raise("Adaptor3d_OffsetCurve::Circle"); |
| 512 | } |
| 513 | // portage WNT |
| 514 | return gp_Circ2d(); |
| 515 | } |
| 516 | |
| 517 | //======================================================================= |
| 518 | //function : Ellipse |
| 519 | //purpose : |
| 520 | //======================================================================= |
| 521 | |
| 522 | gp_Elips2d Adaptor3d_OffsetCurve::Ellipse() const |
| 523 | { |
| 524 | if (myCurve->GetType() == GeomAbs_Ellipse && myOffset == 0.) { |
| 525 | return myCurve->Ellipse();; |
| 526 | } |
| 527 | else { |
| 528 | Standard_NoSuchObject::Raise("Adaptor3d_OffsetCurve:Ellipse"); |
| 529 | } |
| 530 | // portage WNT |
| 531 | return gp_Elips2d(); |
| 532 | } |
| 533 | |
| 534 | //======================================================================= |
| 535 | //function : Hyperbola |
| 536 | //purpose : |
| 537 | //======================================================================= |
| 538 | |
| 539 | gp_Hypr2d Adaptor3d_OffsetCurve::Hyperbola() const |
| 540 | { |
| 541 | if (myCurve->GetType()==GeomAbs_Hyperbola && myOffset==0.) { |
| 542 | return myCurve->Hyperbola(); |
| 543 | } |
| 544 | else { |
| 545 | Standard_NoSuchObject::Raise("Adaptor3d_OffsetCurve:Hyperbola"); |
| 546 | } |
| 547 | // portage WNT |
| 548 | return gp_Hypr2d(); |
| 549 | } |
| 550 | |
| 551 | //======================================================================= |
| 552 | //function : Parabola |
| 553 | //purpose : |
| 554 | //======================================================================= |
| 555 | |
| 556 | gp_Parab2d Adaptor3d_OffsetCurve::Parabola() const |
| 557 | { |
| 558 | if (myCurve->GetType() == GeomAbs_Parabola && myOffset == 0.) { |
| 559 | return myCurve->Parabola(); |
| 560 | } |
| 561 | else { |
| 562 | Standard_NoSuchObject::Raise("Adaptor3d_OffsetCurve:Parabola"); |
| 563 | } |
| 564 | // portage WNT |
| 565 | return gp_Parab2d(); |
| 566 | } |
| 567 | //======================================================================= |
| 568 | //function : Degree |
| 569 | //purpose : |
| 570 | //======================================================================= |
| 571 | |
| 572 | Standard_Integer Adaptor3d_OffsetCurve::Degree() const |
| 573 | { |
| 574 | GeomAbs_CurveType type = myCurve->GetType(); |
| 575 | if ( (type==GeomAbs_BezierCurve || type==GeomAbs_BSplineCurve) |
| 576 | && myOffset == 0.) { |
| 577 | return myCurve->Degree(); |
| 578 | } |
| 579 | else { |
| 580 | Standard_NoSuchObject::Raise("Adaptor3d_offsetCurve::Degree"); |
| 581 | return 0; |
| 582 | } |
| 583 | } |
| 584 | //======================================================================= |
| 585 | //function : IsRational |
| 586 | //purpose : |
| 587 | //======================================================================= |
| 588 | |
| 589 | Standard_Boolean Adaptor3d_OffsetCurve::IsRational() const |
| 590 | { |
| 591 | if ( myOffset == 0.) { |
| 592 | return myCurve->IsRational(); |
| 593 | } |
| 594 | return Standard_False; |
| 595 | } |
| 596 | //======================================================================= |
| 597 | //function : NbPoles |
| 598 | //purpose : |
| 599 | //======================================================================= |
| 600 | |
| 601 | Standard_Integer Adaptor3d_OffsetCurve::NbPoles() const |
| 602 | { |
| 603 | GeomAbs_CurveType type = myCurve->GetType(); |
| 604 | if ( (type==GeomAbs_BezierCurve || type==GeomAbs_BSplineCurve) |
| 605 | && myOffset == 0.) { |
| 606 | return myCurve->NbPoles(); |
| 607 | } |
| 608 | else { |
| 609 | Standard_NoSuchObject::Raise("Adaptor3d_OffsetCurve::NbPoles"); |
| 610 | return 0; |
| 611 | } |
| 612 | } |
| 613 | |
| 614 | //======================================================================= |
| 615 | //function : NbKnots |
| 616 | //purpose : |
| 617 | //======================================================================= |
| 618 | |
| 619 | Standard_Integer Adaptor3d_OffsetCurve::NbKnots() const |
| 620 | { |
| 621 | if( myOffset == 0.) { |
| 622 | return myCurve->NbKnots(); |
| 623 | } |
| 624 | else { |
| 625 | Standard_NoSuchObject::Raise("Adaptor3d_OffsetCurve::NbKnots"); |
| 626 | return 0; |
| 627 | } |
| 628 | } |
| 629 | |
| 630 | //======================================================================= |
| 631 | //function : Bezier |
| 632 | //purpose : |
| 633 | //======================================================================= |
| 634 | |
| 635 | Handle(Geom2d_BezierCurve) Adaptor3d_OffsetCurve::Bezier() const |
| 636 | { |
| 637 | Standard_NoSuchObject_Raise_if |
| 638 | ( myOffset != 0.0e0 || GetType() != GeomAbs_BezierCurve, ""); |
| 639 | return myCurve->Bezier(); |
| 640 | } |
| 641 | |
| 642 | |
| 643 | //======================================================================= |
| 644 | //function : BSpline |
| 645 | //purpose : |
| 646 | //======================================================================= |
| 647 | |
| 648 | Handle(Geom2d_BSplineCurve) Adaptor3d_OffsetCurve::BSpline() const |
| 649 | { |
| 650 | Standard_NoSuchObject_Raise_if |
| 651 | ( myOffset != 0.0e0 || GetType() != GeomAbs_BSplineCurve, ""); |
| 652 | |
| 653 | return myCurve->BSpline(); |
| 654 | } |
| 655 | |
| 656 | |