# This file was automatically generated by SWIG (https://www.swig.org).
# Version 4.2.1
#
# Do not make changes to this file unless you know what you are doing - modify
# the SWIG interface file instead.

"""
IntRes2d module, see official documentation at
https://www.opencascade.com/doc/occt-7.7.0/refman/html/package_intres2d.html
"""

from sys import version_info as _swig_python_version_info
# Import the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _IntRes2d
else:
    import _IntRes2d

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

def _swig_repr(self):
    try:
        strthis = "proxy of " + self.this.__repr__()
    except __builtin__.Exception:
        strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)


def _swig_setattr_nondynamic_instance_variable(set):
    def set_instance_attr(self, name, value):
        if name == "this":
            set(self, name, value)
        elif name == "thisown":
            self.this.own(value)
        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add instance attributes to %s" % self)
    return set_instance_attr


def _swig_setattr_nondynamic_class_variable(set):
    def set_class_attr(cls, name, value):
        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
            set(cls, name, value)
        else:
            raise AttributeError("You cannot add class attributes to %s" % cls)
    return set_class_attr


def _swig_add_metaclass(metaclass):
    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
    def wrapper(cls):
        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
    return wrapper


class _SwigNonDynamicMeta(type):
    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)


class SwigPyIterator(object):
    thisown = 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 value(self):
        return _IntRes2d.SwigPyIterator_value(self)

    def incr(self, n=1):
        return _IntRes2d.SwigPyIterator_incr(self, n)

    def decr(self, n=1):
        return _IntRes2d.SwigPyIterator_decr(self, n)

    def distance(self, x):
        return _IntRes2d.SwigPyIterator_distance(self, x)

    def equal(self, x):
        return _IntRes2d.SwigPyIterator_equal(self, x)

    def copy(self):
        return _IntRes2d.SwigPyIterator_copy(self)

    def next(self):
        return _IntRes2d.SwigPyIterator_next(self)

    def __next__(self):
        return _IntRes2d.SwigPyIterator___next__(self)

    def previous(self):
        return _IntRes2d.SwigPyIterator_previous(self)

    def advance(self, n):
        return _IntRes2d.SwigPyIterator_advance(self, n)

    def __eq__(self, x):
        return _IntRes2d.SwigPyIterator___eq__(self, x)

    def __ne__(self, x):
        return _IntRes2d.SwigPyIterator___ne__(self, x)

    def __iadd__(self, n):
        return _IntRes2d.SwigPyIterator___iadd__(self, n)

    def __isub__(self, n):
        return _IntRes2d.SwigPyIterator___isub__(self, n)

    def __add__(self, n):
        return _IntRes2d.SwigPyIterator___add__(self, n)

    def __sub__(self, *args):
        return _IntRes2d.SwigPyIterator___sub__(self, *args)
    def __iter__(self):
        return self

# Register SwigPyIterator in _IntRes2d:
_IntRes2d.SwigPyIterator_swigregister(SwigPyIterator)

def _dumps_object(klass):
    """ Overwrite default string output for any wrapped object.
    By default, __repr__ method returns something like:
    <OCC.Core.TopoDS.TopoDS_Shape; proxy of <Swig Object of type 'TopoDS_Shape *' at 0x02BB0758> >
    This is too much verbose.
    We prefer :
    <class 'gp_Pnt'>
    or
    <class 'TopoDS_Shape'>
    """
    klass_name = str(klass.__class__).split(".")[3].split("'")[0]
    repr_string = "<class '" + klass_name + "'"
