// Created on: 1993-03-09
// Created by: JCV
// Copyright (c) 1993-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.

#ifndef _Geom_BezierSurface_HeaderFile
#define _Geom_BezierSurface_HeaderFile

#include "Standard.hxx"

#include "gp_Pnt.hxx"
#include "NCollection_Array2.hxx"
#include "NCollection_Array1.hxx"
#include "Geom_BoundedSurface.hxx"
#include "GeomAbs_Shape.hxx"
#include "BSplSLib.hxx"

class Geom_Curve;
class gp_Trsf;
class Geom_Geometry;

namespace GeomEval_RepSurfaceDesc
{
class Base;
}

//! Describes a rational or non-rational Bezier surface.
//! - A non-rational Bezier surface is defined by a table
//! of poles (also known as control points).
//! - A rational Bezier surface is defined by a table of
//! poles with varying associated weights.
//! This data is manipulated using two associative 2D arrays:
//! - the poles table, which is a 2D array of gp_Pnt, and
//! - the weights table, which is a 2D array of reals.
//! The bounds of these arrays are:
//! - 1 and NbUPoles for the row bounds, where
//! NbUPoles is the number of poles of the surface
//! in the u parametric direction, and
//! - 1 and NbVPoles for the column bounds, where
//! NbVPoles is the number of poles of the surface
//! in the v parametric direction.
//! The poles of the surface, the "control points", are the
//! points used to shape and reshape the surface. They
//! comprise a rectangular network of points:
//! - The points (1, 1), (NbUPoles, 1), (1,
//! NbVPoles) and (NbUPoles, NbVPoles)
//! are the four parametric "corners" of the surface.
//! - The first column of poles and the last column of
//! poles define two Bezier curves which delimit the
//! surface in the v parametric direction. These are
//! the v isoparametric curves corresponding to
//! values 0 and 1 of the v parameter.
//! - The first row of poles and the last row of poles
//! define two Bezier curves which delimit the surface
//! in the u parametric direction. These are the u
//! isoparametric curves corresponding to values 0
//! and 1 of the u parameter.
//! It is more difficult to define a geometrical significance
//! for the weights. However they are useful for
//! representing a quadric surface precisely. Moreover, if
//! the weights of all the poles are equal, the surface has
//! a polynomial equation, and hence is a "non-rational surface".
//! The non-rational surface is a special, but frequently
//! used, case, where all poles have identical weights.
//! The weights are defined and used only in the case of
//! a rational surface. This rational characteristic is
//! defined in each parametric direction. Hence, a
//! surface can be rational in the u parametric direction,
//! and non-rational in the v parametric direction.
//! Likewise, the degree of a surface is defined in each
//! parametric direction. The degree of a Bezier surface
//! in a given parametric direction is equal to the number
//! of poles of the surface in that parametric direction,
//! minus 1. This must be greater than or equal to 1.
//! However, the degree for a Geom_BezierSurface is
//! limited to a value of (25) which is defined and
//! controlled by the system. This value is returned by the
//! function MaxDegree.
//! The parameter range for a Bezier surface is [ 0, 1 ]
//! in the two parametric directions.
//! A Bezier surface can also be closed, or open, in each
//! parametric direction. If the first row of poles is
//! identical to the last row of poles, the surface is closed
//! in the u parametric direction. If the first column of
//! poles is identical to the last column of poles, the
//! surface is closed in the v parametric direction.
//! The continuity of a Bezier surface is infinite in the u
//! parametric direction and the in v parametric direction.
//! Note: It is not possible to build a Bezier surface with
//! negative weights. Any weight value that is less than,
//! or equal to, gp::Resolution() is considered
//! to be zero. Two weight values, W1 and W2, are
//! considered equal if: |W2-W1| <= gp::Resolution()
class Geom_BezierSurface : public Geom_BoundedSurface
{

public:
  //! Creates a non-rational Bezier surface with a set of poles.
  //! Control points representation :
  //! SPoles(Uorigin,Vorigin) ...................SPoles(Uorigin,Vend)
  //! .                                     .
  //! .                                     .
  //! SPoles(Uend, Vorigin) .....................SPoles(Uend, Vend)
  //! For the double array the row indice corresponds to the parametric
  //! U direction and the columns indice corresponds to the parametric
  //! V direction.
  //! The weights are defaulted to all being 1.
  //!
  //! Raised if the number of poles of the surface is lower than 2
  //! or greater than MaxDegree + 1 in one of the two directions
  //! U or V.
  Standard_EXPORT Geom_BezierSurface(const NCollection_Array2<gp_Pnt>& SurfacePoles);

