# 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: _ChFiDS.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('_ChFiDS', [dirname(__file__)])
        except ImportError:
            import _ChFiDS
            return _ChFiDS
        if fp is not None:
            try:
                _mod = imp.load_module('_ChFiDS', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _ChFiDS = swig_import_helper()
    del swig_import_helper
else:
    import _ChFiDS
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__ = _ChFiDS.delete_SwigPyIterator
    def __iter__(self): return self
SwigPyIterator.value = new_instancemethod(_ChFiDS.SwigPyIterator_value,None,SwigPyIterator)
SwigPyIterator.incr = new_instancemethod(_ChFiDS.SwigPyIterator_incr,None,SwigPyIterator)
SwigPyIterator.decr = new_instancemethod(_ChFiDS.SwigPyIterator_decr,None,SwigPyIterator)
SwigPyIterator.distance = new_instancemethod(_ChFiDS.SwigPyIterator_distance,None,SwigPyIterator)
SwigPyIterator.equal = new_instancemethod(_ChFiDS.SwigPyIterator_equal,None,SwigPyIterator)
SwigPyIterator.copy = new_instancemethod(_ChFiDS.SwigPyIterator_copy,None,SwigPyIterator)
SwigPyIterator.next = new_instancemethod(_ChFiDS.SwigPyIterator_next,None,SwigPyIterator)
SwigPyIterator.__next__ = new_instancemethod(_ChFiDS.SwigPyIterator___next__,None,SwigPyIterator)
SwigPyIterator.previous = new_instancemethod(_ChFiDS.SwigPyIterator_previous,None,SwigPyIterator)
SwigPyIterator.advance = new_instancemethod(_ChFiDS.SwigPyIterator_advance,None,SwigPyIterator)
SwigPyIterator.__eq__ = new_instancemethod(_ChFiDS.SwigPyIterator___eq__,None,SwigPyIterator)
SwigPyIterator.__ne__ = new_instancemethod(_ChFiDS.SwigPyIterator___ne__,None,SwigPyIterator)
SwigPyIterator.__iadd__ = new_instancemethod(_ChFiDS.SwigPyIterator___iadd__,None,SwigPyIterator)
SwigPyIterator.__isub__ = new_instancemethod(_ChFiDS.SwigPyIterator___isub__,None,SwigPyIterator)
SwigPyIterator.__add__ = new_instancemethod(_ChFiDS.SwigPyIterator___add__,None,SwigPyIterator)
SwigPyIterator.__sub__ = new_instancemethod(_ChFiDS.SwigPyIterator___sub__,None,SwigPyIterator)
SwigPyIterator_swigregister = _ChFiDS.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)

import OCC.gp
import OCC.Standard
import OCC.TopoDS
import OCC.MMgt
import OCC.TCollection
import OCC.TopLoc
import OCC.TopAbs
import OCC.Adaptor3d
import OCC.GeomAbs
import OCC.TColStd
import OCC.Geom
import OCC.TColgp
import OCC.Adaptor2d
import OCC.Geom2d
import OCC.math
import OCC.TopTools
import OCC.Message
import OCC.BRepAdaptor
import OCC.GeomAdaptor
import OCC.Geom2dAdaptor
import OCC.Law
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