# for TopoDS_Shape, we also look for the base type
    if klass_name == "TopoDS_Shape":
        if klass.IsNull():
            repr_string += ": Null>"
            return repr_string
        st = klass.ShapeType()
        types = {OCC.Core.TopAbs.TopAbs_VERTEX: "Vertex",
                 OCC.Core.TopAbs.TopAbs_SOLID: "Solid",
                 OCC.Core.TopAbs.TopAbs_EDGE: "Edge",
                 OCC.Core.TopAbs.TopAbs_FACE: "Face",
                 OCC.Core.TopAbs.TopAbs_SHELL: "Shell",
                 OCC.Core.TopAbs.TopAbs_WIRE: "Wire",
                 OCC.Core.TopAbs.TopAbs_COMPOUND: "Compound",
                 OCC.Core.TopAbs.TopAbs_COMPSOLID: "Compsolid"}
        repr_string += "; Type:%s" % types[st]        
    elif hasattr(klass, "IsNull"):
        if klass.IsNull():
            repr_string += "; Null"
    repr_string += ">"
    return repr_string


def process_exception(error, method_name, class_name):
    return _IntRes2d.process_exception(error, method_name, class_name)

from six import with_metaclass
import warnings
from OCC.Wrapper.wrapper_utils import Proxy, deprecated

import OCC.Core.Standard
import OCC.Core.NCollection
import OCC.Core.gp
import OCC.Core.TColStd
import OCC.Core.TCollection

from enum import IntEnum
from OCC.Core.Exception import *

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_Position(IntEnum):
	IntRes2d_Head = 0
	IntRes2d_Middle = 1
	IntRes2d_End = 2
IntRes2d_Head = IntRes2d_Position.IntRes2d_Head
IntRes2d_Middle = IntRes2d_Position.IntRes2d_Middle
IntRes2d_End = IntRes2d_Position.IntRes2d_End

class IntRes2d_Situation(IntEnum):
	IntRes2d_Inside = 0
	IntRes2d_Outside = 1
	IntRes2d_Unknown = 2
IntRes2d_Inside = IntRes2d_Situation.IntRes2d_Inside
IntRes2d_Outside = IntRes2d_Situation.IntRes2d_Outside
IntRes2d_Unknown = IntRes2d_Situation.IntRes2d_Unknown

class IntRes2d_TypeTrans(IntEnum):
	IntRes2d_In = 0
	IntRes2d_Out = 1
	IntRes2d_Touch = 2
	IntRes2d_Undecided = 3
IntRes2d_In = IntRes2d_TypeTrans.IntRes2d_In
IntRes2d_Out = IntRes2d_TypeTrans.IntRes2d_Out
IntRes2d_Touch = IntRes2d_TypeTrans.IntRes2d_Touch
IntRes2d_Undecided = IntRes2d_TypeTrans.IntRes2d_Undecided

