src/Geom/Geom_BSplineSurface.cdl

   1 -- Created on: 1993-03-09
   2 -- Created by: JCV
   3 -- Copyright (c) 1993-1999 Matra Datavision
   4 -- Copyright (c) 1999-2012 OPEN CASCADE SAS
   5 --
   6 -- The content of this file is subject to the Open CASCADE Technology Public
   7 -- License Version 6.5 (the "License"). You may not use the content of this file
   8 -- except in compliance with the License. Please obtain a copy of the License
   9 -- at http://www.opencascade.org and read it completely before using this file.
  10 --
  11 -- The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
  12 -- main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
  13 --
  14 -- The Original Code and all software distributed under the License is
  15 -- distributed on an "AS IS" basis, without warranty of any kind, and the
  16 -- Initial Developer hereby disclaims all such warranties, including without
  17 -- limitation, any warranties of merchantability, fitness for a particular
  18 -- purpose or non-infringement. Please see the License for the specific terms
  19 -- and conditions governing the rights and limitations under the License.
  20
  21
  22
  23 class BSplineSurface from Geom inherits BoundedSurface from Geom
  24
  25         ---Purpose : Describes a BSpline surface.
  26         -- In each parametric direction, a BSpline surface can be:
  27         -- - uniform or non-uniform,
  28         -- - rational or non-rational,
  29         -- - periodic or non-periodic.
  30         -- A BSpline surface is defined by:
  31         -- - its degrees, in the u and v parametric directions,
  32         -- - its periodic characteristic, in the u and v parametric directions,
  33         -- - a table of poles, also called control points (together
  34         --   with the associated weights if the surface is rational), and
  35         -- - a table of knots, together with the associated multiplicities.
  36         --   The degree of a Geom_BSplineSurface is limited to
  37         -- a value (25) which is defined and controlled by the
  38         -- system. This value is returned by the function MaxDegree.
  39         --       Poles and Weights
  40         -- Poles and Weights are manipulated using two associative double arrays:
  41         -- - the poles table, which is a double array of gp_Pnt points, and
  42         -- - the weights table, which is a double array of reals.
  43         -- The bounds of the poles and weights arrays are:
  44         -- - 1 and NbUPoles for the row bounds (provided
  45         --   that the BSpline surface is not periodic in the u
  46         --   parametric direction), where NbUPoles is the
  47         --   number of poles of the surface in the u parametric direction, and
  48         -- - 1 and NbVPoles for the column bounds (provided
  49         --   that the BSpline surface is not periodic in the v
  50         --   parametric direction), where NbVPoles is the
  51         --   number of poles of the surface in the v parametric direction.
  52         --   The poles of the surface are the points used to shape
  53         -- and reshape the surface. They comprise a rectangular network.
  54         -- If the surface is not periodic:
  55         -- - The points (1, 1), (NbUPoles, 1), (1,
  56         --   NbVPoles), and (NbUPoles, NbVPoles)
  57         --   are the four parametric "corners" of the surface.
  58         -- - The first column of poles and the last column of
  59         --   poles define two BSpline curves which delimit the
  60         --   surface in the v parametric direction. These are the
  61         --   v isoparametric curves corresponding to the two
  62         --   bounds of the v parameter.
  63         -- - The first row of poles and the last row of poles
  64         --   define two BSpline curves which delimit the surface
  65         --   in the u parametric direction. These are the u
  66         --   isoparametric curves corresponding to the two bounds of the u parameter.
  67         -- If the surface is periodic, these geometric properties are not verified.
  68         -- It is more difficult to define a geometrical significance
  69         -- for the weights. However they are useful for
  70         -- representing a quadric surface precisely. Moreover, if
  71         -- the weights of all the poles are equal, the surface has
  72         -- a polynomial equation, and hence is a "non-rational surface".
  73         -- The non-rational surface is a special, but frequently
  74         -- used, case, where all poles have identical weights.
  75         -- The weights are defined and used only in the case of
  76         -- a rational surface. The rational characteristic is
  77         -- defined in each parametric direction. A surface can be
  78         -- rational in the u parametric direction, and
  79         -- non-rational in the v parametric direction.
  80         --        Knots and Multiplicities
  81         -- For a Geom_BSplineSurface the table of knots is
  82         -- made up of two increasing sequences of reals, without
  83         -- repetition, one for each parametric direction. The
  84         -- multiplicities define the repetition of the knots.
  85         -- A BSpline surface comprises multiple contiguous
  86         -- patches, which are themselves polynomial or rational
  87         -- surfaces. The knots are the parameters of the
  88         -- isoparametric curves which limit these contiguous
  89         -- patches. The multiplicity of a knot on a BSpline
  90         -- surface (in a given parametric direction) is related to
  91         -- the degree of continuity of the surface at that knot in
  92         -- that parametric direction:
  93         -- Degree of continuity at knot(i) = Degree - Multi(i) where:
  94         -- - Degree is the degree of the BSpline surface in
  95         --   the given parametric direction, and
  96         -- - Multi(i) is the multiplicity of knot number i in
  97         --   the given parametric direction.
  98         -- There are some special cases, where the knots are
  99         -- regularly spaced in one parametric direction (i.e. the
 100         -- difference between two consecutive knots is a constant).
 101         -- - "Uniform": all the multiplicities are equal to 1.
 102         -- - "Quasi-uniform": all the multiplicities are equal to 1,
 103         --   except for the first and last knots in this parametric
 104         --   direction, and these are equal to Degree + 1.
 105         -- - "Piecewise Bezier": all the multiplicities are equal to
 106         --   Degree except for the first and last knots, which
 107         --   are equal to Degree + 1. This surface is a
 108         --   concatenation of Bezier patches in the given
 109         --   parametric direction.
 110         -- If the BSpline surface is not periodic in a given
 111         -- parametric direction, the bounds of the knots and
 112         -- multiplicities tables are 1 and NbKnots, where
 113         -- NbKnots is the number of knots of the BSpline
 114         -- surface in that parametric direction.
 115         -- If the BSpline surface is periodic in a given parametric
 116         -- direction, and there are k periodic knots and p
 117         -- periodic poles in that parametric direction:
 118         -- - the period is such that:
 119         -- period = Knot(k+1) - Knot(1), and
 120         -- - the poles and knots tables in that parametric
 121         --   direction can be considered as infinite tables, such that:
 122         -- Knot(i+k) = Knot(i) + period, and
 123         -- Pole(i+p) = Pole(i)
 124         -- Note: The data structure tables for a periodic BSpline
 125         -- surface are more complex than those of a non-periodic one.
 126         -- References :
 127         --  . A survey of curve and surface methods in CADG Wolfgang BOHM
 128         --    CAGD 1 (1984)
 129         --  . On de Boor-like algorithms and blossoming Wolfgang BOEHM
 130         --    cagd 5 (1988)
 131         --  . Blossoming and knot insertion algorithms for B-spline curves
 132         --    Ronald N. GOLDMAN
 133         --  . Modelisation des surfaces en CAO, Henri GIAUME Peugeot SA
 134         --  . Curves and Surfaces for Computer Aided Geometric Design,
 135         --    a practical guide Gerald Farin
 136
 137
 138
 139 uses  Array1OfInteger      from TColStd,
 140       Array1OfReal         from TColStd,
 141       Array2OfReal         from TColStd,
 142       HArray1OfInteger     from TColStd,
 143       HArray1OfReal        from TColStd,
 144       HArray2OfReal        from TColStd,
 145       Array1OfPnt          from TColgp,
 146       Array2OfPnt          from TColgp,
 147       Ax1                  from gp,
 148       Ax2                  from gp,
 149       HArray2OfPnt         from TColgp,
 150       Pnt                  from gp,
 151       Trsf                 from gp,
 152       Vec                  from gp,
 153       BSplKnotDistribution from GeomAbs,
 154       Curve                from Geom,
 155       Geometry             from Geom,
 156       Shape                from GeomAbs,
 157       Mutex                from Standard
 158
 159 raises ConstructionError   from Standard,
 160        DimensionError      from Standard,
 161        DomainError         from Standard,
 162        OutOfRange          from Standard,
 163        NoSuchObject        from Standard,
 164        RangeError          from Standard,
 165        UndefinedDerivative from Geom
 166
 167
 168
 169 is
 170
 171
 172
 173   Create (Poles                        : Array2OfPnt     from TColgp;
 174           UKnots, VKnots               : Array1OfReal    from TColStd;
 175           UMults, VMults               : Array1OfInteger from TColStd;
 176           UDegree, VDegree             : Integer;
 177           UPeriodic                    : Boolean = Standard_False;
 178           VPeriodic                    : Boolean = Standard_False)
 179      returns mutable BSplineSurface
 180
 181         ---Purpose : Creates  a non-rational b-spline surface (weights
 182         --         default value is 1.).
 183      raises ConstructionError;
 184         ---Purpose: The following conditions must be verified.
 185         --   0 < UDegree <= MaxDegree.
 186         --   UKnots.Length() == UMults.Length() >= 2
 187         --   UKnots(i) < UKnots(i+1) (Knots are increasing)
 188         --   1 <= UMults(i) <= UDegree
 189         --   On a   non  uperiodic   surface    the  first and    last
 190         --   umultiplicities  may  be     UDegree+1  (this   is   even
 191         --   recommanded if you want the curve  to start and finish on
 192         --   the first and last pole).
 193         --   On a uperiodic     surface  the first    and   the   last
 194         --   umultiplicities must be the same.
 195         --   on non-uperiodic surfaces
 196         --     Poles.ColLength() == Sum(UMults(i)) - UDegree - 1 >= 2
 197         --   on uperiodic surfaces
 198         --   Poles.ColLength() == Sum(UMults(i)) except the first or last
 199         --   The previous conditions for U holds  also for V, with the
 200         --   RowLength of the poles.
 201
 202
 203
 204
 205   Create (Poles                        : Array2OfPnt     from TColgp;
 206           Weights                      : Array2OfReal    from TColStd;
 207           UKnots, VKnots               : Array1OfReal    from TColStd;
 208           UMults, VMults               : Array1OfInteger from TColStd;
 209           UDegree, VDegree             : Integer;
 210           UPeriodic                    : Boolean = Standard_False;
 211           VPeriodic                    : Boolean = Standard_False)
 212      returns mutable BSplineSurface
 213
 214         ---Purpose : Creates  a non-rational b-spline surface (weights
 215         --         default value is 1.).
 216         --
 217      raises ConstructionError;
 218         ---Purpose: The following conditions must be verified.
 219         --  0 < UDegree <= MaxDegree.
 220         --
 221         --  UKnots.Length() == UMults.Length() >= 2
 222         --
 223         --  UKnots(i) < UKnots(i+1) (Knots are increasing)
 224         --  1 <= UMults(i) <= UDegree
 225         --
 226         --   On a   non  uperiodic   surface    the  first and    last
 227         --   umultiplicities  may  be     UDegree+1  (this   is   even
 228         --   recommanded if you want the curve  to start and finish on
 229         --   the first and last pole).
 230         --
 231         --   On a uperiodic     surface  the first    and   the   last
 232         --   umultiplicities must be the same.
 233         --
 234         --   on non-uperiodic surfaces
 235         --
 236         --     Poles.ColLength() == Sum(UMults(i)) - UDegree - 1 >= 2
 237         --
 238         --   on uperiodic surfaces
 239         --
 240         --     Poles.ColLength() == Sum(UMults(i)) except the first or
 241         --     last
 242         --
 243         --
 244         --   The previous conditions for U holds  also for V, with the
 245         --   RowLength of the poles.
 246
 247
 248
 249   ExchangeUV (me : mutable);
 250         ---Purpose: Exchanges the u and v parametric directions on
 251         -- this BSpline surface.
 252         -- As a consequence:
 253         -- - the poles and weights tables are transposed,
 254         -- - the knots and multiplicities tables are exchanged,
 255         -- - degrees of continuity, and rational, periodic and
 256         --   uniform characteristics are exchanged, and
 257         -- - the orientation of the surface is inverted.
 258
 259   SetUPeriodic (me : mutable);
 260         ---Purpose: Sets the surface U periodic.
 261
 262   SetVPeriodic (me : mutable);
 263         ---Purpose:  Modifies this surface to be periodic in the u (or v)
 264         -- parametric direction.
 265         -- To become periodic in a given parametric direction a
 266         -- surface must be closed in that parametric direction,
 267         -- and the knot sequence relative to that direction must be periodic.
 268         -- To generate this periodic sequence of knots, the
 269         -- functions FirstUKnotIndex and LastUKnotIndex (or
 270         -- FirstVKnotIndex and LastVKnotIndex) are used to
 271         -- compute I1 and I2. These are the indexes, in the
 272         -- knot array associated with the given parametric
 273         -- direction, of the knots that correspond to the first and
 274         -- last parameters of this BSpline surface in the given
 275         -- parametric direction. Hence the period is:
 276         -- Knots(I1) - Knots(I2)
 277         -- As a result, the knots and poles tables are modified.
 278         -- Exceptions
 279         -- Standard_ConstructionError if the surface is not
 280         -- closed in the given parametric direction.
 281
 282
 283
 284
 285   PeriodicNormalization(me ;  U,V : in out Real) ;
 286
 287         ---Purpose : returns the parameter normalized within
 288         --         the period if the surface is periodic : otherwise
 289         --         does not do anything
 290
 291   SetUOrigin (me : mutable; Index : Integer)
 292         ---Purpose: Assigns the knot of index Index in the knots table in
 293         -- the corresponding parametric direction to be the
 294         -- origin of this periodic BSpline surface. As a
 295         -- consequence, the knots and poles tables are modified.
 296         -- Exceptions
 297         -- Standard_NoSuchObject if this BSpline surface is
 298         -- not periodic in the given parametric direction.
 299         -- Standard_DomainError if Index is outside the
 300         -- bounds of the knots table in the given parametric direction.
 301     raises NoSuchObject,
 302            DomainError;
 303
 304   SetVOrigin (me : mutable; Index : Integer)
 305         ---Purpose: Assigns the knot of index Index in the knots table in
 306         -- the corresponding parametric direction to be the
 307         -- origin of this periodic BSpline surface. As a
 308         -- consequence, the knots and poles tables are modified.
 309         -- Exceptions
 310         -- Standard_NoSuchObject if this BSpline surface is
 311         -- not periodic in the given parametric direction.
 312         -- Standard_DomainError if Index is outside the
 313         -- bounds of the knots table in the given parametric direction.
 314     raises NoSuchObject,
 315            DomainError;
 316
 317
 318   SetUNotPeriodic (me : mutable);
 319
 320   SetVNotPeriodic (me : mutable);
 321         ---Purpose: Modifies this surface to be periodic in the u (or v) parametric direction.
 322         -- To become periodic in a given parametric direction a
 323         -- surface must be closed in that parametric direction,
 324         -- and the knot sequence relative to that direction must be periodic.
 325         -- To generate this periodic sequence of knots, the
 326         -- functions FirstUKnotIndex and LastUKnotIndex (or
 327         -- FirstVKnotIndex and LastVKnotIndex) are used to
 328         -- compute I1 and I2. These are the indexes, in the
 329         -- knot array associated with the given parametric
 330         -- direction, of the knots that correspond to the first and
 331         -- last parameters of this BSpline surface in the given
 332         -- parametric direction. Hence the period is:
 333         -- Knots(I1) - Knots(I2)
 334         -- As a result, the knots and poles tables are modified.
 335         -- Exceptions
 336         -- Standard_ConstructionError if the surface is not
 337         -- closed in the given parametric direction.
 338
 339   UReverse (me : mutable);
 340
 341   VReverse (me : mutable);
 342         ---Purpose: Changes the orientation of this BSpline surface in the
 343         -- u (or v) parametric direction. The bounds of the
 344         -- surface are not changed but the given parametric
 345         -- direction is reversed. Hence the orientation of the
 346         -- surface is reversed.
 347         -- The knots and poles tables are modified.
 348
 349   UReversedParameter (me; U : Real) returns Real;
 350
 351   VReversedParameter (me; V : Real) returns Real;
 352         ---Purpose: Computes the u (or v) parameter on the modified
 353         -- surface, produced by reversing its u (or v) parametric
 354         -- direction, for the point of u parameter U, (or of v
 355         -- parameter V) on this BSpline surface.
 356         -- For a BSpline surface, these functions return respectively:
 357         -- - UFirst + ULast - U, or
 358         -- - VFirst + VLast - V,
 359         -- where UFirst, ULast, VFirst and VLast are
 360         -- the values of the first and last parameters of this
 361         -- BSpline surface, in the u and v parametric directions.
 362
 363
 364   IncreaseDegree (me : mutable; UDegree, VDegree : Integer);
 365         ---Purpose : Increases the degrees of this BSpline surface to
 366         -- UDegree and VDegree in the u and v parametric
 367         -- directions respectively. As a result, the tables of poles,
 368         -- weights and multiplicities are modified. The tables of
 369         -- knots is not changed.
 370         -- Note: Nothing is done if the given degree is less than
 371         -- or equal to the current degree in the corresponding
 372         -- parametric direction.
 373         -- Exceptions
 374         -- Standard_ConstructionError if UDegree or
 375         -- VDegree is greater than
 376         -- Geom_BSplineSurface::MaxDegree().
 377
 378
 379   InsertUKnots (me : mutable; Knots : Array1OfReal    from TColStd;
 380                               Mults : Array1OfInteger from TColStd;
 381                               ParametricTolerance : Real = 0.0;
 382                               Add : Boolean = Standard_True);
 383
 384   InsertVKnots (me : mutable; Knots : Array1OfReal    from TColStd;
 385                               Mults : Array1OfInteger from TColStd;
 386                               ParametricTolerance : Real = 0.0;
 387                               Add : Boolean = Standard_True);
 388
 389         ---Purpose: Inserts into the knots table for the corresponding
 390         -- parametric direction of this BSpline surface:
 391         -- - the value U, or V, with the multiplicity M (defaulted to 1), or
 392         -- - the values of the array Knots, with their respective
 393         -- multiplicities, Mults.
 394         -- If the knot value to insert already exists in the table, its multiplicity is:
 395         -- - increased by M, if Add is true (the default), or
 396         -- - increased to M, if Add is false.
 397         -- The tolerance criterion used to check the equality of
 398         -- the knots is the larger of the values ParametricTolerance and
 399         -- Standard_Real::Epsilon(val), where val is the knot value to be inserted.
 400         -- Warning
 401         -- - If a given multiplicity coefficient is null, or negative, nothing is done.
 402         -- - The new multiplicity of a knot is limited to the degree of this BSpline surface in the
 403         --   corresponding parametric direction.
 404         -- Exceptions
 405         -- Standard_ConstructionError if a knot value to
 406         -- insert is outside the bounds of this BSpline surface in
 407         -- the specified parametric direction. The comparison
 408         -- uses the precision criterion ParametricTolerance.
 409
 410
 411   RemoveUKnot(me : mutable; Index     : Integer;
 412                            M         : Integer;
 413                            Tolerance : Real) returns Boolean
 414   raises OutOfRange;
 415
 416   RemoveVKnot(me : mutable; Index     : Integer;
 417                            M         : Integer;
 418                            Tolerance : Real) returns Boolean
 419   raises OutOfRange;
 420
 421         ---Purpose : Reduces to M the multiplicity of the knot of index
 422         -- Index in the given parametric direction. If M is 0, the knot is removed.
 423         -- With a modification of this type, the table of poles is also modified.
 424         -- Two different algorithms are used systematically to
 425         -- compute the new poles of the surface. For each
 426         -- pole, the distance between the pole calculated
 427         -- using the first algorithm and the same pole
 428         -- calculated using the second algorithm, is checked. If
 429         -- this distance is less than Tolerance it ensures that
 430         -- the surface is not modified by more than Tolerance.
 431         -- Under these conditions, the function returns true;
 432         -- otherwise, it returns false.
 433         -- A low tolerance prevents modification of the
 434         -- surface. A high tolerance "smoothes" the surface.
 435         -- Exceptions
 436         -- Standard_OutOfRange if Index is outside the
 437         -- bounds of the knots table of this BSpline surface.
 438
 439
 440   IncreaseUMultiplicity (me : mutable; UIndex : Integer; M : Integer)
 441         ---Purpose :
 442         --  Increases the multiplicity of the knot of range UIndex
 443         --  in the UKnots sequence.
 444         --  M is the new multiplicity. M must be greater than the
 445         --  previous multiplicity and lower or equal to the degree
 446         --  of the surface in the U parametric direction.
 447      raises ConstructionError,
 448         ---Purpose : Raised if M is not in the range [1, UDegree]
 449             OutOfRange;
 450         ---Purpose :
 451         --  Raised if UIndex is not in the range [FirstUKnotIndex,
 452         --  LastUKnotIndex] given by the methods with the same name.
 453
 454
 455   IncreaseUMultiplicity (me : mutable; FromI1, ToI2 : Integer; M : Integer)
 456         ---Purpose :
 457         --  Increases until order M the multiplicity of the set of knots
 458         --  FromI1,...., ToI2 in the U direction. This method can be used
 459         --  to make a B_spline surface into a PiecewiseBezier B_spline
 460         --  surface.
 461         --  If <me> was uniform, it can become non uniform.
 462      raises OutOfRange,
 463         ---Purpose :
 464         --  Raised if FromI1 or ToI2 is out of the range [FirstUKnotIndex,
 465         --  LastUKnotIndex].
 466             ConstructionError;
 467         ---Purpose :
 468         --  M should be greater than the previous multiplicity of the
 469         --  all the knots FromI1,..., ToI2 and lower or equal to the
 470         --   Degree of the surface in the U parametric direction.
 471
 472
 473   IncrementUMultiplicity (me : mutable; FromI1, ToI2 : Integer; Step : Integer)
 474         ---Purpose :
 475         --  Increments the multiplicity of the consecutives uknots FromI1..ToI2
 476         --  by step.   The multiplicity of each knot FromI1,.....,ToI2 must be
 477         --  lower or equal to the UDegree of the B_spline.
 478      raises OutOfRange,
 479         ---Purpose :
 480         --  Raised if FromI1 or ToI2 is not in the range
 481         --  [FirstUKnotIndex, LastUKnotIndex]
 482             ConstructionError;
 483        ---Purpose :
 484         --  Raised if one knot has a multiplicity greater than UDegree.
 485
 486
 487   IncreaseVMultiplicity (me : mutable; VIndex : Integer; M : Integer)
 488         ---Purpose :
 489         --  Increases the multiplicity of a knot in the V direction.
 490         --  M is the new multiplicity.
 491      raises ConstructionError,
 492         ---Purpose :
 493         --  M should be greater than the previous multiplicity and lower
 494         --  than the degree of the surface in the V parametric direction.
 495             OutOfRange;
 496         ---Purpose :
 497         --  Raised if VIndex is not in the range [FirstVKnotIndex,
 498         --  LastVKnotIndex] given by the methods with the same name.
 499
 500
 501   IncreaseVMultiplicity (me : mutable; FromI1, ToI2 : Integer; M : Integer)
 502         ---Purpose :
 503         --  Increases until order M the multiplicity of the set of knots
 504         --  FromI1,...., ToI2 in the V direction. This method can be used to
 505         --  make a BSplineSurface into a PiecewiseBezier B_spline
 506         --  surface. If <me> was uniform, it can become non-uniform.
 507      raises OutOfRange,
 508         ---Purpose :
 509         --  Raised if FromI1 or ToI2 is out of the range [FirstVKnotIndex,
 510         --  LastVKnotIndex] given by the methods with the same name.
 511             ConstructionError;
 512         ---Purpose :
 513         --  M should be greater than the previous multiplicity of the
 514         --  all the knots FromI1,..., ToI2 and lower or equal to the
 515         --  Degree of the surface in the V parametric direction.
 516
 517
 518   IncrementVMultiplicity (me : mutable; FromI1, ToI2 : Integer; Step : Integer)
 519         ---Purpose :
 520         --  Increments the multiplicity of the consecutives vknots FromI1..ToI2
 521         --  by step.  The multiplicity of each knot FromI1,.....,ToI2 must be
 522         --  lower or equal to the VDegree of the B_spline.
 523      raises OutOfRange,
 524         ---Purpose :
 525         --  Raised if FromI1 or ToI2 is not in the range
 526         --  [FirstVKnotIndex, LastVKnotIndex]
 527             ConstructionError;
 528         ---Purpose :
 529         --  Raised if one knot has a multiplicity greater than VDegree.
 530
 531
 532   InsertUKnot (me : mutable; U : Real; M : Integer; ParametricTolerance : Real;
 533                              Add : Boolean = Standard_True)
 534         ---Purpose:
 535         --  Inserts a knot value in the sequence of UKnots. If U is a knot
 536         --  value this method increases the multiplicity of the knot if the
 537         --  previous multiplicity was lower than M else it does nothing. The
 538         --  tolerance criterion is ParametricTolerance. ParametricTolerance
 539         --  should be greater or equal than Resolution from package gp.
 540      raises ConstructionError;
 541         ---Purpose :
 542         --  Raised if U is out of the bounds [U1, U2] given by the methods
 543         --  Bounds, the criterion ParametricTolerance is used.
 544         --  Raised if M is not in the range [1, UDegree].
 545
 546
 547   InsertVKnot (me : mutable; V : Real; M : Integer; ParametricTolerance : Real;
 548                              Add : Boolean = Standard_True)
 549         ---Purpose :
 550         --  Inserts a knot value in the sequence of VKnots. If V is a knot
 551         --  value this method increases the multiplicity of the knot if the
 552         --  previous multiplicity was lower than M otherwise it does nothing.
 553         --  The tolerance criterion is ParametricTolerance.
 554         --  ParametricTolerance should be greater or equal than Resolution
 555         --  from package gp.
 556      raises ConstructionError;
 557         ---Purpose :
 558         --  raises if V is out of the Bounds [V1, V2] given by the methods
 559         --  Bounds, the criterion ParametricTolerance is used.
 560         --  raises if M is not in the range [1, VDegree].
 561
 562
 563   Segment (me : mutable; U1, U2, V1, V2 : Real)
 564         ---Purpose :
 565         --  Segments the surface between U1 and U2 in the U-Direction.
 566         --                       between V1 and V2 in the V-Direction.
 567         --  The control points are modified, the first and the last point
 568         --  are not the same.
 569         -- Warnings :
 570         --  Even if <me> is not closed it can become closed after the
 571         --  segmentation for example if U1 or U2 are out of the bounds
 572         --  of the surface <me> or if the surface makes loop.
 573     raises DomainError from Standard;
 574         ---Purpose: raises if U2 < U1 or V2 < V1
 575
 576
 577   CheckAndSegment (me : mutable; U1, U2, V1, V2 : Real)
 578         ---Purpose :
 579         --  Segments the surface between U1 and U2 in the U-Direction.
 580         --                       between V1 and V2 in the V-Direction.
 581         --
 582         --  same as Segment but do nothing if U1 and U2 (resp. V1 and V2) are
 583         --  equal to the bounds in U (resp. in V) of <me>.
 584         --  For example, if <me> is periodic in V, it will be always periodic
 585         --  in V after the segmentation if the bounds in V are unchanged
 586         --
 587         -- Warnings :
 588         --  Even if <me> is not closed it can become closed after the
 589         --  segmentation for example if U1 or U2 are out of the bounds
 590         --  of the surface <me> or if the surface makes loop.
 591     raises DomainError from Standard;
 592         ---Purpose: raises if U2 < U1 or V2 < V1
 593
 594
 595   SetUKnot (me : mutable; UIndex : Integer; K : Real)
 596         ---Purpose :  Substitutes the UKnots of range UIndex with K.
 597      raises OutOfRange,
 598         ---Purpose :
 599         --  Raised if UIndex < 1 or UIndex > NbUKnots
 600             ConstructionError;
 601         ---Purpose :
 602         --  Raised if K >= UKnots(UIndex+1) or K <= UKnots(UIndex-1)
 603
 604
 605   SetUKnots (me : mutable; UK : Array1OfReal from TColStd)
 606         ---Purpose :  Changes all the U-knots of the surface.
 607         --  The multiplicity of the knots are not modified.
 608      raises ConstructionError,
 609         ---Purpose :
 610         --  Raised if there is an index such that UK (Index+1) <= UK (Index).
 611             OutOfRange;
 612         ---Purpose :
 613         --  Raised if  UK.Lower() < 1 or UK.Upper() > NbUKnots
 614
 615
 616   SetUKnot (me : mutable; UIndex : Integer; K : Real; M : Integer)
 617         ---Purpose :
 618         --  Changes the value of the UKnots of range UIndex and
 619         --  increases its multiplicity.
 620      raises OutOfRange,
 621         ---Purpose :
 622         --  Raised if UIndex is not in the range [FirstUKnotIndex,
 623         --  LastUKnotIndex] given by the methods with the same name.
 624             ConstructionError;
 625         ---Purpose :
 626         --  Raised if K >= UKnots(UIndex+1) or K <= UKnots(UIndex-1)
 627         --  M must be lower than UDegree and greater than the previous
 628         --  multiplicity of the knot of range UIndex.
 629
 630
 631   SetVKnot (me : mutable; VIndex : Integer; K : Real)
 632         ---Purpose :  Substitutes the VKnots of range VIndex with K.
 633      raises OutOfRange,
 634         ---Purpose :
 635         --  Raised if VIndex < 1 or VIndex > NbVKnots
 636             ConstructionError;
 637         ---Purpose :
 638         --  Raised if K >= VKnots(VIndex+1) or K <= VKnots(VIndex-1)
 639
 640
 641   SetVKnots (me : mutable; VK : Array1OfReal from TColStd)
 642         ---Purpose :  Changes all the V-knots of the surface.
 643         --  The multiplicity of the knots are not modified.
 644      raises ConstructionError,
 645         ---Purpose :
 646         --  Raised if there is an index such that VK (Index+1) <= VK (Index).
 647             OutOfRange;
 648         ---Purpose :
 649         --  Raised if  VK.Lower() < 1 or VK.Upper() > NbVKnots
 650
 651
 652
 653   SetVKnot (me : mutable; VIndex : Integer; K : Real; M : Integer)
 654         ---Purpose :
 655         --  Changes the value of the VKnots of range VIndex and increases
 656         --  its multiplicity.
 657      raises OutOfRange,
 658         ---Purpose :
 659         --  Raised if VIndex is not in the range [FirstVKnotIndex,
 660         --  LastVKnotIndex] given by the methods with the same name.
 661             ConstructionError;
 662         ---Purpose :
 663         --  Raised if K >= VKnots(VIndex+1) or K <= VKnots(VIndex-1)
 664         --  M must be lower than VDegree and greater than the previous
 665         --  multiplicity of the knot of range VIndex.
 666
 667
 668   LocateU (me;
 669            U                   : Real;
 670            ParametricTolerance : Real;
 671            I1, I2              : in out Integer;
 672            WithKnotRepetition  : Boolean = Standard_False);
 673         ---Purpose :
 674         --  Locates the parametric value U in the sequence of UKnots.
 675         --  If "WithKnotRepetition" is True we consider the knot's
 676         --  representation with repetition of multiple knot value,
 677         --  otherwise  we consider the knot's representation with
 678         --  no repetition of multiple knot values.
 679         --  UKnots (I1) <= U <= UKnots (I2)
 680         --  . if I1 = I2  U is a knot value (the tolerance criterion
 681         --    ParametricTolerance is used).
 682         --  . if I1 < 1  => U < UKnots(1) - Abs(ParametricTolerance)
 683         --  . if I2 > NbUKnots => U > UKnots(NbUKnots)+Abs(ParametricTolerance)
 684
 685
 686   LocateV (me;
 687            V                   : Real;
 688            ParametricTolerance : Real;
 689            I1, I2              : in out Integer;
 690            WithKnotRepetition  : Boolean = Standard_False);
 691         ---Purpose :
 692         --  Locates the parametric value U in the sequence of knots.
 693         --  If "WithKnotRepetition" is True we consider the knot's
 694         --  representation with repetition of multiple knot value,
 695         --  otherwise  we consider the knot's representation with
 696         --  no repetition of multiple knot values.
 697         --  VKnots (I1) <= V <= VKnots (I2)
 698         --  . if I1 = I2  V is a knot value (the tolerance criterion
 699         --    ParametricTolerance is used).
 700         --  . if I1 < 1  => V < VKnots(1) - Abs(ParametricTolerance)
 701         --  . if I2 > NbVKnots => V > VKnots(NbVKnots)+Abs(ParametricTolerance)
 702
 703
 704
 705
 706
 707
 708
 709         ---Purpose :  poles insertion and removing
 710         --  The following methods are available only if the surface
 711         --  is Uniform or QuasiUniform in the considered direction
 712         --  The knot repartition is modified.
 713
 714
 715
 716
 717         ----Purpose : poles and weights modifications
 718
 719   SetPole (me : mutable; UIndex, VIndex : Integer; P : Pnt)
 720         ---Purpose :
 721         --  Substitutes the pole of range (UIndex, VIndex) with P.
 722         --  If the surface is rational the weight of range (UIndex, VIndex)
 723         --  is not modified.
 724      raises OutOfRange;
 725         ---Purpose :
 726         --  Raised if UIndex < 1 or UIndex > NbUPoles or VIndex < 1 or
 727         --  VIndex > NbVPoles.
 728
 729
 730   SetPole (me : mutable; UIndex, VIndex : Integer; P : Pnt; Weight : Real)
 731         ---Purpose :
 732         --  Substitutes the pole and the weight of range (UIndex, VIndex)
 733         --  with P and W.
 734      raises OutOfRange,
 735         ---Purpose :
 736         --  Raised if UIndex < 1 or UIndex > NbUPoles or VIndex < 1 or
 737         --  VIndex > NbVPoles.
 738             ConstructionError;
 739         ---Purpose : Raised if Weight <= Resolution from package gp.
 740
 741
 742   SetPoleCol (me : mutable; VIndex : Integer; CPoles : Array1OfPnt from TColgp)
 743          ---Purpose :
 744          --  Changes a column of poles or a part of this column.
 745      raises OutOfRange,
 746         ---Purpose : Raised if Vindex < 1 or VIndex > NbVPoles.
 747             ConstructionError;
 748         ---Purpose :
 749         --  Raised if CPoles.Lower() < 1 or CPoles.Upper() > NbUPoles.
 750
 751
 752   SetPoleCol (me : mutable; VIndex : Integer; CPoles : Array1OfPnt from TColgp;
 753               CPoleWeights : Array1OfReal from TColStd)
 754          ---Purpose :
 755          --  Changes a column of poles or a part of this column with the
 756          --  corresponding weights. If the surface was rational it can
 757          --  become non rational. If the surface was non rational it can
 758          --  become rational.
 759      raises OutOfRange,
 760         ---Purpose : Raised if Vindex < 1 or VIndex > NbVPoles.
 761             ConstructionError;
 762         ---Purpose :
 763         --  Raised if CPoles.Lower() < 1 or CPoles.Upper() > NbUPoles
 764         --  Raised if the bounds of CPoleWeights are not the same as the
 765         --  bounds of CPoles.
 766         --  Raised if one of the weight value of CPoleWeights is lower or
 767         --  equal to Resolution from package gp.
 768
 769
 770   SetPoleRow (me : mutable; UIndex : Integer; CPoles : Array1OfPnt from TColgp;
 771               CPoleWeights : Array1OfReal from TColStd)
 772          ---Purpose :
 773          --  Changes a row of poles or a part of this row with the
 774          --  corresponding weights. If the surface was rational it can
 775          --  become non rational. If the surface was non rational it can
 776          --  become rational.
 777      raises OutOfRange,
 778         ---Purpose : Raised if Uindex < 1 or UIndex > NbUPoles.
 779             ConstructionError;
 780         ---Purpose :
 781         --  Raised if CPoles.Lower() < 1 or CPoles.Upper() > NbVPoles
 782         --  raises if the bounds of CPoleWeights are not the same as the
 783         --  bounds of CPoles.
 784         --  Raised if one of the weight value of CPoleWeights is lower or
 785         --  equal to Resolution from package gp.
 786
 787
 788   SetPoleRow (me : mutable; UIndex : Integer; CPoles : Array1OfPnt from TColgp)
 789          ---Purpose :
 790          --  Changes a row of poles or a part of this row.
 791      raises OutOfRange,
 792         ---Purpose : Raised if Uindex < 1 or UIndex > NbUPoles.
 793             ConstructionError;
 794         ---Purpose :
 795         --  Raised if CPoles.Lower() < 1 or CPoles.Upper() > NbVPoles.
 796
 797
 798   SetWeight (me : mutable; UIndex, VIndex : Integer; Weight : Real)
 799         ---Purpose :
 800         --  Changes the weight of the pole of range UIndex, VIndex.
 801         --  If the surface was non rational it can become rational.
 802         --  If the surface was rational it can become non rational.
 803      raises OutOfRange,
 804         ---Purpose :
 805         --  Raised if UIndex < 1 or UIndex > NbUPoles or VIndex < 1 or
 806         --  VIndex > NbVPoles
 807             ConstructionError;
 808         ---Purpose :
 809         --  Raised if weight is lower or equal to Resolution from
 810         --  package gp
 811
 812
 813   SetWeightCol (me : mutable; VIndex : Integer;
 814                 CPoleWeights : Array1OfReal from TColStd)
 815         ---Purpose :
 816         --  Changes a column of weights of a part of this column.
 817      raises OutOfRange,
 818         ---Purpose :
 819         --  Raised if VIndex < 1 or VIndex > NbVPoles
 820             ConstructionError;
 821         ---Purpose :
 822         --  Raised if CPoleWeights.Lower() < 1 or
 823         --            CPoleWeights.Upper() > NbUPoles.
 824         --  Raised if a weight value is lower or equal to Resolution
 825         --  from package gp.
 826
 827
 828   SetWeightRow (me : mutable; UIndex : Integer;
 829                 CPoleWeights : Array1OfReal from TColStd)
 830         ---Purpose :
 831         --  Changes a row of weights or a part of this row.
 832      raises OutOfRange,
 833         ---Purpose :
 834         --  Raised if UIndex < 1 or UIndex > NbUPoles
 835             ConstructionError;
 836         ---Purpose :
 837         --  Raised if CPoleWeights.Lower() < 1 or
 838         --            CPoleWeights.Upper() > NbVPoles.
 839         --  Raised  if a weight value is lower or equal to Resolution
 840         --  from package gp.
 841
 842   MovePoint(me: mutable; U, V : Real; P: Pnt;
 843             UIndex1, UIndex2, VIndex1, VIndex2: Integer;
 844             UFirstIndex, ULastIndex, VFirstIndex, VLastIndex: out Integer)
 845       ---Purpose: Move a point with parameter U and V to P.
 846       --          given u,v  as parameters)  to  reach a  new position
 847       --          UIndex1, UIndex2, VIndex1, VIndex2:
 848       --                  indicates the poles which can be moved
 849       --          if Problem in BSplineBasis calculation, no change
 850       --          for the curve and
 851       --              UFirstIndex, VLastIndex = 0
 852       --              VFirstIndex, VLastIndex = 0
 853      raises OutOfRange;
 854         ---Purpose:
 855         --  Raised if UIndex1 < UIndex2 or VIndex1 < VIndex2 or
 856         --            UIndex1 < 1 || UIndex1 > NbUPoles or
 857         --            UIndex2 < 1 || UIndex2 > NbUPoles
 858         --            VIndex1 < 1 || VIndex1 > NbVPoles or
 859         --            VIndex2 < 1 || VIndex2 > NbVPoles
 860
 861
 862
 863         ---Purpose : characteristics of the surface
 864
 865   IsUClosed (me)  returns Boolean;
 866         ---Purpose :
 867         --  Returns true if the first control points row and the last
 868         --  control points row are identical. The tolerance criterion
 869         --  is Resolution from package gp.
 870
 871   IsVClosed (me)   returns Boolean;
 872         ---Purpose :
 873         --  Returns true if the first control points column and the
 874         --  last last control points column are identical.
 875         --  The tolerance criterion is Resolution from package gp.
 876
 877
 878   IsCNu (me; N : Integer)  returns Boolean
 879         ---Purpose :
 880         --  Returns True if the order of continuity of the surface in the
 881         --  U direction  is N.
 882      raises RangeError;
 883         ---Purpose : Raised if N < 0.
 884
 885
 886   IsCNv (me; N : Integer)   returns Boolean
 887         ---Purpose :
 888         --  Returns True if the order of continuity of the surface
 889         --  in the V direction  is N.
 890      raises RangeError;
 891         ---Purpose : Raised if N < 0.
 892
 893
 894   IsUPeriodic (me)  returns Boolean;
 895         ---Purpose :
 896         --  Returns True if the surface is closed in the U direction
 897         --  and if the B-spline has been turned into a periodic surface
 898         --  using the function SetUPeriodic.
 899
 900
 901   IsURational (me)   returns Boolean;
 902         ---Purpose :
 903         --  Returns False if for each row of weights all the weights
 904         --  are identical.
 905         --  The tolerance criterion is resolution from package gp.
 906         --  Example :
 907         --                 |1.0, 1.0, 1.0|
 908         --   if Weights =  |0.5, 0.5, 0.5|   returns False
 909         --                 |2.0, 2.0, 2.0|
 910
 911
 912   IsVPeriodic (me)  returns Boolean;
 913         ---Purpose :
 914         --  Returns True if the surface is closed in the V direction
 915         --  and if the B-spline has been turned into a periodic
 916         --  surface using the function SetVPeriodic.
 917
 918
 919   IsVRational (me)  returns Boolean;
 920         ---Purpose :
 921         --  Returns False if for each column of weights all the weights
 922         --  are identical.
 923         --  The tolerance criterion is resolution from package gp.
 924         --- Examples :
 925         --                 |1.0, 2.0, 0.5|
 926         --   if Weights =  |1.0, 2.0, 0.5|   returns False
 927         --                 |1.0, 2.0, 0.5|
 928
 929   IsCacheValid(me;  UParameter, VParameter : Real) returns Boolean ;
 930
 931         ---Purpose :
 932         --           Tells whether the Cache is valid for the
 933         --           given parameter
 934         -- Warnings : the parameter must be normalized within
 935         -- the period if the curve is periodic. Otherwise
 936         -- the answer will be false
 937         --
 938
 939   Bounds (me; U1, U2, V1, V2 : out Real);
 940         ---Purpose :
 941         --  Returns the parametric bounds of the surface.
 942         --- Warnings :
 943         --  These parametric values are the bounds of the array of
 944         --  knots UKnots and VKnots only if the first knots and the
 945         --  last knots have a multiplicity equal to UDegree + 1 or
 946         --  VDegree + 1
 947
 948
 949   Continuity (me)   returns Shape from GeomAbs;
 950         ---Purpose :
 951         --  Returns the continuity of the surface :
 952         --  C0 : only geometric continuity,
 953         --  C1 : continuity of the first derivative all along the Surface,
 954         --  C2 : continuity of the second derivative all along the Surface,
 955         --  C3 : continuity of the third derivative all along the Surface,
 956         --  CN : the order of continuity is infinite.
 957         --  A B-spline surface is infinitely continuously differentiable
 958         --  for the couple of parameters U, V such thats U != UKnots(i)
 959         --  and V != VKnots(i). The continuity of the surface at a knot
 960         --  value depends on the multiplicity of this knot.
 961         --- Example :
 962         --  If the surface is C1 in the V direction and C2 in the U
 963         --  direction this function returns Shape = C1.
 964
 965
 966   FirstUKnotIndex (me)   returns Integer;
 967         ---Purpose :
 968         --  Computes the Index of the UKnots which gives the first
 969         --  parametric value of the surface in the U direction.
 970         --  The UIso curve corresponding to this value is a
 971         --  boundary curve of the surface.
 972
 973
 974   FirstVKnotIndex (me)   returns Integer;
 975         ---Purpose :
 976         --  Computes the Index of the VKnots which gives the
 977         --  first parametric value of the surface in the V direction.
 978         --  The VIso curve corresponding to this knot is a boundary
 979         --  curve of the surface.
 980
 981
 982   LastUKnotIndex (me)   returns Integer;
 983         ---Purpose :
 984         --  Computes the Index of the UKnots which gives the
 985         --  last parametric value of the surface in the U direction.
 986         --  The UIso curve corresponding to this knot is a boundary
 987         --  curve of the surface.
 988
 989
 990   LastVKnotIndex (me)   returns Integer;
 991         ---Purpose :
 992         --  Computes the Index of the VKnots which gives the
 993         --  last parametric value of the surface in the V direction.
 994         --  The VIso curve corresponding to this knot is a
 995         --  boundary curve of the surface.
 996
 997
 998   NbUKnots (me)   returns Integer;
 999         ---Purpose :  Returns the number of knots in the U direction.