ChFiDS_Sym = _ChFiDS.ChFiDS_Sym
ChFiDS_TwoDist = _ChFiDS.ChFiDS_TwoDist
ChFiDS_DistAngle = _ChFiDS.ChFiDS_DistAngle
ChFiDS_Ok = _ChFiDS.ChFiDS_Ok
ChFiDS_Error = _ChFiDS.ChFiDS_Error
ChFiDS_WalkingFailure = _ChFiDS.ChFiDS_WalkingFailure
ChFiDS_StartsolFailure = _ChFiDS.ChFiDS_StartsolFailure
ChFiDS_TwistedSurface = _ChFiDS.ChFiDS_TwistedSurface
ChFiDS_OnSame = _ChFiDS.ChFiDS_OnSame
ChFiDS_OnDiff = _ChFiDS.ChFiDS_OnDiff
ChFiDS_AllSame = _ChFiDS.ChFiDS_AllSame
ChFiDS_BreakPoint = _ChFiDS.ChFiDS_BreakPoint
ChFiDS_FreeBoundary = _ChFiDS.ChFiDS_FreeBoundary
ChFiDS_Closed = _ChFiDS.ChFiDS_Closed
ChFiDS_Tangent = _ChFiDS.ChFiDS_Tangent
class ChFiDS_CircSection(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

        """
        _ChFiDS.ChFiDS_CircSection_swiginit(self,_ChFiDS.new_ChFiDS_CircSection(*args))
    def Set(self, *args):
        """
        :param C:
        :type C: gp_Circ
        :param F:
        :type F: float
        :param L:
        :type L: float
        :rtype: None

        :param C:
        :type C: gp_Lin
        :param F:
        :type F: float
        :param L:
        :type L: float
        :rtype: None

        """
        return _ChFiDS.ChFiDS_CircSection_Set(self, *args)

    def Get(self, *args):
        """
        :param C:
        :type C: gp_Circ
        :param F:
        :type F: float &
        :param L:
        :type L: float &
        :rtype: None

        :param C:
        :type C: gp_Lin
        :param F:
        :type F: float &
        :param L:
        :type L: float &
        :rtype: None

        """
        return _ChFiDS.ChFiDS_CircSection_Get(self, *args)

    __swig_destroy__ = _ChFiDS.delete_ChFiDS_CircSection
ChFiDS_CircSection.Set = new_instancemethod(_ChFiDS.ChFiDS_CircSection_Set,None,ChFiDS_CircSection)
ChFiDS_CircSection.Get = new_instancemethod(_ChFiDS.ChFiDS_CircSection_Get,None,ChFiDS_CircSection)
ChFiDS_CircSection_swigregister = _ChFiDS.ChFiDS_CircSection_swigregister
ChFiDS_CircSection_swigregister(ChFiDS_CircSection)

class ChFiDS_CommonPoint(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): 
        """
        * Empty constructor.

        :rtype: None

        """
        _ChFiDS.ChFiDS_CommonPoint_swiginit(self,_ChFiDS.new_ChFiDS_CommonPoint(*args))
    def Reset(self, *args):
        """
        * default value for all fields

        :rtype: None

        """
        return _ChFiDS.ChFiDS_CommonPoint_Reset(self, *args)

    def SetVertex(self, *args):
        """
        * Sets the values of a point which is a vertex on the initial facet of restriction of one of the surface.

        :param V:
        :type V: TopoDS_Vertex &
        :rtype: None

        """
        return _ChFiDS.ChFiDS_CommonPoint_SetVertex(self, *args)

    def SetArc(self, *args):
        """
        * Sets the values of a point which is on the arc A, at parameter Param.

        :param Tol:
        :type Tol: float
        :param A:
        :type A: TopoDS_Edge &
        :param Param:
        :type Param: float
        :param TArc:
        :type TArc: TopAbs_Orientation
        :rtype: None

        """
        return _ChFiDS.ChFiDS_CommonPoint_SetArc(self, *args)

    def SetParameter(self, *args):
        """
        * Sets the value of the parameter on the spine

        :param Param:
        :type Param: float
        :rtype: None

        """
        return _ChFiDS.ChFiDS_CommonPoint_SetParameter(self, *args)

    def SetPoint(self, *args):
        """
        * Set the 3d point for a commonpoint that is not a vertex or on an arc.

        :param Point:
        :type Point: gp_Pnt
        :rtype: None

        """
        return _ChFiDS.ChFiDS_CommonPoint_SetPoint(self, *args)

    def SetVector(self, *args):
        """
        * Set the output 3d vector

        :param Vector:
        :type Vector: gp_Vec
        :rtype: None

        """
        return _ChFiDS.ChFiDS_CommonPoint_SetVector(self, *args)

    def SetTolerance(self, *args):
        """
        * This method set the fuzziness on the point.

        :param Tol:
        :type Tol: float
        :rtype: None

        """
        return _ChFiDS.ChFiDS_CommonPoint_SetTolerance(self, *args)

    def Tolerance(self, *args):
        """
        * This method returns the fuzziness on the point.

        :rtype: float

        """
        return _ChFiDS.ChFiDS_CommonPoint_Tolerance(self, *args)

    def IsVertex(self, *args):
        """
        * Returns True if the point is a vertex on the initial restriction facet of the surface.

        :rtype: bool

        """
        return _ChFiDS.ChFiDS_CommonPoint_IsVertex(self, *args)

    def Vertex(self, *args):
        """
        * Returns the information about the point when it is on the domain of the first patch, i-e when the function IsVertex returns True. Otherwise, an exception is raised.

        :rtype: TopoDS_Vertex

        """
        return _ChFiDS.ChFiDS_CommonPoint_Vertex(self, *args)

    def IsOnArc(self, *args):
        """
        * Returns True if the point is a on an edge of the initial restriction facet of the surface.

        :rtype: bool

        """
        return _ChFiDS.ChFiDS_CommonPoint_IsOnArc(self, *args)

    def Arc(self, *args):
        """
        * Returns the arc of restriction containing the vertex.

        :rtype: TopoDS_Edge

        """
        return _ChFiDS.ChFiDS_CommonPoint_Arc(self, *args)

    def TransitionOnArc(self, *args):
        """
        * Returns the transition of the point on the arc returned by Arc().

        :rtype: TopAbs_Orientation

        """
        return _ChFiDS.ChFiDS_CommonPoint_TransitionOnArc(self, *args)

    def ParameterOnArc(self, *args):
        """
        * Returns the parameter of the point on the arc returned by the method Arc().

        :rtype: float

        """
        return _ChFiDS.ChFiDS_CommonPoint_ParameterOnArc(self, *args)

    def Parameter(self, *args):
        """
        * Returns the parameter the paramter on the spine

        :rtype: float

        """
        return _ChFiDS.ChFiDS_CommonPoint_Parameter(self, *args)

    def Point(self, *args):
        """
        * Returns the 3d point

        :rtype: gp_Pnt

        """
        return _ChFiDS.ChFiDS_CommonPoint_Point(self, *args)

    def HasVector(self, *args):
        """
        * Returns True if the output vector is stored.

        :rtype: bool

        """
        return _ChFiDS.ChFiDS_CommonPoint_HasVector(self, *args)

    def Vector(self, *args):
        """
        * Returns the output 3d vector

        :rtype: gp_Vec

        """
        return _ChFiDS.ChFiDS_CommonPoint_Vector(self, *args)

    __swig_destroy__ = _ChFiDS.delete_ChFiDS_CommonPoint
ChFiDS_CommonPoint.Reset = new_instancemethod(_ChFiDS.ChFiDS_CommonPoint_Reset,None,ChFiDS_CommonPoint)
ChFiDS_CommonPoint.SetVertex = new_instancemethod(_ChFiDS.ChFiDS_CommonPoint_SetVertex,None,ChFiDS_CommonPoint)
ChFiDS_CommonPoint.SetArc = new_instancemethod(_ChFiDS.ChFiDS_CommonPoint_SetArc,None,ChFiDS_CommonPoint)
ChFiDS_CommonPoint.SetParameter = new_instancemethod(_ChFiDS.ChFiDS_CommonPoint_SetParameter,None,ChFiDS_CommonPoint)
ChFiDS_CommonPoint.SetPoint = new_instancemethod(_ChFiDS.ChFiDS_CommonPoint_SetPoint,None,ChFiDS_CommonPoint)
ChFiDS_CommonPoint.SetVector = new_instancemethod(_ChFiDS.ChFiDS_CommonPoint_SetVector,None,ChFiDS_CommonPoint)
ChFiDS_CommonPoint.SetTolerance = new_instancemethod(_ChFiDS.ChFiDS_CommonPoint_SetTolerance,None,ChFiDS_CommonPoint)
ChFiDS_CommonPoint.Tolerance = new_instancemethod(_ChFiDS.ChFiDS_CommonPoint_Tolerance,None,ChFiDS_CommonPoint)
ChFiDS_CommonPoint.IsVertex = new_instancemethod(_ChFiDS.ChFiDS_CommonPoint_IsVertex,None,ChFiDS_CommonPoint)
ChFiDS_CommonPoint.Vertex = new_instancemethod(_ChFiDS.ChFiDS_CommonPoint_Vertex,None,ChFiDS_CommonPoint)
ChFiDS_CommonPoint.IsOnArc = new_instancemethod(_ChFiDS.ChFiDS_CommonPoint_IsOnArc,None,ChFiDS_CommonPoint)
ChFiDS_CommonPoint.Arc = new_instancemethod(_ChFiDS.ChFiDS_CommonPoint_Arc,None,ChFiDS_CommonPoint)
ChFiDS_CommonPoint.TransitionOnArc = new_instancemethod(_ChFiDS.ChFiDS_CommonPoint_TransitionOnArc,None,ChFiDS_CommonPoint)
ChFiDS_CommonPoint.ParameterOnArc = new_instancemethod(_ChFiDS.ChFiDS_CommonPoint_ParameterOnArc,None,ChFiDS_CommonPoint)
ChFiDS_CommonPoint.Parameter = new_instancemethod(_ChFiDS.ChFiDS_CommonPoint_Parameter,None,ChFiDS_CommonPoint)
ChFiDS_CommonPoint.Point = new_instancemethod(_ChFiDS.ChFiDS_CommonPoint_Point,None,ChFiDS_CommonPoint)
ChFiDS_CommonPoint.HasVector = new_instancemethod(_ChFiDS.ChFiDS_CommonPoint_HasVector,None,ChFiDS_CommonPoint)
ChFiDS_CommonPoint.Vector = new_instancemethod(_ChFiDS.ChFiDS_CommonPoint_Vector,None,ChFiDS_CommonPoint)
ChFiDS_CommonPoint_swigregister = _ChFiDS.ChFiDS_CommonPoint_swigregister
ChFiDS_CommonPoint_swigregister(ChFiDS_CommonPoint)

class ChFiDS_ElSpine(OCC.Adaptor3d.Adaptor3d_Curve):
    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

        """
        _ChFiDS.ChFiDS_ElSpine_swiginit(self,_ChFiDS.new_ChFiDS_ElSpine(*args))
    def SetPeriodic(self, *args):
        """
        :param I:
        :type I: bool
        :rtype: None

        """
        return _ChFiDS.ChFiDS_ElSpine_SetPeriodic(self, *args)

    def FirstParameter(self, *args):
        """
        :rtype: float

        :param P:
        :type P: float
        :rtype: None

        """
        return _ChFiDS.ChFiDS_ElSpine_FirstParameter(self, *args)

    def LastParameter(self, *args):
        """
        :rtype: float

        :param P:
        :type P: float
        :rtype: None

        """
        return _ChFiDS.ChFiDS_ElSpine_LastParameter(self, *args)

    def SetOrigin(self, *args):
        """
        :param O:
        :type O: float
        :rtype: None

        """
        return _ChFiDS.ChFiDS_ElSpine_SetOrigin(self, *args)

    def FirstPointAndTgt(self, *args):
        """
        :param P:
        :type P: gp_Pnt
        :param T:
        :type T: gp_Vec
        :rtype: None

        """
        return _ChFiDS.ChFiDS_ElSpine_FirstPointAndTgt(self, *args)

    def LastPointAndTgt(self, *args):
        """
        :param P:
        :type P: gp_Pnt
        :param T:
        :type T: gp_Vec
        :rtype: None

        """
        return _ChFiDS.ChFiDS_ElSpine_LastPointAndTgt(self, *args)

    def SetFirstPointAndTgt(self, *args):
        """
        :param P:
        :type P: gp_Pnt
        :param T:
        :type T: gp_Vec
        :rtype: None

        """
        return _ChFiDS.ChFiDS_ElSpine_SetFirstPointAndTgt(self, *args)

    def SetLastPointAndTgt(self, *args):
        """
        :param P:
        :type P: gp_Pnt
        :param T:
        :type T: gp_Vec
        :rtype: None

        """
        return _ChFiDS.ChFiDS_ElSpine_SetLastPointAndTgt(self, *args)

    def SetCurve(self, *args):
        """
        :param C:
        :type C: Handle_Geom_Curve &
        :rtype: None

        """
        return _ChFiDS.ChFiDS_ElSpine_SetCurve(self, *args)

    def Previous(self, *args):
        """
        :rtype: Handle_ChFiDS_SurfData

        """
        return _ChFiDS.ChFiDS_ElSpine_Previous(self, *args)

    def ChangePrevious(self, *args):
        """
        :rtype: Handle_ChFiDS_SurfData

        """
        return _ChFiDS.ChFiDS_ElSpine_ChangePrevious(self, *args)

    def Next(self, *args):
        """
        :rtype: Handle_ChFiDS_SurfData

        """
        return _ChFiDS.ChFiDS_ElSpine_Next(self, *args)

    def ChangeNext(self, *args):
        """
        :rtype: Handle_ChFiDS_SurfData

        """
        return _ChFiDS.ChFiDS_ElSpine_ChangeNext(self, *args)

    __swig_destroy__ = _ChFiDS.delete_ChFiDS_ElSpine
ChFiDS_ElSpine.SetPeriodic = new_instancemethod(_ChFiDS.ChFiDS_ElSpine_SetPeriodic,None,ChFiDS_ElSpine)
ChFiDS_ElSpine.FirstParameter = new_instancemethod(_ChFiDS.ChFiDS_ElSpine_FirstParameter,None,ChFiDS_ElSpine)
ChFiDS_ElSpine.LastParameter = new_instancemethod(_ChFiDS.ChFiDS_ElSpine_LastParameter,None,ChFiDS_ElSpine)
ChFiDS_ElSpine.SetOrigin = new_instancemethod(_ChFiDS.ChFiDS_ElSpine_SetOrigin,None,ChFiDS_ElSpine)
ChFiDS_ElSpine.FirstPointAndTgt = new_instancemethod(_ChFiDS.ChFiDS_ElSpine_FirstPointAndTgt,None,ChFiDS_ElSpine)
ChFiDS_ElSpine.LastPointAndTgt = new_instancemethod(_ChFiDS.ChFiDS_ElSpine_LastPointAndTgt,None,ChFiDS_ElSpine)
ChFiDS_ElSpine.SetFirstPointAndTgt = new_instancemethod(_ChFiDS.ChFiDS_ElSpine_SetFirstPointAndTgt,None,ChFiDS_ElSpine)
ChFiDS_ElSpine.SetLastPointAndTgt = new_instancemethod(_ChFiDS.ChFiDS_ElSpine_SetLastPointAndTgt,None,ChFiDS_ElSpine)
ChFiDS_ElSpine.SetCurve = new_instancemethod(_ChFiDS.ChFiDS_ElSpine_SetCurve,None,ChFiDS_ElSpine)
ChFiDS_ElSpine.Previous = new_instancemethod(_ChFiDS.ChFiDS_ElSpine_Previous,None,ChFiDS_ElSpine)
ChFiDS_ElSpine.ChangePrevious = new_instancemethod(_ChFiDS.ChFiDS_ElSpine_ChangePrevious,None,ChFiDS_ElSpine)
ChFiDS_ElSpine.Next = new_instancemethod(_ChFiDS.ChFiDS_ElSpine_Next,None,ChFiDS_ElSpine)
ChFiDS_ElSpine.ChangeNext = new_instancemethod(_ChFiDS.ChFiDS_ElSpine_ChangeNext,None,ChFiDS_ElSpine)
ChFiDS_ElSpine_swigregister = _ChFiDS.ChFiDS_ElSpine_swigregister
ChFiDS_ElSpine_swigregister(ChFiDS_ElSpine)

class ChFiDS_FaceInterference(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

        """
        _ChFiDS.ChFiDS_FaceInterference_swiginit(self,_ChFiDS.new_ChFiDS_FaceInterference(*args))
    def SetInterference(self, *args):
        """
        :param LineIndex:
        :type LineIndex: int
        :param Trans:
        :type Trans: TopAbs_Orientation
        :param PCurv1:
        :type PCurv1: Handle_Geom2d_Curve &
        :param PCurv2:
        :type PCurv2: Handle_Geom2d_Curve &
        :rtype: None

        """
        return _ChFiDS.ChFiDS_FaceInterference_SetInterference(self, *args)

    def SetTransition(self, *args):
        """
        :param Trans:
        :type Trans: TopAbs_Orientation
        :rtype: None

        """
        return _ChFiDS.ChFiDS_FaceInterference_SetTransition(self, *args)

    def SetFirstParameter(self, *args):
        """
        :param U1:
        :type U1: float
        :rtype: None

        """
        return _ChFiDS.ChFiDS_FaceInterference_SetFirstParameter(self, *args)

    def SetLastParameter(self, *args):
        """
        :param U1:
        :type U1: float
        :rtype: None

        """
        return _ChFiDS.ChFiDS_FaceInterference_SetLastParameter(self, *args)

    def SetParameter(self, *args):
        """
        :param U1:
        :type U1: float
        :param IsFirst:
        :type IsFirst: bool
        :rtype: None

        """
        return _ChFiDS.ChFiDS_FaceInterference_SetParameter(self, *args)

    def LineIndex(self, *args):
        """
        :rtype: int

        """
        return _ChFiDS.ChFiDS_FaceInterference_LineIndex(self, *args)

    def SetLineIndex(self, *args):
        """
        :param I:
        :type I: int
        :rtype: None

        """
        return _ChFiDS.ChFiDS_FaceInterference_SetLineIndex(self, *args)

    def Transition(self, *args):
        """
        :rtype: TopAbs_Orientation

        """
        return _ChFiDS.ChFiDS_FaceInterference_Transition(self, *args)

    def PCurveOnFace(self, *args):
        """
        :rtype: Handle_Geom2d_Curve

        """
        return _ChFiDS.ChFiDS_FaceInterference_PCurveOnFace(self, *args)

    def PCurveOnSurf(self, *args):
        """
        :rtype: Handle_Geom2d_Curve

        """
        return _ChFiDS.ChFiDS_FaceInterference_PCurveOnSurf(self, *args)

    def ChangePCurveOnFace(self, *args):
        """
        :rtype: Handle_Geom2d_Curve

        """
        return _ChFiDS.ChFiDS_FaceInterference_ChangePCurveOnFace(self, *args)

    def ChangePCurveOnSurf(self, *args):
        """
        :rtype: Handle_Geom2d_Curve

        """
        return _ChFiDS.ChFiDS_FaceInterference_ChangePCurveOnSurf(self, *args)

    def FirstParameter(self, *args):
        """
        :rtype: float

        """
        return _ChFiDS.ChFiDS_FaceInterference_FirstParameter(self, *args)

    def LastParameter(self, *args):
        """
        :rtype: float

        """
        return _ChFiDS.ChFiDS_FaceInterference_LastParameter(self, *args)

    def Parameter(self, *args):
        """
        :param IsFirst:
        :type IsFirst: bool
        :rtype: float

        """
        return _ChFiDS.ChFiDS_FaceInterference_Parameter(self, *args)

    __swig_destroy__ = _ChFiDS.delete_ChFiDS_FaceInterference
ChFiDS_FaceInterference.SetInterference = new_instancemethod(_ChFiDS.ChFiDS_FaceInterference_SetInterference,None,ChFiDS_FaceInterference)
ChFiDS_FaceInterference.SetTransition = new_instancemethod(_ChFiDS.ChFiDS_FaceInterference_SetTransition,None,ChFiDS_FaceInterference)
ChFiDS_FaceInterference.SetFirstParameter = new_instancemethod(_ChFiDS.ChFiDS_FaceInterference_SetFirstParameter,None,ChFiDS_FaceInterference)
ChFiDS_FaceInterference.SetLastParameter = new_instancemethod(_ChFiDS.ChFiDS_FaceInterference_SetLastParameter,None,ChFiDS_FaceInterference)
ChFiDS_FaceInterference.SetParameter = new_instancemethod(_ChFiDS.ChFiDS_FaceInterference_SetParameter,None,ChFiDS_FaceInterference)
ChFiDS_FaceInterference.LineIndex = new_instancemethod(_ChFiDS.ChFiDS_FaceInterference_LineIndex,None,ChFiDS_FaceInterference)
ChFiDS_FaceInterference.SetLineIndex = new_instancemethod(_ChFiDS.ChFiDS_FaceInterference_SetLineIndex,None,ChFiDS_FaceInterference)
ChFiDS_FaceInterference.Transition = new_instancemethod(_ChFiDS.ChFiDS_FaceInterference_Transition,None,ChFiDS_FaceInterference)
ChFiDS_FaceInterference.PCurveOnFace = new_instancemethod(_ChFiDS.ChFiDS_FaceInterference_PCurveOnFace,None,ChFiDS_FaceInterference)
ChFiDS_FaceInterference.PCurveOnSurf = new_instancemethod(_ChFiDS.ChFiDS_FaceInterference_PCurveOnSurf,None,ChFiDS_FaceInterference)
ChFiDS_FaceInterference.ChangePCurveOnFace = new_instancemethod(_ChFiDS.ChFiDS_FaceInterference_ChangePCurveOnFace,None,ChFiDS_FaceInterference)
ChFiDS_FaceInterference.ChangePCurveOnSurf = new_instancemethod(_ChFiDS.ChFiDS_FaceInterference_ChangePCurveOnSurf,None,ChFiDS_FaceInterference)
ChFiDS_FaceInterference.FirstParameter = new_instancemethod(_ChFiDS.ChFiDS_FaceInterference_FirstParameter,None,ChFiDS_FaceInterference)
ChFiDS_FaceInterference.LastParameter = new_instancemethod(_ChFiDS.ChFiDS_FaceInterference_LastParameter,None,ChFiDS_FaceInterference)
ChFiDS_FaceInterference.Parameter = new_instancemethod(_ChFiDS.ChFiDS_FaceInterference_Parameter,None,ChFiDS_FaceInterference)
ChFiDS_FaceInterference_swigregister = _ChFiDS.ChFiDS_FaceInterference_swigregister
ChFiDS_FaceInterference_swigregister(ChFiDS_FaceInterference)

class ChFiDS_HData(OCC.MMgt.MMgt_TShared):
    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

        """
        _ChFiDS.ChFiDS_HData_swiginit(self,_ChFiDS.new_ChFiDS_HData(*args))
    def IsEmpty(self, *args):
        """
        :rtype: bool

        """
        return _ChFiDS.ChFiDS_HData_IsEmpty(self, *args)

    def Length(self, *args):
        """
        :rtype: int

        """
        return _ChFiDS.ChFiDS_HData_Length(self, *args)

    def Clear(self, *args):
        """
        :rtype: None

        """
        return _ChFiDS.ChFiDS_HData_Clear(self, *args)

    def Append(self, *args):
        """
        :param anItem:
        :type anItem: Handle_ChFiDS_SurfData &
        :rtype: None

        :param aSequence:
        :type aSequence: Handle_ChFiDS_HData &
        :rtype: None

        """
        return _ChFiDS.ChFiDS_HData_Append(self, *args)

    def Prepend(self, *args):
        """
        :param anItem:
        :type anItem: Handle_ChFiDS_SurfData &
        :rtype: None

        :param aSequence:
        :type aSequence: Handle_ChFiDS_HData &
        :rtype: None

        """
        return _ChFiDS.ChFiDS_HData_Prepend(self, *args)

    def Reverse(self, *args):
        """
        :rtype: None

        """
        return _ChFiDS.ChFiDS_HData_Reverse(self, *args)

    def InsertBefore(self, *args):
        """
        :param anIndex:
        :type anIndex: int
        :param anItem:
        :type anItem: Handle_ChFiDS_SurfData &
        :rtype: None

        :param anIndex:
        :type anIndex: int
        :param aSequence:
        :type aSequence: Handle_ChFiDS_HData &
        :rtype: None

        """
        return _ChFiDS.ChFiDS_HData_InsertBefore(self, *args)

    def InsertAfter(self, *args):
        """
        :param anIndex:
        :type anIndex: int
        :param anItem:
        :type anItem: Handle_ChFiDS_SurfData &
        :rtype: None

        :param anIndex:
        :type anIndex: int
        :param aSequence:
        :type aSequence: Handle_ChFiDS_HData &
        :rtype: None

        """
        return _ChFiDS.ChFiDS_HData_InsertAfter(self, *args)

    def Exchange(self, *args):
        """
        :param anIndex:
        :type anIndex: int
        :param anOtherIndex:
        :type anOtherIndex: int
        :rtype: None

        """
        return _ChFiDS.ChFiDS_HData_Exchange(self, *args)

    def Split(self, *args):
        """
        :param anIndex:
        :type anIndex: int
        :rtype: Handle_ChFiDS_HData

        """
        return _ChFiDS.ChFiDS_HData_Split(self, *args)

    def SetValue(self, *args):
        """
        :param anIndex:
        :type anIndex: int
        :param anItem:
        :type anItem: Handle_ChFiDS_SurfData &
        :rtype: None

        """
        return _ChFiDS.ChFiDS_HData_SetValue(self, *args)

    def Value(self, *args):
        """
        :param anIndex:
        :type anIndex: int
        :rtype: Handle_ChFiDS_SurfData

        """
        return _ChFiDS.ChFiDS_HData_Value(self, *args)

    def ChangeValue(self, *args):
        """
        :param anIndex:
        :type anIndex: int
        :rtype: Handle_ChFiDS_SurfData

        """
        return _ChFiDS.ChFiDS_HData_ChangeValue(self, *args)

    def Remove(self, *args):
        """
        :param anIndex:
        :type anIndex: int
        :rtype: None

        :param fromIndex:
        :type fromIndex: int
        :param toIndex:
        :type toIndex: int
        :rtype: None

        """
        return _ChFiDS.ChFiDS_HData_Remove(self, *args)

    def Sequence(self, *args):
        """
        :rtype: ChFiDS_SequenceOfSurfData

        """
        return _ChFiDS.ChFiDS_HData_Sequence(self, *args)

    def ChangeSequence(self, *args):
        """
        :rtype: ChFiDS_SequenceOfSurfData

        """
        return _ChFiDS.ChFiDS_HData_ChangeSequence(self, *args)

    def ShallowCopy(self, *args):
        """
        :rtype: Handle_ChFiDS_HData

        """
        return _ChFiDS.ChFiDS_HData_ShallowCopy(self, *args)

    def GetHandle(self):
        try:
            return self.thisHandle
        except:
            self.thisHandle = Handle_ChFiDS_HData(self)
            self.thisown = False
            return self.thisHandle

    __swig_destroy__ = _ChFiDS.delete_ChFiDS_HData
ChFiDS_HData.IsEmpty = new_instancemethod(_ChFiDS.ChFiDS_HData_IsEmpty,None,ChFiDS_HData)
ChFiDS_HData.Length = new_instancemethod(_ChFiDS.ChFiDS_HData_Length,None,ChFiDS_HData)
ChFiDS_HData.Clear = new_instancemethod(_ChFiDS.ChFiDS_HData_Clear,None,ChFiDS_HData)
ChFiDS_HData.Append = new_instancemethod(_ChFiDS.ChFiDS_HData_Append,None,ChFiDS_HData)
ChFiDS_HData.Prepend = new_instancemethod(_ChFiDS.ChFiDS_HData_Prepend,None,ChFiDS_HData)
ChFiDS_HData.Reverse = new_instancemethod(_ChFiDS.ChFiDS_HData_Reverse,None,ChFiDS_HData)
ChFiDS_HData.InsertBefore = new_instancemethod(_ChFiDS.ChFiDS_HData_InsertBefore,None,ChFiDS_HData)
ChFiDS_HData.InsertAfter = new_instancemethod(_ChFiDS.ChFiDS_HData_InsertAfter,None,ChFiDS_HData)
ChFiDS_HData.Exchange = new_instancemethod(_ChFiDS.ChFiDS_HData_Exchange,None,ChFiDS_HData)
ChFiDS_HData.Split = new_instancemethod(_ChFiDS.ChFiDS_HData_Split,None,ChFiDS_HData)
ChFiDS_HData.SetValue = new_instancemethod(_ChFiDS.ChFiDS_HData_SetValue,None,ChFiDS_HData)
ChFiDS_HData.Value = new_instancemethod(_ChFiDS.ChFiDS_HData_Value,None,ChFiDS_HData)
ChFiDS_HData.ChangeValue = new_instancemethod(_ChFiDS.ChFiDS_HData_ChangeValue,None,ChFiDS_HData)
ChFiDS_HData.Remove = new_instancemethod(_ChFiDS.ChFiDS_HData_Remove,None,ChFiDS_HData)
ChFiDS_HData.Sequence = new_instancemethod(_ChFiDS.ChFiDS_HData_Sequence,None,ChFiDS_HData)
ChFiDS_HData.ChangeSequence = new_instancemethod(_ChFiDS.ChFiDS_HData_ChangeSequence,None,ChFiDS_HData)
ChFiDS_HData.ShallowCopy = new_instancemethod(_ChFiDS.ChFiDS_HData_ShallowCopy,None,ChFiDS_HData)
ChFiDS_HData_swigregister = _ChFiDS.ChFiDS_HData_swigregister
ChFiDS_HData_swigregister(ChFiDS_HData)

class Handle_ChFiDS_HData(OCC.MMgt.Handle_MMgt_TShared):
    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): 
        _ChFiDS.Handle_ChFiDS_HData_swiginit(self,_ChFiDS.new_Handle_ChFiDS_HData(*args))
        # register the handle in the base object
        if len(args) > 0:
            register_handle(self, args[0])



    DownCast = staticmethod(_ChFiDS.Handle_ChFiDS_HData_DownCast)
    __swig_destroy__ = _ChFiDS.delete_Handle_ChFiDS_HData
Handle_ChFiDS_HData.Nullify = new_instancemethod(_ChFiDS.Handle_ChFiDS_HData_Nullify,None,Handle_ChFiDS_HData)
Handle_ChFiDS_HData.IsNull = new_instancemethod(_ChFiDS.Handle_ChFiDS_HData_IsNull,None,Handle_ChFiDS_HData)
Handle_ChFiDS_HData.GetObject = new_instancemethod(_ChFiDS.Handle_ChFiDS_HData_GetObject,None,Handle_ChFiDS_HData)
Handle_ChFiDS_HData_swigregister = _ChFiDS.Handle_ChFiDS_HData_swigregister
Handle_ChFiDS_HData_swigregister(Handle_ChFiDS_HData)

def Handle_ChFiDS_HData_DownCast(*args):
  return _ChFiDS.Handle_ChFiDS_HData_DownCast(*args)
Handle_ChFiDS_HData_DownCast = _ChFiDS.Handle_ChFiDS_HData_DownCast

class ChFiDS_HElSpine(OCC.Adaptor3d.Adaptor3d_HCurve):
    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

        :param C:
        :type C: ChFiDS_ElSpine &
        :rtype: None

        """
        _ChFiDS.ChFiDS_HElSpine_swiginit(self,_ChFiDS.new_ChFiDS_HElSpine(*args))
    def Set(self, *args):
        """
        :param C:
        :type C: ChFiDS_ElSpine &
        :rtype: None

        """
        return _ChFiDS.ChFiDS_HElSpine_Set(self, *args)

    def ChangeCurve(self, *args):
        """
        :rtype: ChFiDS_ElSpine

        """
        return _ChFiDS.ChFiDS_HElSpine_ChangeCurve(self, *args)

    def GetHandle(self):
        try:
            return self.thisHandle
        except:
            self.thisHandle = Handle_ChFiDS_HElSpine(self)
            self.thisown = False
            return self.thisHandle

    __swig_destroy__ = _ChFiDS.delete_ChFiDS_HElSpine
ChFiDS_HElSpine.Set = new_instancemethod(_ChFiDS.ChFiDS_HElSpine_Set,None,ChFiDS_HElSpine)
ChFiDS_HElSpine.ChangeCurve = new_instancemethod(_ChFiDS.ChFiDS_HElSpine_ChangeCurve,None,ChFiDS_HElSpine)
ChFiDS_HElSpine_swigregister = _ChFiDS.ChFiDS_HElSpine_swigregister
ChFiDS_HElSpine_swigregister(ChFiDS_HElSpine)

class Handle_ChFiDS_HElSpine(OCC.Adaptor3d.Handle_Adaptor3d_HCurve):
    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): 
        _ChFiDS.Handle_ChFiDS_HElSpine_swiginit(self,_ChFiDS.new_Handle_ChFiDS_HElSpine(*args))
        # register the handle in the base object
        if len(args) > 0:
            register_handle(self, args[0])



    DownCast = staticmethod(_ChFiDS.Handle_ChFiDS_HElSpine_DownCast)
    __swig_destroy__ = _ChFiDS.delete_Handle_ChFiDS_HElSpine
Handle_ChFiDS_HElSpine.Nullify = new_instancemethod(_ChFiDS.Handle_ChFiDS_HElSpine_Nullify,None,Handle_ChFiDS_HElSpine)
Handle_ChFiDS_HElSpine.IsNull = new_instancemethod(_ChFiDS.Handle_ChFiDS_HElSpine_IsNull,None,Handle_ChFiDS_HElSpine)
Handle_ChFiDS_HElSpine.GetObject = new_instancemethod(_ChFiDS.Handle_ChFiDS_HElSpine_GetObject,None,Handle_ChFiDS_HElSpine)
Handle_ChFiDS_HElSpine_swigregister = _ChFiDS.Handle_ChFiDS_HElSpine_swigregister
Handle_ChFiDS_HElSpine_swigregister(Handle_ChFiDS_HElSpine)

def Handle_ChFiDS_HElSpine_DownCast(*args):
  return _ChFiDS.Handle_ChFiDS_HElSpine_DownCast(*args)
Handle_ChFiDS_HElSpine_DownCast = _ChFiDS.Handle_ChFiDS_HElSpine_DownCast

class ChFiDS_IndexedDataMapNodeOfIndexedDataMapOfVertexListOfStripe(OCC.TCollection.TCollection_MapNode):
    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): 
        """
        :param K1:
        :type K1: TopoDS_Vertex &
        :param K2:
        :type K2: int
        :param I:
        :type I: ChFiDS_ListOfStripe &
        :param n1:
        :type n1: TCollection_MapNodePtr &
        :param n2:
        :type n2: TCollection_MapNodePtr &
        :rtype: None

        """
        _ChFiDS.ChFiDS_IndexedDataMapNodeOfIndexedDataMapOfVertexListOfStripe_swiginit(self,_ChFiDS.new_ChFiDS_IndexedDataMapNodeOfIndexedDataMapOfVertexListOfStripe(*args))
    def Key1(self, *args):
        """
        :rtype: TopoDS_Vertex

        """
        return _ChFiDS.ChFiDS_IndexedDataMapNodeOfIndexedDataMapOfVertexListOfStripe_Key1(self, *args)

    def GetKey2(self):
        """GetKey2(ChFiDS_IndexedDataMapNodeOfIndexedDataMapOfVertexListOfStripe self) -> Standard_Integer"""
        return _ChFiDS.ChFiDS_IndexedDataMapNodeOfIndexedDataMapOfVertexListOfStripe_GetKey2(self)

    def SetKey2(self, *args):
        """SetKey2(ChFiDS_IndexedDataMapNodeOfIndexedDataMapOfVertexListOfStripe self, Standard_Integer value)"""
        return _ChFiDS.ChFiDS_IndexedDataMapNodeOfIndexedDataMapOfVertexListOfStripe_SetKey2(self, *args)

    def Next2(self, *args):
        """
        :rtype: TCollection_MapNodePtr

        """
        return _ChFiDS.ChFiDS_IndexedDataMapNodeOfIndexedDataMapOfVertexListOfStripe_Next2(self, *args)

    def Value(self, *args):
        """
        :rtype: ChFiDS_ListOfStripe

        """
        return _ChFiDS.ChFiDS_IndexedDataMapNodeOfIndexedDataMapOfVertexListOfStripe_Value(self, *args)

    def GetHandle(self):
        try:
            return self.thisHandle
        except:
            self.thisHandle = Handle_ChFiDS_IndexedDataMapNodeOfIndexedDataMapOfVertexListOfStripe(self)
            self.thisown = False
            return self.thisHandle

    __swig_destroy__ = _ChFiDS.delete_ChFiDS_IndexedDataMapNodeOfIndexedDataMapOfVertexListOfStripe
ChFiDS_IndexedDataMapNodeOfIndexedDataMapOfVertexListOfStripe.Key1 = new_instancemethod(_ChFiDS.ChFiDS_IndexedDataMapNodeOfIndexedDataMapOfVertexListOfStripe_Key1,None,ChFiDS_IndexedDataMapNodeOfIndexedDataMapOfVertexListOfStripe)
ChFiDS_IndexedDataMapNodeOfIndexedDataMapOfVertexListOfStripe.GetKey2 = new_instancemethod(_ChFiDS.ChFiDS_IndexedDataMapNodeOfIndexedDataMapOfVertexListOfStripe_GetKey2,None,ChFiDS_IndexedDataMapNodeOfIndexedDataMapOfVertexListOfStripe)
ChFiDS_IndexedDataMapNodeOfIndexedDataMapOfVertexListOfStripe.SetKey2 = new_instancemethod(_ChFiDS.ChFiDS_IndexedDataMapNodeOfIndexedDataMapOfVertexListOfStripe_SetKey2,None,ChFiDS_IndexedDataMapNodeOfIndexedDataMapOfVertexListOfStripe)
ChFiDS_IndexedDataMapNodeOfIndexedDataMapOfVertexListOfStripe.Next2 = new_instancemethod(_ChFiDS.ChFiDS_IndexedDataMapNodeOfIndexedDataMapOfVertexListOfStripe_Next2,None,ChFiDS_IndexedDataMapNodeOfIndexedDataMapOfVertexListOfStripe)
ChFiDS_IndexedDataMapNodeOfIndexedDataMapOfVertexListOfStripe.Value = new_instancemethod(_ChFiDS.ChFiDS_IndexedDataMapNodeOfIndexedDataMapOfVertexListOfStripe_Value,None,ChFiDS_IndexedDataMapNodeOfIndexedDataMapOfVertexListOfStripe)
ChFiDS_IndexedDataMapNodeOfIndexedDataMapOfVertexListOfStripe_swigregister = _ChFiDS.ChFiDS_IndexedDataMapNodeOfIndexedDataMapOfVertexListOfStripe_swigregister
ChFiDS_IndexedDataMapNodeOfIndexedDataMapOfVertexListOfStripe_swigregister(ChFiDS_IndexedDataMapNodeOfIndexedDataMapOfVertexListOfStripe)

class Handle_ChFiDS_IndexedDataMapNodeOfIndexedDataMapOfVertexListOfStripe(OCC.TCollection.Handle_TCollection_MapNode):
    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): 
        _ChFiDS.Handle_ChFiDS_IndexedDataMapNodeOfIndexedDataMapOfVertexListOfStripe_swiginit(self,_ChFiDS.new_Handle_ChFiDS_IndexedDataMapNodeOfIndexedDataMapOfVertexListOfStripe(*args))
        # register the handle in the base object
        if len(args) > 0:
            register_handle(self, args[0])



    DownCast = staticmethod(_ChFiDS.Handle_ChFiDS_IndexedDataMapNodeOfIndexedDataMapOfVertexListOfStripe_DownCast)
    __swig_destroy__ = _ChFiDS.delete_Handle_ChFiDS_IndexedDataMapNodeOfIndexedDataMapOfVertexListOfStripe
Handle_ChFiDS_IndexedDataMapNodeOfIndexedDataMapOfVertexListOfStripe.Nullify = new_instancemethod(_ChFiDS.Handle_ChFiDS_IndexedDataMapNodeOfIndexedDataMapOfVertexListOfStripe_Nullify,None,Handle_ChFiDS_IndexedDataMapNodeOfIndexedDataMapOfVertexListOfStripe)
Handle_ChFiDS_IndexedDataMapNodeOfIndexedDataMapOfVertexListOfStripe.IsNull = new_instancemethod(_ChFiDS.Handle_ChFiDS_IndexedDataMapNodeOfIndexedDataMapOfVertexListOfStripe_IsNull,None,Handle_ChFiDS_IndexedDataMapNodeOfIndexedDataMapOfVertexListOfStripe)
Handle_ChFiDS_IndexedDataMapNodeOfIndexedDataMapOfVertexListOfStripe.GetObject = new_instancemethod(_ChFiDS.Handle_ChFiDS_IndexedDataMapNodeOfIndexedDataMapOfVertexListOfStripe_GetObject,None,Handle_ChFiDS_IndexedDataMapNodeOfIndexedDataMapOfVertexListOfStripe)
Handle_ChFiDS_IndexedDataMapNodeOfIndexedDataMapOfVertexListOfStripe_swigregister = _ChFiDS.Handle_ChFiDS_IndexedDataMapNodeOfIndexedDataMapOfVertexListOfStripe_swigregister
Handle_ChFiDS_IndexedDataMapNodeOfIndexedDataMapOfVertexListOfStripe_swigregister(Handle_ChFiDS_IndexedDataMapNodeOfIndexedDataMapOfVertexListOfStripe)

def Handle_ChFiDS_IndexedDataMapNodeOfIndexedDataMapOfVertexListOfStripe_DownCast(*args):
  return _ChFiDS.Handle_ChFiDS_IndexedDataMapNodeOfIndexedDataMapOfVertexListOfStripe_DownCast(*args)
Handle_ChFiDS_IndexedDataMapNodeOfIndexedDataMapOfVertexListOfStripe_DownCast = _ChFiDS.Handle_ChFiDS_IndexedDataMapNodeOfIndexedDataMapOfVertexListOfStripe_DownCast

class ChFiDS_IndexedDataMapOfVertexListOfStripe(OCC.TCollection.TCollection_BasicMap):
    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): 
        """
        :param NbBuckets: default value is 1
        :type NbBuckets: int
        :rtype: None

        """
        _ChFiDS.ChFiDS_IndexedDataMapOfVertexListOfStripe_swiginit(self,_ChFiDS.new_ChFiDS_IndexedDataMapOfVertexListOfStripe(*args))
    def Assign(self, *args):
        """
        :param Other:
        :type Other: ChFiDS_IndexedDataMapOfVertexListOfStripe &
        :rtype: ChFiDS_IndexedDataMapOfVertexListOfStripe

        """
        return _ChFiDS.ChFiDS_IndexedDataMapOfVertexListOfStripe_Assign(self, *args)

    def Set(self, *args):
        """
        :param Other:
        :type Other: ChFiDS_IndexedDataMapOfVertexListOfStripe &
        :rtype: ChFiDS_IndexedDataMapOfVertexListOfStripe

        """
        return _ChFiDS.ChFiDS_IndexedDataMapOfVertexListOfStripe_Set(self, *args)

    def ReSize(self, *args):
        """
        :param NbBuckets:
        :type NbBuckets: int
        :rtype: None

        """
        return _ChFiDS.ChFiDS_IndexedDataMapOfVertexListOfStripe_ReSize(self, *args)

    def Clear(self, *args):
        """
        :rtype: None

        """
        return _ChFiDS.ChFiDS_IndexedDataMapOfVertexListOfStripe_Clear(self, *args)

    def Add(self, *args):
        """
        :param K:
        :type K: TopoDS_Vertex &
        :param I:
        :type I: ChFiDS_ListOfStripe &
        :rtype: int

        """
        return _ChFiDS.ChFiDS_IndexedDataMapOfVertexListOfStripe_Add(self, *args)

    def Substitute(self, *args):
        """
        :param I:
        :type I: int
        :param K:
        :type K: TopoDS_Vertex &
        :param T:
        :type T: ChFiDS_ListOfStripe &
        :rtype: None

        """
        return _ChFiDS.ChFiDS_IndexedDataMapOfVertexListOfStripe_Substitute(self, *args)

    def RemoveLast(self, *args):
        """
        :rtype: None

        """
        return _ChFiDS.ChFiDS_IndexedDataMapOfVertexListOfStripe_RemoveLast(self, *args)

    def Contains(self, *args):
        """
        :param K:
        :type K: TopoDS_Vertex &
        :rtype: bool

        """
        return _ChFiDS.ChFiDS_IndexedDataMapOfVertexListOfStripe_Contains(self, *args)

    def FindKey(self, *args):
        """
        :param I:
        :type I: int
        :rtype: TopoDS_Vertex

        """
        return _ChFiDS.ChFiDS_IndexedDataMapOfVertexListOfStripe_FindKey(self, *args)

    def FindFromIndex(self, *args):
        """
        :param I:
        :type I: int
        :rtype: ChFiDS_ListOfStripe

        """
        return _ChFiDS.ChFiDS_IndexedDataMapOfVertexListOfStripe_FindFromIndex(self, *args)

    def ChangeFromIndex(self, *args):
        """
        :param I:
        :type I: int
        :rtype: ChFiDS_ListOfStripe

        """
        return _ChFiDS.ChFiDS_IndexedDataMapOfVertexListOfStripe_ChangeFromIndex(self, *args)

    def FindIndex(self, *args):
        """
        :param K:
        :type K: TopoDS_Vertex &
        :rtype: int

        """
        return _ChFiDS.ChFiDS_IndexedDataMapOfVertexListOfStripe_FindIndex(self, *args)

    def FindFromKey(self, *args):
        """
        :param K:
        :type K: TopoDS_Vertex &
        :rtype: ChFiDS_ListOfStripe

        """
        return _ChFiDS.ChFiDS_IndexedDataMapOfVertexListOfStripe_FindFromKey(self, *args)

    def ChangeFromKey(self, *args):
        """
        :param K:
        :type K: TopoDS_Vertex &
        :rtype: ChFiDS_ListOfStripe

        """
        return _ChFiDS.ChFiDS_IndexedDataMapOfVertexListOfStripe_ChangeFromKey(self, *args)

    def FindFromKey1(self, *args):
        """
        :param K:
        :type K: TopoDS_Vertex &
        :rtype: Standard_Address

        """
        return _ChFiDS.ChFiDS_IndexedDataMapOfVertexListOfStripe_FindFromKey1(self, *args)

    def ChangeFromKey1(self, *args):
        """
        :param K:
        :type K: TopoDS_Vertex &
        :rtype: Standard_Address

        """
        return _ChFiDS.ChFiDS_IndexedDataMapOfVertexListOfStripe_ChangeFromKey1(self, *args)

    __swig_destroy__ = _ChFiDS.delete_ChFiDS_IndexedDataMapOfVertexListOfStripe
ChFiDS_IndexedDataMapOfVertexListOfStripe.Assign = new_instancemethod(_ChFiDS.ChFiDS_IndexedDataMapOfVertexListOfStripe_Assign,None,ChFiDS_IndexedDataMapOfVertexListOfStripe)
ChFiDS_IndexedDataMapOfVertexListOfStripe.Set = new_instancemethod(_ChFiDS.ChFiDS_IndexedDataMapOfVertexListOfStripe_Set,None,ChFiDS_IndexedDataMapOfVertexListOfStripe)
ChFiDS_IndexedDataMapOfVertexListOfStripe.ReSize = new_instancemethod(_ChFiDS.ChFiDS_IndexedDataMapOfVertexListOfStripe_ReSize,None,ChFiDS_IndexedDataMapOfVertexListOfStripe)
ChFiDS_IndexedDataMapOfVertexListOfStripe.Clear = new_instancemethod(_ChFiDS.ChFiDS_IndexedDataMapOfVertexListOfStripe_Clear,None,ChFiDS_IndexedDataMapOfVertexListOfStripe)
ChFiDS_IndexedDataMapOfVertexListOfStripe.Add = new_instancemethod(_ChFiDS.ChFiDS_IndexedDataMapOfVertexListOfStripe_Add,None,ChFiDS_IndexedDataMapOfVertexListOfStripe)
ChFiDS_IndexedDataMapOfVertexListOfStripe.Substitute = new_instancemethod(_ChFiDS.ChFiDS_IndexedDataMapOfVertexListOfStripe_Substitute,None,ChFiDS_IndexedDataMapOfVertexListOfStripe)
ChFiDS_IndexedDataMapOfVertexListOfStripe.RemoveLast = new_instancemethod(_ChFiDS.ChFiDS_IndexedDataMapOfVertexListOfStripe_RemoveLast,None,ChFiDS_IndexedDataMapOfVertexListOfStripe)
ChFiDS_IndexedDataMapOfVertexListOfStripe.Contains = new_instancemethod(_ChFiDS.ChFiDS_IndexedDataMapOfVertexListOfStripe_Contains,None,ChFiDS_IndexedDataMapOfVertexListOfStripe)
ChFiDS_IndexedDataMapOfVertexListOfStripe.FindKey = new_instancemethod(_ChFiDS.ChFiDS_IndexedDataMapOfVertexListOfStripe_FindKey,None,ChFiDS_IndexedDataMapOfVertexListOfStripe)
ChFiDS_IndexedDataMapOfVertexListOfStripe.FindFromIndex = new_instancemethod(_ChFiDS.ChFiDS_IndexedDataMapOfVertexListOfStripe_FindFromIndex,None,ChFiDS_IndexedDataMapOfVertexListOfStripe)
ChFiDS_IndexedDataMapOfVertexListOfStripe.ChangeFromIndex = new_instancemethod(_ChFiDS.ChFiDS_IndexedDataMapOfVertexListOfStripe_ChangeFromIndex,None,ChFiDS_IndexedDataMapOfVertexListOfStripe)
ChFiDS_IndexedDataMapOfVertexListOfStripe.FindIndex = new_instancemethod(_ChFiDS.ChFiDS_IndexedDataMapOfVertexListOfStripe_FindIndex,None,ChFiDS_IndexedDataMapOfVertexListOfStripe)
ChFiDS_IndexedDataMapOfVertexListOfStripe.FindFromKey = new_instancemethod(_ChFiDS.ChFiDS_IndexedDataMapOfVertexListOfStripe_FindFromKey,None,ChFiDS_IndexedDataMapOfVertexListOfStripe)
ChFiDS_IndexedDataMapOfVertexListOfStripe.ChangeFromKey = new_instancemethod(_ChFiDS.ChFiDS_IndexedDataMapOfVertexListOfStripe_ChangeFromKey,None,ChFiDS_IndexedDataMapOfVertexListOfStripe)
ChFiDS_IndexedDataMapOfVertexListOfStripe.FindFromKey1 = new_instancemethod(_ChFiDS.ChFiDS_IndexedDataMapOfVertexListOfStripe_FindFromKey1,None,ChFiDS_IndexedDataMapOfVertexListOfStripe)
ChFiDS_IndexedDataMapOfVertexListOfStripe.ChangeFromKey1 = new_instancemethod(_ChFiDS.ChFiDS_IndexedDataMapOfVertexListOfStripe_ChangeFromKey1,None,ChFiDS_IndexedDataMapOfVertexListOfStripe)
ChFiDS_IndexedDataMapOfVertexListOfStripe_swigregister = _ChFiDS.ChFiDS_IndexedDataMapOfVertexListOfStripe_swigregister
ChFiDS_IndexedDataMapOfVertexListOfStripe_swigregister(ChFiDS_IndexedDataMapOfVertexListOfStripe)

class ChFiDS_ListIteratorOfListOfHElSpine(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

        :param L:
        :type L: ChFiDS_ListOfHElSpine &
        :rtype: None

        """
        _ChFiDS.ChFiDS_ListIteratorOfListOfHElSpine_swiginit(self,_ChFiDS.new_ChFiDS_ListIteratorOfListOfHElSpine(*args))
    def Initialize(self, *args):
        """
        :param L:
        :type L: ChFiDS_ListOfHElSpine &
        :rtype: None

        """
        return _ChFiDS.ChFiDS_ListIteratorOfListOfHElSpine_Initialize(self, *args)

    def More(self, *args):
        """
        :rtype: bool

        """
        return _ChFiDS.ChFiDS_ListIteratorOfListOfHElSpine_More(self, *args)

    def Next(self, *args):
        """
        :rtype: None

        """
        return _ChFiDS.ChFiDS_ListIteratorOfListOfHElSpine_Next(self, *args)

    def Value(self, *args):
        """
        :rtype: Handle_ChFiDS_HElSpine

        """
        return _ChFiDS.ChFiDS_ListIteratorOfListOfHElSpine_Value(self, *args)

    __swig_destroy__ = _ChFiDS.delete_ChFiDS_ListIteratorOfListOfHElSpine
ChFiDS_ListIteratorOfListOfHElSpine.Initialize = new_instancemethod(_ChFiDS.ChFiDS_ListIteratorOfListOfHElSpine_Initialize,None,ChFiDS_ListIteratorOfListOfHElSpine)
ChFiDS_ListIteratorOfListOfHElSpine.More = new_instancemethod(_ChFiDS.ChFiDS_ListIteratorOfListOfHElSpine_More,None,ChFiDS_ListIteratorOfListOfHElSpine)
ChFiDS_ListIteratorOfListOfHElSpine.Next = new_instancemethod(_ChFiDS.ChFiDS_ListIteratorOfListOfHElSpine_Next,None,ChFiDS_ListIteratorOfListOfHElSpine)
ChFiDS_ListIteratorOfListOfHElSpine.Value = new_instancemethod(_ChFiDS.ChFiDS_ListIteratorOfListOfHElSpine_Value,None,ChFiDS_ListIteratorOfListOfHElSpine)
ChFiDS_ListIteratorOfListOfHElSpine_swigregister = _ChFiDS.ChFiDS_ListIteratorOfListOfHElSpine_swigregister
ChFiDS_ListIteratorOfListOfHElSpine_swigregister(ChFiDS_ListIteratorOfListOfHElSpine)

class ChFiDS_ListIteratorOfListOfStripe(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

        :param L:
        :type L: ChFiDS_ListOfStripe &
        :rtype: None

        """
        _ChFiDS.ChFiDS_ListIteratorOfListOfStripe_swiginit(self,_ChFiDS.new_ChFiDS_ListIteratorOfListOfStripe(*args))
    def Initialize(self, *args):
        """
        :param L:
        :type L: ChFiDS_ListOfStripe &
        :rtype: None

        """
        return _ChFiDS.ChFiDS_ListIteratorOfListOfStripe_Initialize(self, *args)

    def More(self, *args):
        """
        :rtype: bool

        """
        return _ChFiDS.ChFiDS_ListIteratorOfListOfStripe_More(self, *args)

    def Next(self, *args):
        """
        :rtype: None

        """
        return _ChFiDS.ChFiDS_ListIteratorOfListOfStripe_Next(self, *args)

    def Value(self, *args):
        """
        :rtype: Handle_ChFiDS_Stripe

        """
        return _ChFiDS.ChFiDS_ListIteratorOfListOfStripe_Value(self, *args)

    __swig_destroy__ = _ChFiDS.delete_ChFiDS_ListIteratorOfListOfStripe
ChFiDS_ListIteratorOfListOfStripe.Initialize = new_instancemethod(_ChFiDS.ChFiDS_ListIteratorOfListOfStripe_Initialize,None,ChFiDS_ListIteratorOfListOfStripe)
ChFiDS_ListIteratorOfListOfStripe.More = new_instancemethod(_ChFiDS.ChFiDS_ListIteratorOfListOfStripe_More,None,ChFiDS_ListIteratorOfListOfStripe)
ChFiDS_ListIteratorOfListOfStripe.Next = new_instancemethod(_ChFiDS.ChFiDS_ListIteratorOfListOfStripe_Next,None,ChFiDS_ListIteratorOfListOfStripe)
ChFiDS_ListIteratorOfListOfStripe.Value = new_instancemethod(_ChFiDS.ChFiDS_ListIteratorOfListOfStripe_Value,None,ChFiDS_ListIteratorOfListOfStripe)
ChFiDS_ListIteratorOfListOfStripe_swigregister = _ChFiDS.ChFiDS_ListIteratorOfListOfStripe_swigregister
ChFiDS_ListIteratorOfListOfStripe_swigregister(ChFiDS_ListIteratorOfListOfStripe)

class ChFiDS_ListIteratorOfRegularities(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

        :param L:
        :type L: ChFiDS_Regularities &
        :rtype: None

        """
        _ChFiDS.ChFiDS_ListIteratorOfRegularities_swiginit(self,_ChFiDS.new_ChFiDS_ListIteratorOfRegularities(*args))
    def Initialize(self, *args):
        """
        :param L:
        :type L: ChFiDS_Regularities &
        :rtype: None

        """
        return _ChFiDS.ChFiDS_ListIteratorOfRegularities_Initialize(self, *args)

    def More(self, *args):
        """
        :rtype: bool

        """
        return _ChFiDS.ChFiDS_ListIteratorOfRegularities_More(self, *args)

    def Next(self, *args):
        """
        :rtype: None

        """
        return _ChFiDS.ChFiDS_ListIteratorOfRegularities_Next(self, *args)

    def Value(self, *args):
        """
        :rtype: ChFiDS_Regul

        """
        return _ChFiDS.ChFiDS_ListIteratorOfRegularities_Value(self, *args)

    __swig_destroy__ = _ChFiDS.delete_ChFiDS_ListIteratorOfRegularities
ChFiDS_ListIteratorOfRegularities.Initialize = new_instancemethod(_ChFiDS.ChFiDS_ListIteratorOfRegularities_Initialize,None,ChFiDS_ListIteratorOfRegularities)
ChFiDS_ListIteratorOfRegularities.More = new_instancemethod(_ChFiDS.ChFiDS_ListIteratorOfRegularities_More,None,ChFiDS_ListIteratorOfRegularities)
ChFiDS_ListIteratorOfRegularities.Next = new_instancemethod(_ChFiDS.ChFiDS_ListIteratorOfRegularities_Next,None,ChFiDS_ListIteratorOfRegularities)
ChFiDS_ListIteratorOfRegularities.Value = new_instancemethod(_ChFiDS.ChFiDS_ListIteratorOfRegularities_Value,None,ChFiDS_ListIteratorOfRegularities)
ChFiDS_ListIteratorOfRegularities_swigregister = _ChFiDS.ChFiDS_ListIteratorOfRegularities_swigregister
ChFiDS_ListIteratorOfRegularities_swigregister(ChFiDS_ListIteratorOfRegularities)

class ChFiDS_ListNodeOfListOfHElSpine(OCC.TCollection.TCollection_MapNode):
    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): 
        """
        :param I:
        :type I: Handle_ChFiDS_HElSpine &
        :param n:
        :type n: TCollection_MapNodePtr &
        :rtype: None

        """
        _ChFiDS.ChFiDS_ListNodeOfListOfHElSpine_swiginit(self,_ChFiDS.new_ChFiDS_ListNodeOfListOfHElSpine(*args))
    def Value(self, *args):
        """
        :rtype: Handle_ChFiDS_HElSpine

        """
        return _ChFiDS.ChFiDS_ListNodeOfListOfHElSpine_Value(self, *args)

    def GetHandle(self):
        try:
            return self.thisHandle
        except:
            self.thisHandle = Handle_ChFiDS_ListNodeOfListOfHElSpine(self)
            self.thisown = False
            return self.thisHandle

    __swig_destroy__ = _ChFiDS.delete_ChFiDS_ListNodeOfListOfHElSpine
ChFiDS_ListNodeOfListOfHElSpine.Value = new_instancemethod(_ChFiDS.ChFiDS_ListNodeOfListOfHElSpine_Value,None,ChFiDS_ListNodeOfListOfHElSpine)
ChFiDS_ListNodeOfListOfHElSpine_swigregister = _ChFiDS.ChFiDS_ListNodeOfListOfHElSpine_swigregister
ChFiDS_ListNodeOfListOfHElSpine_swigregister(ChFiDS_ListNodeOfListOfHElSpine)

class Handle_ChFiDS_ListNodeOfListOfHElSpine(OCC.TCollection.Handle_TCollection_MapNode):
    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): 
        _ChFiDS.Handle_ChFiDS_ListNodeOfListOfHElSpine_swiginit(self,_ChFiDS.new_Handle_ChFiDS_ListNodeOfListOfHElSpine(*args))
        # register the handle in the base object
        if len(args) > 0:
            register_handle(self, args[0])



    DownCast = staticmethod(_ChFiDS.Handle_ChFiDS_ListNodeOfListOfHElSpine_DownCast)
    __swig_destroy__ = _ChFiDS.delete_Handle_ChFiDS_ListNodeOfListOfHElSpine
