# This file was automatically generated by SWIG (http://www.swig.org).
# Version 4.0.2
#
# 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.4.0/refman/html/package_intres2d.html
"""

from sys import version_info as _swig_python_version_info
if _swig_python_version_info < (2, 7, 0):
    raise RuntimeError("Python 2.7 or later required")

# 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 == "thisown":
            self.this.own(value)
        elif name == "this":
            set(self, name, 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) -> "PyObject *":
        return _IntRes2d.SwigPyIterator_value(self)

    def incr(self, n: "size_t"=1) -> "swig::SwigPyIterator *":
        return _IntRes2d.SwigPyIterator_incr(self, n)

    def decr(self, n: "size_t"=1) -> "swig::SwigPyIterator *":
        return _IntRes2d.SwigPyIterator_decr(self, n)

    def distance(self, x: "SwigPyIterator") -> "ptrdiff_t":
        return _IntRes2d.SwigPyIterator_distance(self, x)

    def equal(self, x: "SwigPyIterator") -> "bool":
        return _IntRes2d.SwigPyIterator_equal(self, x)

    def copy(self) -> "swig::SwigPyIterator *":
        return _IntRes2d.SwigPyIterator_copy(self)

    def next(self) -> "PyObject *":
        return _IntRes2d.SwigPyIterator_next(self)

    def __next__(self) -> "PyObject *":
        return _IntRes2d.SwigPyIterator___next__(self)

    def previous(self) -> "PyObject *":
        return _IntRes2d.SwigPyIterator_previous(self)

    def advance(self, n: "ptrdiff_t") -> "swig::SwigPyIterator *":
        return _IntRes2d.SwigPyIterator_advance(self, n)

    def __eq__(self, x: "SwigPyIterator") -> "bool":
        return _IntRes2d.SwigPyIterator___eq__(self, x)

    def __ne__(self, x: "SwigPyIterator") -> "bool":
        return _IntRes2d.SwigPyIterator___ne__(self, x)

    def __iadd__(self, n: "ptrdiff_t") -> "swig::SwigPyIterator &":
        return _IntRes2d.SwigPyIterator___iadd__(self, n)

    def __isub__(self, n: "ptrdiff_t") -> "swig::SwigPyIterator &":
        return _IntRes2d.SwigPyIterator___isub__(self, n)

    def __add__(self, n: "ptrdiff_t") -> "swig::SwigPyIterator *":
        return _IntRes2d.SwigPyIterator___add__(self, n)

    def __sub__(self, *args) -> "ptrdiff_t":
        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: "Standard_Failure", method_name: "std::string", class_name: "std::string") -> "void":
    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) -> "NCollection_Sequence< IntRes2d_IntersectionPoint >::iterator":
        return _IntRes2d.IntRes2d_SequenceOfIntersectionPoint_begin(self)

    def end(self) -> "NCollection_Sequence< IntRes2d_IntersectionPoint >::iterator":
        return _IntRes2d.IntRes2d_SequenceOfIntersectionPoint_end(self)

    def cbegin(self) -> "NCollection_Sequence< IntRes2d_IntersectionPoint >::const_iterator":
        return _IntRes2d.IntRes2d_SequenceOfIntersectionPoint_cbegin(self)

    def cend(self) -> "NCollection_Sequence< IntRes2d_IntersectionPoint >::const_iterator":
        return _IntRes2d.IntRes2d_SequenceOfIntersectionPoint_cend(self)

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

    def Size(self) -> "Standard_Integer":
        return _IntRes2d.IntRes2d_SequenceOfIntersectionPoint_Size(self)

    def Length(self) -> "Standard_Integer":
        return _IntRes2d.IntRes2d_SequenceOfIntersectionPoint_Length(self)

    def Lower(self) -> "Standard_Integer":
        return _IntRes2d.IntRes2d_SequenceOfIntersectionPoint_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _IntRes2d.IntRes2d_SequenceOfIntersectionPoint_Upper(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _IntRes2d.IntRes2d_SequenceOfIntersectionPoint_IsEmpty(self)

    def Reverse(self) -> "void":
        return _IntRes2d.IntRes2d_SequenceOfIntersectionPoint_Reverse(self)

    def Exchange(self, I: "Standard_Integer const", J: "Standard_Integer const") -> "void":
        return _IntRes2d.IntRes2d_SequenceOfIntersectionPoint_Exchange(self, I, J)

    @staticmethod
    def delNode(theNode: "NCollection_SeqNode *", theAl: "opencascade::handle< NCollection_BaseAllocator > &") -> "void":
        return _IntRes2d.IntRes2d_SequenceOfIntersectionPoint_delNode(theNode, theAl)

    def Clear(self, theAllocator: "opencascade::handle< NCollection_BaseAllocator > const &"=0) -> "void":
        return _IntRes2d.IntRes2d_SequenceOfIntersectionPoint_Clear(self, theAllocator)

    def Assign(self, theOther: "IntRes2d_SequenceOfIntersectionPoint") -> "NCollection_Sequence< IntRes2d_IntersectionPoint > &":
        return _IntRes2d.IntRes2d_SequenceOfIntersectionPoint_Assign(self, theOther)

    def Set(self, theOther: "IntRes2d_SequenceOfIntersectionPoint") -> "NCollection_Sequence< IntRes2d_IntersectionPoint > &":
        return _IntRes2d.IntRes2d_SequenceOfIntersectionPoint_Set(self, theOther)

    def Remove(self, *args) -> "void":
        return _IntRes2d.IntRes2d_SequenceOfIntersectionPoint_Remove(self, *args)

    def Append(self, *args) -> "void":
        return _IntRes2d.IntRes2d_SequenceOfIntersectionPoint_Append(self, *args)

    def Prepend(self, *args) -> "void":
        return _IntRes2d.IntRes2d_SequenceOfIntersectionPoint_Prepend(self, *args)

    def InsertBefore(self, *args) -> "void":
        return _IntRes2d.IntRes2d_SequenceOfIntersectionPoint_InsertBefore(self, *args)

    def InsertAfter(self, *args) -> "void":
        return _IntRes2d.IntRes2d_SequenceOfIntersectionPoint_InsertAfter(self, *args)

    def Split(self, theIndex: "Standard_Integer const", theSeq: "IntRes2d_SequenceOfIntersectionPoint") -> "void":
        return _IntRes2d.IntRes2d_SequenceOfIntersectionPoint_Split(self, theIndex, theSeq)

    def First(self) -> "IntRes2d_IntersectionPoint const &":
        return _IntRes2d.IntRes2d_SequenceOfIntersectionPoint_First(self)

    def ChangeFirst(self) -> "IntRes2d_IntersectionPoint &":
        return _IntRes2d.IntRes2d_SequenceOfIntersectionPoint_ChangeFirst(self)

    def Last(self) -> "IntRes2d_IntersectionPoint const &":
        return _IntRes2d.IntRes2d_SequenceOfIntersectionPoint_Last(self)

    def ChangeLast(self) -> "IntRes2d_IntersectionPoint &":
        return _IntRes2d.IntRes2d_SequenceOfIntersectionPoint_ChangeLast(self)

    def Value(self, theIndex: "Standard_Integer const") -> "IntRes2d_IntersectionPoint const &":
        return _IntRes2d.IntRes2d_SequenceOfIntersectionPoint_Value(self, theIndex)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "IntRes2d_IntersectionPoint &":
        return _IntRes2d.IntRes2d_SequenceOfIntersectionPoint_ChangeValue(self, theIndex)

    def __call__(self, *args) -> "IntRes2d_IntersectionPoint &":
        return _IntRes2d.IntRes2d_SequenceOfIntersectionPoint___call__(self, *args)

    def SetValue(self, theIndex: "Standard_Integer const", theItem: "IntRes2d_IntersectionPoint") -> "void":
        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)

def IntRes2d_SequenceOfIntersectionPoint_delNode(theNode: "NCollection_SeqNode *", theAl: "opencascade::handle< NCollection_BaseAllocator > &") -> "void":
    return _IntRes2d.IntRes2d_SequenceOfIntersectionPoint_delNode(theNode, theAl)

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) -> "NCollection_Sequence< IntRes2d_IntersectionSegment >::iterator":
        return _IntRes2d.IntRes2d_SequenceOfIntersectionSegment_begin(self)

    def end(self) -> "NCollection_Sequence< IntRes2d_IntersectionSegment >::iterator":
        return _IntRes2d.IntRes2d_SequenceOfIntersectionSegment_end(self)

    def cbegin(self) -> "NCollection_Sequence< IntRes2d_IntersectionSegment >::const_iterator":
        return _IntRes2d.IntRes2d_SequenceOfIntersectionSegment_cbegin(self)

    def cend(self) -> "NCollection_Sequence< IntRes2d_IntersectionSegment >::const_iterator":
        return _IntRes2d.IntRes2d_SequenceOfIntersectionSegment_cend(self)

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

    def Size(self) -> "Standard_Integer":
        return _IntRes2d.IntRes2d_SequenceOfIntersectionSegment_Size(self)

    def Length(self) -> "Standard_Integer":
        return _IntRes2d.IntRes2d_SequenceOfIntersectionSegment_Length(self)

    def Lower(self) -> "Standard_Integer":
        return _IntRes2d.IntRes2d_SequenceOfIntersectionSegment_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _IntRes2d.IntRes2d_SequenceOfIntersectionSegment_Upper(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _IntRes2d.IntRes2d_SequenceOfIntersectionSegment_IsEmpty(self)

    def Reverse(self) -> "void":
        return _IntRes2d.IntRes2d_SequenceOfIntersectionSegment_Reverse(self)

    def Exchange(self, I: "Standard_Integer const", J: "Standard_Integer const") -> "void":
        return _IntRes2d.IntRes2d_SequenceOfIntersectionSegment_Exchange(self, I, J)

    @staticmethod
    def delNode(theNode: "NCollection_SeqNode *", theAl: "opencascade::handle< NCollection_BaseAllocator > &") -> "void":
        return _IntRes2d.IntRes2d_SequenceOfIntersectionSegment_delNode(theNode, theAl)

    def Clear(self, theAllocator: "opencascade::handle< NCollection_BaseAllocator > const &"=0) -> "void":
        return _IntRes2d.IntRes2d_SequenceOfIntersectionSegment_Clear(self, theAllocator)

    def Assign(self, theOther: "IntRes2d_SequenceOfIntersectionSegment") -> "NCollection_Sequence< IntRes2d_IntersectionSegment > &":
        return _IntRes2d.IntRes2d_SequenceOfIntersectionSegment_Assign(self, theOther)

    def Set(self, theOther: "IntRes2d_SequenceOfIntersectionSegment") -> "NCollection_Sequence< IntRes2d_IntersectionSegment > &":
        return _IntRes2d.IntRes2d_SequenceOfIntersectionSegment_Set(self, theOther)

    def Remove(self, *args) -> "void":
        return _IntRes2d.IntRes2d_SequenceOfIntersectionSegment_Remove(self, *args)

    def Append(self, *args) -> "void":
        return _IntRes2d.IntRes2d_SequenceOfIntersectionSegment_Append(self, *args)

    def Prepend(self, *args) -> "void":
        return _IntRes2d.IntRes2d_SequenceOfIntersectionSegment_Prepend(self, *args)

    def InsertBefore(self, *args) -> "void":
        return _IntRes2d.IntRes2d_SequenceOfIntersectionSegment_InsertBefore(self, *args)

    def InsertAfter(self, *args) -> "void":
        return _IntRes2d.IntRes2d_SequenceOfIntersectionSegment_InsertAfter(self, *args)

    def Split(self, theIndex: "Standard_Integer const", theSeq: "IntRes2d_SequenceOfIntersectionSegment") -> "void":
        return _IntRes2d.IntRes2d_SequenceOfIntersectionSegment_Split(self, theIndex, theSeq)

    def First(self) -> "IntRes2d_IntersectionSegment const &":
        return _IntRes2d.IntRes2d_SequenceOfIntersectionSegment_First(self)

    def ChangeFirst(self) -> "IntRes2d_IntersectionSegment &":
        return _IntRes2d.IntRes2d_SequenceOfIntersectionSegment_ChangeFirst(self)

    def Last(self) -> "IntRes2d_IntersectionSegment const &":
        return _IntRes2d.IntRes2d_SequenceOfIntersectionSegment_Last(self)

    def ChangeLast(self) -> "IntRes2d_IntersectionSegment &":
        return _IntRes2d.IntRes2d_SequenceOfIntersectionSegment_ChangeLast(self)

    def Value(self, theIndex: "Standard_Integer const") -> "IntRes2d_IntersectionSegment const &":
        return _IntRes2d.IntRes2d_SequenceOfIntersectionSegment_Value(self, theIndex)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "IntRes2d_IntersectionSegment &":
        return _IntRes2d.IntRes2d_SequenceOfIntersectionSegment_ChangeValue(self, theIndex)

    def __call__(self, *args) -> "IntRes2d_IntersectionSegment &":
        return _IntRes2d.IntRes2d_SequenceOfIntersectionSegment___call__(self, *args)

    def SetValue(self, theIndex: "Standard_Integer const", theItem: "IntRes2d_IntersectionSegment") -> "void":
        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)

def IntRes2d_SequenceOfIntersectionSegment_delNode(theNode: "NCollection_SeqNode *", theAl: "opencascade::handle< NCollection_BaseAllocator > &") -> "void":
    return _IntRes2d.IntRes2d_SequenceOfIntersectionSegment_delNode(theNode, theAl)

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"""
        Creates an infinite domain (hasfirstpoint = false and haslastpoint = false).

        Returns
        -------
        None
        Creates a bounded domain.

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

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

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

        Returns
        -------
        None

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

    def EquivalentParameters(self, *args) -> "void":
        r"""
        Returns equivalent parameters if the domain is closed. otherwise, the exception domainerror is raised.

        Parameters
        ----------

        Returns
        -------
        zero: float
        zeroplusperiod: float

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

    def FirstParameter(self, *args) -> "Standard_Real":
        r"""
        Returns the parameter of the first point of the domain the exception domainerror is raised if hasfirstpoint returns false.

        Returns
        -------
        float

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

    def FirstPoint(self, *args) -> "gp_Pnt2d const":
        r"""
        Returns the first point of the domain. the exception domainerror is raised if hasfirstpoint returns false.

        Returns
        -------
        gp_Pnt2d

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

    def FirstTolerance(self, *args) -> "Standard_Real":
        r"""
        Returns the tolerance of the first (left) bound. the exception domainerror is raised if hasfirstpoint returns false.

        Returns
        -------
        float

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

    def HasFirstPoint(self, *args) -> "Standard_Boolean":
        r"""
        Returns true if the domain has a first point, i-e a point defining the lowest admitted parameter on the curve.

        Returns
        -------
        bool

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

    def HasLastPoint(self, *args) -> "Standard_Boolean":
        r"""
        Returns true if the domain has a last point, i-e a point defining the highest admitted parameter on the curve.

        Returns
        -------
        bool

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

    def IsClosed(self, *args) -> "Standard_Boolean":
        r"""
        Returns true if the domain is closed.

        Returns
        -------
        bool

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

    def LastParameter(self, *args) -> "Standard_Real":
        r"""
        Returns the parameter of the last point of the domain. the exception domainerror is raised if haslastpoint returns false.

        Returns
        -------
        float

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

    def LastPoint(self, *args) -> "gp_Pnt2d const":
        r"""
        Returns the last point of the domain. the exception domainerror is raised if haslastpoint returns false.

        Returns
        -------
        gp_Pnt2d

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

    def LastTolerance(self, *args) -> "Standard_Real":
        r"""
        Returns the tolerance of the last (right) bound. the exception domainerror is raised if haslastpoint returns false.

        Returns
        -------
        float

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

    def SetEquivalentParameters(self, *args) -> "void":
        r"""
        Defines a closed domain.

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

        Returns
        -------
        None

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

    def SetValues(self, *args) -> "void":
        r"""
        Sets the values for a bounded domain.

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

        Returns
        -------
        None
        Sets the values for an infinite domain.

        Returns
        -------
        None
        Sets the values for a semi-infinite domain.

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

        Returns
        -------
        None

        """
        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) -> "Standard_Boolean":
        r"""
        Returns true when the computation was successful.

        Returns
        -------
        bool

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

    def IsEmpty(self, *args) -> "Standard_Boolean":
        r"""
        Returns true if there is no intersection between the given arguments. the exception notdone is raised if isdone returns false.

        Returns
        -------
        bool

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

    def NbPoints(self, *args) -> "Standard_Integer":
        r"""
        This function returns the number of intersection points between the 2 curves. the exception notdone is raised if isdone returns false.

        Returns
        -------
        int

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

    def NbSegments(self, *args) -> "Standard_Integer":
        r"""
        This function returns the number of intersection segments between the two curves. the exception notdone is raised if isdone returns false.

        Returns
        -------
        int

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

    def Point(self, *args) -> "IntRes2d_IntersectionPoint const &":
        r"""
        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).

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

        Returns
        -------
        IntRes2d_IntersectionPoint

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

    def Segment(self, *args) -> "IntRes2d_IntersectionSegment const &":
        r"""
        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).

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

        Returns
        -------
        IntRes2d_IntersectionSegment

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

    def SetReversedParameters(self, *args) -> "void":
        r"""
        No available documentation.

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

        Returns
        -------
        None

        """
        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"""
        Empty constructor.

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

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

        Returns
        -------
        None

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

    def ParamOnFirst(self, *args) -> "Standard_Real":
        r"""
        Returns the parameter on the first curve.

        Returns
        -------
        float

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

    def ParamOnSecond(self, *args) -> "Standard_Real":
        r"""
        Returns the parameter on the second curve.

        Returns
        -------
        float

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

    def SetValues(self, *args) -> "void":
        r"""
        Sets the values for an existing intersection point. the meaning of the parameters are the same as for the create.

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

        Returns
        -------
        None

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

    def TransitionOfFirst(self, *args) -> "IntRes2d_Transition const &":
        r"""
        Returns the transition of the 1st curve compared to the 2nd one.

        Returns
        -------
        IntRes2d_Transition

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

    def TransitionOfSecond(self, *args) -> "IntRes2d_Transition const &":
        r"""
        Returns the transition of the 2nd curve compared to the 1st one.

        Returns
        -------
        IntRes2d_Transition

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

    def Value(self, *args) -> "gp_Pnt2d const":
        r"""
        Returns the value of the coordinates of the intersection point in the 2d space.

        Returns
        -------
        gp_Pnt2d

        """
        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"""
        Empty constructor.

        Returns
        -------
        None
        No available documentation.

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

        Returns
        -------
        None
        No available documentation.

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

        Returns
        -------
        None
        Creates an infinite segment of intersection.

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

        Returns
        -------
        None

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

    def FirstPoint(self, *args) -> "IntRes2d_IntersectionPoint const &":
        r"""
        Returns the first point of the segment as an intersectionpoint (with a transition). the exception domainerror is raised if hasfirstpoint returns false.

        Returns
        -------
        IntRes2d_IntersectionPoint

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

    def HasFirstPoint(self, *args) -> "Standard_Boolean":
        r"""
        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.

        Returns
        -------
        bool

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

    def HasLastPoint(self, *args) -> "Standard_Boolean":
        r"""
        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.

        Returns
        -------
        bool

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

    def IsOpposite(self, *args) -> "Standard_Boolean":
        r"""
        Returns false if the intersection segment has got the same orientation on both curves.

        Returns
        -------
        bool

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

    def LastPoint(self, *args) -> "IntRes2d_IntersectionPoint const &":
        r"""
        Returns the last point of the segment as an intersectionpoint (with a transition). the exception domainerror is raised if haslastextremity returns false.

        Returns
        -------
        IntRes2d_IntersectionPoint

        """
        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"""
        Empty constructor.

        Returns
        -------
        None
        Creates an in or out transition.

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

        Returns
        -------
        None
        Creates a touch transition.

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

        Returns
        -------
        None
        Creates an undecided transition.

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

        Returns
        -------
        None

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

    def IsOpposite(self, *args) -> "Standard_Boolean":
        r"""
        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.

        Returns
        -------
        bool

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

    def IsTangent(self, *args) -> "Standard_Boolean":
        r"""
        Returns true when the 2 curves are tangent at the intersection point. theexception domainerror is raised if the type of transition is undecided.

        Returns
        -------
        bool

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

    def PositionOnCurve(self, *args) -> "IntRes2d_Position":
        r"""
        Indicates if the intersection is at the beginning (intres2d_head), at the end (intres2d_end), or in the middle (intres2d_middle) of the curve.

        Returns
        -------
        IntRes2d_Position

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

    def SetPosition(self, *args) -> "void":
        r"""
        Sets the value of the position.

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

        Returns
        -------
        None

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

    def SetValue(self, *args) -> "void":
        r"""
        Sets the values of an in or out transition.

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

        Returns
        -------
        None
        Sets the values of a touch transition.

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

        Returns
        -------
        None
        Sets the values of an undecided transition.

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

        Returns
        -------
        None

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

    def Situation(self, *args) -> "IntRes2d_Situation":
        r"""
        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.

        Returns
        -------
        IntRes2d_Situation

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

    def TransitionType(self, *args) -> "IntRes2d_TypeTrans":
        r"""
        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.

        Returns
        -------
        IntRes2d_TypeTrans

        """
        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)