  //! Copy constructor for optimized copying without validation.
  //! @param[in] theOther the Bezier surface to copy from
  Standard_EXPORT Geom_BezierSurface(const Geom_BezierSurface& theOther);

  //! Returns true if an evaluation representation is attached.
  bool HasEvalRepresentation() const { return !myEvalRep.IsNull(); }

  //! Returns the current evaluation representation descriptor (may be null).
  const occ::handle<GeomEval_RepSurfaceDesc::Base>& EvalRepresentation() const { return myEvalRep; }

  //! Sets a new evaluation representation.
  //! Validates descriptor data and ensures no circular references.
  Standard_EXPORT void SetEvalRepresentation(
    const occ::handle<GeomEval_RepSurfaceDesc::Base>& theDesc);

  //! Removes the evaluation representation.
  void ClearEvalRepresentation() { myEvalRep.Nullify(); }

  //! ---Purpose
  //! Creates a rational Bezier surface with a set of poles and a
  //! set of weights.
  //! For the double array the row indice corresponds to the parametric
  //! U direction and the columns indice corresponds to the parametric
  //! V direction.
  //! If all the weights are identical the surface is considered as
  //! non-rational (the tolerance criterion is Resolution from package
  //! gp).
  //!
  //! Raised if SurfacePoles and PoleWeights have not the same
  //! Rowlength or have not the same ColLength.
  //! Raised if PoleWeights (i, j) <= Resolution from gp;
  //! Raised if the number of poles of the surface is lower than 2
  //! or greater than MaxDegree + 1 in one of the two directions U or V.
  Standard_EXPORT Geom_BezierSurface(const NCollection_Array2<gp_Pnt>& SurfacePoles,
                                     const NCollection_Array2<double>& PoleWeights);

  //! Exchanges the direction U and V on a Bezier surface
  //! As a consequence:
  //! - the poles and weights tables are transposed,
  //! - degrees, rational characteristics and so on are
  //! exchanged between the two parametric directions, and
  //! - the orientation of the surface is reversed.
  Standard_EXPORT void ExchangeUV();

  //! Increases the degree of this Bezier surface in the two parametric directions.
  //!
  //! Raised if UDegree < UDegree <me> or VDegree < VDegree <me>
  //! Raised if the degree of the surface is greater than MaxDegree
  //! in one of the two directions U or V.
  Standard_EXPORT void Increase(const int UDeg, const int VDeg);

  //! Inserts a column of poles. If the surface is rational the weights
  //! values associated with CPoles are equal defaulted to 1.
  //!
  //! Raised if Vindex < 1 or VIndex > NbVPoles.
  //!
  //! raises if VDegree is greater than MaxDegree.
  //! raises if the Length of CPoles is not equal to NbUPoles
  Standard_EXPORT void InsertPoleColAfter(const int                         VIndex,
                                          const NCollection_Array1<gp_Pnt>& CPoles);

  //! Inserts a column of poles and weights.
  //! If the surface was non-rational it can become rational.
  //!
  //! Raised if Vindex < 1 or VIndex > NbVPoles.
  //! Raised if
  //! . VDegree is greater than MaxDegree.
  //! . the Length of CPoles is not equal to NbUPoles
  //! . a weight value is lower or equal to Resolution from
  //! package gp
  Standard_EXPORT void InsertPoleColAfter(const int                         VIndex,
                                          const NCollection_Array1<gp_Pnt>& CPoles,
                                          const NCollection_Array1<double>& CPoleWeights);