Handle_ChFiDS_ListNodeOfListOfHElSpine.Nullify = new_instancemethod(_ChFiDS.Handle_ChFiDS_ListNodeOfListOfHElSpine_Nullify,None,Handle_ChFiDS_ListNodeOfListOfHElSpine)
Handle_ChFiDS_ListNodeOfListOfHElSpine.IsNull = new_instancemethod(_ChFiDS.Handle_ChFiDS_ListNodeOfListOfHElSpine_IsNull,None,Handle_ChFiDS_ListNodeOfListOfHElSpine)
Handle_ChFiDS_ListNodeOfListOfHElSpine.GetObject = new_instancemethod(_ChFiDS.Handle_ChFiDS_ListNodeOfListOfHElSpine_GetObject,None,Handle_ChFiDS_ListNodeOfListOfHElSpine)
Handle_ChFiDS_ListNodeOfListOfHElSpine_swigregister = _ChFiDS.Handle_ChFiDS_ListNodeOfListOfHElSpine_swigregister
Handle_ChFiDS_ListNodeOfListOfHElSpine_swigregister(Handle_ChFiDS_ListNodeOfListOfHElSpine)

def Handle_ChFiDS_ListNodeOfListOfHElSpine_DownCast(*args):
  return _ChFiDS.Handle_ChFiDS_ListNodeOfListOfHElSpine_DownCast(*args)
Handle_ChFiDS_ListNodeOfListOfHElSpine_DownCast = _ChFiDS.Handle_ChFiDS_ListNodeOfListOfHElSpine_DownCast

class ChFiDS_ListNodeOfListOfStripe(OCC.TCollection.TCollection_MapNode):
    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): 
        """
        :param I:
        :type I: Handle_ChFiDS_Stripe &
        :param n:
        :type n: TCollection_MapNodePtr &
        :rtype: None

        """
        _ChFiDS.ChFiDS_ListNodeOfListOfStripe_swiginit(self,_ChFiDS.new_ChFiDS_ListNodeOfListOfStripe(*args))
    def Value(self, *args):
        """
        :rtype: Handle_ChFiDS_Stripe

        """
        return _ChFiDS.ChFiDS_ListNodeOfListOfStripe_Value(self, *args)

    def GetHandle(self):
        try:
            return self.thisHandle
        except:
            self.thisHandle = Handle_ChFiDS_ListNodeOfListOfStripe(self)
            self.thisown = False
            return self.thisHandle

    __swig_destroy__ = _ChFiDS.delete_ChFiDS_ListNodeOfListOfStripe
ChFiDS_ListNodeOfListOfStripe.Value = new_instancemethod(_ChFiDS.ChFiDS_ListNodeOfListOfStripe_Value,None,ChFiDS_ListNodeOfListOfStripe)
ChFiDS_ListNodeOfListOfStripe_swigregister = _ChFiDS.ChFiDS_ListNodeOfListOfStripe_swigregister
ChFiDS_ListNodeOfListOfStripe_swigregister(ChFiDS_ListNodeOfListOfStripe)

class Handle_ChFiDS_ListNodeOfListOfStripe(OCC.TCollection.Handle_TCollection_MapNode):
    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): 
        _ChFiDS.Handle_ChFiDS_ListNodeOfListOfStripe_swiginit(self,_ChFiDS.new_Handle_ChFiDS_ListNodeOfListOfStripe(*args))
        # register the handle in the base object
        if len(args) > 0:
            register_handle(self, args[0])



    DownCast = staticmethod(_ChFiDS.Handle_ChFiDS_ListNodeOfListOfStripe_DownCast)
    __swig_destroy__ = _ChFiDS.delete_Handle_ChFiDS_ListNodeOfListOfStripe
Handle_ChFiDS_ListNodeOfListOfStripe.Nullify = new_instancemethod(_ChFiDS.Handle_ChFiDS_ListNodeOfListOfStripe_Nullify,None,Handle_ChFiDS_ListNodeOfListOfStripe)
Handle_ChFiDS_ListNodeOfListOfStripe.IsNull = new_instancemethod(_ChFiDS.Handle_ChFiDS_ListNodeOfListOfStripe_IsNull,None,Handle_ChFiDS_ListNodeOfListOfStripe)
Handle_ChFiDS_ListNodeOfListOfStripe.GetObject = new_instancemethod(_ChFiDS.Handle_ChFiDS_ListNodeOfListOfStripe_GetObject,None,Handle_ChFiDS_ListNodeOfListOfStripe)
Handle_ChFiDS_ListNodeOfListOfStripe_swigregister = _ChFiDS.Handle_ChFiDS_ListNodeOfListOfStripe_swigregister
Handle_ChFiDS_ListNodeOfListOfStripe_swigregister(Handle_ChFiDS_ListNodeOfListOfStripe)

def Handle_ChFiDS_ListNodeOfListOfStripe_DownCast(*args):
  return _ChFiDS.Handle_ChFiDS_ListNodeOfListOfStripe_DownCast(*args)
Handle_ChFiDS_ListNodeOfListOfStripe_DownCast = _ChFiDS.Handle_ChFiDS_ListNodeOfListOfStripe_DownCast

class ChFiDS_ListNodeOfRegularities(OCC.TCollection.TCollection_MapNode):
    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): 
        """
        :param I:
        :type I: ChFiDS_Regul &
        :param n:
        :type n: TCollection_MapNodePtr &
        :rtype: None

        """
        _ChFiDS.ChFiDS_ListNodeOfRegularities_swiginit(self,_ChFiDS.new_ChFiDS_ListNodeOfRegularities(*args))
    def Value(self, *args):
        """
        :rtype: ChFiDS_Regul

        """
        return _ChFiDS.ChFiDS_ListNodeOfRegularities_Value(self, *args)

    def GetHandle(self):
        try:
            return self.thisHandle
        except:
            self.thisHandle = Handle_ChFiDS_ListNodeOfRegularities(self)
            self.thisown = False
            return self.thisHandle

    __swig_destroy__ = _ChFiDS.delete_ChFiDS_ListNodeOfRegularities
ChFiDS_ListNodeOfRegularities.Value = new_instancemethod(_ChFiDS.ChFiDS_ListNodeOfRegularities_Value,None,ChFiDS_ListNodeOfRegularities)
ChFiDS_ListNodeOfRegularities_swigregister = _ChFiDS.ChFiDS_ListNodeOfRegularities_swigregister
ChFiDS_ListNodeOfRegularities_swigregister(ChFiDS_ListNodeOfRegularities)

class Handle_ChFiDS_ListNodeOfRegularities(OCC.TCollection.Handle_TCollection_MapNode):
    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): 
        _ChFiDS.Handle_ChFiDS_ListNodeOfRegularities_swiginit(self,_ChFiDS.new_Handle_ChFiDS_ListNodeOfRegularities(*args))
        # register the handle in the base object
        if len(args) > 0:
            register_handle(self, args[0])



    DownCast = staticmethod(_ChFiDS.Handle_ChFiDS_ListNodeOfRegularities_DownCast)
    __swig_destroy__ = _ChFiDS.delete_Handle_ChFiDS_ListNodeOfRegularities
Handle_ChFiDS_ListNodeOfRegularities.Nullify = new_instancemethod(_ChFiDS.Handle_ChFiDS_ListNodeOfRegularities_Nullify,None,Handle_ChFiDS_ListNodeOfRegularities)
Handle_ChFiDS_ListNodeOfRegularities.IsNull = new_instancemethod(_ChFiDS.Handle_ChFiDS_ListNodeOfRegularities_IsNull,None,Handle_ChFiDS_ListNodeOfRegularities)
Handle_ChFiDS_ListNodeOfRegularities.GetObject = new_instancemethod(_ChFiDS.Handle_ChFiDS_ListNodeOfRegularities_GetObject,None,Handle_ChFiDS_ListNodeOfRegularities)
Handle_ChFiDS_ListNodeOfRegularities_swigregister = _ChFiDS.Handle_ChFiDS_ListNodeOfRegularities_swigregister
Handle_ChFiDS_ListNodeOfRegularities_swigregister(Handle_ChFiDS_ListNodeOfRegularities)

def Handle_ChFiDS_ListNodeOfRegularities_DownCast(*args):
  return _ChFiDS.Handle_ChFiDS_ListNodeOfRegularities_DownCast(*args)
Handle_ChFiDS_ListNodeOfRegularities_DownCast = _ChFiDS.Handle_ChFiDS_ListNodeOfRegularities_DownCast

