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


import collections

from sys import version_info as _version_info
if _version_info < (3, 7, 0):
    raise RuntimeError("Python 3.7 or later required")

from . import _ITKCommonPython


from . import _ITKCommonPython



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

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


if _swig_python_version_info[0:2] >= (3, 3):
    import collections.abc
else:
    import collections

import itk.itkVectorPython
import itk.vnl_vector_refPython
import itk.stdcomplexPython
import itk.pyBasePython
import itk.vnl_vectorPython
import itk.vnl_matrixPython
import itk.itkFixedArrayPython
import itk.ITKCommonBasePython
import itk.itkMatrixPython
import itk.itkPointPython
import itk.itkCovariantVectorPython
import itk.vnl_matrix_fixedPython

def itkMapContainerULD_New():
    return itkMapContainerULD.New()

class itkMapContainerULD(itk.ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkMapContainerULD class."""

    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"""
        __init__(self) -> itkMapContainerULD
        __init__(self, comp) -> itkMapContainerULD

        Parameters
        ----------
        comp: std::less< unsigned long > const &

        """
        _itkMapContainerPython.itkMapContainerULD_swiginit(self, _itkMapContainerPython.new_itkMapContainerULD(*args))

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkMapContainerULD_Pointer"""
        return _itkMapContainerPython.itkMapContainerULD___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMapContainerULD_Pointer"""
        return _itkMapContainerPython.itkMapContainerULD_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> mapULD"""
        return _itkMapContainerPython.itkMapContainerULD_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> mapULD"""
        return _itkMapContainerPython.itkMapContainerULD_CastToSTLConstContainer(self)

    def ElementAt(self, *args):
        r"""
        ElementAt(self, arg0) -> double

        Parameters
        ----------
        arg0: unsigned long

        ElementAt(self, arg0) -> double const &

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULD_ElementAt(self, *args)

    def CreateElementAt(self, arg0):
        r"""
        CreateElementAt(self, arg0) -> double &

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULD_CreateElementAt(self, arg0)

    def GetElement(self, arg0):
        r"""
        GetElement(self, arg0) -> double

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULD_GetElement(self, arg0)

    def SetElement(self, arg0, arg1):
        r"""
        SetElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned long
        arg1: double

        """
        return _itkMapContainerPython.itkMapContainerULD_SetElement(self, arg0, arg1)

    def InsertElement(self, arg0, arg1):
        r"""
        InsertElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned long
        arg1: double

        """
        return _itkMapContainerPython.itkMapContainerULD_InsertElement(self, arg0, arg1)

    def IndexExists(self, arg0):
        r"""
        IndexExists(self, arg0) -> bool

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULD_IndexExists(self, arg0)

    def GetElementIfIndexExists(self, arg0, arg1):
        r"""
        GetElementIfIndexExists(self, arg0, arg1) -> bool

        Parameters
        ----------
        arg0: unsigned long
        arg1: double *

        """
        return _itkMapContainerPython.itkMapContainerULD_GetElementIfIndexExists(self, arg0, arg1)

    def CreateIndex(self, arg0):
        r"""
        CreateIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULD_CreateIndex(self, arg0)

    def DeleteIndex(self, arg0):
        r"""
        DeleteIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULD_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned long"""
        return _itkMapContainerPython.itkMapContainerULD_Size(self)

    def Reserve(self, arg0):
        r"""
        Reserve(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULD_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _itkMapContainerPython.itkMapContainerULD_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _itkMapContainerPython.itkMapContainerULD_Initialize(self)
    __swig_destroy__ = _itkMapContainerPython.delete_itkMapContainerULD

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkMapContainerULD

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _itkMapContainerPython.itkMapContainerULD_cast(obj)

    def New(*args, **kargs):
        """New() -> itkMapContainerULD

        Create a new object of the class itkMapContainerULD and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkMapContainerULD.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkMapContainerULD.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkMapContainerULD.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMapContainerULD in _itkMapContainerPython:
_itkMapContainerPython.itkMapContainerULD_swigregister(itkMapContainerULD)

def itkMapContainerULF_New():
    return itkMapContainerULF.New()

class itkMapContainerULF(itk.ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkMapContainerULF class."""

    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"""
        __init__(self) -> itkMapContainerULF
        __init__(self, comp) -> itkMapContainerULF

        Parameters
        ----------
        comp: std::less< unsigned long > const &

        """
        _itkMapContainerPython.itkMapContainerULF_swiginit(self, _itkMapContainerPython.new_itkMapContainerULF(*args))

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkMapContainerULF_Pointer"""
        return _itkMapContainerPython.itkMapContainerULF___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMapContainerULF_Pointer"""
        return _itkMapContainerPython.itkMapContainerULF_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> std::map< unsigned long,float,std::less< unsigned long >,std::allocator< std::pair< unsigned long const,float > > > &"""
        return _itkMapContainerPython.itkMapContainerULF_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> std::map< unsigned long,float,std::less< unsigned long >,std::allocator< std::pair< unsigned long const,float > > > const &"""
        return _itkMapContainerPython.itkMapContainerULF_CastToSTLConstContainer(self)

    def ElementAt(self, *args):
        r"""
        ElementAt(self, arg0) -> float

        Parameters
        ----------
        arg0: unsigned long

        ElementAt(self, arg0) -> float const &

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULF_ElementAt(self, *args)

    def CreateElementAt(self, arg0):
        r"""
        CreateElementAt(self, arg0) -> float &

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULF_CreateElementAt(self, arg0)

    def GetElement(self, arg0):
        r"""
        GetElement(self, arg0) -> float

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULF_GetElement(self, arg0)

    def SetElement(self, arg0, arg1):
        r"""
        SetElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned long
        arg1: float

        """
        return _itkMapContainerPython.itkMapContainerULF_SetElement(self, arg0, arg1)

    def InsertElement(self, arg0, arg1):
        r"""
        InsertElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned long
        arg1: float

        """
        return _itkMapContainerPython.itkMapContainerULF_InsertElement(self, arg0, arg1)

    def IndexExists(self, arg0):
        r"""
        IndexExists(self, arg0) -> bool

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULF_IndexExists(self, arg0)

    def GetElementIfIndexExists(self, arg0, arg1):
        r"""
        GetElementIfIndexExists(self, arg0, arg1) -> bool

        Parameters
        ----------
        arg0: unsigned long
        arg1: float *

        """
        return _itkMapContainerPython.itkMapContainerULF_GetElementIfIndexExists(self, arg0, arg1)

    def CreateIndex(self, arg0):
        r"""
        CreateIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULF_CreateIndex(self, arg0)

    def DeleteIndex(self, arg0):
        r"""
        DeleteIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULF_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned long"""
        return _itkMapContainerPython.itkMapContainerULF_Size(self)

    def Reserve(self, arg0):
        r"""
        Reserve(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULF_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _itkMapContainerPython.itkMapContainerULF_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _itkMapContainerPython.itkMapContainerULF_Initialize(self)
    __swig_destroy__ = _itkMapContainerPython.delete_itkMapContainerULF

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkMapContainerULF

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _itkMapContainerPython.itkMapContainerULF_cast(obj)

    def New(*args, **kargs):
        """New() -> itkMapContainerULF

        Create a new object of the class itkMapContainerULF and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkMapContainerULF.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkMapContainerULF.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkMapContainerULF.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMapContainerULF in _itkMapContainerPython:
_itkMapContainerPython.itkMapContainerULF_swigregister(itkMapContainerULF)

def itkMapContainerULPD2_New():
    return itkMapContainerULPD2.New()

class itkMapContainerULPD2(itk.ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkMapContainerULPD2 class."""

    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"""
        __init__(self) -> itkMapContainerULPD2
        __init__(self, comp) -> itkMapContainerULPD2

        Parameters
        ----------
        comp: std::less< unsigned long > const &

        """
        _itkMapContainerPython.itkMapContainerULPD2_swiginit(self, _itkMapContainerPython.new_itkMapContainerULPD2(*args))

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkMapContainerULPD2_Pointer"""
        return _itkMapContainerPython.itkMapContainerULPD2___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMapContainerULPD2_Pointer"""
        return _itkMapContainerPython.itkMapContainerULPD2_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> std::map< unsigned long,itkPointD2,std::less< unsigned long >,std::allocator< std::pair< unsigned long const,itkPointD2 > > > &"""
        return _itkMapContainerPython.itkMapContainerULPD2_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> std::map< unsigned long,itkPointD2,std::less< unsigned long >,std::allocator< std::pair< unsigned long const,itkPointD2 > > > const &"""
        return _itkMapContainerPython.itkMapContainerULPD2_CastToSTLConstContainer(self)

    def ElementAt(self, *args):
        r"""
        ElementAt(self, arg0) -> itkPointD2

        Parameters
        ----------
        arg0: unsigned long

        ElementAt(self, arg0) -> itkPointD2

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULPD2_ElementAt(self, *args)

    def CreateElementAt(self, arg0):
        r"""
        CreateElementAt(self, arg0) -> itkPointD2

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULPD2_CreateElementAt(self, arg0)

    def GetElement(self, arg0):
        r"""
        GetElement(self, arg0) -> itkPointD2

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULPD2_GetElement(self, arg0)

    def SetElement(self, arg0, arg1):
        r"""
        SetElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkPointD2

        """
        return _itkMapContainerPython.itkMapContainerULPD2_SetElement(self, arg0, arg1)

    def InsertElement(self, arg0, arg1):
        r"""
        InsertElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkPointD2

        """
        return _itkMapContainerPython.itkMapContainerULPD2_InsertElement(self, arg0, arg1)

    def IndexExists(self, arg0):
        r"""
        IndexExists(self, arg0) -> bool

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULPD2_IndexExists(self, arg0)

    def GetElementIfIndexExists(self, arg0, arg1):
        r"""
        GetElementIfIndexExists(self, arg0, arg1) -> bool

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkPointD2 *

        """
        return _itkMapContainerPython.itkMapContainerULPD2_GetElementIfIndexExists(self, arg0, arg1)

    def CreateIndex(self, arg0):
        r"""
        CreateIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULPD2_CreateIndex(self, arg0)

    def DeleteIndex(self, arg0):
        r"""
        DeleteIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULPD2_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned long"""
        return _itkMapContainerPython.itkMapContainerULPD2_Size(self)

    def Reserve(self, arg0):
        r"""
        Reserve(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULPD2_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _itkMapContainerPython.itkMapContainerULPD2_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _itkMapContainerPython.itkMapContainerULPD2_Initialize(self)
    __swig_destroy__ = _itkMapContainerPython.delete_itkMapContainerULPD2

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkMapContainerULPD2

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _itkMapContainerPython.itkMapContainerULPD2_cast(obj)

    def New(*args, **kargs):
        """New() -> itkMapContainerULPD2

        Create a new object of the class itkMapContainerULPD2 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkMapContainerULPD2.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkMapContainerULPD2.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkMapContainerULPD2.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMapContainerULPD2 in _itkMapContainerPython:
_itkMapContainerPython.itkMapContainerULPD2_swigregister(itkMapContainerULPD2)

def itkMapContainerULPD3_New():
    return itkMapContainerULPD3.New()

class itkMapContainerULPD3(itk.ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkMapContainerULPD3 class."""

    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"""
        __init__(self) -> itkMapContainerULPD3
        __init__(self, comp) -> itkMapContainerULPD3

        Parameters
        ----------
        comp: std::less< unsigned long > const &

        """
        _itkMapContainerPython.itkMapContainerULPD3_swiginit(self, _itkMapContainerPython.new_itkMapContainerULPD3(*args))

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkMapContainerULPD3_Pointer"""
        return _itkMapContainerPython.itkMapContainerULPD3___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMapContainerULPD3_Pointer"""
        return _itkMapContainerPython.itkMapContainerULPD3_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> std::map< unsigned long,itkPointD3,std::less< unsigned long >,std::allocator< std::pair< unsigned long const,itkPointD3 > > > &"""
        return _itkMapContainerPython.itkMapContainerULPD3_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> std::map< unsigned long,itkPointD3,std::less< unsigned long >,std::allocator< std::pair< unsigned long const,itkPointD3 > > > const &"""
        return _itkMapContainerPython.itkMapContainerULPD3_CastToSTLConstContainer(self)

    def ElementAt(self, *args):
        r"""
        ElementAt(self, arg0) -> itkPointD3

        Parameters
        ----------
        arg0: unsigned long

        ElementAt(self, arg0) -> itkPointD3

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULPD3_ElementAt(self, *args)

    def CreateElementAt(self, arg0):
        r"""
        CreateElementAt(self, arg0) -> itkPointD3

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULPD3_CreateElementAt(self, arg0)

    def GetElement(self, arg0):
        r"""
        GetElement(self, arg0) -> itkPointD3

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULPD3_GetElement(self, arg0)

    def SetElement(self, arg0, arg1):
        r"""
        SetElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkPointD3

        """
        return _itkMapContainerPython.itkMapContainerULPD3_SetElement(self, arg0, arg1)

    def InsertElement(self, arg0, arg1):
        r"""
        InsertElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkPointD3

        """
        return _itkMapContainerPython.itkMapContainerULPD3_InsertElement(self, arg0, arg1)

    def IndexExists(self, arg0):
        r"""
        IndexExists(self, arg0) -> bool

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULPD3_IndexExists(self, arg0)

    def GetElementIfIndexExists(self, arg0, arg1):
        r"""
        GetElementIfIndexExists(self, arg0, arg1) -> bool

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkPointD3 *

        """
        return _itkMapContainerPython.itkMapContainerULPD3_GetElementIfIndexExists(self, arg0, arg1)

    def CreateIndex(self, arg0):
        r"""
        CreateIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULPD3_CreateIndex(self, arg0)

    def DeleteIndex(self, arg0):
        r"""
        DeleteIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULPD3_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned long"""
        return _itkMapContainerPython.itkMapContainerULPD3_Size(self)

    def Reserve(self, arg0):
        r"""
        Reserve(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULPD3_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _itkMapContainerPython.itkMapContainerULPD3_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _itkMapContainerPython.itkMapContainerULPD3_Initialize(self)
    __swig_destroy__ = _itkMapContainerPython.delete_itkMapContainerULPD3

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkMapContainerULPD3

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _itkMapContainerPython.itkMapContainerULPD3_cast(obj)

    def New(*args, **kargs):
        """New() -> itkMapContainerULPD3

        Create a new object of the class itkMapContainerULPD3 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkMapContainerULPD3.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkMapContainerULPD3.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkMapContainerULPD3.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMapContainerULPD3 in _itkMapContainerPython:
_itkMapContainerPython.itkMapContainerULPD3_swigregister(itkMapContainerULPD3)

def itkMapContainerULPF2_New():
    return itkMapContainerULPF2.New()

class itkMapContainerULPF2(itk.ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkMapContainerULPF2 class."""

    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"""
        __init__(self) -> itkMapContainerULPF2
        __init__(self, comp) -> itkMapContainerULPF2

        Parameters
        ----------
        comp: std::less< unsigned long > const &

        """
        _itkMapContainerPython.itkMapContainerULPF2_swiginit(self, _itkMapContainerPython.new_itkMapContainerULPF2(*args))

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkMapContainerULPF2_Pointer"""
        return _itkMapContainerPython.itkMapContainerULPF2___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMapContainerULPF2_Pointer"""
        return _itkMapContainerPython.itkMapContainerULPF2_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> std::map< unsigned long,itkPointF2,std::less< unsigned long >,std::allocator< std::pair< unsigned long const,itkPointF2 > > > &"""
        return _itkMapContainerPython.itkMapContainerULPF2_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> std::map< unsigned long,itkPointF2,std::less< unsigned long >,std::allocator< std::pair< unsigned long const,itkPointF2 > > > const &"""
        return _itkMapContainerPython.itkMapContainerULPF2_CastToSTLConstContainer(self)

    def ElementAt(self, *args):
        r"""
        ElementAt(self, arg0) -> itkPointF2

        Parameters
        ----------
        arg0: unsigned long

        ElementAt(self, arg0) -> itkPointF2

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULPF2_ElementAt(self, *args)

    def CreateElementAt(self, arg0):
        r"""
        CreateElementAt(self, arg0) -> itkPointF2

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULPF2_CreateElementAt(self, arg0)

    def GetElement(self, arg0):
        r"""
        GetElement(self, arg0) -> itkPointF2

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULPF2_GetElement(self, arg0)

    def SetElement(self, arg0, arg1):
        r"""
        SetElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkPointF2

        """
        return _itkMapContainerPython.itkMapContainerULPF2_SetElement(self, arg0, arg1)

    def InsertElement(self, arg0, arg1):
        r"""
        InsertElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkPointF2

        """
        return _itkMapContainerPython.itkMapContainerULPF2_InsertElement(self, arg0, arg1)

    def IndexExists(self, arg0):
        r"""
        IndexExists(self, arg0) -> bool

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULPF2_IndexExists(self, arg0)

    def GetElementIfIndexExists(self, arg0, arg1):
        r"""
        GetElementIfIndexExists(self, arg0, arg1) -> bool

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkPointF2 *

        """
        return _itkMapContainerPython.itkMapContainerULPF2_GetElementIfIndexExists(self, arg0, arg1)

    def CreateIndex(self, arg0):
        r"""
        CreateIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULPF2_CreateIndex(self, arg0)

    def DeleteIndex(self, arg0):
        r"""
        DeleteIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULPF2_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned long"""
        return _itkMapContainerPython.itkMapContainerULPF2_Size(self)

    def Reserve(self, arg0):
        r"""
        Reserve(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULPF2_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _itkMapContainerPython.itkMapContainerULPF2_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _itkMapContainerPython.itkMapContainerULPF2_Initialize(self)
    __swig_destroy__ = _itkMapContainerPython.delete_itkMapContainerULPF2

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkMapContainerULPF2

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _itkMapContainerPython.itkMapContainerULPF2_cast(obj)

    def New(*args, **kargs):
        """New() -> itkMapContainerULPF2

        Create a new object of the class itkMapContainerULPF2 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkMapContainerULPF2.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkMapContainerULPF2.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkMapContainerULPF2.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMapContainerULPF2 in _itkMapContainerPython:
_itkMapContainerPython.itkMapContainerULPF2_swigregister(itkMapContainerULPF2)

def itkMapContainerULPF3_New():
    return itkMapContainerULPF3.New()

class itkMapContainerULPF3(itk.ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkMapContainerULPF3 class."""

    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"""
        __init__(self) -> itkMapContainerULPF3
        __init__(self, comp) -> itkMapContainerULPF3

        Parameters
        ----------
        comp: std::less< unsigned long > const &

        """
        _itkMapContainerPython.itkMapContainerULPF3_swiginit(self, _itkMapContainerPython.new_itkMapContainerULPF3(*args))

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkMapContainerULPF3_Pointer"""
        return _itkMapContainerPython.itkMapContainerULPF3___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMapContainerULPF3_Pointer"""
        return _itkMapContainerPython.itkMapContainerULPF3_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> std::map< unsigned long,itkPointF3,std::less< unsigned long >,std::allocator< std::pair< unsigned long const,itkPointF3 > > > &"""
        return _itkMapContainerPython.itkMapContainerULPF3_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> std::map< unsigned long,itkPointF3,std::less< unsigned long >,std::allocator< std::pair< unsigned long const,itkPointF3 > > > const &"""
        return _itkMapContainerPython.itkMapContainerULPF3_CastToSTLConstContainer(self)

    def ElementAt(self, *args):
        r"""
        ElementAt(self, arg0) -> itkPointF3

        Parameters
        ----------
        arg0: unsigned long

        ElementAt(self, arg0) -> itkPointF3

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULPF3_ElementAt(self, *args)

    def CreateElementAt(self, arg0):
        r"""
        CreateElementAt(self, arg0) -> itkPointF3

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULPF3_CreateElementAt(self, arg0)

    def GetElement(self, arg0):
        r"""
        GetElement(self, arg0) -> itkPointF3

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULPF3_GetElement(self, arg0)

    def SetElement(self, arg0, arg1):
        r"""
        SetElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkPointF3

        """
        return _itkMapContainerPython.itkMapContainerULPF3_SetElement(self, arg0, arg1)

    def InsertElement(self, arg0, arg1):
        r"""
        InsertElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkPointF3

        """
        return _itkMapContainerPython.itkMapContainerULPF3_InsertElement(self, arg0, arg1)

    def IndexExists(self, arg0):
        r"""
        IndexExists(self, arg0) -> bool

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULPF3_IndexExists(self, arg0)

    def GetElementIfIndexExists(self, arg0, arg1):
        r"""
        GetElementIfIndexExists(self, arg0, arg1) -> bool

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkPointF3 *

        """
        return _itkMapContainerPython.itkMapContainerULPF3_GetElementIfIndexExists(self, arg0, arg1)

    def CreateIndex(self, arg0):
        r"""
        CreateIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULPF3_CreateIndex(self, arg0)

    def DeleteIndex(self, arg0):
        r"""
        DeleteIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULPF3_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned long"""
        return _itkMapContainerPython.itkMapContainerULPF3_Size(self)

    def Reserve(self, arg0):
        r"""
        Reserve(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULPF3_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _itkMapContainerPython.itkMapContainerULPF3_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _itkMapContainerPython.itkMapContainerULPF3_Initialize(self)
    __swig_destroy__ = _itkMapContainerPython.delete_itkMapContainerULPF3

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkMapContainerULPF3

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _itkMapContainerPython.itkMapContainerULPF3_cast(obj)

    def New(*args, **kargs):
        """New() -> itkMapContainerULPF3

        Create a new object of the class itkMapContainerULPF3 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkMapContainerULPF3.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkMapContainerULPF3.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkMapContainerULPF3.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMapContainerULPF3 in _itkMapContainerPython:
_itkMapContainerPython.itkMapContainerULPF3_swigregister(itkMapContainerULPF3)

def itkMapContainerULSIT_New():
    return itkMapContainerULSIT.New()

class itkMapContainerULSIT(itk.ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkMapContainerULSIT class."""

    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"""
        __init__(self) -> itkMapContainerULSIT
        __init__(self, comp) -> itkMapContainerULSIT

        Parameters
        ----------
        comp: std::less< unsigned long > const &

        """
        _itkMapContainerPython.itkMapContainerULSIT_swiginit(self, _itkMapContainerPython.new_itkMapContainerULSIT(*args))

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkMapContainerULSIT_Pointer"""
        return _itkMapContainerPython.itkMapContainerULSIT___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMapContainerULSIT_Pointer"""
        return _itkMapContainerPython.itkMapContainerULSIT_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> mapsetUL"""
        return _itkMapContainerPython.itkMapContainerULSIT_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> mapsetUL"""
        return _itkMapContainerPython.itkMapContainerULSIT_CastToSTLConstContainer(self)

    def ElementAt(self, *args):
        r"""
        ElementAt(self, arg0) -> setUL

        Parameters
        ----------
        arg0: unsigned long

        ElementAt(self, arg0) -> setUL

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULSIT_ElementAt(self, *args)

    def CreateElementAt(self, arg0):
        r"""
        CreateElementAt(self, arg0) -> setUL

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULSIT_CreateElementAt(self, arg0)

    def GetElement(self, arg0):
        r"""
        GetElement(self, arg0) -> setUL

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULSIT_GetElement(self, arg0)

    def SetElement(self, arg0, arg1):
        r"""
        SetElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned long
        arg1: std::set< unsigned long,std::less< unsigned long >,std::allocator< unsigned long > >

        """
        return _itkMapContainerPython.itkMapContainerULSIT_SetElement(self, arg0, arg1)

    def InsertElement(self, arg0, arg1):
        r"""
        InsertElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned long
        arg1: std::set< unsigned long,std::less< unsigned long >,std::allocator< unsigned long > >

        """
        return _itkMapContainerPython.itkMapContainerULSIT_InsertElement(self, arg0, arg1)

    def IndexExists(self, arg0):
        r"""
        IndexExists(self, arg0) -> bool

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULSIT_IndexExists(self, arg0)

    def GetElementIfIndexExists(self, arg0, arg1):
        r"""
        GetElementIfIndexExists(self, arg0, arg1) -> bool

        Parameters
        ----------
        arg0: unsigned long
        arg1: std::set< unsigned long,std::less< unsigned long >,std::allocator< unsigned long > > *

        """
        return _itkMapContainerPython.itkMapContainerULSIT_GetElementIfIndexExists(self, arg0, arg1)

    def CreateIndex(self, arg0):
        r"""
        CreateIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULSIT_CreateIndex(self, arg0)

    def DeleteIndex(self, arg0):
        r"""
        DeleteIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULSIT_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned long"""
        return _itkMapContainerPython.itkMapContainerULSIT_Size(self)

    def Reserve(self, arg0):
        r"""
        Reserve(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULSIT_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _itkMapContainerPython.itkMapContainerULSIT_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _itkMapContainerPython.itkMapContainerULSIT_Initialize(self)
    __swig_destroy__ = _itkMapContainerPython.delete_itkMapContainerULSIT

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkMapContainerULSIT

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _itkMapContainerPython.itkMapContainerULSIT_cast(obj)

    def New(*args, **kargs):
        """New() -> itkMapContainerULSIT

        Create a new object of the class itkMapContainerULSIT and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkMapContainerULSIT.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkMapContainerULSIT.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkMapContainerULSIT.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMapContainerULSIT in _itkMapContainerPython:
_itkMapContainerPython.itkMapContainerULSIT_swigregister(itkMapContainerULSIT)

def itkMapContainerULVD2_New():
    return itkMapContainerULVD2.New()

class itkMapContainerULVD2(itk.ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkMapContainerULVD2 class."""

    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"""
        __init__(self) -> itkMapContainerULVD2
        __init__(self, comp) -> itkMapContainerULVD2

        Parameters
        ----------
        comp: std::less< unsigned long > const &

        """
        _itkMapContainerPython.itkMapContainerULVD2_swiginit(self, _itkMapContainerPython.new_itkMapContainerULVD2(*args))

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkMapContainerULVD2_Pointer"""
        return _itkMapContainerPython.itkMapContainerULVD2___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMapContainerULVD2_Pointer"""
        return _itkMapContainerPython.itkMapContainerULVD2_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> std::map< unsigned long,itkVectorD2,std::less< unsigned long >,std::allocator< std::pair< unsigned long const,itkVectorD2 > > > &"""
        return _itkMapContainerPython.itkMapContainerULVD2_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> std::map< unsigned long,itkVectorD2,std::less< unsigned long >,std::allocator< std::pair< unsigned long const,itkVectorD2 > > > const &"""
        return _itkMapContainerPython.itkMapContainerULVD2_CastToSTLConstContainer(self)

    def ElementAt(self, *args):
        r"""
        ElementAt(self, arg0) -> itkVectorD2

        Parameters
        ----------
        arg0: unsigned long

        ElementAt(self, arg0) -> itkVectorD2

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULVD2_ElementAt(self, *args)

    def CreateElementAt(self, arg0):
        r"""
        CreateElementAt(self, arg0) -> itkVectorD2

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULVD2_CreateElementAt(self, arg0)

    def GetElement(self, arg0):
        r"""
        GetElement(self, arg0) -> itkVectorD2

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULVD2_GetElement(self, arg0)

    def SetElement(self, arg0, arg1):
        r"""
        SetElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkVectorD2

        """
        return _itkMapContainerPython.itkMapContainerULVD2_SetElement(self, arg0, arg1)

    def InsertElement(self, arg0, arg1):
        r"""
        InsertElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkVectorD2

        """
        return _itkMapContainerPython.itkMapContainerULVD2_InsertElement(self, arg0, arg1)

    def IndexExists(self, arg0):
        r"""
        IndexExists(self, arg0) -> bool

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULVD2_IndexExists(self, arg0)

    def GetElementIfIndexExists(self, arg0, arg1):
        r"""
        GetElementIfIndexExists(self, arg0, arg1) -> bool

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkVectorD2 *

        """
        return _itkMapContainerPython.itkMapContainerULVD2_GetElementIfIndexExists(self, arg0, arg1)

    def CreateIndex(self, arg0):
        r"""
        CreateIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULVD2_CreateIndex(self, arg0)

    def DeleteIndex(self, arg0):
        r"""
        DeleteIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULVD2_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned long"""
        return _itkMapContainerPython.itkMapContainerULVD2_Size(self)

    def Reserve(self, arg0):
        r"""
        Reserve(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULVD2_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _itkMapContainerPython.itkMapContainerULVD2_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _itkMapContainerPython.itkMapContainerULVD2_Initialize(self)
    __swig_destroy__ = _itkMapContainerPython.delete_itkMapContainerULVD2

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkMapContainerULVD2

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _itkMapContainerPython.itkMapContainerULVD2_cast(obj)

    def New(*args, **kargs):
        """New() -> itkMapContainerULVD2

        Create a new object of the class itkMapContainerULVD2 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkMapContainerULVD2.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkMapContainerULVD2.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkMapContainerULVD2.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMapContainerULVD2 in _itkMapContainerPython:
_itkMapContainerPython.itkMapContainerULVD2_swigregister(itkMapContainerULVD2)

def itkMapContainerULVD3_New():
    return itkMapContainerULVD3.New()

class itkMapContainerULVD3(itk.ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkMapContainerULVD3 class."""

    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"""
        __init__(self) -> itkMapContainerULVD3
        __init__(self, comp) -> itkMapContainerULVD3

        Parameters
        ----------
        comp: std::less< unsigned long > const &

        """
        _itkMapContainerPython.itkMapContainerULVD3_swiginit(self, _itkMapContainerPython.new_itkMapContainerULVD3(*args))

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkMapContainerULVD3_Pointer"""
        return _itkMapContainerPython.itkMapContainerULVD3___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMapContainerULVD3_Pointer"""
        return _itkMapContainerPython.itkMapContainerULVD3_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> std::map< unsigned long,itkVectorD3,std::less< unsigned long >,std::allocator< std::pair< unsigned long const,itkVectorD3 > > > &"""
        return _itkMapContainerPython.itkMapContainerULVD3_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> std::map< unsigned long,itkVectorD3,std::less< unsigned long >,std::allocator< std::pair< unsigned long const,itkVectorD3 > > > const &"""
        return _itkMapContainerPython.itkMapContainerULVD3_CastToSTLConstContainer(self)

    def ElementAt(self, *args):
        r"""
        ElementAt(self, arg0) -> itkVectorD3

        Parameters
        ----------
        arg0: unsigned long

        ElementAt(self, arg0) -> itkVectorD3

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULVD3_ElementAt(self, *args)

    def CreateElementAt(self, arg0):
        r"""
        CreateElementAt(self, arg0) -> itkVectorD3

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULVD3_CreateElementAt(self, arg0)

    def GetElement(self, arg0):
        r"""
        GetElement(self, arg0) -> itkVectorD3

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULVD3_GetElement(self, arg0)

    def SetElement(self, arg0, arg1):
        r"""
        SetElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkVectorD3

        """
        return _itkMapContainerPython.itkMapContainerULVD3_SetElement(self, arg0, arg1)

    def InsertElement(self, arg0, arg1):
        r"""
        InsertElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkVectorD3

        """
        return _itkMapContainerPython.itkMapContainerULVD3_InsertElement(self, arg0, arg1)

    def IndexExists(self, arg0):
        r"""
        IndexExists(self, arg0) -> bool

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULVD3_IndexExists(self, arg0)

    def GetElementIfIndexExists(self, arg0, arg1):
        r"""
        GetElementIfIndexExists(self, arg0, arg1) -> bool

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkVectorD3 *

        """
        return _itkMapContainerPython.itkMapContainerULVD3_GetElementIfIndexExists(self, arg0, arg1)

    def CreateIndex(self, arg0):
        r"""
        CreateIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULVD3_CreateIndex(self, arg0)

    def DeleteIndex(self, arg0):
        r"""
        DeleteIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULVD3_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned long"""
        return _itkMapContainerPython.itkMapContainerULVD3_Size(self)

    def Reserve(self, arg0):
        r"""
        Reserve(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULVD3_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _itkMapContainerPython.itkMapContainerULVD3_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _itkMapContainerPython.itkMapContainerULVD3_Initialize(self)
    __swig_destroy__ = _itkMapContainerPython.delete_itkMapContainerULVD3

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkMapContainerULVD3

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _itkMapContainerPython.itkMapContainerULVD3_cast(obj)

    def New(*args, **kargs):
        """New() -> itkMapContainerULVD3

        Create a new object of the class itkMapContainerULVD3 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkMapContainerULVD3.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkMapContainerULVD3.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkMapContainerULVD3.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMapContainerULVD3 in _itkMapContainerPython:
_itkMapContainerPython.itkMapContainerULVD3_swigregister(itkMapContainerULVD3)

def itkMapContainerULVF2_New():
    return itkMapContainerULVF2.New()

class itkMapContainerULVF2(itk.ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkMapContainerULVF2 class."""

    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"""
        __init__(self) -> itkMapContainerULVF2
        __init__(self, comp) -> itkMapContainerULVF2

        Parameters
        ----------
        comp: std::less< unsigned long > const &

        """
        _itkMapContainerPython.itkMapContainerULVF2_swiginit(self, _itkMapContainerPython.new_itkMapContainerULVF2(*args))

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkMapContainerULVF2_Pointer"""
        return _itkMapContainerPython.itkMapContainerULVF2___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMapContainerULVF2_Pointer"""
        return _itkMapContainerPython.itkMapContainerULVF2_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> std::map< unsigned long,itkVectorF2,std::less< unsigned long >,std::allocator< std::pair< unsigned long const,itkVectorF2 > > > &"""
        return _itkMapContainerPython.itkMapContainerULVF2_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> std::map< unsigned long,itkVectorF2,std::less< unsigned long >,std::allocator< std::pair< unsigned long const,itkVectorF2 > > > const &"""
        return _itkMapContainerPython.itkMapContainerULVF2_CastToSTLConstContainer(self)

    def ElementAt(self, *args):
        r"""
        ElementAt(self, arg0) -> itkVectorF2

        Parameters
        ----------
        arg0: unsigned long

        ElementAt(self, arg0) -> itkVectorF2

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULVF2_ElementAt(self, *args)

    def CreateElementAt(self, arg0):
        r"""
        CreateElementAt(self, arg0) -> itkVectorF2

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULVF2_CreateElementAt(self, arg0)

    def GetElement(self, arg0):
        r"""
        GetElement(self, arg0) -> itkVectorF2

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULVF2_GetElement(self, arg0)

    def SetElement(self, arg0, arg1):
        r"""
        SetElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkVectorF2

        """
        return _itkMapContainerPython.itkMapContainerULVF2_SetElement(self, arg0, arg1)

    def InsertElement(self, arg0, arg1):
        r"""
        InsertElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkVectorF2

        """
        return _itkMapContainerPython.itkMapContainerULVF2_InsertElement(self, arg0, arg1)

    def IndexExists(self, arg0):
        r"""
        IndexExists(self, arg0) -> bool

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULVF2_IndexExists(self, arg0)

    def GetElementIfIndexExists(self, arg0, arg1):
        r"""
        GetElementIfIndexExists(self, arg0, arg1) -> bool

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkVectorF2 *

        """
        return _itkMapContainerPython.itkMapContainerULVF2_GetElementIfIndexExists(self, arg0, arg1)

    def CreateIndex(self, arg0):
        r"""
        CreateIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULVF2_CreateIndex(self, arg0)

    def DeleteIndex(self, arg0):
        r"""
        DeleteIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULVF2_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned long"""
        return _itkMapContainerPython.itkMapContainerULVF2_Size(self)

    def Reserve(self, arg0):
        r"""
        Reserve(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULVF2_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _itkMapContainerPython.itkMapContainerULVF2_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _itkMapContainerPython.itkMapContainerULVF2_Initialize(self)
    __swig_destroy__ = _itkMapContainerPython.delete_itkMapContainerULVF2

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkMapContainerULVF2

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _itkMapContainerPython.itkMapContainerULVF2_cast(obj)

    def New(*args, **kargs):
        """New() -> itkMapContainerULVF2

        Create a new object of the class itkMapContainerULVF2 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkMapContainerULVF2.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkMapContainerULVF2.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkMapContainerULVF2.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMapContainerULVF2 in _itkMapContainerPython:
_itkMapContainerPython.itkMapContainerULVF2_swigregister(itkMapContainerULVF2)

def itkMapContainerULVF3_New():
    return itkMapContainerULVF3.New()

class itkMapContainerULVF3(itk.ITKCommonBasePython.itkObject):
    r"""Proxy of C++ itkMapContainerULVF3 class."""

    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"""
        __init__(self) -> itkMapContainerULVF3
        __init__(self, comp) -> itkMapContainerULVF3

        Parameters
        ----------
        comp: std::less< unsigned long > const &

        """
        _itkMapContainerPython.itkMapContainerULVF3_swiginit(self, _itkMapContainerPython.new_itkMapContainerULVF3(*args))

    @staticmethod
    def __New_orig__():
        r"""__New_orig__() -> itkMapContainerULVF3_Pointer"""
        return _itkMapContainerPython.itkMapContainerULVF3___New_orig__()

    def Clone(self):
        r"""Clone(self) -> itkMapContainerULVF3_Pointer"""
        return _itkMapContainerPython.itkMapContainerULVF3_Clone(self)

    def CastToSTLContainer(self):
        r"""CastToSTLContainer(self) -> std::map< unsigned long,itkVectorF3,std::less< unsigned long >,std::allocator< std::pair< unsigned long const,itkVectorF3 > > > &"""
        return _itkMapContainerPython.itkMapContainerULVF3_CastToSTLContainer(self)

    def CastToSTLConstContainer(self):
        r"""CastToSTLConstContainer(self) -> std::map< unsigned long,itkVectorF3,std::less< unsigned long >,std::allocator< std::pair< unsigned long const,itkVectorF3 > > > const &"""
        return _itkMapContainerPython.itkMapContainerULVF3_CastToSTLConstContainer(self)

    def ElementAt(self, *args):
        r"""
        ElementAt(self, arg0) -> itkVectorF3

        Parameters
        ----------
        arg0: unsigned long

        ElementAt(self, arg0) -> itkVectorF3

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULVF3_ElementAt(self, *args)

    def CreateElementAt(self, arg0):
        r"""
        CreateElementAt(self, arg0) -> itkVectorF3

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULVF3_CreateElementAt(self, arg0)

    def GetElement(self, arg0):
        r"""
        GetElement(self, arg0) -> itkVectorF3

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULVF3_GetElement(self, arg0)

    def SetElement(self, arg0, arg1):
        r"""
        SetElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkVectorF3

        """
        return _itkMapContainerPython.itkMapContainerULVF3_SetElement(self, arg0, arg1)

    def InsertElement(self, arg0, arg1):
        r"""
        InsertElement(self, arg0, arg1)

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkVectorF3

        """
        return _itkMapContainerPython.itkMapContainerULVF3_InsertElement(self, arg0, arg1)

    def IndexExists(self, arg0):
        r"""
        IndexExists(self, arg0) -> bool

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULVF3_IndexExists(self, arg0)

    def GetElementIfIndexExists(self, arg0, arg1):
        r"""
        GetElementIfIndexExists(self, arg0, arg1) -> bool

        Parameters
        ----------
        arg0: unsigned long
        arg1: itkVectorF3 *

        """
        return _itkMapContainerPython.itkMapContainerULVF3_GetElementIfIndexExists(self, arg0, arg1)

    def CreateIndex(self, arg0):
        r"""
        CreateIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULVF3_CreateIndex(self, arg0)

    def DeleteIndex(self, arg0):
        r"""
        DeleteIndex(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULVF3_DeleteIndex(self, arg0)

    def Size(self):
        r"""Size(self) -> unsigned long"""
        return _itkMapContainerPython.itkMapContainerULVF3_Size(self)

    def Reserve(self, arg0):
        r"""
        Reserve(self, arg0)

        Parameters
        ----------
        arg0: unsigned long

        """
        return _itkMapContainerPython.itkMapContainerULVF3_Reserve(self, arg0)

    def Squeeze(self):
        r"""Squeeze(self)"""
        return _itkMapContainerPython.itkMapContainerULVF3_Squeeze(self)

    def Initialize(self):
        r"""Initialize(self)"""
        return _itkMapContainerPython.itkMapContainerULVF3_Initialize(self)
    __swig_destroy__ = _itkMapContainerPython.delete_itkMapContainerULVF3

    @staticmethod
    def cast(obj):
        r"""
        cast(obj) -> itkMapContainerULVF3

        Parameters
        ----------
        obj: itkLightObject *

        """
        return _itkMapContainerPython.itkMapContainerULVF3_cast(obj)

    def New(*args, **kargs):
        """New() -> itkMapContainerULVF3

        Create a new object of the class itkMapContainerULVF3 and set the input and the parameters if some
        named or non-named arguments are passed to that method.

        New() tries to assign all the non named parameters to the input of the new objects - the
        first non named parameter in the first input, etc.

        The named parameters are used by calling the method with the same name prefixed by 'Set'.

        Ex:

          itkMapContainerULVF3.New(reader, threshold=10)

        is (most of the time) equivalent to:

          obj = itkMapContainerULVF3.New()
          obj.SetInput(0, reader.GetOutput())
          obj.SetThreshold(10)
        """
        obj = itkMapContainerULVF3.__New_orig__()
        from itk.support import template_class
        template_class.New(obj, *args, **kargs)
        return obj
    New = staticmethod(New)


# Register itkMapContainerULVF3 in _itkMapContainerPython:
_itkMapContainerPython.itkMapContainerULVF3_swigregister(itkMapContainerULVF3)