  //! Inserts a column of poles. If the surface is rational the weights
  //! values associated with CPoles are equal defaulted to 1.
  //!
  //! Raised if Vindex < 1 or VIndex > NbVPoles.
  //!
  //! Raised if VDegree is greater than MaxDegree.
  //! Raised if the Length of CPoles is not equal to NbUPoles
  Standard_EXPORT void InsertPoleColBefore(const int                         VIndex,
                                           const NCollection_Array1<gp_Pnt>& CPoles);

  //! Inserts a column of poles and weights.
  //! If the surface was non-rational it can become rational.
  //!
  //! Raised if Vindex < 1 or VIndex > NbVPoles.
  //! Raised if :
  //! . VDegree is greater than MaxDegree.
  //! . the Length of CPoles is not equal to NbUPoles
  //! . a weight value is lower or equal to Resolution from
  //! package gp
  Standard_EXPORT void InsertPoleColBefore(const int                         VIndex,
                                           const NCollection_Array1<gp_Pnt>& CPoles,
                                           const NCollection_Array1<double>& CPoleWeights);

  //! Inserts a row of poles. If the surface is rational the weights
  //! values associated with CPoles are equal defaulted to 1.
  //!
  //! Raised if Uindex < 1 or UIndex > NbUPoles.
  //!
  //! Raised if UDegree is greater than MaxDegree.
  //! Raised if the Length of CPoles is not equal to NbVPoles
  Standard_EXPORT void InsertPoleRowAfter(const int                         UIndex,
                                          const NCollection_Array1<gp_Pnt>& CPoles);

  //! Inserts a row of poles and weights.
  //! If the surface was non-rational it can become rational.
  //!
  //! Raised if Uindex < 1 or UIndex > NbUPoles.
  //! Raised if :
  //! . UDegree is greater than MaxDegree.
  //! . the Length of CPoles is not equal to NbVPoles
  //! . a weight value is lower or equal to Resolution from
  //! package gp
  Standard_EXPORT void InsertPoleRowAfter(const int                         UIndex,
                                          const NCollection_Array1<gp_Pnt>& CPoles,
                                          const NCollection_Array1<double>& CPoleWeights);

  //! Inserts a row of poles. If the surface is rational the weights
  //! values associated with CPoles are equal defaulted to 1.
  //!
  //! Raised if Uindex < 1 or UIndex > NbUPoles.
  //!
  //! Raised if UDegree is greater than MaxDegree.
  //! Raised if the Length of CPoles is not equal to NbVPoles
  Standard_EXPORT void InsertPoleRowBefore(const int                         UIndex,
                                           const NCollection_Array1<gp_Pnt>& CPoles);

  //! Inserts a row of poles and weights.
  //! If the surface was non-rational it can become rational.
  //!
  //! Raised if Uindex < 1 or UIndex > NbUPoles.
  //! Raised if :
  //! . UDegree is greater than MaxDegree.
  //! . the Length of CPoles is not equal to NbVPoles
  //! . a weight value is lower or equal to Resolution from
  //! package gp
  Standard_EXPORT void InsertPoleRowBefore(const int                         UIndex,
                                           const NCollection_Array1<gp_Pnt>& CPoles,
                                           const NCollection_Array1<double>& CPoleWeights);

  //! Removes a column of poles.
  //! If the surface was rational it can become non-rational.
  //!
  //! Raised if NbVPoles <= 2 after removing, a Bezier surface
  //! must have at least two columns of poles.
  //! Raised if Vindex < 1 or VIndex > NbVPoles
  Standard_EXPORT void RemovePoleCol(const int VIndex);

  //! Removes a row of poles.
  //! If the surface was rational it can become non-rational.
  //!
  //! Raised if NbUPoles <= 2 after removing, a Bezier surface
  //! must have at least two rows of poles.
  //! Raised if Uindex < 1 or UIndex > NbUPoles
  Standard_EXPORT void RemovePoleRow(const int UIndex);