class ChFiDS_ListOfHElSpine(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

        """
        _ChFiDS.ChFiDS_ListOfHElSpine_swiginit(self,_ChFiDS.new_ChFiDS_ListOfHElSpine(*args))
    def Assign(self, *args):
        """
        :param Other:
        :type Other: ChFiDS_ListOfHElSpine &
        :rtype: None

        """
        return _ChFiDS.ChFiDS_ListOfHElSpine_Assign(self, *args)

    def Set(self, *args):
        """
        :param Other:
        :type Other: ChFiDS_ListOfHElSpine &
        :rtype: None

        """
        return _ChFiDS.ChFiDS_ListOfHElSpine_Set(self, *args)

    def Extent(self, *args):
        """
        :rtype: int

        """
        return _ChFiDS.ChFiDS_ListOfHElSpine_Extent(self, *args)

    def Clear(self, *args):
        """
        :rtype: None

        """
        return _ChFiDS.ChFiDS_ListOfHElSpine_Clear(self, *args)

    def IsEmpty(self, *args):
        """
        :rtype: bool

        """
        return _ChFiDS.ChFiDS_ListOfHElSpine_IsEmpty(self, *args)

    def Prepend(self, *args):
        """
        :param I:
        :type I: Handle_ChFiDS_HElSpine &
        :rtype: None

        :param I:
        :type I: Handle_ChFiDS_HElSpine &
        :param theIt:
        :type theIt: ChFiDS_ListIteratorOfListOfHElSpine &
        :rtype: None

        :param Other:
        :type Other: ChFiDS_ListOfHElSpine &
        :rtype: None

        """
        return _ChFiDS.ChFiDS_ListOfHElSpine_Prepend(self, *args)

    def Append(self, *args):
        """
        :param I:
        :type I: Handle_ChFiDS_HElSpine &
        :rtype: None

        :param I:
        :type I: Handle_ChFiDS_HElSpine &
        :param theIt:
        :type theIt: ChFiDS_ListIteratorOfListOfHElSpine &
        :rtype: None

        :param Other:
        :type Other: ChFiDS_ListOfHElSpine &
        :rtype: None

        """
        return _ChFiDS.ChFiDS_ListOfHElSpine_Append(self, *args)

    def First(self, *args):
        """
        :rtype: Handle_ChFiDS_HElSpine

        """
        return _ChFiDS.ChFiDS_ListOfHElSpine_First(self, *args)

    def Last(self, *args):
        """
        :rtype: Handle_ChFiDS_HElSpine

        """
        return _ChFiDS.ChFiDS_ListOfHElSpine_Last(self, *args)

    def RemoveFirst(self, *args):
        """
        :rtype: None

        """
        return _ChFiDS.ChFiDS_ListOfHElSpine_RemoveFirst(self, *args)

    def Remove(self, *args):
        """
        :param It:
        :type It: ChFiDS_ListIteratorOfListOfHElSpine &
        :rtype: None

        """
        return _ChFiDS.ChFiDS_ListOfHElSpine_Remove(self, *args)

    def InsertBefore(self, *args):
        """
        :param I:
        :type I: Handle_ChFiDS_HElSpine &
        :param It:
        :type It: ChFiDS_ListIteratorOfListOfHElSpine &
        :rtype: None

        :param Other:
        :type Other: ChFiDS_ListOfHElSpine &
        :param It:
        :type It: ChFiDS_ListIteratorOfListOfHElSpine &
        :rtype: None

        """
        return _ChFiDS.ChFiDS_ListOfHElSpine_InsertBefore(self, *args)

    def InsertAfter(self, *args):
        """
        :param I:
        :type I: Handle_ChFiDS_HElSpine &
        :param It:
        :type It: ChFiDS_ListIteratorOfListOfHElSpine &
        :rtype: None

        :param Other:
        :type Other: ChFiDS_ListOfHElSpine &
        :param It:
        :type It: ChFiDS_ListIteratorOfListOfHElSpine &
        :rtype: None

        """
        return _ChFiDS.ChFiDS_ListOfHElSpine_InsertAfter(self, *args)

    __swig_destroy__ = _ChFiDS.delete_ChFiDS_ListOfHElSpine
ChFiDS_ListOfHElSpine.Assign = new_instancemethod(_ChFiDS.ChFiDS_ListOfHElSpine_Assign,None,ChFiDS_ListOfHElSpine)
ChFiDS_ListOfHElSpine.Set = new_instancemethod(_ChFiDS.ChFiDS_ListOfHElSpine_Set,None,ChFiDS_ListOfHElSpine)
ChFiDS_ListOfHElSpine.Extent = new_instancemethod(_ChFiDS.ChFiDS_ListOfHElSpine_Extent,None,ChFiDS_ListOfHElSpine)
ChFiDS_ListOfHElSpine.Clear = new_instancemethod(_ChFiDS.ChFiDS_ListOfHElSpine_Clear,None,ChFiDS_ListOfHElSpine)
ChFiDS_ListOfHElSpine.IsEmpty = new_instancemethod(_ChFiDS.ChFiDS_ListOfHElSpine_IsEmpty,None,ChFiDS_ListOfHElSpine)
ChFiDS_ListOfHElSpine.Prepend = new_instancemethod(_ChFiDS.ChFiDS_ListOfHElSpine_Prepend,None,ChFiDS_ListOfHElSpine)
ChFiDS_ListOfHElSpine.Append = new_instancemethod(_ChFiDS.ChFiDS_ListOfHElSpine_Append,None,ChFiDS_ListOfHElSpine)
ChFiDS_ListOfHElSpine.First = new_instancemethod(_ChFiDS.ChFiDS_ListOfHElSpine_First,None,ChFiDS_ListOfHElSpine)
ChFiDS_ListOfHElSpine.Last = new_instancemethod(_ChFiDS.ChFiDS_ListOfHElSpine_Last,None,ChFiDS_ListOfHElSpine)
ChFiDS_ListOfHElSpine.RemoveFirst = new_instancemethod(_ChFiDS.ChFiDS_ListOfHElSpine_RemoveFirst,None,ChFiDS_ListOfHElSpine)
ChFiDS_ListOfHElSpine.Remove = new_instancemethod(_ChFiDS.ChFiDS_ListOfHElSpine_Remove,None,ChFiDS_ListOfHElSpine)
ChFiDS_ListOfHElSpine.InsertBefore = new_instancemethod(_ChFiDS.ChFiDS_ListOfHElSpine_InsertBefore,None,ChFiDS_ListOfHElSpine)
ChFiDS_ListOfHElSpine.InsertAfter = new_instancemethod(_ChFiDS.ChFiDS_ListOfHElSpine_InsertAfter,None,ChFiDS_ListOfHElSpine)
ChFiDS_ListOfHElSpine_swigregister = _ChFiDS.ChFiDS_ListOfHElSpine_swigregister
ChFiDS_ListOfHElSpine_swigregister(ChFiDS_ListOfHElSpine)

class ChFiDS_ListOfStripe(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

        """
        _ChFiDS.ChFiDS_ListOfStripe_swiginit(self,_ChFiDS.new_ChFiDS_ListOfStripe(*args))
    def Assign(self, *args):
        """
        :param Other:
        :type Other: ChFiDS_ListOfStripe &
        :rtype: None

        """
        return _ChFiDS.ChFiDS_ListOfStripe_Assign(self, *args)

    def Set(self, *args):
        """
        :param Other:
        :type Other: ChFiDS_ListOfStripe &
        :rtype: None

        """
        return _ChFiDS.ChFiDS_ListOfStripe_Set(self, *args)

    def Extent(self, *args):
        """
        :rtype: int

        """
        return _ChFiDS.ChFiDS_ListOfStripe_Extent(self, *args)

    def Clear(self, *args):
        """
        :rtype: None

        """
        return _ChFiDS.ChFiDS_ListOfStripe_Clear(self, *args)

    def IsEmpty(self, *args):
        """
        :rtype: bool

        """
        return _ChFiDS.ChFiDS_ListOfStripe_IsEmpty(self, *args)

    def Prepend(self, *args):
        """
        :param I:
        :type I: Handle_ChFiDS_Stripe &
        :rtype: None

        :param I:
        :type I: Handle_ChFiDS_Stripe &
        :param theIt:
        :type theIt: ChFiDS_ListIteratorOfListOfStripe &
        :rtype: None

        :param Other:
        :type Other: ChFiDS_ListOfStripe &
        :rtype: None

        """
        return _ChFiDS.ChFiDS_ListOfStripe_Prepend(self, *args)

    def Append(self, *args):
        """
        :param I:
        :type I: Handle_ChFiDS_Stripe &
        :rtype: None

        :param I:
        :type I: Handle_ChFiDS_Stripe &
        :param theIt:
        :type theIt: ChFiDS_ListIteratorOfListOfStripe &
        :rtype: None

        :param Other:
        :type Other: ChFiDS_ListOfStripe &
        :rtype: None

        """
        return _ChFiDS.ChFiDS_ListOfStripe_Append(self, *args)

    def First(self, *args):
        """
        :rtype: Handle_ChFiDS_Stripe

        """
        return _ChFiDS.ChFiDS_ListOfStripe_First(self, *args)

    def Last(self, *args):
        """
        :rtype: Handle_ChFiDS_Stripe

        """
        return _ChFiDS.ChFiDS_ListOfStripe_Last(self, *args)

    def RemoveFirst(self, *args):
        """
        :rtype: None

        """
        return _ChFiDS.ChFiDS_ListOfStripe_RemoveFirst(self, *args)

    def Remove(self, *args):
        """
        :param It:
        :type It: ChFiDS_ListIteratorOfListOfStripe &
        :rtype: None

        """
        return _ChFiDS.ChFiDS_ListOfStripe_Remove(self, *args)

    def InsertBefore(self, *args):
        """
        :param I:
        :type I: Handle_ChFiDS_Stripe &
        :param It:
        :type It: ChFiDS_ListIteratorOfListOfStripe &
        :rtype: None

        :param Other:
        :type Other: ChFiDS_ListOfStripe &
        :param It:
        :type It: ChFiDS_ListIteratorOfListOfStripe &
        :rtype: None

        """
        return _ChFiDS.ChFiDS_ListOfStripe_InsertBefore(self, *args)

    def InsertAfter(self, *args):
        """
        :param I:
        :type I: Handle_ChFiDS_Stripe &
        :param It:
        :type It: ChFiDS_ListIteratorOfListOfStripe &
        :rtype: None

        :param Other:
        :type Other: ChFiDS_ListOfStripe &
        :param It:
        :type It: ChFiDS_ListIteratorOfListOfStripe &
        :rtype: None

        """
        return _ChFiDS.ChFiDS_ListOfStripe_InsertAfter(self, *args)

    __swig_destroy__ = _ChFiDS.delete_ChFiDS_ListOfStripe
ChFiDS_ListOfStripe.Assign = new_instancemethod(_ChFiDS.ChFiDS_ListOfStripe_Assign,None,ChFiDS_ListOfStripe)
ChFiDS_ListOfStripe.Set = new_instancemethod(_ChFiDS.ChFiDS_ListOfStripe_Set,None,ChFiDS_ListOfStripe)
ChFiDS_ListOfStripe.Extent = new_instancemethod(_ChFiDS.ChFiDS_ListOfStripe_Extent,None,ChFiDS_ListOfStripe)
ChFiDS_ListOfStripe.Clear = new_instancemethod(_ChFiDS.ChFiDS_ListOfStripe_Clear,None,ChFiDS_ListOfStripe)
ChFiDS_ListOfStripe.IsEmpty = new_instancemethod(_ChFiDS.ChFiDS_ListOfStripe_IsEmpty,None,ChFiDS_ListOfStripe)
ChFiDS_ListOfStripe.Prepend = new_instancemethod(_ChFiDS.ChFiDS_ListOfStripe_Prepend,None,ChFiDS_ListOfStripe)
ChFiDS_ListOfStripe.Append = new_instancemethod(_ChFiDS.ChFiDS_ListOfStripe_Append,None,ChFiDS_ListOfStripe)
ChFiDS_ListOfStripe.First = new_instancemethod(_ChFiDS.ChFiDS_ListOfStripe_First,None,ChFiDS_ListOfStripe)
ChFiDS_ListOfStripe.Last = new_instancemethod(_ChFiDS.ChFiDS_ListOfStripe_Last,None,ChFiDS_ListOfStripe)
ChFiDS_ListOfStripe.RemoveFirst = new_instancemethod(_ChFiDS.ChFiDS_ListOfStripe_RemoveFirst,None,ChFiDS_ListOfStripe)
ChFiDS_ListOfStripe.Remove = new_instancemethod(_ChFiDS.ChFiDS_ListOfStripe_Remove,None,ChFiDS_ListOfStripe)
ChFiDS_ListOfStripe.InsertBefore = new_instancemethod(_ChFiDS.ChFiDS_ListOfStripe_InsertBefore,None,ChFiDS_ListOfStripe)
ChFiDS_ListOfStripe.InsertAfter = new_instancemethod(_ChFiDS.ChFiDS_ListOfStripe_InsertAfter,None,ChFiDS_ListOfStripe)
ChFiDS_ListOfStripe_swigregister = _ChFiDS.ChFiDS_ListOfStripe_swigregister
ChFiDS_ListOfStripe_swigregister(ChFiDS_ListOfStripe)

class ChFiDS_Map(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): 
        """
        * Create an empty Map

        :rtype: None

        """
        _ChFiDS.ChFiDS_Map_swiginit(self,_ChFiDS.new_ChFiDS_Map(*args))
    def Fill(self, *args):
        """
        * Fills the map with the subshapes of type T1 as keys and the list of ancestors of type T2 as items.

        :param S:
        :type S: TopoDS_Shape &
        :param T1:
        :type T1: TopAbs_ShapeEnum
        :param T2:
        :type T2: TopAbs_ShapeEnum
        :rtype: None

        """
        return _ChFiDS.ChFiDS_Map_Fill(self, *args)

    def Contains(self, *args):
        """
        :param S:
        :type S: TopoDS_Shape &
        :rtype: bool

        """
        return _ChFiDS.ChFiDS_Map_Contains(self, *args)

    def FindFromKey(self, *args):
        """
        :param S:
        :type S: TopoDS_Shape &
        :rtype: TopTools_ListOfShape

        """
        return _ChFiDS.ChFiDS_Map_FindFromKey(self, *args)

    def FindFromIndex(self, *args):
        """
        :param I:
        :type I: int
        :rtype: TopTools_ListOfShape

        """
        return _ChFiDS.ChFiDS_Map_FindFromIndex(self, *args)

    __swig_destroy__ = _ChFiDS.delete_ChFiDS_Map
ChFiDS_Map.Fill = new_instancemethod(_ChFiDS.ChFiDS_Map_Fill,None,ChFiDS_Map)
ChFiDS_Map.Contains = new_instancemethod(_ChFiDS.ChFiDS_Map_Contains,None,ChFiDS_Map)
ChFiDS_Map.FindFromKey = new_instancemethod(_ChFiDS.ChFiDS_Map_FindFromKey,None,ChFiDS_Map)
ChFiDS_Map.FindFromIndex = new_instancemethod(_ChFiDS.ChFiDS_Map_FindFromIndex,None,ChFiDS_Map)
ChFiDS_Map_swigregister = _ChFiDS.ChFiDS_Map_swigregister
ChFiDS_Map_swigregister(ChFiDS_Map)

class ChFiDS_Regul(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

        """
        _ChFiDS.ChFiDS_Regul_swiginit(self,_ChFiDS.new_ChFiDS_Regul(*args))
    def SetCurve(self, *args):
        """
        :param IC:
        :type IC: int
        :rtype: None

        """
        return _ChFiDS.ChFiDS_Regul_SetCurve(self, *args)

    def SetS1(self, *args):
        """
        :param IS1:
        :type IS1: int
        :param IsFace: default value is Standard_True
        :type IsFace: bool
        :rtype: None

        """
        return _ChFiDS.ChFiDS_Regul_SetS1(self, *args)

    def SetS2(self, *args):
        """
        :param IS2:
        :type IS2: int
        :param IsFace: default value is Standard_True
        :type IsFace: bool
        :rtype: None

        """
        return _ChFiDS.ChFiDS_Regul_SetS2(self, *args)

    def IsSurface1(self, *args):
        """
        :rtype: bool

        """
        return _ChFiDS.ChFiDS_Regul_IsSurface1(self, *args)

    def IsSurface2(self, *args):
        """
        :rtype: bool

        """
        return _ChFiDS.ChFiDS_Regul_IsSurface2(self, *args)

    def Curve(self, *args):
        """
        :rtype: int

        """
        return _ChFiDS.ChFiDS_Regul_Curve(self, *args)

    def S1(self, *args):
        """
        :rtype: int

        """
        return _ChFiDS.ChFiDS_Regul_S1(self, *args)

    def S2(self, *args):
        """
        :rtype: int

        """
        return _ChFiDS.ChFiDS_Regul_S2(self, *args)

    __swig_destroy__ = _ChFiDS.delete_ChFiDS_Regul
ChFiDS_Regul.SetCurve = new_instancemethod(_ChFiDS.ChFiDS_Regul_SetCurve,None,ChFiDS_Regul)
ChFiDS_Regul.SetS1 = new_instancemethod(_ChFiDS.ChFiDS_Regul_SetS1,None,ChFiDS_Regul)
ChFiDS_Regul.SetS2 = new_instancemethod(_ChFiDS.ChFiDS_Regul_SetS2,None,ChFiDS_Regul)
ChFiDS_Regul.IsSurface1 = new_instancemethod(_ChFiDS.ChFiDS_Regul_IsSurface1,None,ChFiDS_Regul)
ChFiDS_Regul.IsSurface2 = new_instancemethod(_ChFiDS.ChFiDS_Regul_IsSurface2,None,ChFiDS_Regul)
ChFiDS_Regul.Curve = new_instancemethod(_ChFiDS.ChFiDS_Regul_Curve,None,ChFiDS_Regul)
ChFiDS_Regul.S1 = new_instancemethod(_ChFiDS.ChFiDS_Regul_S1,None,ChFiDS_Regul)
ChFiDS_Regul.S2 = new_instancemethod(_ChFiDS.ChFiDS_Regul_S2,None,ChFiDS_Regul)
ChFiDS_Regul_swigregister = _ChFiDS.ChFiDS_Regul_swigregister
ChFiDS_Regul_swigregister(ChFiDS_Regul)

class ChFiDS_Regularities(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

        """
        _ChFiDS.ChFiDS_Regularities_swiginit(self,_ChFiDS.new_ChFiDS_Regularities(*args))
    def Assign(self, *args):
        """
        :param Other:
        :type Other: ChFiDS_Regularities &
        :rtype: None

        """
        return _ChFiDS.ChFiDS_Regularities_Assign(self, *args)

    def Set(self, *args):
        """
        :param Other:
        :type Other: ChFiDS_Regularities &
        :rtype: None

        """
        return _ChFiDS.ChFiDS_Regularities_Set(self, *args)

    def Extent(self, *args):
        """
        :rtype: int

        """
        return _ChFiDS.ChFiDS_Regularities_Extent(self, *args)

    def Clear(self, *args):
        """
        :rtype: None

        """
        return _ChFiDS.ChFiDS_Regularities_Clear(self, *args)

    def IsEmpty(self, *args):
        """
        :rtype: bool

        """
        return _ChFiDS.ChFiDS_Regularities_IsEmpty(self, *args)

    def Prepend(self, *args):
        """
        :param I:
        :type I: ChFiDS_Regul &
        :rtype: None

        :param I:
        :type I: ChFiDS_Regul &
        :param theIt:
        :type theIt: ChFiDS_ListIteratorOfRegularities &
        :rtype: None

        :param Other:
        :type Other: ChFiDS_Regularities &
        :rtype: None

        """
        return _ChFiDS.ChFiDS_Regularities_Prepend(self, *args)

    def Append(self, *args):
        """
        :param I:
        :type I: ChFiDS_Regul &
        :rtype: None

        :param I:
        :type I: ChFiDS_Regul &
        :param theIt:
        :type theIt: ChFiDS_ListIteratorOfRegularities &
        :rtype: None

        :param Other:
        :type Other: ChFiDS_Regularities &
        :rtype: None

        """
        return _ChFiDS.ChFiDS_Regularities_Append(self, *args)

    def First(self, *args):
        """
        :rtype: ChFiDS_Regul

        """
        return _ChFiDS.ChFiDS_Regularities_First(self, *args)

    def Last(self, *args):
        """
        :rtype: ChFiDS_Regul

        """
        return _ChFiDS.ChFiDS_Regularities_Last(self, *args)

    def RemoveFirst(self, *args):
        """
        :rtype: None

        """
        return _ChFiDS.ChFiDS_Regularities_RemoveFirst(self, *args)

    def Remove(self, *args):
        """
        :param It:
        :type It: ChFiDS_ListIteratorOfRegularities &
        :rtype: None

        """
        return _ChFiDS.ChFiDS_Regularities_Remove(self, *args)

    def InsertBefore(self, *args):
        """
        :param I:
        :type I: ChFiDS_Regul &
        :param It:
        :type It: ChFiDS_ListIteratorOfRegularities &
        :rtype: None

        :param Other:
        :type Other: ChFiDS_Regularities &
        :param It:
        :type It: ChFiDS_ListIteratorOfRegularities &
        :rtype: None

        """
        return _ChFiDS.ChFiDS_Regularities_InsertBefore(self, *args)

    def InsertAfter(self, *args):
        """
        :param I:
        :type I: ChFiDS_Regul &
        :param It:
        :type It: ChFiDS_ListIteratorOfRegularities &
        :rtype: None

        :param Other:
        :type Other: ChFiDS_Regularities &
        :param It:
        :type It: ChFiDS_ListIteratorOfRegularities &
        :rtype: None

        """
        return _ChFiDS.ChFiDS_Regularities_InsertAfter(self, *args)

    __swig_destroy__ = _ChFiDS.delete_ChFiDS_Regularities
ChFiDS_Regularities.Assign = new_instancemethod(_ChFiDS.ChFiDS_Regularities_Assign,None,ChFiDS_Regularities)
ChFiDS_Regularities.Set = new_instancemethod(_ChFiDS.ChFiDS_Regularities_Set,None,ChFiDS_Regularities)
ChFiDS_Regularities.Extent = new_instancemethod(_ChFiDS.ChFiDS_Regularities_Extent,None,ChFiDS_Regularities)
ChFiDS_Regularities.Clear = new_instancemethod(_ChFiDS.ChFiDS_Regularities_Clear,None,ChFiDS_Regularities)
ChFiDS_Regularities.IsEmpty = new_instancemethod(_ChFiDS.ChFiDS_Regularities_IsEmpty,None,ChFiDS_Regularities)
ChFiDS_Regularities.Prepend = new_instancemethod(_ChFiDS.ChFiDS_Regularities_Prepend,None,ChFiDS_Regularities)
ChFiDS_Regularities.Append = new_instancemethod(_ChFiDS.ChFiDS_Regularities_Append,None,ChFiDS_Regularities)
ChFiDS_Regularities.First = new_instancemethod(_ChFiDS.ChFiDS_Regularities_First,None,ChFiDS_Regularities)
ChFiDS_Regularities.Last = new_instancemethod(_ChFiDS.ChFiDS_Regularities_Last,None,ChFiDS_Regularities)
ChFiDS_Regularities.RemoveFirst = new_instancemethod(_ChFiDS.ChFiDS_Regularities_RemoveFirst,None,ChFiDS_Regularities)
ChFiDS_Regularities.Remove = new_instancemethod(_ChFiDS.ChFiDS_Regularities_Remove,None,ChFiDS_Regularities)
ChFiDS_Regularities.InsertBefore = new_instancemethod(_ChFiDS.ChFiDS_Regularities_InsertBefore,None,ChFiDS_Regularities)
ChFiDS_Regularities.InsertAfter = new_instancemethod(_ChFiDS.ChFiDS_Regularities_InsertAfter,None,ChFiDS_Regularities)
ChFiDS_Regularities_swigregister = _ChFiDS.ChFiDS_Regularities_swigregister
ChFiDS_Regularities_swigregister(ChFiDS_Regularities)

class ChFiDS_SecArray1(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): 
        """
        :param Low:
        :type Low: int
        :param Up:
        :type Up: int
        :rtype: None

        :param Item:
        :type Item: ChFiDS_CircSection &
        :param Low:
        :type Low: int
        :param Up:
        :type Up: int
        :rtype: None

        """
        _ChFiDS.ChFiDS_SecArray1_swiginit(self,_ChFiDS.new_ChFiDS_SecArray1(*args))
    def Init(self, *args):
        """
        :param V:
        :type V: ChFiDS_CircSection &
        :rtype: None

        """
        return _ChFiDS.ChFiDS_SecArray1_Init(self, *args)

    def Destroy(self, *args):
        """
        :rtype: None

        """
        return _ChFiDS.ChFiDS_SecArray1_Destroy(self, *args)

    def IsAllocated(self, *args):
        """
        :rtype: bool

        """
        return _ChFiDS.ChFiDS_SecArray1_IsAllocated(self, *args)

    def Assign(self, *args):
        """
        :param Other:
        :type Other: ChFiDS_SecArray1 &
        :rtype: ChFiDS_SecArray1

        """
        return _ChFiDS.ChFiDS_SecArray1_Assign(self, *args)

    def Set(self, *args):
        """
        :param Other:
        :type Other: ChFiDS_SecArray1 &
        :rtype: ChFiDS_SecArray1

        """
        return _ChFiDS.ChFiDS_SecArray1_Set(self, *args)

    def Length(self, *args):
        """
        :rtype: int

        """
        return _ChFiDS.ChFiDS_SecArray1_Length(self, *args)

    def Lower(self, *args):
        """
        :rtype: int

        """
        return _ChFiDS.ChFiDS_SecArray1_Lower(self, *args)

    def Upper(self, *args):
        """
        :rtype: int

        """
        return _ChFiDS.ChFiDS_SecArray1_Upper(self, *args)

    def SetValue(self, *args):
        """
        :param Index:
        :type Index: int
        :param Value:
        :type Value: ChFiDS_CircSection &
        :rtype: None

        """
        return _ChFiDS.ChFiDS_SecArray1_SetValue(self, *args)

    def Value(self, *args):
        """
        :param Index:
        :type Index: int
        :rtype: ChFiDS_CircSection

        """
        return _ChFiDS.ChFiDS_SecArray1_Value(self, *args)

    def ChangeValue(self, *args):
        """
        :param Index:
        :type Index: int
        :rtype: ChFiDS_CircSection

        """
        return _ChFiDS.ChFiDS_SecArray1_ChangeValue(self, *args)

    __swig_destroy__ = _ChFiDS.delete_ChFiDS_SecArray1
ChFiDS_SecArray1.Init = new_instancemethod(_ChFiDS.ChFiDS_SecArray1_Init,None,ChFiDS_SecArray1)
ChFiDS_SecArray1.Destroy = new_instancemethod(_ChFiDS.ChFiDS_SecArray1_Destroy,None,ChFiDS_SecArray1)
ChFiDS_SecArray1.IsAllocated = new_instancemethod(_ChFiDS.ChFiDS_SecArray1_IsAllocated,None,ChFiDS_SecArray1)
ChFiDS_SecArray1.Assign = new_instancemethod(_ChFiDS.ChFiDS_SecArray1_Assign,None,ChFiDS_SecArray1)
ChFiDS_SecArray1.Set = new_instancemethod(_ChFiDS.ChFiDS_SecArray1_Set,None,ChFiDS_SecArray1)
ChFiDS_SecArray1.Length = new_instancemethod(_ChFiDS.ChFiDS_SecArray1_Length,None,ChFiDS_SecArray1)
ChFiDS_SecArray1.Lower = new_instancemethod(_ChFiDS.ChFiDS_SecArray1_Lower,None,ChFiDS_SecArray1)
ChFiDS_SecArray1.Upper = new_instancemethod(_ChFiDS.ChFiDS_SecArray1_Upper,None,ChFiDS_SecArray1)
ChFiDS_SecArray1.SetValue = new_instancemethod(_ChFiDS.ChFiDS_SecArray1_SetValue,None,ChFiDS_SecArray1)
ChFiDS_SecArray1.Value = new_instancemethod(_ChFiDS.ChFiDS_SecArray1_Value,None,ChFiDS_SecArray1)
ChFiDS_SecArray1.ChangeValue = new_instancemethod(_ChFiDS.ChFiDS_SecArray1_ChangeValue,None,ChFiDS_SecArray1)
ChFiDS_SecArray1_swigregister = _ChFiDS.ChFiDS_SecArray1_swigregister
ChFiDS_SecArray1_swigregister(ChFiDS_SecArray1)

class ChFiDS_SecHArray1(OCC.MMgt.MMgt_TShared):
    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): 
        """
        :param Low:
        :type Low: int
        :param Up:
        :type Up: int
        :rtype: None

        :param Low:
        :type Low: int
        :param Up:
        :type Up: int
        :param V:
        :type V: ChFiDS_CircSection &
        :rtype: None

        """
        _ChFiDS.ChFiDS_SecHArray1_swiginit(self,_ChFiDS.new_ChFiDS_SecHArray1(*args))
    def Init(self, *args):
        """
        :param V:
        :type V: ChFiDS_CircSection &
        :rtype: None

        """
        return _ChFiDS.ChFiDS_SecHArray1_Init(self, *args)

    def Length(self, *args):
        """
        :rtype: int

        """
        return _ChFiDS.ChFiDS_SecHArray1_Length(self, *args)

    def Lower(self, *args):
        """
        :rtype: int

        """
        return _ChFiDS.ChFiDS_SecHArray1_Lower(self, *args)

    def Upper(self, *args):
        """
        :rtype: int

        """
        return _ChFiDS.ChFiDS_SecHArray1_Upper(self, *args)

    def SetValue(self, *args):
        """
        :param Index:
        :type Index: int
        :param Value:
        :type Value: ChFiDS_CircSection &
        :rtype: None

        """
        return _ChFiDS.ChFiDS_SecHArray1_SetValue(self, *args)

    def Value(self, *args):
        """
        :param Index:
        :type Index: int
        :rtype: ChFiDS_CircSection

        """
        return _ChFiDS.ChFiDS_SecHArray1_Value(self, *args)

    def ChangeValue(self, *args):
        """
        :param Index:
        :type Index: int
        :rtype: ChFiDS_CircSection

        """
        return _ChFiDS.ChFiDS_SecHArray1_ChangeValue(self, *args)

    def Array1(self, *args):
        """
        :rtype: ChFiDS_SecArray1

        """
        return _ChFiDS.ChFiDS_SecHArray1_Array1(self, *args)

    def ChangeArray1(self, *args):
        """
        :rtype: ChFiDS_SecArray1

        """
        return _ChFiDS.ChFiDS_SecHArray1_ChangeArray1(self, *args)

    def GetHandle(self):
        try:
            return self.thisHandle
        except:
            self.thisHandle = Handle_ChFiDS_SecHArray1(self)
            self.thisown = False
            return self.thisHandle

    __swig_destroy__ = _ChFiDS.delete_ChFiDS_SecHArray1
ChFiDS_SecHArray1.Init = new_instancemethod(_ChFiDS.ChFiDS_SecHArray1_Init,None,ChFiDS_SecHArray1)
ChFiDS_SecHArray1.Length = new_instancemethod(_ChFiDS.ChFiDS_SecHArray1_Length,None,ChFiDS_SecHArray1)
ChFiDS_SecHArray1.Lower = new_instancemethod(_ChFiDS.ChFiDS_SecHArray1_Lower,None,ChFiDS_SecHArray1)
ChFiDS_SecHArray1.Upper = new_instancemethod(_ChFiDS.ChFiDS_SecHArray1_Upper,None,ChFiDS_SecHArray1)
ChFiDS_SecHArray1.SetValue = new_instancemethod(_ChFiDS.ChFiDS_SecHArray1_SetValue,None,ChFiDS_SecHArray1)
ChFiDS_SecHArray1.Value = new_instancemethod(_ChFiDS.ChFiDS_SecHArray1_Value,None,ChFiDS_SecHArray1)
ChFiDS_SecHArray1.ChangeValue = new_instancemethod(_ChFiDS.ChFiDS_SecHArray1_ChangeValue,None,ChFiDS_SecHArray1)
ChFiDS_SecHArray1.Array1 = new_instancemethod(_ChFiDS.ChFiDS_SecHArray1_Array1,None,ChFiDS_SecHArray1)
ChFiDS_SecHArray1.ChangeArray1 = new_instancemethod(_ChFiDS.ChFiDS_SecHArray1_ChangeArray1,None,ChFiDS_SecHArray1)
ChFiDS_SecHArray1_swigregister = _ChFiDS.ChFiDS_SecHArray1_swigregister
ChFiDS_SecHArray1_swigregister(ChFiDS_SecHArray1)

class Handle_ChFiDS_SecHArray1(OCC.MMgt.Handle_MMgt_TShared):
    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): 
        _ChFiDS.Handle_ChFiDS_SecHArray1_swiginit(self,_ChFiDS.new_Handle_ChFiDS_SecHArray1(*args))
        # register the handle in the base object
        if len(args) > 0:
            register_handle(self, args[0])



    DownCast = staticmethod(_ChFiDS.Handle_ChFiDS_SecHArray1_DownCast)
    __swig_destroy__ = _ChFiDS.delete_Handle_ChFiDS_SecHArray1