1000
1001   NbUPoles (me)  returns Integer;
1002         ---Purpose : Returns number of poles in the U direction.
1003
1004   NbVKnots (me)  returns Integer;
1005         ---Purpose : Returns the number of knots in the V direction.
1006
1007   NbVPoles (me)  returns Integer;
1008         ---Purpose : Returns the number of poles in the V direction.
1009
1010
1011   Pole (me; UIndex, VIndex : Integer)   returns Pnt
1012         ---Purpose:
1013         --  Returns the pole of range (UIndex, VIndex).
1014      raises OutOfRange;
1015         ---Purpose :
1016         --  Raised if UIndex < 1 or UIndex > NbUPoles or VIndex < 1 or
1017         --  VIndex > NbVPoles.
1018
1019
1020   Poles (me; P : out Array2OfPnt from TColgp)
1021        ---Purpose : Returns the poles of the B-spline surface.
1022      raises DimensionError;
1023        ---Purpose :
1024        --  Raised if the length of P in the U and V direction
1025        --  is not equal to NbUpoles and NbVPoles.
1026
1027
1028   UDegree (me)  returns Integer;
1029         ---Purpose :
1030         --  Returns the degree of the normalized B-splines Ni,n in the U
1031         --  direction.
1032
1033
1034   UKnot (me; UIndex : Integer)  returns Real
1035         ---Purpose :
1036         --  Returns the Knot value of range UIndex.
1037      raises OutOfRange;
1038         ---Purpose : Raised if UIndex < 1 or UIndex > NbUKnots
1039
1040
1041   UKnotDistribution (me)   returns BSplKnotDistribution from GeomAbs;
1042         ---Purpose :
1043         --  Returns NonUniform or Uniform or QuasiUniform or
1044         --  PiecewiseBezier.  If all the knots differ by a
1045         --  positive constant from the preceding knot in the U
1046         --  direction the B-spline surface can be :
1047         --  - Uniform if all the knots are of multiplicity 1,
1048         --  - QuasiUniform if all the knots are of multiplicity 1
1049         --    except for the first and last knot which are of
1050         --    multiplicity Degree + 1,
1051         --  - PiecewiseBezier if the first and last knots have
1052         --    multiplicity Degree + 1 and if interior knots have
1053         --    multiplicity Degree
1054         --  otherwise the surface is non uniform in the U direction
1055         --  The tolerance criterion is Resolution from package gp.
1056
1057
1058   UKnots (me; Ku : out Array1OfReal from TColStd)
1059         ---Purpose : Returns the knots in the U direction.
1060      raises DimensionError;
1061         ---Purpose :
1062         --  Raised if the length of Ku is not equal to the number of knots
1063         --  in the U direction.
1064
1065
1066   UKnotSequence (me; Ku : out Array1OfReal from TColStd)
1067         ---Purpose : Returns the uknots sequence.
1068         --  In this sequence the knots with a multiplicity greater than 1
1069         --  are repeated.
1070         --- Example :
1071         --  Ku = {k1, k1, k1, k2, k3, k3, k4, k4, k4}
1072      raises DimensionError;
1073         ---Purpose :
1074         --  Raised if the length of Ku is not equal to NbUPoles + UDegree + 1
1075
1076
1077   UMultiplicity (me; UIndex : Integer)   returns Integer
1078         ---Purpose :
1079         --  Returns the multiplicity value of knot of range UIndex in
1080         --  the u direction.
1081      raises OutOfRange;
1082         ---Purpose : Raised if UIndex < 1 or UIndex > NbUKnots.
1083
1084
1085   UMultiplicities (me; Mu : out Array1OfInteger from TColStd)
1086         ---Purpose :
1087         --  Returns the multiplicities of the knots in the U direction.
1088      raises DimensionError;
1089         ---Purpose :
1090         --  Raised if the length of Mu is not equal to the number of
1091         --  knots in the U direction.
1092
1093
1094   VDegree (me)  returns Integer;
1095         ---Purpose :
1096         --  Returns the degree of the normalized B-splines Ni,d in the
1097         --  V direction.
1098
1099
1100   VKnot (me; VIndex : Integer)   returns Real
1101         ---Purpose : Returns the Knot value of range VIndex.
1102      raises OutOfRange;
1103         --- Purpse : Raised if VIndex < 1 or VIndex > NbVKnots
1104
1105
1106   VKnotDistribution (me)  returns BSplKnotDistribution from GeomAbs;
1107         ---Purpose :
1108         --  Returns NonUniform or Uniform or QuasiUniform or
1109         --  PiecewiseBezier. If all the knots differ by a positive
1110         --  constant from the preceding knot in the V direction the
1111         --  B-spline surface can be :
1112         --  - Uniform if all the knots are of multiplicity 1,
1113         --  - QuasiUniform if all the knots are of multiplicity 1
1114         --    except for the first and last knot which are of
1115         --    multiplicity Degree + 1,
1116         --  - PiecewiseBezier if the first and last knots have
1117         --    multiplicity  Degree + 1 and if interior knots have
1118         --     multiplicity Degree
1119         --  otherwise the surface is non uniform in the V direction.
1120         --  The tolerance criterion is Resolution from package gp.
1121
1122
1123   VKnots (me; Kv : out Array1OfReal from TColStd)
1124        ---Purpose : Returns the knots in the V direction.
1125      raises DimensionError;
1126        ---Purpose :
1127        --  Raised if the length of Kv is not equal to the number of
1128        --  knots in the V direction.
1129
1130
1131   VKnotSequence (me; Kv : out Array1OfReal from TColStd)
1132         ---Purpose : Returns the vknots sequence.
1133         --  In this sequence the knots with a multiplicity greater than 1
1134         --  are repeated.
1135         --- Example :
1136         --  Kv = {k1, k1, k1, k2, k3, k3, k4, k4, k4}
1137      raises DimensionError;
1138         ---Purpose :
1139         --  Raised if the length of Kv is not equal to NbVPoles + VDegree + 1
1140
1141
1142   VMultiplicity (me; VIndex : Integer)   returns Integer
1143         ---Purpose :
1144         --  Returns the multiplicity value of knot of range VIndex in
1145         --  the v direction.
1146      raises OutOfRange;
1147         ---Purpose : Raised if VIndex < 1 or VIndex > NbVKnots
1148
1149
1150   VMultiplicities (me; Mv : out Array1OfInteger from TColStd)
1151        ---Purpose :
1152        --  Returns the multiplicities of the knots in the V direction.
1153      raises DimensionError;
1154        ---Purpose :
1155        --  Raised if the length of Mv is not equal to the number of
1156        --  knots in the V direction.
1157
1158
1159   Weight (me; UIndex, VIndex : Integer)   returns Real
1160         ---Purpose : Returns the weight value of range UIndex, VIndex.
1161      raises OutOfRange;
1162         ---Purpose :
1163         --  Raised if UIndex < 1 or UIndex > NbUPoles or VIndex < 1
1164         --  or VIndex > NbVPoles.
1165
1166
1167   Weights (me; W : out Array2OfReal from TColStd)
1168         ---Purpose : Returns the weights of the B-spline surface.
1169      raises DimensionError;
1170         ---Purpose :
1171         --  Raised if the length of W in the U and V direction is
1172         --  not equal to NbUPoles and NbVPoles.
1173
1174
1175
1176
1177
1178
1179         ---Purpose : value and derivatives computation
1180
1181   D0 (me; U, V : Real; P : out Pnt);
1182
1183
1184   D1 (me; U, V : Real; P : out Pnt; D1U, D1V : out Vec)
1185      raises UndefinedDerivative;
1186         ---Purpose : Raised if the continuity of the surface is not C1.
1187
1188
1189   D2 (me; U, V : Real; P : out Pnt; D1U, D1V, D2U, D2V, D2UV : out Vec)
1190      raises UndefinedDerivative;
1191         ---Purpose : Raised if the continuity of the surface is not C2.
1192
1193
1194   D3 (me; U, V : Real; P : out Pnt; D1U, D1V, D2U, D2V, D2UV, D3U, D3V, D3UUV,
1195       D3UVV : out Vec)
1196      raises UndefinedDerivative;
1197         ---Purpose : Raised if the continuity of the surface is not C3.
1198
1199
1200   DN (me; U, V : Real; Nu, Nv : Integer)   returns Vec
1201         ---Purpose :
1202         --  Nu is the order of derivation in the U parametric direction and
1203         --  Nv is the order of derivation in the V parametric direction.
1204      raises UndefinedDerivative,
1205         ---Purpose :
1206         --  Raised if the continuity of the surface is not CNu in the U
1207         --  direction and CNv in the V direction.
1208             RangeError;
1209         ---Purpose :
1210         --  Raised if Nu + Nv < 1 or Nu < 0 or Nv < 0.
1211
1212
1213
1214
1215
1216
1217         ---Purpose  :
1218         --  The following functions computes the point for the
1219         --  parametric values (U, V) and the derivatives at
1220         --  this point on the B-spline surface patch delimited
1221         --  with the knots FromUK1, FromVK1 and the knots ToUK2,
1222         --  ToVK2.  (U, V) can be out of these parametric bounds
1223         --  but for the computation we only use the definition
1224         --  of the surface between these knots. This method is
1225         --  useful to compute local derivative, if the order of
1226         --  continuity of the whole surface is not greater enough.
1227         --  Inside the parametric knot's domain previously defined
1228         --  the evaluations are the same as if we consider the whole
1229         --  definition of the surface. Of course the evaluations are
1230         --  different outside this parametric domain.
1231
1232
1233   LocalD0 (me; U, V : Real; FromUK1, ToUK2, FromVK1, ToVK2 : Integer;
1234                P : out Pnt)
1235      raises DomainError,
1236         ---Purpose : Raised if FromUK1 = ToUK2 or FromVK1 = ToVK2.
1237             OutOfRange;
1238         ---Purpose :
1239         --  Raised if FromUK1, ToUK2 are not in the range [FirstUKnotIndex,
1240         --  LastUKnotIndex] or if FromVK1, ToVK2 are not in the range
1241         --  [FirstVKnotIndex, LastVKnotIndex]
1242
1243
1244   LocalD1 (me; U, V : Real;  FromUK1, ToUK2, FromVK1, ToVK2 : Integer;
1245           P : out Pnt; D1U, D1V : out Vec)
1246      raises UndefinedDerivative,
1247         ---Purpose :
1248         --  Raised if the local continuity of the surface is not C1
1249         --  between the knots FromUK1, ToUK2 and FromVK1, ToVK2.
1250             DomainError,
1251         ---Purpose : Raised if FromUK1 = ToUK2 or FromVK1 = ToVK2.
1252             OutOfRange;
1253         ---Purpose :
1254         --  Raised if FromUK1, ToUK2 are not in the range [FirstUKnotIndex,
1255         --  LastUKnotIndex] or if FromVK1, ToVK2 are not in the range
1256         --  [FirstVKnotIndex, LastVKnotIndex]
1257
1258
1259   LocalD2 (me; U, V : Real; FromUK1, ToUK2, FromVK1, ToVK2 : Integer;
1260            P : out Pnt; D1U, D1V, D2U, D2V, D2UV : out Vec)
1261      raises UndefinedDerivative,
1262         ---Purpose :
1263         --  Raised if the local continuity of the surface is not C2
1264         --  between the knots FromUK1, ToUK2 and FromVK1, ToVK2.
1265             DomainError,
1266         ---Purpose : Raised if FromUK1 = ToUK2 or FromVK1 = ToVK2.
1267             OutOfRange;
1268         ---Purpose :
1269         --  Raised if FromUK1, ToUK2 are not in the range [FirstUKnotIndex,
1270         --  LastUKnotIndex] or if FromVK1, ToVK2 are not in the range
1271         --  [FirstVKnotIndex, LastVKnotIndex]
1272
1273
1274   LocalD3 (me; U, V : Real; FromUK1, ToUK2, FromVK1, ToVK2 : Integer;
1275            P : out Pnt; D1U, D1V, D2U, D2V, D2UV, D3U, D3V, D3UUV, D3UVV :
1276            out Vec)
1277      raises UndefinedDerivative,
1278         ---Purpose :
1279         --  Raised if the local continuity of the surface is not C3
1280         --  between the knots FromUK1, ToUK2 and FromVK1, ToVK2.
1281             DomainError,
1282         ---Purpose : Raised if FromUK1 = ToUK2 or FromVK1 = ToVK2.
1283             OutOfRange;
1284         ---Purpose :
1285         --  Raised if FromUK1, ToUK2 are not in the range [FirstUKnotIndex,
1286         --  LastUKnotIndex] or if FromVK1, ToVK2 are not in the range
1287         --  [FirstVKnotIndex, LastVKnotIndex]
1288
1289
1290   LocalDN (me; U, V : Real; FromUK1, ToUK2, FromVK1, ToVK2 : Integer;
1291            Nu, Nv : Integer)
1292      returns Vec
1293      raises UndefinedDerivative,
1294         ---Purpose :
1295         --  Raised if the local continuity of the surface is not CNu
1296         --  between the knots FromUK1, ToUK2 and CNv between the knots
1297         --  FromVK1, ToVK2.
1298             DomainError,
1299         ---Purpose : Raised if FromUK1 = ToUK2 or FromVK1 = ToVK2.
1300              RangeError,
1301         --  Raised if Nu + Nv < 1 or Nu < 0 or Nv < 0.
1302              OutOfRange;
1303         ---Purpose :
1304         --  Raised if FromUK1, ToUK2 are not in the range [FirstUKnotIndex,
1305         --  LastUKnotIndex] or if FromVK1, ToVK2 are not in the range
1306         --  [FirstVKnotIndex, LastVKnotIndex]
1307
1308   LocalValue(me; U, V : Real;  FromUK1, ToUK2, FromVK1, ToVK2 : Integer)
1309         ---Purpose  :
1310         --  Computes the point of parameter U, V on the BSpline surface patch
1311         --  defines between the knots UK1 UK2, VK1, VK2. U can be out of the
1312         --  bounds [Knot UK1, Knot UK2] and V can be outof the bounds
1313         --  [Knot VK1, Knot VK2]  but for the computation we only use the
1314         --  definition of the surface between these knot values.
1315      returns Pnt
1316      raises DomainError,
1317         ---Purpose : Raises if FromUK1 = ToUK2 or FromVK1 = ToVK2.
1318             OutOfRange;
1319         ---Purpose :
1320         --  Raises if FromUK1, ToUK2 are not in the range [FirstUKnotIndex,
1321         --  LastUKnotIndex] or if FromVK1, ToVK2 are not in the range
1322         --  [FirstVKnotIndex, LastVKnotIndex]
1323
1324
1325
1326   UIso (me; U : Real) returns mutable Curve;
1327         ---Purpose :
1328         --  Computes the U isoparametric curve.
1329         --  A B-spline curve is returned.
1330
1331
1332   VIso (me; V : Real)  returns mutable Curve;
1333         ---Purpose :
1334         --  Computes the V isoparametric curve.
1335         --  A B-spline curve is returned.
1336
1337
1338   UIso (me; U : Real; CheckRational : Boolean) returns mutable Curve;
1339         ---Purpose :
1340         --  Computes the U isoparametric curve.
1341         --  If CheckRational=False, no try to make it non-rational.
1342         --  A B-spline curve is returned.
1343
1344
1345   VIso (me; V : Real; CheckRational : Boolean) returns mutable Curve;
1346         ---Purpose :
1347         --  Computes the V isoparametric curve.
1348         --  If CheckRational=False, no try to make it non-rational.
1349         --  A B-spline curve is returned.
1350
1351
1352
1353
1354
1355         ---Purpose : transformations
1356
1357   Transform (me : mutable; T : Trsf) ;
1358
1359         --- Purpose: Applies the transformation T to this BSpline surface.
1360
1361   MaxDegree (myclass)   returns Integer;
1362         ---Purpose :
1363         --  Returns the value of the maximum degree of the normalized
1364         --  B-spline basis functions in the u and v directions.
1365
1366
1367   Resolution(me          : mutable;
1368              Tolerance3D :     Real ;
1369              UTolerance  : out Real ;
1370              VTolerance  : out Real)
1371         ---Purpose: Computes two tolerance values for this BSpline
1372         -- surface, based on the given tolerance in 3D space
1373         -- Tolerance3D. The tolerances computed are:
1374         -- - UTolerance in the u parametric direction, and
1375         -- - VTolerance in the v parametric direction.
1376         -- If f(u,v) is the equation of this BSpline surface,
1377         -- UTolerance and VTolerance guarantee that :
1378         --          | u1 - u0 | < UTolerance and
1379         --          | v1 - v0 | < VTolerance
1380         --          ====> |f (u1,v1) - f (u0,v0)| < Tolerance3D
1381   ;
1382
1383   Copy (me)  returns mutable like me;
1384
1385         ---Purpose: Creates a new object which is a copy of this BSpline surface.
1386
1387   UpdateUKnots(me : mutable)
1388         ---Purpose: Recompute  the  flatknots,  the knotsdistribution, the
1389         --          continuity for U.
1390   is static private;
1391
1392   UpdateVKnots(me : mutable)
1393         ---Purpose: Recompute  the  flatknots,  the knotsdistribution, the
1394         --          continuity for V.
1395   is static private;
1396
1397
1398   InvalidateCache(me : mutable)
1399         ---Purpose : Invalidates the cache. This has to be private this has to be private
1400       is static private;
1401
1402   ValidateCache(me : mutable ; UParameter : Real;
1403                                VParameter : Real)
1404
1405     is static private;
1406         ---Purpose : updates the cache and validates it
1407
1408
1409 fields
1410
1411    urational : Boolean;
1412    vrational : Boolean;
1413    uperiodic : Boolean;
1414    vperiodic : Boolean;
1415    uknotSet  : BSplKnotDistribution from GeomAbs;
1416    vknotSet  : BSplKnotDistribution from GeomAbs;
1417    Usmooth   : Shape from GeomAbs;
1418    Vsmooth   : Shape from GeomAbs;
1419    udeg      : Integer;
1420    vdeg      : Integer;
1421    poles     : HArray2OfPnt     from TColgp;
1422    weights   : HArray2OfReal    from TColStd;
1423    ufknots   : HArray1OfReal    from TColStd;
1424    vfknots   : HArray1OfReal    from TColStd;
1425    uknots    : HArray1OfReal    from TColStd;
1426    vknots    : HArray1OfReal    from TColStd;
1427    umults    : HArray1OfInteger from TColStd;
1428    vmults    : HArray1OfInteger from TColStd;
1429   -- Inplementation of the cache on surfaces
1430    cachepoles : HArray2OfPnt     from TColgp;
1431   -- Taylor expansion of the poles function, in homogeneous
1432   -- form if the curve is rational. The taylor expansion
1433   -- is normalized so that the span corresponds to
1434   -- [0 1]x[0 1]. The Taylor expension of lower degree
1435   -- is stored as consecutive Pnt in the array that is
1436   -- if udeg <= vdeg than the array stores the following
1437   --
1438   --                                  (2,0)           (3,0)
1439   --               (1,0)             f     (u0,v0)   f     (u0,v0)
1440   --  f  (u0,v0)  f     (u0,v0)      -------------   -----------
1441   --                                      2             3!
1442   --
1443   --                                   (2,1)           (3,1)
1444   --   (0,1)          (1,1)         f     (u0,v0)   f     (u0,v0)
1445   --  f     (u0,v0)  f     (u0,v0)  -------------   -----------
1446   --                                     2              3!
1447   --
1448   -- Otherwise it is stored in the following fashion
1449   --
1450   --
1451   --                                  (0,2)           (0,3)
1452   --               (0,1)             f     (u0,v0)   f     (u0,v0)
1453   --  f  (u0,v0)  f     (u0,v0)      -------------   -----------
1454   --                                      2             3!
1455   --
1456   --                                 (1,2)           (1,3)
1457   --   (1,0)          (1,1)         f     (u0,v0)   f     (u0,v0)
1458   --  f     (u0,v0)  f     (u0,v0)  -------------   -----------
1459   --                                     2              3!
1460   --
1461   --   The size of the array is (1,Max degree) (1, Min degree)
1462   --
1463     cacheweights   : HArray2OfReal    from TColStd;
1464   -- Taylor expansion of the poles function, in homogeneous
1465   -- form if the curve is rational. The taylor expansion
1466   -- is normalized so that the span corresponds to
1467   -- [0 1]x[0 1]. The Taylor expension of lower degree
1468   -- is stored as consecutive Real in the array as explained above
1469     ucacheparameter : Real ;
1470     vcacheparameter : Real ;
1471   -- Parameters at which the Taylor expension is stored in
1472   -- the cache
1473     ucachespanlenght : Real ;
1474     vcachespanlenght : Real ;
1475       -- Since the Taylor expansion is normalized in the
1476   -- cache to evaluate the cache one has to use
1477   -- (UParameter - uparametercache) / ucachespanlenght
1478   -- (VParameter - vparametercache) / vcachespanlenght
1479     ucachespanindex : Integer ;
1480     vcachespanindex : Integer ;
1481   -- the span for which the cache is valid if
1482   -- validcache is 1
1483     validcache : Integer ;
1484
1485   -- usefull to evaluate the parametric resolutions
1486     umaxderivinv  : Real from Standard;
1487     vmaxderivinv  : Real from Standard;
1488     maxderivinvok : Boolean from Standard;
1489
1490     myMutex       : Mutex from Standard;
1491     -- protected bsplinesurface-cache
1492
1493 end;