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

"""
MAT2d module, see official documentation at
https://www.opencascade.com/doc/occt-7.7.0/refman/html/package_mat2d.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 _MAT2d
else:
    import _MAT2d

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__ = _MAT2d.delete_SwigPyIterator

    def value(self):
        return _MAT2d.SwigPyIterator_value(self)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

# Register SwigPyIterator in _MAT2d:
_MAT2d.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 _MAT2d.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.GeomAbs
import OCC.Core.TColStd
import OCC.Core.TCollection
import OCC.Core.Geom2d
import OCC.Core.gp
import OCC.Core.TColgp
import OCC.Core.MAT
import OCC.Core.Bisector
import OCC.Core.math
import OCC.Core.Message
import OCC.Core.OSD
import OCC.Core.IntRes2d

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




def Handle_MAT2d_Circuit_Create():
    return _MAT2d.Handle_MAT2d_Circuit_Create()

def Handle_MAT2d_Circuit_DownCast(t):
    return _MAT2d.Handle_MAT2d_Circuit_DownCast(t)

def Handle_MAT2d_Circuit_IsNull(t):
    return _MAT2d.Handle_MAT2d_Circuit_IsNull(t)

def Handle_MAT2d_Connexion_Create():
    return _MAT2d.Handle_MAT2d_Connexion_Create()

def Handle_MAT2d_Connexion_DownCast(t):
    return _MAT2d.Handle_MAT2d_Connexion_DownCast(t)

def Handle_MAT2d_Connexion_IsNull(t):
    return _MAT2d.Handle_MAT2d_Connexion_IsNull(t)
class MAT2d_Array2OfConnexion(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):
        _MAT2d.MAT2d_Array2OfConnexion_swiginit(self, _MAT2d.new_MAT2d_Array2OfConnexion(*args))

    def Init(self, theValue):
        return _MAT2d.MAT2d_Array2OfConnexion_Init(self, theValue)

    def Size(self):
        return _MAT2d.MAT2d_Array2OfConnexion_Size(self)

    def Length(self):
        return _MAT2d.MAT2d_Array2OfConnexion_Length(self)

    def NbRows(self):
        return _MAT2d.MAT2d_Array2OfConnexion_NbRows(self)

    def NbColumns(self):
        return _MAT2d.MAT2d_Array2OfConnexion_NbColumns(self)

    def RowLength(self):
        return _MAT2d.MAT2d_Array2OfConnexion_RowLength(self)

    def ColLength(self):
        return _MAT2d.MAT2d_Array2OfConnexion_ColLength(self)

    def LowerRow(self):
        return _MAT2d.MAT2d_Array2OfConnexion_LowerRow(self)

    def UpperRow(self):
        return _MAT2d.MAT2d_Array2OfConnexion_UpperRow(self)

    def LowerCol(self):
        return _MAT2d.MAT2d_Array2OfConnexion_LowerCol(self)

    def UpperCol(self):
        return _MAT2d.MAT2d_Array2OfConnexion_UpperCol(self)

    def IsDeletable(self):
        return _MAT2d.MAT2d_Array2OfConnexion_IsDeletable(self)

    def Assign(self, theOther):
        return _MAT2d.MAT2d_Array2OfConnexion_Assign(self, theOther)

    def Move(self, theOther):
        return _MAT2d.MAT2d_Array2OfConnexion_Move(self, theOther)

    def Set(self, *args):
        return _MAT2d.MAT2d_Array2OfConnexion_Set(self, *args)

    def Value(self, theRow, theCol):
        return _MAT2d.MAT2d_Array2OfConnexion_Value(self, theRow, theCol)

    def ChangeValue(self, theRow, theCol):
        return _MAT2d.MAT2d_Array2OfConnexion_ChangeValue(self, theRow, theCol)

    def __call__(self, *args):
        return _MAT2d.MAT2d_Array2OfConnexion___call__(self, *args)

    def SetValue(self, theRow, theCol, theItem):
        return _MAT2d.MAT2d_Array2OfConnexion_SetValue(self, theRow, theCol, theItem)

    def Resize(self, theRowLower, theRowUpper, theColLower, theColUpper, theToCopyData):
        return _MAT2d.MAT2d_Array2OfConnexion_Resize(self, theRowLower, theRowUpper, theColLower, theColUpper, theToCopyData)
    __swig_destroy__ = _MAT2d.delete_MAT2d_Array2OfConnexion

# Register MAT2d_Array2OfConnexion in _MAT2d:
_MAT2d.MAT2d_Array2OfConnexion_swigregister(MAT2d_Array2OfConnexion)
class MAT2d_DataMapOfBiIntInteger(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 _MAT2d.MAT2d_DataMapOfBiIntInteger_begin(self)

    def end(self):
        return _MAT2d.MAT2d_DataMapOfBiIntInteger_end(self)

    def cbegin(self):
        return _MAT2d.MAT2d_DataMapOfBiIntInteger_cbegin(self)

    def cend(self):
        return _MAT2d.MAT2d_DataMapOfBiIntInteger_cend(self)

    def __init__(self, *args):
        _MAT2d.MAT2d_DataMapOfBiIntInteger_swiginit(self, _MAT2d.new_MAT2d_DataMapOfBiIntInteger(*args))

    def Exchange(self, theOther):
        return _MAT2d.MAT2d_DataMapOfBiIntInteger_Exchange(self, theOther)

    def Assign(self, theOther):
        return _MAT2d.MAT2d_DataMapOfBiIntInteger_Assign(self, theOther)

    def Set(self, theOther):
        return _MAT2d.MAT2d_DataMapOfBiIntInteger_Set(self, theOther)

    def ReSize(self, N):
        return _MAT2d.MAT2d_DataMapOfBiIntInteger_ReSize(self, N)

    def Bind(self, theKey, theItem):
        return _MAT2d.MAT2d_DataMapOfBiIntInteger_Bind(self, theKey, theItem)

    def Bound(self, theKey, theItem):
        return _MAT2d.MAT2d_DataMapOfBiIntInteger_Bound(self, theKey, theItem)

    def IsBound(self, theKey):
        return _MAT2d.MAT2d_DataMapOfBiIntInteger_IsBound(self, theKey)

    def UnBind(self, theKey):
        return _MAT2d.MAT2d_DataMapOfBiIntInteger_UnBind(self, theKey)

    def Seek(self, theKey):
        return _MAT2d.MAT2d_DataMapOfBiIntInteger_Seek(self, theKey)

    def Find(self, *args):
        return _MAT2d.MAT2d_DataMapOfBiIntInteger_Find(self, *args)

    def ChangeSeek(self, theKey):
        return _MAT2d.MAT2d_DataMapOfBiIntInteger_ChangeSeek(self, theKey)

    def ChangeFind(self, theKey):
        return _MAT2d.MAT2d_DataMapOfBiIntInteger_ChangeFind(self, theKey)

    def __call__(self, *args):
        return _MAT2d.MAT2d_DataMapOfBiIntInteger___call__(self, *args)

    def Clear(self, *args):
        return _MAT2d.MAT2d_DataMapOfBiIntInteger_Clear(self, *args)
    __swig_destroy__ = _MAT2d.delete_MAT2d_DataMapOfBiIntInteger

    def Size(self):
        return _MAT2d.MAT2d_DataMapOfBiIntInteger_Size(self)

# Register MAT2d_DataMapOfBiIntInteger in _MAT2d:
_MAT2d.MAT2d_DataMapOfBiIntInteger_swigregister(MAT2d_DataMapOfBiIntInteger)
class MAT2d_DataMapOfBiIntSequenceOfInteger(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 _MAT2d.MAT2d_DataMapOfBiIntSequenceOfInteger_begin(self)

    def end(self):
        return _MAT2d.MAT2d_DataMapOfBiIntSequenceOfInteger_end(self)

    def cbegin(self):
        return _MAT2d.MAT2d_DataMapOfBiIntSequenceOfInteger_cbegin(self)

    def cend(self):
        return _MAT2d.MAT2d_DataMapOfBiIntSequenceOfInteger_cend(self)

    def __init__(self, *args):
        _MAT2d.MAT2d_DataMapOfBiIntSequenceOfInteger_swiginit(self, _MAT2d.new_MAT2d_DataMapOfBiIntSequenceOfInteger(*args))

    def Exchange(self, theOther):
        return _MAT2d.MAT2d_DataMapOfBiIntSequenceOfInteger_Exchange(self, theOther)

    def Assign(self, theOther):
        return _MAT2d.MAT2d_DataMapOfBiIntSequenceOfInteger_Assign(self, theOther)

    def Set(self, theOther):
        return _MAT2d.MAT2d_DataMapOfBiIntSequenceOfInteger_Set(self, theOther)

    def ReSize(self, N):
        return _MAT2d.MAT2d_DataMapOfBiIntSequenceOfInteger_ReSize(self, N)

    def Bind(self, theKey, theItem):
        return _MAT2d.MAT2d_DataMapOfBiIntSequenceOfInteger_Bind(self, theKey, theItem)

    def Bound(self, theKey, theItem):
        return _MAT2d.MAT2d_DataMapOfBiIntSequenceOfInteger_Bound(self, theKey, theItem)

    def IsBound(self, theKey):
        return _MAT2d.MAT2d_DataMapOfBiIntSequenceOfInteger_IsBound(self, theKey)

    def UnBind(self, theKey):
        return _MAT2d.MAT2d_DataMapOfBiIntSequenceOfInteger_UnBind(self, theKey)

    def Seek(self, theKey):
        return _MAT2d.MAT2d_DataMapOfBiIntSequenceOfInteger_Seek(self, theKey)

    def Find(self, *args):
        return _MAT2d.MAT2d_DataMapOfBiIntSequenceOfInteger_Find(self, *args)

    def ChangeSeek(self, theKey):
        return _MAT2d.MAT2d_DataMapOfBiIntSequenceOfInteger_ChangeSeek(self, theKey)

    def ChangeFind(self, theKey):
        return _MAT2d.MAT2d_DataMapOfBiIntSequenceOfInteger_ChangeFind(self, theKey)

    def __call__(self, *args):
        return _MAT2d.MAT2d_DataMapOfBiIntSequenceOfInteger___call__(self, *args)

    def Clear(self, *args):
        return _MAT2d.MAT2d_DataMapOfBiIntSequenceOfInteger_Clear(self, *args)
    __swig_destroy__ = _MAT2d.delete_MAT2d_DataMapOfBiIntSequenceOfInteger

    def Size(self):
        return _MAT2d.MAT2d_DataMapOfBiIntSequenceOfInteger_Size(self)

# Register MAT2d_DataMapOfBiIntSequenceOfInteger in _MAT2d:
_MAT2d.MAT2d_DataMapOfBiIntSequenceOfInteger_swigregister(MAT2d_DataMapOfBiIntSequenceOfInteger)
class MAT2d_DataMapOfIntegerBisec(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 _MAT2d.MAT2d_DataMapOfIntegerBisec_begin(self)

    def end(self):
        return _MAT2d.MAT2d_DataMapOfIntegerBisec_end(self)

    def cbegin(self):
        return _MAT2d.MAT2d_DataMapOfIntegerBisec_cbegin(self)

    def cend(self):
        return _MAT2d.MAT2d_DataMapOfIntegerBisec_cend(self)

    def __init__(self, *args):
        _MAT2d.MAT2d_DataMapOfIntegerBisec_swiginit(self, _MAT2d.new_MAT2d_DataMapOfIntegerBisec(*args))

    def Exchange(self, theOther):
        return _MAT2d.MAT2d_DataMapOfIntegerBisec_Exchange(self, theOther)

    def Assign(self, theOther):
        return _MAT2d.MAT2d_DataMapOfIntegerBisec_Assign(self, theOther)

    def Set(self, theOther):
        return _MAT2d.MAT2d_DataMapOfIntegerBisec_Set(self, theOther)

    def ReSize(self, N):
        return _MAT2d.MAT2d_DataMapOfIntegerBisec_ReSize(self, N)

    def Bind(self, theKey, theItem):
        return _MAT2d.MAT2d_DataMapOfIntegerBisec_Bind(self, theKey, theItem)

    def Bound(self, theKey, theItem):
        return _MAT2d.MAT2d_DataMapOfIntegerBisec_Bound(self, theKey, theItem)

    def IsBound(self, theKey):
        return _MAT2d.MAT2d_DataMapOfIntegerBisec_IsBound(self, theKey)

    def UnBind(self, theKey):
        return _MAT2d.MAT2d_DataMapOfIntegerBisec_UnBind(self, theKey)

    def Seek(self, theKey):
        return _MAT2d.MAT2d_DataMapOfIntegerBisec_Seek(self, theKey)

    def Find(self, *args):
        return _MAT2d.MAT2d_DataMapOfIntegerBisec_Find(self, *args)

    def ChangeSeek(self, theKey):
        return _MAT2d.MAT2d_DataMapOfIntegerBisec_ChangeSeek(self, theKey)

    def ChangeFind(self, theKey):
        return _MAT2d.MAT2d_DataMapOfIntegerBisec_ChangeFind(self, theKey)

    def __call__(self, *args):
        return _MAT2d.MAT2d_DataMapOfIntegerBisec___call__(self, *args)

    def Clear(self, *args):
        return _MAT2d.MAT2d_DataMapOfIntegerBisec_Clear(self, *args)
    __swig_destroy__ = _MAT2d.delete_MAT2d_DataMapOfIntegerBisec

    def Size(self):
        return _MAT2d.MAT2d_DataMapOfIntegerBisec_Size(self)

    def Keys(self):
        return _MAT2d.MAT2d_DataMapOfIntegerBisec_Keys(self)

# Register MAT2d_DataMapOfIntegerBisec in _MAT2d:
_MAT2d.MAT2d_DataMapOfIntegerBisec_swigregister(MAT2d_DataMapOfIntegerBisec)
class MAT2d_DataMapOfIntegerConnexion(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 _MAT2d.MAT2d_DataMapOfIntegerConnexion_begin(self)

    def end(self):
        return _MAT2d.MAT2d_DataMapOfIntegerConnexion_end(self)

    def cbegin(self):
        return _MAT2d.MAT2d_DataMapOfIntegerConnexion_cbegin(self)

    def cend(self):
        return _MAT2d.MAT2d_DataMapOfIntegerConnexion_cend(self)

    def __init__(self, *args):
        _MAT2d.MAT2d_DataMapOfIntegerConnexion_swiginit(self, _MAT2d.new_MAT2d_DataMapOfIntegerConnexion(*args))

    def Exchange(self, theOther):
        return _MAT2d.MAT2d_DataMapOfIntegerConnexion_Exchange(self, theOther)

    def Assign(self, theOther):
        return _MAT2d.MAT2d_DataMapOfIntegerConnexion_Assign(self, theOther)

    def Set(self, theOther):
        return _MAT2d.MAT2d_DataMapOfIntegerConnexion_Set(self, theOther)

    def ReSize(self, N):
        return _MAT2d.MAT2d_DataMapOfIntegerConnexion_ReSize(self, N)

    def Bind(self, theKey, theItem):
        return _MAT2d.MAT2d_DataMapOfIntegerConnexion_Bind(self, theKey, theItem)

    def Bound(self, theKey, theItem):
        return _MAT2d.MAT2d_DataMapOfIntegerConnexion_Bound(self, theKey, theItem)

    def IsBound(self, theKey):
        return _MAT2d.MAT2d_DataMapOfIntegerConnexion_IsBound(self, theKey)

    def UnBind(self, theKey):
        return _MAT2d.MAT2d_DataMapOfIntegerConnexion_UnBind(self, theKey)

    def Seek(self, theKey):
        return _MAT2d.MAT2d_DataMapOfIntegerConnexion_Seek(self, theKey)

    def Find(self, *args):
        return _MAT2d.MAT2d_DataMapOfIntegerConnexion_Find(self, *args)

    def ChangeSeek(self, theKey):
        return _MAT2d.MAT2d_DataMapOfIntegerConnexion_ChangeSeek(self, theKey)

    def ChangeFind(self, theKey):
        return _MAT2d.MAT2d_DataMapOfIntegerConnexion_ChangeFind(self, theKey)

    def __call__(self, *args):
        return _MAT2d.MAT2d_DataMapOfIntegerConnexion___call__(self, *args)

    def Clear(self, *args):
        return _MAT2d.MAT2d_DataMapOfIntegerConnexion_Clear(self, *args)
    __swig_destroy__ = _MAT2d.delete_MAT2d_DataMapOfIntegerConnexion

    def Size(self):
        return _MAT2d.MAT2d_DataMapOfIntegerConnexion_Size(self)

    def Keys(self):
        return _MAT2d.MAT2d_DataMapOfIntegerConnexion_Keys(self)

# Register MAT2d_DataMapOfIntegerConnexion in _MAT2d:
_MAT2d.MAT2d_DataMapOfIntegerConnexion_swigregister(MAT2d_DataMapOfIntegerConnexion)
class MAT2d_DataMapOfIntegerPnt2d(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 _MAT2d.MAT2d_DataMapOfIntegerPnt2d_begin(self)

    def end(self):
        return _MAT2d.MAT2d_DataMapOfIntegerPnt2d_end(self)

    def cbegin(self):
        return _MAT2d.MAT2d_DataMapOfIntegerPnt2d_cbegin(self)

    def cend(self):
        return _MAT2d.MAT2d_DataMapOfIntegerPnt2d_cend(self)

    def __init__(self, *args):
        _MAT2d.MAT2d_DataMapOfIntegerPnt2d_swiginit(self, _MAT2d.new_MAT2d_DataMapOfIntegerPnt2d(*args))

    def Exchange(self, theOther):
        return _MAT2d.MAT2d_DataMapOfIntegerPnt2d_Exchange(self, theOther)

    def Assign(self, theOther):
        return _MAT2d.MAT2d_DataMapOfIntegerPnt2d_Assign(self, theOther)

    def Set(self, theOther):
        return _MAT2d.MAT2d_DataMapOfIntegerPnt2d_Set(self, theOther)

    def ReSize(self, N):
        return _MAT2d.MAT2d_DataMapOfIntegerPnt2d_ReSize(self, N)

    def Bind(self, theKey, theItem):
        return _MAT2d.MAT2d_DataMapOfIntegerPnt2d_Bind(self, theKey, theItem)

    def Bound(self, theKey, theItem):
        return _MAT2d.MAT2d_DataMapOfIntegerPnt2d_Bound(self, theKey, theItem)

    def IsBound(self, theKey):
        return _MAT2d.MAT2d_DataMapOfIntegerPnt2d_IsBound(self, theKey)

    def UnBind(self, theKey):
        return _MAT2d.MAT2d_DataMapOfIntegerPnt2d_UnBind(self, theKey)

    def Seek(self, theKey):
        return _MAT2d.MAT2d_DataMapOfIntegerPnt2d_Seek(self, theKey)

    def Find(self, *args):
        return _MAT2d.MAT2d_DataMapOfIntegerPnt2d_Find(self, *args)

    def ChangeSeek(self, theKey):
        return _MAT2d.MAT2d_DataMapOfIntegerPnt2d_ChangeSeek(self, theKey)

    def ChangeFind(self, theKey):
        return _MAT2d.MAT2d_DataMapOfIntegerPnt2d_ChangeFind(self, theKey)

    def __call__(self, *args):
        return _MAT2d.MAT2d_DataMapOfIntegerPnt2d___call__(self, *args)

    def Clear(self, *args):
        return _MAT2d.MAT2d_DataMapOfIntegerPnt2d_Clear(self, *args)
    __swig_destroy__ = _MAT2d.delete_MAT2d_DataMapOfIntegerPnt2d

    def Size(self):
        return _MAT2d.MAT2d_DataMapOfIntegerPnt2d_Size(self)

    def Keys(self):
        return _MAT2d.MAT2d_DataMapOfIntegerPnt2d_Keys(self)

# Register MAT2d_DataMapOfIntegerPnt2d in _MAT2d:
_MAT2d.MAT2d_DataMapOfIntegerPnt2d_swigregister(MAT2d_DataMapOfIntegerPnt2d)
class MAT2d_DataMapOfIntegerSequenceOfConnexion(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 _MAT2d.MAT2d_DataMapOfIntegerSequenceOfConnexion_begin(self)

    def end(self):
        return _MAT2d.MAT2d_DataMapOfIntegerSequenceOfConnexion_end(self)

    def cbegin(self):
        return _MAT2d.MAT2d_DataMapOfIntegerSequenceOfConnexion_cbegin(self)

    def cend(self):
        return _MAT2d.MAT2d_DataMapOfIntegerSequenceOfConnexion_cend(self)

    def __init__(self, *args):
        _MAT2d.MAT2d_DataMapOfIntegerSequenceOfConnexion_swiginit(self, _MAT2d.new_MAT2d_DataMapOfIntegerSequenceOfConnexion(*args))

    def Exchange(self, theOther):
        return _MAT2d.MAT2d_DataMapOfIntegerSequenceOfConnexion_Exchange(self, theOther)

    def Assign(self, theOther):
        return _MAT2d.MAT2d_DataMapOfIntegerSequenceOfConnexion_Assign(self, theOther)

    def Set(self, theOther):
        return _MAT2d.MAT2d_DataMapOfIntegerSequenceOfConnexion_Set(self, theOther)

    def ReSize(self, N):
        return _MAT2d.MAT2d_DataMapOfIntegerSequenceOfConnexion_ReSize(self, N)

    def Bind(self, theKey, theItem):
        return _MAT2d.MAT2d_DataMapOfIntegerSequenceOfConnexion_Bind(self, theKey, theItem)

    def Bound(self, theKey, theItem):
        return _MAT2d.MAT2d_DataMapOfIntegerSequenceOfConnexion_Bound(self, theKey, theItem)

    def IsBound(self, theKey):
        return _MAT2d.MAT2d_DataMapOfIntegerSequenceOfConnexion_IsBound(self, theKey)

    def UnBind(self, theKey):
        return _MAT2d.MAT2d_DataMapOfIntegerSequenceOfConnexion_UnBind(self, theKey)

    def Seek(self, theKey):
        return _MAT2d.MAT2d_DataMapOfIntegerSequenceOfConnexion_Seek(self, theKey)

    def Find(self, *args):
        return _MAT2d.MAT2d_DataMapOfIntegerSequenceOfConnexion_Find(self, *args)

    def ChangeSeek(self, theKey):
        return _MAT2d.MAT2d_DataMapOfIntegerSequenceOfConnexion_ChangeSeek(self, theKey)

    def ChangeFind(self, theKey):
        return _MAT2d.MAT2d_DataMapOfIntegerSequenceOfConnexion_ChangeFind(self, theKey)

    def __call__(self, *args):
        return _MAT2d.MAT2d_DataMapOfIntegerSequenceOfConnexion___call__(self, *args)

    def Clear(self, *args):
        return _MAT2d.MAT2d_DataMapOfIntegerSequenceOfConnexion_Clear(self, *args)
    __swig_destroy__ = _MAT2d.delete_MAT2d_DataMapOfIntegerSequenceOfConnexion

    def Size(self):
        return _MAT2d.MAT2d_DataMapOfIntegerSequenceOfConnexion_Size(self)

    def Keys(self):
        return _MAT2d.MAT2d_DataMapOfIntegerSequenceOfConnexion_Keys(self)

# Register MAT2d_DataMapOfIntegerSequenceOfConnexion in _MAT2d:
_MAT2d.MAT2d_DataMapOfIntegerSequenceOfConnexion_swigregister(MAT2d_DataMapOfIntegerSequenceOfConnexion)
class MAT2d_DataMapOfIntegerVec2d(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 _MAT2d.MAT2d_DataMapOfIntegerVec2d_begin(self)

    def end(self):
        return _MAT2d.MAT2d_DataMapOfIntegerVec2d_end(self)

    def cbegin(self):
        return _MAT2d.MAT2d_DataMapOfIntegerVec2d_cbegin(self)

    def cend(self):
        return _MAT2d.MAT2d_DataMapOfIntegerVec2d_cend(self)

    def __init__(self, *args):
        _MAT2d.MAT2d_DataMapOfIntegerVec2d_swiginit(self, _MAT2d.new_MAT2d_DataMapOfIntegerVec2d(*args))

    def Exchange(self, theOther):
        return _MAT2d.MAT2d_DataMapOfIntegerVec2d_Exchange(self, theOther)

    def Assign(self, theOther):
        return _MAT2d.MAT2d_DataMapOfIntegerVec2d_Assign(self, theOther)

    def Set(self, theOther):
        return _MAT2d.MAT2d_DataMapOfIntegerVec2d_Set(self, theOther)

    def ReSize(self, N):
        return _MAT2d.MAT2d_DataMapOfIntegerVec2d_ReSize(self, N)

    def Bind(self, theKey, theItem):
        return _MAT2d.MAT2d_DataMapOfIntegerVec2d_Bind(self, theKey, theItem)

    def Bound(self, theKey, theItem):
        return _MAT2d.MAT2d_DataMapOfIntegerVec2d_Bound(self, theKey, theItem)

    def IsBound(self, theKey):
        return _MAT2d.MAT2d_DataMapOfIntegerVec2d_IsBound(self, theKey)

    def UnBind(self, theKey):
        return _MAT2d.MAT2d_DataMapOfIntegerVec2d_UnBind(self, theKey)

    def Seek(self, theKey):
        return _MAT2d.MAT2d_DataMapOfIntegerVec2d_Seek(self, theKey)

    def Find(self, *args):
        return _MAT2d.MAT2d_DataMapOfIntegerVec2d_Find(self, *args)

    def ChangeSeek(self, theKey):
        return _MAT2d.MAT2d_DataMapOfIntegerVec2d_ChangeSeek(self, theKey)

    def ChangeFind(self, theKey):
        return _MAT2d.MAT2d_DataMapOfIntegerVec2d_ChangeFind(self, theKey)

    def __call__(self, *args):
        return _MAT2d.MAT2d_DataMapOfIntegerVec2d___call__(self, *args)

    def Clear(self, *args):
        return _MAT2d.MAT2d_DataMapOfIntegerVec2d_Clear(self, *args)
    __swig_destroy__ = _MAT2d.delete_MAT2d_DataMapOfIntegerVec2d

    def Size(self):
        return _MAT2d.MAT2d_DataMapOfIntegerVec2d_Size(self)

    def Keys(self):
        return _MAT2d.MAT2d_DataMapOfIntegerVec2d_Keys(self)

# Register MAT2d_DataMapOfIntegerVec2d in _MAT2d:
_MAT2d.MAT2d_DataMapOfIntegerVec2d_swigregister(MAT2d_DataMapOfIntegerVec2d)
class MAT2d_SequenceOfConnexion(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 _MAT2d.MAT2d_SequenceOfConnexion_begin(self)

    def end(self):
        return _MAT2d.MAT2d_SequenceOfConnexion_end(self)

    def cbegin(self):
        return _MAT2d.MAT2d_SequenceOfConnexion_cbegin(self)

    def cend(self):
        return _MAT2d.MAT2d_SequenceOfConnexion_cend(self)

    def __init__(self, *args):
        _MAT2d.MAT2d_SequenceOfConnexion_swiginit(self, _MAT2d.new_MAT2d_SequenceOfConnexion(*args))

    def Size(self):
        return _MAT2d.MAT2d_SequenceOfConnexion_Size(self)

    def Length(self):
        return _MAT2d.MAT2d_SequenceOfConnexion_Length(self)

    def Lower(self):
        return _MAT2d.MAT2d_SequenceOfConnexion_Lower(self)

    def Upper(self):
        return _MAT2d.MAT2d_SequenceOfConnexion_Upper(self)

    def IsEmpty(self):
        return _MAT2d.MAT2d_SequenceOfConnexion_IsEmpty(self)

    def Reverse(self):
        return _MAT2d.MAT2d_SequenceOfConnexion_Reverse(self)

    def Exchange(self, I, J):
        return _MAT2d.MAT2d_SequenceOfConnexion_Exchange(self, I, J)

    @staticmethod
    def delNode(theNode, theAl):
        return _MAT2d.MAT2d_SequenceOfConnexion_delNode(theNode, theAl)

    def Clear(self, theAllocator=0):
        return _MAT2d.MAT2d_SequenceOfConnexion_Clear(self, theAllocator)

    def Assign(self, theOther):
        return _MAT2d.MAT2d_SequenceOfConnexion_Assign(self, theOther)

    def Set(self, theOther):
        return _MAT2d.MAT2d_SequenceOfConnexion_Set(self, theOther)

    def Remove(self, *args):
        return _MAT2d.MAT2d_SequenceOfConnexion_Remove(self, *args)

    def Append(self, *args):
        return _MAT2d.MAT2d_SequenceOfConnexion_Append(self, *args)

    def Prepend(self, *args):
        return _MAT2d.MAT2d_SequenceOfConnexion_Prepend(self, *args)

    def InsertBefore(self, *args):
        return _MAT2d.MAT2d_SequenceOfConnexion_InsertBefore(self, *args)

    def InsertAfter(self, *args):
        return _MAT2d.MAT2d_SequenceOfConnexion_InsertAfter(self, *args)

    def Split(self, theIndex, theSeq):
        return _MAT2d.MAT2d_SequenceOfConnexion_Split(self, theIndex, theSeq)

    def First(self):
        return _MAT2d.MAT2d_SequenceOfConnexion_First(self)

    def ChangeFirst(self):
        return _MAT2d.MAT2d_SequenceOfConnexion_ChangeFirst(self)

    def Last(self):
        return _MAT2d.MAT2d_SequenceOfConnexion_Last(self)

    def ChangeLast(self):
        return _MAT2d.MAT2d_SequenceOfConnexion_ChangeLast(self)

    def Value(self, theIndex):
        return _MAT2d.MAT2d_SequenceOfConnexion_Value(self, theIndex)

    def ChangeValue(self, theIndex):
        return _MAT2d.MAT2d_SequenceOfConnexion_ChangeValue(self, theIndex)

    def __call__(self, *args):
        return _MAT2d.MAT2d_SequenceOfConnexion___call__(self, *args)

    def SetValue(self, theIndex, theItem):
        return _MAT2d.MAT2d_SequenceOfConnexion_SetValue(self, theIndex, theItem)
    __swig_destroy__ = _MAT2d.delete_MAT2d_SequenceOfConnexion

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


# Register MAT2d_SequenceOfConnexion in _MAT2d:
_MAT2d.MAT2d_SequenceOfConnexion_swigregister(MAT2d_SequenceOfConnexion)
class MAT2d_SequenceOfSequenceOfCurve(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 _MAT2d.MAT2d_SequenceOfSequenceOfCurve_begin(self)

    def end(self):
        return _MAT2d.MAT2d_SequenceOfSequenceOfCurve_end(self)

    def cbegin(self):
        return _MAT2d.MAT2d_SequenceOfSequenceOfCurve_cbegin(self)

    def cend(self):
        return _MAT2d.MAT2d_SequenceOfSequenceOfCurve_cend(self)

    def __init__(self, *args):
        _MAT2d.MAT2d_SequenceOfSequenceOfCurve_swiginit(self, _MAT2d.new_MAT2d_SequenceOfSequenceOfCurve(*args))

    def Size(self):
        return _MAT2d.MAT2d_SequenceOfSequenceOfCurve_Size(self)

    def Length(self):
        return _MAT2d.MAT2d_SequenceOfSequenceOfCurve_Length(self)

    def Lower(self):
        return _MAT2d.MAT2d_SequenceOfSequenceOfCurve_Lower(self)

    def Upper(self):
        return _MAT2d.MAT2d_SequenceOfSequenceOfCurve_Upper(self)

    def IsEmpty(self):
        return _MAT2d.MAT2d_SequenceOfSequenceOfCurve_IsEmpty(self)

    def Reverse(self):
        return _MAT2d.MAT2d_SequenceOfSequenceOfCurve_Reverse(self)

    def Exchange(self, I, J):
        return _MAT2d.MAT2d_SequenceOfSequenceOfCurve_Exchange(self, I, J)

    @staticmethod
    def delNode(theNode, theAl):
        return _MAT2d.MAT2d_SequenceOfSequenceOfCurve_delNode(theNode, theAl)

    def Clear(self, theAllocator=0):
        return _MAT2d.MAT2d_SequenceOfSequenceOfCurve_Clear(self, theAllocator)

    def Assign(self, theOther):
        return _MAT2d.MAT2d_SequenceOfSequenceOfCurve_Assign(self, theOther)

    def Set(self, theOther):
        return _MAT2d.MAT2d_SequenceOfSequenceOfCurve_Set(self, theOther)

    def Remove(self, *args):
        return _MAT2d.MAT2d_SequenceOfSequenceOfCurve_Remove(self, *args)

    def Append(self, *args):
        return _MAT2d.MAT2d_SequenceOfSequenceOfCurve_Append(self, *args)

    def Prepend(self, *args):
        return _MAT2d.MAT2d_SequenceOfSequenceOfCurve_Prepend(self, *args)

    def InsertBefore(self, *args):
        return _MAT2d.MAT2d_SequenceOfSequenceOfCurve_InsertBefore(self, *args)

    def InsertAfter(self, *args):
        return _MAT2d.MAT2d_SequenceOfSequenceOfCurve_InsertAfter(self, *args)

    def Split(self, theIndex, theSeq):
        return _MAT2d.MAT2d_SequenceOfSequenceOfCurve_Split(self, theIndex, theSeq)

    def First(self):
        return _MAT2d.MAT2d_SequenceOfSequenceOfCurve_First(self)

    def ChangeFirst(self):
        return _MAT2d.MAT2d_SequenceOfSequenceOfCurve_ChangeFirst(self)

    def Last(self):
        return _MAT2d.MAT2d_SequenceOfSequenceOfCurve_Last(self)

    def ChangeLast(self):
        return _MAT2d.MAT2d_SequenceOfSequenceOfCurve_ChangeLast(self)

    def Value(self, theIndex):
        return _MAT2d.MAT2d_SequenceOfSequenceOfCurve_Value(self, theIndex)

    def ChangeValue(self, theIndex):
        return _MAT2d.MAT2d_SequenceOfSequenceOfCurve_ChangeValue(self, theIndex)

    def __call__(self, *args):
        return _MAT2d.MAT2d_SequenceOfSequenceOfCurve___call__(self, *args)

    def SetValue(self, theIndex, theItem):
        return _MAT2d.MAT2d_SequenceOfSequenceOfCurve_SetValue(self, theIndex, theItem)
    __swig_destroy__ = _MAT2d.delete_MAT2d_SequenceOfSequenceOfCurve

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


# Register MAT2d_SequenceOfSequenceOfCurve in _MAT2d:
_MAT2d.MAT2d_SequenceOfSequenceOfCurve_swigregister(MAT2d_SequenceOfSequenceOfCurve)
class MAT2d_SequenceOfSequenceOfGeometry(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 _MAT2d.MAT2d_SequenceOfSequenceOfGeometry_begin(self)

    def end(self):
        return _MAT2d.MAT2d_SequenceOfSequenceOfGeometry_end(self)

    def cbegin(self):
        return _MAT2d.MAT2d_SequenceOfSequenceOfGeometry_cbegin(self)

    def cend(self):
        return _MAT2d.MAT2d_SequenceOfSequenceOfGeometry_cend(self)

    def __init__(self, *args):
        _MAT2d.MAT2d_SequenceOfSequenceOfGeometry_swiginit(self, _MAT2d.new_MAT2d_SequenceOfSequenceOfGeometry(*args))

    def Size(self):
        return _MAT2d.MAT2d_SequenceOfSequenceOfGeometry_Size(self)

    def Length(self):
        return _MAT2d.MAT2d_SequenceOfSequenceOfGeometry_Length(self)

    def Lower(self):
        return _MAT2d.MAT2d_SequenceOfSequenceOfGeometry_Lower(self)

    def Upper(self):
        return _MAT2d.MAT2d_SequenceOfSequenceOfGeometry_Upper(self)

    def IsEmpty(self):
        return _MAT2d.MAT2d_SequenceOfSequenceOfGeometry_IsEmpty(self)

    def Reverse(self):
        return _MAT2d.MAT2d_SequenceOfSequenceOfGeometry_Reverse(self)

    def Exchange(self, I, J):
        return _MAT2d.MAT2d_SequenceOfSequenceOfGeometry_Exchange(self, I, J)

    @staticmethod
    def delNode(theNode, theAl):
        return _MAT2d.MAT2d_SequenceOfSequenceOfGeometry_delNode(theNode, theAl)

    def Clear(self, theAllocator=0):
        return _MAT2d.MAT2d_SequenceOfSequenceOfGeometry_Clear(self, theAllocator)

    def Assign(self, theOther):
        return _MAT2d.MAT2d_SequenceOfSequenceOfGeometry_Assign(self, theOther)

    def Set(self, theOther):
        return _MAT2d.MAT2d_SequenceOfSequenceOfGeometry_Set(self, theOther)

    def Remove(self, *args):
        return _MAT2d.MAT2d_SequenceOfSequenceOfGeometry_Remove(self, *args)

    def Append(self, *args):
        return _MAT2d.MAT2d_SequenceOfSequenceOfGeometry_Append(self, *args)

    def Prepend(self, *args):
        return _MAT2d.MAT2d_SequenceOfSequenceOfGeometry_Prepend(self, *args)

    def InsertBefore(self, *args):
        return _MAT2d.MAT2d_SequenceOfSequenceOfGeometry_InsertBefore(self, *args)

    def InsertAfter(self, *args):
        return _MAT2d.MAT2d_SequenceOfSequenceOfGeometry_InsertAfter(self, *args)

    def Split(self, theIndex, theSeq):
        return _MAT2d.MAT2d_SequenceOfSequenceOfGeometry_Split(self, theIndex, theSeq)

    def First(self):
        return _MAT2d.MAT2d_SequenceOfSequenceOfGeometry_First(self)

    def ChangeFirst(self):
        return _MAT2d.MAT2d_SequenceOfSequenceOfGeometry_ChangeFirst(self)

    def Last(self):
        return _MAT2d.MAT2d_SequenceOfSequenceOfGeometry_Last(self)

    def ChangeLast(self):
        return _MAT2d.MAT2d_SequenceOfSequenceOfGeometry_ChangeLast(self)

    def Value(self, theIndex):
        return _MAT2d.MAT2d_SequenceOfSequenceOfGeometry_Value(self, theIndex)

    def ChangeValue(self, theIndex):
        return _MAT2d.MAT2d_SequenceOfSequenceOfGeometry_ChangeValue(self, theIndex)

    def __call__(self, *args):
        return _MAT2d.MAT2d_SequenceOfSequenceOfGeometry___call__(self, *args)

    def SetValue(self, theIndex, theItem):
        return _MAT2d.MAT2d_SequenceOfSequenceOfGeometry_SetValue(self, theIndex, theItem)
    __swig_destroy__ = _MAT2d.delete_MAT2d_SequenceOfSequenceOfGeometry

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


# Register MAT2d_SequenceOfSequenceOfGeometry in _MAT2d:
_MAT2d.MAT2d_SequenceOfSequenceOfGeometry_swigregister(MAT2d_SequenceOfSequenceOfGeometry)
class MAT2d_BiInt(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"""

        Parameters
        ----------
        I1: int
        I2: int

        Return
        -------
        None

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

        """
        _MAT2d.MAT2d_BiInt_swiginit(self, _MAT2d.new_MAT2d_BiInt(*args))

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

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

        Parameters
        ----------
        I1: int

        Return
        -------
        None

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

        """
        return _MAT2d.MAT2d_BiInt_FirstIndex(self, *args)

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

        Parameters
        ----------
        B: MAT2d_BiInt

        Return
        -------
        bool

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

        """
        return _MAT2d.MAT2d_BiInt_IsEqual(self, *args)

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

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

        Parameters
        ----------
        I2: int

        Return
        -------
        None

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

        """
        return _MAT2d.MAT2d_BiInt_SecondIndex(self, *args)

    def __eq_wrapper__(self, other):
        return _MAT2d.MAT2d_BiInt___eq_wrapper__(self, other)

    def __eq__(self, right):
        try:
            return self.__eq_wrapper__(right)
        except:
            return False


    __repr__ = _dumps_object

    __swig_destroy__ = _MAT2d.delete_MAT2d_BiInt