Handle_ChFiDS_SecHArray1.Nullify = new_instancemethod(_ChFiDS.Handle_ChFiDS_SecHArray1_Nullify,None,Handle_ChFiDS_SecHArray1)
Handle_ChFiDS_SecHArray1.IsNull = new_instancemethod(_ChFiDS.Handle_ChFiDS_SecHArray1_IsNull,None,Handle_ChFiDS_SecHArray1)
Handle_ChFiDS_SecHArray1.GetObject = new_instancemethod(_ChFiDS.Handle_ChFiDS_SecHArray1_GetObject,None,Handle_ChFiDS_SecHArray1)
Handle_ChFiDS_SecHArray1_swigregister = _ChFiDS.Handle_ChFiDS_SecHArray1_swigregister
Handle_ChFiDS_SecHArray1_swigregister(Handle_ChFiDS_SecHArray1)

def Handle_ChFiDS_SecHArray1_DownCast(*args):
  return _ChFiDS.Handle_ChFiDS_SecHArray1_DownCast(*args)
Handle_ChFiDS_SecHArray1_DownCast = _ChFiDS.Handle_ChFiDS_SecHArray1_DownCast

class ChFiDS_SequenceNodeOfSequenceOfSpine(OCC.TCollection.TCollection_SeqNode):
    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): 
        """
        :param I:
        :type I: Handle_ChFiDS_Spine &
        :param n:
        :type n: TCollection_SeqNodePtr &
        :param p:
        :type p: TCollection_SeqNodePtr &
        :rtype: None

        """
        _ChFiDS.ChFiDS_SequenceNodeOfSequenceOfSpine_swiginit(self,_ChFiDS.new_ChFiDS_SequenceNodeOfSequenceOfSpine(*args))
    def Value(self, *args):
        """
        :rtype: Handle_ChFiDS_Spine

        """
        return _ChFiDS.ChFiDS_SequenceNodeOfSequenceOfSpine_Value(self, *args)

    def GetHandle(self):
        try:
            return self.thisHandle
        except:
            self.thisHandle = Handle_ChFiDS_SequenceNodeOfSequenceOfSpine(self)
            self.thisown = False
            return self.thisHandle

    __swig_destroy__ = _ChFiDS.delete_ChFiDS_SequenceNodeOfSequenceOfSpine
ChFiDS_SequenceNodeOfSequenceOfSpine.Value = new_instancemethod(_ChFiDS.ChFiDS_SequenceNodeOfSequenceOfSpine_Value,None,ChFiDS_SequenceNodeOfSequenceOfSpine)
ChFiDS_SequenceNodeOfSequenceOfSpine_swigregister = _ChFiDS.ChFiDS_SequenceNodeOfSequenceOfSpine_swigregister
ChFiDS_SequenceNodeOfSequenceOfSpine_swigregister(ChFiDS_SequenceNodeOfSequenceOfSpine)

class Handle_ChFiDS_SequenceNodeOfSequenceOfSpine(OCC.TCollection.Handle_TCollection_SeqNode):
    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): 
        _ChFiDS.Handle_ChFiDS_SequenceNodeOfSequenceOfSpine_swiginit(self,_ChFiDS.new_Handle_ChFiDS_SequenceNodeOfSequenceOfSpine(*args))
        # register the handle in the base object
        if len(args) > 0:
            register_handle(self, args[0])



    DownCast = staticmethod(_ChFiDS.Handle_ChFiDS_SequenceNodeOfSequenceOfSpine_DownCast)
    __swig_destroy__ = _ChFiDS.delete_Handle_ChFiDS_SequenceNodeOfSequenceOfSpine
Handle_ChFiDS_SequenceNodeOfSequenceOfSpine.Nullify = new_instancemethod(_ChFiDS.Handle_ChFiDS_SequenceNodeOfSequenceOfSpine_Nullify,None,Handle_ChFiDS_SequenceNodeOfSequenceOfSpine)
Handle_ChFiDS_SequenceNodeOfSequenceOfSpine.IsNull = new_instancemethod(_ChFiDS.Handle_ChFiDS_SequenceNodeOfSequenceOfSpine_IsNull,None,Handle_ChFiDS_SequenceNodeOfSequenceOfSpine)
Handle_ChFiDS_SequenceNodeOfSequenceOfSpine.GetObject = new_instancemethod(_ChFiDS.Handle_ChFiDS_SequenceNodeOfSequenceOfSpine_GetObject,None,Handle_ChFiDS_SequenceNodeOfSequenceOfSpine)
Handle_ChFiDS_SequenceNodeOfSequenceOfSpine_swigregister = _ChFiDS.Handle_ChFiDS_SequenceNodeOfSequenceOfSpine_swigregister
Handle_ChFiDS_SequenceNodeOfSequenceOfSpine_swigregister(Handle_ChFiDS_SequenceNodeOfSequenceOfSpine)

def Handle_ChFiDS_SequenceNodeOfSequenceOfSpine_DownCast(*args):
  return _ChFiDS.Handle_ChFiDS_SequenceNodeOfSequenceOfSpine_DownCast(*args)
Handle_ChFiDS_SequenceNodeOfSequenceOfSpine_DownCast = _ChFiDS.Handle_ChFiDS_SequenceNodeOfSequenceOfSpine_DownCast

class ChFiDS_SequenceNodeOfSequenceOfSurfData(OCC.TCollection.TCollection_SeqNode):
    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): 
        """
        :param I:
        :type I: Handle_ChFiDS_SurfData &
        :param n:
        :type n: TCollection_SeqNodePtr &
        :param p:
        :type p: TCollection_SeqNodePtr &
        :rtype: None

        """
        _ChFiDS.ChFiDS_SequenceNodeOfSequenceOfSurfData_swiginit(self,_ChFiDS.new_ChFiDS_SequenceNodeOfSequenceOfSurfData(*args))
    def Value(self, *args):
        """
        :rtype: Handle_ChFiDS_SurfData

        """
        return _ChFiDS.ChFiDS_SequenceNodeOfSequenceOfSurfData_Value(self, *args)

    def GetHandle(self):
        try:
            return self.thisHandle
        except:
            self.thisHandle = Handle_ChFiDS_SequenceNodeOfSequenceOfSurfData(self)
            self.thisown = False
            return self.thisHandle

    __swig_destroy__ = _ChFiDS.delete_ChFiDS_SequenceNodeOfSequenceOfSurfData
ChFiDS_SequenceNodeOfSequenceOfSurfData.Value = new_instancemethod(_ChFiDS.ChFiDS_SequenceNodeOfSequenceOfSurfData_Value,None,ChFiDS_SequenceNodeOfSequenceOfSurfData)
ChFiDS_SequenceNodeOfSequenceOfSurfData_swigregister = _ChFiDS.ChFiDS_SequenceNodeOfSequenceOfSurfData_swigregister
ChFiDS_SequenceNodeOfSequenceOfSurfData_swigregister(ChFiDS_SequenceNodeOfSequenceOfSurfData)

class Handle_ChFiDS_SequenceNodeOfSequenceOfSurfData(OCC.TCollection.Handle_TCollection_SeqNode):
    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): 
        _ChFiDS.Handle_ChFiDS_SequenceNodeOfSequenceOfSurfData_swiginit(self,_ChFiDS.new_Handle_ChFiDS_SequenceNodeOfSequenceOfSurfData(*args))
        # register the handle in the base object
        if len(args) > 0:
            register_handle(self, args[0])



    DownCast = staticmethod(_ChFiDS.Handle_ChFiDS_SequenceNodeOfSequenceOfSurfData_DownCast)
    __swig_destroy__ = _ChFiDS.delete_Handle_ChFiDS_SequenceNodeOfSequenceOfSurfData
Handle_ChFiDS_SequenceNodeOfSequenceOfSurfData.Nullify = new_instancemethod(_ChFiDS.Handle_ChFiDS_SequenceNodeOfSequenceOfSurfData_Nullify,None,Handle_ChFiDS_SequenceNodeOfSequenceOfSurfData)
Handle_ChFiDS_SequenceNodeOfSequenceOfSurfData.IsNull = new_instancemethod(_ChFiDS.Handle_ChFiDS_SequenceNodeOfSequenceOfSurfData_IsNull,None,Handle_ChFiDS_SequenceNodeOfSequenceOfSurfData)
Handle_ChFiDS_SequenceNodeOfSequenceOfSurfData.GetObject = new_instancemethod(_ChFiDS.Handle_ChFiDS_SequenceNodeOfSequenceOfSurfData_GetObject,None,Handle_ChFiDS_SequenceNodeOfSequenceOfSurfData)
Handle_ChFiDS_SequenceNodeOfSequenceOfSurfData_swigregister = _ChFiDS.Handle_ChFiDS_SequenceNodeOfSequenceOfSurfData_swigregister
Handle_ChFiDS_SequenceNodeOfSequenceOfSurfData_swigregister(Handle_ChFiDS_SequenceNodeOfSequenceOfSurfData)

def Handle_ChFiDS_SequenceNodeOfSequenceOfSurfData_DownCast(*args):
  return _ChFiDS.Handle_ChFiDS_SequenceNodeOfSequenceOfSurfData_DownCast(*args)
Handle_ChFiDS_SequenceNodeOfSequenceOfSurfData_DownCast = _ChFiDS.Handle_ChFiDS_SequenceNodeOfSequenceOfSurfData_DownCast

class ChFiDS_SequenceOfSpine(OCC.TCollection.TCollection_BaseSequence):
    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

        """
        _ChFiDS.ChFiDS_SequenceOfSpine_swiginit(self,_ChFiDS.new_ChFiDS_SequenceOfSpine(*args))
    def Clear(self, *args):
        """
        :rtype: None

        """
        return _ChFiDS.ChFiDS_SequenceOfSpine_Clear(self, *args)

    def Assign(self, *args):
        """
        :param Other:
        :type Other: ChFiDS_SequenceOfSpine &
        :rtype: ChFiDS_SequenceOfSpine

        """
        return _ChFiDS.ChFiDS_SequenceOfSpine_Assign(self, *args)

    def Set(self, *args):
        """
        :param Other:
        :type Other: ChFiDS_SequenceOfSpine &
        :rtype: ChFiDS_SequenceOfSpine

        """
        return _ChFiDS.ChFiDS_SequenceOfSpine_Set(self, *args)

    def Append(self, *args):
        """
        :param T:
        :type T: Handle_ChFiDS_Spine &
        :rtype: None

        :param S:
        :type S: ChFiDS_SequenceOfSpine &
        :rtype: None

        """
        return _ChFiDS.ChFiDS_SequenceOfSpine_Append(self, *args)

    def Prepend(self, *args):
        """
        :param T:
        :type T: Handle_ChFiDS_Spine &
        :rtype: None

        :param S:
        :type S: ChFiDS_SequenceOfSpine &
        :rtype: None

        """
        return _ChFiDS.ChFiDS_SequenceOfSpine_Prepend(self, *args)

    def InsertBefore(self, *args):
        """
        :param Index:
        :type Index: int
        :param T:
        :type T: Handle_ChFiDS_Spine &
        :rtype: None

        :param Index:
        :type Index: int
        :param S:
        :type S: ChFiDS_SequenceOfSpine &
        :rtype: None

        """
        return _ChFiDS.ChFiDS_SequenceOfSpine_InsertBefore(self, *args)

    def InsertAfter(self, *args):
        """
        :param Index:
        :type Index: int
        :param T:
        :type T: Handle_ChFiDS_Spine &
        :rtype: None

        :param Index:
        :type Index: int
        :param S:
        :type S: ChFiDS_SequenceOfSpine &
        :rtype: None

        """
        return _ChFiDS.ChFiDS_SequenceOfSpine_InsertAfter(self, *args)

    def First(self, *args):
        """
        :rtype: Handle_ChFiDS_Spine

        """
        return _ChFiDS.ChFiDS_SequenceOfSpine_First(self, *args)

    def Last(self, *args):
        """
        :rtype: Handle_ChFiDS_Spine

        """
        return _ChFiDS.ChFiDS_SequenceOfSpine_Last(self, *args)

    def Split(self, *args):
        """
        :param Index:
        :type Index: int
        :param Sub:
        :type Sub: ChFiDS_SequenceOfSpine &
        :rtype: None

        """
        return _ChFiDS.ChFiDS_SequenceOfSpine_Split(self, *args)

    def Value(self, *args):
        """
        :param Index:
        :type Index: int
        :rtype: Handle_ChFiDS_Spine

        """
        return _ChFiDS.ChFiDS_SequenceOfSpine_Value(self, *args)

    def SetValue(self, *args):
        """
        :param Index:
        :type Index: int
        :param I:
        :type I: Handle_ChFiDS_Spine &
        :rtype: None

        """
        return _ChFiDS.ChFiDS_SequenceOfSpine_SetValue(self, *args)

    def ChangeValue(self, *args):
        """
        :param Index:
        :type Index: int
        :rtype: Handle_ChFiDS_Spine

        """
        return _ChFiDS.ChFiDS_SequenceOfSpine_ChangeValue(self, *args)

    def Remove(self, *args):
        """
        :param Index:
        :type Index: int
        :rtype: None

        :param FromIndex:
        :type FromIndex: int
        :param ToIndex:
        :type ToIndex: int
        :rtype: None

        """
        return _ChFiDS.ChFiDS_SequenceOfSpine_Remove(self, *args)

    __swig_destroy__ = _ChFiDS.delete_ChFiDS_SequenceOfSpine
ChFiDS_SequenceOfSpine.Clear = new_instancemethod(_ChFiDS.ChFiDS_SequenceOfSpine_Clear,None,ChFiDS_SequenceOfSpine)
ChFiDS_SequenceOfSpine.Assign = new_instancemethod(_ChFiDS.ChFiDS_SequenceOfSpine_Assign,None,ChFiDS_SequenceOfSpine)
ChFiDS_SequenceOfSpine.Set = new_instancemethod(_ChFiDS.ChFiDS_SequenceOfSpine_Set,None,ChFiDS_SequenceOfSpine)
ChFiDS_SequenceOfSpine.Append = new_instancemethod(_ChFiDS.ChFiDS_SequenceOfSpine_Append,None,ChFiDS_SequenceOfSpine)
ChFiDS_SequenceOfSpine.Prepend = new_instancemethod(_ChFiDS.ChFiDS_SequenceOfSpine_Prepend,None,ChFiDS_SequenceOfSpine)
ChFiDS_SequenceOfSpine.InsertBefore = new_instancemethod(_ChFiDS.ChFiDS_SequenceOfSpine_InsertBefore,None,ChFiDS_SequenceOfSpine)
ChFiDS_SequenceOfSpine.InsertAfter = new_instancemethod(_ChFiDS.ChFiDS_SequenceOfSpine_InsertAfter,None,ChFiDS_SequenceOfSpine)
ChFiDS_SequenceOfSpine.First = new_instancemethod(_ChFiDS.ChFiDS_SequenceOfSpine_First,None,ChFiDS_SequenceOfSpine)
ChFiDS_SequenceOfSpine.Last = new_instancemethod(_ChFiDS.ChFiDS_SequenceOfSpine_Last,None,ChFiDS_SequenceOfSpine)
ChFiDS_SequenceOfSpine.Split = new_instancemethod(_ChFiDS.ChFiDS_SequenceOfSpine_Split,None,ChFiDS_SequenceOfSpine)
ChFiDS_SequenceOfSpine.Value = new_instancemethod(_ChFiDS.ChFiDS_SequenceOfSpine_Value,None,ChFiDS_SequenceOfSpine)
ChFiDS_SequenceOfSpine.SetValue = new_instancemethod(_ChFiDS.ChFiDS_SequenceOfSpine_SetValue,None,ChFiDS_SequenceOfSpine)
ChFiDS_SequenceOfSpine.ChangeValue = new_instancemethod(_ChFiDS.ChFiDS_SequenceOfSpine_ChangeValue,None,ChFiDS_SequenceOfSpine)
ChFiDS_SequenceOfSpine.Remove = new_instancemethod(_ChFiDS.ChFiDS_SequenceOfSpine_Remove,None,ChFiDS_SequenceOfSpine)
ChFiDS_SequenceOfSpine_swigregister = _ChFiDS.ChFiDS_SequenceOfSpine_swigregister
ChFiDS_SequenceOfSpine_swigregister(ChFiDS_SequenceOfSpine)

class ChFiDS_SequenceOfSurfData(OCC.TCollection.TCollection_BaseSequence):
    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

        """
        _ChFiDS.ChFiDS_SequenceOfSurfData_swiginit(self,_ChFiDS.new_ChFiDS_SequenceOfSurfData(*args))
    def Clear(self, *args):
        """
        :rtype: None

        """
        return _ChFiDS.ChFiDS_SequenceOfSurfData_Clear(self, *args)

    def Assign(self, *args):
        """
        :param Other:
        :type Other: ChFiDS_SequenceOfSurfData &
        :rtype: ChFiDS_SequenceOfSurfData

        """
        return _ChFiDS.ChFiDS_SequenceOfSurfData_Assign(self, *args)

    def Set(self, *args):
        """
        :param Other:
        :type Other: ChFiDS_SequenceOfSurfData &
        :rtype: ChFiDS_SequenceOfSurfData

        """
        return _ChFiDS.ChFiDS_SequenceOfSurfData_Set(self, *args)

    def Append(self, *args):
        """
        :param T:
        :type T: Handle_ChFiDS_SurfData &
        :rtype: None

        :param S:
        :type S: ChFiDS_SequenceOfSurfData &
        :rtype: None

        """
        return _ChFiDS.ChFiDS_SequenceOfSurfData_Append(self, *args)

    def Prepend(self, *args):
        """
        :param T:
        :type T: Handle_ChFiDS_SurfData &
        :rtype: None

        :param S:
        :type S: ChFiDS_SequenceOfSurfData &
        :rtype: None

        """
        return _ChFiDS.ChFiDS_SequenceOfSurfData_Prepend(self, *args)

    def InsertBefore(self, *args):
        """
        :param Index:
        :type Index: int
        :param T:
        :type T: Handle_ChFiDS_SurfData &
        :rtype: None

        :param Index:
        :type Index: int
        :param S:
        :type S: ChFiDS_SequenceOfSurfData &
        :rtype: None

        """
        return _ChFiDS.ChFiDS_SequenceOfSurfData_InsertBefore(self, *args)

    def InsertAfter(self, *args):
        """
        :param Index:
        :type Index: int
        :param T:
        :type T: Handle_ChFiDS_SurfData &
        :rtype: None

        :param Index:
        :type Index: int
        :param S:
        :type S: ChFiDS_SequenceOfSurfData &
        :rtype: None

        """
        return _ChFiDS.ChFiDS_SequenceOfSurfData_InsertAfter(self, *args)

    def First(self, *args):
        """
        :rtype: Handle_ChFiDS_SurfData

        """
        return _ChFiDS.ChFiDS_SequenceOfSurfData_First(self, *args)

    def Last(self, *args):
        """
        :rtype: Handle_ChFiDS_SurfData

        """
        return _ChFiDS.ChFiDS_SequenceOfSurfData_Last(self, *args)

    def Split(self, *args):
        """
        :param Index:
        :type Index: int
        :param Sub:
        :type Sub: ChFiDS_SequenceOfSurfData &
        :rtype: None

        """
        return _ChFiDS.ChFiDS_SequenceOfSurfData_Split(self, *args)

    def Value(self, *args):
        """
        :param Index:
        :type Index: int
        :rtype: Handle_ChFiDS_SurfData

        """
        return _ChFiDS.ChFiDS_SequenceOfSurfData_Value(self, *args)

    def SetValue(self, *args):
        """
        :param Index:
        :type Index: int
        :param I:
        :type I: Handle_ChFiDS_SurfData &
        :rtype: None

        """
        return _ChFiDS.ChFiDS_SequenceOfSurfData_SetValue(self, *args)

    def ChangeValue(self, *args):
        """
        :param Index:
        :type Index: int
        :rtype: Handle_ChFiDS_SurfData

        """
        return _ChFiDS.ChFiDS_SequenceOfSurfData_ChangeValue(self, *args)

    def Remove(self, *args):
        """
        :param Index:
        :type Index: int
        :rtype: None

        :param FromIndex:
        :type FromIndex: int
        :param ToIndex:
        :type ToIndex: int
        :rtype: None

        """
        return _ChFiDS.ChFiDS_SequenceOfSurfData_Remove(self, *args)

    __swig_destroy__ = _ChFiDS.delete_ChFiDS_SequenceOfSurfData
ChFiDS_SequenceOfSurfData.Clear = new_instancemethod(_ChFiDS.ChFiDS_SequenceOfSurfData_Clear,None,ChFiDS_SequenceOfSurfData)
ChFiDS_SequenceOfSurfData.Assign = new_instancemethod(_ChFiDS.ChFiDS_SequenceOfSurfData_Assign,None,ChFiDS_SequenceOfSurfData)
ChFiDS_SequenceOfSurfData.Set = new_instancemethod(_ChFiDS.ChFiDS_SequenceOfSurfData_Set,None,ChFiDS_SequenceOfSurfData)
ChFiDS_SequenceOfSurfData.Append = new_instancemethod(_ChFiDS.ChFiDS_SequenceOfSurfData_Append,None,ChFiDS_SequenceOfSurfData)
ChFiDS_SequenceOfSurfData.Prepend = new_instancemethod(_ChFiDS.ChFiDS_SequenceOfSurfData_Prepend,None,ChFiDS_SequenceOfSurfData)
ChFiDS_SequenceOfSurfData.InsertBefore = new_instancemethod(_ChFiDS.ChFiDS_SequenceOfSurfData_InsertBefore,None,ChFiDS_SequenceOfSurfData)
ChFiDS_SequenceOfSurfData.InsertAfter = new_instancemethod(_ChFiDS.ChFiDS_SequenceOfSurfData_InsertAfter,None,ChFiDS_SequenceOfSurfData)
ChFiDS_SequenceOfSurfData.First = new_instancemethod(_ChFiDS.ChFiDS_SequenceOfSurfData_First,None,ChFiDS_SequenceOfSurfData)
ChFiDS_SequenceOfSurfData.Last = new_instancemethod(_ChFiDS.ChFiDS_SequenceOfSurfData_Last,None,ChFiDS_SequenceOfSurfData)
ChFiDS_SequenceOfSurfData.Split = new_instancemethod(_ChFiDS.ChFiDS_SequenceOfSurfData_Split,None,ChFiDS_SequenceOfSurfData)
ChFiDS_SequenceOfSurfData.Value = new_instancemethod(_ChFiDS.ChFiDS_SequenceOfSurfData_Value,None,ChFiDS_SequenceOfSurfData)
ChFiDS_SequenceOfSurfData.SetValue = new_instancemethod(_ChFiDS.ChFiDS_SequenceOfSurfData_SetValue,None,ChFiDS_SequenceOfSurfData)
ChFiDS_SequenceOfSurfData.ChangeValue = new_instancemethod(_ChFiDS.ChFiDS_SequenceOfSurfData_ChangeValue,None,ChFiDS_SequenceOfSurfData)
ChFiDS_SequenceOfSurfData.Remove = new_instancemethod(_ChFiDS.ChFiDS_SequenceOfSurfData_Remove,None,ChFiDS_SequenceOfSurfData)
ChFiDS_SequenceOfSurfData_swigregister = _ChFiDS.ChFiDS_SequenceOfSurfData_swigregister
ChFiDS_SequenceOfSurfData_swigregister(ChFiDS_SequenceOfSurfData)