  //! Modifies this Bezier surface by segmenting it
  //! between U1 and U2 in the u parametric direction,
  //! and between V1 and V2 in the v parametric
  //! direction. U1, U2, V1, and V2 can be outside the
  //! bounds of this surface.
  //! - U1 and U2 isoparametric Bezier curves,
  //! segmented between V1 and V2, become the two
  //! bounds of the surface in the v parametric
  //! direction (0. and 1. u isoparametric curves).
  //! - V1 and V2 isoparametric Bezier curves,
  //! segmented between U1 and U2, become the two
  //! bounds of the surface in the u parametric
  //! direction (0. and 1. v isoparametric curves).
  //! The poles and weights tables are modified, but the
  //! degree of this surface in the u and v parametric
  //! directions does not change.
  //! U1 can be greater than U2, and V1 can be greater
  //! than V2. In these cases, the corresponding
  //! parametric direction is inverted. The orientation of
  //! the surface is inverted if one (and only one)
  //! parametric direction is inverted.
  Standard_EXPORT void Segment(const double U1, const double U2, const double V1, const double V2);

  //! Modifies a pole value.
  //! If the surface is rational the weight of range (UIndex, VIndex)
  //! is not modified.
  //!
  //! Raised if UIndex < 1 or UIndex > NbUPoles or VIndex < 1
  //! or VIndex > NbVPoles.
  Standard_EXPORT void SetPole(const int UIndex, const int VIndex, const gp_Pnt& P);

  //! Substitutes the pole and the weight of range UIndex, VIndex.
  //! If the surface <me> is not rational it can become rational.
  //! if the surface was rational it can become non-rational.
  //!
  //! raises if UIndex < 1 or UIndex > NbUPoles or VIndex < 1
  //! or VIndex > NbVPoles.
  //! Raised if Weight <= Resolution from package gp.
  Standard_EXPORT void SetPole(const int     UIndex,
                               const int     VIndex,
                               const gp_Pnt& P,
                               const double  Weight);

  //! Modifies a column of poles.
  //! The length of CPoles can be lower but not greater than NbUPoles
  //! so you can modify just a part of the column.
  //! Raised if VIndex < 1 or VIndex > NbVPoles
  //!
  //! Raised if CPoles.Lower() < 1 or CPoles.Upper() > NbUPoles
  Standard_EXPORT void SetPoleCol(const int VIndex, const NCollection_Array1<gp_Pnt>& CPoles);

  //! Modifies a column of poles.
  //! If the surface was rational it can become non-rational
  //! If the surface was non-rational it can become rational.
  //! The length of CPoles can be lower but not greater than NbUPoles
  //! so you can modify just a part of the column.
  //! Raised if VIndex < 1 or VIndex > NbVPoles
  //!
  //! Raised if CPoles.Lower() < 1 or CPoles.Upper() > NbUPoles
  //! Raised if CPoleWeights and CPoles have not the same bounds.
  //! Raised if one of the weight value CPoleWeights (i) is lower
  //! or equal to Resolution from package gp.
  Standard_EXPORT void SetPoleCol(const int                         VIndex,
                                  const NCollection_Array1<gp_Pnt>& CPoles,
                                  const NCollection_Array1<double>& CPoleWeights);

  //! Modifies a row of poles.
  //! The length of CPoles can be lower but not greater than NbVPoles
  //! so you can modify just a part of the row.
  //! Raised if UIndex < 1 or UIndex > NbUPoles
  //!
  //! Raised if CPoles.Lower() < 1 or CPoles.Upper() > NbVPoles
  Standard_EXPORT void SetPoleRow(const int UIndex, const NCollection_Array1<gp_Pnt>& CPoles);

  //! Modifies a row of poles and weights.
  //! If the surface was rational it can become non-rational.
  //! If the surface was non-rational it can become rational.
  //! The length of CPoles can be lower but not greater than NbVPoles
  //! so you can modify just a part of the row.
  //! Raised if UIndex < 1 or UIndex > NbUPoles
  //!
  //! Raised if CPoles.Lower() < 1 or CPoles.Upper() > NbVPoles
  //! Raised if CPoleWeights and CPoles have not the same bounds.
  //! Raised if one of the weight value CPoleWeights (i) is lower
  //! or equal to Resolution from gp.
  Standard_EXPORT void SetPoleRow(const int                         UIndex,
                                  const NCollection_Array1<gp_Pnt>& CPoles,
                                  const NCollection_Array1<double>& CPoleWeights);