class IntRes2d_SequenceOfIntersectionPoint(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def begin(self):
        return _IntRes2d.IntRes2d_SequenceOfIntersectionPoint_begin(self)

    def end(self):
        return _IntRes2d.IntRes2d_SequenceOfIntersectionPoint_end(self)

    def cbegin(self):
        return _IntRes2d.IntRes2d_SequenceOfIntersectionPoint_cbegin(self)

    def cend(self):
        return _IntRes2d.IntRes2d_SequenceOfIntersectionPoint_cend(self)

    def __init__(self, *args):
        _IntRes2d.IntRes2d_SequenceOfIntersectionPoint_swiginit(self, _IntRes2d.new_IntRes2d_SequenceOfIntersectionPoint(*args))

    def Size(self):
        return _IntRes2d.IntRes2d_SequenceOfIntersectionPoint_Size(self)

    def Length(self):
        return _IntRes2d.IntRes2d_SequenceOfIntersectionPoint_Length(self)

    def Lower(self):
        return _IntRes2d.IntRes2d_SequenceOfIntersectionPoint_Lower(self)

    def Upper(self):
        return _IntRes2d.IntRes2d_SequenceOfIntersectionPoint_Upper(self)

    def IsEmpty(self):
        return _IntRes2d.IntRes2d_SequenceOfIntersectionPoint_IsEmpty(self)

    def Reverse(self):
        return _IntRes2d.IntRes2d_SequenceOfIntersectionPoint_Reverse(self)

    def Exchange(self, I, J):
        return _IntRes2d.IntRes2d_SequenceOfIntersectionPoint_Exchange(self, I, J)

    @staticmethod
    def delNode(theNode, theAl):
        return _IntRes2d.IntRes2d_SequenceOfIntersectionPoint_delNode(theNode, theAl)

    def Clear(self, theAllocator=0):
        return _IntRes2d.IntRes2d_SequenceOfIntersectionPoint_Clear(self, theAllocator)

    def Assign(self, theOther):
        return _IntRes2d.IntRes2d_SequenceOfIntersectionPoint_Assign(self, theOther)

    def Set(self, theOther):
        return _IntRes2d.IntRes2d_SequenceOfIntersectionPoint_Set(self, theOther)

    def Remove(self, *args):
        return _IntRes2d.IntRes2d_SequenceOfIntersectionPoint_Remove(self, *args)

    def Append(self, *args):
        return _IntRes2d.IntRes2d_SequenceOfIntersectionPoint_Append(self, *args)

    def Prepend(self, *args):
        return _IntRes2d.IntRes2d_SequenceOfIntersectionPoint_Prepend(self, *args)

    def InsertBefore(self, *args):
        return _IntRes2d.IntRes2d_SequenceOfIntersectionPoint_InsertBefore(self, *args)

    def InsertAfter(self, *args):
        return _IntRes2d.IntRes2d_SequenceOfIntersectionPoint_InsertAfter(self, *args)

    def Split(self, theIndex, theSeq):
        return _IntRes2d.IntRes2d_SequenceOfIntersectionPoint_Split(self, theIndex, theSeq)

    def First(self):
        return _IntRes2d.IntRes2d_SequenceOfIntersectionPoint_First(self)

    def ChangeFirst(self):
        return _IntRes2d.IntRes2d_SequenceOfIntersectionPoint_ChangeFirst(self)

    def Last(self):
        return _IntRes2d.IntRes2d_SequenceOfIntersectionPoint_Last(self)

    def ChangeLast(self):
        return _IntRes2d.IntRes2d_SequenceOfIntersectionPoint_ChangeLast(self)

    def Value(self, theIndex):
        return _IntRes2d.IntRes2d_SequenceOfIntersectionPoint_Value(self, theIndex)

    def ChangeValue(self, theIndex):
        return _IntRes2d.IntRes2d_SequenceOfIntersectionPoint_ChangeValue(self, theIndex)

    def __call__(self, *args):
        return _IntRes2d.IntRes2d_SequenceOfIntersectionPoint___call__(self, *args)

    def SetValue(self, theIndex, theItem):
        return _IntRes2d.IntRes2d_SequenceOfIntersectionPoint_SetValue(self, theIndex, theItem)
    __swig_destroy__ = _IntRes2d.delete_IntRes2d_SequenceOfIntersectionPoint

    def __len__(self):
        return self.Size()


# Register IntRes2d_SequenceOfIntersectionPoint in _IntRes2d:
_IntRes2d.IntRes2d_SequenceOfIntersectionPoint_swigregister(IntRes2d_SequenceOfIntersectionPoint)
class IntRes2d_SequenceOfIntersectionSegment(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def begin(self):
        return _IntRes2d.IntRes2d_SequenceOfIntersectionSegment_begin(self)

    def end(self):
        return _IntRes2d.IntRes2d_SequenceOfIntersectionSegment_end(self)

    def cbegin(self):
        return _IntRes2d.IntRes2d_SequenceOfIntersectionSegment_cbegin(self)

    def cend(self):
        return _IntRes2d.IntRes2d_SequenceOfIntersectionSegment_cend(self)

    def __init__(self, *args):
        _IntRes2d.IntRes2d_SequenceOfIntersectionSegment_swiginit(self, _IntRes2d.new_IntRes2d_SequenceOfIntersectionSegment(*args))

    def Size(self):
        return _IntRes2d.IntRes2d_SequenceOfIntersectionSegment_Size(self)

    def Length(self):
        return _IntRes2d.IntRes2d_SequenceOfIntersectionSegment_Length(self)

    def Lower(self):
        return _IntRes2d.IntRes2d_SequenceOfIntersectionSegment_Lower(self)

    def Upper(self):
        return _IntRes2d.IntRes2d_SequenceOfIntersectionSegment_Upper(self)

    def IsEmpty(self):
        return _IntRes2d.IntRes2d_SequenceOfIntersectionSegment_IsEmpty(self)

    def Reverse(self):
        return _IntRes2d.IntRes2d_SequenceOfIntersectionSegment_Reverse(self)

    def Exchange(self, I, J):
        return _IntRes2d.IntRes2d_SequenceOfIntersectionSegment_Exchange(self, I, J)

    @staticmethod
    def delNode(theNode, theAl):
        return _IntRes2d.IntRes2d_SequenceOfIntersectionSegment_delNode(theNode, theAl)

    def Clear(self, theAllocator=0):
        return _IntRes2d.IntRes2d_SequenceOfIntersectionSegment_Clear(self, theAllocator)

    def Assign(self, theOther):
        return _IntRes2d.IntRes2d_SequenceOfIntersectionSegment_Assign(self, theOther)

    def Set(self, theOther):
        return _IntRes2d.IntRes2d_SequenceOfIntersectionSegment_Set(self, theOther)

    def Remove(self, *args):
        return _IntRes2d.IntRes2d_SequenceOfIntersectionSegment_Remove(self, *args)

    def Append(self, *args):
        return _IntRes2d.IntRes2d_SequenceOfIntersectionSegment_Append(self, *args)

    def Prepend(self, *args):
        return _IntRes2d.IntRes2d_SequenceOfIntersectionSegment_Prepend(self, *args)

    def InsertBefore(self, *args):
        return _IntRes2d.IntRes2d_SequenceOfIntersectionSegment_InsertBefore(self, *args)

    def InsertAfter(self, *args):
        return _IntRes2d.IntRes2d_SequenceOfIntersectionSegment_InsertAfter(self, *args)

    def Split(self, theIndex, theSeq):
        return _IntRes2d.IntRes2d_SequenceOfIntersectionSegment_Split(self, theIndex, theSeq)

    def First(self):
        return _IntRes2d.IntRes2d_SequenceOfIntersectionSegment_First(self)

    def ChangeFirst(self):
        return _IntRes2d.IntRes2d_SequenceOfIntersectionSegment_ChangeFirst(self)

    def Last(self):
        return _IntRes2d.IntRes2d_SequenceOfIntersectionSegment_Last(self)

    def ChangeLast(self):
        return _IntRes2d.IntRes2d_SequenceOfIntersectionSegment_ChangeLast(self)

    def Value(self, theIndex):
        return _IntRes2d.IntRes2d_SequenceOfIntersectionSegment_Value(self, theIndex)

    def ChangeValue(self, theIndex):
        return _IntRes2d.IntRes2d_SequenceOfIntersectionSegment_ChangeValue(self, theIndex)

    def __call__(self, *args):
        return _IntRes2d.IntRes2d_SequenceOfIntersectionSegment___call__(self, *args)

    def SetValue(self, theIndex, theItem):
        return _IntRes2d.IntRes2d_SequenceOfIntersectionSegment_SetValue(self, theIndex, theItem)
    __swig_destroy__ = _IntRes2d.delete_IntRes2d_SequenceOfIntersectionSegment

    def __len__(self):
        return self.Size()


# Register IntRes2d_SequenceOfIntersectionSegment in _IntRes2d:
_IntRes2d.IntRes2d_SequenceOfIntersectionSegment_swigregister(IntRes2d_SequenceOfIntersectionSegment)
class IntRes2d_Domain(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        Return
        -------
        None

        Description
        -----------
        Creates an infinite domain (hasfirstpoint = false and haslastpoint = false).

        Parameters
        ----------
        Pnt1: gp_Pnt2d
        Par1: float
        Tol1: float
        Pnt2: gp_Pnt2d
        Par2: float
        Tol2: float

        Return
        -------
        None

        Description
        -----------
        Creates a bounded domain.

        Parameters
        ----------
        Pnt: gp_Pnt2d
        Par: float
        Tol: float
        First: bool

        Return
        -------
        None

        Description
        -----------
        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.

        """
        _IntRes2d.IntRes2d_Domain_swiginit(self, _IntRes2d.new_IntRes2d_Domain(*args))

    def EquivalentParameters(self, *args):
        r"""

        Parameters
        ----------

        Return
        -------
        zero: float
        zeroplusperiod: float

        Description
        -----------
        Returns equivalent parameters if the domain is closed. otherwise, the exception domainerror is raised.

        """
        return _IntRes2d.IntRes2d_Domain_EquivalentParameters(self, *args)

    def FirstParameter(self, *args):
        r"""
        Return
        -------
        float

        Description
        -----------
        Returns the parameter of the first point of the domain the exception domainerror is raised if hasfirstpoint returns false.

        """
        return _IntRes2d.IntRes2d_Domain_FirstParameter(self, *args)

    def FirstPoint(self, *args):
        r"""
        Return
        -------
        gp_Pnt2d

        Description
        -----------
        Returns the first point of the domain. the exception domainerror is raised if hasfirstpoint returns false.

        """
        return _IntRes2d.IntRes2d_Domain_FirstPoint(self, *args)

    def FirstTolerance(self, *args):
        r"""
        Return
        -------
        float

        Description
        -----------
        Returns the tolerance of the first (left) bound. the exception domainerror is raised if hasfirstpoint returns false.

        """
        return _IntRes2d.IntRes2d_Domain_FirstTolerance(self, *args)

    def HasFirstPoint(self, *args):
        r"""
        Return
        -------
        bool

        Description
        -----------
        Returns true if the domain has a first point, i-e a point defining the lowest admitted parameter on the curve.

        """
        return _IntRes2d.IntRes2d_Domain_HasFirstPoint(self, *args)

    def HasLastPoint(self, *args):
        r"""
        Return
        -------
        bool

        Description
        -----------
        Returns true if the domain has a last point, i-e a point defining the highest admitted parameter on the curve.

        """
        return _IntRes2d.IntRes2d_Domain_HasLastPoint(self, *args)

    def IsClosed(self, *args):
        r"""
        Return
        -------
        bool

        Description
        -----------
        Returns true if the domain is closed.

        """
        return _IntRes2d.IntRes2d_Domain_IsClosed(self, *args)

    def LastParameter(self, *args):
        r"""
        Return
        -------
        float

        Description
        -----------
        Returns the parameter of the last point of the domain. the exception domainerror is raised if haslastpoint returns false.

        """
        return _IntRes2d.IntRes2d_Domain_LastParameter(self, *args)

    def LastPoint(self, *args):
        r"""
        Return
        -------
        gp_Pnt2d

        Description
        -----------
        Returns the last point of the domain. the exception domainerror is raised if haslastpoint returns false.

        """
        return _IntRes2d.IntRes2d_Domain_LastPoint(self, *args)

    def LastTolerance(self, *args):
        r"""
        Return
        -------
        float

        Description
        -----------
        Returns the tolerance of the last (right) bound. the exception domainerror is raised if haslastpoint returns false.

        """
        return _IntRes2d.IntRes2d_Domain_LastTolerance(self, *args)

    def SetEquivalentParameters(self, *args):
        r"""

        Parameters
        ----------
        zero: float
        period: float

        Return
        -------
        None

        Description
        -----------
        Defines a closed domain.

        """
        return _IntRes2d.IntRes2d_Domain_SetEquivalentParameters(self, *args)

    def SetValues(self, *args):
        r"""

        Parameters
        ----------
        Pnt1: gp_Pnt2d
        Par1: float
        Tol1: float
        Pnt2: gp_Pnt2d
        Par2: float
        Tol2: float

        Return
        -------
        None

        Description
        -----------
        Sets the values for a bounded domain.
        Return
        -------
        None

        Description
        -----------
        Sets the values for an infinite domain.

        Parameters
        ----------
        Pnt: gp_Pnt2d
        Par: float
        Tol: float
        First: bool

        Return
        -------
        None

        Description
        -----------
        Sets the values for a semi-infinite domain.

        """
        return _IntRes2d.IntRes2d_Domain_SetValues(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _IntRes2d.delete_IntRes2d_Domain

# Register IntRes2d_Domain in _IntRes2d:
_IntRes2d.IntRes2d_Domain_swigregister(IntRes2d_Domain)
class IntRes2d_Intersection(object):
    thisown = 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):
        r"""
        Return
        -------
        bool

        Description
        -----------
        Returns true when the computation was successful.

        """
        return _IntRes2d.IntRes2d_Intersection_IsDone(self, *args)

    def IsEmpty(self, *args):
        r"""
        Return
        -------
        bool

        Description
        -----------
        Returns true if there is no intersection between the given arguments. the exception notdone is raised if isdone returns false.

        """
        return _IntRes2d.IntRes2d_Intersection_IsEmpty(self, *args)

    def NbPoints(self, *args):
        r"""
        Return
        -------
        int

        Description
        -----------
        This function returns the number of intersection points between the 2 curves. the exception notdone is raised if isdone returns false.

        """
        return _IntRes2d.IntRes2d_Intersection_NbPoints(self, *args)

    def NbSegments(self, *args):
        r"""
        Return
        -------
        int

        Description
        -----------
        This function returns the number of intersection segments between the two curves. the exception notdone is raised if isdone returns false.

        """
        return _IntRes2d.IntRes2d_Intersection_NbSegments(self, *args)

    def Point(self, *args):
        r"""

        Parameters
        ----------
        N: int

        Return
        -------
        IntRes2d_IntersectionPoint

        Description
        -----------
        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).

        """
        return _IntRes2d.IntRes2d_Intersection_Point(self, *args)

    def Segment(self, *args):
        r"""

        Parameters
        ----------
        N: int

        Return
        -------
        IntRes2d_IntersectionSegment

        Description
        -----------
        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).

        """
        return _IntRes2d.IntRes2d_Intersection_Segment(self, *args)

    def SetReversedParameters(self, *args):
        r"""

        Parameters
        ----------
        Reverseflag: bool

        Return
        -------
        None

        Description
        -----------
        No available documentation.

        """
        return _IntRes2d.IntRes2d_Intersection_SetReversedParameters(self, *args)

    __repr__ = _dumps_object


# Register IntRes2d_Intersection in _IntRes2d:
_IntRes2d.IntRes2d_Intersection_swigregister(IntRes2d_Intersection)
class IntRes2d_IntersectionPoint(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        Return
        -------
        None

        Description
        -----------
        Empty constructor.

        Parameters
        ----------
        P: gp_Pnt2d
        Uc1: float
        Uc2: float
        Trans1: IntRes2d_Transition
        Trans2: IntRes2d_Transition
        ReversedFlag: bool

        Return
        -------
        None

        Description
        -----------
        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).

        """
        _IntRes2d.IntRes2d_IntersectionPoint_swiginit(self, _IntRes2d.new_IntRes2d_IntersectionPoint(*args))

    def ParamOnFirst(self, *args):
        r"""
        Return
        -------
        float

        Description
        -----------
        Returns the parameter on the first curve.

        """
        return _IntRes2d.IntRes2d_IntersectionPoint_ParamOnFirst(self, *args)

    def ParamOnSecond(self, *args):
        r"""
        Return
        -------
        float

        Description
        -----------
        Returns the parameter on the second curve.

        """
        return _IntRes2d.IntRes2d_IntersectionPoint_ParamOnSecond(self, *args)

    def SetValues(self, *args):
        r"""

        Parameters
        ----------
        P: gp_Pnt2d
        Uc1: float
        Uc2: float
        Trans1: IntRes2d_Transition
        Trans2: IntRes2d_Transition
        ReversedFlag: bool

        Return
        -------
        None

        Description
        -----------
        Sets the values for an existing intersection point. the meaning of the parameters are the same as for the create.

        """
        return _IntRes2d.IntRes2d_IntersectionPoint_SetValues(self, *args)

    def TransitionOfFirst(self, *args):
        r"""
        Return
        -------
        IntRes2d_Transition

        Description
        -----------
        Returns the transition of the 1st curve compared to the 2nd one.

        """
        return _IntRes2d.IntRes2d_IntersectionPoint_TransitionOfFirst(self, *args)

    def TransitionOfSecond(self, *args):
        r"""
        Return
        -------
        IntRes2d_Transition

        Description
        -----------
        Returns the transition of the 2nd curve compared to the 1st one.

        """
        return _IntRes2d.IntRes2d_IntersectionPoint_TransitionOfSecond(self, *args)

    def Value(self, *args):
        r"""
        Return
        -------
        gp_Pnt2d

        Description
        -----------
        Returns the value of the coordinates of the intersection point in the 2d space.

        """
        return _IntRes2d.IntRes2d_IntersectionPoint_Value(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _IntRes2d.delete_IntRes2d_IntersectionPoint

# Register IntRes2d_IntersectionPoint in _IntRes2d:
_IntRes2d.IntRes2d_IntersectionPoint_swigregister(IntRes2d_IntersectionPoint)
class IntRes2d_IntersectionSegment(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        Return
        -------
        None

        Description
        -----------
        Empty constructor.

        Parameters
        ----------
        P1: IntRes2d_IntersectionPoint
        P2: IntRes2d_IntersectionPoint
        Oppos: bool
        ReverseFlag: bool

        Return
        -------
        None

        Description
        -----------
        No available documentation.

        Parameters
        ----------
        P: IntRes2d_IntersectionPoint
        First: bool
        Oppos: bool
        ReverseFlag: bool

        Return
        -------
        None

        Description
        -----------
        No available documentation.

        Parameters
        ----------
        Oppos: bool

        Return
        -------
        None

        Description
        -----------
        Creates an infinite segment of intersection.

        """
        _IntRes2d.IntRes2d_IntersectionSegment_swiginit(self, _IntRes2d.new_IntRes2d_IntersectionSegment(*args))

    def FirstPoint(self, *args):
        r"""
        Return
        -------
        IntRes2d_IntersectionPoint

        Description
        -----------
        Returns the first point of the segment as an intersectionpoint (with a transition). the exception domainerror is raised if hasfirstpoint returns false.

        """
        return _IntRes2d.IntRes2d_IntersectionSegment_FirstPoint(self, *args)

    def HasFirstPoint(self, *args):
        r"""
        Return
        -------
        bool

        Description
        -----------
        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.

        """
        return _IntRes2d.IntRes2d_IntersectionSegment_HasFirstPoint(self, *args)

    def HasLastPoint(self, *args):
        r"""
        Return
        -------
        bool

        Description
        -----------
        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.

        """
        return _IntRes2d.IntRes2d_IntersectionSegment_HasLastPoint(self, *args)

    def IsOpposite(self, *args):
        r"""
        Return
        -------
        bool

        Description
        -----------
        Returns false if the intersection segment has got the same orientation on both curves.

        """
        return _IntRes2d.IntRes2d_IntersectionSegment_IsOpposite(self, *args)

    def LastPoint(self, *args):
        r"""
        Return
        -------
        IntRes2d_IntersectionPoint

        Description
        -----------
        Returns the last point of the segment as an intersectionpoint (with a transition). the exception domainerror is raised if haslastextremity returns false.

        """
        return _IntRes2d.IntRes2d_IntersectionSegment_LastPoint(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _IntRes2d.delete_IntRes2d_IntersectionSegment

# Register IntRes2d_IntersectionSegment in _IntRes2d:
_IntRes2d.IntRes2d_IntersectionSegment_swigregister(IntRes2d_IntersectionSegment)
class IntRes2d_Transition(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        Return
        -------
        None

        Description
        -----------
        Empty constructor.

        Parameters
        ----------
        Tangent: bool
        Pos: IntRes2d_Position
        Type: IntRes2d_TypeTrans

        Return
        -------
        None

        Description
        -----------
        Creates an in or out transition.

        Parameters
        ----------
        Tangent: bool
        Pos: IntRes2d_Position
        Situ: IntRes2d_Situation
        Oppos: bool

        Return
        -------
        None

        Description
        -----------
        Creates a touch transition.

        Parameters
        ----------
        Pos: IntRes2d_Position

        Return
        -------
        None

        Description
        -----------
        Creates an undecided transition.

        """
        _IntRes2d.IntRes2d_Transition_swiginit(self, _IntRes2d.new_IntRes2d_Transition(*args))

    def IsOpposite(self, *args):
        r"""
        Return
        -------
        bool

        Description
        -----------
        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.

        """
        return _IntRes2d.IntRes2d_Transition_IsOpposite(self, *args)

    def IsTangent(self, *args):
        r"""
        Return
        -------
        bool

        Description
        -----------
        Returns true when the 2 curves are tangent at the intersection point. theexception domainerror is raised if the type of transition is undecided.

        """
        return _IntRes2d.IntRes2d_Transition_IsTangent(self, *args)

    def PositionOnCurve(self, *args):
        r"""
        Return
        -------
        IntRes2d_Position

        Description
        -----------
        Indicates if the intersection is at the beginning (intres2d_head), at the end (intres2d_end), or in the middle (intres2d_middle) of the curve.

        """
        return _IntRes2d.IntRes2d_Transition_PositionOnCurve(self, *args)

    def SetPosition(self, *args):
        r"""

        Parameters
        ----------
        Pos: IntRes2d_Position

        Return
        -------
        None

        Description
        -----------
        Sets the value of the position.

        """
        return _IntRes2d.IntRes2d_Transition_SetPosition(self, *args)

    def SetValue(self, *args):
        r"""

        Parameters
        ----------
        Tangent: bool
        Pos: IntRes2d_Position
        Type: IntRes2d_TypeTrans

        Return
        -------
        None

        Description
        -----------
        Sets the values of an in or out transition.

        Parameters
        ----------
        Tangent: bool
        Pos: IntRes2d_Position
        Situ: IntRes2d_Situation
        Oppos: bool

        Return
        -------
        None

        Description
        -----------
        Sets the values of a touch transition.

        Parameters
        ----------
        Pos: IntRes2d_Position

        Return
        -------
        None

        Description
        -----------
        Sets the values of an undecided transition.

        """
        return _IntRes2d.IntRes2d_Transition_SetValue(self, *args)

    def Situation(self, *args):
        r"""
        Return
        -------
        IntRes2d_Situation

        Description
        -----------
        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.

        """
        return _IntRes2d.IntRes2d_Transition_Situation(self, *args)

    def TransitionType(self, *args):
        r"""
        Return
        -------
        IntRes2d_TypeTrans

        Description
        -----------
        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.

        """
        return _IntRes2d.IntRes2d_Transition_TransitionType(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _IntRes2d.delete_IntRes2d_Transition

# Register IntRes2d_Transition in _IntRes2d:
_IntRes2d.IntRes2d_Transition_swigregister(IntRes2d_Transition)