class ChFiDS_Spine(OCC.MMgt.MMgt_TShared):
    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

        :param Tol:
        :type Tol: float
        :rtype: None

        """
        _ChFiDS.ChFiDS_Spine_swiginit(self,_ChFiDS.new_ChFiDS_Spine(*args))
    def SetEdges(self, *args):
        """
        * store edges composing the guideline

        :param E:
        :type E: TopoDS_Edge &
        :rtype: None

        """
        return _ChFiDS.ChFiDS_Spine_SetEdges(self, *args)

    def PutInFirst(self, *args):
        """
        * store the edge at the first position before all others

        :param E:
        :type E: TopoDS_Edge &
        :rtype: None

        """
        return _ChFiDS.ChFiDS_Spine_PutInFirst(self, *args)

    def NbEdges(self, *args):
        """
        :rtype: int

        """
        return _ChFiDS.ChFiDS_Spine_NbEdges(self, *args)

    def Edges(self, *args):
        """
        :param I:
        :type I: int
        :rtype: TopoDS_Edge

        """
        return _ChFiDS.ChFiDS_Spine_Edges(self, *args)

    def SetFirstStatus(self, *args):
        """
        * stores if the start of a set of edges starts on a section of free border or forms a closed contour

        :param S:
        :type S: ChFiDS_State
        :rtype: None

        """
        return _ChFiDS.ChFiDS_Spine_SetFirstStatus(self, *args)

    def SetLastStatus(self, *args):
        """
        * stores if the end of a set of edges starts on a section of free border or forms a closed contour

        :param S:
        :type S: ChFiDS_State
        :rtype: None

        """
        return _ChFiDS.ChFiDS_Spine_SetLastStatus(self, *args)

    def AppendElSpine(self, *args):
        """
        :param Els:
        :type Els: Handle_ChFiDS_HElSpine &
        :rtype: void

        """
        return _ChFiDS.ChFiDS_Spine_AppendElSpine(self, *args)

    def ElSpine(self, *args):
        """
        :param IE:
        :type IE: int
        :rtype: Handle_ChFiDS_HElSpine

        :param E:
        :type E: TopoDS_Edge &
        :rtype: Handle_ChFiDS_HElSpine

        :param W:
        :type W: float
        :rtype: Handle_ChFiDS_HElSpine

        """
        return _ChFiDS.ChFiDS_Spine_ElSpine(self, *args)

    def ChangeElSpines(self, *args):
        """
        :rtype: ChFiDS_ListOfHElSpine

        """
        return _ChFiDS.ChFiDS_Spine_ChangeElSpines(self, *args)

    def Reset(self, *args):
        """
        :param AllData: default value is Standard_False
        :type AllData: bool
        :rtype: void

        """
        return _ChFiDS.ChFiDS_Spine_Reset(self, *args)

    def SplitDone(self, *args):
        """
        :rtype: bool

        :param B:
        :type B: bool
        :rtype: None

        """
        return _ChFiDS.ChFiDS_Spine_SplitDone(self, *args)

    def Load(self, *args):
        """
        * prepare the guideline depending on the edges that are elementary arks (take parameters from a single curvilinear abscissa); to be able to call methods on the geometry (first,last,value,d1,d2) it is necessary to start with preparation otherwise an exception will be raised

        :rtype: None

        """
        return _ChFiDS.ChFiDS_Spine_Load(self, *args)

    def Resolution(self, *args):
        """
        :param R3d:
        :type R3d: float
        :rtype: float

        """
        return _ChFiDS.ChFiDS_Spine_Resolution(self, *args)

    def IsClosed(self, *args):
        """
        :rtype: bool

        """
        return _ChFiDS.ChFiDS_Spine_IsClosed(self, *args)

    def SetFirstParameter(self, *args):
        """
        :param Par:
        :type Par: float
        :rtype: None

        """
        return _ChFiDS.ChFiDS_Spine_SetFirstParameter(self, *args)

    def SetLastParameter(self, *args):
        """
        :param Par:
        :type Par: float
        :rtype: None

        """
        return _ChFiDS.ChFiDS_Spine_SetLastParameter(self, *args)

    def FirstParameter(self, *args):
        """
        :rtype: float

        * gives the total length of all arcs before the number IndexSp

        :param IndexSpine:
        :type IndexSpine: int
        :rtype: float

        """
        return _ChFiDS.ChFiDS_Spine_FirstParameter(self, *args)

    def LastParameter(self, *args):
        """
        :rtype: float

        * gives the total length till the ark with number IndexSpine (inclus)

        :param IndexSpine:
        :type IndexSpine: int
        :rtype: float

        """
        return _ChFiDS.ChFiDS_Spine_LastParameter(self, *args)

    def Length(self, *args):
        """
        * gives the length of ark with number IndexSp

        :param IndexSpine:
        :type IndexSpine: int
        :rtype: float

        """
        return _ChFiDS.ChFiDS_Spine_Length(self, *args)

    def IsPeriodic(self, *args):
        """
        :rtype: bool

        """
        return _ChFiDS.ChFiDS_Spine_IsPeriodic(self, *args)

    def Period(self, *args):
        """
        :rtype: float

        """
        return _ChFiDS.ChFiDS_Spine_Period(self, *args)

    def Parameter(self, *args):
        """
        :param AbsC:
        :type AbsC: float
        :param U:
        :type U: float &
        :param Oriented: default value is Standard_True
        :type Oriented: bool
        :rtype: None

        :param Index:
        :type Index: int
        :param AbsC:
        :type AbsC: float
        :param U:
        :type U: float &
        :param Oriented: default value is Standard_True
        :type Oriented: bool
        :rtype: None

        """
        return _ChFiDS.ChFiDS_Spine_Parameter(self, *args)

    def Value(self, *args):
        """
        :param AbsC:
        :type AbsC: float
        :rtype: gp_Pnt

        """
        return _ChFiDS.ChFiDS_Spine_Value(self, *args)

    def D0(self, *args):
        """
        :param AbsC:
        :type AbsC: float
        :param P:
        :type P: gp_Pnt
        :rtype: None

        """
        return _ChFiDS.ChFiDS_Spine_D0(self, *args)

    def D1(self, *args):
        """
        :param AbsC:
        :type AbsC: float
        :param P:
        :type P: gp_Pnt
        :param V1:
        :type V1: gp_Vec
        :rtype: None

        """
        return _ChFiDS.ChFiDS_Spine_D1(self, *args)

    def D2(self, *args):
        """
        :param AbsC:
        :type AbsC: float
        :param P:
        :type P: gp_Pnt
        :param V1:
        :type V1: gp_Vec
        :param V2:
        :type V2: gp_Vec
        :rtype: None

        """
        return _ChFiDS.ChFiDS_Spine_D2(self, *args)

    def SetCurrent(self, *args):
        """
        :param Index:
        :type Index: int
        :rtype: None

        """
        return _ChFiDS.ChFiDS_Spine_SetCurrent(self, *args)

    def CurrentElementarySpine(self, *args):
        """
        * sets the current curve and returns it

        :param Index:
        :type Index: int
        :rtype: BRepAdaptor_Curve

        """
        return _ChFiDS.ChFiDS_Spine_CurrentElementarySpine(self, *args)

    def CurrentIndexOfElementarySpine(self, *args):
        """
        :rtype: int

        """
        return _ChFiDS.ChFiDS_Spine_CurrentIndexOfElementarySpine(self, *args)

    def GetType(self, *args):
        """
        :rtype: GeomAbs_CurveType

        """
        return _ChFiDS.ChFiDS_Spine_GetType(self, *args)

    def Line(self, *args):
        """
        :rtype: gp_Lin

        """
        return _ChFiDS.ChFiDS_Spine_Line(self, *args)

    def Circle(self, *args):
        """
        :rtype: gp_Circ

        """
        return _ChFiDS.ChFiDS_Spine_Circle(self, *args)

    def FirstStatus(self, *args):
        """
        * returns if the set of edges starts on a free boundary or if the first vertex is a breakpoint or if the set is closed

        :rtype: ChFiDS_State

        """
        return _ChFiDS.ChFiDS_Spine_FirstStatus(self, *args)

    def LastStatus(self, *args):
        """
        * returns the state at the end of the set

        :rtype: ChFiDS_State

        """
        return _ChFiDS.ChFiDS_Spine_LastStatus(self, *args)

    def Status(self, *args):
        """
        :param IsFirst:
        :type IsFirst: bool
        :rtype: ChFiDS_State

        """
        return _ChFiDS.ChFiDS_Spine_Status(self, *args)

    def SetStatus(self, *args):
        """
        :param S:
        :type S: ChFiDS_State
        :param IsFirst:
        :type IsFirst: bool
        :rtype: None

        """
        return _ChFiDS.ChFiDS_Spine_SetStatus(self, *args)

    def IsTangencyExtremity(self, *args):
        """
        * returns if the set of edges starts (or end) on Tangency point.

        :param IsFirst:
        :type IsFirst: bool
        :rtype: bool

        """
        return _ChFiDS.ChFiDS_Spine_IsTangencyExtremity(self, *args)

    def SetTangencyExtremity(self, *args):
        """
        :param IsTangency:
        :type IsTangency: bool
        :param IsFirst:
        :type IsFirst: bool
        :rtype: None

        """
        return _ChFiDS.ChFiDS_Spine_SetTangencyExtremity(self, *args)

    def Absc(self, *args):
        """
        :param U:
        :type U: float
        :rtype: float

        :param U:
        :type U: float
        :param I:
        :type I: int
        :rtype: float

        :param V:
        :type V: TopoDS_Vertex &
        :rtype: float

        """
        return _ChFiDS.ChFiDS_Spine_Absc(self, *args)

    def FirstVertex(self, *args):
        """
        :rtype: TopoDS_Vertex

        """
        return _ChFiDS.ChFiDS_Spine_FirstVertex(self, *args)

    def LastVertex(self, *args):
        """
        :rtype: TopoDS_Vertex

        """
        return _ChFiDS.ChFiDS_Spine_LastVertex(self, *args)

    def SetFirstTgt(self, *args):
        """
        :param W:
        :type W: float
        :rtype: None

        """
        return _ChFiDS.ChFiDS_Spine_SetFirstTgt(self, *args)

    def SetLastTgt(self, *args):
        """
        :param W:
        :type W: float
        :rtype: None

        """
        return _ChFiDS.ChFiDS_Spine_SetLastTgt(self, *args)

    def HasFirstTgt(self, *args):
        """
        :rtype: bool

        """
        return _ChFiDS.ChFiDS_Spine_HasFirstTgt(self, *args)

    def HasLastTgt(self, *args):
        """
        :rtype: bool

        """
        return _ChFiDS.ChFiDS_Spine_HasLastTgt(self, *args)

    def SetReference(self, *args):
        """
        * set a parameter reference for the approx.

        :param W:
        :type W: float
        :rtype: None

        * set a parameter reference for the approx, at the middle of edge I.

        :param I:
        :type I: int
        :rtype: None

        """
        return _ChFiDS.ChFiDS_Spine_SetReference(self, *args)

    def Index(self, *args):
        """
        :param W:
        :type W: float
        :param Forward: default value is Standard_True
        :type Forward: bool
        :rtype: int

        :param E:
        :type E: TopoDS_Edge &
        :rtype: int

        """
        return _ChFiDS.ChFiDS_Spine_Index(self, *args)

    def UnsetReference(self, *args):
        """
        :rtype: None

        """
        return _ChFiDS.ChFiDS_Spine_UnsetReference(self, *args)

    def SetErrorStatus(self, *args):
        """
        :param state:
        :type state: ChFiDS_ErrorStatus
        :rtype: None

        """
        return _ChFiDS.ChFiDS_Spine_SetErrorStatus(self, *args)

    def ErrorStatus(self, *args):
        """
        :rtype: ChFiDS_ErrorStatus

        """
        return _ChFiDS.ChFiDS_Spine_ErrorStatus(self, *args)

    def GetHandle(self):
        try:
            return self.thisHandle
        except:
            self.thisHandle = Handle_ChFiDS_Spine(self)
            self.thisown = False
            return self.thisHandle

    __swig_destroy__ = _ChFiDS.delete_ChFiDS_Spine
ChFiDS_Spine.SetEdges = new_instancemethod(_ChFiDS.ChFiDS_Spine_SetEdges,None,ChFiDS_Spine)
ChFiDS_Spine.PutInFirst = new_instancemethod(_ChFiDS.ChFiDS_Spine_PutInFirst,None,ChFiDS_Spine)
ChFiDS_Spine.NbEdges = new_instancemethod(_ChFiDS.ChFiDS_Spine_NbEdges,None,ChFiDS_Spine)
ChFiDS_Spine.Edges = new_instancemethod(_ChFiDS.ChFiDS_Spine_Edges,None,ChFiDS_Spine)
ChFiDS_Spine.SetFirstStatus = new_instancemethod(_ChFiDS.ChFiDS_Spine_SetFirstStatus,None,ChFiDS_Spine)
ChFiDS_Spine.SetLastStatus = new_instancemethod(_ChFiDS.ChFiDS_Spine_SetLastStatus,None,ChFiDS_Spine)
ChFiDS_Spine.AppendElSpine = new_instancemethod(_ChFiDS.ChFiDS_Spine_AppendElSpine,None,ChFiDS_Spine)
ChFiDS_Spine.ElSpine = new_instancemethod(_ChFiDS.ChFiDS_Spine_ElSpine,None,ChFiDS_Spine)
ChFiDS_Spine.ChangeElSpines = new_instancemethod(_ChFiDS.ChFiDS_Spine_ChangeElSpines,None,ChFiDS_Spine)
ChFiDS_Spine.Reset = new_instancemethod(_ChFiDS.ChFiDS_Spine_Reset,None,ChFiDS_Spine)
ChFiDS_Spine.SplitDone = new_instancemethod(_ChFiDS.ChFiDS_Spine_SplitDone,None,ChFiDS_Spine)
ChFiDS_Spine.Load = new_instancemethod(_ChFiDS.ChFiDS_Spine_Load,None,ChFiDS_Spine)
ChFiDS_Spine.Resolution = new_instancemethod(_ChFiDS.ChFiDS_Spine_Resolution,None,ChFiDS_Spine)
ChFiDS_Spine.IsClosed = new_instancemethod(_ChFiDS.ChFiDS_Spine_IsClosed,None,ChFiDS_Spine)
ChFiDS_Spine.SetFirstParameter = new_instancemethod(_ChFiDS.ChFiDS_Spine_SetFirstParameter,None,ChFiDS_Spine)
ChFiDS_Spine.SetLastParameter = new_instancemethod(_ChFiDS.ChFiDS_Spine_SetLastParameter,None,ChFiDS_Spine)
ChFiDS_Spine.FirstParameter = new_instancemethod(_ChFiDS.ChFiDS_Spine_FirstParameter,None,ChFiDS_Spine)
ChFiDS_Spine.LastParameter = new_instancemethod(_ChFiDS.ChFiDS_Spine_LastParameter,None,ChFiDS_Spine)
ChFiDS_Spine.Length = new_instancemethod(_ChFiDS.ChFiDS_Spine_Length,None,ChFiDS_Spine)
ChFiDS_Spine.IsPeriodic = new_instancemethod(_ChFiDS.ChFiDS_Spine_IsPeriodic,None,ChFiDS_Spine)
ChFiDS_Spine.Period = new_instancemethod(_ChFiDS.ChFiDS_Spine_Period,None,ChFiDS_Spine)
ChFiDS_Spine.Parameter = new_instancemethod(_ChFiDS.ChFiDS_Spine_Parameter,None,ChFiDS_Spine)
ChFiDS_Spine.Value = new_instancemethod(_ChFiDS.ChFiDS_Spine_Value,None,ChFiDS_Spine)
ChFiDS_Spine.D0 = new_instancemethod(_ChFiDS.ChFiDS_Spine_D0,None,ChFiDS_Spine)
ChFiDS_Spine.D1 = new_instancemethod(_ChFiDS.ChFiDS_Spine_D1,None,ChFiDS_Spine)
ChFiDS_Spine.D2 = new_instancemethod(_ChFiDS.ChFiDS_Spine_D2,None,ChFiDS_Spine)
ChFiDS_Spine.SetCurrent = new_instancemethod(_ChFiDS.ChFiDS_Spine_SetCurrent,None,ChFiDS_Spine)
ChFiDS_Spine.CurrentElementarySpine = new_instancemethod(_ChFiDS.ChFiDS_Spine_CurrentElementarySpine,None,ChFiDS_Spine)
ChFiDS_Spine.CurrentIndexOfElementarySpine = new_instancemethod(_ChFiDS.ChFiDS_Spine_CurrentIndexOfElementarySpine,None,ChFiDS_Spine)
ChFiDS_Spine.GetType = new_instancemethod(_ChFiDS.ChFiDS_Spine_GetType,None,ChFiDS_Spine)
ChFiDS_Spine.Line = new_instancemethod(_ChFiDS.ChFiDS_Spine_Line,None,ChFiDS_Spine)
ChFiDS_Spine.Circle = new_instancemethod(_ChFiDS.ChFiDS_Spine_Circle,None,ChFiDS_Spine)
ChFiDS_Spine.FirstStatus = new_instancemethod(_ChFiDS.ChFiDS_Spine_FirstStatus,None,ChFiDS_Spine)
ChFiDS_Spine.LastStatus = new_instancemethod(_ChFiDS.ChFiDS_Spine_LastStatus,None,ChFiDS_Spine)
ChFiDS_Spine.Status = new_instancemethod(_ChFiDS.ChFiDS_Spine_Status,None,ChFiDS_Spine)
ChFiDS_Spine.SetStatus = new_instancemethod(_ChFiDS.ChFiDS_Spine_SetStatus,None,ChFiDS_Spine)
ChFiDS_Spine.IsTangencyExtremity = new_instancemethod(_ChFiDS.ChFiDS_Spine_IsTangencyExtremity,None,ChFiDS_Spine)
ChFiDS_Spine.SetTangencyExtremity = new_instancemethod(_ChFiDS.ChFiDS_Spine_SetTangencyExtremity,None,ChFiDS_Spine)
ChFiDS_Spine.Absc = new_instancemethod(_ChFiDS.ChFiDS_Spine_Absc,None,ChFiDS_Spine)
ChFiDS_Spine.FirstVertex = new_instancemethod(_ChFiDS.ChFiDS_Spine_FirstVertex,None,ChFiDS_Spine)
ChFiDS_Spine.LastVertex = new_instancemethod(_ChFiDS.ChFiDS_Spine_LastVertex,None,ChFiDS_Spine)
ChFiDS_Spine.SetFirstTgt = new_instancemethod(_ChFiDS.ChFiDS_Spine_SetFirstTgt,None,ChFiDS_Spine)
ChFiDS_Spine.SetLastTgt = new_instancemethod(_ChFiDS.ChFiDS_Spine_SetLastTgt,None,ChFiDS_Spine)
ChFiDS_Spine.HasFirstTgt = new_instancemethod(_ChFiDS.ChFiDS_Spine_HasFirstTgt,None,ChFiDS_Spine)
ChFiDS_Spine.HasLastTgt = new_instancemethod(_ChFiDS.ChFiDS_Spine_HasLastTgt,None,ChFiDS_Spine)
ChFiDS_Spine.SetReference = new_instancemethod(_ChFiDS.ChFiDS_Spine_SetReference,None,ChFiDS_Spine)
ChFiDS_Spine.Index = new_instancemethod(_ChFiDS.ChFiDS_Spine_Index,None,ChFiDS_Spine)
ChFiDS_Spine.UnsetReference = new_instancemethod(_ChFiDS.ChFiDS_Spine_UnsetReference,None,ChFiDS_Spine)
ChFiDS_Spine.SetErrorStatus = new_instancemethod(_ChFiDS.ChFiDS_Spine_SetErrorStatus,None,ChFiDS_Spine)
ChFiDS_Spine.ErrorStatus = new_instancemethod(_ChFiDS.ChFiDS_Spine_ErrorStatus,None,ChFiDS_Spine)
ChFiDS_Spine_swigregister = _ChFiDS.ChFiDS_Spine_swigregister
ChFiDS_Spine_swigregister(ChFiDS_Spine)

class Handle_ChFiDS_Spine(OCC.MMgt.Handle_MMgt_TShared):
    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): 
        _ChFiDS.Handle_ChFiDS_Spine_swiginit(self,_ChFiDS.new_Handle_ChFiDS_Spine(*args))
        # register the handle in the base object
        if len(args) > 0:
            register_handle(self, args[0])



    DownCast = staticmethod(_ChFiDS.Handle_ChFiDS_Spine_DownCast)
    __swig_destroy__ = _ChFiDS.delete_Handle_ChFiDS_Spine
Handle_ChFiDS_Spine.Nullify = new_instancemethod(_ChFiDS.Handle_ChFiDS_Spine_Nullify,None,Handle_ChFiDS_Spine)
Handle_ChFiDS_Spine.IsNull = new_instancemethod(_ChFiDS.Handle_ChFiDS_Spine_IsNull,None,Handle_ChFiDS_Spine)
Handle_ChFiDS_Spine.GetObject = new_instancemethod(_ChFiDS.Handle_ChFiDS_Spine_GetObject,None,Handle_ChFiDS_Spine)
Handle_ChFiDS_Spine_swigregister = _ChFiDS.Handle_ChFiDS_Spine_swigregister
Handle_ChFiDS_Spine_swigregister(Handle_ChFiDS_Spine)

def Handle_ChFiDS_Spine_DownCast(*args):
  return _ChFiDS.Handle_ChFiDS_Spine_DownCast(*args)
Handle_ChFiDS_Spine_DownCast = _ChFiDS.Handle_ChFiDS_Spine_DownCast

class ChFiDS_Stripe(OCC.MMgt.MMgt_TShared):
    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

        """
        _ChFiDS.ChFiDS_Stripe_swiginit(self,_ChFiDS.new_ChFiDS_Stripe(*args))
    def Reset(self, *args):
        """
        * Reset everything except Spine.

        :rtype: None

        """
        return _ChFiDS.ChFiDS_Stripe_Reset(self, *args)

    def SetOfSurfData(self, *args):
        """
        :rtype: Handle_ChFiDS_HData

        """
        return _ChFiDS.ChFiDS_Stripe_SetOfSurfData(self, *args)

    def Spine(self, *args):
        """
        :rtype: Handle_ChFiDS_Spine

        """
        return _ChFiDS.ChFiDS_Stripe_Spine(self, *args)

    def ChangeSetOfSurfData(self, *args):
        """
        :rtype: Handle_ChFiDS_HData

        """
        return _ChFiDS.ChFiDS_Stripe_ChangeSetOfSurfData(self, *args)

    def ChangeSpine(self, *args):
        """
        :rtype: Handle_ChFiDS_Spine

        """
        return _ChFiDS.ChFiDS_Stripe_ChangeSpine(self, *args)

    def OrientationOnFace1(self, *args):
        """
        :rtype: TopAbs_Orientation

        :param Or1:
        :type Or1: TopAbs_Orientation
        :rtype: None

        """
        return _ChFiDS.ChFiDS_Stripe_OrientationOnFace1(self, *args)

    def OrientationOnFace2(self, *args):
        """
        :rtype: TopAbs_Orientation

        :param Or2:
        :type Or2: TopAbs_Orientation
        :rtype: None

        """
        return _ChFiDS.ChFiDS_Stripe_OrientationOnFace2(self, *args)

    def Choix(self, *args):
        """
        :rtype: int

        :param C:
        :type C: int
        :rtype: None

        """
        return _ChFiDS.ChFiDS_Stripe_Choix(self, *args)

    def FirstParameters(self, *args):
        """
        :param Pdeb:
        :type Pdeb: float &
        :param Pfin:
        :type Pfin: float &
        :rtype: None

        """
        return _ChFiDS.ChFiDS_Stripe_FirstParameters(self, *args)

    def LastParameters(self, *args):
        """
        :param Pdeb:
        :type Pdeb: float &
        :param Pfin:
        :type Pfin: float &
        :rtype: None

        """
        return _ChFiDS.ChFiDS_Stripe_LastParameters(self, *args)

    def ChangeFirstParameters(self, *args):
        """
        :param Pdeb:
        :type Pdeb: float
        :param Pfin:
        :type Pfin: float
        :rtype: None

        """
        return _ChFiDS.ChFiDS_Stripe_ChangeFirstParameters(self, *args)

    def ChangeLastParameters(self, *args):
        """
        :param Pdeb:
        :type Pdeb: float
        :param Pfin:
        :type Pfin: float
        :rtype: None

        """
        return _ChFiDS.ChFiDS_Stripe_ChangeLastParameters(self, *args)

    def FirstCurve(self, *args):
        """
        :rtype: int

        """
        return _ChFiDS.ChFiDS_Stripe_FirstCurve(self, *args)

    def LastCurve(self, *args):
        """
        :rtype: int

        """
        return _ChFiDS.ChFiDS_Stripe_LastCurve(self, *args)

    def ChangeFirstCurve(self, *args):
        """
        :param Index:
        :type Index: int
        :rtype: None

        """
        return _ChFiDS.ChFiDS_Stripe_ChangeFirstCurve(self, *args)

    def ChangeLastCurve(self, *args):
        """
        :param Index:
        :type Index: int
        :rtype: None

        """
        return _ChFiDS.ChFiDS_Stripe_ChangeLastCurve(self, *args)

    def FirstPCurve(self, *args):
        """
        :rtype: Handle_Geom2d_Curve

        """
        return _ChFiDS.ChFiDS_Stripe_FirstPCurve(self, *args)

    def LastPCurve(self, *args):
        """
        :rtype: Handle_Geom2d_Curve

        """
        return _ChFiDS.ChFiDS_Stripe_LastPCurve(self, *args)

    def ChangeFirstPCurve(self, *args):
        """
        :rtype: Handle_Geom2d_Curve

        """
        return _ChFiDS.ChFiDS_Stripe_ChangeFirstPCurve(self, *args)

    def ChangeLastPCurve(self, *args):
        """
        :rtype: Handle_Geom2d_Curve

        """
        return _ChFiDS.ChFiDS_Stripe_ChangeLastPCurve(self, *args)

    def FirstPCurveOrientation(self, *args):
        """
        :rtype: TopAbs_Orientation

        :param O:
        :type O: TopAbs_Orientation
        :rtype: None

        """
        return _ChFiDS.ChFiDS_Stripe_FirstPCurveOrientation(self, *args)

    def LastPCurveOrientation(self, *args):
        """
        :rtype: TopAbs_Orientation

        :param O:
        :type O: TopAbs_Orientation
        :rtype: None

        """
        return _ChFiDS.ChFiDS_Stripe_LastPCurveOrientation(self, *args)

    def IndexFirstPointOnS1(self, *args):
        """
        :rtype: int

        """
        return _ChFiDS.ChFiDS_Stripe_IndexFirstPointOnS1(self, *args)

    def IndexFirstPointOnS2(self, *args):
        """
        :rtype: int

        """
        return _ChFiDS.ChFiDS_Stripe_IndexFirstPointOnS2(self, *args)

    def IndexLastPointOnS1(self, *args):
        """
        :rtype: int

        """
        return _ChFiDS.ChFiDS_Stripe_IndexLastPointOnS1(self, *args)

    def IndexLastPointOnS2(self, *args):
        """
        :rtype: int

        """
        return _ChFiDS.ChFiDS_Stripe_IndexLastPointOnS2(self, *args)

    def ChangeIndexFirstPointOnS1(self, *args):
        """
        :param Index:
        :type Index: int
        :rtype: None

        """
        return _ChFiDS.ChFiDS_Stripe_ChangeIndexFirstPointOnS1(self, *args)

    def ChangeIndexFirstPointOnS2(self, *args):
        """
        :param Index:
        :type Index: int
        :rtype: None

        """
        return _ChFiDS.ChFiDS_Stripe_ChangeIndexFirstPointOnS2(self, *args)

    def ChangeIndexLastPointOnS1(self, *args):
        """
        :param Index:
        :type Index: int
        :rtype: None

        """
        return _ChFiDS.ChFiDS_Stripe_ChangeIndexLastPointOnS1(self, *args)

    def ChangeIndexLastPointOnS2(self, *args):
        """
        :param Index:
        :type Index: int
        :rtype: None

        """
        return _ChFiDS.ChFiDS_Stripe_ChangeIndexLastPointOnS2(self, *args)

    def Parameters(self, *args):
        """
        :param First:
        :type First: bool
        :param Pdeb:
        :type Pdeb: float &
        :param Pfin:
        :type Pfin: float &
        :rtype: None

        """
        return _ChFiDS.ChFiDS_Stripe_Parameters(self, *args)

    def SetParameters(self, *args):
        """
        :param First:
        :type First: bool
        :param Pdeb:
        :type Pdeb: float
        :param Pfin:
        :type Pfin: float
        :rtype: None

        """
        return _ChFiDS.ChFiDS_Stripe_SetParameters(self, *args)

    def Curve(self, *args):
        """
        :param First:
        :type First: bool
        :rtype: int

        """
        return _ChFiDS.ChFiDS_Stripe_Curve(self, *args)

    def SetCurve(self, *args):
        """
        :param Index:
        :type Index: int
        :param First:
        :type First: bool
        :rtype: None

        """
        return _ChFiDS.ChFiDS_Stripe_SetCurve(self, *args)

    def PCurve(self, *args):
        """
        :param First:
        :type First: bool
        :rtype: Handle_Geom2d_Curve

        """
        return _ChFiDS.ChFiDS_Stripe_PCurve(self, *args)

    def ChangePCurve(self, *args):
        """
        :param First:
        :type First: bool
        :rtype: Handle_Geom2d_Curve

        """
        return _ChFiDS.ChFiDS_Stripe_ChangePCurve(self, *args)

    def Orientation(self, *args):
        """
        :param OnS:
        :type OnS: int
        :rtype: TopAbs_Orientation

        :param First:
        :type First: bool
        :rtype: TopAbs_Orientation

        """
        return _ChFiDS.ChFiDS_Stripe_Orientation(self, *args)

    def SetOrientation(self, *args):
        """
        :param Or:
        :type Or: TopAbs_Orientation
        :param OnS:
        :type OnS: int
        :rtype: None

        :param Or:
        :type Or: TopAbs_Orientation
        :param First:
        :type First: bool
        :rtype: None

        """
        return _ChFiDS.ChFiDS_Stripe_SetOrientation(self, *args)

    def IndexPoint(self, *args):
        """
        :param First:
        :type First: bool
        :param OnS:
        :type OnS: int
        :rtype: int

        """
        return _ChFiDS.ChFiDS_Stripe_IndexPoint(self, *args)

    def SetIndexPoint(self, *args):
        """
        :param Index:
        :type Index: int
        :param First:
        :type First: bool
        :param OnS:
        :type OnS: int
        :rtype: None

        """
        return _ChFiDS.ChFiDS_Stripe_SetIndexPoint(self, *args)

    def SolidIndex(self, *args):
        """
        :rtype: int

        """
        return _ChFiDS.ChFiDS_Stripe_SolidIndex(self, *args)

    def SetSolidIndex(self, *args):
        """
        :param Index:
        :type Index: int
        :rtype: None

        """
        return _ChFiDS.ChFiDS_Stripe_SetSolidIndex(self, *args)

    def InDS(self, *args):
        """
        * Set nb of SurfData's at end put in DS

        :param First:
        :type First: bool
        :param Nb: default value is 1
        :type Nb: int
        :rtype: None

        """
        return _ChFiDS.ChFiDS_Stripe_InDS(self, *args)

    def IsInDS(self, *args):
        """
        * Returns nb of SurfData's at end being in DS

        :param First:
        :type First: bool
        :rtype: int

        """
        return _ChFiDS.ChFiDS_Stripe_IsInDS(self, *args)

    def GetHandle(self):
        try:
            return self.thisHandle
        except:
            self.thisHandle = Handle_ChFiDS_Stripe(self)
            self.thisown = False
            return self.thisHandle

    __swig_destroy__ = _ChFiDS.delete_ChFiDS_Stripe
