text: # This file was automatically generated by SWIG (http://www.swig.org).
  # Version 2.0.10
  #
  # Do not make changes to this file unless you know what you are doing--modify
  # the SWIG interface file instead.
  
  
  
  from sys import version_info
  if version_info >= (3,0,0):
      new_instancemethod = lambda func, inst, cls: _CPnts.SWIG_PyInstanceMethod_New(func)
  else:
      from new import instancemethod as new_instancemethod
  if version_info >= (2,6,0):
      def swig_import_helper():
          from os.path import dirname
          import imp
          fp = None
          try:
              fp, pathname, description = imp.find_module('_CPnts', [dirname(__file__)])
          except ImportError:
              import _CPnts
              return _CPnts
          if fp is not None:
              try:
                  _mod = imp.load_module('_CPnts', fp, pathname, description)
              finally:
                  fp.close()
              return _mod
      _CPnts = swig_import_helper()
      del swig_import_helper
  else:
      import _CPnts
  del version_info
  try:
      _swig_property = property
  except NameError:
      pass # Python < 2.2 doesn't have 'property'.
  def _swig_setattr_nondynamic(self,class_type,name,value,static=1):
      if (name == "thisown"): return self.this.own(value)
      if (name == "this"):
          if type(value).__name__ == 'SwigPyObject':
              self.__dict__[name] = value
              return
      method = class_type.__swig_setmethods__.get(name,None)
      if method: return method(self,value)
      if (not static):
          self.__dict__[name] = value
      else:
          raise AttributeError("You cannot add attributes to %s" % self)
  
  def _swig_setattr(self,class_type,name,value):
      return _swig_setattr_nondynamic(self,class_type,name,value,0)
  
  def _swig_getattr(self,class_type,name):
      if (name == "thisown"): return self.this.own()
      method = class_type.__swig_getmethods__.get(name,None)
      if method: return method(self)
      raise AttributeError(name)
  
  def _swig_repr(self):
      try: strthis = "proxy of " + self.this.__repr__()
      except: strthis = ""
      return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)
  
  try:
      _object = object
      _newclass = 1
  except AttributeError:
      class _object : pass
      _newclass = 0
  
  
  def _swig_setattr_nondynamic_method(set):
      def set_attr(self,name,value):
          if (name == "thisown"): return self.this.own(value)
          if hasattr(self,name) or (name == "this"):
              set(self,name,value)
          else:
              raise AttributeError("You cannot add attributes to %s" % self)
      return set_attr
  
  
  class SwigPyIterator(object):
      thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
      def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
      __repr__ = _swig_repr
      __swig_destroy__ = _CPnts.delete_SwigPyIterator
      def __iter__(self): return self
  SwigPyIterator.value = new_instancemethod(_CPnts.SwigPyIterator_value,None,SwigPyIterator)
  SwigPyIterator.incr = new_instancemethod(_CPnts.SwigPyIterator_incr,None,SwigPyIterator)
  SwigPyIterator.decr = new_instancemethod(_CPnts.SwigPyIterator_decr,None,SwigPyIterator)
  SwigPyIterator.distance = new_instancemethod(_CPnts.SwigPyIterator_distance,None,SwigPyIterator)
  SwigPyIterator.equal = new_instancemethod(_CPnts.SwigPyIterator_equal,None,SwigPyIterator)
  SwigPyIterator.copy = new_instancemethod(_CPnts.SwigPyIterator_copy,None,SwigPyIterator)
  SwigPyIterator.next = new_instancemethod(_CPnts.SwigPyIterator_next,None,SwigPyIterator)
  SwigPyIterator.__next__ = new_instancemethod(_CPnts.SwigPyIterator___next__,None,SwigPyIterator)
  SwigPyIterator.previous = new_instancemethod(_CPnts.SwigPyIterator_previous,None,SwigPyIterator)
  SwigPyIterator.advance = new_instancemethod(_CPnts.SwigPyIterator_advance,None,SwigPyIterator)
  SwigPyIterator.__eq__ = new_instancemethod(_CPnts.SwigPyIterator___eq__,None,SwigPyIterator)
  SwigPyIterator.__ne__ = new_instancemethod(_CPnts.SwigPyIterator___ne__,None,SwigPyIterator)
  SwigPyIterator.__iadd__ = new_instancemethod(_CPnts.SwigPyIterator___iadd__,None,SwigPyIterator)
  SwigPyIterator.__isub__ = new_instancemethod(_CPnts.SwigPyIterator___isub__,None,SwigPyIterator)
  SwigPyIterator.__add__ = new_instancemethod(_CPnts.SwigPyIterator___add__,None,SwigPyIterator)
  SwigPyIterator.__sub__ = new_instancemethod(_CPnts.SwigPyIterator___sub__,None,SwigPyIterator)
  SwigPyIterator_swigregister = _CPnts.SwigPyIterator_swigregister
  SwigPyIterator_swigregister(SwigPyIterator)
  
  import OCC.Adaptor3d
  import OCC.Standard
  import OCC.GeomAbs
  import OCC.TColStd
  import OCC.TCollection
  import OCC.MMgt
  import OCC.gp
  import OCC.Geom
  import OCC.TColgp
  import OCC.Adaptor2d
  import OCC.Geom2d
  import OCC.TopAbs
  import OCC.math
  def register_handle(handle, base_object):
      """
      Inserts the handle into the base object to
      prevent memory corruption in certain cases
      """
      try:
          if base_object.IsKind("Standard_Transient"):
              base_object.thisHandle = handle
              base_object.thisown = False
      except:
          pass
  
  class CPnts_AbscissaPoint(object):
      thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
      __repr__ = _swig_repr
      def Length(*args):
          """
          * Computes the length of the Curve <C>.
  
          :param C:
          :type C: Adaptor3d_Curve &
          :rtype: float
  
          * Computes the length of the Curve <C>.
  
          :param C:
          :type C: Adaptor2d_Curve2d &
          :rtype: float
  
          * Computes the length of the Curve <C> with the given tolerance.
  
          :param C:
          :type C: Adaptor3d_Curve &
          :param Tol:
          :type Tol: float
          :rtype: float
  
          * Computes the length of the Curve <C> with the given tolerance.
  
          :param C:
          :type C: Adaptor2d_Curve2d &
          :param Tol:
          :type Tol: float
          :rtype: float
  
          * Computes the length of the Curve <C> between <U1> and <U2>.
  
          :param C:
          :type C: Adaptor3d_Curve &
          :param U1:
          :type U1: float
          :param U2:
          :type U2: float
          :rtype: float
  
          * Computes the length of the Curve <C> between <U1> and <U2>.
  
          :param C:
          :type C: Adaptor2d_Curve2d &
          :param U1:
          :type U1: float
          :param U2:
          :type U2: float
          :rtype: float
  
          * Computes the length of the Curve <C> between <U1> and <U2> with the given tolerance.
  
          :param C:
          :type C: Adaptor3d_Curve &
          :param U1:
          :type U1: float
          :param U2:
          :type U2: float
          :param Tol:
          :type Tol: float
          :rtype: float
  
          * Computes the length of the Curve <C> between <U1> and <U2> with the given tolerance. creation of a indefinite AbscissaPoint.
  
          :param C:
          :type C: Adaptor2d_Curve2d &
          :param U1:
          :type U1: float
          :param U2:
          :type U2: float
          :param Tol:
          :type Tol: float
          :rtype: float
  
          """
          return _CPnts.CPnts_AbscissaPoint_Length(*args)
  
      Length = staticmethod(Length)
      def __init__(self, *args): 
          """
          :rtype: None
  
          * the algorithm computes a point on a curve <Curve> at the distance <Abscissa> from the point of parameter <U0>. <Resolution> is the error allowed in the computation. The computed point can be outside of the curve 's bounds.
  
          :param C:
          :type C: Adaptor3d_Curve &
          :param Abscissa:
          :type Abscissa: float
          :param U0:
          :type U0: float
          :param Resolution:
          :type Resolution: float
          :rtype: None
  
          * the algorithm computes a point on a curve <Curve> at the distance <Abscissa> from the point of parameter <U0>. <Resolution> is the error allowed in the computation. The computed point can be outside of the curve 's bounds.
  
          :param C:
          :type C: Adaptor2d_Curve2d &
          :param Abscissa:
          :type Abscissa: float
          :param U0:
          :type U0: float
          :param Resolution:
          :type Resolution: float
          :rtype: None
  
          * the algorithm computes a point on a curve <Curve> at the distance <Abscissa> from the point of parameter <U0>. <Ui> is the starting value used in the iterative process which find the solution, it must be closed to the final solution <Resolution> is the error allowed in the computation. The computed point can be outside of the curve 's bounds.
  
          :param C:
          :type C: Adaptor3d_Curve &
          :param Abscissa:
          :type Abscissa: float
          :param U0:
          :type U0: float
          :param Ui:
          :type Ui: float
          :param Resolution:
          :type Resolution: float
          :rtype: None
  
          * the algorithm computes a point on a curve <Curve> at the distance <Abscissa> from the point of parameter <U0>. <Ui> is the starting value used in the iterative process which find the solution, it must be closed to the final solution <Resolution> is the error allowed in the computation. The computed point can be outside of the curve 's bounds.
  
          :param C:
          :type C: Adaptor2d_Curve2d &
          :param Abscissa:
          :type Abscissa: float
          :param U0:
          :type U0: float
          :param Ui:
          :type Ui: float
          :param Resolution:
          :type Resolution: float
          :rtype: None
  
          """
          _CPnts.CPnts_AbscissaPoint_swiginit(self,_CPnts.new_CPnts_AbscissaPoint(*args))
      def Init(self, *args):
          """
          * Initializes the resolution function with <C>.
  
          :param C:
          :type C: Adaptor3d_Curve &
          :rtype: None
  
          * Initializes the resolution function with <C>.
  
          :param C:
          :type C: Adaptor2d_Curve2d &
          :rtype: None
  
          * Initializes the resolution function with <C>.
  
          :param C:
          :type C: Adaptor3d_Curve &
          :param Tol:
          :type Tol: float
          :rtype: None
  
          * Initializes the resolution function with <C>.
  
          :param C:
          :type C: Adaptor2d_Curve2d &
          :param Tol:
          :type Tol: float
          :rtype: None
  
          * Initializes the resolution function with <C> between U1 and U2.
  
          :param C:
          :type C: Adaptor3d_Curve &
          :param U1:
          :type U1: float
          :param U2:
          :type U2: float
          :rtype: None
  
          * Initializes the resolution function with <C> between U1 and U2.
  
          :param C:
          :type C: Adaptor2d_Curve2d &
          :param U1:
          :type U1: float
          :param U2:
          :type U2: float
          :rtype: None
  
          * Initializes the resolution function with <C> between U1 and U2.
  
          :param C:
          :type C: Adaptor3d_Curve &
          :param U1:
          :type U1: float
          :param U2:
          :type U2: float
          :param Tol:
          :type Tol: float
          :rtype: None
  
          * Initializes the resolution function with <C> between U1 and U2.
  
          :param C:
          :type C: Adaptor2d_Curve2d &
          :param U1:
          :type U1: float
          :param U2:
          :type U2: float
          :param Tol:
          :type Tol: float
          :rtype: None
  
          """
          return _CPnts.CPnts_AbscissaPoint_Init(self, *args)
  
      def Perform(self, *args):
          """
          * Computes the point at the distance <Abscissa> of the curve.
  
          :param Abscissa:
          :type Abscissa: float
          :param U0:
          :type U0: float
          :param Resolution:
          :type Resolution: float
          :rtype: None
  
          * Computes the point at the distance <Abscissa> of the curve.
  
          :param Abscissa:
          :type Abscissa: float
          :param U0:
          :type U0: float
          :param Ui:
          :type Ui: float
          :param Resolution:
          :type Resolution: float
          :rtype: None
  
          """
          return _CPnts.CPnts_AbscissaPoint_Perform(self, *args)
  
      def AdvPerform(self, *args):
          """
          * Computes the point at the distance <Abscissa> of the curve; performs more appropriate tolerance managment; to use this method in right way it is necessary to call empty consructor. then call method Init with //!	 Tolerance = Resolution, then call AdvPermorm.
  
          :param Abscissa:
          :type Abscissa: float
          :param U0:
          :type U0: float
          :param Ui:
          :type Ui: float
          :param Resolution:
          :type Resolution: float
          :rtype: None
  
          """
          return _CPnts.CPnts_AbscissaPoint_AdvPerform(self, *args)
  
      def IsDone(self, *args):
          """
          * True if the computation was successful, False otherwise.
  
          :rtype: bool
  
          """
          return _CPnts.CPnts_AbscissaPoint_IsDone(self, *args)
  
      def Parameter(self, *args):
          """
          * Returns the parameter of the solution.
  
          :rtype: float
  
          """
          return _CPnts.CPnts_AbscissaPoint_Parameter(self, *args)
  
      def SetParameter(self, *args):
          """
          * Enforce the solution, used by GCPnts.
  
          :param P:
          :type P: float
          :rtype: None
  
          """
          return _CPnts.CPnts_AbscissaPoint_SetParameter(self, *args)
  
      __swig_destroy__ = _CPnts.delete_CPnts_AbscissaPoint
  CPnts_AbscissaPoint.Init = new_instancemethod(_CPnts.CPnts_AbscissaPoint_Init,None,CPnts_AbscissaPoint)
  CPnts_AbscissaPoint.Perform = new_instancemethod(_CPnts.CPnts_AbscissaPoint_Perform,None,CPnts_AbscissaPoint)
  CPnts_AbscissaPoint.AdvPerform = new_instancemethod(_CPnts.CPnts_AbscissaPoint_AdvPerform,None,CPnts_AbscissaPoint)
  CPnts_AbscissaPoint.IsDone = new_instancemethod(_CPnts.CPnts_AbscissaPoint_IsDone,None,CPnts_AbscissaPoint)
  CPnts_AbscissaPoint.Parameter = new_instancemethod(_CPnts.CPnts_AbscissaPoint_Parameter,None,CPnts_AbscissaPoint)
  CPnts_AbscissaPoint.SetParameter = new_instancemethod(_CPnts.CPnts_AbscissaPoint_SetParameter,None,CPnts_AbscissaPoint)
  CPnts_AbscissaPoint_swigregister = _CPnts.CPnts_AbscissaPoint_swigregister
  CPnts_AbscissaPoint_swigregister(CPnts_AbscissaPoint)
  
  def CPnts_AbscissaPoint_Length(*args):
    """
      * Computes the length of the Curve <C>.
  
      :param C:
      :type C: Adaptor3d_Curve &
      :rtype: float
  
      * Computes the length of the Curve <C>.
  
      :param C:
      :type C: Adaptor2d_Curve2d &
      :rtype: float
  
      * Computes the length of the Curve <C> with the given tolerance.
  
      :param C:
      :type C: Adaptor3d_Curve &
      :param Tol:
      :type Tol: float
      :rtype: float
  
      * Computes the length of the Curve <C> with the given tolerance.
  
      :param C:
      :type C: Adaptor2d_Curve2d &
      :param Tol:
      :type Tol: float
      :rtype: float
  
      * Computes the length of the Curve <C> between <U1> and <U2>.
  
      :param C:
      :type C: Adaptor3d_Curve &
      :param U1:
      :type U1: float
      :param U2:
      :type U2: float
      :rtype: float
  
      * Computes the length of the Curve <C> between <U1> and <U2>.
  
      :param C:
      :type C: Adaptor2d_Curve2d &
      :param U1:
      :type U1: float
      :param U2:
      :type U2: float
      :rtype: float
  
      * Computes the length of the Curve <C> between <U1> and <U2> with the given tolerance.
  
      :param C:
      :type C: Adaptor3d_Curve &
      :param U1:
      :type U1: float
      :param U2:
      :type U2: float
      :param Tol:
      :type Tol: float
      :rtype: float
  
      * Computes the length of the Curve <C> between <U1> and <U2> with the given tolerance. creation of a indefinite AbscissaPoint.
  
      :param C:
      :type C: Adaptor2d_Curve2d &
      :param U1:
      :type U1: float
      :param U2:
      :type U2: float
      :param Tol:
      :type Tol: float
      :rtype: float
  
      """
    return _CPnts.CPnts_AbscissaPoint_Length(*args)
  
  class CPnts_MyGaussFunction(object):
      thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
      __repr__ = _swig_repr
      def __init__(self, *args): 
          """
          :rtype: None
  
          """
          _CPnts.CPnts_MyGaussFunction_swiginit(self,_CPnts.new_CPnts_MyGaussFunction(*args))
      def Init(self, *args):
          """
          * F is a pointer on a function D is a client data  Each value is computed with F(D)
  
          :param F:
          :type F: CPnts_RealFunction &
          :param D:
          :type D: Standard_Address
          :rtype: None
  
          """
          return _CPnts.CPnts_MyGaussFunction_Init(self, *args)
  
      def Value(self, *args):
          """
          :param X:
          :type X: float
          :param F:
          :type F: float &
          :rtype: bool
  
          """
          return _CPnts.CPnts_MyGaussFunction_Value(self, *args)
  
      __swig_destroy__ = _CPnts.delete_CPnts_MyGaussFunction
  CPnts_MyGaussFunction.Init = new_instancemethod(_CPnts.CPnts_MyGaussFunction_Init,None,CPnts_MyGaussFunction)
  CPnts_MyGaussFunction.Value = new_instancemethod(_CPnts.CPnts_MyGaussFunction_Value,None,CPnts_MyGaussFunction)
  CPnts_MyGaussFunction_swigregister = _CPnts.CPnts_MyGaussFunction_swigregister
  CPnts_MyGaussFunction_swigregister(CPnts_MyGaussFunction)
  
  class CPnts_MyRootFunction(object):
      thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
      __repr__ = _swig_repr
      def __init__(self, *args): 
          """
          :rtype: None
  
          """
          _CPnts.CPnts_MyRootFunction_swiginit(self,_CPnts.new_CPnts_MyRootFunction(*args))
      def Init(self, *args):
          """
          * F is a pointer on a function D is a client data Order is the order of integration to use
  
          :param F:
          :type F: CPnts_RealFunction &
          :param D:
          :type D: Standard_Address
          :param Order:
          :type Order: int
          :rtype: None
  
          * We want to solve Integral(X0,X,F(X,D)) = L
  
          :param X0:
          :type X0: float
          :param L:
          :type L: float
          :rtype: None
  
          * We want to solve Integral(X0,X,F(X,D)) = L with given tolerance
  
          :param X0:
          :type X0: float
          :param L:
          :type L: float
          :param Tol:
          :type Tol: float
          :rtype: None
  
          """
          return _CPnts.CPnts_MyRootFunction_Init(self, *args)
  
      def Value(self, *args):
          """
          * This is Integral(X0,X,F(X,D)) - L
  
          :param X:
          :type X: float
          :param F:
          :type F: float &
          :rtype: bool
  
          """
          return _CPnts.CPnts_MyRootFunction_Value(self, *args)
  
      def Derivative(self, *args):
          """
          * This is F(X,D)
  
          :param X:
          :type X: float
          :param Df:
          :type Df: float &
          :rtype: bool
  
          """
          return _CPnts.CPnts_MyRootFunction_Derivative(self, *args)
  
      def Values(self, *args):
          """
          :param X:
          :type X: float
          :param F:
          :type F: float &
          :param Df:
          :type Df: float &
          :rtype: bool
  
          """
          return _CPnts.CPnts_MyRootFunction_Values(self, *args)
  
      __swig_destroy__ = _CPnts.delete_CPnts_MyRootFunction
  CPnts_MyRootFunction.Init = new_instancemethod(_CPnts.CPnts_MyRootFunction_Init,None,CPnts_MyRootFunction)
  CPnts_MyRootFunction.Value = new_instancemethod(_CPnts.CPnts_MyRootFunction_Value,None,CPnts_MyRootFunction)
  CPnts_MyRootFunction.Derivative = new_instancemethod(_CPnts.CPnts_MyRootFunction_Derivative,None,CPnts_MyRootFunction)
  CPnts_MyRootFunction.Values = new_instancemethod(_CPnts.CPnts_MyRootFunction_Values,None,CPnts_MyRootFunction)
  CPnts_MyRootFunction_swigregister = _CPnts.CPnts_MyRootFunction_swigregister
  CPnts_MyRootFunction_swigregister(CPnts_MyRootFunction)
  
  class CPnts_UniformDeflection(object):
      thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
      __repr__ = _swig_repr
      def __init__(self, *args): 
          """
          * creation of a indefinite UniformDeflection
  
          :rtype: None
  
          * Computes a uniform deflection distribution of points on the curve <C>. <Deflection> defines the constant deflection value. The algorithm computes the number of points and the points. The curve <C> must be at least C2 else the computation can fail. If just some parts of the curve is C2 it is better to give the parameters bounds and to use the below constructor . if <WithControl> is True, the algorithm controls the estimate deflection when the curve is singular at the point P(u),the algorithm computes the next point as P(u + Max(CurrentStep,Abs(LastParameter-FirstParameter))) if the singularity is at the first point ,the next point calculated is the P(LastParameter)
  
          :param C:
          :type C: Adaptor3d_Curve &
          :param Deflection:
          :type Deflection: float
          :param Resolution:
          :type Resolution: float
          :param WithControl:
          :type WithControl: bool
          :rtype: None
  
          * As above with 2d curve
  
          :param C:
          :type C: Adaptor2d_Curve2d &
          :param Deflection:
          :type Deflection: float
          :param Resolution:
          :type Resolution: float
          :param WithControl:
          :type WithControl: bool
          :rtype: None
  
          * Computes an uniform deflection distribution of points on a part of the curve <C>. Deflection defines the step between the points. <U1> and <U2> define the distribution span. <U1> and <U2> must be in the parametric range of the curve.
  
          :param C:
          :type C: Adaptor3d_Curve &
          :param Deflection:
          :type Deflection: float
          :param U1:
          :type U1: float
          :param U2:
          :type U2: float
          :param Resolution:
          :type Resolution: float
          :param WithControl:
          :type WithControl: bool
          :rtype: None
  
          * As above with 2d curve
  
          :param C:
          :type C: Adaptor2d_Curve2d &
          :param Deflection:
          :type Deflection: float
          :param U1:
          :type U1: float
          :param U2:
          :type U2: float
          :param Resolution:
          :type Resolution: float
          :param WithControl:
          :type WithControl: bool
          :rtype: None
  
          """
          _CPnts.CPnts_UniformDeflection_swiginit(self,_CPnts.new_CPnts_UniformDeflection(*args))
      def Initialize(self, *args):
          """
          * Initialize the algoritms with <C>, <Deflection>, <UStep>, <Resolution> and <WithControl>
  
          :param C:
          :type C: Adaptor3d_Curve &
          :param Deflection:
          :type Deflection: float
          :param Resolution:
          :type Resolution: float
          :param WithControl:
          :type WithControl: bool
          :rtype: None
  
          * Initialize the algoritms with <C>, <Deflection>, <UStep>, <Resolution> and <WithControl>
  
          :param C:
          :type C: Adaptor2d_Curve2d &
          :param Deflection:
          :type Deflection: float
          :param Resolution:
          :type Resolution: float
          :param WithControl:
          :type WithControl: bool
          :rtype: None
  
          * Initialize the algoritms with <C>, <Deflection>, <UStep>, <U1>, <U2> and <WithControl>
  
          :param C:
          :type C: Adaptor3d_Curve &
          :param Deflection:
          :type Deflection: float
          :param U1:
          :type U1: float
          :param U2:
          :type U2: float
          :param Resolution:
          :type Resolution: float
          :param WithControl:
          :type WithControl: bool
          :rtype: None
  
          * Initialize the algoritms with <C>, <Deflection>, <UStep>, <U1>, <U2> and <WithControl>
  
          :param C:
          :type C: Adaptor2d_Curve2d &
          :param Deflection:
          :type Deflection: float
          :param U1:
          :type U1: float
          :param U2:
          :type U2: float
          :param Resolution:
          :type Resolution: float
          :param WithControl:
          :type WithControl: bool
          :rtype: None
  
          """
          return _CPnts.CPnts_UniformDeflection_Initialize(self, *args)
  
      def IsAllDone(self, *args):
          """
          * To know if all the calculus were done successfully (ie all the points have been computed). The calculus can fail if the Curve is not C1 in the considered domain. Returns True if the calculus was successful.
  
          :rtype: bool
  
          """
          return _CPnts.CPnts_UniformDeflection_IsAllDone(self, *args)
  
      def Next(self, *args):
          """
          * go to the next Point.
  
          :rtype: None
  
          """
          return _CPnts.CPnts_UniformDeflection_Next(self, *args)
  
      def More(self, *args):
          """
          * returns True if it exists a next Point.
  
          :rtype: bool
  
          """
          return _CPnts.CPnts_UniformDeflection_More(self, *args)
  
      def Value(self, *args):
          """
          * return the computed parameter
  
          :rtype: float
  
          """
          return _CPnts.CPnts_UniformDeflection_Value(self, *args)
  
      def Point(self, *args):
          """
          * return the computed parameter
  
          :rtype: gp_Pnt
  
          """
          return _CPnts.CPnts_UniformDeflection_Point(self, *args)
  
      __swig_destroy__ = _CPnts.delete_CPnts_UniformDeflection
  CPnts_UniformDeflection.Initialize = new_instancemethod(_CPnts.CPnts_UniformDeflection_Initialize,None,CPnts_UniformDeflection)
  CPnts_UniformDeflection.IsAllDone = new_instancemethod(_CPnts.CPnts_UniformDeflection_IsAllDone,None,CPnts_UniformDeflection)
  CPnts_UniformDeflection.Next = new_instancemethod(_CPnts.CPnts_UniformDeflection_Next,None,CPnts_UniformDeflection)
  CPnts_UniformDeflection.More = new_instancemethod(_CPnts.CPnts_UniformDeflection_More,None,CPnts_UniformDeflection)
  CPnts_UniformDeflection.Value = new_instancemethod(_CPnts.CPnts_UniformDeflection_Value,None,CPnts_UniformDeflection)
  CPnts_UniformDeflection.Point = new_instancemethod(_CPnts.CPnts_UniformDeflection_Point,None,CPnts_UniformDeflection)
  CPnts_UniformDeflection_swigregister = _CPnts.CPnts_UniformDeflection_swigregister
  CPnts_UniformDeflection_swigregister(CPnts_UniformDeflection)
  
  
  
  