text: # This file was automatically generated by SWIG (http://www.swig.org).
  # Version 3.0.1
  #
  # 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: _IntRes2d.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('_IntRes2d', [dirname(__file__)])
          except ImportError:
              import _IntRes2d
              return _IntRes2d
          if fp is not None:
              try:
                  _mod = imp.load_module('_IntRes2d', fp, pathname, description)
              finally:
                  fp.close()
              return _mod
      _IntRes2d = swig_import_helper()
      del swig_import_helper
  else:
      import _IntRes2d
  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__ = _IntRes2d.delete_SwigPyIterator
      def __iter__(self): return self
  SwigPyIterator.value = new_instancemethod(_IntRes2d.SwigPyIterator_value,None,SwigPyIterator)
  SwigPyIterator.incr = new_instancemethod(_IntRes2d.SwigPyIterator_incr,None,SwigPyIterator)
  SwigPyIterator.decr = new_instancemethod(_IntRes2d.SwigPyIterator_decr,None,SwigPyIterator)
  SwigPyIterator.distance = new_instancemethod(_IntRes2d.SwigPyIterator_distance,None,SwigPyIterator)
  SwigPyIterator.equal = new_instancemethod(_IntRes2d.SwigPyIterator_equal,None,SwigPyIterator)
  SwigPyIterator.copy = new_instancemethod(_IntRes2d.SwigPyIterator_copy,None,SwigPyIterator)
  SwigPyIterator.next = new_instancemethod(_IntRes2d.SwigPyIterator_next,None,SwigPyIterator)
  SwigPyIterator.__next__ = new_instancemethod(_IntRes2d.SwigPyIterator___next__,None,SwigPyIterator)
  SwigPyIterator.previous = new_instancemethod(_IntRes2d.SwigPyIterator_previous,None,SwigPyIterator)
  SwigPyIterator.advance = new_instancemethod(_IntRes2d.SwigPyIterator_advance,None,SwigPyIterator)
  SwigPyIterator.__eq__ = new_instancemethod(_IntRes2d.SwigPyIterator___eq__,None,SwigPyIterator)
  SwigPyIterator.__ne__ = new_instancemethod(_IntRes2d.SwigPyIterator___ne__,None,SwigPyIterator)
  SwigPyIterator.__iadd__ = new_instancemethod(_IntRes2d.SwigPyIterator___iadd__,None,SwigPyIterator)
  SwigPyIterator.__isub__ = new_instancemethod(_IntRes2d.SwigPyIterator___isub__,None,SwigPyIterator)
  SwigPyIterator.__add__ = new_instancemethod(_IntRes2d.SwigPyIterator___add__,None,SwigPyIterator)
  SwigPyIterator.__sub__ = new_instancemethod(_IntRes2d.SwigPyIterator___sub__,None,SwigPyIterator)
  SwigPyIterator_swigregister = _IntRes2d.SwigPyIterator_swigregister
  SwigPyIterator_swigregister(SwigPyIterator)
  
  import OCC.gp
  import OCC.Standard
  import OCC.TCollection
  import OCC.MMgt
  IntRes2d_Head = _IntRes2d.IntRes2d_Head
  IntRes2d_Middle = _IntRes2d.IntRes2d_Middle
  IntRes2d_End = _IntRes2d.IntRes2d_End
  IntRes2d_Inside = _IntRes2d.IntRes2d_Inside
  IntRes2d_Outside = _IntRes2d.IntRes2d_Outside
  IntRes2d_Unknown = _IntRes2d.IntRes2d_Unknown
  IntRes2d_In = _IntRes2d.IntRes2d_In
  IntRes2d_Out = _IntRes2d.IntRes2d_Out
  IntRes2d_Touch = _IntRes2d.IntRes2d_Touch
  IntRes2d_Undecided = _IntRes2d.IntRes2d_Undecided
  class IntRes2d_Domain(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): 
          """
          * Creates an infinite Domain (HasFirstPoint = False and HasLastPoint = False).
  
          :rtype: None
  
          * Creates a bounded Domain.
  
          :param Pnt1:
          :type Pnt1: gp_Pnt2d
          :param Par1:
          :type Par1: float
          :param Tol1:
          :type Tol1: float
          :param Pnt2:
          :type Pnt2: gp_Pnt2d
          :param Par2:
          :type Par2: float
          :param Tol2:
          :type Tol2: float
          :rtype: None
  
          * Creates a semi-infinite Domain. If First is set to True, the given point is the first point of the domain, otherwise it is the last point.
  
          :param Pnt:
          :type Pnt: gp_Pnt2d
          :param Par:
          :type Par: float
          :param Tol:
          :type Tol: float
          :param First:
          :type First: bool
          :rtype: None
  
          """
          _IntRes2d.IntRes2d_Domain_swiginit(self,_IntRes2d.new_IntRes2d_Domain(*args))
      def SetValues(self, *args):
          """
          * Sets the values for a bounded domain.
  
          :param Pnt1:
          :type Pnt1: gp_Pnt2d
          :param Par1:
          :type Par1: float
          :param Tol1:
          :type Tol1: float
          :param Pnt2:
          :type Pnt2: gp_Pnt2d
          :param Par2:
          :type Par2: float
          :param Tol2:
          :type Tol2: float
          :rtype: None
  
          * Sets the values for an infinite domain.
  
          :rtype: None
  
          * Sets the values for a semi-infinite domain.
  
          :param Pnt:
          :type Pnt: gp_Pnt2d
          :param Par:
          :type Par: float
          :param Tol:
          :type Tol: float
          :param First:
          :type First: bool
          :rtype: None
  
          """
          return _IntRes2d.IntRes2d_Domain_SetValues(self, *args)
  
      def SetEquivalentParameters(self, *args):
          """
          * Defines a closed domain.
  
          :param zero:
          :type zero: float
          :param period:
          :type period: float
          :rtype: None
  
          """
          return _IntRes2d.IntRes2d_Domain_SetEquivalentParameters(self, *args)
  
      def HasFirstPoint(self, *args):
          """
          * Returns True if the domain has a first point, i-e a point defining the lowest admitted parameter on the curve.
  
          :rtype: bool
  
          """
          return _IntRes2d.IntRes2d_Domain_HasFirstPoint(self, *args)
  
      def FirstParameter(self, *args):
          """
          * Returns the parameter of the first point of the domain The exception DomainError is raised if HasFirstPoint returns False.
  
          :rtype: float
  
          """
          return _IntRes2d.IntRes2d_Domain_FirstParameter(self, *args)
  
      def FirstPoint(self, *args):
          """
          * Returns the first point of the domain. The exception DomainError is raised if HasFirstPoint returns False.
  
          :rtype: gp_Pnt2d
  
          """
          return _IntRes2d.IntRes2d_Domain_FirstPoint(self, *args)
  
      def FirstTolerance(self, *args):
          """
          * Returns the tolerance of the first (left) bound. The exception DomainError is raised if HasFirstPoint returns False.
  
          :rtype: float
  
          """
          return _IntRes2d.IntRes2d_Domain_FirstTolerance(self, *args)
  
      def HasLastPoint(self, *args):
          """
          * Returns True if the domain has a last point, i-e a point defining the highest admitted parameter on the curve.
  
          :rtype: bool
  
          """
          return _IntRes2d.IntRes2d_Domain_HasLastPoint(self, *args)
  
      def LastParameter(self, *args):
          """
          * Returns the parameter of the last point of the domain. The exception DomainError is raised if HasLastPoint returns False.
  
          :rtype: float
  
          """
          return _IntRes2d.IntRes2d_Domain_LastParameter(self, *args)
  
      def LastPoint(self, *args):
          """
          * Returns the last point of the domain. The exception DomainError is raised if HasLastPoint returns False.
  
          :rtype: gp_Pnt2d
  
          """
          return _IntRes2d.IntRes2d_Domain_LastPoint(self, *args)
  
      def LastTolerance(self, *args):
          """
          * Returns the tolerance of the last (right) bound. The exception DomainError is raised if HasLastPoint returns False.
  
          :rtype: float
  
          """
          return _IntRes2d.IntRes2d_Domain_LastTolerance(self, *args)
  
      def IsClosed(self, *args):
          """
          * Returns True if the domain is closed.
  
          :rtype: bool
  
          """
          return _IntRes2d.IntRes2d_Domain_IsClosed(self, *args)
  
      def EquivalentParameters(self, *args):
          """
          * Returns Equivalent parameters if the domain is closed. Otherwise, the exception DomainError is raised.
  
          :param zero:
          :type zero: float &
          :param zeroplusperiod:
          :type zeroplusperiod: float &
          :rtype: None
  
          """
          return _IntRes2d.IntRes2d_Domain_EquivalentParameters(self, *args)
  
      def __del__(self):
      	try:
      		self.thisown = False
      		GarbageCollector.garbage.collect_object(self)
      	except:
      		pass
  
  
  IntRes2d_Domain.SetValues = new_instancemethod(_IntRes2d.IntRes2d_Domain_SetValues,None,IntRes2d_Domain)
  IntRes2d_Domain.SetEquivalentParameters = new_instancemethod(_IntRes2d.IntRes2d_Domain_SetEquivalentParameters,None,IntRes2d_Domain)
  IntRes2d_Domain.HasFirstPoint = new_instancemethod(_IntRes2d.IntRes2d_Domain_HasFirstPoint,None,IntRes2d_Domain)
  IntRes2d_Domain.FirstParameter = new_instancemethod(_IntRes2d.IntRes2d_Domain_FirstParameter,None,IntRes2d_Domain)
  IntRes2d_Domain.FirstPoint = new_instancemethod(_IntRes2d.IntRes2d_Domain_FirstPoint,None,IntRes2d_Domain)
  IntRes2d_Domain.FirstTolerance = new_instancemethod(_IntRes2d.IntRes2d_Domain_FirstTolerance,None,IntRes2d_Domain)
  IntRes2d_Domain.HasLastPoint = new_instancemethod(_IntRes2d.IntRes2d_Domain_HasLastPoint,None,IntRes2d_Domain)
  IntRes2d_Domain.LastParameter = new_instancemethod(_IntRes2d.IntRes2d_Domain_LastParameter,None,IntRes2d_Domain)
  IntRes2d_Domain.LastPoint = new_instancemethod(_IntRes2d.IntRes2d_Domain_LastPoint,None,IntRes2d_Domain)
  IntRes2d_Domain.LastTolerance = new_instancemethod(_IntRes2d.IntRes2d_Domain_LastTolerance,None,IntRes2d_Domain)
  IntRes2d_Domain.IsClosed = new_instancemethod(_IntRes2d.IntRes2d_Domain_IsClosed,None,IntRes2d_Domain)
  IntRes2d_Domain.EquivalentParameters = new_instancemethod(_IntRes2d.IntRes2d_Domain_EquivalentParameters,None,IntRes2d_Domain)
  IntRes2d_Domain._kill_pointed = new_instancemethod(_IntRes2d.IntRes2d_Domain__kill_pointed,None,IntRes2d_Domain)
  IntRes2d_Domain_swigregister = _IntRes2d.IntRes2d_Domain_swigregister
  IntRes2d_Domain_swigregister(IntRes2d_Domain)
  
  class IntRes2d_Intersection(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")
      __repr__ = _swig_repr
      def IsDone(self, *args):
          """
          * returns True when the computation was successful.
  
          :rtype: bool
  
          """
          return _IntRes2d.IntRes2d_Intersection_IsDone(self, *args)
  
      def IsEmpty(self, *args):
          """
          * Returns True if there is no intersection between the given arguments. The exception NotDone is raised if IsDone returns False.
  
          :rtype: bool
  
          """
          return _IntRes2d.IntRes2d_Intersection_IsEmpty(self, *args)
  
      def NbPoints(self, *args):
          """
          * This function returns the number of intersection points between the 2 curves. The exception NotDone is raised if IsDone returns False.
  
          :rtype: int
  
          """
          return _IntRes2d.IntRes2d_Intersection_NbPoints(self, *args)
  
      def Point(self, *args):
          """
          * This function returns the intersection point of range N; The exception NotDone is raised if IsDone returns False. The exception OutOfRange is raised if (N <= 0) or (N > NbPoints).
  
          :param N:
          :type N: int
          :rtype: IntRes2d_IntersectionPoint
  
          """
          return _IntRes2d.IntRes2d_Intersection_Point(self, *args)
  
      def NbSegments(self, *args):
          """
          * This function returns the number of intersection segments between the two curves. The exception NotDone is raised if IsDone returns False.
  
          :rtype: int
  
          """
          return _IntRes2d.IntRes2d_Intersection_NbSegments(self, *args)
  
      def Segment(self, *args):
          """
          * This function returns the intersection segment of range N; The exception NotDone is raised if IsDone returns False. The exception OutOfRange is raised if (N <= 0) or (N > NbPoints).
  
          :param N:
          :type N: int
          :rtype: IntRes2d_IntersectionSegment
  
          """
          return _IntRes2d.IntRes2d_Intersection_Segment(self, *args)
  
      def SetReversedParameters(self, *args):
          """
          :param Reverseflag:
          :type Reverseflag: bool
          :rtype: None
  
          """
          return _IntRes2d.IntRes2d_Intersection_SetReversedParameters(self, *args)
  
      def __del__(self):
      	try:
      		self.thisown = False
      		GarbageCollector.garbage.collect_object(self)
      	except:
      		pass
  
  
  IntRes2d_Intersection.IsDone = new_instancemethod(_IntRes2d.IntRes2d_Intersection_IsDone,None,IntRes2d_Intersection)
  IntRes2d_Intersection.IsEmpty = new_instancemethod(_IntRes2d.IntRes2d_Intersection_IsEmpty,None,IntRes2d_Intersection)
  IntRes2d_Intersection.NbPoints = new_instancemethod(_IntRes2d.IntRes2d_Intersection_NbPoints,None,IntRes2d_Intersection)
  IntRes2d_Intersection.Point = new_instancemethod(_IntRes2d.IntRes2d_Intersection_Point,None,IntRes2d_Intersection)
  IntRes2d_Intersection.NbSegments = new_instancemethod(_IntRes2d.IntRes2d_Intersection_NbSegments,None,IntRes2d_Intersection)
  IntRes2d_Intersection.Segment = new_instancemethod(_IntRes2d.IntRes2d_Intersection_Segment,None,IntRes2d_Intersection)
  IntRes2d_Intersection.SetReversedParameters = new_instancemethod(_IntRes2d.IntRes2d_Intersection_SetReversedParameters,None,IntRes2d_Intersection)
  IntRes2d_Intersection._kill_pointed = new_instancemethod(_IntRes2d.IntRes2d_Intersection__kill_pointed,None,IntRes2d_Intersection)
  IntRes2d_Intersection_swigregister = _IntRes2d.IntRes2d_Intersection_swigregister
  IntRes2d_Intersection_swigregister(IntRes2d_Intersection)
  
  class IntRes2d_IntersectionPoint(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
  
          * Creates an IntersectionPoint. if ReversedFlag is False, the parameter Uc1(resp. Uc2) and the Transition Trans1 (resp. Trans2) refer to the first curve (resp. second curve) otherwise Uc1 and Trans1 (resp. Uc2 and Trans2) refer to the second curve (resp. the first curve).
  
          :param P:
          :type P: gp_Pnt2d
          :param Uc1:
          :type Uc1: float
          :param Uc2:
          :type Uc2: float
          :param Trans1:
          :type Trans1: IntRes2d_Transition &
          :param Trans2:
          :type Trans2: IntRes2d_Transition &
          :param ReversedFlag:
          :type ReversedFlag: bool
          :rtype: None
  
          """
          _IntRes2d.IntRes2d_IntersectionPoint_swiginit(self,_IntRes2d.new_IntRes2d_IntersectionPoint(*args))
      def SetValues(self, *args):
          """
          * Sets the values for an existing intersection point. The meaning of the parameters are the same as for the Create.
  
          :param P:
          :type P: gp_Pnt2d
          :param Uc1:
          :type Uc1: float
          :param Uc2:
          :type Uc2: float
          :param Trans1:
          :type Trans1: IntRes2d_Transition &
          :param Trans2:
          :type Trans2: IntRes2d_Transition &
          :param ReversedFlag:
          :type ReversedFlag: bool
          :rtype: None
  
          """
          return _IntRes2d.IntRes2d_IntersectionPoint_SetValues(self, *args)
  
      def Value(self, *args):
          """
          * Returns the value of the coordinates of the intersection point in the 2D space.
  
          :rtype: gp_Pnt2d
  
          """
          return _IntRes2d.IntRes2d_IntersectionPoint_Value(self, *args)
  
      def ParamOnFirst(self, *args):
          """
          * Returns the parameter on the first curve.
  
          :rtype: float
  
          """
          return _IntRes2d.IntRes2d_IntersectionPoint_ParamOnFirst(self, *args)
  
      def ParamOnSecond(self, *args):
          """
          * Returns the parameter on the second curve.
  
          :rtype: float
  
          """
          return _IntRes2d.IntRes2d_IntersectionPoint_ParamOnSecond(self, *args)
  
      def TransitionOfFirst(self, *args):
          """
          * Returns the transition of the 1st curve compared to the 2nd one.
  
          :rtype: IntRes2d_Transition
  
          """
          return _IntRes2d.IntRes2d_IntersectionPoint_TransitionOfFirst(self, *args)
  
      def TransitionOfSecond(self, *args):
          """
          * returns the transition of the 2nd curve compared to the 1st one.
  
          :rtype: IntRes2d_Transition
  
          """
          return _IntRes2d.IntRes2d_IntersectionPoint_TransitionOfSecond(self, *args)
  
      def _CSFDB_GetIntRes2d_IntersectionPointpt(self, *args):
          """
          :rtype: gp_Pnt2d
  
          """
          return _IntRes2d.IntRes2d_IntersectionPoint__CSFDB_GetIntRes2d_IntersectionPointpt(self, *args)
  
      def _CSFDB_GetIntRes2d_IntersectionPointp1(self, *args):
          """
          :rtype: float
  
          """
          return _IntRes2d.IntRes2d_IntersectionPoint__CSFDB_GetIntRes2d_IntersectionPointp1(self, *args)
  
      def _CSFDB_SetIntRes2d_IntersectionPointp1(self, *args):
          """
          :param p:
          :type p: float
          :rtype: None
  
          """
          return _IntRes2d.IntRes2d_IntersectionPoint__CSFDB_SetIntRes2d_IntersectionPointp1(self, *args)
  
      def _CSFDB_GetIntRes2d_IntersectionPointp2(self, *args):
          """
          :rtype: float
  
          """
          return _IntRes2d.IntRes2d_IntersectionPoint__CSFDB_GetIntRes2d_IntersectionPointp2(self, *args)
  
      def _CSFDB_SetIntRes2d_IntersectionPointp2(self, *args):
          """
          :param p:
          :type p: float
          :rtype: None
  
          """
          return _IntRes2d.IntRes2d_IntersectionPoint__CSFDB_SetIntRes2d_IntersectionPointp2(self, *args)
  
      def _CSFDB_GetIntRes2d_IntersectionPointtrans1(self, *args):
          """
          :rtype: IntRes2d_Transition
  
          """
          return _IntRes2d.IntRes2d_IntersectionPoint__CSFDB_GetIntRes2d_IntersectionPointtrans1(self, *args)
  
      def _CSFDB_GetIntRes2d_IntersectionPointtrans2(self, *args):
          """
          :rtype: IntRes2d_Transition
  
          """
          return _IntRes2d.IntRes2d_IntersectionPoint__CSFDB_GetIntRes2d_IntersectionPointtrans2(self, *args)
  
      def __del__(self):
      	try:
      		self.thisown = False
      		GarbageCollector.garbage.collect_object(self)
      	except:
      		pass
  
  
  IntRes2d_IntersectionPoint.SetValues = new_instancemethod(_IntRes2d.IntRes2d_IntersectionPoint_SetValues,None,IntRes2d_IntersectionPoint)
  IntRes2d_IntersectionPoint.Value = new_instancemethod(_IntRes2d.IntRes2d_IntersectionPoint_Value,None,IntRes2d_IntersectionPoint)
  IntRes2d_IntersectionPoint.ParamOnFirst = new_instancemethod(_IntRes2d.IntRes2d_IntersectionPoint_ParamOnFirst,None,IntRes2d_IntersectionPoint)
  IntRes2d_IntersectionPoint.ParamOnSecond = new_instancemethod(_IntRes2d.IntRes2d_IntersectionPoint_ParamOnSecond,None,IntRes2d_IntersectionPoint)
  IntRes2d_IntersectionPoint.TransitionOfFirst = new_instancemethod(_IntRes2d.IntRes2d_IntersectionPoint_TransitionOfFirst,None,IntRes2d_IntersectionPoint)
  IntRes2d_IntersectionPoint.TransitionOfSecond = new_instancemethod(_IntRes2d.IntRes2d_IntersectionPoint_TransitionOfSecond,None,IntRes2d_IntersectionPoint)
  IntRes2d_IntersectionPoint._CSFDB_GetIntRes2d_IntersectionPointpt = new_instancemethod(_IntRes2d.IntRes2d_IntersectionPoint__CSFDB_GetIntRes2d_IntersectionPointpt,None,IntRes2d_IntersectionPoint)
  IntRes2d_IntersectionPoint._CSFDB_GetIntRes2d_IntersectionPointp1 = new_instancemethod(_IntRes2d.IntRes2d_IntersectionPoint__CSFDB_GetIntRes2d_IntersectionPointp1,None,IntRes2d_IntersectionPoint)
  IntRes2d_IntersectionPoint._CSFDB_SetIntRes2d_IntersectionPointp1 = new_instancemethod(_IntRes2d.IntRes2d_IntersectionPoint__CSFDB_SetIntRes2d_IntersectionPointp1,None,IntRes2d_IntersectionPoint)
  IntRes2d_IntersectionPoint._CSFDB_GetIntRes2d_IntersectionPointp2 = new_instancemethod(_IntRes2d.IntRes2d_IntersectionPoint__CSFDB_GetIntRes2d_IntersectionPointp2,None,IntRes2d_IntersectionPoint)
  IntRes2d_IntersectionPoint._CSFDB_SetIntRes2d_IntersectionPointp2 = new_instancemethod(_IntRes2d.IntRes2d_IntersectionPoint__CSFDB_SetIntRes2d_IntersectionPointp2,None,IntRes2d_IntersectionPoint)
  IntRes2d_IntersectionPoint._CSFDB_GetIntRes2d_IntersectionPointtrans1 = new_instancemethod(_IntRes2d.IntRes2d_IntersectionPoint__CSFDB_GetIntRes2d_IntersectionPointtrans1,None,IntRes2d_IntersectionPoint)
  IntRes2d_IntersectionPoint._CSFDB_GetIntRes2d_IntersectionPointtrans2 = new_instancemethod(_IntRes2d.IntRes2d_IntersectionPoint__CSFDB_GetIntRes2d_IntersectionPointtrans2,None,IntRes2d_IntersectionPoint)
  IntRes2d_IntersectionPoint._kill_pointed = new_instancemethod(_IntRes2d.IntRes2d_IntersectionPoint__kill_pointed,None,IntRes2d_IntersectionPoint)
  IntRes2d_IntersectionPoint_swigregister = _IntRes2d.IntRes2d_IntersectionPoint_swigregister
  IntRes2d_IntersectionPoint_swigregister(IntRes2d_IntersectionPoint)
  
  class IntRes2d_IntersectionSegment(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
  
          :param P1:
          :type P1: IntRes2d_IntersectionPoint &
          :param P2:
          :type P2: IntRes2d_IntersectionPoint &
          :param Oppos:
          :type Oppos: bool
          :param ReverseFlag:
          :type ReverseFlag: bool
          :rtype: None
  
          :param P:
          :type P: IntRes2d_IntersectionPoint &
          :param First:
          :type First: bool
          :param Oppos:
          :type Oppos: bool
          :param ReverseFlag:
          :type ReverseFlag: bool
          :rtype: None
  
          * Creates an infinite segment of intersection.
  
          :param Oppos:
          :type Oppos: bool
          :rtype: None
  
          """
          _IntRes2d.IntRes2d_IntersectionSegment_swiginit(self,_IntRes2d.new_IntRes2d_IntersectionSegment(*args))
      def IsOpposite(self, *args):
          """
          * Returns True if the intersection segment has got the same orientation on both curves.
  
          :rtype: bool
  
          """
          return _IntRes2d.IntRes2d_IntersectionSegment_IsOpposite(self, *args)
  
      def HasFirstPoint(self, *args):
          """
          * Returns True if the segment is limited by a first point. This point defines the lowest parameter admitted on the first curve for the segment. If IsOpposite returns False, it defines the lowest parameter on the second curve, otherwise, it is the highest parameter on the second curve.
  
          :rtype: bool
  
          """
          return _IntRes2d.IntRes2d_IntersectionSegment_HasFirstPoint(self, *args)
  
      def FirstPoint(self, *args):
          """
          * Returns the first point of the segment as an IntersectionPoint (with a transition). The exception DomainError is raised if HasFirstPoint returns False.
  
          :rtype: IntRes2d_IntersectionPoint
  
          """
          return _IntRes2d.IntRes2d_IntersectionSegment_FirstPoint(self, *args)
  
      def HasLastPoint(self, *args):
          """
          * Returns True if the segment is limited by a last point. This point defines the highest parameter admitted on the first curve for the segment. If IsOpposite returns False, it defines the highest parameter on the second curve, otherwise, it is the lowest parameter on the second curve.
  
          :rtype: bool
  
          """
          return _IntRes2d.IntRes2d_IntersectionSegment_HasLastPoint(self, *args)
  
      def LastPoint(self, *args):
          """
          * Returns the last point of the segment as an IntersectionPoint (with a transition). The exception DomainError is raised if HasLastExtremity returns False.
  
          :rtype: IntRes2d_IntersectionPoint
  
          """
          return _IntRes2d.IntRes2d_IntersectionSegment_LastPoint(self, *args)
  
      def _CSFDB_GetIntRes2d_IntersectionSegmentoppos(self, *args):
          """
          :rtype: bool
  
          """
          return _IntRes2d.IntRes2d_IntersectionSegment__CSFDB_GetIntRes2d_IntersectionSegmentoppos(self, *args)
  
      def _CSFDB_SetIntRes2d_IntersectionSegmentoppos(self, *args):
          """
          :param p:
          :type p: bool
          :rtype: None
  
          """
          return _IntRes2d.IntRes2d_IntersectionSegment__CSFDB_SetIntRes2d_IntersectionSegmentoppos(self, *args)
  
      def _CSFDB_GetIntRes2d_IntersectionSegmentfirst(self, *args):
          """
          :rtype: bool
  
          """
          return _IntRes2d.IntRes2d_IntersectionSegment__CSFDB_GetIntRes2d_IntersectionSegmentfirst(self, *args)
  
      def _CSFDB_SetIntRes2d_IntersectionSegmentfirst(self, *args):
          """
          :param p:
          :type p: bool
          :rtype: None
  
          """
          return _IntRes2d.IntRes2d_IntersectionSegment__CSFDB_SetIntRes2d_IntersectionSegmentfirst(self, *args)
  
      def _CSFDB_GetIntRes2d_IntersectionSegmentlast(self, *args):
          """
          :rtype: bool
  
          """
          return _IntRes2d.IntRes2d_IntersectionSegment__CSFDB_GetIntRes2d_IntersectionSegmentlast(self, *args)
  
      def _CSFDB_SetIntRes2d_IntersectionSegmentlast(self, *args):
          """
          :param p:
          :type p: bool
          :rtype: None
  
          """
          return _IntRes2d.IntRes2d_IntersectionSegment__CSFDB_SetIntRes2d_IntersectionSegmentlast(self, *args)
  
      def _CSFDB_GetIntRes2d_IntersectionSegmentptfirst(self, *args):
          """
          :rtype: IntRes2d_IntersectionPoint
  
          """
          return _IntRes2d.IntRes2d_IntersectionSegment__CSFDB_GetIntRes2d_IntersectionSegmentptfirst(self, *args)
  
      def _CSFDB_GetIntRes2d_IntersectionSegmentptlast(self, *args):
          """
          :rtype: IntRes2d_IntersectionPoint
  
          """
          return _IntRes2d.IntRes2d_IntersectionSegment__CSFDB_GetIntRes2d_IntersectionSegmentptlast(self, *args)
  
      def __del__(self):
      	try:
      		self.thisown = False
      		GarbageCollector.garbage.collect_object(self)
      	except:
      		pass
  
  
  IntRes2d_IntersectionSegment.IsOpposite = new_instancemethod(_IntRes2d.IntRes2d_IntersectionSegment_IsOpposite,None,IntRes2d_IntersectionSegment)
  IntRes2d_IntersectionSegment.HasFirstPoint = new_instancemethod(_IntRes2d.IntRes2d_IntersectionSegment_HasFirstPoint,None,IntRes2d_IntersectionSegment)
  IntRes2d_IntersectionSegment.FirstPoint = new_instancemethod(_IntRes2d.IntRes2d_IntersectionSegment_FirstPoint,None,IntRes2d_IntersectionSegment)
  IntRes2d_IntersectionSegment.HasLastPoint = new_instancemethod(_IntRes2d.IntRes2d_IntersectionSegment_HasLastPoint,None,IntRes2d_IntersectionSegment)
  IntRes2d_IntersectionSegment.LastPoint = new_instancemethod(_IntRes2d.IntRes2d_IntersectionSegment_LastPoint,None,IntRes2d_IntersectionSegment)
  IntRes2d_IntersectionSegment._CSFDB_GetIntRes2d_IntersectionSegmentoppos = new_instancemethod(_IntRes2d.IntRes2d_IntersectionSegment__CSFDB_GetIntRes2d_IntersectionSegmentoppos,None,IntRes2d_IntersectionSegment)
  IntRes2d_IntersectionSegment._CSFDB_SetIntRes2d_IntersectionSegmentoppos = new_instancemethod(_IntRes2d.IntRes2d_IntersectionSegment__CSFDB_SetIntRes2d_IntersectionSegmentoppos,None,IntRes2d_IntersectionSegment)
  IntRes2d_IntersectionSegment._CSFDB_GetIntRes2d_IntersectionSegmentfirst = new_instancemethod(_IntRes2d.IntRes2d_IntersectionSegment__CSFDB_GetIntRes2d_IntersectionSegmentfirst,None,IntRes2d_IntersectionSegment)
  IntRes2d_IntersectionSegment._CSFDB_SetIntRes2d_IntersectionSegmentfirst = new_instancemethod(_IntRes2d.IntRes2d_IntersectionSegment__CSFDB_SetIntRes2d_IntersectionSegmentfirst,None,IntRes2d_IntersectionSegment)
  IntRes2d_IntersectionSegment._CSFDB_GetIntRes2d_IntersectionSegmentlast = new_instancemethod(_IntRes2d.IntRes2d_IntersectionSegment__CSFDB_GetIntRes2d_IntersectionSegmentlast,None,IntRes2d_IntersectionSegment)
  IntRes2d_IntersectionSegment._CSFDB_SetIntRes2d_IntersectionSegmentlast = new_instancemethod(_IntRes2d.IntRes2d_IntersectionSegment__CSFDB_SetIntRes2d_IntersectionSegmentlast,None,IntRes2d_IntersectionSegment)
  IntRes2d_IntersectionSegment._CSFDB_GetIntRes2d_IntersectionSegmentptfirst = new_instancemethod(_IntRes2d.IntRes2d_IntersectionSegment__CSFDB_GetIntRes2d_IntersectionSegmentptfirst,None,IntRes2d_IntersectionSegment)
  IntRes2d_IntersectionSegment._CSFDB_GetIntRes2d_IntersectionSegmentptlast = new_instancemethod(_IntRes2d.IntRes2d_IntersectionSegment__CSFDB_GetIntRes2d_IntersectionSegmentptlast,None,IntRes2d_IntersectionSegment)
  IntRes2d_IntersectionSegment._kill_pointed = new_instancemethod(_IntRes2d.IntRes2d_IntersectionSegment__kill_pointed,None,IntRes2d_IntersectionSegment)
  IntRes2d_IntersectionSegment_swigregister = _IntRes2d.IntRes2d_IntersectionSegment_swigregister
  IntRes2d_IntersectionSegment_swigregister(IntRes2d_IntersectionSegment)
  
  class IntRes2d_SequenceNodeOfSequenceOfIntersectionPoint(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: IntRes2d_IntersectionPoint &
          :param n:
          :type n: TCollection_SeqNodePtr &
          :param p:
          :type p: TCollection_SeqNodePtr &
          :rtype: None
  
          """
          _IntRes2d.IntRes2d_SequenceNodeOfSequenceOfIntersectionPoint_swiginit(self,_IntRes2d.new_IntRes2d_SequenceNodeOfSequenceOfIntersectionPoint(*args))
      def Value(self, *args):
          """
          :rtype: IntRes2d_IntersectionPoint
  
          """
          return _IntRes2d.IntRes2d_SequenceNodeOfSequenceOfIntersectionPoint_Value(self, *args)
  
      def _kill_pointed(self):
          """_kill_pointed(IntRes2d_SequenceNodeOfSequenceOfIntersectionPoint self)"""
          return _IntRes2d.IntRes2d_SequenceNodeOfSequenceOfIntersectionPoint__kill_pointed(self)
  
      def GetHandle(self):
          """GetHandle(IntRes2d_SequenceNodeOfSequenceOfIntersectionPoint self) -> Handle_IntRes2d_SequenceNodeOfSequenceOfIntersectionPoint"""
          return _IntRes2d.IntRes2d_SequenceNodeOfSequenceOfIntersectionPoint_GetHandle(self)
  
      def __del__(self):
      	try:
      		self.thisown = False
      		GarbageCollector.garbage.collect_object(self)
      	except:
      		pass
  
  
  IntRes2d_SequenceNodeOfSequenceOfIntersectionPoint.Value = new_instancemethod(_IntRes2d.IntRes2d_SequenceNodeOfSequenceOfIntersectionPoint_Value,None,IntRes2d_SequenceNodeOfSequenceOfIntersectionPoint)
  IntRes2d_SequenceNodeOfSequenceOfIntersectionPoint._kill_pointed = new_instancemethod(_IntRes2d.IntRes2d_SequenceNodeOfSequenceOfIntersectionPoint__kill_pointed,None,IntRes2d_SequenceNodeOfSequenceOfIntersectionPoint)
  IntRes2d_SequenceNodeOfSequenceOfIntersectionPoint.GetHandle = new_instancemethod(_IntRes2d.IntRes2d_SequenceNodeOfSequenceOfIntersectionPoint_GetHandle,None,IntRes2d_SequenceNodeOfSequenceOfIntersectionPoint)
  IntRes2d_SequenceNodeOfSequenceOfIntersectionPoint_swigregister = _IntRes2d.IntRes2d_SequenceNodeOfSequenceOfIntersectionPoint_swigregister
  IntRes2d_SequenceNodeOfSequenceOfIntersectionPoint_swigregister(IntRes2d_SequenceNodeOfSequenceOfIntersectionPoint)
  
  class Handle_IntRes2d_SequenceNodeOfSequenceOfIntersectionPoint(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): 
          _IntRes2d.Handle_IntRes2d_SequenceNodeOfSequenceOfIntersectionPoint_swiginit(self,_IntRes2d.new_Handle_IntRes2d_SequenceNodeOfSequenceOfIntersectionPoint(*args))
      DownCast = staticmethod(_IntRes2d.Handle_IntRes2d_SequenceNodeOfSequenceOfIntersectionPoint_DownCast)
      def __del__(self):
          try:
              self.thisown = False
              GarbageCollector.garbage.collect_object(self)
          except:
              pass
  
  
  Handle_IntRes2d_SequenceNodeOfSequenceOfIntersectionPoint.Nullify = new_instancemethod(_IntRes2d.Handle_IntRes2d_SequenceNodeOfSequenceOfIntersectionPoint_Nullify,None,Handle_IntRes2d_SequenceNodeOfSequenceOfIntersectionPoint)
  Handle_IntRes2d_SequenceNodeOfSequenceOfIntersectionPoint.IsNull = new_instancemethod(_IntRes2d.Handle_IntRes2d_SequenceNodeOfSequenceOfIntersectionPoint_IsNull,None,Handle_IntRes2d_SequenceNodeOfSequenceOfIntersectionPoint)
  Handle_IntRes2d_SequenceNodeOfSequenceOfIntersectionPoint.GetObject = new_instancemethod(_IntRes2d.Handle_IntRes2d_SequenceNodeOfSequenceOfIntersectionPoint_GetObject,None,Handle_IntRes2d_SequenceNodeOfSequenceOfIntersectionPoint)
  Handle_IntRes2d_SequenceNodeOfSequenceOfIntersectionPoint._kill_pointed = new_instancemethod(_IntRes2d.Handle_IntRes2d_SequenceNodeOfSequenceOfIntersectionPoint__kill_pointed,None,Handle_IntRes2d_SequenceNodeOfSequenceOfIntersectionPoint)
  Handle_IntRes2d_SequenceNodeOfSequenceOfIntersectionPoint_swigregister = _IntRes2d.Handle_IntRes2d_SequenceNodeOfSequenceOfIntersectionPoint_swigregister
  Handle_IntRes2d_SequenceNodeOfSequenceOfIntersectionPoint_swigregister(Handle_IntRes2d_SequenceNodeOfSequenceOfIntersectionPoint)
  
  def Handle_IntRes2d_SequenceNodeOfSequenceOfIntersectionPoint_DownCast(*args):
    return _IntRes2d.Handle_IntRes2d_SequenceNodeOfSequenceOfIntersectionPoint_DownCast(*args)
  Handle_IntRes2d_SequenceNodeOfSequenceOfIntersectionPoint_DownCast = _IntRes2d.Handle_IntRes2d_SequenceNodeOfSequenceOfIntersectionPoint_DownCast
  
  class IntRes2d_SequenceNodeOfSequenceOfIntersectionSegment(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: IntRes2d_IntersectionSegment &
          :param n:
          :type n: TCollection_SeqNodePtr &
          :param p:
          :type p: TCollection_SeqNodePtr &
          :rtype: None
  
          """
          _IntRes2d.IntRes2d_SequenceNodeOfSequenceOfIntersectionSegment_swiginit(self,_IntRes2d.new_IntRes2d_SequenceNodeOfSequenceOfIntersectionSegment(*args))
      def Value(self, *args):
          """
          :rtype: IntRes2d_IntersectionSegment
  
          """
          return _IntRes2d.IntRes2d_SequenceNodeOfSequenceOfIntersectionSegment_Value(self, *args)
  
      def _kill_pointed(self):
          """_kill_pointed(IntRes2d_SequenceNodeOfSequenceOfIntersectionSegment self)"""
          return _IntRes2d.IntRes2d_SequenceNodeOfSequenceOfIntersectionSegment__kill_pointed(self)
  
      def GetHandle(self):
          """GetHandle(IntRes2d_SequenceNodeOfSequenceOfIntersectionSegment self) -> Handle_IntRes2d_SequenceNodeOfSequenceOfIntersectionSegment"""
          return _IntRes2d.IntRes2d_SequenceNodeOfSequenceOfIntersectionSegment_GetHandle(self)
  
      def __del__(self):
      	try:
      		self.thisown = False
      		GarbageCollector.garbage.collect_object(self)
      	except:
      		pass
  
  
  IntRes2d_SequenceNodeOfSequenceOfIntersectionSegment.Value = new_instancemethod(_IntRes2d.IntRes2d_SequenceNodeOfSequenceOfIntersectionSegment_Value,None,IntRes2d_SequenceNodeOfSequenceOfIntersectionSegment)
  IntRes2d_SequenceNodeOfSequenceOfIntersectionSegment._kill_pointed = new_instancemethod(_IntRes2d.IntRes2d_SequenceNodeOfSequenceOfIntersectionSegment__kill_pointed,None,IntRes2d_SequenceNodeOfSequenceOfIntersectionSegment)
  IntRes2d_SequenceNodeOfSequenceOfIntersectionSegment.GetHandle = new_instancemethod(_IntRes2d.IntRes2d_SequenceNodeOfSequenceOfIntersectionSegment_GetHandle,None,IntRes2d_SequenceNodeOfSequenceOfIntersectionSegment)
  IntRes2d_SequenceNodeOfSequenceOfIntersectionSegment_swigregister = _IntRes2d.IntRes2d_SequenceNodeOfSequenceOfIntersectionSegment_swigregister
  IntRes2d_SequenceNodeOfSequenceOfIntersectionSegment_swigregister(IntRes2d_SequenceNodeOfSequenceOfIntersectionSegment)
  
  class Handle_IntRes2d_SequenceNodeOfSequenceOfIntersectionSegment(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): 
          _IntRes2d.Handle_IntRes2d_SequenceNodeOfSequenceOfIntersectionSegment_swiginit(self,_IntRes2d.new_Handle_IntRes2d_SequenceNodeOfSequenceOfIntersectionSegment(*args))
      DownCast = staticmethod(_IntRes2d.Handle_IntRes2d_SequenceNodeOfSequenceOfIntersectionSegment_DownCast)
      def __del__(self):
          try:
              self.thisown = False
              GarbageCollector.garbage.collect_object(self)
          except:
              pass
  
  
  Handle_IntRes2d_SequenceNodeOfSequenceOfIntersectionSegment.Nullify = new_instancemethod(_IntRes2d.Handle_IntRes2d_SequenceNodeOfSequenceOfIntersectionSegment_Nullify,None,Handle_IntRes2d_SequenceNodeOfSequenceOfIntersectionSegment)
  Handle_IntRes2d_SequenceNodeOfSequenceOfIntersectionSegment.IsNull = new_instancemethod(_IntRes2d.Handle_IntRes2d_SequenceNodeOfSequenceOfIntersectionSegment_IsNull,None,Handle_IntRes2d_SequenceNodeOfSequenceOfIntersectionSegment)
  Handle_IntRes2d_SequenceNodeOfSequenceOfIntersectionSegment.GetObject = new_instancemethod(_IntRes2d.Handle_IntRes2d_SequenceNodeOfSequenceOfIntersectionSegment_GetObject,None,Handle_IntRes2d_SequenceNodeOfSequenceOfIntersectionSegment)
  Handle_IntRes2d_SequenceNodeOfSequenceOfIntersectionSegment._kill_pointed = new_instancemethod(_IntRes2d.Handle_IntRes2d_SequenceNodeOfSequenceOfIntersectionSegment__kill_pointed,None,Handle_IntRes2d_SequenceNodeOfSequenceOfIntersectionSegment)
  Handle_IntRes2d_SequenceNodeOfSequenceOfIntersectionSegment_swigregister = _IntRes2d.Handle_IntRes2d_SequenceNodeOfSequenceOfIntersectionSegment_swigregister
  Handle_IntRes2d_SequenceNodeOfSequenceOfIntersectionSegment_swigregister(Handle_IntRes2d_SequenceNodeOfSequenceOfIntersectionSegment)
  
  def Handle_IntRes2d_SequenceNodeOfSequenceOfIntersectionSegment_DownCast(*args):
    return _IntRes2d.Handle_IntRes2d_SequenceNodeOfSequenceOfIntersectionSegment_DownCast(*args)
  Handle_IntRes2d_SequenceNodeOfSequenceOfIntersectionSegment_DownCast = _IntRes2d.Handle_IntRes2d_SequenceNodeOfSequenceOfIntersectionSegment_DownCast
  
  class IntRes2d_SequenceOfIntersectionPoint(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
  
          """
          _IntRes2d.IntRes2d_SequenceOfIntersectionPoint_swiginit(self,_IntRes2d.new_IntRes2d_SequenceOfIntersectionPoint(*args))
      def Clear(self, *args):
          """
          :rtype: None
  
          """
          return _IntRes2d.IntRes2d_SequenceOfIntersectionPoint_Clear(self, *args)
  
      def Assign(self, *args):
          """
          :param Other:
          :type Other: IntRes2d_SequenceOfIntersectionPoint &
          :rtype: IntRes2d_SequenceOfIntersectionPoint
  
          """
          return _IntRes2d.IntRes2d_SequenceOfIntersectionPoint_Assign(self, *args)
  
      def Set(self, *args):
          """
          :param Other:
          :type Other: IntRes2d_SequenceOfIntersectionPoint &
          :rtype: IntRes2d_SequenceOfIntersectionPoint
  
          """
          return _IntRes2d.IntRes2d_SequenceOfIntersectionPoint_Set(self, *args)
  
      def Append(self, *args):
          """
          :param T:
          :type T: IntRes2d_IntersectionPoint &
          :rtype: None
  
          :param S:
          :type S: IntRes2d_SequenceOfIntersectionPoint &
          :rtype: None
  
          """
          return _IntRes2d.IntRes2d_SequenceOfIntersectionPoint_Append(self, *args)
  
      def Prepend(self, *args):
          """
          :param T:
          :type T: IntRes2d_IntersectionPoint &
          :rtype: None
  
          :param S:
          :type S: IntRes2d_SequenceOfIntersectionPoint &
          :rtype: None
  
          """
          return _IntRes2d.IntRes2d_SequenceOfIntersectionPoint_Prepend(self, *args)
  
      def InsertBefore(self, *args):
          """
          :param Index:
          :type Index: int
          :param T:
          :type T: IntRes2d_IntersectionPoint &
          :rtype: None
  
          :param Index:
          :type Index: int
          :param S:
          :type S: IntRes2d_SequenceOfIntersectionPoint &
          :rtype: None
  
          """
          return _IntRes2d.IntRes2d_SequenceOfIntersectionPoint_InsertBefore(self, *args)
  
      def InsertAfter(self, *args):
          """
          :param Index:
          :type Index: int
          :param T:
          :type T: IntRes2d_IntersectionPoint &
          :rtype: None
  
          :param Index:
          :type Index: int
          :param S:
          :type S: IntRes2d_SequenceOfIntersectionPoint &
          :rtype: None
  
          """
          return _IntRes2d.IntRes2d_SequenceOfIntersectionPoint_InsertAfter(self, *args)
  
      def First(self, *args):
          """
          :rtype: IntRes2d_IntersectionPoint
  
          """
          return _IntRes2d.IntRes2d_SequenceOfIntersectionPoint_First(self, *args)
  
      def Last(self, *args):
          """
          :rtype: IntRes2d_IntersectionPoint
  
          """
          return _IntRes2d.IntRes2d_SequenceOfIntersectionPoint_Last(self, *args)
  
      def Split(self, *args):
          """
          :param Index:
          :type Index: int
          :param Sub:
          :type Sub: IntRes2d_SequenceOfIntersectionPoint &
          :rtype: None
  
          """
          return _IntRes2d.IntRes2d_SequenceOfIntersectionPoint_Split(self, *args)
  
      def Value(self, *args):
          """
          :param Index:
          :type Index: int
          :rtype: IntRes2d_IntersectionPoint
  
          """
          return _IntRes2d.IntRes2d_SequenceOfIntersectionPoint_Value(self, *args)
  
      def SetValue(self, *args):
          """
          :param Index:
          :type Index: int
          :param I:
          :type I: IntRes2d_IntersectionPoint &
          :rtype: None
  
          """
          return _IntRes2d.IntRes2d_SequenceOfIntersectionPoint_SetValue(self, *args)
  
      def ChangeValue(self, *args):
          """
          :param Index:
          :type Index: int
          :rtype: IntRes2d_IntersectionPoint
  
          """
          return _IntRes2d.IntRes2d_SequenceOfIntersectionPoint_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 _IntRes2d.IntRes2d_SequenceOfIntersectionPoint_Remove(self, *args)
  
      def __del__(self):
      	try:
      		self.thisown = False
      		GarbageCollector.garbage.collect_object(self)
      	except:
      		pass
  
  
  IntRes2d_SequenceOfIntersectionPoint.Clear = new_instancemethod(_IntRes2d.IntRes2d_SequenceOfIntersectionPoint_Clear,None,IntRes2d_SequenceOfIntersectionPoint)
  IntRes2d_SequenceOfIntersectionPoint.Assign = new_instancemethod(_IntRes2d.IntRes2d_SequenceOfIntersectionPoint_Assign,None,IntRes2d_SequenceOfIntersectionPoint)
  IntRes2d_SequenceOfIntersectionPoint.Set = new_instancemethod(_IntRes2d.IntRes2d_SequenceOfIntersectionPoint_Set,None,IntRes2d_SequenceOfIntersectionPoint)
  IntRes2d_SequenceOfIntersectionPoint.Append = new_instancemethod(_IntRes2d.IntRes2d_SequenceOfIntersectionPoint_Append,None,IntRes2d_SequenceOfIntersectionPoint)
  IntRes2d_SequenceOfIntersectionPoint.Prepend = new_instancemethod(_IntRes2d.IntRes2d_SequenceOfIntersectionPoint_Prepend,None,IntRes2d_SequenceOfIntersectionPoint)
  IntRes2d_SequenceOfIntersectionPoint.InsertBefore = new_instancemethod(_IntRes2d.IntRes2d_SequenceOfIntersectionPoint_InsertBefore,None,IntRes2d_SequenceOfIntersectionPoint)
  IntRes2d_SequenceOfIntersectionPoint.InsertAfter = new_instancemethod(_IntRes2d.IntRes2d_SequenceOfIntersectionPoint_InsertAfter,None,IntRes2d_SequenceOfIntersectionPoint)
  IntRes2d_SequenceOfIntersectionPoint.First = new_instancemethod(_IntRes2d.IntRes2d_SequenceOfIntersectionPoint_First,None,IntRes2d_SequenceOfIntersectionPoint)
  IntRes2d_SequenceOfIntersectionPoint.Last = new_instancemethod(_IntRes2d.IntRes2d_SequenceOfIntersectionPoint_Last,None,IntRes2d_SequenceOfIntersectionPoint)
  IntRes2d_SequenceOfIntersectionPoint.Split = new_instancemethod(_IntRes2d.IntRes2d_SequenceOfIntersectionPoint_Split,None,IntRes2d_SequenceOfIntersectionPoint)
  IntRes2d_SequenceOfIntersectionPoint.Value = new_instancemethod(_IntRes2d.IntRes2d_SequenceOfIntersectionPoint_Value,None,IntRes2d_SequenceOfIntersectionPoint)
  IntRes2d_SequenceOfIntersectionPoint.SetValue = new_instancemethod(_IntRes2d.IntRes2d_SequenceOfIntersectionPoint_SetValue,None,IntRes2d_SequenceOfIntersectionPoint)
  IntRes2d_SequenceOfIntersectionPoint.ChangeValue = new_instancemethod(_IntRes2d.IntRes2d_SequenceOfIntersectionPoint_ChangeValue,None,IntRes2d_SequenceOfIntersectionPoint)
  IntRes2d_SequenceOfIntersectionPoint.Remove = new_instancemethod(_IntRes2d.IntRes2d_SequenceOfIntersectionPoint_Remove,None,IntRes2d_SequenceOfIntersectionPoint)
  IntRes2d_SequenceOfIntersectionPoint._kill_pointed = new_instancemethod(_IntRes2d.IntRes2d_SequenceOfIntersectionPoint__kill_pointed,None,IntRes2d_SequenceOfIntersectionPoint)
  IntRes2d_SequenceOfIntersectionPoint_swigregister = _IntRes2d.IntRes2d_SequenceOfIntersectionPoint_swigregister
  IntRes2d_SequenceOfIntersectionPoint_swigregister(IntRes2d_SequenceOfIntersectionPoint)
  
  class IntRes2d_SequenceOfIntersectionSegment(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
  
          """
          _IntRes2d.IntRes2d_SequenceOfIntersectionSegment_swiginit(self,_IntRes2d.new_IntRes2d_SequenceOfIntersectionSegment(*args))
      def Clear(self, *args):
          """
          :rtype: None
  
          """
          return _IntRes2d.IntRes2d_SequenceOfIntersectionSegment_Clear(self, *args)
  
      def Assign(self, *args):
          """
          :param Other:
          :type Other: IntRes2d_SequenceOfIntersectionSegment &
          :rtype: IntRes2d_SequenceOfIntersectionSegment
  
          """
          return _IntRes2d.IntRes2d_SequenceOfIntersectionSegment_Assign(self, *args)
  
      def Set(self, *args):
          """
          :param Other:
          :type Other: IntRes2d_SequenceOfIntersectionSegment &
          :rtype: IntRes2d_SequenceOfIntersectionSegment
  
          """
          return _IntRes2d.IntRes2d_SequenceOfIntersectionSegment_Set(self, *args)
  
      def Append(self, *args):
          """
          :param T:
          :type T: IntRes2d_IntersectionSegment &
          :rtype: None
  
          :param S:
          :type S: IntRes2d_SequenceOfIntersectionSegment &
          :rtype: None
  
          """
          return _IntRes2d.IntRes2d_SequenceOfIntersectionSegment_Append(self, *args)
  
      def Prepend(self, *args):
          """
          :param T:
          :type T: IntRes2d_IntersectionSegment &
          :rtype: None
  
          :param S:
          :type S: IntRes2d_SequenceOfIntersectionSegment &
          :rtype: None
  
          """
          return _IntRes2d.IntRes2d_SequenceOfIntersectionSegment_Prepend(self, *args)
  
      def InsertBefore(self, *args):
          """
          :param Index:
          :type Index: int
          :param T:
          :type T: IntRes2d_IntersectionSegment &
          :rtype: None
  
          :param Index:
          :type Index: int
          :param S:
          :type S: IntRes2d_SequenceOfIntersectionSegment &
          :rtype: None
  
          """
          return _IntRes2d.IntRes2d_SequenceOfIntersectionSegment_InsertBefore(self, *args)
  
      def InsertAfter(self, *args):
          """
          :param Index:
          :type Index: int
          :param T:
          :type T: IntRes2d_IntersectionSegment &
          :rtype: None
  
          :param Index:
          :type Index: int
          :param S:
          :type S: IntRes2d_SequenceOfIntersectionSegment &
          :rtype: None
  
          """
          return _IntRes2d.IntRes2d_SequenceOfIntersectionSegment_InsertAfter(self, *args)
  
      def First(self, *args):
          """
          :rtype: IntRes2d_IntersectionSegment
  
          """
          return _IntRes2d.IntRes2d_SequenceOfIntersectionSegment_First(self, *args)
  
      def Last(self, *args):
          """
          :rtype: IntRes2d_IntersectionSegment
  
          """
          return _IntRes2d.IntRes2d_SequenceOfIntersectionSegment_Last(self, *args)
  
      def Split(self, *args):
          """
          :param Index:
          :type Index: int
          :param Sub:
          :type Sub: IntRes2d_SequenceOfIntersectionSegment &
          :rtype: None
  
          """
          return _IntRes2d.IntRes2d_SequenceOfIntersectionSegment_Split(self, *args)
  
      def Value(self, *args):
          """
          :param Index:
          :type Index: int
          :rtype: IntRes2d_IntersectionSegment
  
          """
          return _IntRes2d.IntRes2d_SequenceOfIntersectionSegment_Value(self, *args)
  
      def SetValue(self, *args):
          """
          :param Index:
          :type Index: int
          :param I:
          :type I: IntRes2d_IntersectionSegment &
          :rtype: None
  
          """
          return _IntRes2d.IntRes2d_SequenceOfIntersectionSegment_SetValue(self, *args)
  
      def ChangeValue(self, *args):
          """
          :param Index:
          :type Index: int
          :rtype: IntRes2d_IntersectionSegment
  
          """
          return _IntRes2d.IntRes2d_SequenceOfIntersectionSegment_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 _IntRes2d.IntRes2d_SequenceOfIntersectionSegment_Remove(self, *args)
  
      def __del__(self):
      	try:
      		self.thisown = False
      		GarbageCollector.garbage.collect_object(self)
      	except:
      		pass
  
  
  IntRes2d_SequenceOfIntersectionSegment.Clear = new_instancemethod(_IntRes2d.IntRes2d_SequenceOfIntersectionSegment_Clear,None,IntRes2d_SequenceOfIntersectionSegment)
  IntRes2d_SequenceOfIntersectionSegment.Assign = new_instancemethod(_IntRes2d.IntRes2d_SequenceOfIntersectionSegment_Assign,None,IntRes2d_SequenceOfIntersectionSegment)
  IntRes2d_SequenceOfIntersectionSegment.Set = new_instancemethod(_IntRes2d.IntRes2d_SequenceOfIntersectionSegment_Set,None,IntRes2d_SequenceOfIntersectionSegment)
  IntRes2d_SequenceOfIntersectionSegment.Append = new_instancemethod(_IntRes2d.IntRes2d_SequenceOfIntersectionSegment_Append,None,IntRes2d_SequenceOfIntersectionSegment)
  IntRes2d_SequenceOfIntersectionSegment.Prepend = new_instancemethod(_IntRes2d.IntRes2d_SequenceOfIntersectionSegment_Prepend,None,IntRes2d_SequenceOfIntersectionSegment)
  IntRes2d_SequenceOfIntersectionSegment.InsertBefore = new_instancemethod(_IntRes2d.IntRes2d_SequenceOfIntersectionSegment_InsertBefore,None,IntRes2d_SequenceOfIntersectionSegment)
  IntRes2d_SequenceOfIntersectionSegment.InsertAfter = new_instancemethod(_IntRes2d.IntRes2d_SequenceOfIntersectionSegment_InsertAfter,None,IntRes2d_SequenceOfIntersectionSegment)
  IntRes2d_SequenceOfIntersectionSegment.First = new_instancemethod(_IntRes2d.IntRes2d_SequenceOfIntersectionSegment_First,None,IntRes2d_SequenceOfIntersectionSegment)
  IntRes2d_SequenceOfIntersectionSegment.Last = new_instancemethod(_IntRes2d.IntRes2d_SequenceOfIntersectionSegment_Last,None,IntRes2d_SequenceOfIntersectionSegment)
  IntRes2d_SequenceOfIntersectionSegment.Split = new_instancemethod(_IntRes2d.IntRes2d_SequenceOfIntersectionSegment_Split,None,IntRes2d_SequenceOfIntersectionSegment)
  IntRes2d_SequenceOfIntersectionSegment.Value = new_instancemethod(_IntRes2d.IntRes2d_SequenceOfIntersectionSegment_Value,None,IntRes2d_SequenceOfIntersectionSegment)
  IntRes2d_SequenceOfIntersectionSegment.SetValue = new_instancemethod(_IntRes2d.IntRes2d_SequenceOfIntersectionSegment_SetValue,None,IntRes2d_SequenceOfIntersectionSegment)
  IntRes2d_SequenceOfIntersectionSegment.ChangeValue = new_instancemethod(_IntRes2d.IntRes2d_SequenceOfIntersectionSegment_ChangeValue,None,IntRes2d_SequenceOfIntersectionSegment)
  IntRes2d_SequenceOfIntersectionSegment.Remove = new_instancemethod(_IntRes2d.IntRes2d_SequenceOfIntersectionSegment_Remove,None,IntRes2d_SequenceOfIntersectionSegment)
  IntRes2d_SequenceOfIntersectionSegment._kill_pointed = new_instancemethod(_IntRes2d.IntRes2d_SequenceOfIntersectionSegment__kill_pointed,None,IntRes2d_SequenceOfIntersectionSegment)
  IntRes2d_SequenceOfIntersectionSegment_swigregister = _IntRes2d.IntRes2d_SequenceOfIntersectionSegment_swigregister
  IntRes2d_SequenceOfIntersectionSegment_swigregister(IntRes2d_SequenceOfIntersectionSegment)
  
  class IntRes2d_Transition(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
  
          * Creates an IN or OUT transition.
  
          :param Tangent:
          :type Tangent: bool
          :param Pos:
          :type Pos: IntRes2d_Position
          :param Type:
          :type Type: IntRes2d_TypeTrans
          :rtype: None
  
          * Creates a TOUCH transition.
  
          :param Tangent:
          :type Tangent: bool
          :param Pos:
          :type Pos: IntRes2d_Position
          :param Situ:
          :type Situ: IntRes2d_Situation
          :param Oppos:
          :type Oppos: bool
          :rtype: None
  
          * Creates an UNDECIDED transition.
  
          :param Pos:
          :type Pos: IntRes2d_Position
          :rtype: None
  
          """
          _IntRes2d.IntRes2d_Transition_swiginit(self,_IntRes2d.new_IntRes2d_Transition(*args))
      def SetValue(self, *args):
          """
          * Sets the values of an IN or OUT transition.
  
          :param Tangent:
          :type Tangent: bool
          :param Pos:
          :type Pos: IntRes2d_Position
          :param Type:
          :type Type: IntRes2d_TypeTrans
          :rtype: None
  
          * Sets the values of a TOUCH transition.
  
          :param Tangent:
          :type Tangent: bool
          :param Pos:
          :type Pos: IntRes2d_Position
          :param Situ:
          :type Situ: IntRes2d_Situation
          :param Oppos:
          :type Oppos: bool
          :rtype: None
  
          * Sets the values of an UNDECIDED transition.
  
          :param Pos:
          :type Pos: IntRes2d_Position
          :rtype: None
  
          """
          return _IntRes2d.IntRes2d_Transition_SetValue(self, *args)
  
      def SetPosition(self, *args):
          """
          * Sets the value of the position.
  
          :param Pos:
          :type Pos: IntRes2d_Position
          :rtype: None
  
          """
          return _IntRes2d.IntRes2d_Transition_SetPosition(self, *args)
  
      def PositionOnCurve(self, *args):
          """
          * Indicates if the intersection is at the beginning (IntRes2d_Head), at the end (IntRes2d_End), or in the middle (IntRes2d_Middle) of the curve.
  
          :rtype: IntRes2d_Position
  
          """
          return _IntRes2d.IntRes2d_Transition_PositionOnCurve(self, *args)
  
      def TransitionType(self, *args):
          """
          * Returns the type of transition at the intersection. It may be IN or OUT or TOUCH, or UNDECIDED if the two first derivatives are not enough to give the tangent to one of the two curves.
  
          :rtype: IntRes2d_TypeTrans
  
          """
          return _IntRes2d.IntRes2d_Transition_TransitionType(self, *args)
  
      def IsTangent(self, *args):
          """
          * Returns True when the 2 curves are tangent at the intersection point. Theexception DomainError is raised if the type of transition is UNDECIDED.
  
          :rtype: bool
  
          """
          return _IntRes2d.IntRes2d_Transition_IsTangent(self, *args)
  
      def Situation(self, *args):
          """
          * returns a significant value if TransitionType returns TOUCH. In this case, the function returns : INSIDE when the curve remains inside the other one, OUTSIDE when it remains outside the other one, UNKNOWN when the calculus, based on the second derivatives cannot give the result. If TransitionType returns IN or OUT or UNDECIDED, the exception DomainError is raised.
  
          :rtype: IntRes2d_Situation
  
          """
          return _IntRes2d.IntRes2d_Transition_Situation(self, *args)
  
      def IsOpposite(self, *args):
          """
          * returns a significant value if TransitionType returns TOUCH. In this case, the function returns true when the 2 curves locally define two different parts of the space. If TransitionType returns IN or OUT or UNDECIDED, the exception DomainError is raised.
  
          :rtype: bool
  
          """
          return _IntRes2d.IntRes2d_Transition_IsOpposite(self, *args)
  
      def _CSFDB_GetIntRes2d_Transitiontangent(self, *args):
          """
          :rtype: bool
  
          """
          return _IntRes2d.IntRes2d_Transition__CSFDB_GetIntRes2d_Transitiontangent(self, *args)
  
      def _CSFDB_SetIntRes2d_Transitiontangent(self, *args):
          """
          :param p:
          :type p: bool
          :rtype: None
  
          """
          return _IntRes2d.IntRes2d_Transition__CSFDB_SetIntRes2d_Transitiontangent(self, *args)
  
      def _CSFDB_GetIntRes2d_Transitionposit(self, *args):
          """
          :rtype: IntRes2d_Position
  
          """
          return _IntRes2d.IntRes2d_Transition__CSFDB_GetIntRes2d_Transitionposit(self, *args)
  
      def _CSFDB_SetIntRes2d_Transitionposit(self, *args):
          """
          :param p:
          :type p: IntRes2d_Position
          :rtype: None
  
          """
          return _IntRes2d.IntRes2d_Transition__CSFDB_SetIntRes2d_Transitionposit(self, *args)
  
      def _CSFDB_GetIntRes2d_Transitiontypetra(self, *args):
          """
          :rtype: IntRes2d_TypeTrans
  
          """
          return _IntRes2d.IntRes2d_Transition__CSFDB_GetIntRes2d_Transitiontypetra(self, *args)
  
      def _CSFDB_SetIntRes2d_Transitiontypetra(self, *args):
          """
          :param p:
          :type p: IntRes2d_TypeTrans
          :rtype: None
  
          """
          return _IntRes2d.IntRes2d_Transition__CSFDB_SetIntRes2d_Transitiontypetra(self, *args)
  
      def _CSFDB_GetIntRes2d_Transitionsituat(self, *args):
          """
          :rtype: IntRes2d_Situation
  
          """
          return _IntRes2d.IntRes2d_Transition__CSFDB_GetIntRes2d_Transitionsituat(self, *args)
  
      def _CSFDB_SetIntRes2d_Transitionsituat(self, *args):
          """
          :param p:
          :type p: IntRes2d_Situation
          :rtype: None
  
          """
          return _IntRes2d.IntRes2d_Transition__CSFDB_SetIntRes2d_Transitionsituat(self, *args)
  
      def _CSFDB_GetIntRes2d_Transitionoppos(self, *args):
          """
          :rtype: bool
  
          """
          return _IntRes2d.IntRes2d_Transition__CSFDB_GetIntRes2d_Transitionoppos(self, *args)
  
      def _CSFDB_SetIntRes2d_Transitionoppos(self, *args):
          """
          :param p:
          :type p: bool
          :rtype: None
  
          """
          return _IntRes2d.IntRes2d_Transition__CSFDB_SetIntRes2d_Transitionoppos(self, *args)
  
      def __del__(self):
      	try:
      		self.thisown = False
      		GarbageCollector.garbage.collect_object(self)
      	except:
      		pass
  
  
  IntRes2d_Transition.SetValue = new_instancemethod(_IntRes2d.IntRes2d_Transition_SetValue,None,IntRes2d_Transition)
  IntRes2d_Transition.SetPosition = new_instancemethod(_IntRes2d.IntRes2d_Transition_SetPosition,None,IntRes2d_Transition)
  IntRes2d_Transition.PositionOnCurve = new_instancemethod(_IntRes2d.IntRes2d_Transition_PositionOnCurve,None,IntRes2d_Transition)
  IntRes2d_Transition.TransitionType = new_instancemethod(_IntRes2d.IntRes2d_Transition_TransitionType,None,IntRes2d_Transition)
  IntRes2d_Transition.IsTangent = new_instancemethod(_IntRes2d.IntRes2d_Transition_IsTangent,None,IntRes2d_Transition)
  IntRes2d_Transition.Situation = new_instancemethod(_IntRes2d.IntRes2d_Transition_Situation,None,IntRes2d_Transition)
  IntRes2d_Transition.IsOpposite = new_instancemethod(_IntRes2d.IntRes2d_Transition_IsOpposite,None,IntRes2d_Transition)
  IntRes2d_Transition._CSFDB_GetIntRes2d_Transitiontangent = new_instancemethod(_IntRes2d.IntRes2d_Transition__CSFDB_GetIntRes2d_Transitiontangent,None,IntRes2d_Transition)
  IntRes2d_Transition._CSFDB_SetIntRes2d_Transitiontangent = new_instancemethod(_IntRes2d.IntRes2d_Transition__CSFDB_SetIntRes2d_Transitiontangent,None,IntRes2d_Transition)
  IntRes2d_Transition._CSFDB_GetIntRes2d_Transitionposit = new_instancemethod(_IntRes2d.IntRes2d_Transition__CSFDB_GetIntRes2d_Transitionposit,None,IntRes2d_Transition)
  IntRes2d_Transition._CSFDB_SetIntRes2d_Transitionposit = new_instancemethod(_IntRes2d.IntRes2d_Transition__CSFDB_SetIntRes2d_Transitionposit,None,IntRes2d_Transition)
  IntRes2d_Transition._CSFDB_GetIntRes2d_Transitiontypetra = new_instancemethod(_IntRes2d.IntRes2d_Transition__CSFDB_GetIntRes2d_Transitiontypetra,None,IntRes2d_Transition)
  IntRes2d_Transition._CSFDB_SetIntRes2d_Transitiontypetra = new_instancemethod(_IntRes2d.IntRes2d_Transition__CSFDB_SetIntRes2d_Transitiontypetra,None,IntRes2d_Transition)
  IntRes2d_Transition._CSFDB_GetIntRes2d_Transitionsituat = new_instancemethod(_IntRes2d.IntRes2d_Transition__CSFDB_GetIntRes2d_Transitionsituat,None,IntRes2d_Transition)
  IntRes2d_Transition._CSFDB_SetIntRes2d_Transitionsituat = new_instancemethod(_IntRes2d.IntRes2d_Transition__CSFDB_SetIntRes2d_Transitionsituat,None,IntRes2d_Transition)
  IntRes2d_Transition._CSFDB_GetIntRes2d_Transitionoppos = new_instancemethod(_IntRes2d.IntRes2d_Transition__CSFDB_GetIntRes2d_Transitionoppos,None,IntRes2d_Transition)
  IntRes2d_Transition._CSFDB_SetIntRes2d_Transitionoppos = new_instancemethod(_IntRes2d.IntRes2d_Transition__CSFDB_SetIntRes2d_Transitionoppos,None,IntRes2d_Transition)
  IntRes2d_Transition._kill_pointed = new_instancemethod(_IntRes2d.IntRes2d_Transition__kill_pointed,None,IntRes2d_Transition)
  IntRes2d_Transition_swigregister = _IntRes2d.IntRes2d_Transition_swigregister
  IntRes2d_Transition_swigregister(IntRes2d_Transition)
  
  
  
  