ChFiDS_Stripe.Reset = new_instancemethod(_ChFiDS.ChFiDS_Stripe_Reset,None,ChFiDS_Stripe)
ChFiDS_Stripe.SetOfSurfData = new_instancemethod(_ChFiDS.ChFiDS_Stripe_SetOfSurfData,None,ChFiDS_Stripe)
ChFiDS_Stripe.Spine = new_instancemethod(_ChFiDS.ChFiDS_Stripe_Spine,None,ChFiDS_Stripe)
ChFiDS_Stripe.ChangeSetOfSurfData = new_instancemethod(_ChFiDS.ChFiDS_Stripe_ChangeSetOfSurfData,None,ChFiDS_Stripe)
ChFiDS_Stripe.ChangeSpine = new_instancemethod(_ChFiDS.ChFiDS_Stripe_ChangeSpine,None,ChFiDS_Stripe)
ChFiDS_Stripe.OrientationOnFace1 = new_instancemethod(_ChFiDS.ChFiDS_Stripe_OrientationOnFace1,None,ChFiDS_Stripe)
ChFiDS_Stripe.OrientationOnFace2 = new_instancemethod(_ChFiDS.ChFiDS_Stripe_OrientationOnFace2,None,ChFiDS_Stripe)
ChFiDS_Stripe.Choix = new_instancemethod(_ChFiDS.ChFiDS_Stripe_Choix,None,ChFiDS_Stripe)
ChFiDS_Stripe.FirstParameters = new_instancemethod(_ChFiDS.ChFiDS_Stripe_FirstParameters,None,ChFiDS_Stripe)
ChFiDS_Stripe.LastParameters = new_instancemethod(_ChFiDS.ChFiDS_Stripe_LastParameters,None,ChFiDS_Stripe)
ChFiDS_Stripe.ChangeFirstParameters = new_instancemethod(_ChFiDS.ChFiDS_Stripe_ChangeFirstParameters,None,ChFiDS_Stripe)
ChFiDS_Stripe.ChangeLastParameters = new_instancemethod(_ChFiDS.ChFiDS_Stripe_ChangeLastParameters,None,ChFiDS_Stripe)
ChFiDS_Stripe.FirstCurve = new_instancemethod(_ChFiDS.ChFiDS_Stripe_FirstCurve,None,ChFiDS_Stripe)
ChFiDS_Stripe.LastCurve = new_instancemethod(_ChFiDS.ChFiDS_Stripe_LastCurve,None,ChFiDS_Stripe)
ChFiDS_Stripe.ChangeFirstCurve = new_instancemethod(_ChFiDS.ChFiDS_Stripe_ChangeFirstCurve,None,ChFiDS_Stripe)
ChFiDS_Stripe.ChangeLastCurve = new_instancemethod(_ChFiDS.ChFiDS_Stripe_ChangeLastCurve,None,ChFiDS_Stripe)
ChFiDS_Stripe.FirstPCurve = new_instancemethod(_ChFiDS.ChFiDS_Stripe_FirstPCurve,None,ChFiDS_Stripe)
ChFiDS_Stripe.LastPCurve = new_instancemethod(_ChFiDS.ChFiDS_Stripe_LastPCurve,None,ChFiDS_Stripe)
ChFiDS_Stripe.ChangeFirstPCurve = new_instancemethod(_ChFiDS.ChFiDS_Stripe_ChangeFirstPCurve,None,ChFiDS_Stripe)
ChFiDS_Stripe.ChangeLastPCurve = new_instancemethod(_ChFiDS.ChFiDS_Stripe_ChangeLastPCurve,None,ChFiDS_Stripe)
ChFiDS_Stripe.FirstPCurveOrientation = new_instancemethod(_ChFiDS.ChFiDS_Stripe_FirstPCurveOrientation,None,ChFiDS_Stripe)
ChFiDS_Stripe.LastPCurveOrientation = new_instancemethod(_ChFiDS.ChFiDS_Stripe_LastPCurveOrientation,None,ChFiDS_Stripe)
ChFiDS_Stripe.IndexFirstPointOnS1 = new_instancemethod(_ChFiDS.ChFiDS_Stripe_IndexFirstPointOnS1,None,ChFiDS_Stripe)
ChFiDS_Stripe.IndexFirstPointOnS2 = new_instancemethod(_ChFiDS.ChFiDS_Stripe_IndexFirstPointOnS2,None,ChFiDS_Stripe)
ChFiDS_Stripe.IndexLastPointOnS1 = new_instancemethod(_ChFiDS.ChFiDS_Stripe_IndexLastPointOnS1,None,ChFiDS_Stripe)
ChFiDS_Stripe.IndexLastPointOnS2 = new_instancemethod(_ChFiDS.ChFiDS_Stripe_IndexLastPointOnS2,None,ChFiDS_Stripe)
ChFiDS_Stripe.ChangeIndexFirstPointOnS1 = new_instancemethod(_ChFiDS.ChFiDS_Stripe_ChangeIndexFirstPointOnS1,None,ChFiDS_Stripe)
ChFiDS_Stripe.ChangeIndexFirstPointOnS2 = new_instancemethod(_ChFiDS.ChFiDS_Stripe_ChangeIndexFirstPointOnS2,None,ChFiDS_Stripe)
ChFiDS_Stripe.ChangeIndexLastPointOnS1 = new_instancemethod(_ChFiDS.ChFiDS_Stripe_ChangeIndexLastPointOnS1,None,ChFiDS_Stripe)
ChFiDS_Stripe.ChangeIndexLastPointOnS2 = new_instancemethod(_ChFiDS.ChFiDS_Stripe_ChangeIndexLastPointOnS2,None,ChFiDS_Stripe)
ChFiDS_Stripe.Parameters = new_instancemethod(_ChFiDS.ChFiDS_Stripe_Parameters,None,ChFiDS_Stripe)
ChFiDS_Stripe.SetParameters = new_instancemethod(_ChFiDS.ChFiDS_Stripe_SetParameters,None,ChFiDS_Stripe)
ChFiDS_Stripe.Curve = new_instancemethod(_ChFiDS.ChFiDS_Stripe_Curve,None,ChFiDS_Stripe)
ChFiDS_Stripe.SetCurve = new_instancemethod(_ChFiDS.ChFiDS_Stripe_SetCurve,None,ChFiDS_Stripe)
ChFiDS_Stripe.PCurve = new_instancemethod(_ChFiDS.ChFiDS_Stripe_PCurve,None,ChFiDS_Stripe)
ChFiDS_Stripe.ChangePCurve = new_instancemethod(_ChFiDS.ChFiDS_Stripe_ChangePCurve,None,ChFiDS_Stripe)
ChFiDS_Stripe.Orientation = new_instancemethod(_ChFiDS.ChFiDS_Stripe_Orientation,None,ChFiDS_Stripe)
ChFiDS_Stripe.SetOrientation = new_instancemethod(_ChFiDS.ChFiDS_Stripe_SetOrientation,None,ChFiDS_Stripe)
ChFiDS_Stripe.IndexPoint = new_instancemethod(_ChFiDS.ChFiDS_Stripe_IndexPoint,None,ChFiDS_Stripe)
ChFiDS_Stripe.SetIndexPoint = new_instancemethod(_ChFiDS.ChFiDS_Stripe_SetIndexPoint,None,ChFiDS_Stripe)
ChFiDS_Stripe.SolidIndex = new_instancemethod(_ChFiDS.ChFiDS_Stripe_SolidIndex,None,ChFiDS_Stripe)
ChFiDS_Stripe.SetSolidIndex = new_instancemethod(_ChFiDS.ChFiDS_Stripe_SetSolidIndex,None,ChFiDS_Stripe)
ChFiDS_Stripe.InDS = new_instancemethod(_ChFiDS.ChFiDS_Stripe_InDS,None,ChFiDS_Stripe)
ChFiDS_Stripe.IsInDS = new_instancemethod(_ChFiDS.ChFiDS_Stripe_IsInDS,None,ChFiDS_Stripe)
ChFiDS_Stripe_swigregister = _ChFiDS.ChFiDS_Stripe_swigregister
ChFiDS_Stripe_swigregister(ChFiDS_Stripe)

class Handle_ChFiDS_Stripe(OCC.MMgt.Handle_MMgt_TShared):
    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): 
        _ChFiDS.Handle_ChFiDS_Stripe_swiginit(self,_ChFiDS.new_Handle_ChFiDS_Stripe(*args))
        # register the handle in the base object
        if len(args) > 0:
            register_handle(self, args[0])



    DownCast = staticmethod(_ChFiDS.Handle_ChFiDS_Stripe_DownCast)
    __swig_destroy__ = _ChFiDS.delete_Handle_ChFiDS_Stripe
Handle_ChFiDS_Stripe.Nullify = new_instancemethod(_ChFiDS.Handle_ChFiDS_Stripe_Nullify,None,Handle_ChFiDS_Stripe)
Handle_ChFiDS_Stripe.IsNull = new_instancemethod(_ChFiDS.Handle_ChFiDS_Stripe_IsNull,None,Handle_ChFiDS_Stripe)
Handle_ChFiDS_Stripe.GetObject = new_instancemethod(_ChFiDS.Handle_ChFiDS_Stripe_GetObject,None,Handle_ChFiDS_Stripe)
Handle_ChFiDS_Stripe_swigregister = _ChFiDS.Handle_ChFiDS_Stripe_swigregister
Handle_ChFiDS_Stripe_swigregister(Handle_ChFiDS_Stripe)

def Handle_ChFiDS_Stripe_DownCast(*args):
  return _ChFiDS.Handle_ChFiDS_Stripe_DownCast(*args)
Handle_ChFiDS_Stripe_DownCast = _ChFiDS.Handle_ChFiDS_Stripe_DownCast

class ChFiDS_StripeArray1(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): 
        """
        :param Low:
        :type Low: int
        :param Up:
        :type Up: int
        :rtype: None

        :param Item:
        :type Item: Handle_ChFiDS_Stripe &
        :param Low:
        :type Low: int
        :param Up:
        :type Up: int
        :rtype: None

        """
        _ChFiDS.ChFiDS_StripeArray1_swiginit(self,_ChFiDS.new_ChFiDS_StripeArray1(*args))
    def Init(self, *args):
        """
        :param V:
        :type V: Handle_ChFiDS_Stripe &
        :rtype: None

        """
        return _ChFiDS.ChFiDS_StripeArray1_Init(self, *args)

    def Destroy(self, *args):
        """
        :rtype: None

        """
        return _ChFiDS.ChFiDS_StripeArray1_Destroy(self, *args)

    def IsAllocated(self, *args):
        """
        :rtype: bool

        """
        return _ChFiDS.ChFiDS_StripeArray1_IsAllocated(self, *args)

    def Assign(self, *args):
        """
        :param Other:
        :type Other: ChFiDS_StripeArray1 &
        :rtype: ChFiDS_StripeArray1

        """
        return _ChFiDS.ChFiDS_StripeArray1_Assign(self, *args)

    def Set(self, *args):
        """
        :param Other:
        :type Other: ChFiDS_StripeArray1 &
        :rtype: ChFiDS_StripeArray1

        """
        return _ChFiDS.ChFiDS_StripeArray1_Set(self, *args)

    def Length(self, *args):
        """
        :rtype: int

        """
        return _ChFiDS.ChFiDS_StripeArray1_Length(self, *args)

    def Lower(self, *args):
        """
        :rtype: int

        """
        return _ChFiDS.ChFiDS_StripeArray1_Lower(self, *args)

    def Upper(self, *args):
        """
        :rtype: int

        """
        return _ChFiDS.ChFiDS_StripeArray1_Upper(self, *args)

    def SetValue(self, *args):
        """
        :param Index:
        :type Index: int
        :param Value:
        :type Value: Handle_ChFiDS_Stripe &
        :rtype: None

        """
        return _ChFiDS.ChFiDS_StripeArray1_SetValue(self, *args)

    def Value(self, *args):
        """
        :param Index:
        :type Index: int
        :rtype: Handle_ChFiDS_Stripe

        """
        return _ChFiDS.ChFiDS_StripeArray1_Value(self, *args)

    def ChangeValue(self, *args):
        """
        :param Index:
        :type Index: int
        :rtype: Handle_ChFiDS_Stripe

        """
        return _ChFiDS.ChFiDS_StripeArray1_ChangeValue(self, *args)

    __swig_destroy__ = _ChFiDS.delete_ChFiDS_StripeArray1
ChFiDS_StripeArray1.Init = new_instancemethod(_ChFiDS.ChFiDS_StripeArray1_Init,None,ChFiDS_StripeArray1)
ChFiDS_StripeArray1.Destroy = new_instancemethod(_ChFiDS.ChFiDS_StripeArray1_Destroy,None,ChFiDS_StripeArray1)
ChFiDS_StripeArray1.IsAllocated = new_instancemethod(_ChFiDS.ChFiDS_StripeArray1_IsAllocated,None,ChFiDS_StripeArray1)
ChFiDS_StripeArray1.Assign = new_instancemethod(_ChFiDS.ChFiDS_StripeArray1_Assign,None,ChFiDS_StripeArray1)
ChFiDS_StripeArray1.Set = new_instancemethod(_ChFiDS.ChFiDS_StripeArray1_Set,None,ChFiDS_StripeArray1)
ChFiDS_StripeArray1.Length = new_instancemethod(_ChFiDS.ChFiDS_StripeArray1_Length,None,ChFiDS_StripeArray1)
ChFiDS_StripeArray1.Lower = new_instancemethod(_ChFiDS.ChFiDS_StripeArray1_Lower,None,ChFiDS_StripeArray1)
ChFiDS_StripeArray1.Upper = new_instancemethod(_ChFiDS.ChFiDS_StripeArray1_Upper,None,ChFiDS_StripeArray1)
ChFiDS_StripeArray1.SetValue = new_instancemethod(_ChFiDS.ChFiDS_StripeArray1_SetValue,None,ChFiDS_StripeArray1)
ChFiDS_StripeArray1.Value = new_instancemethod(_ChFiDS.ChFiDS_StripeArray1_Value,None,ChFiDS_StripeArray1)
ChFiDS_StripeArray1.ChangeValue = new_instancemethod(_ChFiDS.ChFiDS_StripeArray1_ChangeValue,None,ChFiDS_StripeArray1)
ChFiDS_StripeArray1_swigregister = _ChFiDS.ChFiDS_StripeArray1_swigregister
ChFiDS_StripeArray1_swigregister(ChFiDS_StripeArray1)