  //! Modifies the weight of the pole of range UIndex, VIndex.
  //! If the surface was non-rational it can become rational.
  //! If the surface was rational it can become non-rational.
  //!
  //! Raised if UIndex < 1 or UIndex > NbUPoles or VIndex < 1 or
  //! VIndex > NbVPoles.
  //! Raised if Weight <= Resolution from package gp.
  Standard_EXPORT void SetWeight(const int UIndex, const int VIndex, const double Weight);

  //! Modifies a column of weights.
  //! If the surface was rational it can become non-rational.
  //! If the surface was non-rational it can become rational.
  //! The length of CPoleWeights can be lower but not greater than
  //! NbUPoles.
  //! Raised if VIndex < 1 or VIndex > NbVPoles
  //!
  //! Raised if CPoleWeights.Lower() < 1 or CPoleWeights.Upper() >
  //! NbUPoles
  //! Raised if one of the weight value CPoleWeights (i) is lower
  //! or equal to Resolution from package gp.
  Standard_EXPORT void SetWeightCol(const int                         VIndex,
                                    const NCollection_Array1<double>& CPoleWeights);

  //! Modifies a row of weights.
  //! If the surface was rational it can become non-rational.
  //! If the surface was non-rational it can become rational.
  //! The length of CPoleWeights can be lower but not greater than
  //! NbVPoles.
  //! Raised if UIndex < 1 or UIndex > NbUPoles
  //!
  //! Raised if CPoleWeights.Lower() < 1 or CPoleWeights.Upper() >
  //! NbVPoles
  //! Raised if one of the weight value CPoleWeights (i) is lower
  //! or equal to Resolution from package gp.
  Standard_EXPORT void SetWeightRow(const int                         UIndex,
                                    const NCollection_Array1<double>& CPoleWeights);

  //! Changes the orientation of this Bezier surface in the
  //! u parametric direction. The bounds of the
  //! surface are not changed, but the given parametric
  //! direction is reversed. Hence, the orientation of the surface is reversed.
  Standard_EXPORT void UReverse() final;

  //! Computes the u (or v) parameter on the modified
  //! surface, produced by reversing its u (or v) parametric
  //! direction, for any point of u parameter U (or of v
  //! parameter V) on this Bezier surface.
  //! In the case of a Bezier surface, these functions return respectively:
  //! - 1.-U, or 1.-V.
  Standard_EXPORT double UReversedParameter(const double U) const final;

  //! Changes the orientation of this Bezier surface in the
  //! v parametric direction. The bounds of the
  //! surface are not changed, but the given parametric
  //! direction is reversed. Hence, the orientation of the
  //! surface is reversed.
  Standard_EXPORT void VReverse() final;

  //! Computes the u (or v) parameter on the modified
  //! surface, produced by reversing its u (or v) parametric
  //! direction, for any point of u parameter U (or of v
  //! parameter V) on this Bezier surface.
  //! In the case of a Bezier surface, these functions return respectively:
  //! - 1.-U, or 1.-V.
  Standard_EXPORT double VReversedParameter(const double V) const final;

  //! Returns the parametric bounds U1, U2, V1 and V2 of
  //! this Bezier surface.
  //! In the case of a Bezier surface, this function returns
  //! U1 = 0, V1 = 0, U2 = 1, V2 = 1.
  Standard_EXPORT void Bounds(double& U1, double& U2, double& V1, double& V2) const final;

  //! Returns the continuity of the surface CN : the order of
  //! continuity is infinite.
  Standard_EXPORT GeomAbs_Shape Continuity() const final;

  //! Computes the point of parameter (U, V) on the surface.
  //! Raises an exception on failure.
  Standard_EXPORT gp_Pnt EvalD0(const double U, const double V) const final;

  //! Computes the point and first partial derivatives at (U, V).
  //! Raises an exception if the surface continuity is not C1.
  Standard_EXPORT Geom_Surface::ResD1 EvalD1(const double U, const double V) const final;

