1 // Created on: 1993-03-09 2 // Created by: JCV 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 #ifndef _Geom_BSplineCurve_HeaderFile 18 #define _Geom_BSplineCurve_HeaderFile 19 20 #include <Standard.hxx> 21 #include <Standard_Type.hxx> 22 23 #include <Precision.hxx> 24 #include <Standard_Boolean.hxx> 25 #include <GeomAbs_BSplKnotDistribution.hxx> 26 #include <GeomAbs_Shape.hxx> 27 #include <Standard_Integer.hxx> 28 #include <TColgp_HArray1OfPnt.hxx> 29 #include <TColStd_HArray1OfReal.hxx> 30 #include <TColStd_HArray1OfInteger.hxx> 31 #include <Standard_Real.hxx> 32 #include <Geom_BoundedCurve.hxx> 33 #include <TColgp_Array1OfPnt.hxx> 34 #include <TColStd_Array1OfReal.hxx> 35 #include <TColStd_Array1OfInteger.hxx> 36 class Standard_ConstructionError; 37 class Standard_DimensionError; 38 class Standard_DomainError; 39 class Standard_OutOfRange; 40 class Standard_RangeError; 41 class Standard_NoSuchObject; 42 class Geom_UndefinedDerivative; 43 class gp_Pnt; 44 class gp_Vec; 45 class gp_Trsf; 46 class Geom_Geometry; 47 48 49 class Geom_BSplineCurve; 50 DEFINE_STANDARD_HANDLE(Geom_BSplineCurve, Geom_BoundedCurve) 51 52 //! Definition of the B_spline curve. 53 //! A B-spline curve can be 54 //! Uniform or non-uniform 55 //! Rational or non-rational 56 //! Periodic or non-periodic 57 //! 58 //! a b-spline curve is defined by : 59 //! its degree; the degree for a 60 //! Geom_BSplineCurve is limited to a value (25) 61 //! which is defined and controlled by the system. 62 //! This value is returned by the function MaxDegree; 63 //! - its periodic or non-periodic nature; 64 //! - a table of poles (also called control points), with 65 //! their associated weights if the BSpline curve is 66 //! rational. The poles of the curve are "control 67 //! points" used to deform the curve. If the curve is 68 //! non-periodic, the first pole is the start point of 69 //! the curve, and the last pole is the end point of 70 //! the curve. The segment which joins the first pole 71 //! to the second pole is the tangent to the curve at 72 //! its start point, and the segment which joins the 73 //! last pole to the second-from-last pole is the 74 //! tangent to the curve at its end point. If the curve 75 //! is periodic, these geometric properties are not 76 //! verified. It is more difficult to give a geometric 77 //! signification to the weights but are useful for 78 //! providing exact representations of the arcs of a 79 //! circle or ellipse. Moreover, if the weights of all the 80 //! poles are equal, the curve has a polynomial 81 //! equation; it is therefore a non-rational curve. 82 //! - a table of knots with their multiplicities. For a 83 //! Geom_BSplineCurve, the table of knots is an 84 //! increasing sequence of reals without repetition; 85 //! the multiplicities define the repetition of the knots. 86 //! A BSpline curve is a piecewise polynomial or 87 //! rational curve. The knots are the parameters of 88 //! junction points between two pieces. The 89 //! multiplicity Mult(i) of the knot Knot(i) of 90 //! the BSpline curve is related to the degree of 91 //! continuity of the curve at the knot Knot(i), 92 //! which is equal to Degree - Mult(i) 93 //! where Degree is the degree of the BSpline curve. 94 //! If the knots are regularly spaced (i.e. the difference 95 //! between two consecutive knots is a constant), three 96 //! specific and frequently used cases of knot 97 //! distribution can be identified: 98 //! - "uniform" if all multiplicities are equal to 1, 99 //! - "quasi-uniform" if all multiplicities are equal to 1, 100 //! except the first and the last knot which have a 101 //! multiplicity of Degree + 1, where Degree is 102 //! the degree of the BSpline curve, 103 //! - "Piecewise Bezier" if all multiplicities are equal to 104 //! Degree except the first and last knot which 105 //! have a multiplicity of Degree + 1, where 106 //! Degree is the degree of the BSpline curve. A 107 //! curve of this type is a concatenation of arcs of Bezier curves. 108 //! If the BSpline curve is not periodic: 109 //! - the bounds of the Poles and Weights tables are 1 110 //! and NbPoles, where NbPoles is the number 111 //! of poles of the BSpline curve, 112 //! - the bounds of the Knots and Multiplicities tables 113 //! are 1 and NbKnots, where NbKnots is the 114 //! number of knots of the BSpline curve. 115 //! If the BSpline curve is periodic, and if there are k 116 //! periodic knots and p periodic poles, the period is: 117 //! period = Knot(k + 1) - Knot(1) 118 //! and the poles and knots tables can be considered 119 //! as infinite tables, verifying: 120 //! - Knot(i+k) = Knot(i) + period 121 //! - Pole(i+p) = Pole(i) 122 //! Note: data structures of a periodic BSpline curve 123 //! are more complex than those of a non-periodic one. 124 //! Warning 125 //! In this class, weight value is considered to be zero if 126 //! the weight is less than or equal to gp::Resolution(). 127 //! 128 //! References : 129 //! . A survey of curve and surface methods in CADG Wolfgang BOHM 130 //! CAGD 1 (1984) 131 //! . On de Boor-like algorithms and blossoming Wolfgang BOEHM 132 //! cagd 5 (1988) 133 //! . Blossoming and knot insertion algorithms for B-spline curves 134 //! Ronald N. GOLDMAN 135 //! . Modelisation des surfaces en CAO, Henri GIAUME Peugeot SA 136 //! . Curves and Surfaces for Computer Aided Geometric Design, 137 //! a practical guide Gerald Farin 138 class Geom_BSplineCurve : public Geom_BoundedCurve 139 { 140 141 public: 142 143 144 //! Creates a non-rational B_spline curve on the 145 //! basis <Knots, Multiplicities> of degree <Degree>. 146 Standard_EXPORT Geom_BSplineCurve(const TColgp_Array1OfPnt& Poles, const TColStd_Array1OfReal& Knots, const TColStd_Array1OfInteger& Multiplicities, const Standard_Integer Degree, const Standard_Boolean Periodic = Standard_False); 147 148 //! Creates a rational B_spline curve on the basis 149 //! <Knots, Multiplicities> of degree <Degree>. 150 //! Raises ConstructionError subject to the following conditions 151 //! 0 < Degree <= MaxDegree. 152 //! 153 //! Weights.Length() == Poles.Length() 154 //! 155 //! Knots.Length() == Mults.Length() >= 2 156 //! 157 //! Knots(i) < Knots(i+1) (Knots are increasing) 158 //! 159 //! 1 <= Mults(i) <= Degree 160 //! 161 //! On a non periodic curve the first and last multiplicities 162 //! may be Degree+1 (this is even recommanded if you want the 163 //! curve to start and finish on the first and last pole). 164 //! 165 //! On a periodic curve the first and the last multicities 166 //! must be the same. 167 //! 168 //! on non-periodic curves 169 //! 170 //! Poles.Length() == Sum(Mults(i)) - Degree - 1 >= 2 171 //! 172 //! on periodic curves 173 //! 174 //! Poles.Length() == Sum(Mults(i)) except the first or last 175 Standard_EXPORT Geom_BSplineCurve(const TColgp_Array1OfPnt& Poles, const TColStd_Array1OfReal& Weights, const TColStd_Array1OfReal& Knots, const TColStd_Array1OfInteger& Multiplicities, const Standard_Integer Degree, const Standard_Boolean Periodic = Standard_False, const Standard_Boolean CheckRational = Standard_True); 176 177 //! Increases the degree of this BSpline curve to 178 //! Degree. As a result, the poles, weights and 179 //! multiplicities tables are modified; the knots table is 180 //! not changed. Nothing is done if Degree is less than 181 //! or equal to the current degree. 182 //! Exceptions 183 //! Standard_ConstructionError if Degree is greater than 184 //! Geom_BSplineCurve::MaxDegree(). 185 Standard_EXPORT void IncreaseDegree (const Standard_Integer Degree); 186 187 //! Increases the multiplicity of the knot <Index> to 188 //! <M>. 189 //! 190 //! If <M> is lower or equal to the current 191 //! multiplicity nothing is done. If <M> is higher than 192 //! the degree the degree is used. 193 //! If <Index> is not in [FirstUKnotIndex, LastUKnotIndex] 194 Standard_EXPORT void IncreaseMultiplicity (const Standard_Integer Index, const Standard_Integer M); 195 196 //! Increases the multiplicities of the knots in 197 //! [I1,I2] to <M>. 198 //! 199 //! For each knot if <M> is lower or equal to the 200 //! current multiplicity nothing is done. If <M> is 201 //! higher than the degree the degree is used. 202 //! If <I1,I2> are not in [FirstUKnotIndex, LastUKnotIndex] 203 Standard_EXPORT void IncreaseMultiplicity (const Standard_Integer I1, const Standard_Integer I2, const Standard_Integer M); 204 205 //! Increment the multiplicities of the knots in 206 //! [I1,I2] by <M>. 207 //! 208 //! If <M> is not positive nithing is done. 209 //! 210 //! For each knot the resulting multiplicity is 211 //! limited to the Degree. 212 //! If <I1,I2> are not in [FirstUKnotIndex, LastUKnotIndex] 213 Standard_EXPORT void IncrementMultiplicity (const Standard_Integer I1, const Standard_Integer I2, const Standard_Integer M); 214 215 //! Inserts a knot value in the sequence of knots. If 216 //! <U> is an existing knot the multiplicity is 217 //! increased by <M>. 218 //! 219 //! If U is not on the parameter range nothing is 220 //! done. 221 //! 222 //! If the multiplicity is negative or null nothing is 223 //! done. The new multiplicity is limited to the 224 //! degree. 225 //! 226 //! The tolerance criterion for knots equality is 227 //! the max of Epsilon(U) and ParametricTolerance. 228 Standard_EXPORT void InsertKnot (const Standard_Real U, const Standard_Integer M = 1, const Standard_Real ParametricTolerance = 0.0, const Standard_Boolean Add = Standard_True); 229 230 //! Inserts a set of knots values in the sequence of 231 //! knots. 232 //! 233 //! For each U = Knots(i), M = Mults(i) 234 //! 235 //! If <U> is an existing knot the multiplicity is 236 //! increased by <M> if <Add> is True, increased to 237 //! <M> if <Add> is False. 238 //! 239 //! If U is not on the parameter range nothing is 240 //! done. 241 //! 242 //! If the multiplicity is negative or null nothing is 243 //! done. The new multiplicity is limited to the 244 //! degree. 245 //! 246 //! The tolerance criterion for knots equality is 247 //! the max of Epsilon(U) and ParametricTolerance. 248 Standard_EXPORT void InsertKnots (const TColStd_Array1OfReal& Knots, const TColStd_Array1OfInteger& Mults, const Standard_Real ParametricTolerance = 0.0, const Standard_Boolean Add = Standard_False); 249 250 //! Reduces the multiplicity of the knot of index Index 251 //! to M. If M is equal to 0, the knot is removed. 252 //! With a modification of this type, the array of poles is also modified. 253 //! Two different algorithms are systematically used to 254 //! compute the new poles of the curve. If, for each 255 //! pole, the distance between the pole calculated 256 //! using the first algorithm and the same pole 257 //! calculated using the second algorithm, is less than 258 //! Tolerance, this ensures that the curve is not 259 //! modified by more than Tolerance. Under these 260 //! conditions, true is returned; otherwise, false is returned. 261 //! A low tolerance is used to prevent modification of 262 //! the curve. A high tolerance is used to "smooth" the curve. 263 //! Exceptions 264 //! Standard_OutOfRange if Index is outside the 265 //! bounds of the knots table. 266 //! pole insertion and pole removing 267 //! this operation is limited to the Uniform or QuasiUniform 268 //! BSplineCurve. The knot values are modified . If the BSpline is 269 //! NonUniform or Piecewise Bezier an exception Construction error 270 //! is raised. 271 Standard_EXPORT Standard_Boolean RemoveKnot (const Standard_Integer Index, const Standard_Integer M, const Standard_Real Tolerance); 272 273 274 //! Changes the direction of parametrization of <me>. The Knot 275 //! sequence is modified, the FirstParameter and the 276 //! LastParameter are not modified. The StartPoint of the 277 //! initial curve becomes the EndPoint of the reversed curve 278 //! and the EndPoint of the initial curve becomes the StartPoint 279 //! of the reversed curve. 280 Standard_EXPORT void Reverse() Standard_OVERRIDE; 281 282 //! Returns the parameter on the reversed curve for 283 //! the point of parameter U on <me>. 284 //! 285 //! returns UFirst + ULast - U 286 Standard_EXPORT Standard_Real ReversedParameter (const Standard_Real U) const Standard_OVERRIDE; 287 288 //! Modifies this BSpline curve by segmenting it between 289 //! U1 and U2. Either of these values can be outside the 290 //! bounds of the curve, but U2 must be greater than U1. 291 //! All data structure tables of this BSpline curve are 292 //! modified, but the knots located between U1 and U2 293 //! are retained. The degree of the curve is not modified. 294 //! 295 //! Parameter theTolerance defines the possible proximity of the segment 296 //! boundaries and B-spline knots to treat them as equal. 297 //! 298 //! Warnings : 299 //! Even if <me> is not closed it can become closed after the 300 //! segmentation for example if U1 or U2 are out of the bounds 301 //! of the curve <me> or if the curve makes loop. 302 //! After the segmentation the length of a curve can be null. 303 //! raises if U2 < U1. 304 //! Standard_DomainError if U2 - U1 exceeds the period for periodic curves. 305 //! i.e. ((U2 - U1) - Period) > Precision::PConfusion(). 306 Standard_EXPORT void Segment (const Standard_Real U1, const Standard_Real U2, 307 const Standard_Real theTolerance = Precision::PConfusion()); 308 309 //! Modifies this BSpline curve by assigning the value K 310 //! to the knot of index Index in the knots table. This is a 311 //! relatively local modification because K must be such that: 312 //! Knots(Index - 1) < K < Knots(Index + 1) 313 //! The second syntax allows you also to increase the 314 //! multiplicity of the knot to M (but it is not possible to 315 //! decrease the multiplicity of the knot with this function). 316 //! Standard_ConstructionError if: 317 //! - K is not such that: 318 //! Knots(Index - 1) < K < Knots(Index + 1) 319 //! - M is greater than the degree of this BSpline curve 320 //! or lower than the previous multiplicity of knot of 321 //! index Index in the knots table. 322 //! Standard_OutOfRange if Index is outside the bounds of the knots table. 323 Standard_EXPORT void SetKnot (const Standard_Integer Index, const Standard_Real K); 324 325 //! Modifies this BSpline curve by assigning the array 326 //! K to its knots table. The multiplicity of the knots is not modified. 327 //! Exceptions 328 //! Standard_ConstructionError if the values in the 329 //! array K are not in ascending order. 330 //! Standard_OutOfRange if the bounds of the array 331 //! K are not respectively 1 and the number of knots of this BSpline curve. 332 Standard_EXPORT void SetKnots (const TColStd_Array1OfReal& K); 333 334 335 //! Changes the knot of range Index with its multiplicity. 336 //! You can increase the multiplicity of a knot but it is 337 //! not allowed to decrease the multiplicity of an existing knot. 338 //! 339 //! Raised if K >= Knots(Index+1) or K <= Knots(Index-1). 340 //! Raised if M is greater than Degree or lower than the previous 341 //! multiplicity of knot of range Index. 342 //! Raised if Index < 1 || Index > NbKnots 343 Standard_EXPORT void SetKnot (const Standard_Integer Index, const Standard_Real K, const Standard_Integer M); 344 345 //! returns the parameter normalized within 346 //! the period if the curve is periodic : otherwise 347 //! does not do anything 348 Standard_EXPORT void PeriodicNormalization (Standard_Real& U) const; 349 350 //! Changes this BSpline curve into a periodic curve. 351 //! To become periodic, the curve must first be closed. 352 //! Next, the knot sequence must be periodic. For this, 353 //! FirstUKnotIndex and LastUKnotIndex are used 354 //! to compute I1 and I2, the indexes in the knots 355 //! array of the knots corresponding to the first and 356 //! last parameters of this BSpline curve. 357 //! The period is therefore: Knots(I2) - Knots(I1). 358 //! Consequently, the knots and poles tables are modified. 359 //! Exceptions 360 //! Standard_ConstructionError if this BSpline curve is not closed. 361 Standard_EXPORT void SetPeriodic(); 362 363 //! Assigns the knot of index Index in the knots table as 364 //! the origin of this periodic BSpline curve. As a 365 //! consequence, the knots and poles tables are modified. 366 //! Exceptions 367 //! Standard_NoSuchObject if this curve is not periodic. 368 //! Standard_DomainError if Index is outside the bounds of the knots table. 369 Standard_EXPORT void SetOrigin (const Standard_Integer Index); 370 371 //! Set the origin of a periodic curve at Knot U. If U 372 //! is not a knot of the BSpline a new knot is 373 //! inseted. KnotVector and poles are modified. 374 //! Raised if the curve is not periodic 375 Standard_EXPORT void SetOrigin (const Standard_Real U, const Standard_Real Tol); 376 377 //! Changes this BSpline curve into a non-periodic 378 //! curve. If this curve is already non-periodic, it is not modified. 379 //! Note: the poles and knots tables are modified. 380 //! Warning 381 //! If this curve is periodic, as the multiplicity of the first 382 //! and last knots is not modified, and is not equal to 383 //! Degree + 1, where Degree is the degree of 384 //! this BSpline curve, the start and end points of the 385 //! curve are not its first and last poles. 386 Standard_EXPORT void SetNotPeriodic(); 387 388 //! Modifies this BSpline curve by assigning P to the pole 389 //! of index Index in the poles table. 390 //! Exceptions 391 //! Standard_OutOfRange if Index is outside the 392 //! bounds of the poles table. 393 //! Standard_ConstructionError if Weight is negative or null. 394 Standard_EXPORT void SetPole (const Standard_Integer Index, const gp_Pnt& P); 395 396 //! Modifies this BSpline curve by assigning P to the pole 397 //! of index Index in the poles table. 398 //! This syntax also allows you to modify the 399 //! weight of the modified pole, which becomes Weight. 400 //! In this case, if this BSpline curve is non-rational, it 401 //! can become rational and vice versa. 402 //! Exceptions 403 //! Standard_OutOfRange if Index is outside the 404 //! bounds of the poles table. 405 //! Standard_ConstructionError if Weight is negative or null. 406 Standard_EXPORT void SetPole (const Standard_Integer Index, const gp_Pnt& P, const Standard_Real Weight); 407 408 409 //! Changes the weight for the pole of range Index. 410 //! If the curve was non rational it can become rational. 411 //! If the curve was rational it can become non rational. 412 //! 413 //! Raised if Index < 1 || Index > NbPoles 414 //! Raised if Weight <= 0.0 415 Standard_EXPORT void SetWeight (const Standard_Integer Index, const Standard_Real Weight); 416 417 //! Moves the point of parameter U of this BSpline curve 418 //! to P. Index1 and Index2 are the indexes in the table 419 //! of poles of this BSpline curve of the first and last 420 //! poles designated to be moved. 421 //! FirstModifiedPole and LastModifiedPole are the 422 //! indexes of the first and last poles which are effectively modified. 423 //! In the event of incompatibility between Index1, Index2 and the value U: 424 //! - no change is made to this BSpline curve, and 425 //! - the FirstModifiedPole and LastModifiedPole are returned null. 426 //! Exceptions 427 //! Standard_OutOfRange if: 428 //! - Index1 is greater than or equal to Index2, or 429 //! - Index1 or Index2 is less than 1 or greater than the 430 //! number of poles of this BSpline curve. 431 Standard_EXPORT void MovePoint (const Standard_Real U, const gp_Pnt& P, const Standard_Integer Index1, const Standard_Integer Index2, Standard_Integer& FirstModifiedPole, Standard_Integer& LastModifiedPole); 432 433 434 //! Move a point with parameter U to P. 435 //! and makes it tangent at U be Tangent. 436 //! StartingCondition = -1 means first can move 437 //! EndingCondition = -1 means last point can move 438 //! StartingCondition = 0 means the first point cannot move 439 //! EndingCondition = 0 means the last point cannot move 440 //! StartingCondition = 1 means the first point and tangent cannot move 441 //! EndingCondition = 1 means the last point and tangent cannot move 442 //! and so forth 443 //! ErrorStatus != 0 means that there are not enought degree of freedom 444 //! with the constrain to deform the curve accordingly 445 Standard_EXPORT void MovePointAndTangent (const Standard_Real U, const gp_Pnt& P, const gp_Vec& Tangent, const Standard_Real Tolerance, const Standard_Integer StartingCondition, const Standard_Integer EndingCondition, Standard_Integer& ErrorStatus); 446 447 448 //! Returns the continuity of the curve, the curve is at least C0. 449 //! Raised if N < 0. 450 Standard_EXPORT Standard_Boolean IsCN (const Standard_Integer N) const Standard_OVERRIDE; 451 452 453 //! Check if curve has at least G1 continuity in interval [theTf, theTl] 454 //! Returns true if IsCN(1) 455 //! or 456 //! angle betweem "left" and "right" first derivatives at 457 //! knots with C0 continuity is less then theAngTol 458 //! only knots in interval [theTf, theTl] is checked 459 Standard_EXPORT Standard_Boolean IsG1 (const Standard_Real theTf, const Standard_Real theTl, const Standard_Real theAngTol) const; 460 461 462 //! Returns true if the distance between the first point and the 463 //! last point of the curve is lower or equal to Resolution 464 //! from package gp. 465 //! Warnings : 466 //! The first and the last point can be different from the first 467 //! pole and the last pole of the curve. 468 Standard_EXPORT Standard_Boolean IsClosed() const Standard_OVERRIDE; 469 470 //! Returns True if the curve is periodic. 471 Standard_EXPORT Standard_Boolean IsPeriodic() const Standard_OVERRIDE; 472 473 474 //! Returns True if the weights are not identical. 475 //! The tolerance criterion is Epsilon of the class Real. 476 Standard_EXPORT Standard_Boolean IsRational() const; 477 478 479 //! Returns the global continuity of the curve : 480 //! C0 : only geometric continuity, 481 //! C1 : continuity of the first derivative all along the Curve, 482 //! C2 : continuity of the second derivative all along the Curve, 483 //! C3 : continuity of the third derivative all along the Curve, 484 //! CN : the order of continuity is infinite. 485 //! For a B-spline curve of degree d if a knot Ui has a 486 //! multiplicity p the B-spline curve is only Cd-p continuous 487 //! at Ui. So the global continuity of the curve can't be greater 488 //! than Cd-p where p is the maximum multiplicity of the interior 489 //! Knots. In the interior of a knot span the curve is infinitely 490 //! continuously differentiable. 491 Standard_EXPORT GeomAbs_Shape Continuity() const Standard_OVERRIDE; 492 493 //! Returns the degree of this BSpline curve. 494 //! The degree of a Geom_BSplineCurve curve cannot 495 //! be greater than Geom_BSplineCurve::MaxDegree(). 496 //! Computation of value and derivatives 497 Standard_EXPORT Standard_Integer Degree() const; 498 499 //! Returns in P the point of parameter U. 500 Standard_EXPORT void D0 (const Standard_Real U, gp_Pnt& P) const Standard_OVERRIDE; 501 502 //! Raised if the continuity of the curve is not C1. 503 Standard_EXPORT void D1 (const Standard_Real U, gp_Pnt& P, gp_Vec& V1) const Standard_OVERRIDE; 504 505 //! Raised if the continuity of the curve is not C2. 506 Standard_EXPORT void D2 (const Standard_Real U, gp_Pnt& P, gp_Vec& V1, gp_Vec& V2) const Standard_OVERRIDE; 507 508 //! Raised if the continuity of the curve is not C3. 509 Standard_EXPORT void D3 (const Standard_Real U, gp_Pnt& P, gp_Vec& V1, gp_Vec& V2, gp_Vec& V3) const Standard_OVERRIDE; 510 511 //! For the point of parameter U of this BSpline curve, 512 //! computes the vector corresponding to the Nth derivative. 513 //! Warning 514 //! On a point where the continuity of the curve is not the 515 //! one requested, this function impacts the part defined 516 //! by the parameter with a value greater than U, i.e. the 517 //! part of the curve to the "right" of the singularity. 518 //! Exceptions 519 //! Standard_RangeError if N is less than 1. 520 //! 521 //! The following functions compute the point of parameter U 522 //! and the derivatives at this point on the B-spline curve 523 //! arc defined between the knot FromK1 and the knot ToK2. 524 //! U can be out of bounds [Knot (FromK1), Knot (ToK2)] but 525 //! for the computation we only use the definition of the curve 526 //! between these two knots. This method is useful to compute 527 //! local derivative, if the order of continuity of the whole 528 //! curve is not greater enough. Inside the parametric 529 //! domain Knot (FromK1), Knot (ToK2) the evaluations are 530 //! the same as if we consider the whole definition of the 531 //! curve. Of course the evaluations are different outside 532 //! this parametric domain. 533 Standard_EXPORT gp_Vec DN (const Standard_Real U, const Standard_Integer N) const Standard_OVERRIDE; 534 535 //! Raised if FromK1 = ToK2. 536 Standard_EXPORT gp_Pnt LocalValue (const Standard_Real U, const Standard_Integer FromK1, const Standard_Integer ToK2) const; 537 538 //! Raised if FromK1 = ToK2. 539 Standard_EXPORT void LocalD0 (const Standard_Real U, const Standard_Integer FromK1, const Standard_Integer ToK2, gp_Pnt& P) const; 540 541 542 //! Raised if the local continuity of the curve is not C1 543 //! between the knot K1 and the knot K2. 544 //! Raised if FromK1 = ToK2. 545 Standard_EXPORT void LocalD1 (const Standard_Real U, const Standard_Integer FromK1, const Standard_Integer ToK2, gp_Pnt& P, gp_Vec& V1) const; 546 547 548 //! Raised if the local continuity of the curve is not C2 549 //! between the knot K1 and the knot K2. 550 //! Raised if FromK1 = ToK2. 551 Standard_EXPORT void LocalD2 (const Standard_Real U, const Standard_Integer FromK1, const Standard_Integer ToK2, gp_Pnt& P, gp_Vec& V1, gp_Vec& V2) const; 552 553 554 //! Raised if the local continuity of the curve is not C3 555 //! between the knot K1 and the knot K2. 556 //! Raised if FromK1 = ToK2. 557 Standard_EXPORT void LocalD3 (const Standard_Real U, const Standard_Integer FromK1, const Standard_Integer ToK2, gp_Pnt& P, gp_Vec& V1, gp_Vec& V2, gp_Vec& V3) const; 558 559 560 //! Raised if the local continuity of the curve is not CN 561 //! between the knot K1 and the knot K2. 562 //! Raised if FromK1 = ToK2. 563 //! Raised if N < 1. 564 Standard_EXPORT gp_Vec LocalDN (const Standard_Real U, const Standard_Integer FromK1, const Standard_Integer ToK2, const Standard_Integer N) const; 565 566 567 //! Returns the last point of the curve. 568 //! Warnings : 569 //! The last point of the curve is different from the last 570 //! pole of the curve if the multiplicity of the last knot 571 //! is lower than Degree. 572 Standard_EXPORT gp_Pnt EndPoint() const Standard_OVERRIDE; 573 574 //! Returns the index in the knot array of the knot 575 //! corresponding to the first or last parameter of this BSpline curve. 576 //! For a BSpline curve, the first (or last) parameter 577 //! (which gives the start (or end) point of the curve) is a 578 //! knot value. However, if the multiplicity of the first (or 579 //! last) knot is less than Degree + 1, where 580 //! Degree is the degree of the curve, it is not the first 581 //! (or last) knot of the curve. 582 Standard_EXPORT Standard_Integer FirstUKnotIndex() const; 583 584 //! Returns the value of the first parameter of this 585 //! BSpline curve. This is a knot value. 586 //! The first parameter is the one of the start point of the BSpline curve. 587 Standard_EXPORT Standard_Real FirstParameter() const Standard_OVERRIDE; 588 589 590 //! Returns the knot of range Index. When there is a knot 591 //! with a multiplicity greater than 1 the knot is not repeated. 592 //! The method Multiplicity can be used to get the multiplicity 593 //! of the Knot. 594 //! Raised if Index < 1 or Index > NbKnots 595 Standard_EXPORT Standard_Real Knot (const Standard_Integer Index) const; 596 597 //! returns the knot values of the B-spline curve; 598 //! Warning 599 //! A knot with a multiplicity greater than 1 is not 600 //! repeated in the knot table. The Multiplicity function 601 //! can be used to obtain the multiplicity of each knot. 602 //! 603 //! Raised K.Lower() is less than number of first knot or 604 //! K.Upper() is more than number of last knot. 605 Standard_EXPORT void Knots (TColStd_Array1OfReal& K) const; 606 607 //! returns the knot values of the B-spline curve; 608 //! Warning 609 //! A knot with a multiplicity greater than 1 is not 610 //! repeated in the knot table. The Multiplicity function 611 //! can be used to obtain the multiplicity of each knot. 612 Standard_EXPORT const TColStd_Array1OfReal& Knots() const; 613 614 //! Returns K, the knots sequence of this BSpline curve. 615 //! In this sequence, knots with a multiplicity greater than 1 are repeated. 616 //! In the case of a non-periodic curve the length of the 617 //! sequence must be equal to the sum of the NbKnots 618 //! multiplicities of the knots of the curve (where 619 //! NbKnots is the number of knots of this BSpline 620 //! curve). This sum is also equal to : NbPoles + Degree + 1 621 //! where NbPoles is the number of poles and 622 //! Degree the degree of this BSpline curve. 623 //! In the case of a periodic curve, if there are k periodic 624 //! knots, the period is Knot(k+1) - Knot(1). 625 //! The initial sequence is built by writing knots 1 to k+1, 626 //! which are repeated according to their corresponding multiplicities. 627 //! If Degree is the degree of the curve, the degree of 628 //! continuity of the curve at the knot of index 1 (or k+1) 629 //! is equal to c = Degree + 1 - Mult(1). c 630 //! knots are then inserted at the beginning and end of 631 //! the initial sequence: 632 //! - the c values of knots preceding the first item 633 //! Knot(k+1) in the initial sequence are inserted 634 //! at the beginning; the period is subtracted from these c values; 635 //! - the c values of knots following the last item 636 //! Knot(1) in the initial sequence are inserted at 637 //! the end; the period is added to these c values. 638 //! The length of the sequence must therefore be equal to: 639 //! NbPoles + 2*Degree - Mult(1) + 2. 640 //! Example 641 //! For a non-periodic BSpline curve of degree 2 where: 642 //! - the array of knots is: { k1 k2 k3 k4 }, 643 //! - with associated multiplicities: { 3 1 2 3 }, 644 //! the knot sequence is: 645 //! K = { k1 k1 k1 k2 k3 k3 k4 k4 k4 } 646 //! For a periodic BSpline curve of degree 4 , which is 647 //! "C1" continuous at the first knot, and where : 648 //! - the periodic knots are: { k1 k2 k3 (k4) } 649 //! (3 periodic knots: the points of parameter k1 and k4 650 //! are identical, the period is p = k4 - k1), 651 //! - with associated multiplicities: { 3 1 2 (3) }, 652 //! the degree of continuity at knots k1 and k4 is: 653 //! Degree + 1 - Mult(i) = 2. 654 //! 2 supplementary knots are added at the beginning 655 //! and end of the sequence: 656 //! - at the beginning: the 2 knots preceding k4 minus 657 //! the period; in this example, this is k3 - p both times; 658 //! - at the end: the 2 knots following k1 plus the period; 659 //! in this example, this is k2 + p and k3 + p. 660 //! The knot sequence is therefore: 661 //! K = { k3-p k3-p k1 k1 k1 k2 k3 k3 662 //! k4 k4 k4 k2+p k3+p } 663 //! Exceptions 664 //! Raised if K.Lower() is less than number of first knot 665 //! in knot sequence with repetitions or K.Upper() is more 666 //! than number of last knot in knot sequence with repetitions. 667 Standard_EXPORT void KnotSequence (TColStd_Array1OfReal& K) const; 668 669 //! returns the knots of the B-spline curve. 670 //! Knots with multiplicit greater than 1 are repeated 671 Standard_EXPORT const TColStd_Array1OfReal& KnotSequence() const; 672 673 674 //! Returns NonUniform or Uniform or QuasiUniform or PiecewiseBezier. 675 //! If all the knots differ by a positive constant from the 676 //! preceding knot the BSpline Curve can be : 677 //! - Uniform if all the knots are of multiplicity 1, 678 //! - QuasiUniform if all the knots are of multiplicity 1 except for 679 //! the first and last knot which are of multiplicity Degree + 1, 680 //! - PiecewiseBezier if the first and last knots have multiplicity 681 //! Degree + 1 and if interior knots have multiplicity Degree 682 //! A piecewise Bezier with only two knots is a BezierCurve. 683 //! else the curve is non uniform. 684 //! The tolerance criterion is Epsilon from class Real. 685 Standard_EXPORT GeomAbs_BSplKnotDistribution KnotDistribution() const; 686 687 688 //! For a BSpline curve the last parameter (which gives the 689 //! end point of the curve) is a knot value but if the 690 //! multiplicity of the last knot index is lower than 691 //! Degree + 1 it is not the last knot of the curve. This 692 //! method computes the index of the knot corresponding to 693 //! the last parameter. 694 Standard_EXPORT Standard_Integer LastUKnotIndex() const; 695 696 697 //! Computes the parametric value of the end point of the curve. 698 //! It is a knot value. 699 Standard_EXPORT Standard_Real LastParameter() const Standard_OVERRIDE; 700 701 702 //! Locates the parametric value U in the sequence of knots. 703 //! If "WithKnotRepetition" is True we consider the knot's 704 //! representation with repetition of multiple knot value, 705 //! otherwise we consider the knot's representation with 706 //! no repetition of multiple knot values. 707 //! Knots (I1) <= U <= Knots (I2) 708 //! . if I1 = I2 U is a knot value (the tolerance criterion 709 //! ParametricTolerance is used). 710 //! . if I1 < 1 => U < Knots (1) - Abs(ParametricTolerance) 711 //! . if I2 > NbKnots => U > Knots (NbKnots) + Abs(ParametricTolerance) 712 Standard_EXPORT void LocateU (const Standard_Real U, const Standard_Real ParametricTolerance, Standard_Integer& I1, Standard_Integer& I2, const Standard_Boolean WithKnotRepetition = Standard_False) const; 713 714 715 //! Returns the multiplicity of the knots of range Index. 716 //! Raised if Index < 1 or Index > NbKnots 717 Standard_EXPORT Standard_Integer Multiplicity (const Standard_Integer Index) const; 718 719 720 //! Returns the multiplicity of the knots of the curve. 721 //! 722 //! Raised if the length of M is not equal to NbKnots. 723 Standard_EXPORT void Multiplicities (TColStd_Array1OfInteger& M) const; 724 725 //! returns the multiplicity of the knots of the curve. 726 Standard_EXPORT const TColStd_Array1OfInteger& Multiplicities() const; 727 728 729 //! Returns the number of knots. This method returns the number of 730 //! knot without repetition of multiple knots. 731 Standard_EXPORT Standard_Integer NbKnots() const; 732 733 //! Returns the number of poles 734 Standard_EXPORT Standard_Integer NbPoles() const; 735 736 //! Returns the pole of range Index. 737 //! Raised if Index < 1 or Index > NbPoles. 738 Standard_EXPORT const gp_Pnt& Pole(const Standard_Integer Index) const; 739 740 //! Returns the poles of the B-spline curve; 741 //! 742 //! Raised if the length of P is not equal to the number of poles. 743 Standard_EXPORT void Poles (TColgp_Array1OfPnt& P) const; 744 745 //! Returns the poles of the B-spline curve; 746 Standard_EXPORT const TColgp_Array1OfPnt& Poles() const; 747 748 749 //! Returns the start point of the curve. 750 //! Warnings : 751 //! This point is different from the first pole of the curve if the 752 //! multiplicity of the first knot is lower than Degree. 753 Standard_EXPORT gp_Pnt StartPoint() const Standard_OVERRIDE; 754 755 //! Returns the weight of the pole of range Index . 756 //! Raised if Index < 1 or Index > NbPoles. 757 Standard_EXPORT Standard_Real Weight (const Standard_Integer Index) const; 758 759 //! Returns the weights of the B-spline curve; 760 //! 761 //! Raised if the length of W is not equal to NbPoles. 762 Standard_EXPORT void Weights (TColStd_Array1OfReal& W) const; 763 764 //! Returns the weights of the B-spline curve; 765 Standard_EXPORT const TColStd_Array1OfReal* Weights() const; 766 767 //! Applies the transformation T to this BSpline curve. 768 Standard_EXPORT void Transform (const gp_Trsf& T) Standard_OVERRIDE; 769 770 771 //! Returns the value of the maximum degree of the normalized 772 //! B-spline basis functions in this package. 773 Standard_EXPORT static Standard_Integer MaxDegree(); 774 775 //! Computes for this BSpline curve the parametric 776 //! tolerance UTolerance for a given 3D tolerance Tolerance3D. 777 //! If f(t) is the equation of this BSpline curve, 778 //! UTolerance ensures that: 779 //! | t1 - t0| < Utolerance ===> 780 //! |f(t1) - f(t0)| < Tolerance3D 781 Standard_EXPORT void Resolution (const Standard_Real Tolerance3D, Standard_Real& UTolerance); 782 783 //! Creates a new object which is a copy of this BSpline curve. 784 Standard_EXPORT Handle(Geom_Geometry) Copy() const Standard_OVERRIDE; 785 786 //! Comapare two Bspline curve on identity; 787 Standard_EXPORT Standard_Boolean IsEqual (const Handle(Geom_BSplineCurve)& theOther, const Standard_Real thePreci) const; 788 789 790 791 792 DEFINE_STANDARD_RTTIEXT(Geom_BSplineCurve,Geom_BoundedCurve) 793 794 protected: 795 796 797 798 799 private: 800 801 802 //! Recompute the flatknots, the knotsdistribution, the continuity. 803 Standard_EXPORT void UpdateKnots(); 804 805 Standard_Boolean rational; 806 Standard_Boolean periodic; 807 GeomAbs_BSplKnotDistribution knotSet; 808 GeomAbs_Shape smooth; 809 Standard_Integer deg; 810 Handle(TColgp_HArray1OfPnt) poles; 811 Handle(TColStd_HArray1OfReal) weights; 812 Handle(TColStd_HArray1OfReal) flatknots; 813 Handle(TColStd_HArray1OfReal) knots; 814 Handle(TColStd_HArray1OfInteger) mults; 815 Standard_Real maxderivinv; 816 Standard_Boolean maxderivinvok; 817 818 819 }; 820 821 822 823 824 825 826 827 #endif // _Geom_BSplineCurve_HeaderFile 828