class ChFiDS_StripeMap(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

        """
        _ChFiDS.ChFiDS_StripeMap_swiginit(self,_ChFiDS.new_ChFiDS_StripeMap(*args))
    def Add(self, *args):
        """
        :param V:
        :type V: TopoDS_Vertex &
        :param F:
        :type F: Handle_ChFiDS_Stripe &
        :rtype: None

        """
        return _ChFiDS.ChFiDS_StripeMap_Add(self, *args)

    def Extent(self, *args):
        """
        :rtype: int

        """
        return _ChFiDS.ChFiDS_StripeMap_Extent(self, *args)

    def FindFromKey(self, *args):
        """
        :param V:
        :type V: TopoDS_Vertex &
        :rtype: ChFiDS_ListOfStripe

        """
        return _ChFiDS.ChFiDS_StripeMap_FindFromKey(self, *args)

    def FindFromIndex(self, *args):
        """
        :param I:
        :type I: int
        :rtype: ChFiDS_ListOfStripe

        """
        return _ChFiDS.ChFiDS_StripeMap_FindFromIndex(self, *args)

    def FindKey(self, *args):
        """
        :param I:
        :type I: int
        :rtype: TopoDS_Vertex

        """
        return _ChFiDS.ChFiDS_StripeMap_FindKey(self, *args)

    def Clear(self, *args):
        """
        :rtype: None

        """
        return _ChFiDS.ChFiDS_StripeMap_Clear(self, *args)

    __swig_destroy__ = _ChFiDS.delete_ChFiDS_StripeMap
ChFiDS_StripeMap.Add = new_instancemethod(_ChFiDS.ChFiDS_StripeMap_Add,None,ChFiDS_StripeMap)
ChFiDS_StripeMap.Extent = new_instancemethod(_ChFiDS.ChFiDS_StripeMap_Extent,None,ChFiDS_StripeMap)
ChFiDS_StripeMap.FindFromKey = new_instancemethod(_ChFiDS.ChFiDS_StripeMap_FindFromKey,None,ChFiDS_StripeMap)
ChFiDS_StripeMap.FindFromIndex = new_instancemethod(_ChFiDS.ChFiDS_StripeMap_FindFromIndex,None,ChFiDS_StripeMap)
ChFiDS_StripeMap.FindKey = new_instancemethod(_ChFiDS.ChFiDS_StripeMap_FindKey,None,ChFiDS_StripeMap)
ChFiDS_StripeMap.Clear = new_instancemethod(_ChFiDS.ChFiDS_StripeMap_Clear,None,ChFiDS_StripeMap)
ChFiDS_StripeMap_swigregister = _ChFiDS.ChFiDS_StripeMap_swigregister
ChFiDS_StripeMap_swigregister(ChFiDS_StripeMap)

class ChFiDS_SurfData(OCC.MMgt.MMgt_TShared):
    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

        """
        _ChFiDS.ChFiDS_SurfData_swiginit(self,_ChFiDS.new_ChFiDS_SurfData(*args))
    def Copy(self, *args):
        """
        :param Other:
        :type Other: Handle_ChFiDS_SurfData &
        :rtype: None

        """
        return _ChFiDS.ChFiDS_SurfData_Copy(self, *args)

    def IndexOfS1(self, *args):
        """
        :rtype: int

        """
        return _ChFiDS.ChFiDS_SurfData_IndexOfS1(self, *args)

    def IndexOfS2(self, *args):
        """
        :rtype: int

        """
        return _ChFiDS.ChFiDS_SurfData_IndexOfS2(self, *args)

    def IsOnCurve1(self, *args):
        """
        :rtype: bool

        """
        return _ChFiDS.ChFiDS_SurfData_IsOnCurve1(self, *args)

    def IsOnCurve2(self, *args):
        """
        :rtype: bool

        """
        return _ChFiDS.ChFiDS_SurfData_IsOnCurve2(self, *args)

    def IndexOfC1(self, *args):
        """
        :rtype: int

        """
        return _ChFiDS.ChFiDS_SurfData_IndexOfC1(self, *args)

    def IndexOfC2(self, *args):
        """
        :rtype: int

        """
        return _ChFiDS.ChFiDS_SurfData_IndexOfC2(self, *args)

    def Surf(self, *args):
        """
        :rtype: int

        """
        return _ChFiDS.ChFiDS_SurfData_Surf(self, *args)

    def Orientation(self, *args):
        """
        :rtype: TopAbs_Orientation

        """
        return _ChFiDS.ChFiDS_SurfData_Orientation(self, *args)

    def InterferenceOnS1(self, *args):
        """
        :rtype: ChFiDS_FaceInterference

        """
        return _ChFiDS.ChFiDS_SurfData_InterferenceOnS1(self, *args)

    def InterferenceOnS2(self, *args):
        """
        :rtype: ChFiDS_FaceInterference

        """
        return _ChFiDS.ChFiDS_SurfData_InterferenceOnS2(self, *args)

    def VertexFirstOnS1(self, *args):
        """
        :rtype: ChFiDS_CommonPoint

        """
        return _ChFiDS.ChFiDS_SurfData_VertexFirstOnS1(self, *args)

    def VertexFirstOnS2(self, *args):
        """
        :rtype: ChFiDS_CommonPoint

        """
        return _ChFiDS.ChFiDS_SurfData_VertexFirstOnS2(self, *args)

    def VertexLastOnS1(self, *args):
        """
        :rtype: ChFiDS_CommonPoint

        """
        return _ChFiDS.ChFiDS_SurfData_VertexLastOnS1(self, *args)

    def VertexLastOnS2(self, *args):
        """
        :rtype: ChFiDS_CommonPoint

        """
        return _ChFiDS.ChFiDS_SurfData_VertexLastOnS2(self, *args)

    def ChangeIndexOfS1(self, *args):
        """
        :param Index:
        :type Index: int
        :rtype: None

        """
        return _ChFiDS.ChFiDS_SurfData_ChangeIndexOfS1(self, *args)

    def ChangeIndexOfS2(self, *args):
        """
        :param Index:
        :type Index: int
        :rtype: None

        """
        return _ChFiDS.ChFiDS_SurfData_ChangeIndexOfS2(self, *args)

    def ChangeSurf(self, *args):
        """
        :param Index:
        :type Index: int
        :rtype: None

        """
        return _ChFiDS.ChFiDS_SurfData_ChangeSurf(self, *args)

    def SetIndexOfC1(self, *args):
        """
        :param Index:
        :type Index: int
        :rtype: None

        """
        return _ChFiDS.ChFiDS_SurfData_SetIndexOfC1(self, *args)

    def SetIndexOfC2(self, *args):
        """
        :param Index:
        :type Index: int
        :rtype: None

        """
        return _ChFiDS.ChFiDS_SurfData_SetIndexOfC2(self, *args)

    def ChangeOrientation(self, *args):
        """
        :rtype: TopAbs_Orientation

        """
        return _ChFiDS.ChFiDS_SurfData_ChangeOrientation(self, *args)

    def ChangeInterferenceOnS1(self, *args):
        """
        :rtype: ChFiDS_FaceInterference

        """
        return _ChFiDS.ChFiDS_SurfData_ChangeInterferenceOnS1(self, *args)

    def ChangeInterferenceOnS2(self, *args):
        """
        :rtype: ChFiDS_FaceInterference

        """
        return _ChFiDS.ChFiDS_SurfData_ChangeInterferenceOnS2(self, *args)

    def ChangeVertexFirstOnS1(self, *args):
        """
        :rtype: ChFiDS_CommonPoint

        """
        return _ChFiDS.ChFiDS_SurfData_ChangeVertexFirstOnS1(self, *args)

    def ChangeVertexFirstOnS2(self, *args):
        """
        :rtype: ChFiDS_CommonPoint

        """
        return _ChFiDS.ChFiDS_SurfData_ChangeVertexFirstOnS2(self, *args)

    def ChangeVertexLastOnS1(self, *args):
        """
        :rtype: ChFiDS_CommonPoint

        """
        return _ChFiDS.ChFiDS_SurfData_ChangeVertexLastOnS1(self, *args)

    def ChangeVertexLastOnS2(self, *args):
        """
        :rtype: ChFiDS_CommonPoint

        """
        return _ChFiDS.ChFiDS_SurfData_ChangeVertexLastOnS2(self, *args)

    def Interference(self, *args):
        """
        :param OnS:
        :type OnS: int
        :rtype: ChFiDS_FaceInterference

        """
        return _ChFiDS.ChFiDS_SurfData_Interference(self, *args)

    def ChangeInterference(self, *args):
        """
        :param OnS:
        :type OnS: int
        :rtype: ChFiDS_FaceInterference

        """
        return _ChFiDS.ChFiDS_SurfData_ChangeInterference(self, *args)

    def Index(self, *args):
        """
        :param OfS:
        :type OfS: int
        :rtype: int

        """
        return _ChFiDS.ChFiDS_SurfData_Index(self, *args)

    def Vertex(self, *args):
        """
        * returns one of the four vertices wether First is true or wrong and OnS equals 1 or 2.

        :param First:
        :type First: bool
        :param OnS:
        :type OnS: int
        :rtype: ChFiDS_CommonPoint

        """
        return _ChFiDS.ChFiDS_SurfData_Vertex(self, *args)

    def ChangeVertex(self, *args):
        """
        * returns one of the four vertices wether First is true or wrong and OnS equals 1 or 2.

        :param First:
        :type First: bool
        :param OnS:
        :type OnS: int
        :rtype: ChFiDS_CommonPoint

        """
        return _ChFiDS.ChFiDS_SurfData_ChangeVertex(self, *args)

    def IsOnCurve(self, *args):
        """
        :param OnS:
        :type OnS: int
        :rtype: bool

        """
        return _ChFiDS.ChFiDS_SurfData_IsOnCurve(self, *args)

    def IndexOfC(self, *args):
        """
        :param OnS:
        :type OnS: int
        :rtype: int

        """
        return _ChFiDS.ChFiDS_SurfData_IndexOfC(self, *args)

    def FirstSpineParam(self, *args):
        """
        :rtype: float

        :param Par:
        :type Par: float
        :rtype: None

        """
        return _ChFiDS.ChFiDS_SurfData_FirstSpineParam(self, *args)

    def LastSpineParam(self, *args):
        """
        :rtype: float

        :param Par:
        :type Par: float
        :rtype: None

        """
        return _ChFiDS.ChFiDS_SurfData_LastSpineParam(self, *args)

    def FirstExtensionValue(self, *args):
        """
        :rtype: float

        :param Extend:
        :type Extend: float
        :rtype: None

        """
        return _ChFiDS.ChFiDS_SurfData_FirstExtensionValue(self, *args)

    def LastExtensionValue(self, *args):
        """
        :rtype: float

        :param Extend:
        :type Extend: float
        :rtype: None

        """
        return _ChFiDS.ChFiDS_SurfData_LastExtensionValue(self, *args)

    def Simul(self, *args):
        """
        :rtype: Handle_MMgt_TShared

        """
        return _ChFiDS.ChFiDS_SurfData_Simul(self, *args)

    def SetSimul(self, *args):
        """
        :param S:
        :type S: Handle_MMgt_TShared &
        :rtype: None

        """
        return _ChFiDS.ChFiDS_SurfData_SetSimul(self, *args)

    def ResetSimul(self, *args):
        """
        :rtype: None

        """
        return _ChFiDS.ChFiDS_SurfData_ResetSimul(self, *args)

    def Get2dPoints(self, *args):
        """
        :param First:
        :type First: bool
        :param OnS:
        :type OnS: int
        :rtype: gp_Pnt2d

        :param P2df1:
        :type P2df1: gp_Pnt2d
        :param P2dl1:
        :type P2dl1: gp_Pnt2d
        :param P2df2:
        :type P2df2: gp_Pnt2d
        :param P2dl2:
        :type P2dl2: gp_Pnt2d
        :rtype: None

        """
        return _ChFiDS.ChFiDS_SurfData_Get2dPoints(self, *args)

    def Set2dPoints(self, *args):
        """
        :param P2df1:
        :type P2df1: gp_Pnt2d
        :param P2dl1:
        :type P2dl1: gp_Pnt2d
        :param P2df2:
        :type P2df2: gp_Pnt2d
        :param P2dl2:
        :type P2dl2: gp_Pnt2d
        :rtype: None

        """
        return _ChFiDS.ChFiDS_SurfData_Set2dPoints(self, *args)

    def TwistOnS1(self, *args):
        """
        :rtype: bool

        :param T:
        :type T: bool
        :rtype: None

        """
        return _ChFiDS.ChFiDS_SurfData_TwistOnS1(self, *args)

    def TwistOnS2(self, *args):
        """
        :rtype: bool

        :param T:
        :type T: bool
        :rtype: None

        """
        return _ChFiDS.ChFiDS_SurfData_TwistOnS2(self, *args)

    def GetHandle(self):
        try:
            return self.thisHandle
        except:
            self.thisHandle = Handle_ChFiDS_SurfData(self)
            self.thisown = False
            return self.thisHandle

    __swig_destroy__ = _ChFiDS.delete_ChFiDS_SurfData
ChFiDS_SurfData.Copy = new_instancemethod(_ChFiDS.ChFiDS_SurfData_Copy,None,ChFiDS_SurfData)
ChFiDS_SurfData.IndexOfS1 = new_instancemethod(_ChFiDS.ChFiDS_SurfData_IndexOfS1,None,ChFiDS_SurfData)
ChFiDS_SurfData.IndexOfS2 = new_instancemethod(_ChFiDS.ChFiDS_SurfData_IndexOfS2,None,ChFiDS_SurfData)
ChFiDS_SurfData.IsOnCurve1 = new_instancemethod(_ChFiDS.ChFiDS_SurfData_IsOnCurve1,None,ChFiDS_SurfData)
ChFiDS_SurfData.IsOnCurve2 = new_instancemethod(_ChFiDS.ChFiDS_SurfData_IsOnCurve2,None,ChFiDS_SurfData)
ChFiDS_SurfData.IndexOfC1 = new_instancemethod(_ChFiDS.ChFiDS_SurfData_IndexOfC1,None,ChFiDS_SurfData)
ChFiDS_SurfData.IndexOfC2 = new_instancemethod(_ChFiDS.ChFiDS_SurfData_IndexOfC2,None,ChFiDS_SurfData)
ChFiDS_SurfData.Surf = new_instancemethod(_ChFiDS.ChFiDS_SurfData_Surf,None,ChFiDS_SurfData)
ChFiDS_SurfData.Orientation = new_instancemethod(_ChFiDS.ChFiDS_SurfData_Orientation,None,ChFiDS_SurfData)
ChFiDS_SurfData.InterferenceOnS1 = new_instancemethod(_ChFiDS.ChFiDS_SurfData_InterferenceOnS1,None,ChFiDS_SurfData)
ChFiDS_SurfData.InterferenceOnS2 = new_instancemethod(_ChFiDS.ChFiDS_SurfData_InterferenceOnS2,None,ChFiDS_SurfData)
ChFiDS_SurfData.VertexFirstOnS1 = new_instancemethod(_ChFiDS.ChFiDS_SurfData_VertexFirstOnS1,None,ChFiDS_SurfData)
ChFiDS_SurfData.VertexFirstOnS2 = new_instancemethod(_ChFiDS.ChFiDS_SurfData_VertexFirstOnS2,None,ChFiDS_SurfData)
ChFiDS_SurfData.VertexLastOnS1 = new_instancemethod(_ChFiDS.ChFiDS_SurfData_VertexLastOnS1,None,ChFiDS_SurfData)
ChFiDS_SurfData.VertexLastOnS2 = new_instancemethod(_ChFiDS.ChFiDS_SurfData_VertexLastOnS2,None,ChFiDS_SurfData)
ChFiDS_SurfData.ChangeIndexOfS1 = new_instancemethod(_ChFiDS.ChFiDS_SurfData_ChangeIndexOfS1,None,ChFiDS_SurfData)
ChFiDS_SurfData.ChangeIndexOfS2 = new_instancemethod(_ChFiDS.ChFiDS_SurfData_ChangeIndexOfS2,None,ChFiDS_SurfData)
ChFiDS_SurfData.ChangeSurf = new_instancemethod(_ChFiDS.ChFiDS_SurfData_ChangeSurf,None,ChFiDS_SurfData)
ChFiDS_SurfData.SetIndexOfC1 = new_instancemethod(_ChFiDS.ChFiDS_SurfData_SetIndexOfC1,None,ChFiDS_SurfData)
ChFiDS_SurfData.SetIndexOfC2 = new_instancemethod(_ChFiDS.ChFiDS_SurfData_SetIndexOfC2,None,ChFiDS_SurfData)
ChFiDS_SurfData.ChangeOrientation = new_instancemethod(_ChFiDS.ChFiDS_SurfData_ChangeOrientation,None,ChFiDS_SurfData)
ChFiDS_SurfData.ChangeInterferenceOnS1 = new_instancemethod(_ChFiDS.ChFiDS_SurfData_ChangeInterferenceOnS1,None,ChFiDS_SurfData)
ChFiDS_SurfData.ChangeInterferenceOnS2 = new_instancemethod(_ChFiDS.ChFiDS_SurfData_ChangeInterferenceOnS2,None,ChFiDS_SurfData)
ChFiDS_SurfData.ChangeVertexFirstOnS1 = new_instancemethod(_ChFiDS.ChFiDS_SurfData_ChangeVertexFirstOnS1,None,ChFiDS_SurfData)
ChFiDS_SurfData.ChangeVertexFirstOnS2 = new_instancemethod(_ChFiDS.ChFiDS_SurfData_ChangeVertexFirstOnS2,None,ChFiDS_SurfData)
ChFiDS_SurfData.ChangeVertexLastOnS1 = new_instancemethod(_ChFiDS.ChFiDS_SurfData_ChangeVertexLastOnS1,None,ChFiDS_SurfData)
ChFiDS_SurfData.ChangeVertexLastOnS2 = new_instancemethod(_ChFiDS.ChFiDS_SurfData_ChangeVertexLastOnS2,None,ChFiDS_SurfData)
ChFiDS_SurfData.Interference = new_instancemethod(_ChFiDS.ChFiDS_SurfData_Interference,None,ChFiDS_SurfData)
ChFiDS_SurfData.ChangeInterference = new_instancemethod(_ChFiDS.ChFiDS_SurfData_ChangeInterference,None,ChFiDS_SurfData)
ChFiDS_SurfData.Index = new_instancemethod(_ChFiDS.ChFiDS_SurfData_Index,None,ChFiDS_SurfData)
ChFiDS_SurfData.Vertex = new_instancemethod(_ChFiDS.ChFiDS_SurfData_Vertex,None,ChFiDS_SurfData)
ChFiDS_SurfData.ChangeVertex = new_instancemethod(_ChFiDS.ChFiDS_SurfData_ChangeVertex,None,ChFiDS_SurfData)
ChFiDS_SurfData.IsOnCurve = new_instancemethod(_ChFiDS.ChFiDS_SurfData_IsOnCurve,None,ChFiDS_SurfData)
ChFiDS_SurfData.IndexOfC = new_instancemethod(_ChFiDS.ChFiDS_SurfData_IndexOfC,None,ChFiDS_SurfData)
ChFiDS_SurfData.FirstSpineParam = new_instancemethod(_ChFiDS.ChFiDS_SurfData_FirstSpineParam,None,ChFiDS_SurfData)
ChFiDS_SurfData.LastSpineParam = new_instancemethod(_ChFiDS.ChFiDS_SurfData_LastSpineParam,None,ChFiDS_SurfData)
ChFiDS_SurfData.FirstExtensionValue = new_instancemethod(_ChFiDS.ChFiDS_SurfData_FirstExtensionValue,None,ChFiDS_SurfData)
ChFiDS_SurfData.LastExtensionValue = new_instancemethod(_ChFiDS.ChFiDS_SurfData_LastExtensionValue,None,ChFiDS_SurfData)
ChFiDS_SurfData.Simul = new_instancemethod(_ChFiDS.ChFiDS_SurfData_Simul,None,ChFiDS_SurfData)
ChFiDS_SurfData.SetSimul = new_instancemethod(_ChFiDS.ChFiDS_SurfData_SetSimul,None,ChFiDS_SurfData)
ChFiDS_SurfData.ResetSimul = new_instancemethod(_ChFiDS.ChFiDS_SurfData_ResetSimul,None,ChFiDS_SurfData)
ChFiDS_SurfData.Get2dPoints = new_instancemethod(_ChFiDS.ChFiDS_SurfData_Get2dPoints,None,ChFiDS_SurfData)
ChFiDS_SurfData.Set2dPoints = new_instancemethod(_ChFiDS.ChFiDS_SurfData_Set2dPoints,None,ChFiDS_SurfData)
ChFiDS_SurfData.TwistOnS1 = new_instancemethod(_ChFiDS.ChFiDS_SurfData_TwistOnS1,None,ChFiDS_SurfData)
ChFiDS_SurfData.TwistOnS2 = new_instancemethod(_ChFiDS.ChFiDS_SurfData_TwistOnS2,None,ChFiDS_SurfData)
ChFiDS_SurfData_swigregister = _ChFiDS.ChFiDS_SurfData_swigregister
ChFiDS_SurfData_swigregister(ChFiDS_SurfData)

class Handle_ChFiDS_SurfData(OCC.MMgt.Handle_MMgt_TShared):
    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): 
        _ChFiDS.Handle_ChFiDS_SurfData_swiginit(self,_ChFiDS.new_Handle_ChFiDS_SurfData(*args))
        # register the handle in the base object
        if len(args) > 0:
            register_handle(self, args[0])



    DownCast = staticmethod(_ChFiDS.Handle_ChFiDS_SurfData_DownCast)
    __swig_destroy__ = _ChFiDS.delete_Handle_ChFiDS_SurfData
Handle_ChFiDS_SurfData.Nullify = new_instancemethod(_ChFiDS.Handle_ChFiDS_SurfData_Nullify,None,Handle_ChFiDS_SurfData)
Handle_ChFiDS_SurfData.IsNull = new_instancemethod(_ChFiDS.Handle_ChFiDS_SurfData_IsNull,None,Handle_ChFiDS_SurfData)
Handle_ChFiDS_SurfData.GetObject = new_instancemethod(_ChFiDS.Handle_ChFiDS_SurfData_GetObject,None,Handle_ChFiDS_SurfData)
Handle_ChFiDS_SurfData_swigregister = _ChFiDS.Handle_ChFiDS_SurfData_swigregister
Handle_ChFiDS_SurfData_swigregister(Handle_ChFiDS_SurfData)

def Handle_ChFiDS_SurfData_DownCast(*args):
  return _ChFiDS.Handle_ChFiDS_SurfData_DownCast(*args)
Handle_ChFiDS_SurfData_DownCast = _ChFiDS.Handle_ChFiDS_SurfData_DownCast

class ChFiDS_ChamfSpine(ChFiDS_Spine):
    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

        :param Tol:
        :type Tol: float
        :rtype: None

        """
        _ChFiDS.ChFiDS_ChamfSpine_swiginit(self,_ChFiDS.new_ChFiDS_ChamfSpine(*args))
    def SetDist(self, *args):
        """
        :param Dis:
        :type Dis: float
        :rtype: None

        """
        return _ChFiDS.ChFiDS_ChamfSpine_SetDist(self, *args)

    def GetDist(self, *args):
        """
        :param Dis:
        :type Dis: float &
        :rtype: None

        """
        return _ChFiDS.ChFiDS_ChamfSpine_GetDist(self, *args)

    def SetDists(self, *args):
        """
        :param Dis1:
        :type Dis1: float
        :param Dis2:
        :type Dis2: float
        :rtype: None

        """
        return _ChFiDS.ChFiDS_ChamfSpine_SetDists(self, *args)

    def Dists(self, *args):
        """
        :param Dis1:
        :type Dis1: float &
        :param Dis2:
        :type Dis2: float &
        :rtype: None

        """
        return _ChFiDS.ChFiDS_ChamfSpine_Dists(self, *args)

    def GetDistAngle(self, *args):
        """
        :param Dis:
        :type Dis: float &
        :param Angle:
        :type Angle: float &
        :param DisOnF1:
        :type DisOnF1: bool
        :rtype: None

        """
        return _ChFiDS.ChFiDS_ChamfSpine_GetDistAngle(self, *args)

    def SetDistAngle(self, *args):
        """
        :param Dis:
        :type Dis: float
        :param Angle:
        :type Angle: float
        :param DisOnF1:
        :type DisOnF1: bool
        :rtype: None

        """
        return _ChFiDS.ChFiDS_ChamfSpine_SetDistAngle(self, *args)

    def IsChamfer(self, *args):
        """
        * Return the method of chamfers used

        :rtype: ChFiDS_ChamfMethod

        """
        return _ChFiDS.ChFiDS_ChamfSpine_IsChamfer(self, *args)

    def GetHandle(self):
        try:
            return self.thisHandle
        except:
            self.thisHandle = Handle_ChFiDS_ChamfSpine(self)
            self.thisown = False
            return self.thisHandle

    __swig_destroy__ = _ChFiDS.delete_ChFiDS_ChamfSpine
ChFiDS_ChamfSpine.SetDist = new_instancemethod(_ChFiDS.ChFiDS_ChamfSpine_SetDist,None,ChFiDS_ChamfSpine)
ChFiDS_ChamfSpine.GetDist = new_instancemethod(_ChFiDS.ChFiDS_ChamfSpine_GetDist,None,ChFiDS_ChamfSpine)
ChFiDS_ChamfSpine.SetDists = new_instancemethod(_ChFiDS.ChFiDS_ChamfSpine_SetDists,None,ChFiDS_ChamfSpine)
ChFiDS_ChamfSpine.Dists = new_instancemethod(_ChFiDS.ChFiDS_ChamfSpine_Dists,None,ChFiDS_ChamfSpine)
ChFiDS_ChamfSpine.GetDistAngle = new_instancemethod(_ChFiDS.ChFiDS_ChamfSpine_GetDistAngle,None,ChFiDS_ChamfSpine)
ChFiDS_ChamfSpine.SetDistAngle = new_instancemethod(_ChFiDS.ChFiDS_ChamfSpine_SetDistAngle,None,ChFiDS_ChamfSpine)
ChFiDS_ChamfSpine.IsChamfer = new_instancemethod(_ChFiDS.ChFiDS_ChamfSpine_IsChamfer,None,ChFiDS_ChamfSpine)
ChFiDS_ChamfSpine_swigregister = _ChFiDS.ChFiDS_ChamfSpine_swigregister
ChFiDS_ChamfSpine_swigregister(ChFiDS_ChamfSpine)

class Handle_ChFiDS_ChamfSpine(Handle_ChFiDS_Spine):
    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): 
        _ChFiDS.Handle_ChFiDS_ChamfSpine_swiginit(self,_ChFiDS.new_Handle_ChFiDS_ChamfSpine(*args))
        # register the handle in the base object
        if len(args) > 0:
            register_handle(self, args[0])



    DownCast = staticmethod(_ChFiDS.Handle_ChFiDS_ChamfSpine_DownCast)
    __swig_destroy__ = _ChFiDS.delete_Handle_ChFiDS_ChamfSpine
Handle_ChFiDS_ChamfSpine.Nullify = new_instancemethod(_ChFiDS.Handle_ChFiDS_ChamfSpine_Nullify,None,Handle_ChFiDS_ChamfSpine)
Handle_ChFiDS_ChamfSpine.IsNull = new_instancemethod(_ChFiDS.Handle_ChFiDS_ChamfSpine_IsNull,None,Handle_ChFiDS_ChamfSpine)
Handle_ChFiDS_ChamfSpine.GetObject = new_instancemethod(_ChFiDS.Handle_ChFiDS_ChamfSpine_GetObject,None,Handle_ChFiDS_ChamfSpine)
Handle_ChFiDS_ChamfSpine_swigregister = _ChFiDS.Handle_ChFiDS_ChamfSpine_swigregister
Handle_ChFiDS_ChamfSpine_swigregister(Handle_ChFiDS_ChamfSpine)

def Handle_ChFiDS_ChamfSpine_DownCast(*args):
  return _ChFiDS.Handle_ChFiDS_ChamfSpine_DownCast(*args)
Handle_ChFiDS_ChamfSpine_DownCast = _ChFiDS.Handle_ChFiDS_ChamfSpine_DownCast

class ChFiDS_FilSpine(ChFiDS_Spine):
    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

        :param Tol:
        :type Tol: float
        :rtype: None

        """
        _ChFiDS.ChFiDS_FilSpine_swiginit(self,_ChFiDS.new_ChFiDS_FilSpine(*args))
    def UnSetRadius(self, *args):
        """
        * resets the constant vector on edge E.

        :param E:
        :type E: TopoDS_Edge &
        :rtype: None

        * resets the vector on Vertex V.

        :param V:
        :type V: TopoDS_Vertex &
        :rtype: None

        """
        return _ChFiDS.ChFiDS_FilSpine_UnSetRadius(self, *args)

    def SetRadius(self, *args):
        """
        * initializes the constant vector on edge E.

        :param Radius:
        :type Radius: float
        :param E:
        :type E: TopoDS_Edge &
        :rtype: None

        * initializes the vector on Vertex V.

        :param Radius:
        :type Radius: float
        :param V:
        :type V: TopoDS_Vertex &
        :rtype: None

        * initializes the vector on the point of parameter W.

        :param UandR:
        :type UandR: gp_XY
        :param IinC:
        :type IinC: int
        :rtype: None

        * initializes the constant vector on all spine.

        :param Radius:
        :type Radius: float
        :rtype: None

        * initializes the rule of evolution on all spine.

        :param C:
        :type C: Handle_Law_Function &
        :param IinC:
        :type IinC: int
        :rtype: None

        """
        return _ChFiDS.ChFiDS_FilSpine_SetRadius(self, *args)

    def IsConstant(self, *args):
        """
        * returns true if the radius is constant all along the spine.

        :rtype: bool

        * returns true if the radius is constant all along the edge E.

        :param IE:
        :type IE: int
        :rtype: bool

        """
        return _ChFiDS.ChFiDS_FilSpine_IsConstant(self, *args)

    def Radius(self, *args):
        """
        * returns the radius if the fillet is constant all along the spine.

        :rtype: float

        * returns the radius if the fillet is constant all along the edge E.

        :param IE:
        :type IE: int
        :rtype: float

        * returns the radius if the fillet is constant all along the edge E.

        :param E:
        :type E: TopoDS_Edge &
        :rtype: float

        """
        return _ChFiDS.ChFiDS_FilSpine_Radius(self, *args)

    def law(self, *args):
        """
        :param Els:
        :type Els: Handle_ChFiDS_HElSpine &
        :rtype: Handle_Law_Composite

        """
        return _ChFiDS.ChFiDS_FilSpine_law(self, *args)

    def ChangeLaw(self, *args):
        """
        * returns the elementary law

        :param E:
        :type E: TopoDS_Edge &
        :rtype: Handle_Law_Function

        """
        return _ChFiDS.ChFiDS_FilSpine_ChangeLaw(self, *args)

    def MaxRadFromSeqAndLaws(self, *args):
        """
        * returns the maximum radius if the fillet is non-constant

        :rtype: float

        """
        return _ChFiDS.ChFiDS_FilSpine_MaxRadFromSeqAndLaws(self, *args)

    def GetHandle(self):
        try:
            return self.thisHandle
        except:
            self.thisHandle = Handle_ChFiDS_FilSpine(self)
            self.thisown = False
            return self.thisHandle

    __swig_destroy__ = _ChFiDS.delete_ChFiDS_FilSpine
ChFiDS_FilSpine.UnSetRadius = new_instancemethod(_ChFiDS.ChFiDS_FilSpine_UnSetRadius,None,ChFiDS_FilSpine)
ChFiDS_FilSpine.SetRadius = new_instancemethod(_ChFiDS.ChFiDS_FilSpine_SetRadius,None,ChFiDS_FilSpine)
ChFiDS_FilSpine.IsConstant = new_instancemethod(_ChFiDS.ChFiDS_FilSpine_IsConstant,None,ChFiDS_FilSpine)
ChFiDS_FilSpine.Radius = new_instancemethod(_ChFiDS.ChFiDS_FilSpine_Radius,None,ChFiDS_FilSpine)
ChFiDS_FilSpine.law = new_instancemethod(_ChFiDS.ChFiDS_FilSpine_law,None,ChFiDS_FilSpine)
ChFiDS_FilSpine.ChangeLaw = new_instancemethod(_ChFiDS.ChFiDS_FilSpine_ChangeLaw,None,ChFiDS_FilSpine)
ChFiDS_FilSpine.MaxRadFromSeqAndLaws = new_instancemethod(_ChFiDS.ChFiDS_FilSpine_MaxRadFromSeqAndLaws,None,ChFiDS_FilSpine)
ChFiDS_FilSpine_swigregister = _ChFiDS.ChFiDS_FilSpine_swigregister
ChFiDS_FilSpine_swigregister(ChFiDS_FilSpine)

class Handle_ChFiDS_FilSpine(Handle_ChFiDS_Spine):
    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): 
        _ChFiDS.Handle_ChFiDS_FilSpine_swiginit(self,_ChFiDS.new_Handle_ChFiDS_FilSpine(*args))
        # register the handle in the base object
        if len(args) > 0:
            register_handle(self, args[0])



    DownCast = staticmethod(_ChFiDS.Handle_ChFiDS_FilSpine_DownCast)
    __swig_destroy__ = _ChFiDS.delete_Handle_ChFiDS_FilSpine
Handle_ChFiDS_FilSpine.Nullify = new_instancemethod(_ChFiDS.Handle_ChFiDS_FilSpine_Nullify,None,Handle_ChFiDS_FilSpine)
Handle_ChFiDS_FilSpine.IsNull = new_instancemethod(_ChFiDS.Handle_ChFiDS_FilSpine_IsNull,None,Handle_ChFiDS_FilSpine)
Handle_ChFiDS_FilSpine.GetObject = new_instancemethod(_ChFiDS.Handle_ChFiDS_FilSpine_GetObject,None,Handle_ChFiDS_FilSpine)
Handle_ChFiDS_FilSpine_swigregister = _ChFiDS.Handle_ChFiDS_FilSpine_swigregister
Handle_ChFiDS_FilSpine_swigregister(Handle_ChFiDS_FilSpine)

def Handle_ChFiDS_FilSpine_DownCast(*args):
  return _ChFiDS.Handle_ChFiDS_FilSpine_DownCast(*args)
Handle_ChFiDS_FilSpine_DownCast = _ChFiDS.Handle_ChFiDS_FilSpine_DownCast