  //! Computes the point and partial derivatives up to 2nd order at (U, V).
  //! Raises an exception if the surface continuity is not C2.
  Standard_EXPORT Geom_Surface::ResD2 EvalD2(const double U, const double V) const final;

  //! Computes the point and partial derivatives up to 3rd order at (U, V).
  //! Note: The parameters U and V can be outside the bounds of the surface.
  //! Raises an exception if the surface continuity is not C3.
  Standard_EXPORT Geom_Surface::ResD3 EvalD3(const double U, const double V) const final;

  //! Computes the derivative of order Nu in the u
  //! parametric direction, and Nv in the v parametric
  //! direction, at the point of parameters (U, V) of this Bezier surface.
  //! Note: The parameters U and V can be outside the bounds of the surface.
  //! Raises an exception on failure.
  //! Exceptions
  //! Standard_RangeError if:
  //! - Nu + Nv is less than 1, or Nu or Nv is negative.
  Standard_EXPORT gp_Vec EvalDN(const double U,
                                const double V,
                                const int    Nu,
                                const int    Nv) const final;

  //! Returns the number of poles in the U direction.
  Standard_EXPORT int NbUPoles() const;

  //! Returns the number of poles in the V direction.
  Standard_EXPORT int NbVPoles() const;

  //! Returns the pole of range UIndex, VIndex
  //! Raised if UIndex < 1 or UIndex > NbUPoles, or
  //! VIndex < 1 or VIndex > NbVPoles.
  Standard_EXPORT const gp_Pnt& Pole(const int UIndex, const int VIndex) const;

  //! Returns the poles of the Bezier surface.
  //!
  //! Raised if the length of P in the U an V direction is not equal to
  //! NbUPoles and NbVPoles.
  Standard_DEPRECATED("use Poles() returning const reference instead")
  Standard_EXPORT void Poles(NCollection_Array2<gp_Pnt>& P) const;

  //! Returns the poles of the Bezier surface.
  const NCollection_Array2<gp_Pnt>& Poles() const { return myPoles; }

  //! Returns the degree of the surface in the U direction it is
  //! NbUPoles - 1
  Standard_EXPORT int UDegree() const;

  //! Computes the U isoparametric curve. For a Bezier surface the
  //! UIso curve is a Bezier curve.
  Standard_EXPORT occ::handle<Geom_Curve> UIso(const double U) const final;

  //! Returns the degree of the surface in the V direction it is
  //! NbVPoles - 1
  Standard_EXPORT int VDegree() const;

  //! Computes the V isoparametric curve. For a Bezier surface the
  //! VIso curve is a Bezier curve.
  Standard_EXPORT occ::handle<Geom_Curve> VIso(const double V) const final;

  //! Returns the weight of range UIndex, VIndex
  //!
  //! Raised if UIndex < 1 or UIndex > NbUPoles, or
  //! VIndex < 1 or VIndex > NbVPoles.
  Standard_EXPORT double Weight(const int UIndex, const int VIndex) const;

  //! Returns the weights of the Bezier surface.
  //!
  //! Raised if the length of W in the U an V direction is not
  //! equal to NbUPoles and NbVPoles.
  Standard_DEPRECATED("use Weights() returning const pointer instead")
  Standard_EXPORT void Weights(NCollection_Array2<double>& W) const;

  //! Returns the weights of the Bezier surface.
  const NCollection_Array2<double>* Weights() const
  {
    return (myURational || myVRational) ? &myWeights : BSplSLib::NoWeights();
  }

  //! Returns a const reference to the weights array.
  //! For rational surfaces: the internal owning weights array.
  //! For non-rational surfaces: a non-owning view of unit weights from BSplSLib.
  //! The array is always sized to match NbUPoles() x NbVPoles().
  //! @warning Do NOT modify elements through the returned reference.
  const NCollection_Array2<double>& WeightsArray() const { return myWeights; }

  //! Returns True if the first control points row and the
  //! last control points row are identical. The tolerance
  //! criterion is Resolution from package gp.
  Standard_EXPORT bool IsUClosed() const final;

  //! Returns True if the first control points column
  //! and the last control points column are identical.
  //! The tolerance criterion is Resolution from package gp.
  Standard_EXPORT bool IsVClosed() const final;