# Register MAT2d_BiInt in _MAT2d:
_MAT2d.MAT2d_BiInt_swigregister(MAT2d_BiInt)
class MAT2d_Circuit(OCC.Core.Standard.Standard_Transient):
    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"""

        Parameters
        ----------
        aJoinType: GeomAbs_JoinType (optional, default to GeomAbs_Arc)
        IsOpenResult: bool (optional, default to Standard_False)

        Return
        -------
        None

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

        """
        _MAT2d.MAT2d_Circuit_swiginit(self, _MAT2d.new_MAT2d_Circuit(*args))

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

        Parameters
        ----------
        Index: int

        Return
        -------
        opencascade::handle<MAT2d_Connexion>

        Description
        -----------
        Returns the connexion on the item <index> in me.

        """
        return _MAT2d.MAT2d_Circuit_Connexion(self, *args)

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

        Parameters
        ----------
        Index: int

        Return
        -------
        bool

        Description
        -----------
        Returns <true> is there is a connexion on the item <index> in <self>.

        """
        return _MAT2d.MAT2d_Circuit_ConnexionOn(self, *args)

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

        Parameters
        ----------
        IndexLine: int

        Return
        -------
        int

        Description
        -----------
        Returns the number of items on the line <indexline>.

        """
        return _MAT2d.MAT2d_Circuit_LineLength(self, *args)

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

        Description
        -----------
        Returns the number of items .

        """
        return _MAT2d.MAT2d_Circuit_NumberOfItems(self, *args)

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

        Parameters
        ----------
        aFigure: MAT2d_SequenceOfSequenceOfGeometry
        IsClosed: TColStd_SequenceOfBoolean
        IndRefLine: int
        Trigo: bool

        Return
        -------
        None

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

        """
        return _MAT2d.MAT2d_Circuit_Perform(self, *args)

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

        Parameters
        ----------
        IndLine: int
        IndCurve: int

        Return
        -------
        TColStd_SequenceOfInteger

        Description
        -----------
        Returns the set of index of the items in <self>corresponding to the curve <indcurve> on the line <indline> from the initial figure.

        """
        return _MAT2d.MAT2d_Circuit_RefToEqui(self, *args)

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

        Parameters
        ----------
        Index: int

        Return
        -------
        opencascade::handle<Geom2d_Geometry>

        Description
        -----------
        Returns the item at position <index> in <self>.

        """
        return _MAT2d.MAT2d_Circuit_Value(self, *args)


    @staticmethod
    def DownCast(t):
      return Handle_MAT2d_Circuit_DownCast(t)


    __repr__ = _dumps_object

    __swig_destroy__ = _MAT2d.delete_MAT2d_Circuit

# Register MAT2d_Circuit in _MAT2d:
_MAT2d.MAT2d_Circuit_swigregister(MAT2d_Circuit)
class MAT2d_Connexion(OCC.Core.Standard.Standard_Transient):
    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
        -----------
        No available documentation.

        Parameters
        ----------
        LineA: int
        LineB: int
        ItemA: int
        ItemB: int
        Distance: float
        ParameterOnA: float
        ParameterOnB: float
        PointA: gp_Pnt2d
        PointB: gp_Pnt2d

        Return
        -------
        None

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

        """
        _MAT2d.MAT2d_Connexion_swiginit(self, _MAT2d.new_MAT2d_Connexion(*args))

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

        Description
        -----------
        Returns the distance between the two points.

        Parameters
        ----------
        aDistance: float

        Return
        -------
        None

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

        """
        return _MAT2d.MAT2d_Connexion_Distance(self, *args)

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

        Parameters
        ----------
        Deep: int (optional, default to 0)
        Offset: int (optional, default to 0)

        Return
        -------
        None

        Description
        -----------
        Print <self>.

        """
        return _MAT2d.MAT2d_Connexion_Dump(self, *args)

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

        Description
        -----------
        Returns the index on the first line.

        Parameters
        ----------
        anIndex: int

        Return
        -------
        None

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

        """
        return _MAT2d.MAT2d_Connexion_IndexFirstLine(self, *args)

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

        Description
        -----------
        Returns the index of the item on the first line.

        Parameters
        ----------
        anIndex: int

        Return
        -------
        None

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

        """
        return _MAT2d.MAT2d_Connexion_IndexItemOnFirst(self, *args)

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

        Description
        -----------
        Returns the index of the item on the second line.

        Parameters
        ----------
        anIndex: int

        Return
        -------
        None

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

        """
        return _MAT2d.MAT2d_Connexion_IndexItemOnSecond(self, *args)

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

        Description
        -----------
        Returns the index on the second line.

        Parameters
        ----------
        anIndex: int

        Return
        -------
        None

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

        """
        return _MAT2d.MAT2d_Connexion_IndexSecondLine(self, *args)

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

        Parameters
        ----------
        aConnexion: MAT2d_Connexion
        aSense: float

        Return
        -------
        bool

        Description
        -----------
        Returns <true> if my firstpoint is on the same line than the firstpoint of <aconnexion> and my firstpoint is after the firstpoint of <aconnexion> on the line. <asense> = 1 if <aconnexion> is on the left of its firstline, else <asense> = -1.

        """
        return _MAT2d.MAT2d_Connexion_IsAfter(self, *args)

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

        Description
        -----------
        Returns the parameter of the point on the firstline.

        Parameters
        ----------
        aParameter: float

        Return
        -------
        None

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

        """
        return _MAT2d.MAT2d_Connexion_ParameterOnFirst(self, *args)

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

        Description
        -----------
        Returns the parameter of the point on the secondline.

        Parameters
        ----------
        aParameter: float

        Return
        -------
        None

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

        """
        return _MAT2d.MAT2d_Connexion_ParameterOnSecond(self, *args)

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

        Description
        -----------
        Returns the point on the firstline.

        Parameters
        ----------
        aPoint: gp_Pnt2d

        Return
        -------
        None

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

        """
        return _MAT2d.MAT2d_Connexion_PointOnFirst(self, *args)

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

        Description
        -----------
        Returns the point on the secondline.

        Parameters
        ----------
        aPoint: gp_Pnt2d

        Return
        -------
        None

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

        """
        return _MAT2d.MAT2d_Connexion_PointOnSecond(self, *args)

    def Reverse(self, *args):
        r"""
        Return
        -------
        opencascade::handle<MAT2d_Connexion>

        Description
        -----------
        Returns the reverse connexion of <self>. the firstpoint is the secondpoint. the secondpoint is the firstpoint.

        """
        return _MAT2d.MAT2d_Connexion_Reverse(self, *args)


    @staticmethod
    def DownCast(t):
      return Handle_MAT2d_Connexion_DownCast(t)


    __repr__ = _dumps_object

    __swig_destroy__ = _MAT2d.delete_MAT2d_Connexion

# Register MAT2d_Connexion in _MAT2d:
_MAT2d.MAT2d_Connexion_swigregister(MAT2d_Connexion)
class MAT2d_MapBiIntHasher(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def HashCode(*args):
        r"""

        Parameters
        ----------
        theKey: MAT2d_BiInt
        theUpperBound: int

        Return
        -------
        int

        Description
        -----------
        Computes a hash code for the given key, in the range [1, theupperbound] @param thekey the key which hash code is to be computed @param theupperbound the upper bound of the range a computing hash code must be within return a computed hash code, in the range [1, theupperbound].

        """
        return _MAT2d.MAT2d_MapBiIntHasher_HashCode(*args)

    @staticmethod
    def IsEqual(*args):
        r"""

        Parameters
        ----------
        Key1: MAT2d_BiInt
        Key2: MAT2d_BiInt

        Return
        -------
        bool

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

        """
        return _MAT2d.MAT2d_MapBiIntHasher_IsEqual(*args)

    __repr__ = _dumps_object


    def __init__(self):
        _MAT2d.MAT2d_MapBiIntHasher_swiginit(self, _MAT2d.new_MAT2d_MapBiIntHasher())
    __swig_destroy__ = _MAT2d.delete_MAT2d_MapBiIntHasher

# Register MAT2d_MapBiIntHasher in _MAT2d:
_MAT2d.MAT2d_MapBiIntHasher_swigregister(MAT2d_MapBiIntHasher)
class MAT2d_Mat2d(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"""

        Parameters
        ----------
        IsOpenResult: bool (optional, default to Standard_False)

        Return
        -------
        None

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

        """
        _MAT2d.MAT2d_Mat2d_swiginit(self, _MAT2d.new_MAT2d_Mat2d(*args))

    def bisector(self, *args):
        r"""
        Return
        -------
        opencascade::handle<MAT_Bisector>

        Description
        -----------
        Returns the current root.

        """
        return _MAT2d.MAT2d_Mat2d_bisector(self, *args)

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

        Parameters
        ----------
        aTool: MAT2d_Tool2d

        Return
        -------
        None

        Description
        -----------
        Algorithm of computation of the bisecting locus.

        """
        return _MAT2d.MAT2d_Mat2d_CreateMat(self, *args)

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

        Parameters
        ----------
        aTool: MAT2d_Tool2d

        Return
        -------
        None

        Description
        -----------
        Algorithm of computation of the bisecting locus for open wire.

        """
        return _MAT2d.MAT2d_Mat2d_CreateMatOpen(self, *args)

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

        Description
        -----------
        Initialize an iterator on the set of the roots of the trees of bisectors.

        """
        return _MAT2d.MAT2d_Mat2d_Init(self, *args)

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

        Description
        -----------
        Returns <true> if createmat has succeeded.

        """
        return _MAT2d.MAT2d_Mat2d_IsDone(self, *args)

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

        Description
        -----------
        Return false if there is no more roots.

        """
        return _MAT2d.MAT2d_Mat2d_More(self, *args)

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

        Description
        -----------
        Move to the next root.

        """
        return _MAT2d.MAT2d_Mat2d_Next(self, *args)

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

        Description
        -----------
        Returns the total number of bisectors.

        """
        return _MAT2d.MAT2d_Mat2d_NumberOfBisectors(self, *args)

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

        Description
        -----------
        Returns true if there are semi_infinite bisectors. so there is a tree for each semi_infinte bisector.

        """
        return _MAT2d.MAT2d_Mat2d_SemiInfinite(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _MAT2d.delete_MAT2d_Mat2d

# Register MAT2d_Mat2d in _MAT2d:
_MAT2d.MAT2d_Mat2d_swigregister(MAT2d_Mat2d)
class MAT2d_MiniPath(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
        -----------
        No available documentation.

        """
        _MAT2d.MAT2d_MiniPath_swiginit(self, _MAT2d.new_MAT2d_MiniPath(*args))

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

        Parameters
        ----------
        Index: int

        Return
        -------
        MAT2d_SequenceOfConnexion

        Description
        -----------
        Returns the connexions which start on line designed by <index>.

        """
        return _MAT2d.MAT2d_MiniPath_ConnexionsFrom(self, *args)

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

        Parameters
        ----------
        Index: int

        Return
        -------
        opencascade::handle<MAT2d_Connexion>

        Description
        -----------
        Returns the connexion which ends on line designed by <index>.

        """
        return _MAT2d.MAT2d_MiniPath_Father(self, *args)

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

        Parameters
        ----------
        Index: int

        Return
        -------
        bool

        Description
        -----------
        Returns <true> if there is one connexion which starts on line designed by <index>.

        """
        return _MAT2d.MAT2d_MiniPath_IsConnexionsFrom(self, *args)

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

        Parameters
        ----------
        Index: int

        Return
        -------
        bool

        Description
        -----------
        Returns <true> if the line designed by <index> is the root.

        """
        return _MAT2d.MAT2d_MiniPath_IsRoot(self, *args)

    def Path(self, *args):
        r"""
        Return
        -------
        MAT2d_SequenceOfConnexion

        Description
        -----------
        Returns the sequence of connexions corresponding to the path.

        """
        return _MAT2d.MAT2d_MiniPath_Path(self, *args)

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

        Parameters
        ----------
        Figure: MAT2d_SequenceOfSequenceOfGeometry
        IndStart: int
        Sense: bool

        Return
        -------
        None

        Description
        -----------
        Computes the path to link the lines in <figure>. the path starts on the line of index <indstart> <sense> = true if the circuit turns in the trigonometric sense.

        """
        return _MAT2d.MAT2d_MiniPath_Perform(self, *args)

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

        Description
        -----------
        Run on the set of connexions to compute the path. the path is an exploration of the tree which contains the connexions and their reverses. if the tree of connexions is a / | b e / | | c d f //! the path is a->b, b->c, c->b, b->d, d->b, b->a, a->e, e->f, f->e, e->a.

        """
        return _MAT2d.MAT2d_MiniPath_RunOnConnexions(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _MAT2d.delete_MAT2d_MiniPath

# Register MAT2d_MiniPath in _MAT2d:
_MAT2d.MAT2d_MiniPath_swigregister(MAT2d_MiniPath)
class MAT2d_Tool2d(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.

        """
        _MAT2d.MAT2d_Tool2d_swiginit(self, _MAT2d.new_MAT2d_Tool2d(*args))

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

        Parameters
        ----------
        Index1: int
        Index2: int

        Return
        -------
        None

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

        """
        return _MAT2d.MAT2d_Tool2d_BisecFusion(self, *args)

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

        Parameters
        ----------
        Index: int

        Return
        -------
        Bisector_Bisec

        Description
        -----------
        Returns the <bisec> of index <index> in <thegeombisectors>.

        """
        return _MAT2d.MAT2d_Tool2d_ChangeGeomBis(self, *args)

    def Circuit(self, *args):
        r"""
        Return
        -------
        opencascade::handle<MAT2d_Circuit>

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

        """
        return _MAT2d.MAT2d_Tool2d_Circuit(self, *args)

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

        Parameters
        ----------
        abisector: MAT_Bisector

        Return
        -------
        None

        Description
        -----------
        Creates the geometric bisector defined by <abisector>.

        """
        return _MAT2d.MAT2d_Tool2d_CreateBisector(self, *args)

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

        Parameters
        ----------
        abisector: MAT_Bisector
        param1: float
        param2: float

        Return
        -------
        float

        Description
        -----------
        Returns the distance between the two points designed by their parameters on <abisector>.

        """
        return _MAT2d.MAT2d_Tool2d_Distance(self, *args)

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

        Parameters
        ----------
        bisector: int
        erease: int

        Return
        -------
        None

        Description
        -----------
        Displays information about the bisector defined by <bisector>.

        """
        return _MAT2d.MAT2d_Tool2d_Dump(self, *args)

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

        Parameters
        ----------
        anitem: int

        Return
        -------
        dist: float

        Description
        -----------
        Creates the point at the origin of the bisector between anitem and the previous item. dist is the distance from the firstpoint to <anitem>. returns the index of this point in <thegeompnts>.

        """
        return _MAT2d.MAT2d_Tool2d_FirstPoint(self, *args)

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

        Parameters
        ----------
        Index: int

        Return
        -------
        Bisector_Bisec

        Description
        -----------
        Returns the <bisec> of index <index> in <thegeombisectors>.

        """
        return _MAT2d.MAT2d_Tool2d_GeomBis(self, *args)

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

        Parameters
        ----------
        Index: int

        Return
        -------
        opencascade::handle<Geom2d_Geometry>

        Description
        -----------
        Returns the geometry of index <index> in <thegeomelts>.

        """
        return _MAT2d.MAT2d_Tool2d_GeomElt(self, *args)

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

        Parameters
        ----------
        Index: int

        Return
        -------
        gp_Pnt2d

        Description
        -----------
        Returns the point of index <index> in the <thegeompnts>.

        """
        return _MAT2d.MAT2d_Tool2d_GeomPnt(self, *args)

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

        Parameters
        ----------
        Index: int

        Return
        -------
        gp_Vec2d

        Description
        -----------
        Returns the vector of index <index> in the <thegeomvecs>.

        """
        return _MAT2d.MAT2d_Tool2d_GeomVec(self, *args)

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

        Parameters
        ----------
        aCircuit: MAT2d_Circuit

        Return
        -------
        None

        Description
        -----------
        Inititems cuts the line in items. this items are the geometrics representations of the basicelts from mat.

        """
        return _MAT2d.MAT2d_Tool2d_InitItems(self, *args)

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

        Parameters
        ----------
        bisectorone: MAT_Bisector
        bisectortwo: MAT_Bisector

        Return
        -------
        intpnt: int

        Description
        -----------
        Computes the point of intersection between the bisectors defined by <bisectorone> and <bisectortwo> . if this point exists, <intpnt> is its index in <thegeompnts> and return the distance of the point from the bisector else return <reallast>.

        """
        return _MAT2d.MAT2d_Tool2d_IntersectBisector(self, *args)

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

        Description
        -----------
        Returns the number of items .

        """
        return _MAT2d.MAT2d_Tool2d_NumberOfItems(self, *args)

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

        Parameters
        ----------
        aside: MAT_Side

        Return
        -------
        None

        Description
        -----------
        <aside> defines the side of the computation of the map.

        """
        return _MAT2d.MAT2d_Tool2d_Sense(self, *args)

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

        Parameters
        ----------
        aJoinType: GeomAbs_JoinType

        Return
        -------
        None

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

        """
        return _MAT2d.MAT2d_Tool2d_SetJoinType(self, *args)

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

        Parameters
        ----------
        bisector: int

        Return
        -------
        int

        Description
        -----------
        Creates the tangent at the end of the bisector defined by <bisector>. returns the index of this vector in <thegeomvecs>.

        """
        return _MAT2d.MAT2d_Tool2d_Tangent(self, *args)

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

        Parameters
        ----------
        anitem: int
        IsOpenResult: bool

        Return
        -------
        int

        Description
        -----------
        Creates the reversed tangent at the origin of the item defined by <anitem>. returns the index of this vector in <thegeomvecs>.

        """
        return _MAT2d.MAT2d_Tool2d_TangentAfter(self, *args)

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

        Parameters
        ----------
        anitem: int
        IsOpenResult: bool

        Return
        -------
        int

        Description
        -----------
        Creates the tangent at the end of the item defined by <anitem>. returns the index of this vector in <thegeomvecs>.

        """
        return _MAT2d.MAT2d_Tool2d_TangentBefore(self, *args)

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

        Description
        -----------
        Returns tolerance to test the confusion of two points.

        """
        return _MAT2d.MAT2d_Tool2d_ToleranceOfConfusion(self, *args)

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

        Parameters
        ----------
        abisector: MAT_Bisector

        Return
        -------
        bool

        Description
        -----------
        Trims the geometric bisector by the <firstparameter> of <abisector>. if the parameter is out of the bisector, return false. else return true.

        Parameters
        ----------
        abisector: MAT_Bisector
        apoint: int

        Return
        -------
        bool

        Description
        -----------
        Trims the geometric bisector by the point of index <apoint> in <thegeompnts>. if the point is out of the bisector, return false. else return true.

        """
        return _MAT2d.MAT2d_Tool2d_TrimBisector(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _MAT2d.delete_MAT2d_Tool2d

# Register MAT2d_Tool2d in _MAT2d:
_MAT2d.MAT2d_Tool2d_swigregister(MAT2d_Tool2d)

@classnotwrapped
class MAT2d_SketchExplorer:
	pass

@classnotwrapped
class MAT2d_CutCurve:
	pass





@deprecated
def MAT2d_MapBiIntHasher_HashCode(*args):
	return MAT2d_MapBiIntHasher.HashCode(*args)

@deprecated
def MAT2d_MapBiIntHasher_IsEqual(*args):
	return MAT2d_MapBiIntHasher.IsEqual(*args)