  //! Returns True, a Bezier surface is always CN
  Standard_EXPORT bool IsCNu(const int N) const final;

  //! Returns True, a BezierSurface is always CN
  Standard_EXPORT bool IsCNv(const int N) const final;

  //! Returns False.
  Standard_EXPORT bool IsUPeriodic() const final;

  //! Returns False.
  Standard_EXPORT bool IsVPeriodic() const final;

  //! Returns False if the weights are identical in the U direction,
  //! The tolerance criterion is Resolution from package gp.
  //! Example :
  //! |1.0, 1.0, 1.0|
  //! if Weights =  |0.5, 0.5, 0.5|   returns False
  //! |2.0, 2.0, 2.0|
  Standard_EXPORT bool IsURational() const;

  //! Returns False if the weights are identical in the V direction,
  //! The tolerance criterion is Resolution from package gp.
  //! Example :
  //! |1.0, 2.0, 0.5|
  //! if Weights =  |1.0, 2.0, 0.5|   returns False
  //! |1.0, 2.0, 0.5|
  Standard_EXPORT bool IsVRational() const;

  //! Applies the transformation T to this Bezier surface.
  Standard_EXPORT void Transform(const gp_Trsf& T) final;

  //! Returns the value of the maximum polynomial degree of a
  //! Bezier surface. This value is 25.
  Standard_EXPORT static int MaxDegree();

  //! Computes two tolerance values for this Bezier
  //! surface, based on the given tolerance in 3D space
  //! Tolerance3D. The tolerances computed are:
  //! - UTolerance in the u parametric direction, and
  //! - VTolerance in the v parametric direction.
  //! If f(u,v) is the equation of this Bezier surface,
  //! UTolerance and VTolerance guarantee that:
  //! | u1 - u0 | < UTolerance and
  //! | v1 - v0 | < VTolerance
  //! ====> |f (u1,v1) - f (u0,v0)| < Tolerance3D
  Standard_EXPORT void Resolution(const double Tolerance3D, double& UTolerance, double& VTolerance);

  //! Creates a new object which is a copy of this Bezier surface.
  Standard_EXPORT occ::handle<Geom_Geometry> Copy() const final;

  //! Dumps the content of me into the stream
  Standard_EXPORT void DumpJson(Standard_OStream& theOStream, int theDepth = -1) const final;

  //! Returns Bezier knots {0.0, 1.0} as a static array.
  Standard_EXPORT const NCollection_Array1<double>& UKnots() const;

  //! Returns Bezier knots {0.0, 1.0} as a static array.
  Standard_EXPORT const NCollection_Array1<double>& VKnots() const;

  //! Returns Bezier multiplicities for the U degree.
  Standard_EXPORT const NCollection_Array1<int>& UMultiplicities() const;

  //! Returns Bezier multiplicities for the V degree.
  Standard_EXPORT const NCollection_Array1<int>& VMultiplicities() const;

  //! Returns Bezier flat knots for the U degree.
  Standard_EXPORT const NCollection_Array1<double>& UKnotSequence() const;

  //! Returns Bezier flat knots for the V degree.
  Standard_EXPORT const NCollection_Array1<double>& VKnotSequence() const;

  DEFINE_STANDARD_RTTIEXT(Geom_BezierSurface, Geom_BoundedSurface)

protected:
  //! Set poles to thePoles, weights to theWeights.
  //! If theWeights is null the surface is non rational.
  //! Update rational flags.
  void init(const NCollection_Array2<gp_Pnt>& thePoles,
            const NCollection_Array2<double>* theWeights);

private:
  NCollection_Array2<gp_Pnt>                 myPoles;
  NCollection_Array2<double>                 myWeights;
  occ::handle<GeomEval_RepSurfaceDesc::Base> myEvalRep;
  bool                                       myURational     = false;
  bool                                       myVRational     = false;
  double                                     myUMaxDerivInv  = 0.0;
  double                                     myVMaxDerivInv  = 0.0;
  bool                                       myMaxDerivInvOk = false;
};

#endif // _Geom_BezierSurface_HeaderFile